@cheongfish/bouncer 0.0.0-stage → 0.1.13

package/dist/execute-prepare.js

@@ -0,0 +1,262 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const current = require("./current");
+const { readCurrent, presentCurrent, resolveEffectiveTask, CurrentSelectionError } = current;
+const runtimeState = require("./runtime-state");
+const { worktreePathFor, coordinatorPathsFor, branchNamesFor, resolveWorktreeBranch } = runtimeState;
+const seedWorktreeMod = require("./seed-worktree");
+const { seedWorktree } = seedWorktreeMod;
+const scopeMod = require("./scope");
+const { readCoordinatorLedger } = scopeMod;
+const paths = require("./paths");
+const { toPosix } = paths;
+const TASK_DOC_RE = /(?:^|\/)tasks\/(\d{3})\/tasks\.md$/;
+function isSelectionError(error) {
+    return error instanceof CurrentSelectionError
+        || (typeof error === 'object'
+            && error !== null
+            && 'code' in error
+            && typeof error.code === 'string'
+            && String(error.code).startsWith('CURRENT_'));
+}
+function sameBlueprint(left, right) {
+    return toPosix(left).replace(/\/+$/, '') === toPosix(right).replace(/\/+$/, '');
+}
+function taskDigits(task) {
+    if (typeof task !== 'string' || !task)
+        return null;
+    if (/^\d{3}$/.test(task))
+        return task;
+    const match = TASK_DOC_RE.exec(toPosix(task));
+    return match ? match[1] : null;
+}
+function gitStderr(error) {
+    const err = error;
+    const raw = err.stderr != null ? String(err.stderr) : (err.message || '');
+    const first = raw.trim().split('\n').find((line) => line.trim());
+    // JSON stdout을 깨지 않으려고 hook·사용법 덤프 전체가 아니라 첫 줄만 싣는다.
+    return first || 'git worktree add failed';
+}
+function listWorktrees(repoRoot) {
+    const out = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    const entries = [];
+    let current = null;
+    const flush = () => {
+        if (current)
+            entries.push(current);
+        current = null;
+    };
+    for (const line of out.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            flush();
+            current = { path: line.slice('worktree '.length), branch: null };
+        }
+        else if (current && line.startsWith('branch ')) {
+            current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+        }
+    }
+    flush();
+    return entries;
+}
+function realOf(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch (_e) {
+        return null;
+    }
+}
+function isDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch (_e) {
+        return false;
+    }
+}
+/**
+ * 예상 경로가 Git에 등록된 worktree면 그 항목, 없으면 null, 디렉터리만
+ * 있으면 'unregistered'. 등록 여부는 브랜치 이름이 아니라 경로로만 본다 —
+ * 기존 체크아웃을 rename·migrate 하지 않기 위함이다.
+ *
+ * @param {string} repoRoot - 기준 checkout
+ * @param {string} expectedPath - worktreePathFor 결과
+ * @returns {ListedWorktree | null | 'unregistered'} 재사용 / 신규 / 거절
+ */
+function matchWorktree(repoRoot, expectedPath) {
+    const listed = listWorktrees(repoRoot);
+    const expectedReal = isDirectory(expectedPath) ? realOf(expectedPath) : null;
+    if (expectedReal) {
+        const hit = listed.find((entry) => realOf(entry.path) === expectedReal);
+        if (hit)
+            return hit;
+        return 'unregistered';
+    }
+    return null;
+}
+function pointerTask(pointer, repoRoot) {
+    const presented = presentCurrent(pointer, { repoRoot });
+    if (!presented)
+        return { task: null, scale: null };
+    // drive·standalone 모두 effective task(path/id)를 보고한다. pointer.task는
+    // presentCurrent의 task 키로 남고, 소비자는 lease 우선 값을 써야 한다.
+    const eff = presented.effectiveTask;
+    if (eff && eff.source && typeof eff.path === 'string') {
+        return {
+            task: { id: eff.id, path: eff.path },
+            scale: presented.scale,
+        };
+    }
+    return { task: presented.task, scale: presented.scale };
+}
+function assignedWorkerPath(repoRoot, blueprintDir, taskRef, ledger) {
+    const taskId = taskDigits(taskRef);
+    const computed = coordinatorPathsFor({
+        repoRoot, blueprint: blueprintDir, task: taskId || undefined,
+    });
+    if (ledger && Array.isArray(ledger.tasks) && taskId) {
+        const entry = ledger.tasks.find((item) => item && item.id === taskId);
+        if (entry && typeof entry.workerPath === 'string' && entry.workerPath) {
+            return entry.workerPath;
+        }
+    }
+    return computed.workerPath || computed.integrationPath;
+}
+function seedOrConflict(repoRoot, blueprintDir, worktreePath) {
+    const seeded = seedWorktree({
+        repoRoot,
+        blueprintDir,
+        worktreePath,
+    });
+    if (seeded.ok) {
+        return {
+            ok: true,
+            moved: seeded.moved,
+            restored: seeded.restored,
+            config: seeded.config,
+        };
+    }
+    // conflict만 계약 코드로 바꾸고, 이미 만든 worktree는 호출자가 지우지 않는다.
+    if (seeded.reason === 'conflict') {
+        return { ok: false, reason: 'seed-conflict', conflicts: seeded.conflicts || [] };
+    }
+    return { ok: false, reason: seeded.reason };
+}
+/**
+ * standalone execute의 worktree 경로·브랜치·재사용·seed를 한 명령으로 수행한다.
+ * coordinator 원장이 있으면 drive로 보고 생성·seed를 하지 않는다 — 그 쓰기는
+ * `coordinate prepare` 소유이고, 여기서 main checkout을 건드리면 경계가 깨진다.
+ *
+ * @param {object} opts
+ * @param {string} opts.repoRoot - plan 문서가 있는 base checkout
+ * @param {string} opts.blueprintDir - `--blueprint` 값
+ * @returns {PrepareResult} 성공 payload 또는 거절 reason
+ */
+function executePrepare({ repoRoot, blueprintDir }) {
+    const blueprint = toPosix(blueprintDir);
+    let pointer;
+    try {
+        pointer = readCurrent({ repoRoot });
+    }
+    catch (error) {
+        if (isSelectionError(error)) {
+            const fail = { ok: false, reason: error.code };
+            if (error.candidates)
+                fail.candidates = error.candidates;
+            if (error.issues)
+                fail.issues = error.issues;
+            return fail;
+        }
+        throw error;
+    }
+    if (!pointer)
+        return { ok: false, reason: 'no-current' };
+    if (!sameBlueprint(pointer.blueprint, blueprint)) {
+        return { ok: false, reason: 'blueprint-mismatch' };
+    }
+    // worker cwd에서 lease를 확인하지 못하면 drive·standalone 모두 거절한다.
+    // pointer로 떨어지면 다른 task의 workerPath를 보고하게 된다.
+    const effective = resolveEffectiveTask({ repoRoot });
+    if (effective && effective.source === null) {
+        return { ok: false, reason: effective.reason };
+    }
+    const { task, scale } = pointerTask(pointer, repoRoot);
+    const taskRef = effective && typeof effective.path === 'string'
+        ? effective.path
+        : pointer.task;
+    const found = readCoordinatorLedger({ repoRoot, blueprint });
+    // 원장 파일이 있으면(읽을 수 없어도) drive다. 부재만 standalone이다.
+    if (found.ok || found.reason === 'unreadable-ledger') {
+        const ledger = found.ok ? found.ledger : null;
+        return {
+            ok: true,
+            drive: true,
+            worktreePath: assignedWorkerPath(repoRoot, blueprint, taskRef, ledger),
+            created: false,
+            task,
+            scale,
+        };
+    }
+    const worktreePath = worktreePathFor({ repoRoot, blueprint });
+    const matched = matchWorktree(repoRoot, worktreePath);
+    if (matched === 'unregistered') {
+        return { ok: false, reason: 'unregistered-worktree' };
+    }
+    let branch;
+    try {
+        // standalone도 coordinator와 같은 이름·충돌 계약을 써야 한다. 그래야 새
+        // checkout만 만들고, 예전 checkout은 실제 branch를 보존하는 경계가 한 곳에 남는다.
+        const names = branchNamesFor({ repoRoot, blueprint });
+        // porcelain의 detached checkout은 helper가 branch 없는 경로를 신규로 보고
+        // 기존 ref 충돌을 돌린다. 이 경우에는 새 branch를 만들려는 요청 자체가 없으므로
+        // 실제 null을 보존한다; branchNamesFor는 위에서 계속 검증된다.
+        const resolved = matched && !matched.branch
+            ? null
+            : resolveWorktreeBranch({ repoRoot, worktreePath, branch: names.standalone });
+        branch = resolved ? resolved.branch : null;
+        if (!matched) {
+            fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+            execFileSync('git', ['worktree', 'add', '-b', branch, worktreePath, pointer.base], {
+                cwd: repoRoot,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? error.code : null;
+        if (code === 'invalid-commit-type' || code === 'invalid-branch-name' || code === 'branch-conflict') {
+            return { ok: false, reason: code };
+        }
+        return { ok: false, reason: 'worktree-add-failed', message: gitStderr(error) };
+    }
+    if (matched) {
+        // 등록된 체크아웃의 실제 브랜치를 그대로 돌려준다. 계산된 이름과 달라도
+        // 옮기거나 고치지 않는다. porcelain에 branch 줄이 없으면 detached HEAD이므로
+        // null을 그대로 둔다 — `<commit_type>/<leaf>`를 합성하면 스킬이 그 이름으로
+        // 커밋을 시도하지만 워킹 트리는 그 브랜치에 있지 않다.
+        branch = matched.branch;
+    }
+    const created = !matched;
+    const seeded = seedOrConflict(repoRoot, blueprint, worktreePath);
+    if (!seeded.ok)
+        return seeded;
+    return {
+        ok: true,
+        drive: false,
+        worktreePath,
+        branch,
+        created,
+        base: pointer.base,
+        task,
+        scale,
+        seed: { moved: seeded.moved, restored: seeded.restored, config: seeded.config },
+    };
+}
+module.exports = { executePrepare };

package/dist/execution-contracts.js

@@ -0,0 +1,46 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validOutsideScope = validOutsideScope;
+const nonEmptyText = (value) => typeof value === 'string' && value.trim() !== '';
+/**
+ * terminal verification task가 "성공은 아니지만 범위 밖 실패로 입증돼 완료를 막지 않는" 상태인지
+ * 판정한다. next·gate·digest·finalize가 같은 판정을 쓰도록 한 곳에 둔다 — 소비자마다
+ * 조건이 다르면 한쪽은 진행시키고 다른 쪽은 막아 drive가 갈라진다.
+ *
+ * 모든 조건이 맞을 때만 분류를 돌려준다: task가 verification이고 `verifying`이며,
+ * 원장 terminalFailure가 그 task의 것이고, disposition이 완전하며(kind·reason·evidence_id·
+ * source_digest·paths), 실패 증거의 identity와 일치하고, 현재 integrationHead가 분류 당시의
+ * source_digest와 같다(소스가 바뀌었으면 stale). 어느 하나라도 어긋나면 null이라 호출자는
+ * 기존 blocked/미완료 의미를 그대로 유지한다.
+ *
+ * @param {unknown} ledger - 원장 객체(읽기만 한다). 모양이 틀리면 null
+ * @param {string} taskId - 세 자리 terminal task id (`TASKS-` 접두는 벗겨 비교한다)
+ * @returns {OutsideScopeDisposition | null} 유효한 분류, 아니면 null
+ */
+function validOutsideScope(ledger, taskId) {
+    if (!ledger || typeof ledger !== 'object')
+        return null;
+    const root = ledger;
+    const id = String(taskId).replace(/^TASKS-/, '');
+    const task = (Array.isArray(root.tasks) ? root.tasks : []).find((entry) => Boolean(entry) && typeof entry === 'object' && entry.id === id);
+    if (!task || task.execution_kind !== 'verification' || task.status !== 'verifying')
+        return null;
+    const failure = root.terminalFailure;
+    if (!failure || typeof failure !== 'object' || failure.task !== id)
+        return null;
+    const disposition = failure.disposition;
+    if (!disposition || typeof disposition !== 'object' || disposition.kind !== 'outside_scope')
+        return null;
+    if (!nonEmptyText(disposition.reason) || !nonEmptyText(disposition.evidence_id)
+        || !nonEmptyText(disposition.source_digest))
+        return null;
+    if (!Array.isArray(disposition.paths) || disposition.paths.length === 0
+        || !disposition.paths.every(nonEmptyText))
+        return null;
+    if (disposition.evidence_id !== failure.evidence_id || disposition.source_digest !== failure.source_digest) {
+        return null;
+    }
+    if (root.integrationHead !== disposition.source_digest)
+        return null;
+    return disposition;
+}

package/dist/execution-dag.js

@@ -0,0 +1,148 @@
+'use strict';
+// I/O 없는 DAG 규칙: 어떤 task를 지금 열 수 있는지(readyWave)와 상태 전이(transition).
+// coordinator가 명령 처리와 이 규칙을 함께 들고 있으면 current·commit 같은 읽기 쪽 모듈이
+// readyWave 하나 때문에 coordinator 전체를 가져와 verification → current → coordinator →
+// verification 순환이 생긴다. 규칙만 하위 모듈로 내려 그 간선을 끊는다.
+// 이 모듈은 config(DEFAULT_MAX_PARALLEL)와 path-overlap만 런타임에 가져온다 —
+// cli·validate·coordinator·current·verification을 가져오면 경계 테스트가 실패한다.
+const configMod = require("./config");
+const { DEFAULT_MAX_PARALLEL } = configMod;
+const pathOverlapMod = require("./path-overlap");
+// 정규화 정본은 path-overlap이다. 기존 소비자(dag-shape·coordinator-commands)가 이 모듈에서
+// 같은 이름으로 가져가므로 아래 export에서 그대로 다시 내보낸다.
+const { pathsOverlap, normalizeOverlapPath } = pathOverlapMod;
+/**
+ * commit은 prepared·recorded, verification은 ready·verifying만 in-flight다.
+ * pending·integrated·(commit의) ready는 자리 수를 쓰지 않는다 — prepare가
+ * ready를 거쳐 바로 prepared로 올리므로, ready를 세면 한 wave가 자신을 막는다.
+ *
+ * @param {Task} task - 원장 task
+ * @returns {boolean} 동시 실행 한도·충돌 집합에 넣을지
+ */
+function isInFlight(task) {
+    const status = task.status || 'pending';
+    if ((task.execution_kind || 'commit') === 'verification') {
+        return status === 'ready' || status === 'verifying';
+    }
+    return status === 'prepared' || status === 'recorded';
+}
+/**
+ * 충돌 판정용 경로 집합. scope.paths가 있으면 lease 개정 뒤의 실제 범위를
+ * 쓰고, 없으면 bootstrap 스냅샷 affected_paths를 쓴다. 둘 다 없으면 legacy —
+ * 옛 원장이 경로 없이 열려 병렬로 겹치는 쓰기를 막기 위해 모든 task와 충돌한다.
+ *
+ * @param {Task} task - 원장 task
+ * @returns {string[] | null} 경로 목록, legacy면 null
+ */
+function pathSetOf(task) {
+    if (task.scope && Array.isArray(task.scope.paths))
+        return task.scope.paths;
+    if (Array.isArray(task.affected_paths))
+        return task.affected_paths;
+    return null;
+}
+/**
+ * 두 task가 같은 시점에 in-flight이면 안 되는지 판정한다. 경로 조상·동일
+ * 비교는 path-overlap.pathsOverlap 하나만 쓴다 — 새 규칙을 두면 경로 중첩 규칙과
+ * scheduler가 갈라진다. 입력만 normalizeOverlapPath로 맞춘다.
+ *
+ * @param {Task} left - 한쪽 task
+ * @param {Task} right - 다른 쪽 task
+ * @returns {boolean} 충돌이면 true
+ */
+function tasksConflict(left, right) {
+    return taskConflictDetail(left, right) !== null;
+}
+/**
+ * 두 task의 경로·자원 충돌 근거를 반환한다. 경로가 없는 legacy task는
+ * 모든 상대와 충돌시키되 실제 교집합 경로는 없으므로 빈 목록으로 표시한다.
+ *
+ * @param {Task} left - 비교할 task
+ * @param {Task} right - 비교할 상대 task
+ * @returns {{ paths: string[]; resources: string[]; legacy: boolean } | null} 충돌 근거 또는 충돌 없음
+ */
+function taskConflictDetail(left, right) {
+    const leftPaths = pathSetOf(left);
+    const rightPaths = pathSetOf(right);
+    if (leftPaths === null || rightPaths === null)
+        return { paths: [], resources: [], legacy: true };
+    const paths = new Set();
+    const sharedResources = new Set();
+    for (const a of leftPaths) {
+        for (const b of rightPaths) {
+            if (pathsOverlap(normalizeOverlapPath(a), normalizeOverlapPath(b)))
+                paths.add(b);
+        }
+    }
+    const leftResources = new Set(Array.isArray(left.exclusive_resources) ? left.exclusive_resources : []);
+    for (const resource of Array.isArray(right.exclusive_resources) ? right.exclusive_resources : []) {
+        if (leftResources.has(resource))
+            sharedResources.add(resource);
+    }
+    const resources = [...sharedResources];
+    return paths.size || resources.length ? { paths: [...paths], resources, legacy: false } : null;
+}
+/**
+ * 설정 한도와 경로·exclusive_resources 충돌 안에서 다음에 열 수 있는 task id를
+ * 고른다. in-flight에 순차 task가 있거나 후보에 순차 task가 있으면 병렬 wave를
+ * 열지 않는다 — parallel_safe는 명시 true만 허용하는 기존 계약을 유지한다.
+ *
+ * @param {Task[]} tasks - 원장 task 목록
+ * @param {{ maxParallel?: number }} [options] - 동시 실행 상한. 부재 시 기본 2
+ * @returns {string[]} ID순으로 고른 ready task id
+ */
+function readyWave(tasks, options) {
+    const maxParallel = options && typeof options.maxParallel === 'number'
+        ? options.maxParallel
+        : DEFAULT_MAX_PARALLEL;
+    const inFlight = tasks.filter(isInFlight);
+    // 순차 task가 이미 돌고 있으면 자리를 더 열지 않는다. prepared 옆의 parallel
+    // 후보를 예전처럼 바로 열면 한도·충돌 정책과 어긋난다.
+    if (inFlight.some((task) => task.parallel_safe !== true))
+        return [];
+    const candidates = tasks.filter((task) => (task.status || 'pending') === 'pending'
+        && (task.depends_on || []).every((id) => {
+            const predecessor = tasks.find((other) => other.id === id);
+            // successor가 요구한 gate를 predecessor status와 그대로 비교한다. gate는
+            // integrated 하나뿐이므로 종단에 닿지 않은 predecessor는 successor를 열지 않는다.
+            return predecessor?.status === (task.dependency_gate || 'integrated');
+        })).sort((a, b) => a.id.localeCompare(b.id));
+    const sequential = candidates.find((task) => task.parallel_safe !== true);
+    if (sequential) {
+        // in-flight가 비었을 때만 순차 하나를 연다. 이미 자리가 있으면 [] —
+        // 순차와 parallel을 같은 순간에 섞지 않는다.
+        return inFlight.length === 0 ? [sequential.id] : [];
+    }
+    const slots = maxParallel - inFlight.length;
+    if (slots <= 0)
+        return [];
+    const selected = [];
+    for (const candidate of candidates) {
+        if (selected.length >= slots)
+            break;
+        const blocked = inFlight.some((task) => tasksConflict(candidate, task))
+            || selected.some((task) => tasksConflict(candidate, task));
+        if (blocked)
+            continue;
+        selected.push(candidate);
+    }
+    return selected.map((task) => task.id);
+}
+/**
+ * 실행 종류별 coordinator 상태 전이를 검증한다. verification은 worker·SHA를
+ * 만들지 않으므로 commit 전이와 교차할 수 없다.
+ *
+ * @param {string} from - 현재 ledger 상태
+ * @param {string} to - 요청한 다음 상태
+ * @param {'commit' | 'verification'} [executionKind] - 부재면 기존 commit 전이
+ * @returns {string} 허용된 다음 상태
+ */
+function transition(from, to, executionKind = 'commit') {
+    const allowed = executionKind === 'verification'
+        ? { pending: ['ready'], ready: ['verifying'], verifying: ['integrated'] }
+        : { pending: ['ready'], ready: ['prepared'], prepared: ['recorded'], recorded: ['integrated'] };
+    if (!(allowed[from] || []).includes(to))
+        throw new Error(`illegal state transition: ${from} -> ${to}`);
+    return to;
+}
+module.exports = { readyWave, tasksConflict, taskConflictDetail, transition, normalizeOverlapPath, pathSetOf };

package/dist/finalize-checks.js

@@ -0,0 +1,177 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const paths = require("./paths");
+const { toPosix } = paths;
+const frontmatter = require("./frontmatter");
+const { parseFrontmatter } = frontmatter;
+const execution_contracts_1 = require("./execution-contracts");
+function asRecord(value) { return value; }
+function isDeferredMustFix(raw) {
+    const finding = asRecord(raw);
+    return finding.actionability === 'must_fix'
+        && finding.status === 'deferred'
+        && typeof finding.id === 'string' && finding.id !== '';
+}
+function collectMustFixWarnings(rawFindings) {
+    const warnings = [];
+    const seen = new Set();
+    for (const raw of Array.isArray(rawFindings) ? rawFindings : []) {
+        if (!isDeferredMustFix(raw))
+            continue;
+        const finding = asRecord(raw);
+        const id = finding.id;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        warnings.push({
+            kind: 'must-fix-deferred',
+            id,
+            note: typeof finding.note === 'string' ? finding.note : '',
+        });
+    }
+    return warnings;
+}
+/**
+ * ledger task id를 세 자리 목록용으로 정규화한다.
+ * 원장은 `001`과 `TASKS-001`을 섞어 쓸 수 있어, 보고 목록만 세 자리로 맞춘다.
+ *
+ * @param {unknown} id - 원장 task id
+ * @returns {string | null} 세 자리 id. 숫자로 해석되지 않으면 null
+ */
+function threeDigitTaskId(id) {
+    if (typeof id === 'number' && Number.isInteger(id) && id >= 0 && id <= 999) {
+        return String(id).padStart(3, '0');
+    }
+    if (typeof id !== 'string' || id === '')
+        return null;
+    const match = /^(?:TASKS-)?(\d{1,3})$/.exec(id);
+    return match ? match[1].padStart(3, '0') : null;
+}
+/**
+ * finalize payload의 보고 전용 `integration` 필드를 만든다.
+ * 거절 reason은 바꾸지 않는다. 깨진 원장은 기존 `coordinator-ledger`만 쓰고,
+ * 미통합 task는 `complete`/`openTasks`로만 알린다.
+ *
+ * @param {object} read - `readCoordinatorLedger` 결과
+ * @returns {IntegrationReport} absent는 비-drive, unreadable은 기존 거절과 함께 실림
+ */
+function buildIntegration(read) {
+    // 1. 원장이 없으면 위임 실행이 아니다. required를 켜면 스킬이 비-drive를
+    //    미완료로 오인하고 `--yes`를 멈춘다.
+    if (!read.ok) {
+        if (read.reason !== 'unreadable-ledger') {
+            return {
+                ledger: 'absent',
+                required: false,
+                complete: true,
+                openTasks: [],
+                headVerified: null,
+            };
+        }
+        return {
+            ledger: 'unreadable',
+            required: true,
+            complete: false,
+            openTasks: [],
+            headVerified: null,
+        };
+    }
+    const tasks = (Array.isArray(read.ledger.tasks) ? read.ledger.tasks : [])
+        .filter((entry) => Boolean(entry) && typeof entry === 'object')
+        .map((entry) => asRecord(entry));
+    const classified = tasks
+        .map((entry) => ({ entry, disposition: (0, execution_contracts_1.validOutsideScope)(read.ledger, String(entry.id)) }))
+        .find((row) => row.disposition !== null);
+    const open = tasks.filter((entry) => entry.status !== 'integrated'
+        && !(classified && classified.entry === entry));
+    const openTasks = open
+        .map((entry) => threeDigitTaskId(entry.id))
+        .filter((id) => Boolean(id))
+        .sort();
+    const verification = tasks.filter((entry) => entry.execution_kind === 'verification');
+    return {
+        ledger: 'ok',
+        required: true,
+        // open.length: id를 못 읽은 미통합 task도 complete를 false로 남긴다.
+        complete: open.length === 0,
+        openTasks,
+        // verification node가 없으면 head 판정 대상이 없다. null과 false를 구분해
+        // 스킬이 "검증 실패"와 "검증 task 없음"을 같은 중지로 접지 않게 한다.
+        headVerified: verification.length === 0
+            ? null
+            : verification.every((entry) => entry.status === 'integrated'),
+        ...(classified && classified.disposition
+            ? { outsideScope: { task: String(classified.entry.id), disposition: classified.disposition } }
+            : {}),
+    };
+}
+/**
+ * 원장에서 integrated인 task마다 integration 사본의 tasks.md 상태를 대조한다.
+ * commit task는 `verified`, verification task는 `integrated`여야 한다. 원장만 앞서
+ * 가고 문서가 따라오지 않으면 G16이 원인 모를 열린 task로 보고하므로, 그 앞에서
+ * 어긋난 task를 이름으로 돌려준다. 읽기만 한다.
+ *
+ * @param {object} read - 읽기에 성공한 `readCoordinatorLedger` 결과
+ * @param {string} blueprintDir - blueprint 상대 경로
+ * @returns {EvidenceMismatch[]} 어긋난 task. 비어 있으면 일치
+ */
+function coordinatorEvidenceMismatches(read, blueprintDir) {
+    const tasks = (Array.isArray(read.ledger.tasks) ? read.ledger.tasks : [])
+        .filter((entry) => Boolean(entry) && typeof entry === 'object')
+        .map((entry) => asRecord(entry))
+        .filter((entry) => entry.status === 'integrated');
+    const mismatches = [];
+    for (const entry of tasks) {
+        const id = threeDigitTaskId(entry.id);
+        const expected = entry.execution_kind === 'verification' ? 'integrated' : 'verified';
+        let actual = null;
+        if (id && read.integrationPath) {
+            const file = path.join(read.integrationPath, toPosix(blueprintDir), 'tasks', id, 'tasks.md');
+            actual = readTaskStatus(file);
+        }
+        if (actual !== expected)
+            mismatches.push({ id, expected, actual });
+    }
+    return mismatches;
+}
+/**
+ * tasks.md의 `bouncer.status`를 읽는다. 문서가 없거나 frontmatter를 읽을 수 없으면
+ * null — 대조에서는 둘 다 기대 상태와 다른 값이다.
+ *
+ * @param {string} file - tasks.md 절대 경로
+ * @returns {string | null} 상태 문자열 또는 null
+ */
+function readTaskStatus(file) {
+    const source = (() => {
+        try {
+            return fs.readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    })();
+    if (source === null || !/^---\s*\r?\n/.test(source))
+        return null;
+    let data;
+    try {
+        data = parseFrontmatter(source).data;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'YAMLException')
+            return null;
+        throw error;
+    }
+    const root = data && typeof data === 'object' ? asRecord(data) : null;
+    const bouncer = root && root.bouncer && typeof root.bouncer === 'object'
+        ? asRecord(root.bouncer)
+        : null;
+    const status = bouncer && bouncer.status;
+    return typeof status === 'string' ? status : null;
+}
+module.exports = {
+    buildIntegration, coordinatorEvidenceMismatches,
+    collectMustFixWarnings, isDeferredMustFix,
+};