@attalabs/vinaya 0.24.1 → 0.25.0

package/dist/checks/bin/check-reader-resolvable-prose.js

@@ -4,7 +4,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/checks/bin/check-reader-resolvable-prose.ts
 import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
-import { join as join5 } from "node:path";
+import { extname, join as join5 } from "node:path";
 // ../../packages/aeg-core/src/gate-audience.ts
 var GATE_AUDIENCE = {
   "check-branch-topology": { shippedAs: "branch-topology", ring: 0 },
@@ -1939,13 +1939,18 @@ function parseInlineFieldList(section) {
 }
 // ../../packages/aeg-core/src/verdict-extraction.ts
 var HEAD_SHA_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Judged head:\s*([0-9a-f]{7,40})(?![A-Za-z0-9])/im;
-function firstThreeLines(comment) {
+var OBJECTIVES_VERSION_PATTERN = /^[ \t]*(?:\*{1,3}|_{1,3})?Objectives version:\s*([0-9a-f]{64})(?![A-Za-z0-9])/im;
+function firstFiveLines(comment) {
   return comment.split(`
-`).slice(0, 3).join(`
+`).slice(0, 5).join(`
 `);
 }
 function extractHeadSha(comment) {
-  const m = firstThreeLines(comment).match(HEAD_SHA_PATTERN);
+  const m = firstFiveLines(comment).match(HEAD_SHA_PATTERN);
+  return m ? m[1].toLowerCase() : null;
+}
+function extractObjectivesVersion(comment) {
+  const m = firstFiveLines(comment).match(OBJECTIVES_VERSION_PATTERN);
   return m ? m[1].toLowerCase() : null;
 }
 function extractVerdict(comments, valuePattern, missingLabel) {
@@ -1954,21 +1959,24 @@ function extractVerdict(comments, valuePattern, missingLabel) {
     return {
       value: `no ${missingLabel} pass was run before merge — DANGLING, see below`,
       headSha: null,
+      objectivesVersion: null,
       danglingNote: `no ${missingLabel} verdict comment found on this PR`
     };
   }
   const latest = candidates[candidates.length - 1];
-  const m = firstThreeLines(latest).match(valuePattern);
+  const m = firstFiveLines(latest).match(valuePattern);
   if (!m) {
     return {
-      value: `the most recent ${missingLabel} comment's VERDICT line is not within its first three lines — DANGLING, see below`,
+      value: `the most recent ${missingLabel} comment's VERDICT line is not within its first five lines — DANGLING, see below`,
       headSha: null,
-      danglingNote: `the most recent ${missingLabel} verdict comment carries a VERDICT-shaped line outside the first-three-line read window`
+      objectivesVersion: null,
+      danglingNote: `the most recent ${missingLabel} verdict comment carries a VERDICT-shaped line outside the first-five-line read window`
     };
   }
   return {
     value: m[1].toUpperCase().replace(/[_-]/g, " "),
     headSha: extractHeadSha(latest),
+    objectivesVersion: extractObjectivesVersion(latest),
     danglingNote: null
   };
 }
@@ -2325,8 +2333,105 @@ function overrideActive(opts) {
     return true;
   return false;
 }
-// ../../packages/aeg-core/src/premise-check.ts
+// ../../packages/aeg-core/src/objectives.ts
 import { createHash as createHash2 } from "node:crypto";
+var HEADING_RE = /^##[ \t]*Objectives[ \t]*$/im;
+var NEXT_HEADING_RE = /^##[ \t]/m;
+var OBJECTIVE_LINE_RE = /^O(\d+)\.[ \t]*(.*)$/;
+function hasBacktickedPath(text) {
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf("`", i);
+    if (start === -1)
+      return false;
+    const end = text.indexOf("`", start + 1);
+    if (end === -1)
+      return false;
+    if (text.slice(start + 1, end).includes("/"))
+      return true;
+    i = end + 1;
+  }
+  return false;
+}
+var MIN_WORDS_OUTSIDE_BACKTICKS = 3;
+function stripObjectiveBackticks(text) {
+  return text.replace(/`[^`\n]*`/g, " ");
+}
+function wordCount(text) {
+  return text.split(/\s+/).filter((w) => /[a-z]/i.test(w)).length;
+}
+function objectivesSectionText(body) {
+  const heading = HEADING_RE.exec(body);
+  if (!heading)
+    return null;
+  const afterHeading = body.slice(heading.index + heading[0].length);
+  const next = NEXT_HEADING_RE.exec(afterHeading);
+  return next ? afterHeading.slice(0, next.index) : afterHeading;
+}
+function hasObjectivesHeading(body) {
+  return HEADING_RE.test(body);
+}
+function objectivesOf(body) {
+  const section = objectivesSectionText(body);
+  if (section === null) {
+    return { ok: false, errors: ["no `## Objectives` heading found in the body."] };
+  }
+  const lines = section.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length === 0) {
+    return { ok: false, errors: ["the `## Objectives` section has no `O<n>.` lines."] };
+  }
+  const objectives = [];
+  const errors = [];
+  for (const line of lines) {
+    const m = OBJECTIVE_LINE_RE.exec(line);
+    if (!m) {
+      errors.push(`"${line}" is not a well-formed objective line — expected \`O<n>. <sentence>\`, e.g. \`O1. …\`.`);
+      continue;
+    }
+    const n = m[1];
+    const text = m[2].trim();
+    if (text.length === 0) {
+      errors.push(`O${n} has no sentence — every objective is one observable sentence.`);
+      continue;
+    }
+    if (hasBacktickedPath(text) && wordCount(stripObjectiveBackticks(text)) < MIN_WORDS_OUTSIDE_BACKTICKS) {
+      errors.push(`O${n} is little more than a file path — an objective states an observable outcome, never a bare path (the Brief Author maps it to files).`);
+      continue;
+    }
+    objectives.push({ id: `O${n}`, text });
+  }
+  for (let i = 0;i < objectives.length; i++) {
+    const expected = i + 1;
+    const actual = Number.parseInt(objectives[i].id.slice(1), 10);
+    if (actual !== expected) {
+      errors.push(`numbering is not contiguous from O1 — expected O${expected}, found ${objectives[i].id}.`);
+      break;
+    }
+  }
+  if (errors.length > 0)
+    return { ok: false, errors };
+  return { ok: true, objectives };
+}
+function normalizeText(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function objectivesVersion(objectives) {
+  const normalized = objectives.map((o) => `${o.id} ${normalizeText(o.text)}`).join(`
+`);
+  return createHash2("sha256").update(normalized).digest("hex");
+}
+function isIssueNotFoundError(err) {
+  const stderr = err?.stderr;
+  const haystack = [
+    err?.message ?? "",
+    typeof stderr === "string" ? stderr : stderr?.toString() ?? ""
+  ].join(`
+`);
+  return /could not resolve to an (?:issue|pull request)|\b404\b|not found/i.test(haystack);
+}
+
+// ../../packages/aeg-core/src/premise-check.ts
+import { createHash as createHash3 } from "node:crypto";
 var ASSERTION_KINDS = new Set(["contains", "absent", "sha256"]);
 function isPremiseHeader(line) {
   const stripped = line.replace(/[*#]/g, "").trim();
@@ -2397,7 +2502,7 @@ function checkPremises(assertions, fileReader) {
     } else if (a.kind === "absent" && content.includes(a.value)) {
       failures.push(`premise-check: ${a.path} now contains "${a.value}", but the brief pinned it absent — the premise has moved; re-dig before proceeding.`);
     } else if (a.kind === "sha256") {
-      const actual = createHash2("sha256").update(content).digest("hex");
+      const actual = createHash3("sha256").update(content).digest("hex");
       if (actual !== a.value.toLowerCase()) {
         failures.push(`premise-check: ${a.path} sha256 mismatch (brief pinned ${a.value}, file is now ${actual}) — the file changed since this brief was authored; re-dig before proceeding.`);
       }
@@ -2758,8 +2863,55 @@ function checkDefeatCases(prBody) {
     ]
   };
 }
+var PART_CITATION_RE = /Part\s+\d+\s*\(([^)]*)\)/gi;
+var OBJECTIVE_REF_RE = /O(\d+)/g;
+function citedObjectiveIds(section6) {
+  const ids = new Set;
+  for (const m of section6.matchAll(PART_CITATION_RE)) {
+    for (const r of m[1].matchAll(OBJECTIVE_REF_RE))
+      ids.add(Number.parseInt(r[1], 10));
+  }
+  return ids;
+}
+function checkObjectivesCopy(prBody, issueObjectives) {
+  const parsed = objectivesOf(prBody);
+  if (!parsed.ok) {
+    return { status: "fail", errors: parsed.errors.map((e) => `brief-validation objectives copy: ${e}`) };
+  }
+  if (objectivesVersion(parsed.objectives) !== objectivesVersion(issueObjectives)) {
+    return {
+      status: "fail",
+      errors: [
+        "brief-validation objectives copy: the brief's `## Objectives` section does not match the Issue's — copy the Issue's `## Objectives` section (aeg-root/roles/developer.md)."
+      ]
+    };
+  }
+  return { status: "pass", errors: [] };
+}
+function checkObjectivesCoverage(prBody) {
+  const parsed = objectivesOf(prBody);
+  if (!parsed.ok) {
+    return { status: "fail", errors: parsed.errors.map((e) => `brief-validation objectives coverage: ${e}`) };
+  }
+  const declaredIds = new Set(parsed.objectives.map((o) => Number.parseInt(o.id.slice(1), 10)));
+  const section6 = extractNumberedSection(prBody, 6) ?? "";
+  const cited = citedObjectiveIds(section6);
+  const maxDeclared = Math.max(...declaredIds, 0);
+  const errors = [];
+  for (const id of declaredIds) {
+    if (!cited.has(id)) {
+      errors.push(`brief-validation objectives coverage: O${id} is not cited by any Part in §6 — every objective must be cited by at least one Part.`);
+    }
+  }
+  for (const id of cited) {
+    if (!declaredIds.has(id)) {
+      errors.push(`brief-validation objectives coverage: a Part in §6 cites O${id}, but the Objectives section ends at O${maxDeclared}.`);
+    }
+  }
+  return errors.length === 0 ? { status: "pass", errors: [] } : { status: "fail", errors };
+}
 function checkBriefSections(prBody, readTier, options = {}) {
-  const { requireClosesN = true, consumersOf = () => [] } = options;
+  const { requireClosesN = true, consumersOf = () => [], issueObjectives } = options;
   const results = [
     checkTierField(prBody, readTier),
     checkTestPlan(prBody),
@@ -2777,6 +2929,7 @@ function checkBriefSections(prBody, readTier, options = {}) {
     checkCommandsCarryOutput(prBody),
     checkConsumerTests(prBody, consumersOf),
     checkDefeatCases(prBody),
+    ...issueObjectives !== undefined ? [checkObjectivesCopy(prBody, issueObjectives), checkObjectivesCoverage(prBody)] : [],
     ...requireClosesN ? [checkClosesN(prBody)] : []
   ];
   return { errors: results.flatMap((r) => r.errors) };
@@ -2975,14 +3128,14 @@ function checkSectionDensity(prBody, heading) {
     ]
   };
 }
-function checkSummaryDensity(prBody) {
-  return checkSectionDensity(prBody, "Summary");
+function checkDecisionsDensity(prBody) {
+  return checkSectionDensity(prBody, "Decisions");
 }
 function checkScopeDensity(prBody) {
   return checkSectionDensity(prBody, "Scope");
 }
 function checkPrReportDensity(prBody) {
-  const results = [checkSummaryDensity(prBody), checkScopeDensity(prBody)];
+  const results = [checkDecisionsDensity(prBody), checkScopeDensity(prBody)];
   return { errors: results.flatMap((r) => r.errors) };
 }
 // ../../packages/aeg-core/src/issue-validation.ts
@@ -3014,6 +3167,15 @@ function checkIssueRationale(body) {
   }
   return { status: errors.length > 0 ? "fail" : "pass", errors };
 }
+var OBJECTIVES_SINCE_ISSUE = 404;
+function checkIssueObjectives(body, issueNumber) {
+  if (issueNumber !== null && issueNumber < OBJECTIVES_SINCE_ISSUE)
+    return { status: "pass", errors: [] };
+  const result = objectivesOf(body);
+  if (result.ok)
+    return { status: "pass", errors: [] };
+  return { status: "fail", errors: result.errors.map((e) => `issue-validation objectives: ${e}`) };
+}
 function isTaskIssueLabelSet(labels) {
   return hasLabel("tranche", labels);
 }
@@ -3275,7 +3437,8 @@ function checkR1(issuesBySlug, grandfatheredIssues, registeredNames = []) {
         continue;
       const errors = [
         ...checkIssueRationale(issue.body).errors,
-        ...checkProjectsRegistered(issue.body, issue.labels, registeredNames).errors
+        ...checkProjectsRegistered(issue.body, issue.labels, registeredNames).errors,
+        ...checkIssueObjectives(issue.body, issue.number).errors
       ];
       if (errors.length === 0)
         continue;
@@ -3390,6 +3553,27 @@ function checkClosesN2(branch, prBody, trancheFiles, taskIssueRefs) {
   }
   return { ok: true, expectedIssue };
 }
+// ../../packages/aeg-core/src/archive-task.ts
+function closesRefs(text) {
+  return [...new Set([...text.matchAll(/Closes #(\d+)/gi)].map((m) => Number(m[1])))];
+}
+function extractIssue(body) {
+  const stripped = stripCode(body);
+  const bodyNums = closesRefs(stripped);
+  const anchored = anchoredRegion(stripped, "CLOSES");
+  if (anchored !== null) {
+    const anchorNums = closesRefs(anchored);
+    if (anchorNums.length === 0)
+      return { issue: null, extraIssues: bodyNums, outsideHeader: false };
+    const issue2 = anchorNums[0];
+    return { issue: issue2, extraIssues: bodyNums.filter((n) => n !== issue2), outsideHeader: false };
+  }
+  const headerNums = closesRefs(headerRegion(stripped));
+  if (bodyNums.length === 0)
+    return { issue: null, extraIssues: [], outsideHeader: false };
+  const issue = headerNums.length > 0 ? headerNums[0] : bodyNums[0];
+  return { issue, extraIssues: bodyNums.filter((n) => n !== issue), outsideHeader: headerNums.length === 0 };
+}
 // ../../packages/aeg-core/src/review-gate.ts
 function isBoundToHead(extraction, headSha) {
   if (!extraction.headSha)
@@ -3408,6 +3592,11 @@ function isBoundByPatchIdentity(extraction, headSha, patchIdOf) {
 function isBoundToPatch(extraction, headSha, patchIdOf) {
   return isBoundToHead(extraction, headSha) || isBoundByPatchIdentity(extraction, headSha, patchIdOf);
 }
+function isBoundToObjectives(extraction, currentVersion) {
+  if (currentVersion === null)
+    return true;
+  return extraction.objectivesVersion === currentVersion;
+}
 function checkReviewGate(input) {
   const principalAllowlist = input.principalAllowlist ?? PRINCIPAL_ALLOWLIST;
   const waived = isWaiverLabelActorVerified({
@@ -3434,7 +3623,9 @@ function checkReviewGate(input) {
   const securityClean = security.value === "PASS";
   const codeReviewBound = isBoundToPatch(codeReview, input.headSha, input.patchIdOf);
   const securityBound = isBoundToPatch(security, input.headSha, input.patchIdOf);
-  if (codeReviewClean && codeReviewBound && securityClean && securityBound && mechanicalChecksClean) {
+  const codeReviewObjectivesBound = isBoundToObjectives(codeReview, input.objectivesVersion);
+  const securityObjectivesBound = isBoundToObjectives(security, input.objectivesVersion);
+  if (codeReviewClean && codeReviewBound && codeReviewObjectivesBound && securityClean && securityBound && securityObjectivesBound && mechanicalChecksClean) {
     return {
       verdict: "pass",
       reason: `code-reviewer verdict is a clean APPROVE and security-review verdict is a clean PASS, both covering head ${input.headSha}, and every reported mechanical check is green.`,
@@ -3446,11 +3637,15 @@ function checkReviewGate(input) {
     problems.push(`code-reviewer verdict is not a clean APPROVE (found: ${codeReview.value})`);
   } else if (!codeReviewBound) {
     problems.push(`the newest code-review verdict covers ${codeReview.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
+  } else if (!codeReviewObjectivesBound) {
+    problems.push(`the newest code-review verdict was cast against objectives version ${codeReview.objectivesVersion ?? "none"}, the Issue's list is now ${input.objectivesVersion}`);
   }
   if (!securityClean) {
     problems.push(`security-review verdict is not a clean PASS (found: ${security.value})`);
   } else if (!securityBound) {
     problems.push(`the newest security-review verdict covers ${security.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
+  } else if (!securityObjectivesBound) {
+    problems.push(`the newest security-review verdict was cast against objectives version ${security.objectivesVersion ?? "none"}, the Issue's list is now ${input.objectivesVersion}`);
   }
   if (!mechanicalChecksClean) {
     problems.push(reportedMechanicalChecks.length === 0 ? "no mechanical checks have reported for this head yet" : `mechanical check(s) not green: ${reportedMechanicalChecks.filter((c) => c.bucket !== "pass").map((c) => `${c.name} (${c.bucket})`).join(", ")}`);
@@ -3686,55 +3881,20 @@ function checkG6(rows, registeredCheckNames) {
   }
   return { check: "G6", status: findings.length > 0 ? "fail" : "pass", findings };
 }
-// ../../packages/aeg-core/src/dead-branch-push-guard.ts
-function checkDeadBranchPush(input) {
-  const { branch, prState, prNumber } = input;
-  if (prState === "MERGED") {
-    return {
-      verdict: "refuse",
-      reason: `Branch \`${branch}\` already has a MERGED PR (#${prNumber}) — this branch's work is done. Push a new task branch instead of pushing onto an already-resolved one.`
-    };
-  }
-  if (prState === "CLOSED") {
-    return {
-      verdict: "refuse",
-      reason: `Branch \`${branch}\` has a CLOSED PR (#${prNumber}) that was never merged — pushing here would resurrect abandoned/rejected work. Open a new task branch instead.`
-    };
-  }
-  if (prState === "OPEN") {
-    return {
-      verdict: "allow",
-      reason: `Branch \`${branch}\` has an OPEN PR (#${prNumber}) — pushing more commits to it is normal.`
-    };
-  }
-  if (prState === "NONE") {
-    return {
-      verdict: "allow",
-      reason: `Branch \`${branch}\` has no PR yet — a brand-new task branch legitimately has none.`
-    };
-  }
-  return {
-    verdict: "allow",
-    reason: `Could not determine \`${branch}\`'s PR state (forge unreachable) — failing open rather than blocking the push on a transient issue.`
-  };
-}
-// ../../packages/aeg-core/src/baseline-capture.ts
-function captureBaseline(counts, capturedAt) {
-  return counts.map((c) => ({ tool: c.tool, findingCount: c.findingCount, capturedAt }));
+// ../../packages/aeg-core/src/reader-resolvable-prose.ts
+var PRODUCT_SLUG_SCOPE = [
+  "apps/cli/src",
+  ".github/workflows",
+  ".vinaya",
+  "apps/cli/README.md",
+  "packages/sources/README.md"
+];
+function isUnderOrEqual(path, prefix) {
+  return path === prefix || path.startsWith(`${prefix}/`);
 }
-function compareToBaseline(current, baseline) {
-  const perTool = current.map((c) => {
-    const baselineEntry = baseline.find((b) => b.tool === c.tool);
-    const baselineCount = baselineEntry ? baselineEntry.findingCount : c.findingCount;
-    return { tool: c.tool, baseline: baselineCount, current: c.findingCount, delta: c.findingCount - baselineCount };
-  });
-  return {
-    withinBudget: perTool.every((t) => t.delta <= 0),
-    delta: perTool.reduce((sum, t) => sum + t.delta, 0),
-    perTool
-  };
+function isProductScopeFile(path) {
+  return PRODUCT_SLUG_SCOPE.some((prefix) => isUnderOrEqual(path, prefix));
 }
-// ../../packages/aeg-core/src/reader-resolvable-prose.ts
 var SHIPS_PREFIX = "aeg-root/";
 function shipsArchivePrefix(shipsPrefix) {
   return `${shipsPrefix}tranches/completed/`;
@@ -3754,6 +3914,8 @@ function classifyProseFile(path, readerFacingPrefix, readerFacingSuffix, shipsPr
   }
   if (isSpecFile2(path) || isClaudeMdFile(path))
     return "internal";
+  if (isProductScopeFile(path))
+    return "product";
   return null;
 }
 var SWEPT_CLASSES = new Set(["ships", "reader-facing"]);
@@ -3766,6 +3928,9 @@ function stripNonProse(path, content) {
   }
   return content;
 }
+function stripNonProseForProduct(path, content) {
+  return path.endsWith(".md") ? stripNonProse(path, content) : content;
+}
 function lineAt(content, index) {
   let line = 1;
   for (let i = 0;i < index; i++) {
@@ -3790,12 +3955,19 @@ function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuff
     { pattern: TRANCHE_SLUG_VN_PATTERN, what: "an internal tranche slug" },
     ...legacyPattern ? [{ pattern: legacyPattern, what: "an internal tranche slug", group: 2 }] : []
   ];
+  const productPatterns = [
+    { pattern: TRANCHE_SLUG_VN_PATTERN, what: "an internal tranche slug in product code" }
+  ];
   for (const file of files) {
     const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix, shipsPrefix);
-    if (!cls || !SWEPT_CLASSES.has(cls))
+    if (!cls || cls === "internal")
       continue;
-    const scrubbed = stripNonProse(file.path, file.content);
-    for (const { pattern, what, group } of patterns) {
+    if (cls !== "product" && !SWEPT_CLASSES.has(cls))
+      continue;
+    const blocking = cls === "product";
+    const scrubbed = blocking ? stripNonProseForProduct(file.path, file.content) : stripNonProse(file.path, file.content);
+    const patternsToRun = blocking ? productPatterns : patterns;
+    for (const { pattern, what, group } of patternsToRun) {
       pattern.lastIndex = 0;
       let match = pattern.exec(scrubbed);
       while (match !== null) {
@@ -3803,7 +3975,8 @@ function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuff
         findings.push({
           file: file.path,
           line: lineAt(scrubbed, match.index),
-          message: `references ${what} ("${cited}") a reader outside this repo's tracker cannot resolve`
+          message: `references ${what} ("${cited}") a reader outside this repo's tracker cannot resolve`,
+          blocking
         });
         match = pattern.exec(scrubbed);
       }
@@ -3853,7 +4026,8 @@ function checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, read
       findings.push({
         file: file.path,
         line,
-        message: `uses coined term "${term}" without defining it inline or linking the glossary`
+        message: `uses coined term "${term}" without defining it inline or linking the glossary`,
+        blocking: false
       });
     }
   }
@@ -3876,6 +4050,7 @@ function parseGlossaryTerms(glossaryContent) {
   }
   return terms;
 }
+
 // ../../packages/aeg-core/src/quoted-command.ts
 var QUOTED_COMMAND_SHIPS_PREFIX = "aeg-root/";
 var QUOTED_COMMAND_SWEPT_CLASSES = new Set(["ships", "reader-facing"]);
@@ -3970,6 +4145,54 @@ function evaluateCitedQuotes(citedQuotes, citedFileContents) {
   }
   return findings;
 }
+// ../../packages/aeg-core/src/dead-branch-push-guard.ts
+function checkDeadBranchPush(input) {
+  const { branch, prState, prNumber } = input;
+  if (prState === "MERGED") {
+    return {
+      verdict: "refuse",
+      reason: `Branch \`${branch}\` already has a MERGED PR (#${prNumber}) — this branch's work is done. Push a new task branch instead of pushing onto an already-resolved one.`
+    };
+  }
+  if (prState === "CLOSED") {
+    return {
+      verdict: "refuse",
+      reason: `Branch \`${branch}\` has a CLOSED PR (#${prNumber}) that was never merged — pushing here would resurrect abandoned/rejected work. Open a new task branch instead.`
+    };
+  }
+  if (prState === "OPEN") {
+    return {
+      verdict: "allow",
+      reason: `Branch \`${branch}\` has an OPEN PR (#${prNumber}) — pushing more commits to it is normal.`
+    };
+  }
+  if (prState === "NONE") {
+    return {
+      verdict: "allow",
+      reason: `Branch \`${branch}\` has no PR yet — a brand-new task branch legitimately has none.`
+    };
+  }
+  return {
+    verdict: "allow",
+    reason: `Could not determine \`${branch}\`'s PR state (forge unreachable) — failing open rather than blocking the push on a transient issue.`
+  };
+}
+// ../../packages/aeg-core/src/baseline-capture.ts
+function captureBaseline(counts, capturedAt) {
+  return counts.map((c) => ({ tool: c.tool, findingCount: c.findingCount, capturedAt }));
+}
+function compareToBaseline(current, baseline) {
+  const perTool = current.map((c) => {
+    const baselineEntry = baseline.find((b) => b.tool === c.tool);
+    const baselineCount = baselineEntry ? baselineEntry.findingCount : c.findingCount;
+    return { tool: c.tool, baseline: baselineCount, current: c.findingCount, delta: c.findingCount - baselineCount };
+  });
+  return {
+    withinBudget: perTool.every((t) => t.delta <= 0),
+    delta: perTool.reduce((sum, t) => sum + t.delta, 0),
+    perTool
+  };
+}
 // ../../packages/aeg-core/src/retired-vocabulary.ts
 var RETIRED_PATTERNS = [
   String.raw`\bD-[0-9]{3}\b`,
@@ -4439,6 +4662,222 @@ function findWorkspaceEscapes(files, knownPaths, workspaceDirs = DEFAULT_WORKSPA
   }
   return findings;
 }
+// ../../packages/aeg-core/src/log/schema.ts
+import { z } from "zod";
+var ROLE_VALUES = [
+  "planner",
+  "brief-author",
+  "developer",
+  "code-reviewer",
+  "security",
+  "principal",
+  "archivist",
+  "architect"
+];
+var RoleSchema = z.enum(ROLE_VALUES);
+var HOST_VALUES = ["hook", "ci", "cli", "loop"];
+var HostSchema = z.enum(HOST_VALUES);
+var RUN_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
+var HeaderMetaSchema = z.object({
+  schema: z.literal(1),
+  ts: z.string(),
+  run_id: z.string().regex(RUN_ID_PATTERN),
+  seq: z.number().int().nonnegative(),
+  repo: z.string().nullable(),
+  vinaya: z.string(),
+  doctrine: z.string(),
+  host: HostSchema,
+  machine: z.string()
+}).strict();
+var SubjectSchema = z.object({
+  issue: z.number().int().nullable(),
+  pr: z.number().int().optional(),
+  sha: z.string().optional(),
+  role: z.union([RoleSchema, z.literal("unattributed")]),
+  round: z.number().int().optional(),
+  objectives_version: z.string().optional()
+}).strict();
+var HeaderSchema = z.object({
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema
+}).strict();
+var envelopeTail = {
+  duration_ms: z.number().nonnegative().optional(),
+  payload: z.object({}).strict()
+};
+var DispatchOutcomeSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("pr_opened"), pr: z.number().int(), head: z.string() }).strict(),
+  z.object({
+    type: z.literal("round_pushed"),
+    pr: z.number().int(),
+    head: z.string(),
+    comment_id: z.number().int()
+  }).strict(),
+  z.object({
+    type: z.literal("verdict"),
+    verdict: z.enum(["APPROVE", "REQUEST CHANGES", "PASS", "FAIL"]),
+    head: z.string(),
+    comment_id: z.number().int(),
+    objectives: z.array(z.object({ id: z.string(), met: z.boolean() }).strict()),
+    findings: z.array(z.object({ id: z.string(), severity: z.string(), state: z.string().optional() }).strict())
+  }).strict(),
+  z.object({
+    type: z.literal("escalation"),
+    class: z.enum(["authority", "strategy", "product"]),
+    comment_id: z.number().int()
+  }).strict(),
+  z.object({ type: z.literal("brief"), comment_id: z.number().int(), hash: z.string() }).strict(),
+  z.object({ type: z.literal("plan"), issues: z.array(z.number().int()) }).strict(),
+  z.object({ type: z.literal("archive"), provenance_comment_id: z.number().int() }).strict()
+]);
+var dispatchShared = {
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema,
+  kind: z.literal("dispatch"),
+  ...envelopeTail,
+  target_role: RoleSchema,
+  model: z.string(),
+  round: z.number().int().optional(),
+  effect_id: z.string()
+};
+var DispatchEventSchema = z.discriminatedUnion("event", [
+  z.object({ ...dispatchShared, event: z.literal("dispatched"), prompt_hash: z.string() }).strict(),
+  z.object({
+    ...dispatchShared,
+    event: z.literal("outcome_received"),
+    outcome: DispatchOutcomeSchema,
+    usage: z.object({ input: z.number().nonnegative(), output: z.number().nonnegative() }).strict().nullable()
+  }).strict(),
+  z.object({
+    ...dispatchShared,
+    event: z.literal("dispatch_failed"),
+    reason: z.enum(["timeout", "crash", "refused", "unattributed_write"])
+  }).strict()
+]);
+var loopShared = {
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema,
+  kind: z.literal("dev_review_loop"),
+  ...envelopeTail,
+  loop_id: z.string()
+};
+var DevReviewLoopEventSchema = z.discriminatedUnion("event", [
+  z.object({
+    ...loopShared,
+    event: z.literal("loop_started"),
+    task: z.number().int(),
+    policy: z.object({
+      max_rounds: z.number().int().nonnegative(),
+      reviewers: z.array(RoleSchema),
+      models: z.record(RoleSchema, z.string())
+    }).strict()
+  }).strict(),
+  z.object({ ...loopShared, event: z.literal("round_started"), round: z.number().int(), base_head: z.string() }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("gate_result_read"),
+    round: z.number().int(),
+    head: z.string(),
+    green: z.boolean()
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("verdicts_read"),
+    round: z.number().int(),
+    head: z.string(),
+    all_approve: z.boolean(),
+    blockers: z.number().int().nonnegative()
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("findings_compared"),
+    round: z.number().int(),
+    open: z.array(z.string()),
+    resolved: z.array(z.string()),
+    new: z.array(z.string()),
+    recurring: z.array(z.string())
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("stop_condition_met"),
+    round: z.number().int(),
+    condition: z.enum([
+      "green",
+      "max_rounds",
+      "no_progress",
+      "escalated",
+      "principal_stop",
+      "confidence",
+      "reappearance"
+    ])
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("paused"),
+    round: z.number().int(),
+    reason: z.enum(["escalation", "principal_item", "refreeze_needed"])
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("resumed"),
+    round: z.number().int(),
+    by: z.literal("principal")
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("round_ended"),
+    round: z.number().int(),
+    base_head: z.string(),
+    head: z.string(),
+    files_changed: z.number().int().nonnegative(),
+    insertions: z.number().int().nonnegative(),
+    deletions: z.number().int().nonnegative(),
+    wall_ms: z.number().nonnegative(),
+    outcome: z.enum(["green", "changes_requested", "escalated"])
+  }).strict(),
+  z.object({
+    ...loopShared,
+    event: z.literal("journal_finalized"),
+    rounds: z.number().int().nonnegative(),
+    total_wall_ms: z.number().nonnegative(),
+    time_to_green_ms: z.number().nonnegative().nullable(),
+    files_changed_total: z.number().int().nonnegative(),
+    final_head: z.string(),
+    result: z.enum(["merged_ready", "stopped"])
+  }).strict()
+]);
+var ForgeOpSchema = z.enum([
+  "pr.create",
+  "pr.comment",
+  "pr.body.replace",
+  "pr.refreeze",
+  "issue.create",
+  "issue.edit",
+  "issue.comment",
+  "milestone.create",
+  "milestone.edit",
+  "milestone.close",
+  "label.add",
+  "label.remove"
+]);
+var ForgeWriteTargetSchema = z.object({
+  issue: z.number().int().optional(),
+  pr: z.number().int().optional()
+}).strict();
+var forgeWriteShared = {
+  meta: HeaderMetaSchema,
+  subject: SubjectSchema,
+  kind: z.literal("forge_write"),
+  ...envelopeTail,
+  op: ForgeOpSchema,
+  target: ForgeWriteTargetSchema
+};
+var ForgeWriteEventSchema = z.discriminatedUnion("event", [
+  z.object({ ...forgeWriteShared, event: z.literal("validated") }).strict(),
+  z.object({ ...forgeWriteShared, event: z.literal("refused"), reason: z.string() }).strict(),
+  z.object({ ...forgeWriteShared, event: z.literal("written"), comment_ids: z.array(z.string()) }).strict()
+]);
+var LogEventSchema = z.union([DispatchEventSchema, DevReviewLoopEventSchema, ForgeWriteEventSchema]);
 // src/commands/doctrine.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
@@ -4497,27 +4936,27 @@ import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname3, join as join3, resolve } from "node:path";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/lib/agent-vendors.ts
 var AGENT_VENDORS = ["skills", "claude", "gemini"];
 
 // src/lib/config.ts
-var EnvEntrySchema = z.union([
-  z.literal(true),
-  z.object({ optional: z.literal(true) }),
-  z.object({ anyOf: z.array(z.string()).min(2) }),
-  z.string()
+var EnvEntrySchema = z2.union([
+  z2.literal(true),
+  z2.object({ optional: z2.literal(true) }),
+  z2.object({ anyOf: z2.array(z2.string()).min(2) }),
+  z2.string()
 ]);
-var CheckEntrySchema = z.object({
-  run: z.string(),
-  scope: z.enum(["diff", "full"]),
-  include: z.array(z.string()).optional(),
-  args: z.array(z.string()).optional(),
-  timeoutMs: z.number().optional(),
-  env: z.record(z.string(), EnvEntrySchema).optional(),
-  requiresOpenPr: z.boolean().optional(),
-  ownWorkflow: z.boolean().optional()
+var CheckEntrySchema = z2.object({
+  run: z2.string(),
+  scope: z2.enum(["diff", "full"]),
+  include: z2.array(z2.string()).optional(),
+  args: z2.array(z2.string()).optional(),
+  timeoutMs: z2.number().optional(),
+  env: z2.record(z2.string(), EnvEntrySchema).optional(),
+  requiresOpenPr: z2.boolean().optional(),
+  ownWorkflow: z2.boolean().optional()
 }).superRefine((entry2, ctx) => {
   if (!entry2.env)
     return;
@@ -4527,22 +4966,22 @@ var CheckEntrySchema = z.object({
     const members = value.anyOf;
     if (new Set(members).size !== members.length) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: `env.${key}.anyOf has duplicate members`,
         path: ["env", key, "anyOf"]
       });
     }
     if (!members.includes(key)) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: `env.${key}.anyOf must include "${key}" itself as a member`,
         path: ["env", key, "anyOf"]
       });
     }
   }
 });
-var RoleEntrySchema = z.object({
-  contract: z.string().refine((p) => p.includes("/"), {
+var RoleEntrySchema = z2.object({
+  contract: z2.string().refine((p) => p.includes("/"), {
     message: 'must be a path (contain at least one "/"), not a bare filename'
   })
 });
@@ -4561,19 +5000,21 @@ var BRIEF_BUILTINS = [
   "closesN",
   "premiseCoverage",
   "issueRationale",
+  "objectives",
+  "briefSections",
   "milestoneShape"
 ];
-var BriefSectionSchema = z.union([
-  z.object({ builtin: z.enum(BRIEF_BUILTINS) }),
-  z.object({ heading: z.string().min(1), name: z.string().optional() }),
-  z.object({ field: z.string().min(1), name: z.string().optional() }),
-  z.object({ phrase: z.string().min(1), name: z.string().optional() })
+var BriefSectionSchema = z2.union([
+  z2.object({ builtin: z2.enum(BRIEF_BUILTINS) }),
+  z2.object({ heading: z2.string().min(1), name: z2.string().optional() }),
+  z2.object({ field: z2.string().min(1), name: z2.string().optional() }),
+  z2.object({ phrase: z2.string().min(1), name: z2.string().optional() })
 ]);
-var BriefSchemaSchema = z.object({
-  pr: z.object({ sections: z.array(BriefSectionSchema) }).optional(),
-  issue: z.object({ sections: z.array(BriefSectionSchema) }).optional(),
-  milestone: z.object({ sections: z.array(BriefSectionSchema) }).optional(),
-  ack: z.array(z.enum(BRIEF_BUILTINS)).optional()
+var BriefSchemaSchema = z2.object({
+  pr: z2.object({ sections: z2.array(BriefSectionSchema) }).optional(),
+  issue: z2.object({ sections: z2.array(BriefSectionSchema) }).optional(),
+  milestone: z2.object({ sections: z2.array(BriefSectionSchema) }).optional(),
+  ack: z2.array(z2.enum(BRIEF_BUILTINS)).optional()
 });
 function isSafeRepoRelPath(p) {
   if (p.length === 0)
@@ -4582,7 +5023,7 @@ function isSafeRepoRelPath(p) {
     return false;
   return p.split(/[\\/]/).every((seg) => seg !== ".." && seg !== "");
 }
-var SafeRepoRelPath = z.string().refine(isSafeRepoRelPath, {
+var SafeRepoRelPath = z2.string().refine(isSafeRepoRelPath, {
   message: "must be a repo-root-relative path with no `..` segment or absolute root"
 });
 var CANONICAL_HOOK_BLOCK_PREFIXES = [".git/", ".husky/", ".vinaya/hooks/", ".claude/hooks/"];
@@ -4592,22 +5033,22 @@ function isCanonicalHookBlockPath(p) {
 var ManagedHookBlockPath = SafeRepoRelPath.refine(isCanonicalHookBlockPath, {
   message: `must start with one of ${CANONICAL_HOOK_BLOCK_PREFIXES.join(", ")} (byte-exact, case-sensitive)`
 });
-var ManagedBlockRecordSchema = z.object({
+var ManagedBlockRecordSchema = z2.object({
   path: ManagedHookBlockPath,
-  marker: z.string(),
-  comment: z.enum(["hash", "html"])
+  marker: z2.string(),
+  comment: z2.enum(["hash", "html"])
 });
-var ManagedManifestSchema = z.object({
-  version: z.number().int().positive(),
-  files: z.array(SafeRepoRelPath),
-  blocks: z.array(ManagedBlockRecordSchema),
-  labels: z.array(z.string()),
-  agents: z.array(z.enum(AGENT_VENDORS)).optional()
+var ManagedManifestSchema = z2.object({
+  version: z2.number().int().positive(),
+  files: z2.array(SafeRepoRelPath),
+  blocks: z2.array(ManagedBlockRecordSchema),
+  labels: z2.array(z2.string()),
+  agents: z2.array(z2.enum(AGENT_VENDORS)).optional()
 });
-var ProjectEntrySchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1).optional(),
-  path: z.string().min(1).optional()
+var ProjectEntrySchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().min(1).optional(),
+  path: z2.string().min(1).optional()
 });
 function parseTokensCollectDeclaration(value) {
   const m = value.trim().match(/^(\S+)\s+(\S+)$/);
@@ -4618,31 +5059,35 @@ function parseTokensCollectDeclaration(value) {
     return null;
   return { interpreter, script };
 }
-var VinayaConfigSchema = z.object({
-  rings: z.object({
-    ring1_forgeWriteInterception: z.boolean(),
-    ring2_asyncAudits: z.boolean()
+var VinayaConfigSchema = z2.object({
+  rings: z2.object({
+    ring1_forgeWriteInterception: z2.boolean(),
+    ring2_asyncAudits: z2.boolean()
   }).optional(),
-  checks: z.record(z.string(), CheckEntrySchema).optional(),
-  roles: z.record(z.string(), RoleEntrySchema).optional(),
+  checks: z2.record(z2.string(), CheckEntrySchema).optional(),
+  roles: z2.record(z2.string(), RoleEntrySchema).optional(),
   briefSchema: BriefSchemaSchema.optional(),
   managed: ManagedManifestSchema.optional(),
-  principals: z.array(z.string()).min(1).optional(),
-  releaseActor: z.string().min(1).optional(),
-  ci: z.object({ setup: z.string().min(1) }).optional(),
-  tokens: z.object({
-    collect: z.string().min(1).refine((v) => parseTokensCollectDeclaration(v) !== null, {
+  principals: z2.array(z2.string()).min(1).optional(),
+  releaseActor: z2.string().min(1).optional(),
+  ci: z2.object({ setup: z2.string().min(1) }).optional(),
+  tokens: z2.object({
+    collect: z2.string().min(1).refine((v) => parseTokensCollectDeclaration(v) !== null, {
       message: 'tokens.collect must be exactly "<interpreter> <repo-relative-script-path>" — two whitespace-separated tokens, no flags, no shell syntax, no quoting'
     })
   }).optional(),
-  blastRadius: z.object({ extraDomains: z.array(z.string()).optional() }).optional(),
-  proseGates: z.object({
-    doctrineRoot: z.string().min(1).optional(),
-    readerFacingPrefix: z.string().min(1).optional(),
-    readerFacingSuffix: z.string().min(1).optional(),
-    legacySlugDir: z.string().min(1).optional()
+  blastRadius: z2.object({ extraDomains: z2.array(z2.string()).optional() }).optional(),
+  proseGates: z2.object({
+    doctrineRoot: z2.string().min(1).optional(),
+    readerFacingPrefix: z2.string().min(1).optional(),
+    readerFacingSuffix: z2.string().min(1).optional(),
+    legacySlugDir: z2.string().min(1).optional()
   }).optional(),
-  projects: z.array(ProjectEntrySchema).optional()
+  projects: z2.array(ProjectEntrySchema).optional(),
+  dispatch: z2.object({
+    timeoutMs: z2.number().int().positive().optional(),
+    agent: z2.enum(["claude", "codex", "gemini"]).optional()
+  }).optional()
 });
 var GLOBAL_VINAYA_HOME = join3(homedir(), ".vinaya");
 var GLOBAL_CONFIG_PATH = join3(GLOBAL_VINAYA_HOME, "config.json");
@@ -4972,6 +5417,32 @@ function collect(dir, out = []) {
 function readAll(paths) {
   return paths.map((p) => ({ path: p, content: readFileSync4(p, "utf8") }));
 }
+var PRODUCT_SCOPE_EXTENSIONS = new Set([".ts", ".tsx", ".yml", ".md"]);
+function collectProductScopeFiles(root) {
+  const out = [];
+  for (const prefix of PRODUCT_SLUG_SCOPE) {
+    const abs = join5(root, prefix);
+    let isDir;
+    try {
+      isDir = statSync(abs).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      for (const f of collect(abs)) {
+        const rel = f.slice(root.length + 1);
+        if (PRODUCT_SCOPE_EXTENSIONS.has(extname(rel)))
+          out.push(rel);
+      }
+    } else if (PRODUCT_SCOPE_EXTENSIONS.has(extname(prefix))) {
+      out.push(prefix);
+    }
+  }
+  return out;
+}
+function readProductFiles(root, relPaths) {
+  return relPaths.map((rel) => ({ path: rel, content: readFileSync4(join5(root, rel), "utf8") }));
+}
 function legacySlugs(legacySlugDir) {
   if (!existsSync4(legacySlugDir))
     return { slugs: [], dormant: true };
@@ -4998,7 +5469,10 @@ function main() {
   const shipsPrefix = `${DOCTRINE_ROOT}/`;
   const shipsPaths = collect(DOCTRINE_ROOT).filter((p) => p.endsWith(".md"));
   const readerFacingPaths = READER_FACING_ACTIVE && READER_FACING_SUFFIX !== null ? collect(READER_FACING_PREFIX).filter((p) => p.endsWith(READER_FACING_SUFFIX)) : [];
-  const files = readAll([...shipsPaths, ...readerFacingPaths]);
+  const productRoot = repoRoot() ?? process.cwd();
+  const productRelPaths = collectProductScopeFiles(productRoot);
+  const productFiles = readProductFiles(productRoot, productRelPaths);
+  const files = [...readAll([...shipsPaths, ...readerFacingPaths]), ...productFiles];
   const glossaryPath = join5(DOCTRINE_ROOT, "glossary.md");
   const glossaryTerms = existsSync4(glossaryPath) ? parseGlossaryTerms(readFileSync4(glossaryPath, "utf8")) : [];
   const legacySlugDir = LEGACY_SLUG_DIR ?? `${DOCTRINE_ROOT}/tranches/completed`;
@@ -5007,18 +5481,21 @@ function main() {
   const readerFacingSuffix = READER_FACING_ACTIVE && READER_FACING_SUFFIX !== null ? READER_FACING_SUFFIX : "/page.tsx";
   const findings = checkReaderResolvableProse(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix, slugs, shipsPrefix);
   const reportable = findingsInThisDiff(findings);
-  console.log(`${CHECK_NAME}: doctrine root "${DOCTRINE_ROOT}"; reader-facing class ${READER_FACING_ACTIVE ? "ran" : "dormant — proseGates.readerFacingPrefix/readerFacingSuffix not both set"}; ` + `legacy-slug class ${legacySlugsDormant ? `dormant — ${legacySlugDir} is absent` : `ran (${slugs.length} slug(s))`}; ` + `${findings.length} finding(s) swept, ${reportable.length} in this diff`);
+  console.log(`${CHECK_NAME}: doctrine root "${DOCTRINE_ROOT}"; reader-facing class ${READER_FACING_ACTIVE ? "ran" : "dormant — proseGates.readerFacingPrefix/readerFacingSuffix not both set"}; ` + `legacy-slug class ${legacySlugsDormant ? `dormant — ${legacySlugDir} is absent` : `ran (${slugs.length} slug(s))`}; ` + `product class ran (${productRelPaths.length} file(s) swept); ` + `${findings.length} finding(s) swept, ${reportable.length} in this diff`);
+  let hasBlocking = false;
   for (const finding of reportable) {
+    if (finding.blocking)
+      hasBlocking = true;
     emitCheckError({
       schema: CHECK_SCHEMA_VERSION,
       check: CHECK_NAME,
-      severity: "warning",
+      severity: finding.blocking ? "error" : "warning",
       message: `${finding.file}:${finding.line}: ${finding.message}`,
       file: finding.file,
       line: finding.line,
-      agent_recovery_prompt: finding.message.includes("coined term") ? "This page uses AEG/Vinaya-internal vocabulary a first-time reader cannot resolve. Either define the term " + 'inline (the same "Term — one-sentence definition" shape the glossary uses) at its first use on this page, ' + "or link to the glossary. Do not simply delete the word if the sentence needs it." : "This doctrine or page cites a forge number or an internal tranche slug the reader has no tracker to " + "resolve. Rewrite the sentence to state the fact plainly instead of pointing at the citation — say what " + "was learned/decided, not where it was logged."
+      agent_recovery_prompt: finding.message.includes("coined term") ? "This page uses AEG/Vinaya-internal vocabulary a first-time reader cannot resolve. Either define the term " + 'inline (the same "Term — one-sentence definition" shape the glossary uses) at its first use on this page, ' + "or link to the glossary. Do not simply delete the word if the sentence needs it." : finding.blocking ? "This product-code file cites an internal tranche slug a reader outside this repo cannot resolve " + "(Issue #435 — reader-resolvable-prose.ts PRODUCT_SLUG_SCOPE). Remove the citation or rewrite the " + "comment/doc to state the fact plainly instead of pointing at the tranche that did it. This finding " + "blocks the push and CI." : "This doctrine or page cites a forge number or an internal tranche slug the reader has no tracker to " + "resolve. Rewrite the sentence to state the fact plainly instead of pointing at the citation — say what " + "was learned/decided, not where it was logged."
     });
   }
-  process.exit(0);
+  process.exit(hasBlocking ? 1 : 0);
 }
 main();