onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/review/ontology-path-classifier.js

@@ -1,179 +0,0 @@
-/**
- * ontology-path-classifier.ts — Review 세션의 ontology path 라벨링 + 경로 비교 metric
- *
- * W-A-75 (review-r+ / ontology-present path) + W-A-76 (review-r− / ontology-absent path).
- * 세션별로 r+ / r− / unknown 라벨을 부여하고, 두 경로 간 비용·품질 delta 를 산출한다.
- *
- * 현재 구현은 "환경 수준" classifier — project 에 ontology seat 이 존재했느냐를 시그널로 쓴다.
- * 세션별 ontology 소비 기록을 artifact 에 추가할 수 있게 되면 per-session 로직으로 확장한다.
- * (세부 설계 한계는 .onto/processes/review/ontology-path.md §5 참조)
- *
- * 소비자: W-A-75/76 evidence, onto:health, refresh protocol
- */
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-// ─── Internal constants ───
-const DEFAULT_ONTOLOGY_SEAT_FILENAMES = [
-    // design/commands/start.ts signature
-    "code-mapping.yaml",
-    "behavior.yaml",
-    "model.yaml",
-    // 일반 pattern (다른 프로젝트 호환성)
-    "ontology.yaml",
-    "actions.yaml",
-    "transitions.yaml",
-];
-const DEFAULT_SEARCH_ROOTS = ["ontology", "authority"];
-const MAX_SCAN_DEPTH = 3;
-const EXCLUDED_DIRS = new Set(["node_modules", ".git", ".onto", "dist", "build"]);
-// ─── Core API ───
-/**
- * 프로젝트 루트에서 ontology seat 을 탐지하고, 세션별 라벨과 cohort delta 를 산출한다.
- *
- * 현재는 "환경 수준" classifier — project 에 seat 이 존재하면 모든 세션이 r+,
- * 존재하지 않으면 모든 세션이 r− 로 라벨링된다. 세션별 per-session 라벨은
- * 향후 artifact 확장 후 구현 (.onto/processes/review/ontology-path.md §5 한계 항목).
- */
-export function classifyReviewPaths(entries, projectRoot, options = {}) {
-    const absProjectRoot = resolve(projectRoot);
-    const seatFilenames = options.ontology_seat_filenames ?? DEFAULT_ONTOLOGY_SEAT_FILENAMES;
-    const searchRoots = options.search_roots ?? DEFAULT_SEARCH_ROOTS;
-    const seatPaths = detectOntologySeats(absProjectRoot, searchRoots, seatFilenames);
-    const seatDetected = seatPaths.length > 0;
-    const envLabel = seatDetected ? "r+" : "r-";
-    const overrides = options.session_overrides ?? {};
-    const sessions = entries.map((e) => {
-        const override = overrides[e.session_id];
-        const label = override ?? envLabel;
-        // evidence 는 label=r+ 일 때만 의미 있음. override 로 r+ 지정됐는데 환경에 seat 이 있으면 그 seat 을 evidence 로 연결.
-        const evidence = label === "r+" ? seatPaths : [];
-        return {
-            session_id: e.session_id,
-            label,
-            ontology_seat_evidence: evidence,
-            total_duration_ms: e.total_duration_ms,
-            degraded_lens_ratio: computeDegradedRatio(e),
-            review_target_refs: e.review_target_refs,
-        };
-    });
-    const rPlus = sessions.filter((s) => s.label === "r+");
-    const rMinus = sessions.filter((s) => s.label === "r-");
-    const cohortRPlus = aggregateCohort("r+", rPlus);
-    const cohortRMinus = aggregateCohort("r-", rMinus);
-    const delta = computeDelta(cohortRPlus, cohortRMinus);
-    return {
-        classified_at: new Date().toISOString(),
-        project_root: absProjectRoot,
-        ontology_seat_detected: seatDetected,
-        ontology_seat_paths: seatPaths,
-        sessions,
-        cohort_r_plus: cohortRPlus,
-        cohort_r_minus: cohortRMinus,
-        delta,
-    };
-}
-// ─── Internal helpers ───
-function computeDegradedRatio(entry) {
-    if (entry.lens_count <= 0)
-        return null;
-    return Math.round((entry.degraded_lens_ids.length / entry.lens_count) * 1000) / 1000;
-}
-function aggregateCohort(label, sessions) {
-    if (sessions.length === 0) {
-        return {
-            label,
-            session_count: 0,
-            avg_duration_ms: null,
-            avg_degraded_lens_ratio: null,
-        };
-    }
-    const totalDuration = sessions.reduce((s, x) => s + x.total_duration_ms, 0);
-    const avgDuration = Math.round(totalDuration / sessions.length);
-    const ratioValues = sessions
-        .map((s) => s.degraded_lens_ratio)
-        .filter((v) => v !== null);
-    const avgRatio = ratioValues.length === 0
-        ? null
-        : Math.round((ratioValues.reduce((s, x) => s + x, 0) / ratioValues.length) * 1000) / 1000;
-    return {
-        label,
-        session_count: sessions.length,
-        avg_duration_ms: avgDuration,
-        avg_degraded_lens_ratio: avgRatio,
-    };
-}
-function computeDelta(rPlus, rMinus) {
-    let durationDelta = null;
-    let durationRatio = null;
-    if (rPlus.avg_duration_ms !== null && rMinus.avg_duration_ms !== null) {
-        durationDelta = rPlus.avg_duration_ms - rMinus.avg_duration_ms;
-        if (rMinus.avg_duration_ms > 0) {
-            durationRatio = Math.round((rPlus.avg_duration_ms / rMinus.avg_duration_ms) * 1000) / 1000;
-        }
-    }
-    let degradedDelta = null;
-    if (rPlus.avg_degraded_lens_ratio !== null && rMinus.avg_degraded_lens_ratio !== null) {
-        degradedDelta =
-            Math.round((rPlus.avg_degraded_lens_ratio - rMinus.avg_degraded_lens_ratio) * 1000) / 1000;
-    }
-    return {
-        r_plus: rPlus,
-        r_minus: rMinus,
-        duration_delta_ms: durationDelta,
-        duration_ratio: durationRatio,
-        degraded_ratio_delta: degradedDelta,
-    };
-}
-/**
- * project 내에서 ontology seat 파일을 탐지한다.
- *
- * 탐색 범위:
- * - `{projectRoot}/{searchRoot}/**` 를 최대 MAX_SCAN_DEPTH 까지
- * - EXCLUDED_DIRS 제외
- *
- * 성능 고려: classifier 는 read-only observational tool 이므로 비용을 최소화.
- */
-function detectOntologySeats(projectRoot, searchRoots, seatFilenames) {
-    const found = new Set();
-    const seatSet = new Set(seatFilenames);
-    for (const rootName of searchRoots) {
-        const rootPath = join(projectRoot, rootName);
-        if (!safeIsDirectory(rootPath))
-            continue;
-        scanForSeats(rootPath, seatSet, 0, found);
-    }
-    return [...found].sort();
-}
-function scanForSeats(dir, seatSet, depth, found) {
-    if (depth > MAX_SCAN_DEPTH)
-        return;
-    let names;
-    try {
-        names = readdirSync(dir);
-    }
-    catch {
-        return;
-    }
-    for (const name of names) {
-        if (EXCLUDED_DIRS.has(name))
-            continue;
-        const full = join(dir, name);
-        if (seatSet.has(name)) {
-            found.add(full);
-            continue;
-        }
-        if (safeIsDirectory(full)) {
-            scanForSeats(full, seatSet, depth + 1, found);
-        }
-    }
-}
-function safeIsDirectory(p) {
-    if (!existsSync(p))
-        return false;
-    try {
-        return statSync(p).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/core-runtime/review/ontology-path-classifier.test.js

@@ -1,216 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { classifyReviewPaths } from "./ontology-path-classifier.js";
-// ─── Test fixtures ───
-function makeEntry(overrides = {}) {
-    return {
-        session_id: "20260413-aaa00001",
-        created_at: "2026-04-13T10:00:00+09:00",
-        review_target_refs: ["src/foo.ts"],
-        request_text: "mock request",
-        review_mode: "full",
-        execution_realization: "subagent",
-        host_runtime: "codex",
-        execution_status: "completed",
-        total_duration_ms: 100000,
-        lens_count: 3,
-        participating_lens_ids: ["logic", "structure", "axiology"],
-        degraded_lens_ids: [],
-        per_lens_duration: [],
-        synthesis_duration_ms: 5000,
-        provenance_summary: { runner_wallclock: 3, coordinator_derived: 0, batch_fallback: 0, unknown: 0 },
-        ...overrides,
-    };
-}
-// ─── Tests ───
-describe("classifyReviewPaths", () => {
-    let tmpRoot;
-    beforeEach(() => {
-        tmpRoot = join(tmpdir(), `ontology-path-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        mkdirSync(tmpRoot, { recursive: true });
-    });
-    afterEach(() => {
-        try {
-            rmSync(tmpRoot, { recursive: true, force: true });
-        }
-        catch { }
-    });
-    describe("ontology seat detection", () => {
-        it("r- label 부여: project 에 ontology seat 이 없으면 모든 세션이 ontology-absent path", () => {
-            const result = classifyReviewPaths([makeEntry(), makeEntry({ session_id: "20260413-aaa00002" })], tmpRoot);
-            expect(result.ontology_seat_detected).toBe(false);
-            expect(result.ontology_seat_paths).toEqual([]);
-            expect(result.sessions).toHaveLength(2);
-            expect(result.sessions.every((s) => s.label === "r-")).toBe(true);
-        });
-        it("r+ label 부여: ontology/ 하위에 code-mapping.yaml 이 있으면 ontology-present 환경", () => {
-            const ontoDir = join(tmpRoot, "ontology");
-            mkdirSync(ontoDir, { recursive: true });
-            writeFileSync(join(ontoDir, "code-mapping.yaml"), "glossary: []\n");
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.ontology_seat_detected).toBe(true);
-            expect(result.ontology_seat_paths).toEqual([join(ontoDir, "code-mapping.yaml")]);
-            expect(result.sessions[0].label).toBe("r+");
-            expect(result.sessions[0].ontology_seat_evidence).toEqual([join(ontoDir, "code-mapping.yaml")]);
-        });
-        it("r+ label 부여: .onto/authority/ 하위에 model.yaml 만 있어도 present 로 판정", () => {
-            const authDir = join(tmpRoot, "authority");
-            mkdirSync(authDir, { recursive: true });
-            writeFileSync(join(authDir, "model.yaml"), "entities: []\n");
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.ontology_seat_detected).toBe(true);
-            expect(result.sessions[0].label).toBe("r+");
-        });
-        it("복수 seat 탐지: seat 3종 모두 존재 시 ontology_seat_paths 정렬되어 수집", () => {
-            const ontoDir = join(tmpRoot, "ontology");
-            mkdirSync(ontoDir, { recursive: true });
-            writeFileSync(join(ontoDir, "code-mapping.yaml"), "");
-            writeFileSync(join(ontoDir, "behavior.yaml"), "");
-            writeFileSync(join(ontoDir, "model.yaml"), "");
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.ontology_seat_paths).toHaveLength(3);
-            // sort() 순서
-            expect(result.ontology_seat_paths).toEqual([
-                join(ontoDir, "behavior.yaml"),
-                join(ontoDir, "code-mapping.yaml"),
-                join(ontoDir, "model.yaml"),
-            ]);
-        });
-        it("node_modules / .git / .onto 는 탐색 대상에서 제외된다", () => {
-            const excluded = join(tmpRoot, "node_modules", "some-pkg", "ontology");
-            mkdirSync(excluded, { recursive: true });
-            writeFileSync(join(excluded, "model.yaml"), "");
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.ontology_seat_detected).toBe(false);
-        });
-        it("search_roots 커스텀: 기본 외의 디렉터리도 탐색 가능", () => {
-            const customDir = join(tmpRoot, "custom-onto");
-            mkdirSync(customDir, { recursive: true });
-            writeFileSync(join(customDir, "ontology.yaml"), "");
-            const result = classifyReviewPaths([makeEntry()], tmpRoot, {
-                search_roots: ["custom-onto"],
-            });
-            expect(result.ontology_seat_detected).toBe(true);
-            expect(result.ontology_seat_paths[0]).toContain("custom-onto");
-        });
-        it("depth 초과 디렉터리는 탐지하지 않는다 (MAX_SCAN_DEPTH=3)", () => {
-            const deep = join(tmpRoot, "ontology", "a", "b", "c", "d", "e");
-            mkdirSync(deep, { recursive: true });
-            writeFileSync(join(deep, "model.yaml"), "");
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.ontology_seat_detected).toBe(false);
-        });
-    });
-    describe("cohort metrics (r+ / r-)", () => {
-        it("r- only: r+ cohort 는 모두 null, r- 집계만 산출", () => {
-            const result = classifyReviewPaths([
-                makeEntry({ session_id: "s1", total_duration_ms: 100000, degraded_lens_ids: [], lens_count: 3 }),
-                makeEntry({ session_id: "s2", total_duration_ms: 120000, degraded_lens_ids: ["logic"], lens_count: 3 }),
-            ], tmpRoot);
-            expect(result.cohort_r_plus.session_count).toBe(0);
-            expect(result.cohort_r_plus.avg_duration_ms).toBeNull();
-            expect(result.cohort_r_plus.avg_degraded_lens_ratio).toBeNull();
-            expect(result.cohort_r_minus.session_count).toBe(2);
-            expect(result.cohort_r_minus.avg_duration_ms).toBe(110000);
-            // (0 + 0.333) / 2 = 0.167 (rounded to 3 decimals — 0.333/2 ≈ 0.166 → 0.167)
-            expect(result.cohort_r_minus.avg_degraded_lens_ratio).toBeCloseTo(0.167, 2);
-        });
-        it("r+ only: r- cohort 는 모두 null", () => {
-            const ontoDir = join(tmpRoot, "ontology");
-            mkdirSync(ontoDir, { recursive: true });
-            writeFileSync(join(ontoDir, "model.yaml"), "");
-            const result = classifyReviewPaths([makeEntry({ total_duration_ms: 80000, lens_count: 3, degraded_lens_ids: [] })], tmpRoot);
-            expect(result.cohort_r_plus.session_count).toBe(1);
-            expect(result.cohort_r_plus.avg_duration_ms).toBe(80000);
-            expect(result.cohort_r_plus.avg_degraded_lens_ratio).toBe(0);
-            expect(result.cohort_r_minus.session_count).toBe(0);
-            expect(result.cohort_r_minus.avg_duration_ms).toBeNull();
-        });
-        it("empty entries: 두 cohort 모두 count=0 + null 평균", () => {
-            const result = classifyReviewPaths([], tmpRoot);
-            expect(result.cohort_r_plus.session_count).toBe(0);
-            expect(result.cohort_r_minus.session_count).toBe(0);
-            expect(result.delta.duration_delta_ms).toBeNull();
-            expect(result.delta.duration_ratio).toBeNull();
-            expect(result.delta.degraded_ratio_delta).toBeNull();
-        });
-        it("lens_count=0 인 세션은 degraded_lens_ratio null 로 제외되고 집계에 영향 없음", () => {
-            const result = classifyReviewPaths([
-                makeEntry({ session_id: "s1", lens_count: 0, degraded_lens_ids: [] }),
-                makeEntry({ session_id: "s2", lens_count: 3, degraded_lens_ids: ["logic"] }),
-            ], tmpRoot);
-            // r- cohort: 2 세션이지만 degraded_ratio 계산 가능한 건 1건 (avg = 0.333)
-            expect(result.cohort_r_minus.session_count).toBe(2);
-            expect(result.cohort_r_minus.avg_degraded_lens_ratio).toBeCloseTo(0.333, 2);
-        });
-    });
-    describe("path delta metric", () => {
-        it("한쪽 cohort 가 비어있으면 duration_delta_ms / duration_ratio / degraded_ratio_delta 모두 null", () => {
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.delta.duration_delta_ms).toBeNull();
-            expect(result.delta.duration_ratio).toBeNull();
-            expect(result.delta.degraded_ratio_delta).toBeNull();
-        });
-        it("혼합 cohort (session_overrides 로 r+/r- 분배): duration_delta·ratio 산출", () => {
-            // session_overrides 로 per-session 분배 — r+ 2세션 (빠름) vs r- 2세션 (느림)
-            const entries = [
-                makeEntry({ session_id: "rp1", total_duration_ms: 80000, lens_count: 3, degraded_lens_ids: [] }),
-                makeEntry({ session_id: "rp2", total_duration_ms: 70000, lens_count: 3, degraded_lens_ids: [] }),
-                makeEntry({ session_id: "rm1", total_duration_ms: 120000, lens_count: 3, degraded_lens_ids: ["logic"] }),
-                makeEntry({ session_id: "rm2", total_duration_ms: 130000, lens_count: 3, degraded_lens_ids: ["logic"] }),
-            ];
-            const result = classifyReviewPaths(entries, tmpRoot, {
-                session_overrides: {
-                    rp1: "r+",
-                    rp2: "r+",
-                    rm1: "r-",
-                    rm2: "r-",
-                },
-            });
-            expect(result.cohort_r_plus.session_count).toBe(2);
-            expect(result.cohort_r_plus.avg_duration_ms).toBe(75000);
-            expect(result.cohort_r_plus.avg_degraded_lens_ratio).toBe(0);
-            expect(result.cohort_r_minus.session_count).toBe(2);
-            expect(result.cohort_r_minus.avg_duration_ms).toBe(125000);
-            expect(result.cohort_r_minus.avg_degraded_lens_ratio).toBeCloseTo(0.333, 2);
-            // r+ 가 r- 보다 50000ms 빠름 → 음수 delta = 개선
-            expect(result.delta.duration_delta_ms).toBe(-50000);
-            // 75000 / 125000 = 0.6
-            expect(result.delta.duration_ratio).toBe(0.6);
-            // r+ 품질 저하 ratio (0) - r- 품질 저하 ratio (0.333) = -0.333 → r+ 가 품질 저하 적음
-            expect(result.delta.degraded_ratio_delta).toBeCloseTo(-0.333, 2);
-        });
-        it("session_overrides 미지정 세션은 환경 수준 라벨을 따른다 (partial override)", () => {
-            // 환경: seat 없음 → 기본 r-. override 로 한 세션만 r+ 강제.
-            const entries = [
-                makeEntry({ session_id: "forced-plus", total_duration_ms: 60000 }),
-                makeEntry({ session_id: "default-minus", total_duration_ms: 100000 }),
-            ];
-            const result = classifyReviewPaths(entries, tmpRoot, {
-                session_overrides: { "forced-plus": "r+" },
-            });
-            const forced = result.sessions.find((s) => s.session_id === "forced-plus");
-            const defaulted = result.sessions.find((s) => s.session_id === "default-minus");
-            expect(forced.label).toBe("r+");
-            expect(defaulted.label).toBe("r-");
-        });
-    });
-    describe("session-level fields", () => {
-        it("degraded_lens_ratio = degraded_lens_ids.length / lens_count (3decimal rounding)", () => {
-            const result = classifyReviewPaths([
-                makeEntry({ session_id: "s1", lens_count: 3, degraded_lens_ids: ["logic"] }),
-            ], tmpRoot);
-            expect(result.sessions[0].degraded_lens_ratio).toBeCloseTo(0.333, 2);
-        });
-        it("review_target_refs 는 ReviewLogEntry 에서 그대로 전달", () => {
-            const result = classifyReviewPaths([makeEntry({ review_target_refs: ["src/a.ts", "src/b.ts"] })], tmpRoot);
-            expect(result.sessions[0].review_target_refs).toEqual(["src/a.ts", "src/b.ts"]);
-        });
-        it("r- 세션의 ontology_seat_evidence 는 빈 배열", () => {
-            const result = classifyReviewPaths([makeEntry()], tmpRoot);
-            expect(result.sessions[0].ontology_seat_evidence).toEqual([]);
-        });
-    });
-});

package/dist/core-runtime/review/packet-boundary-policy.test.js

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parsePacketBoundaryPolicy } from "./packet-boundary-policy.js";
-describe("parsePacketBoundaryPolicy — section detection", () => {
-    it("returns all-unknown when no Boundary Policy section exists", () => {
-        const policy = parsePacketBoundaryPolicy("# Prompt\n\nNo policy section here.");
-        expect(policy.filesystem).toBe("unknown");
-        expect(policy.network).toBe("unknown");
-        expect(policy.tools).toBe("unknown");
-        expect(policy.sectionBody).toBeUndefined();
-    });
-    it("matches case-insensitive heading", () => {
-        const packet = "# Prompt\n\n## boundary policy\n- Filesystem: denied\n";
-        const policy = parsePacketBoundaryPolicy(packet);
-        expect(policy.filesystem).toBe("denied");
-    });
-    it("stops section body at the next heading", () => {
-        const packet = [
-            "## Boundary Policy",
-            "- Filesystem: denied",
-            "",
-            "## Other Section",
-            "- Filesystem: allowed  ",
-        ].join("\n");
-        const policy = parsePacketBoundaryPolicy(packet);
-        expect(policy.filesystem).toBe("denied");
-    });
-});
-describe("parsePacketBoundaryPolicy — filesystem (A1 regression)", () => {
-    it("detects denied", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Filesystem: denied");
-        expect(p.filesystem).toBe("denied");
-        expect(p.filesystemRaw).toBe("denied");
-    });
-    it("detects allowed via read-only compound phrase", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Filesystem: read-only inside round1/ (lens outputs only)");
-        expect(p.filesystem).toBe("allowed");
-    });
-    it("returns unknown for unrecognised value", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Filesystem: whatever");
-        expect(p.filesystem).toBe("unknown");
-    });
-});
-describe("parsePacketBoundaryPolicy — tools (A4)", () => {
-    it("detects Tools: required", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Tools: required");
-        expect(p.tools).toBe("required");
-        expect(p.toolsRaw).toBe("required");
-    });
-    it("detects required via synonyms (mandatory, needed, must)", () => {
-        for (const v of ["mandatory", "needed", "must"]) {
-            const p = parsePacketBoundaryPolicy(`## Boundary Policy\n- Tools: ${v}`);
-            expect(p.tools).toBe("required");
-        }
-    });
-    it("detects Tools: optional", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Tools: optional");
-        expect(p.tools).toBe("optional");
-    });
-    it("detects Tools: denied", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Tools: denied");
-        expect(p.tools).toBe("denied");
-    });
-    it("detects required via compound phrase (first token)", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Tools: required — lens outputs must be fetched via read_file");
-        expect(p.tools).toBe("required");
-    });
-    it("is case-insensitive on the key", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- TOOLS: Required");
-        expect(p.tools).toBe("required");
-    });
-    it("returns unknown when Tools bullet is absent", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Filesystem: denied");
-        expect(p.tools).toBe("unknown");
-        expect(p.toolsRaw).toBeUndefined();
-    });
-    it("returns unknown for unrecognised value", () => {
-        const p = parsePacketBoundaryPolicy("## Boundary Policy\n- Tools: sometimes");
-        expect(p.tools).toBe("unknown");
-    });
-});
-describe("parsePacketBoundaryPolicy — combined declarations", () => {
-    it("parses filesystem + network + tools together", () => {
-        const packet = [
-            "## Boundary Policy",
-            "- Filesystem: read-only inside round1/",
-            "- Network: denied",
-            "- Tools: required",
-        ].join("\n");
-        const p = parsePacketBoundaryPolicy(packet);
-        expect(p.filesystem).toBe("allowed");
-        expect(p.network).toBe("denied");
-        expect(p.tools).toBe("required");
-    });
-    it("detects contradictory declaration (denied filesystem + required tools) raw but classifies each correctly", () => {
-        // The parser itself does NOT enforce internal consistency — it just
-        // reports what the packet said. The executor is responsible for rejecting
-        // impossible combinations.
-        const packet = [
-            "## Boundary Policy",
-            "- Filesystem: denied",
-            "- Tools: required",
-        ].join("\n");
-        const p = parsePacketBoundaryPolicy(packet);
-        expect(p.filesystem).toBe("denied");
-        expect(p.tools).toBe("required");
-    });
-});

package/dist/core-runtime/review/participating-lens-paths.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseParticipatingLensPaths } from "./participating-lens-paths.js";
-describe("parseParticipatingLensPaths", () => {
-    it("parses `## Participating Lens Outputs` with backtick paths", () => {
-        const packet = [
-            "## Participating Lens Outputs",
-            "- axiology: `.onto/review/session/round1/axiology.md`",
-            "- dependency: `.onto/review/session/round1/dependency.md`",
-            "- structure: `.onto/review/session/round1/structure.md`",
-        ].join("\n");
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths).toEqual([
-            { lensId: "axiology", path: ".onto/review/session/round1/axiology.md" },
-            { lensId: "dependency", path: ".onto/review/session/round1/dependency.md" },
-            { lensId: "structure", path: ".onto/review/session/round1/structure.md" },
-        ]);
-    });
-    it("parses `## Runtime Participating Lens Outputs` (coordinator-generated)", () => {
-        const packet = [
-            "## Runtime Participating Lens Outputs",
-            "- axiology: .onto/review/session/round1/axiology.md",
-            "- logic: .onto/review/session/round1/logic.md",
-        ].join("\n");
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths.map((p) => p.lensId)).toEqual(["axiology", "logic"]);
-    });
-    it("tolerates paths without backtick wrappers", () => {
-        const packet = [
-            "## Participating Lens Outputs",
-            "- axiology: .onto/review/x/round1/axiology.md",
-        ].join("\n");
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths[0]?.path).toBe(".onto/review/x/round1/axiology.md");
-    });
-    it("stops at the next heading", () => {
-        const packet = [
-            "## Participating Lens Outputs",
-            "- axiology: `path/a.md`",
-            "",
-            "## Required Output Sections",
-            "- dependency: `path/should-not-be-parsed.md`",
-        ].join("\n");
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths).toEqual([{ lensId: "axiology", path: "path/a.md" }]);
-    });
-    it("skips placeholder rows like `(none for mock test)`", () => {
-        const packet = [
-            "## Participating Lens Outputs",
-            "(none for mock test)",
-            "",
-        ].join("\n");
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths).toEqual([]);
-    });
-    it("returns empty array when section absent", () => {
-        const packet = "# Some Packet\n\n## Other Section\n- foo: bar";
-        expect(parseParticipatingLensPaths(packet)).toEqual([]);
-    });
-    it("returns empty array when section is empty or has no bullets", () => {
-        const packet = "## Participating Lens Outputs\n\n";
-        expect(parseParticipatingLensPaths(packet)).toEqual([]);
-    });
-    it("is case-insensitive on the heading", () => {
-        const packet = "## participating lens outputs\n- axiology: x.md";
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths).toEqual([{ lensId: "axiology", path: "x.md" }]);
-    });
-    it("accepts asterisk bullets", () => {
-        const packet = "## Participating Lens Outputs\n* axiology: x.md";
-        const paths = parseParticipatingLensPaths(packet);
-        expect(paths).toEqual([{ lensId: "axiology", path: "x.md" }]);
-    });
-});