@cheongfish/bouncer 0.0.0-stage → 0.1.13

package/dist/plan-inspect.js

@@ -0,0 +1,575 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const layout = require("./layout");
+const { isCanonicalEpicDir, isCanonicalBlueprintDir, isValidBlueprintOrder, listBlueprintOrders, } = layout;
+const contextIds = require("./context-ids");
+const { parseContextPath } = contextIds;
+const paths = require("./paths");
+const { toPosix } = paths;
+const current = require("./current");
+const { resolveCurrent } = current;
+const frontmatter = require("./frontmatter");
+const { readDoc } = frontmatter;
+const tasksDocs = require("./tasks-docs");
+const { listTasksDocs } = tasksDocs;
+const epicRegistry = require("./epic-registry");
+const { readEpicRegistry, COMMON_EPICS } = epicRegistry;
+const BOUNCER_DIR = '.bouncer';
+const EPICS_REL = '.bouncer/context/epics';
+const VERIFY_FILES = [
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'compose.yml',
+    'compose.yaml',
+    'Makefile',
+    'Taskfile.yml',
+];
+// light/full 추천 신호용 경로 규칙. 설정 파일로 열지 않는 코드 상수 —
+// review_risk(frontmatter)와 별개 계약이라 여기만 소유한다.
+const SECURITY_SEGMENTS = new Set([
+    'auth',
+    'credential',
+    'credentials',
+    'secret',
+    'secrets',
+    'token',
+    'tokens',
+    'permission',
+    'permissions',
+]);
+const MANIFEST_EXACT = new Set([
+    'package.json',
+    'package-lock.json',
+    'bun.lock',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'go.mod',
+]);
+const MODULE_EXCLUDED = new Set(['test', 'tests', 'docs']);
+/**
+ * `\d{3}-<slug>` 디렉터리 이름만 모아 최댓값 + 1을 세 자리로 채운다.
+ * 구형 `EPIC-009` / `BP-001` 이름은 정규식에서 빠지므로 번호가 그 쪽으로
+ * 점프하지 않는다. 후보가 없으면 `001` — 빈 트리의 첫 id. blueprint id 제안에 쓴다.
+ *
+ * @param {string[]} names - 한 부모 아래의 디렉터리 이름
+ * @returns {string} zero-pad 세 자리 다음 id
+ */
+function nextNumericId(names) {
+    let max = 0;
+    for (const name of names) {
+        // 정본 번호 이름(`ddd-slug`)만 센다. EPIC-/BP- 접두와 slug 이름은 최댓값에 넣지 않아 구형 디렉터리가
+        // 다음 번호를 건너뛰게 하지 않는다. 세그먼트 해석은 context-ids 한 곳에 맡기고, blueprint 이름도
+        // epic 자리에 끼워 같은 규칙으로 읽는다.
+        const parsed = parseContextPath(`epics/${name}`);
+        if (!parsed || parsed.format !== 'numeric')
+            continue;
+        const n = Number(parsed.epicKey);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    return String(max + 1).padStart(3, '0');
+}
+/**
+ * 활성 `features` epic의 blueprint를 `bouncer.area`별로 세어 승격 후보를 낸다.
+ * 읽기 전용이며 승격은 실행하지 않는다 — 사용자 승인 뒤 스킬이 명령을 돌린다.
+ *
+ * @param {string} repoRoot - 저장소 루트 절대 경로
+ * @param {string | null} featuresDir - 활성 features epic의 repo-relative 디렉터리(없으면 null)
+ * @param {number | undefined} threshold - 등록부 `areaPromotionThreshold`
+ * @returns {{ area: string, count: number }[]} count가 threshold 이상인 area(이름순)
+ */
+function countAreaPromotions(repoRoot, featuresDir, threshold) {
+    if (threshold === undefined || featuresDir === null)
+        return [];
+    const bpRoot = path.join(repoRoot, featuresDir, 'blueprints');
+    const counts = new Map();
+    for (const name of listDirNames(bpRoot)) {
+        try {
+            const doc = readDoc(path.join(bpRoot, name, 'index.md'));
+            const data = doc.data && typeof doc.data === 'object' ? doc.data : {};
+            const bouncer = data.bouncer && typeof data.bouncer === 'object'
+                ? data.bouncer : null;
+            const area = bouncer ? bouncer.area : undefined;
+            if (typeof area === 'string' && area !== '')
+                counts.set(area, (counts.get(area) ?? 0) + 1);
+        }
+        catch (_e) {
+            // index.md가 없거나 파싱 불가한 blueprint는 집계에서 뺀다. inspect는 읽기 전용이라
+            // 문서를 고치지 않고, 한 문서의 오류가 나머지 집계를 막지 않게 한다.
+        }
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count >= threshold)
+        .map(([area, count]) => ({ area, count }))
+        .sort((a, b) => (a.area < b.area ? -1 : a.area > b.area ? 1 : 0));
+}
+/**
+ * 등록부(`.bouncer/epics.json`)를 한 번 읽어 inspect용 후보 목록으로 바꾼다.
+ * 귀속은 판단하지 않고 사실(활성 epic, 디렉터리 유무, legacy, area)만 낸다.
+ * 형식 위반도 실패로 올리지 않고 `invalid`로 접어 plan이 안내를 이어가게 한다.
+ *
+ * @param {string} repoRoot - 저장소 루트 절대 경로
+ * @param {string[]} dirNames - epics 디렉터리 직계 이름(v1 `<id>-<slug>`, v2 `<slug>`)
+ * @returns {{ registry: InspectRegistry, nextEpicId: string | null }} 등록부 요약과
+ *   승인됐으나 디렉터리가 없는 도메인 epic 중 가장 작은 id(없거나 등록부 불량이면 null, v2는 번호가 없어 항상 null)
+ */
+function summarizeRegistry(repoRoot, dirNames) {
+    const read = readEpicRegistry(repoRoot);
+    if (read.status === 'missing') {
+        return {
+            registry: { status: 'missing', next: 'Run `bouncer init` to create .bouncer/epics.json.' },
+            nextEpicId: null,
+        };
+    }
+    if (read.status === 'invalid') {
+        return {
+            registry: {
+                status: 'invalid',
+                code: 'S35',
+                message: `epic registry is invalid: ${read.message}`,
+                next: 'Fix .bouncer/epics.json so `bouncer validate` no longer reports S35.',
+            },
+            nextEpicId: null,
+        };
+    }
+    const { registry } = read;
+    // v1은 `<id>-<slug>` 디렉터리와 `id`를, v2는 `<slug>` 디렉터리와 선택 `legacy_id`를 쓴다.
+    // 버전은 등록부 `version`으로만 가른다(디렉터리 이름 모양으로 추측하지 않는다).
+    const isV2 = registry.version === 2;
+    const idOf = (entry) => (isV2 ? entry.legacy_id ?? null : entry.id);
+    const dirOf = (entry) => {
+        const name = isV2 ? entry.slug : `${entry.id}-${entry.slug}`;
+        return dirNames.includes(name) ? `${EPICS_REL}/${name}` : null;
+    };
+    const epics = [];
+    const legacy = [];
+    const pendingDomainIds = [];
+    for (const entry of registry.epics) {
+        if (!entry.active)
+            continue;
+        const dir = dirOf(entry);
+        const id = idOf(entry);
+        if (entry.kind === 'legacy') {
+            // legacy는 디렉터리가 있어야 의미가 있다. 없는 항목은 후보로 내지 않는다.
+            if (dir !== null)
+                legacy.push({ slug: entry.slug, id, dir });
+            continue;
+        }
+        if (entry.kind === 'domain') {
+            // v2 slug epic은 번호가 없어 다음 번호 후보에 넣지 않는다.
+            if (dir === null && !isV2)
+                pendingDomainIds.push(entry.id);
+            epics.push({
+                slug: entry.slug, id, dir, kind: 'domain',
+                description: null, include: entry.approval ? entry.approval.reason : '', exclude: '',
+            });
+            continue;
+        }
+        const common = COMMON_EPICS.find((c) => c.slug === entry.slug);
+        epics.push({
+            slug: entry.slug, id, dir, kind: 'common',
+            description: common ? common.description : null,
+            include: common ? common.include : '',
+            exclude: common ? common.exclude : '',
+        });
+    }
+    pendingDomainIds.sort();
+    // 상한이 남아 있을 때만 후보를 낸다: 소진되면 add-domain이 어차피 거절된다.
+    const domainCount = registry.epics.filter((e) => e.kind === 'domain').length;
+    const features = epics.find((e) => e.slug === 'features');
+    const promotions = domainCount < registry.domainEpicLimit
+        ? countAreaPromotions(repoRoot, features ? features.dir : null, registry.areaPromotionThreshold)
+        : [];
+    return {
+        registry: {
+            status: 'ok', profile: registry.profile, epics, legacy, areas: registry.areas, promotions,
+        },
+        nextEpicId: pendingDomainIds.length > 0 ? pendingDomainIds[0] : null,
+    };
+}
+/**
+ * 한 부모의 직계 디렉터리 이름만 나열한다. 읽기 실패는 빈 목록 — inspect는
+ * 추천값만 계산하므로 권한 오류를 종료로 승격하지 않는다.
+ *
+ * @param {string} absDir - 절대 경로
+ * @returns {string[]} 디렉터리 이름
+ */
+function listDirNames(absDir) {
+    try {
+        if (!fs.existsSync(absDir))
+            return [];
+        const entries = fs.readdirSync(absDir, { withFileTypes: true });
+        const names = [];
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                names.push(entry.name);
+        }
+        return names;
+    }
+    catch (_e) {
+        // EACCES 등만 접는다. 추천 id를 못 구하면 빈 목록으로 `001`이 나온다.
+        return [];
+    }
+}
+/**
+ * epic/blueprint `index.md`의 `bouncer.status`만 읽는다. 파싱 실패는 null —
+ * inspect가 문서를 고치지 않고, 없는 상태를 지어내지 않기 위함.
+ *
+ * @param {string} absIndex - index.md 절대 경로
+ * @returns {string | null} 문자열 status, 없거나 읽을 수 없으면 null
+ */
+function readStatus(absIndex) {
+    try {
+        const doc = readDoc(absIndex);
+        const data = doc.data && typeof doc.data === 'object'
+            ? doc.data : {};
+        const bouncer = data.bouncer && typeof data.bouncer === 'object'
+            ? data.bouncer : null;
+        return bouncer && typeof bouncer.status === 'string' ? bouncer.status : null;
+    }
+    catch (_e) {
+        // 부재·YAML 오류는 상태 없음으로만 접는다. inspect는 문서를 복구하지 않는다.
+        return null;
+    }
+}
+/**
+ * slug epic의 다음 blueprint 순서를 구한다. 쓸 수 있는 `order`(양의 정수)의 최댓값 + 1이다.
+ * 간격은 메우지 않는다(1·2·5 → 6) — 순서는 디렉터리 이름이 아니라 frontmatter가 가지므로
+ * 중간 값을 비워 둔 채 계속 추가해도 기존 순서가 흔들리지 않는다. 읽을 수 없거나 모양이 틀린 값은
+ * 최댓값에서 뺀다(그 문서의 오류는 S37이 따로 보고한다). 후보가 없으면 1이다.
+ *
+ * @param {string} repoRoot - 저장소 루트 절대 경로
+ * @param {string} dirRel - 저장소 상대 epic 디렉터리
+ * @returns {number} 다음 순서(양의 정수)
+ */
+function nextBlueprintOrder(repoRoot, dirRel) {
+    let max = 0;
+    for (const entry of listBlueprintOrders(repoRoot, dirRel)) {
+        if (isValidBlueprintOrder(entry.order) && entry.order > max)
+            max = entry.order;
+    }
+    return max + 1;
+}
+function epicInfo(repoRoot, dirRel) {
+    const status = readStatus(path.join(repoRoot, dirRel, 'index.md'));
+    // 형식은 경로로 판정한다(호출자가 정본 검사를 통과시켰다).
+    if (parseContextPath(dirRel)?.format === 'slug') {
+        return { dir: dirRel, status, nextBlueprintId: null, nextBlueprintOrder: nextBlueprintOrder(repoRoot, dirRel) };
+    }
+    const nextBlueprintId = nextNumericId(listDirNames(path.join(repoRoot, dirRel, 'blueprints')));
+    return { dir: dirRel, status, nextBlueprintId, nextBlueprintOrder: Number(nextBlueprintId) };
+}
+function presentCurrent(repoRoot) {
+    const resolved = resolveCurrent({ repoRoot });
+    if (resolved.status === 'selected') {
+        return {
+            status: 'selected',
+            blueprint: resolved.current.blueprint,
+            task: resolved.current.task,
+            base: resolved.current.base,
+        };
+    }
+    // empty·ambiguous·invalid 모두 포인터 필드를 비운다. 워크플로 중단은
+    // 스킬이 status를 보고 결정하며, inspect는 후보를 고르지 않는다.
+    return {
+        status: resolved.status,
+        blueprint: null,
+        task: null,
+        base: null,
+    };
+}
+/**
+ * 루트 파일 존재와 `package.json`의 `scripts` 키 존재만 본다.
+ * compose/Makefile 내용은 읽지 않는다. JSON 파싱은 키 존재 확인에만 쓴다.
+ *
+ * @param {string} repoRoot - 저장소 루트 절대 경로
+ * @returns {string[]} Interface 나열 순의 신호 토큰
+ */
+function collectVerifySignals(repoRoot) {
+    const signals = [];
+    for (const name of VERIFY_FILES) {
+        if (fs.existsSync(path.join(repoRoot, name)))
+            signals.push(name);
+    }
+    const pkgAbs = path.join(repoRoot, 'package.json');
+    if (!fs.existsSync(pkgAbs))
+        return signals;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(pkgAbs, 'utf8'));
+        if (parsed
+            && typeof parsed === 'object'
+            && !Array.isArray(parsed)
+            && Object.hasOwn(parsed, 'scripts')) {
+            signals.push('package.json#scripts');
+        }
+    }
+    catch (_e) {
+        // 깨진 JSON은 scripts 키를 확인할 수 없으므로 신호에 넣지 않는다.
+    }
+    return signals;
+}
+function normalizeRelDir(value) {
+    if (typeof value !== 'string' || value === '')
+        return null;
+    return toPosix(value).replace(/\/+$/, '');
+}
+/**
+ * basename이 `prefix*suffix` 형태(단일 `*`)와 맞는지 본다.
+ * 설정/외부 glob 엔진 없이 상수 규칙만 쓰기 위함.
+ *
+ * @param {string} name - 파일 basename
+ * @param {string} prefix - `*` 앞
+ * @param {string} suffix - `*` 뒤
+ * @returns {boolean} 매칭 여부
+ */
+function matchStar(name, prefix, suffix) {
+    return name.startsWith(prefix) && name.endsWith(suffix)
+        && name.length >= prefix.length + suffix.length;
+}
+/**
+ * 경로를 `/` 조각으로 나누고 마지막 조각의 확장자를 벗긴다.
+ * `tokenizer`≠`token`처럼 부분 문자열 오탐을 막으려면 확장자 없는
+ * 조각과 정확히 비교해야 한다.
+ *
+ * @param {string} relPath - repo-relative posix 경로
+ * @returns {string[]} 확장자 없는 경로 조각
+ */
+function pathSegments(relPath) {
+    const parts = toPosix(relPath).split('/').filter(Boolean);
+    return parts.map((part, index) => {
+        if (index !== parts.length - 1)
+            return part;
+        // `.github` 같은 leading-dot 디렉터리는 확장자가 아니다.
+        if (part.startsWith('.'))
+            return part;
+        const dot = part.lastIndexOf('.');
+        return dot > 0 ? part.slice(0, dot) : part;
+    });
+}
+/**
+ * 한 경로가 걸리는 첫 risk kind를 고른다. 우선순위는 security → manifest →
+ * build → migration — 한 path에 여러 kind를 쌓지 않아 recommendation 근거가
+ * 중복되지 않게 한다.
+ *
+ * @param {string} relPath - repo-relative 경로
+ * @returns {RiskKind | null} 매칭 kind, 없으면 null
+ */
+function classifyOnePath(relPath) {
+    const posix = toPosix(relPath);
+    const base = path.posix.basename(posix);
+    const segments = pathSegments(posix);
+    if (segments.some((seg) => SECURITY_SEGMENTS.has(seg)))
+        return 'security';
+    if (MANIFEST_EXACT.has(base)
+        || matchStar(base, 'requirements', '.txt')) {
+        return 'manifest';
+    }
+    if (matchStar(base, 'Dockerfile', '')
+        || base === 'Makefile'
+        || matchStar(base, 'tsconfig', '.json')
+        || posix === '.github/workflows'
+        || posix.startsWith('.github/workflows/')) {
+        return 'build';
+    }
+    // migrations/ 접두·조각, schema 조각. `schemas` 복수형은 규칙에 없어 제외.
+    if (segments.includes('migrations')
+        || segments.includes('schema')) {
+        return 'migration';
+    }
+    return null;
+}
+/**
+ * 경로 목록을 risk kind로 분류한다. I/O 없음 — 단위 테스트가 규칙만
+ * 고정하고 planInspect는 집계 전에 같은 헬퍼를 재사용한다.
+ *
+ * @param {string[]} pathList - repo-relative 경로 목록
+ * @returns {Array<{ path: string, kind: RiskKind }>} 매칭된 {path, kind}만, 입력 순
+ */
+function classifyRoutingPaths(pathList) {
+    const out = [];
+    for (const relPath of pathList) {
+        if (typeof relPath !== 'string' || relPath === '')
+            continue;
+        const kind = classifyOnePath(relPath);
+        if (kind !== null)
+            out.push({ path: toPosix(relPath), kind });
+    }
+    return out;
+}
+/**
+ * 모듈 토큰: 첫 경로 조각. `test`/`tests`/`docs`와 루트 파일(슬래시 없음)은
+ * 접촉 모듈이 아니므로 세지 않는다 — light 후보를 path count로 키우지 않기 위함.
+ *
+ * @param {string[]} pathList - affected_paths 합집합
+ * @returns {string[]} 정렬·중복 제거된 모듈 이름
+ */
+function collectModules(pathList) {
+    const modules = new Set();
+    for (const relPath of pathList) {
+        const posix = toPosix(relPath);
+        if (!posix.includes('/'))
+            continue;
+        const head = posix.split('/')[0];
+        if (!head || MODULE_EXCLUDED.has(head))
+            continue;
+        modules.add(head);
+    }
+    return [...modules].sort();
+}
+/**
+ * commit task 요약으로 advisory routing을 만든다. 선택·승인은 하지 않고
+ * recommendation/reasons만 낸다 — light 선언은 사용자 소유다.
+ *
+ * @param {Array<{ paths: string[], dependsOn: string[] }>} taskList - 이미
+ *   commit-only로 걸러진 task 입력. paths는 affected_paths, dependsOn은 depends_on
+ * @returns {Routing} advisory routing 객체
+ */
+function summarizeRouting(taskList) {
+    const tasks = taskList.length;
+    let dependencies = 0;
+    const allPaths = [];
+    for (const task of taskList) {
+        dependencies += Array.isArray(task.dependsOn) ? task.dependsOn.length : 0;
+        if (Array.isArray(task.paths)) {
+            for (const p of task.paths) {
+                if (typeof p === 'string' && p !== '')
+                    allPaths.push(p);
+            }
+        }
+    }
+    const modules = collectModules(allPaths);
+    const riskPaths = classifyRoutingPaths(allPaths);
+    const reasons = [];
+    // 조건 이름 = 필드명. 스킬이 reasons를 그대로 인용할 수 있게 짧게 둔다.
+    if (tasks >= 2)
+        reasons.push('tasks');
+    if (dependencies > 0)
+        reasons.push('dependencies');
+    if (modules.length >= 3)
+        reasons.push('modules');
+    if (riskPaths.length > 0)
+        reasons.push('riskPaths');
+    // empty는 full 트리거가 아니다. 근거만 남기고 light-candidate를 유지한다.
+    if (allPaths.length === 0)
+        reasons.push('affected-paths-empty');
+    const recommendation = (tasks >= 2
+        || dependencies > 0
+        || modules.length >= 3
+        || riskPaths.length > 0) ? 'full-candidate' : 'light-candidate';
+    return {
+        advisory: true,
+        tasks,
+        dependencies,
+        modules,
+        riskPaths,
+        recommendation,
+        reasons,
+    };
+}
+/**
+ * blueprint의 commit task에서 paths/dependsOn만 모은다. verification task는
+ * tasks 카운트·모듈·위험 경로에 넣지 않는다 — light 신호는 구현 커밋 범위다.
+ *
+ * @param {string} repoRoot - 저장소 루트
+ * @param {string} blueprintDir - 정본 blueprint 상대 경로
+ * @returns {RoutingTask[]} summarizeRouting 입력
+ */
+function loadRoutingTasks(repoRoot, blueprintDir) {
+    const listing = listTasksDocs({ repoRoot, blueprintDir });
+    const out = [];
+    for (const entry of listing.entries) {
+        if (entry.executionKind !== 'commit')
+            continue;
+        let paths = [];
+        let dependsOn = [];
+        try {
+            const doc = readDoc(path.join(repoRoot, entry.tasks.rel));
+            const data = doc.data && typeof doc.data === 'object'
+                ? doc.data : {};
+            const bouncer = data.bouncer && typeof data.bouncer === 'object'
+                ? data.bouncer : null;
+            if (bouncer) {
+                if (Array.isArray(bouncer.affected_paths)) {
+                    paths = bouncer.affected_paths.filter((p) => typeof p === 'string' && p !== '');
+                }
+                if (Array.isArray(bouncer.depends_on)) {
+                    dependsOn = bouncer.depends_on.filter((p) => typeof p === 'string' && p !== '');
+                }
+            }
+        }
+        catch (_e) {
+            // 파싱 실패 task는 빈 paths로만 센다. inspect가 draft를 고치지 않는다.
+        }
+        out.push({ paths, dependsOn });
+    }
+    return out;
+}
+/**
+ * 계획 스킬이 본문에서 반복하던 등록부 후보·다음 도메인 id·verify 신호·포인터 상태와
+ * (선택) light 추천 근거를 한 번 계산한다. 추천값만 반환하며 어떤 경로에도
+ * 파일을 쓰지 않는다. `--blueprint`가 없으면 `routing: null`.
+ *
+ * @param {{ repoRoot: string, epicDir?: unknown, blueprintDir?: unknown }} opts -
+ *   repoRoot는 대상 저장소, epicDir/blueprintDir은 선택적 정본 상대 경로
+ * @returns {InspectResult} 성공 JSON 또는 not-initialized / invalid-*-dir
+ */
+function planInspect({ repoRoot, epicDir, blueprintDir }) {
+    const bouncerAbs = path.join(repoRoot, BOUNCER_DIR);
+    // 1. 초기화 여부. epic-dir 형식보다 앞선다 — 없는 트리의 경로 오류로
+    //    위장하면 `/bouncer-init` 안내가 빗나간다.
+    if (!fs.existsSync(bouncerAbs) || !fs.statSync(bouncerAbs).isDirectory()) {
+        return { ok: false, reason: 'not-initialized' };
+    }
+    let epic = null;
+    if (epicDir !== undefined) {
+        // 2. --epic-dir는 정본 상대 경로만. 짧은 이름·EPIC- 접두·부재는 같은
+        //    거절 코드라서 호출자가 형식을 추측해 재시도하지 않게 한다.
+        const rel = normalizeRelDir(epicDir);
+        if (rel === null || !isCanonicalEpicDir(rel)) {
+            return { ok: false, reason: 'invalid-epic-dir' };
+        }
+        const abs = path.join(repoRoot, rel);
+        try {
+            // ENOENT·ENOTDIR·EACCES는 모두 같은 거절 코드다. 형식이 맞아도
+            // 없는 디렉터리를 다음 id 계산에 쓰면 없는 epic을 추천하게 된다.
+            if (!fs.statSync(abs).isDirectory()) {
+                return { ok: false, reason: 'invalid-epic-dir' };
+            }
+        }
+        catch (_e) {
+            return { ok: false, reason: 'invalid-epic-dir' };
+        }
+        epic = epicInfo(repoRoot, rel);
+    }
+    let routing = null;
+    if (blueprintDir !== undefined) {
+        // 3. --blueprint는 정본 blueprint 경로만. routing은 읽기 전용 신호다.
+        const rel = normalizeRelDir(blueprintDir);
+        if (rel === null || !isCanonicalBlueprintDir(rel)) {
+            return { ok: false, reason: 'invalid-blueprint-dir' };
+        }
+        const abs = path.join(repoRoot, rel);
+        try {
+            if (!fs.statSync(abs).isDirectory()) {
+                return { ok: false, reason: 'invalid-blueprint-dir' };
+            }
+        }
+        catch (_e) {
+            return { ok: false, reason: 'invalid-blueprint-dir' };
+        }
+        routing = summarizeRouting(loadRoutingTasks(repoRoot, rel));
+    }
+    const epicNames = listDirNames(path.join(repoRoot, EPICS_REL));
+    const { registry, nextEpicId } = summarizeRegistry(repoRoot, epicNames);
+    return {
+        ok: true,
+        nextEpicId,
+        registry,
+        epic,
+        verifySignals: collectVerifySignals(repoRoot),
+        current: presentCurrent(repoRoot),
+        routing,
+    };
+}
+module.exports = { planInspect, classifyRoutingPaths, summarizeRouting };