@outerlayer/cli 0.6.0 → 0.7.0

package/dist/{chunk-EMY4I27X.js → chunk-7ZR5UPMB.js}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { RESERVED_EMIT_NAMES } from './chunk-YNJEOGDL.js';
 import { __commonJS, __require, __toESM } from './chunk-Z5GEFMRW.js';
 
 createRequire(import.meta.url);
@@ -7163,7 +7164,7 @@ var require_public_api = __commonJS({
       }
       return doc;
     }
-    function parse(src, reviver, options) {
+    function parse2(src, reviver, options) {
       let _reviver = void 0;
       if (typeof reviver === "function") {
         _reviver = reviver;
@@ -7204,7 +7205,7 @@ var require_public_api = __commonJS({
         return value.toString(options);
       return new Document.Document(value, _replacer, options).toString(options);
     }
-    exports$1.parse = parse;
+    exports$1.parse = parse2;
     exports$1.parseAllDocuments = parseAllDocuments;
     exports$1.parseDocument = parseDocument2;
     exports$1.stringify = stringify;
@@ -7286,8 +7287,8 @@ function classifyOnePath(rawPath) {
   const segs = path.split("/");
   const outerlayerIndex = segs.indexOf(OUTERLAYER_DIR);
   if (outerlayerIndex === -1) {
-    const base = segs[segs.length - 1];
-    if (base === "AGENTS.md" || base === "CLAUDE.md") {
+    const base2 = segs[segs.length - 1];
+    if (base2 === "AGENTS.md" || base2 === "CLAUDE.md") {
       const scopePath2 = segs.slice(0, -1).join("/");
       return { type: "entry", entry: { path, kind: "external-instructions", scopePath: scopePath2 } };
     }
@@ -7974,5 +7975,554 @@ function normalizeRepoName(repo) {
 }
 var CONTEXT_PIN_FILENAME = ".outerlayer-pin.json";
 var CONTEXT_PIN_SCHEMA_VERSION = 1;
+var base = {
+  whenPaths: null,
+  whenIssueType: null,
+  whenIssueLabels: null,
+  needs: [],
+  declaresEmit: null,
+  level: "warn"
+};
+var REGISTRY_VALIDATORS = [
+  {
+    ...base,
+    id: "code-review-ran",
+    name: "Code review report",
+    row: "A code review report is attached to this change",
+    requireAny: [{ type: "artifact", kind: "report", for: "code-review-ran" }]
+  }
+];
+var MAX_COMMAND_LENGTH = 2e3;
+var RECOMMENDED_EXTENDS = "outerlayer:recommended@v1";
+var FREED_BUILTINS = /* @__PURE__ */ new Set(["ci-passed", "acceptance-criteria"]);
+var RETIRED_BUILTINS = /* @__PURE__ */ new Set([
+  "red-then-green",
+  "no-test-tampering",
+  "tests-after-last-edit",
+  "commits-from-sessions"
+]);
+var SLUG_PATTERN2 = /^[a-z][a-z0-9._-]{0,63}$/;
+var CONTROL_CHARS = /\p{Cc}/u;
+function inlineText(raw, max = 80) {
+  const flat = raw.replace(/\p{Cc}+/gu, " ");
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+var MAX_ROW_LENGTH = 200;
+var MAX_NAME_LENGTH = 40;
+var MAX_GLOB_LENGTH = 200;
+var MAX_WHEN_PATHS = 20;
+var NEEDS_ALIASES = {
+  "tool-calls.commands": "commands",
+  "tool-calls.edits": "edits",
+  commands: "commands",
+  edits: "edits"
+};
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseLevel(value) {
+  return value === "warn" || value === "info" || value === "off" ? value : null;
+}
+function parseMergeGate(value) {
+  return value === "none" || value === "on-flag" || value === "on-unverifiable" ? value : null;
+}
+function parseReview(value) {
+  return value === "required" || value === "optional" ? value : null;
+}
+function parsePolicyFile(file) {
+  const problems = [];
+  const fail = (problem) => {
+    problems.push({ file: file.path, problem });
+    return { extendsOk: false, overrides: {}, mergeGate: null, review: null, testProof: null, criteriaMissing: null, problems };
+  };
+  let root;
+  try {
+    root = (0, import_yaml.parse)(file.content);
+  } catch (error) {
+    return fail(`not valid YAML \u2014 ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(root)) return fail("must be a YAML mapping");
+  for (const key of Object.keys(root)) {
+    if (key !== "extends" && key !== "validators" && key !== "merge_gate" && key !== "review" && key !== "build" && key !== "criteria") {
+      return fail(`unknown key "${inlineText(key)}"`);
+    }
+  }
+  if (root["build"] !== void 0) {
+    const build = root["build"];
+    if (!isRecord(build)) return fail("build must be a mapping");
+    for (const key of Object.keys(build)) {
+      if (key !== "workflows") return fail(`unknown key "build.${inlineText(key)}"`);
+    }
+    const workflows = build["workflows"];
+    if (workflows !== void 0 && workflows !== "allow" && workflows !== "deny") {
+      return fail(`build.workflows has value "${inlineText(String(workflows))}" \u2014 use allow or deny`);
+    }
+  }
+  let testProof = null;
+  let criteriaMissing = null;
+  if (root["criteria"] !== void 0) {
+    const criteria = root["criteria"];
+    if (!isRecord(criteria)) return fail("criteria must be a mapping");
+    for (const key of Object.keys(criteria)) {
+      if (key !== "replace" && key !== "test_proof" && key !== "missing") {
+        return fail(`unknown key "criteria.${inlineText(key)}"`);
+      }
+    }
+    const rawTestProof = criteria["test_proof"];
+    if (rawTestProof !== void 0) {
+      if (rawTestProof !== "any" && rawTestProof !== "ci") {
+        return fail(`criteria.test_proof has value "${inlineText(String(rawTestProof))}" \u2014 use any or ci`);
+      }
+      testProof = rawTestProof;
+    }
+    const rawMissing = criteria["missing"];
+    if (rawMissing !== void 0) {
+      const level = parseLevel(rawMissing);
+      if (level === null) {
+        return fail(`criteria.missing has value "${inlineText(String(rawMissing))}" \u2014 use warn, info, or off`);
+      }
+      criteriaMissing = level;
+    }
+    const replace = criteria["replace"];
+    if (replace !== void 0 && replace !== "people" && replace !== "anyone") {
+      return fail(`criteria.replace has value "${inlineText(String(replace))}" \u2014 use people or anyone`);
+    }
+  }
+  let mergeGate = null;
+  if (root["merge_gate"] !== void 0) {
+    mergeGate = parseMergeGate(root["merge_gate"]);
+    if (mergeGate === null) {
+      return fail(
+        `merge_gate has value "${inlineText(String(root["merge_gate"]))}" \u2014 use none, on-flag, or on-unverifiable`
+      );
+    }
+  }
+  let review = null;
+  if (root["review"] !== void 0) {
+    review = parseReview(root["review"]);
+    if (review === null) {
+      return fail(`review has value "${inlineText(String(root["review"]))}" \u2014 use required or optional`);
+    }
+  }
+  if (root["extends"] === void 0) {
+    return fail(`missing "extends" \u2014 adopt the registry with extends: ${RECOMMENDED_EXTENDS}`);
+  }
+  if (root["extends"] !== RECOMMENDED_EXTENDS) {
+    return fail(
+      `unknown extends "${inlineText(String(root["extends"]))}" \u2014 the only supported registry is ${RECOMMENDED_EXTENDS}`
+    );
+  }
+  const overrides = {};
+  const validators = root["validators"];
+  if (validators !== void 0) {
+    if (!isRecord(validators)) return fail(`"validators" must be a mapping of id to level`);
+    for (const [id, rawLevel] of Object.entries(validators)) {
+      const level = parseLevel(rawLevel);
+      if (level === null) {
+        return fail(`validator "${inlineText(id)}" has level "${inlineText(String(rawLevel))}" \u2014 use warn, info, or off`);
+      }
+      overrides[id] = level;
+    }
+  }
+  return { extendsOk: true, overrides, mergeGate, review, testProof, criteriaMissing, problems };
+}
+function parseSessionRan(value, file, problems) {
+  var _a;
+  if (!isRecord(value)) {
+    problems.push({ file, problem: `"session.ran" must be a mapping with a "command"` });
+    return null;
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "command" && key !== "status") {
+      problems.push({ file, problem: `"session.ran" has unknown key "${inlineText(key)}"` });
+      return null;
+    }
+  }
+  const command = value["command"];
+  if (typeof command !== "string" || command.trim() === "") {
+    problems.push({ file, problem: `"session.ran" needs a non-empty "command"` });
+    return null;
+  }
+  const status = (_a = value["status"]) != null ? _a : "ok";
+  if (status !== "ok" && status !== "error") {
+    problems.push({ file, problem: `"session.ran" status must be ok or error` });
+    return null;
+  }
+  return { type: "session-ran", command: command.trim(), status };
+}
+function parseRequirementAlt(value, file, problems) {
+  if (!isRecord(value)) {
+    problems.push({ file, problem: `each requirement must be a single-key mapping` });
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    problems.push({
+      file,
+      problem: `a requirement names exactly one of session.ran, validator, emitted`
+    });
+    return null;
+  }
+  const key = keys[0];
+  if (key === "session.ran") return parseSessionRan(value[key], file, problems);
+  if (key === "validator") {
+    const id = value[key];
+    if (typeof id !== "string" || !SLUG_PATTERN2.test(id)) {
+      problems.push({ file, problem: `"validator" must name a validator id` });
+      return null;
+    }
+    return { type: "validator", id };
+  }
+  if (key === "emitted") {
+    const name = value[key];
+    if (typeof name !== "string" || !SLUG_PATTERN2.test(name)) {
+      problems.push({ file, problem: `"emitted" must name an emit (id characters only)` });
+      return null;
+    }
+    return { type: "emitted", name };
+  }
+  problems.push({ file, problem: `unknown requirement "${key}"` });
+  return null;
+}
+function parseRequire(value, file, problems) {
+  if (isRecord(value) && "any" in value) {
+    if (Object.keys(value).length !== 1 || !Array.isArray(value["any"]) || value["any"].length === 0) {
+      problems.push({ file, problem: `"require.any" must be a non-empty list of requirements` });
+      return null;
+    }
+    const alts = [];
+    for (const entry of value["any"]) {
+      const alt = parseRequirementAlt(entry, file, problems);
+      if (alt === null) return null;
+      alts.push(alt);
+    }
+    return alts;
+  }
+  const single = parseRequirementAlt(value, file, problems);
+  return single === null ? null : [single];
+}
+function parseNeeds(value, file, problems) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    problems.push({ file, problem: `"needs" must be a list of fact families` });
+    return null;
+  }
+  const families = [];
+  for (const entry of value) {
+    const family = typeof entry === "string" ? NEEDS_ALIASES[entry] : void 0;
+    if (family === void 0) {
+      problems.push({ file, problem: `unknown fact family "${inlineText(String(entry))}" in "needs"` });
+      return null;
+    }
+    families.push(family);
+  }
+  return families;
+}
+var CUSTOM_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "name",
+  "row",
+  "level",
+  "when",
+  "require",
+  "run",
+  "needs"
+]);
+function parseCustomFile(file, problems) {
+  const fail = (problem) => {
+    problems.push({ file: file.path, problem });
+    return null;
+  };
+  let root;
+  try {
+    root = (0, import_yaml.parse)(file.content);
+  } catch (error) {
+    return fail(`not valid YAML \u2014 ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(root)) return fail("must be a YAML mapping");
+  for (const key of Object.keys(root)) {
+    if (!CUSTOM_KEYS.has(key)) return fail(`unknown key "${inlineText(key)}"`);
+  }
+  const id = root["id"];
+  if (typeof id !== "string" || !SLUG_PATTERN2.test(id)) {
+    return fail(`"id" must be lowercase id characters (got ${inlineText(JSON.stringify(root["id"]))})`);
+  }
+  const kind = root["kind"];
+  if (kind !== "validation" && kind !== "signal") {
+    return fail(`"${id}" has kind "${inlineText(String(kind))}" \u2014 use validation or signal`);
+  }
+  if (kind === "signal") return { signalId: id };
+  const rawRow = root["row"];
+  if (typeof rawRow !== "string" || rawRow.trim() === "") {
+    return fail(`"${id}" needs a "row" \u2014 the sentence its result renders as`);
+  }
+  const row = rawRow.trim();
+  if (CONTROL_CHARS.test(row) || row.length > MAX_ROW_LENGTH) {
+    return fail(`"${id}" row must be a single line of at most ${MAX_ROW_LENGTH} characters`);
+  }
+  const rawName = root["name"];
+  let name = null;
+  if (rawName !== void 0) {
+    if (typeof rawName !== "string") {
+      return fail(`"${id}" name must be one short line`);
+    }
+    const trimmedName = rawName.trim();
+    if (trimmedName === "" || CONTROL_CHARS.test(trimmedName) || trimmedName.length > MAX_NAME_LENGTH) {
+      return fail(`"${id}" name must be one short line`);
+    }
+    name = trimmedName;
+  }
+  const level = root["level"] === void 0 ? "warn" : parseLevel(root["level"]);
+  if (level === null) {
+    return fail(`"${id}" has level "${inlineText(String(root["level"]))}" \u2014 use warn, info, or off`);
+  }
+  let whenPaths = null;
+  let whenIssueType = null;
+  let whenIssueLabels = null;
+  if (root["when"] !== void 0) {
+    const when = root["when"];
+    if (!isRecord(when) || Object.keys(when).some(
+      (key) => key !== "paths" && key !== "issue.type" && key !== "issue.labels"
+    ) || Object.keys(when).length === 0) {
+      return fail(
+        `"${id}" when: only "paths", "issue.type", and "issue.labels" scoping is supported`
+      );
+    }
+    const paths = when["paths"];
+    if (paths !== void 0) {
+      if (!Array.isArray(paths) || paths.length === 0 || paths.some((p) => typeof p !== "string" || p.trim() === "")) {
+        return fail(`"${id}" when.paths must be a non-empty list of path globs`);
+      }
+      if (paths.length > MAX_WHEN_PATHS) {
+        return fail(`"${id}" when.paths lists ${paths.length} globs \u2014 the cap is ${MAX_WHEN_PATHS}`);
+      }
+      const oversized = paths.find((p) => p.length > MAX_GLOB_LENGTH);
+      if (oversized !== void 0) {
+        return fail(
+          `"${id}" when.paths has a ${oversized.length}-character glob \u2014 the cap is ${MAX_GLOB_LENGTH}`
+        );
+      }
+      whenPaths = paths.map((p) => p.trim());
+    }
+    const issueType = when["issue.type"];
+    if (issueType !== void 0) {
+      if (typeof issueType !== "string" || issueType.trim() === "") {
+        return fail(`"${id}" when.issue.type must be a non-empty string`);
+      }
+      whenIssueType = issueType.trim();
+    }
+    const issueLabels = when["issue.labels"];
+    if (issueLabels !== void 0) {
+      if (!Array.isArray(issueLabels) || issueLabels.length === 0 || issueLabels.some((label) => typeof label !== "string" || label.trim() === "")) {
+        return fail(`"${id}" when.issue.labels must be a non-empty list of label names`);
+      }
+      whenIssueLabels = issueLabels.map((label) => label.trim());
+    }
+  }
+  const hasRequire = root["require"] !== void 0;
+  const hasRun = root["run"] !== void 0;
+  if (hasRequire === hasRun) {
+    return fail(`"${id}" must declare exactly one of "require" or "run"`);
+  }
+  let requireAny;
+  let declaresEmit = null;
+  let runWhere;
+  let command;
+  if (hasRun) {
+    const run = root["run"];
+    if (!isRecord(run) || Object.keys(run).some((key) => key !== "where" && key !== "emit" && key !== "command")) {
+      return fail(`"${id}" run: must be a mapping of "where", "emit" and, for where: host, "command"`);
+    }
+    const where = run["where"];
+    if (where !== "ci" && where !== "host") {
+      return fail(`"${id}" run.where must be ci or host \u2014 the engine never executes customer code, so a host check runs on the factory host`);
+    }
+    const emit = run["emit"];
+    if (typeof emit !== "string" || !SLUG_PATTERN2.test(emit)) {
+      return fail(`"${id}" run.emit must name the emit (id characters only)`);
+    }
+    if (RESERVED_EMIT_NAMES.includes(emit)) {
+      return fail(
+        `"${id}" run.emit "${emit}" is reserved \u2014 \`outerlayer emit ${emit}\` is a subcommand, so a check cannot be emitted under that name`
+      );
+    }
+    if (where === "ci" && run["command"] !== void 0) {
+      return fail(`"${id}" run.command is only for run.where: host \u2014 a where: ci check runs in your own CI`);
+    }
+    if (where === "host") {
+      const rawCommand = run["command"];
+      if (rawCommand === void 0) {
+        return fail(`"${id}" run.where: host needs a "command" \u2014 the shell line the host runs`);
+      }
+      if (typeof rawCommand !== "string" || rawCommand.trim() === "" || rawCommand.length > MAX_COMMAND_LENGTH) {
+        return fail(`"${id}" run.command must be a non-empty string of at most ${MAX_COMMAND_LENGTH} characters`);
+      }
+      command = rawCommand.trim();
+      runWhere = "host";
+    }
+    declaresEmit = emit;
+    requireAny = [where === "host" ? { type: "emitted", name: emit, recorder: "host" } : { type: "emitted", name: emit }];
+  } else {
+    const parsed = parseRequire(root["require"], file.path, problems);
+    if (parsed === null) return null;
+    requireAny = parsed;
+  }
+  const declaredNeeds = parseNeeds(root["needs"], file.path, problems);
+  if (declaredNeeds === null) return null;
+  return {
+    def: {
+      id,
+      name,
+      row: row.trim(),
+      level,
+      whenPaths,
+      whenIssueType,
+      whenIssueLabels,
+      requireAny,
+      // Declared needs only — the author's own statement of what the rule
+      // reads. A session.ran alternative is guarded per-alternative at
+      // evaluation regardless, so an uncaptured command channel can never
+      // silently pass; deriving it here would additionally blind an `any:`
+      // whose OTHER alternative (an emitted result) could still answer.
+      needs: [...new Set(declaredNeeds)].sort(),
+      declaresEmit,
+      ...runWhere === void 0 ? {} : { runWhere },
+      ...command === void 0 ? {} : { command }
+    },
+    file: file.path,
+    validatorRefs: requireAny.flatMap((alt) => alt.type === "validator" ? [alt.id] : []),
+    emittedRefs: requireAny.flatMap((alt) => alt.type === "emitted" ? [alt.name] : [])
+  };
+}
+function resolveReferences(parsed, signalIds, problems) {
+  let surviving = parsed;
+  for (; ; ) {
+    const ids = new Set(surviving.map((p) => p.def.id));
+    const emits = new Set(
+      surviving.flatMap((p) => p.def.declaresEmit === null ? [] : [p.def.declaresEmit])
+    );
+    const next = surviving.filter((candidate) => {
+      for (const ref of candidate.validatorRefs) {
+        if (ref === candidate.def.id || !ids.has(ref) || signalIds.has(ref)) {
+          problems.push({
+            file: candidate.file,
+            problem: `"${candidate.def.id}" requires validator "${ref}" \u2014 ${signalIds.has(ref) ? "a signal can never satisfy a validation" : RETIRED_BUILTINS.has(ref) ? "that built-in check was retired" : "no such validator exists"}`
+          });
+          return false;
+        }
+      }
+      for (const name of candidate.emittedRefs) {
+        if (!emits.has(name)) {
+          problems.push({
+            file: candidate.file,
+            problem: `"${candidate.def.id}" requires emitted "${name}" but no validator declares emit: ${name}`
+          });
+          return false;
+        }
+      }
+      return true;
+    });
+    if (next.length === surviving.length) return dropCycles(next, problems);
+    surviving = next;
+  }
+}
+function dropCycles(parsed, problems) {
+  const byId = new Map(parsed.map((p) => [p.def.id, p]));
+  const state = /* @__PURE__ */ new Map();
+  const cyclic = /* @__PURE__ */ new Set();
+  const visit = (id, stack) => {
+    const entry = byId.get(id);
+    if (!entry || state.get(id) === "done") return;
+    if (state.get(id) === "visiting") {
+      for (const member of stack.slice(stack.indexOf(id))) cyclic.add(member);
+      return;
+    }
+    state.set(id, "visiting");
+    for (const ref of entry.validatorRefs) visit(ref, [...stack, id]);
+    state.set(id, "done");
+  };
+  for (const p of parsed) visit(p.def.id, []);
+  return parsed.filter((p) => {
+    if (!cyclic.has(p.def.id)) return true;
+    problems.push({
+      file: p.file,
+      problem: `"${p.def.id}" is part of a validator-reference cycle and cannot be evaluated`
+    });
+    return false;
+  });
+}
+function parsePolicy(policyFile, validatorFiles) {
+  var _a, _b, _c, _d, _e;
+  const problems = [];
+  const policy = policyFile ? parsePolicyFile(policyFile) : {
+    extendsOk: true,
+    overrides: {},
+    mergeGate: null,
+    review: null,
+    testProof: null,
+    criteriaMissing: null,
+    problems: []
+  };
+  problems.push(...policy.problems);
+  const mergeGate = (_a = policy.mergeGate) != null ? _a : "none";
+  const review = (_b = policy.review) != null ? _b : "required";
+  const testProof = (_c = policy.testProof) != null ? _c : "any";
+  const criteriaMissing = (_d = policy.criteriaMissing) != null ? _d : policyFile !== null ? "warn" : "off";
+  const parsed = [];
+  const signalIds = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const file of [...validatorFiles].sort((a, b) => a.path < b.path ? -1 : 1)) {
+    const result = parseCustomFile(file, problems);
+    if (result === null) continue;
+    const id = "signalId" in result ? result.signalId : result.def.id;
+    const collidesWithBuiltin = RETIRED_BUILTINS.has(id);
+    if (seenIds.has(id) || collidesWithBuiltin) {
+      problems.push({
+        file: file.path,
+        problem: collidesWithBuiltin ? `"${id}" collides with a built-in validator id` : `duplicate validator id "${id}"`
+      });
+      continue;
+    }
+    seenIds.add(id);
+    if ("signalId" in result) signalIds.add(id);
+    else parsed.push(result);
+  }
+  const emitOwners = /* @__PURE__ */ new Map();
+  const deduped = parsed.filter((p) => {
+    if (p.def.declaresEmit === null) return true;
+    const owner = emitOwners.get(p.def.declaresEmit);
+    if (owner === void 0) {
+      emitOwners.set(p.def.declaresEmit, p.def.id);
+      return true;
+    }
+    problems.push({
+      file: p.file,
+      problem: `"${p.def.id}" declares emit "${p.def.declaresEmit}" already declared by "${owner}"`
+    });
+    return false;
+  });
+  const resolved = resolveReferences(deduped, signalIds, problems);
+  const registry = policyFile !== null && policy.extendsOk ? REGISTRY_VALIDATORS.filter((def) => !seenIds.has(def.id)) : [];
+  const sorted = [...resolved.map((p) => p.def), ...registry].sort((a, b) => a.id < b.id ? -1 : 1);
+  const levels = {};
+  for (const custom of sorted) levels[custom.id] = custom.level;
+  for (const [id, level] of Object.entries(policy.overrides)) {
+    if (RETIRED_BUILTINS.has(id)) continue;
+    if (FREED_BUILTINS.has(id) && !(id in levels)) continue;
+    if (!(id in levels) && !signalIds.has(id)) {
+      problems.push({
+        file: (_e = policyFile == null ? void 0 : policyFile.path) != null ? _e : ".outerlayer/policy.yaml",
+        problem: `policy levels unknown validator "${id}"`
+      });
+      continue;
+    }
+    if (!signalIds.has(id)) levels[id] = level;
+  }
+  const customs = sorted.map(
+    (def) => levels[def.id] === def.level ? def : { ...def, level: levels[def.id] }
+  );
+  return { levels, customs, mergeGate, review, testProof, criteriaMissing, problems };
+}
 
-export { CONTEXT_PIN_FILENAME, CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_SOURCE_CONFIG_PATH, classifyTree, emitTree, generatedHeaderSource, normalizePath, normalizeRepoName, parseGoverns, parseOuterlayerConfig, splitRawFile };
+export { CONTEXT_PIN_FILENAME, CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_SOURCE_CONFIG_PATH, classifyTree, emitTree, generatedHeaderSource, normalizePath, normalizeRepoName, parseGoverns, parseOuterlayerConfig, parsePolicy, splitRawFile };