raptor-aios 0.1.0

package/dist/_core/dist/gates/builtin.js

@@ -0,0 +1,860 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { validateAuditFile } from "../audit/validate.js";
+import { parseFrontmatter } from "../frontmatter/index.js";
+import { extractCoreBlock } from "../constitution/core.js";
+import { parsePlan } from "../models/plan.js";
+import { parseSpec } from "../models/spec.js";
+import { parseTaskList, parseTasks } from "../models/tasks.js";
+function extractIdsByPattern(source, re) {
+    const seen = new Set();
+    const iter = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");
+    let m;
+    while ((m = iter.exec(source)) !== null) {
+        seen.add(m[1]);
+    }
+    return Array.from(seen).sort((a, b) => {
+        const na = Number(a.replace(/\D/g, ""));
+        const nb = Number(b.replace(/\D/g, ""));
+        return na - nb;
+    });
+}
+const US_RE = /\[(US\d+)\]/g;
+const FR_RE = /\[(FR-\d+)\]/g;
+const AC_RE = /\[(AC-\d+)\]/g;
+const ALLOWED_AMENDMENT_EVENTS = new Set([
+    "constitution.initialized",
+    "constitution.upgraded",
+    "constitution.repaired",
+    "amendment",
+]);
+const requireFeatureDir = (ctx) => {
+    if (!ctx.featureDir) {
+        throw new Error("gate requires featureDir in context");
+    }
+    return ctx.featureDir;
+};
+export const gateSpecExists = {
+    id: "gate.spec.exists",
+    title: "Spec exists for this feature",
+    level: "critical",
+    article: "C1",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const path = join(dir, "spec.md");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `spec.md missing at ${path}`,
+            };
+        }
+        const spec = parseSpec(path);
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { hash: spec.hash, status: spec.data.status },
+        };
+    },
+};
+export const gateAuditComplete = {
+    id: "gate.audit.complete",
+    title: "audit.jsonl present and parseable",
+    level: "critical",
+    article: "C2",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const path = join(dir, "audit.jsonl");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `audit.jsonl missing at ${path}`,
+            };
+        }
+        const content = readFileSync(path, "utf8");
+        const lines = content.split("\n").filter((l) => l.length > 0);
+        const bad = [];
+        let withHash = 0;
+        lines.forEach((line, i) => {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.prompt?.hash ||
+                    obj.inputs?.some((r) => r.hash) ||
+                    obj.outputs?.some((r) => r.hash)) {
+                    withHash++;
+                }
+            }
+            catch {
+                bad.push(i + 1);
+            }
+        });
+        if (bad.length > 0) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `malformed JSONL at line(s): ${bad.join(", ")}`,
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { entries: lines.length, withHash },
+        };
+    },
+};
+export const gatePlanApproved = {
+    id: "gate.plan.approved",
+    title: "Plan is approved and Phase -1 passed",
+    level: "critical",
+    article: "C3",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const path = join(dir, "plan.md");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `plan.md missing at ${path}`,
+            };
+        }
+        const plan = parsePlan(path);
+        const ok = plan.data.status === "approved" &&
+            (plan.data.phase_minus_one === "passed" ||
+                plan.data.phase_minus_one === "justified");
+        if (!ok) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `plan status=${plan.data.status}, phase_minus_one=${plan.data.phase_minus_one}`,
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: {
+                approved_by: plan.data.approved_by,
+                approved_at: plan.data.approved_at,
+            },
+        };
+    },
+};
+export const gateConstitutionIntegrity = {
+    id: "gate.constitution.integrity",
+    title: "RAPTOR-CORE block intact",
+    level: "critical",
+    article: "C4",
+    run(ctx) {
+        const path = join(ctx.projectRoot, ".raptor", "constitution.md");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `constitution.md missing at ${path}`,
+            };
+        }
+        const source = readFileSync(path, "utf8");
+        const extracted = extractCoreBlock(source);
+        if (!extracted) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "RAPTOR-CORE markers not found in constitution.md",
+            };
+        }
+        if (!extracted.isIntact) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `hash mismatch — declared ${extracted.declaredHash}, computed ${extracted.computedHash}`,
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { version: extracted.version, hash: extracted.declaredHash },
+        };
+    },
+};
+export const gateAmendmentCore = {
+    id: "gate.amendment.core",
+    title: "amendments.log is schema-valid and restricted to constitutional events",
+    level: "critical",
+    article: "C4",
+    run(ctx) {
+        const path = join(ctx.projectRoot, ".raptor", "memory", "amendments.log");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `amendments.log missing at ${path}`,
+            };
+        }
+        const result = validateAuditFile(path, { strict: true });
+        if (!result.valid) {
+            const first = result.errors[0];
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: first
+                    ? `${first.path}: ${first.message} [${first.keyword}]` +
+                        (first.line ? ` (line ${first.line})` : "")
+                    : "amendments.log failed schema validation",
+                details: {
+                    totalLines: result.totalLines,
+                    validLines: result.validLines,
+                    errorCount: result.errors.length,
+                },
+            };
+        }
+        const content = readFileSync(path, "utf8").trimEnd();
+        if (content.length === 0) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { entries: 0 },
+            };
+        }
+        const lines = content.split("\n");
+        const offenders = [];
+        for (let i = 0; i < lines.length; i++) {
+            const obj = JSON.parse(lines[i]);
+            if (!ALLOWED_AMENDMENT_EVENTS.has(obj.event)) {
+                offenders.push({ line: i + 1, event: obj.event });
+            }
+        }
+        if (offenders.length > 0) {
+            const first = offenders[0];
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `disallowed event "${first.event}" at line ${first.line} — amendments.log must only contain ${Array.from(ALLOWED_AMENDMENT_EVENTS).join(", ")}`,
+                details: { offenders },
+            };
+        }
+        const firstEntry = JSON.parse(lines[0]);
+        if (firstEntry.event !== "constitution.initialized") {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `first entry must be "constitution.initialized", got "${firstEntry.event}"`,
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { entries: lines.length },
+        };
+    },
+};
+export const gateSpecClarifications = {
+    id: "gate.spec.clarifications",
+    title: "Spec has no unresolved [NEEDS CLARIFICATION]",
+    level: "required",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const path = join(dir, "spec.md");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                status: "fail",
+                message: "spec.md missing",
+            };
+        }
+        const spec = parseSpec(path);
+        if (spec.clarifications.length > 0) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                status: "fail",
+                message: `${spec.clarifications.length} unresolved [NEEDS CLARIFICATION] block(s)`,
+                details: { count: spec.clarifications.length },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            status: "pass",
+        };
+    },
+};
+export const gateSpecApproved = {
+    id: "gate.spec.approved",
+    title: "Spec frontmatter status is approved",
+    level: "required",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const path = join(dir, "spec.md");
+        if (!existsSync(path)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                status: "fail",
+                message: "spec.md missing",
+            };
+        }
+        const raw = readFileSync(path, "utf8");
+        const { data } = parseFrontmatter(raw);
+        if (data.status !== "approved") {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                status: "fail",
+                message: `spec.status=${data.status ?? "unknown"}`,
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            status: "pass",
+        };
+    },
+};
+export const gatePlanInputHash = {
+    id: "gate.plan.input_hash",
+    title: "plan.md spec_hash matches current spec.md (PI-3 staleness)",
+    level: "required",
+    article: "C2",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const planPath = join(dir, "plan.md");
+        if (!existsSync(planPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "plan.md not yet generated" },
+            };
+        }
+        const raw = readFileSync(planPath, "utf8");
+        const isStub = raw.trim().startsWith("# Plan:") && raw.length < 300;
+        if (isStub) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "plan.md is stub (awaiting raptor plan)" },
+            };
+        }
+        const specPath = join(dir, "spec.md");
+        if (!existsSync(specPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "spec.md missing but plan.md exists",
+            };
+        }
+        const plan = parsePlan(planPath);
+        if (!plan.data.spec_hash) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "plan.md frontmatter missing spec_hash",
+            };
+        }
+        const spec = parseSpec(specPath);
+        if (plan.data.spec_hash !== spec.hash) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `stale: plan declares spec_hash=${plan.data.spec_hash.slice(0, 20)}…, current spec hash=${spec.hash.slice(0, 20)}…`,
+                details: {
+                    declared: plan.data.spec_hash,
+                    current: spec.hash,
+                },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { spec_hash: spec.hash },
+        };
+    },
+};
+export const gateTasksInputHash = {
+    id: "gate.tasks.input_hash",
+    title: "tasks.md plan_hash matches current plan.md (PI-3 staleness)",
+    level: "required",
+    article: "C2",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const tasksPath = join(dir, "tasks.md");
+        if (!existsSync(tasksPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "tasks.md not yet generated" },
+            };
+        }
+        const raw = readFileSync(tasksPath, "utf8");
+        const isStub = raw.trim().startsWith("# Tasks:") && raw.length < 300;
+        if (isStub) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "tasks.md is stub (awaiting raptor tasks)" },
+            };
+        }
+        const planPath = join(dir, "plan.md");
+        if (!existsSync(planPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "plan.md missing but tasks.md exists",
+            };
+        }
+        const tasks = parseTasks(tasksPath);
+        if (!tasks.data.plan_hash) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "tasks.md frontmatter missing plan_hash",
+            };
+        }
+        const plan = parsePlan(planPath);
+        if (tasks.data.plan_hash !== plan.hash) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `stale: tasks declares plan_hash=${tasks.data.plan_hash.slice(0, 20)}…, current plan hash=${plan.hash.slice(0, 20)}…`,
+                details: {
+                    declared: tasks.data.plan_hash,
+                    current: plan.hash,
+                },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { plan_hash: plan.hash },
+        };
+    },
+};
+export const gatePlanCoverageComplete = {
+    id: "gate.plan.coverage_complete",
+    title: "plan.md mentions every [US#] and [FR-#] declared in spec.md (PI-2)",
+    level: "required",
+    article: "C2",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const planPath = join(dir, "plan.md");
+        if (!existsSync(planPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "plan.md not yet generated" },
+            };
+        }
+        const planRaw = readFileSync(planPath, "utf8");
+        const isStub = planRaw.trim().startsWith("# Plan:") && planRaw.length < 300;
+        if (isStub) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "plan.md is stub (awaiting raptor plan)" },
+            };
+        }
+        const specPath = join(dir, "spec.md");
+        if (!existsSync(specPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "spec.md missing but plan.md exists",
+            };
+        }
+        const spec = parseSpec(specPath);
+        const plan = parsePlan(planPath);
+        const specUS = extractIdsByPattern(spec.body, US_RE);
+        const specFR = extractIdsByPattern(spec.body, FR_RE);
+        const planUS = new Set(extractIdsByPattern(plan.body, US_RE));
+        const planFR = new Set(extractIdsByPattern(plan.body, FR_RE));
+        const missingUS = specUS.filter((id) => !planUS.has(id));
+        const missingFR = specFR.filter((id) => !planFR.has(id));
+        if (missingUS.length > 0 || missingFR.length > 0) {
+            const parts = [];
+            if (missingUS.length > 0)
+                parts.push(`US: ${missingUS.join(", ")}`);
+            if (missingFR.length > 0)
+                parts.push(`FR: ${missingFR.join(", ")}`);
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `plan.md does not cover ${parts.join("; ")}`,
+                details: {
+                    missing_us: missingUS,
+                    missing_fr: missingFR,
+                    spec_us: specUS,
+                    spec_fr: specFR,
+                },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: {
+                us_covered: specUS.length,
+                fr_covered: specFR.length,
+            },
+        };
+    },
+};
+export const gateTasksCoverageComplete = {
+    id: "gate.tasks.coverage_complete",
+    title: "tasks.md covers every [US#] with ≥1 task and mentions every [AC-#] (PI-2)",
+    level: "required",
+    article: "C2",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const tasksPath = join(dir, "tasks.md");
+        if (!existsSync(tasksPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "tasks.md not yet generated" },
+            };
+        }
+        const tasksRaw = readFileSync(tasksPath, "utf8");
+        const isStub = tasksRaw.trim().startsWith("# Tasks:") && tasksRaw.length < 300;
+        if (isStub) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "tasks.md is stub (awaiting raptor tasks)" },
+            };
+        }
+        const specPath = join(dir, "spec.md");
+        if (!existsSync(specPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "spec.md missing but tasks.md exists",
+            };
+        }
+        const spec = parseSpec(specPath);
+        const tasks = parseTasks(tasksPath);
+        const specUS = extractIdsByPattern(spec.body, US_RE);
+        const specAC = extractIdsByPattern(spec.body, AC_RE);
+        const items = parseTaskList(tasks.body);
+        const storiesCovered = new Set();
+        for (const it of items) {
+            for (const s of it.stories)
+                storiesCovered.add(s);
+        }
+        const acMentioned = new Set(extractIdsByPattern(tasks.body, AC_RE));
+        const missingUS = specUS.filter((id) => !storiesCovered.has(id));
+        const missingAC = specAC.filter((id) => !acMentioned.has(id));
+        if (missingUS.length > 0 || missingAC.length > 0) {
+            const parts = [];
+            if (missingUS.length > 0) {
+                parts.push(`US without task: ${missingUS.join(", ")}`);
+            }
+            if (missingAC.length > 0) {
+                parts.push(`AC not mentioned: ${missingAC.join(", ")}`);
+            }
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `tasks.md incomplete — ${parts.join("; ")}`,
+                details: {
+                    missing_us: missingUS,
+                    missing_ac: missingAC,
+                    spec_us: specUS,
+                    spec_ac: specAC,
+                    task_count: items.length,
+                },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: {
+                us_covered: specUS.length,
+                ac_covered: specAC.length,
+                task_count: items.length,
+            },
+        };
+    },
+};
+const META_TASK_RE = /\[meta\]/i;
+export const gateTasksTraceComplete = {
+    id: "gate.tasks.trace_complete",
+    title: "every task in tasks.md traces to a [US#] or [meta] (PI-1)",
+    level: "required",
+    article: "C2",
+    run(ctx) {
+        const dir = requireFeatureDir(ctx);
+        const tasksPath = join(dir, "tasks.md");
+        if (!existsSync(tasksPath)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "tasks.md not yet generated" },
+            };
+        }
+        const tasksRaw = readFileSync(tasksPath, "utf8");
+        const isStub = tasksRaw.trim().startsWith("# Tasks:") && tasksRaw.length < 300;
+        if (isStub) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "pass",
+                details: { reason: "tasks.md is stub (awaiting raptor tasks)" },
+            };
+        }
+        const tasks = parseTasks(tasksPath);
+        const items = parseTaskList(tasks.body);
+        if (items.length === 0) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: "tasks.md has no parseable task items",
+            };
+        }
+        const orphans = [];
+        for (const it of items) {
+            if (it.stories.length > 0)
+                continue;
+            if (META_TASK_RE.test(it.raw))
+                continue;
+            orphans.push({ id: it.id, raw: it.raw.trim() });
+        }
+        if (orphans.length > 0) {
+            const ids = orphans.map((o) => o.id).join(", ");
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                article: this.article,
+                status: "fail",
+                message: `${orphans.length} orphan task(s) without [US#] or [meta]: ${ids}`,
+                details: { orphans, total_tasks: items.length },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            article: this.article,
+            status: "pass",
+            details: { total_tasks: items.length },
+        };
+    },
+};
+export const gateHotfixUnreconciled = {
+    id: "gate.hotfix.unreconciled",
+    title: "No hotfix is still waiting reconciliation beyond its deadline",
+    level: "advisory",
+    run(ctx) {
+        const dir = join(ctx.projectRoot, ".raptor", "hotfixes");
+        if (!existsSync(dir)) {
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                status: "pass",
+                details: { entries: 0 },
+            };
+        }
+        const subdirs = readdirSync(dir).filter((d) => {
+            const p = join(dir, d);
+            return /^\d{3,}-/.test(d) && existsSync(p) && statSync(p).isDirectory();
+        });
+        const open = [];
+        const overdue = [];
+        const today = new Date().toISOString().slice(0, 10);
+        for (const sub of subdirs) {
+            const mdPath = join(dir, sub, "hotfix.md");
+            if (!existsSync(mdPath))
+                continue;
+            const raw = readFileSync(mdPath, "utf8");
+            const { data } = parseFrontmatter(raw);
+            if (data.status !== "open")
+                continue;
+            open.push({
+                slug: data.slug ?? sub,
+                article: data.article,
+                reconcileBy: data.reconcile_by,
+            });
+            if (data.reconcile_by && data.reconcile_by < today) {
+                overdue.push({ slug: data.slug ?? sub, reconcileBy: data.reconcile_by });
+            }
+        }
+        if (overdue.length > 0) {
+            const first = overdue[0];
+            return {
+                id: this.id,
+                title: this.title,
+                level: this.level,
+                status: "fail",
+                message: `${overdue.length} hotfix${overdue.length > 1 ? "es" : ""} overdue for reconciliation (first: ${first.slug}, reconcile_by=${first.reconcileBy})`,
+                details: { open: open.length, overdue },
+            };
+        }
+        return {
+            id: this.id,
+            title: this.title,
+            level: this.level,
+            status: "pass",
+            details: { open: open.length, overdue: 0 },
+        };
+    },
+};
+import { M7_GATES } from "./m7-gates.js";
+export const PROJECT_GATES = [
+    gateConstitutionIntegrity,
+    gateAmendmentCore,
+    gateHotfixUnreconciled,
+];
+export const BUILTIN_GATES = [
+    gateSpecExists,
+    gateAuditComplete,
+    gatePlanApproved,
+    gateConstitutionIntegrity,
+    gateAmendmentCore,
+    gateHotfixUnreconciled,
+    gateSpecClarifications,
+    gateSpecApproved,
+    gatePlanInputHash,
+    gateTasksInputHash,
+    gatePlanCoverageComplete,
+    gateTasksCoverageComplete,
+    gateTasksTraceComplete,
+    ...M7_GATES,
+];
+export function gateById(id) {
+    return BUILTIN_GATES.find((g) => g.id === id);
+}
+//# sourceMappingURL=builtin.js.map