@attalabs/vinaya 0.22.0 → 0.23.0

package/dist/checks/bin/check-changeset-coverage.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/checks/bin/check-changeset-coverage.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2, relative } from "node:path";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3, relative as relative2 } from "node:path";
 // ../../packages/aeg-core/src/gate-audience.ts
 var GATE_AUDIENCE = {
   "check-branch-topology": { shippedAs: "branch-topology", ring: 0 },
@@ -212,17 +214,18 @@ function splitIds(raw) {
     return [];
   return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0 && !isEmptyMarker(s) && ID_TOKEN.test(s));
 }
-function resolveIds(raw, lastSlug) {
+function resolveIds(raw) {
   const ids = splitIds(raw);
   const resolved = [];
+  let lastSlug = null;
   for (const id of ids) {
     const qualified = id.match(SLUG_QUALIFIED_ID);
     if (qualified) {
-      lastSlug.current = qualified[1] ?? null;
+      lastSlug = qualified[1] ?? null;
       resolved.push(id);
-    } else if (lastSlug.current) {
-      resolved.push(`${lastSlug.current} ${id}`);
-      lastSlug.current = null;
+    } else if (lastSlug) {
+      resolved.push(`${lastSlug} ${id}`);
+      lastSlug = null;
     } else {
       resolved.push(id);
     }
@@ -242,12 +245,7 @@ function parseRationaleDeps(body) {
   const section = extractSection(body);
   const dependsOn = [];
   const conflictsWith = [];
-  let current = null;
   const assignedFields = new Set;
-  const lastSlugByField = {
-    dependsOn: { current: null },
-    conflictsWith: { current: null }
-  };
   const spanPattern = /`([^`]*)`/g;
   let match = spanPattern.exec(section);
   while (match !== null) {
@@ -257,13 +255,9 @@ function parseRationaleDeps(body) {
       const field = labelMatch[1]?.toLowerCase() === "conflicts-with" ? "conflictsWith" : "dependsOn";
       if (!assignedFields.has(field)) {
         assignedFields.add(field);
-        current = field;
-        const ids = resolveIds(labelMatch[2] ?? "", lastSlugByField[field]);
+        const ids = resolveIds(labelMatch[2] ?? "");
         pushUnique(field === "dependsOn" ? dependsOn : conflictsWith, ids);
       }
-    } else if (current) {
-      const ids = resolveIds(content, lastSlugByField[current]);
-      pushUnique(current === "dependsOn" ? dependsOn : conflictsWith, ids);
     }
     match = spanPattern.exec(section);
   }
@@ -1728,6 +1722,48 @@ function splitTableRow(row) {
     parts.pop();
   return parts.map((p) => p.split(PLACEHOLDER).join("|"));
 }
+// ../../packages/aeg-core/src/blast-radius-domains.ts
+function resolveWorkspaceEntry(entry2, listDirs) {
+  if (entry2.endsWith("/*")) {
+    const baseDir = entry2.slice(0, -2);
+    return listDirs(baseDir).map((name) => `${baseDir}/${name}`);
+  }
+  if (entry2.includes("*"))
+    return [];
+  return [entry2];
+}
+// ../../packages/aeg-core/src/consumer-enumeration.ts
+function deriveWorkspaceMemberDirs(workspaces, listDirs) {
+  const positive = workspaces.filter((entry2) => !entry2.startsWith("!"));
+  const negative = workspaces.filter((entry2) => entry2.startsWith("!")).map((entry2) => entry2.slice(1));
+  const excluded = new Set;
+  for (const entry2 of negative) {
+    for (const member of resolveWorkspaceEntry(entry2, listDirs))
+      excluded.add(member);
+  }
+  const members = new Set;
+  for (const entry2 of positive) {
+    for (const member of resolveWorkspaceEntry(entry2, listDirs)) {
+      if (!excluded.has(member))
+        members.add(member);
+    }
+  }
+  return [...members].sort();
+}
+function buildConsumersOf(workspaces, listDirs, readManifest) {
+  const members = deriveWorkspaceMemberDirs(workspaces, listDirs);
+  return (pkg) => {
+    const target = `@attalabs/${pkg}`;
+    return members.filter((dir) => {
+      if (dir === `packages/${pkg}`)
+        return false;
+      const manifest = readManifest(dir);
+      if (!manifest)
+        return false;
+      return target in (manifest.dependencies ?? {}) || target in (manifest.devDependencies ?? {});
+    });
+  };
+}
 // ../../packages/aeg-core/src/state-machine-model.ts
 var FORGE_FACT_INPUTS = [
   {
@@ -1832,6 +1868,22 @@ function isEmDashOrDash(s) {
   const t = s.trim();
   return t === "—" || t === "-" || t === "–";
 }
+// ../../packages/aeg-core/src/waiver-label.ts
+var WAIVER_LABEL = label("waiver-docs");
+var WAIVER_LABEL_REVIEW = label("waiver-review");
+var PRINCIPAL_ALLOWLIST = ["daniboomerang"];
+function isPrincipal(login, principalAllowlist) {
+  if (login === null)
+    return false;
+  const normalized = login.toLowerCase();
+  return principalAllowlist.some((p) => p.toLowerCase() === normalized);
+}
+function isWaiverLabelActorVerified(opts) {
+  if (!opts.labels.includes(opts.label))
+    return false;
+  return isPrincipal(opts.labelActor, opts.principalAllowlist);
+}
+
 // ../../packages/aeg-core/src/parse-token-report.ts
 var TOKEN_REPORT_HEADING = /^\s*(?:#{1,6}\s*Token report\s*|\*\*Token report\*\*)\s*$/i;
 var INLINE_FIELD_LIST = /Phase:\s*([^|]+?)\s*\|\s*Role:\s*([^|]+?)\s*\|\s*Agent\/Model:\s*([^|]+?)\s*\|\s*Tokens in:\s*([^|]+?)\s*\|\s*Tokens out:\s*([^|]+?)\s*\|\s*Cost:\s*([^|]+?)\s*\|\s*Date:\s*(.+?)\s*$/im;
@@ -1886,6 +1938,47 @@ function parseInlineFieldList(section) {
     return null;
   return rowFromCells([m[1], m[2], m[3], m[4], m[5], m[6], m[7]]);
 }
+// ../../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) {
+  return comment.split(`
+`).slice(0, 3).join(`
+`);
+}
+function extractHeadSha(comment) {
+  const m = firstThreeLines(comment).match(HEAD_SHA_PATTERN);
+  return m ? m[1].toLowerCase() : null;
+}
+function extractVerdict(comments, valuePattern, missingLabel) {
+  const candidates = comments.filter((c) => valuePattern.test(c));
+  if (candidates.length === 0) {
+    return {
+      value: `no ${missingLabel} pass was run before merge — DANGLING, see below`,
+      headSha: null,
+      danglingNote: `no ${missingLabel} verdict comment found on this PR`
+    };
+  }
+  const latest = candidates[candidates.length - 1];
+  const m = firstThreeLines(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`,
+      headSha: null,
+      danglingNote: `the most recent ${missingLabel} verdict comment carries a VERDICT-shaped line outside the first-three-line read window`
+    };
+  }
+  return {
+    value: m[1].toUpperCase().replace(/[_-]/g, " "),
+    headSha: extractHeadSha(latest),
+    danglingNote: null
+  };
+}
+function extractCodeReviewVerdict(comments) {
+  return extractVerdict(comments, /^[ \t]*(?:\*{1,3}|_{1,3})?VERDICT:\s*(APPROVE|REQUEST[ _-]?CHANGES|LGTM)(?![A-Za-z0-9])/im, "code-reviewer");
+}
+function extractSecurityReviewVerdict(comments) {
+  return extractVerdict(comments, /^[ \t]*(?:\*{1,3}|_{1,3})?VERDICT:\s*(PASS|FAIL)(?![A-Za-z0-9])/im, "security-review");
+}
 // ../../packages/aeg-core/src/report-tokens.ts
 var DASH_LOOKALIKES = {
   "-": "‑",
@@ -2050,22 +2143,6 @@ function isCodeFile(p) {
     return false;
   return /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|sql|css)$/.test(p);
 }
-// ../../packages/aeg-core/src/waiver-label.ts
-var WAIVER_LABEL = label("waiver-docs");
-var WAIVER_LABEL_REVIEW = label("waiver-review");
-var PRINCIPAL_ALLOWLIST = ["daniboomerang"];
-function isPrincipal(login, principalAllowlist) {
-  if (login === null)
-    return false;
-  const normalized = login.toLowerCase();
-  return principalAllowlist.some((p) => p.toLowerCase() === normalized);
-}
-function isWaiverLabelActorVerified(opts) {
-  if (!opts.labels.includes(opts.label))
-    return false;
-  return isPrincipal(opts.labelActor, opts.principalAllowlist);
-}
-
 // ../../packages/aeg-core/src/doc-owners.ts
 var DOC_OWNERS_PATH = ".vinaya/doc-owners";
 function parseDocOwners(content) {
@@ -2282,6 +2359,32 @@ function parsePremiseBlock(prBody) {
   }
   return assertions;
 }
+function premiseBlockText(prBody) {
+  const searchIn = anchoredRegion(prBody, "PREMISE") ?? prBody;
+  const lines = searchIn.split(/\r?\n/);
+  let startIdx = -1;
+  let endIdxExclusive = lines.length;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (startIdx === -1) {
+      if (isPremiseHeader(line))
+        startIdx = i;
+      continue;
+    }
+    if (line === "") {
+      endIdxExclusive = i;
+      break;
+    }
+    if (!PREMISE_LINE.test(line)) {
+      endIdxExclusive = i;
+      break;
+    }
+  }
+  if (startIdx === -1)
+    return null;
+  return lines.slice(startIdx, endIdxExclusive).join(`
+`);
+}
 function checkPremises(assertions, fileReader) {
   const failures = [];
   for (const a of assertions) {
@@ -2368,15 +2471,18 @@ function testPlanRegion(prBody) {
   return located.found ? located.section : prBody;
 }
 function checkTestPlan(prBody) {
-  const region = testPlanRegion(prBody);
+  const located = locateTestPlanSection(prBody);
+  const region = located.found ? located.section : prBody;
   if (TEST_PLAN_UNIT_TESTS_ONLY_RE.test(region))
     return { status: "pass", errors: [] };
   if (/\*\*\[(?:agent|principal)\]\*\*/.test(region))
     return { status: "pass", errors: [] };
+  if (located.found && extractFencedBlocks(region).length > 0)
+    return { status: "pass", errors: [] };
   return {
     status: "fail",
     errors: [
-      "brief-validation Test Plan: no Test Plan section found — expected `Test Plan: unit-tests-only`, or at least one `**[agent]**`/`**[principal]**`-tagged checklist item."
+      "brief-validation Test Plan: no Test Plan section found — expected `Test Plan: unit-tests-only`, a fenced `[agent]` command list, or at least one `**[agent]**`/`**[principal]**`-tagged checklist item."
     ]
   };
 }
@@ -2499,8 +2605,162 @@ function isBriefShaped(prBody) {
   const stripped = stripCode(prBody);
   return BRIEF_SHAPE_MARKERS.filter((check) => check(stripped).status === "pass").length >= 2;
 }
+var COMMAND_WORDS = ["export", "bun", "gh", "git", "grep", "sed", "cat", "diff", "vinaya"];
+var BRIEF_RULES_SINCE_PR = 394;
+var AGENT_BOXES_REFUSED_SINCE_PR = 396;
+var AGENT_BOX_LINE_RE = /^-\s*\[[ xX]\]\s*\*{2}\[agent\]\*{2}/im;
+function checkNoAgentBoxes(prBody) {
+  const region = testPlanRegion(prBody);
+  if (!AGENT_BOX_LINE_RE.test(region))
+    return { status: "pass", errors: [] };
+  return {
+    status: "fail",
+    errors: [
+      "brief-validation no agent boxes: the Test Plan carries a checkbox `[agent]` item — an agent never ticks a box or edits a PR body (Principal ruling, 2026-09-03, after PR #395). Render the `[agent]` half as a fenced command list instead; `vinaya pr report` runs each command from the PR head and writes its actual output into the AEG:EVIDENCE block. `[principal]` checkboxes are unaffected."
+    ]
+  };
+}
+function rolloutThresholdFor(message) {
+  if (message.startsWith("brief-validation unpinned code claim:") || message.startsWith("brief-validation commands carry output:") || message.startsWith("brief-validation consumer tests:") || message.startsWith("brief-validation defeat cases:")) {
+    return BRIEF_RULES_SINCE_PR;
+  }
+  if (message.startsWith("brief-validation no agent boxes:"))
+    return AGENT_BOXES_REFUSED_SINCE_PR;
+  return null;
+}
+function partitionBriefErrorsByRollout(errors, prNumber) {
+  const blocking = [];
+  const info = [];
+  for (const e of errors) {
+    const threshold = rolloutThresholdFor(e);
+    const grandfathered = threshold !== null && prNumber !== null && prNumber < threshold;
+    (grandfathered ? info : blocking).push(e);
+  }
+  return { blocking, info };
+}
+function extractFencedBlocks(text) {
+  const re = /^[ \t]*(`{3,}|~{3,})([^\n]*)\n([\s\S]*?)^[ \t]*\1[ \t]*$/gm;
+  const blocks = [];
+  let m = re.exec(text);
+  while (m !== null) {
+    const lang = m[2].trim().toLowerCase().split(/\s+/)[0] ?? "";
+    blocks.push({ start: m.index, end: m.index + m[0].length, lang, content: m[3] });
+    m = re.exec(text);
+  }
+  return blocks;
+}
+function firstNonBlankLine(text) {
+  const line = text.split(`
+`).find((l) => l.trim().length > 0);
+  return line?.trim() ?? "";
+}
+var FILE_LINE_RE = /\b[\w./-]+\.(?:tsx?|jsx?|mjs|cjs|md|mdx|json|ya?ml|sh|py|toml):\d+\b/g;
+function checkNoUnpinnedCodeClaims(prBody) {
+  const premiseText = premiseBlockText(prBody);
+  const withoutPremise = premiseText ? prBody.replace(premiseText, "") : prBody;
+  const scanned = stripCode(withoutPremise, { inlineSpans: "keep" });
+  const matches = scanned.match(FILE_LINE_RE) ?? [];
+  if (matches.length === 0)
+    return { status: "pass", errors: [] };
+  return {
+    status: "fail",
+    errors: matches.map((m) => `brief-validation unpinned code claim: "${m}" states a code fact by file-and-line reference outside a \`Premise:\` pin and outside a fenced code block — pin it in \`Premise:\`, or show the executed command and its output instead.`)
+  };
+}
+function extractNumberedSection(prBody, num) {
+  const startRe = new RegExp(`^#{1,4}\\s*(?:\\*\\*)?${num}[a-z]?\\.\\s`, "im");
+  const start = startRe.exec(prBody);
+  if (!start)
+    return null;
+  const afterStart = start.index + start[0].length;
+  const rest = prBody.slice(afterStart);
+  const next = /^#{1,4}\s/m.exec(rest);
+  return next ? rest.slice(0, next.index) : rest;
+}
+function commandWordOf(line) {
+  return line.trim().split(/\s+/)[0] ?? "";
+}
+function isCommandBlock(content) {
+  return COMMAND_WORDS.includes(commandWordOf(firstNonBlankLine(content)));
+}
+function isStep0Block(content) {
+  return firstNonBlankLine(content).startsWith("git worktree add");
+}
+function checkCommandsCarryOutput(prBody) {
+  const errors = [];
+  for (const [label2, num] of [
+    ["5", 5],
+    ["6", 6]
+  ]) {
+    const section = extractNumberedSection(prBody, num);
+    if (!section)
+      continue;
+    const blocks = extractFencedBlocks(section);
+    for (let i = 0;i < blocks.length; i++) {
+      const block = blocks[i];
+      if (isStep0Block(block.content) || !isCommandBlock(block.content))
+        continue;
+      const next = blocks[i + 1];
+      if (!next || isCommandBlock(next.content)) {
+        errors.push(`brief-validation commands carry output: §${label2} has a command block ("${firstNonBlankLine(block.content)}") not immediately followed by a non-command output block — the very next fenced block must hold that command's actual output, not another command.`);
+      }
+    }
+  }
+  return errors.length === 0 ? { status: "pass", errors: [] } : { status: "fail", errors };
+}
+var CONSUMER_TESTS_SENTINEL_RE = /consumer-tests\s*:\s*none\s*[-—–]\s*\S/i;
+function packagesNamedIn(text) {
+  const re = /\bpackages\/([A-Za-z0-9_-]+)\//g;
+  const pkgs = new Set;
+  let m = re.exec(text);
+  while (m !== null) {
+    pkgs.add(m[1]);
+    m = re.exec(text);
+  }
+  return [...pkgs];
+}
+function hasTestPathForConsumer(text, consumerDir) {
+  const escaped = consumerDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`${escaped}\\/[\\w./-]*\\.test\\.[A-Za-z0-9]+`);
+  return re.test(text);
+}
+function checkConsumerTests(prBody, consumersOf) {
+  const section4 = extractNumberedSection(prBody, 4);
+  if (!section4)
+    return { status: "pass", errors: [] };
+  if (CONSUMER_TESTS_SENTINEL_RE.test(section4))
+    return { status: "pass", errors: [] };
+  const errors = [];
+  for (const pkg of packagesNamedIn(section4)) {
+    for (const consumerDir of consumersOf(pkg)) {
+      if (hasTestPathForConsumer(section4, consumerDir))
+        continue;
+      errors.push(`brief-validation consumer tests: §4 names a path under packages/${pkg}/, and ${consumerDir} depends on @attalabs/${pkg}, but no test path under ${consumerDir} is named in §4 — name one, or add \`consumer-tests: none — <reason>\`.`);
+    }
+  }
+  return errors.length === 0 ? { status: "pass", errors: [] } : { status: "fail", errors };
+}
+var CHECK_NAME_RE = /\bcheck-[a-z0-9-]+(?:\.ts)?\b/;
+var FORGE_WRITE_COMMAND_RE = /\bgh\s+(?:pr|issue)\s+(?:create|merge|close|comment|edit|review)\b|\bgit\s+push\b|\bvinaya\s+pr\s+(?:create|report\s+--write)\b/i;
+var DEFEAT_CASES_RE = /defeat cases\s*:/i;
+function checkDefeatCases(prBody) {
+  const section4 = extractNumberedSection(prBody, 4);
+  if (!section4)
+    return { status: "pass", errors: [] };
+  if (!CHECK_NAME_RE.test(section4) && !FORGE_WRITE_COMMAND_RE.test(section4))
+    return { status: "pass", errors: [] };
+  const section6 = extractNumberedSection(prBody, 6) ?? "";
+  if (DEFEAT_CASES_RE.test(section6))
+    return { status: "pass", errors: [] };
+  return {
+    status: "fail",
+    errors: [
+      "brief-validation defeat cases: §4 names a check or a forge-writing command, but §6 carries no `Defeat cases:` line — name the inputs that would defeat this check, or that this command must not accidentally trigger on."
+    ]
+  };
+}
 function checkBriefSections(prBody, readTier, options = {}) {
-  const { requireClosesN = true } = options;
+  const { requireClosesN = true, consumersOf = () => [] } = options;
   const results = [
     checkTierField(prBody, readTier),
     checkTestPlan(prBody),
@@ -2513,10 +2773,219 @@ function checkBriefSections(prBody, readTier, options = {}) {
     checkAutonomyClause(prBody),
     checkProjectField(prBody),
     checkForField(prBody),
+    checkNoUnpinnedCodeClaims(prBody),
+    checkNoAgentBoxes(prBody),
+    checkCommandsCarryOutput(prBody),
+    checkConsumerTests(prBody, consumersOf),
+    checkDefeatCases(prBody),
     ...requireClosesN ? [checkClosesN(prBody)] : []
   ];
   return { errors: results.flatMap((r) => r.errors) };
 }
+// ../../packages/aeg-core/src/doctrine-portability.ts
+var DEFAULT_SHIPS_PREFIX = "aeg-root/";
+var STATIC_PORTABLE_PREFIXES = [
+  "roles/",
+  "contracts/",
+  "skills/",
+  ".github/",
+  ".vinaya/",
+  ".claude/",
+  ".git/",
+  ".husky/"
+];
+var EXEMPT_LITERALS = new Set([
+  "path/inside/the/shipped/diff.ts",
+  "path/inside/the/surface.ts",
+  "apps/x/specs/..."
+]);
+var CITED_PATH_PATTERN = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]*)+$/;
+var NON_PATH_TOP_SEGMENTS = new Set(["origin", "refs", "HEAD", "vinaya", "fix"]);
+var VENDOR_NAME_SOURCE = "\\bclaude code\\b|\\bclaude\\b|\\banthropic\\b|\\bchatgpt\\b|\\bopenai\\b|\\bgpt\\b|\\bgemini\\b|\\bcodex\\b|\\bgrok\\b|\\bdeepseek\\b|\\bopus\\b|\\bsonnet\\b|\\bhaiku\\b";
+var VENDOR_EXAMPLE_START = /<!--\s*AEG:VENDOR-EXAMPLE:START\s*-->/;
+var VENDOR_EXAMPLE_END = /<!--\s*AEG:VENDOR-EXAMPLE:END\s*-->/;
+function maskVendorExampleRegion(masked) {
+  const start = VENDOR_EXAMPLE_START.exec(masked);
+  if (!start)
+    return masked;
+  const afterStart = start.index + start[0].length;
+  const end = VENDOR_EXAMPLE_END.exec(masked.slice(afterStart));
+  if (!end)
+    return masked;
+  const regionEnd = afterStart + end.index + end[0].length;
+  const region = masked.slice(start.index, regionEnd);
+  const blanked = region.replace(/[^\n]/g, " ");
+  return masked.slice(0, start.index) + blanked + masked.slice(regionEnd);
+}
+function extractVendorMentions(content) {
+  const scoped = maskVendorExampleRegion(maskCode(content));
+  const found = [];
+  const pattern = new RegExp(VENDOR_NAME_SOURCE, "gi");
+  let match = pattern.exec(scoped);
+  while (match !== null) {
+    found.push({ name: match[0], index: match.index });
+    match = pattern.exec(scoped);
+  }
+  return found;
+}
+function extractCitedPaths(content) {
+  const found = [];
+  const spanPattern = /`([^`\n]+)`/g;
+  let match = spanPattern.exec(content);
+  while (match !== null) {
+    const cited = match[1] ?? "";
+    const topSegment = cited.slice(0, cited.indexOf("/"));
+    if (CITED_PATH_PATTERN.test(cited) && !NON_PATH_TOP_SEGMENTS.has(topSegment)) {
+      found.push({ cited, index: match.index });
+    }
+    match = spanPattern.exec(content);
+  }
+  return found;
+}
+function lineAtIndex(content, index) {
+  let line = 1;
+  for (let i = 0;i < index; i++) {
+    if (content.charCodeAt(i) === 10)
+      line++;
+  }
+  return line;
+}
+function isPortable(cited, shipsPrefix) {
+  if (cited.startsWith(shipsPrefix))
+    return true;
+  return STATIC_PORTABLE_PREFIXES.some((prefix) => cited.startsWith(prefix));
+}
+function checkDoctrinePortability(files, shipsPrefix = DEFAULT_SHIPS_PREFIX) {
+  const findings = [];
+  for (const file of files) {
+    if (!file.path.startsWith(shipsPrefix))
+      continue;
+    for (const { cited, index } of extractCitedPaths(file.content)) {
+      if (EXEMPT_LITERALS.has(cited))
+        continue;
+      if (isPortable(cited, shipsPrefix))
+        continue;
+      findings.push({
+        file: file.path,
+        line: lineAtIndex(file.content, index),
+        cited,
+        message: `cites "${cited}", a path that only exists in the authoring repository — not portable doctrine`,
+        kind: "path"
+      });
+    }
+    for (const { name, index } of extractVendorMentions(file.content)) {
+      findings.push({
+        file: file.path,
+        line: lineAtIndex(file.content, index),
+        cited: name,
+        message: `names "${name}" outside the one fenced vendor-example home (an <!-- AEG:VENDOR-EXAMPLE:START --> … <!-- AEG:VENDOR-EXAMPLE:END --> pair) — portable doctrine refers to a host generically everywhere else`,
+        kind: "vendor-name"
+      });
+    }
+  }
+  return findings;
+}
+
+// ../../packages/aeg-core/src/doctrine-no-procedures.ts
+function vendorExampleSpan(content) {
+  const start = VENDOR_EXAMPLE_START.exec(content);
+  if (!start)
+    return null;
+  const afterStart = start.index + start[0].length;
+  const end = VENDOR_EXAMPLE_END.exec(content.slice(afterStart));
+  if (!end)
+    return null;
+  return { start: start.index, end: afterStart + end.index + end[0].length };
+}
+function isCommandLine(line) {
+  const word = line.trim().split(/\s+/)[0] ?? "";
+  return COMMAND_WORDS.includes(word);
+}
+var SHELL_LANGS = new Set(["", "sh", "bash", "shell", "console"]);
+function procedureLineNumberAt(content, index) {
+  return content.slice(0, index).split(`
+`).length;
+}
+function isTemplatePath(path) {
+  return /(^|\/)templates\//.test(path);
+}
+function checkDoctrineNoProcedures(files) {
+  const findings = [];
+  for (const file of files) {
+    if (isTemplatePath(file.path))
+      continue;
+    const span = vendorExampleSpan(file.content);
+    for (const block of extractFencedBlocks(file.content)) {
+      if (span && block.start >= span.start && block.end <= span.end)
+        continue;
+      if (!SHELL_LANGS.has(block.lang))
+        continue;
+      const commandLineCount = block.content.split(`
+`).filter(isCommandLine).length;
+      if (commandLineCount >= 2) {
+        findings.push({
+          file: file.path,
+          line: procedureLineNumberAt(file.content, block.start),
+          message: `this fenced block has ${commandLineCount} shell-command lines — this sequence is a \`vinaya\` command, name it (or move it inside the \`AEG:VENDOR-EXAMPLE\` anchor / a \`templates/\` file).`
+        });
+      }
+    }
+  }
+  return findings;
+}
+// ../../packages/aeg-core/src/pr-report-density.ts
+function headingSectionBody(prBody, heading) {
+  const headingRe = new RegExp(`^##\\s+${heading}\\s*$`, "im");
+  const m = headingRe.exec(prBody);
+  if (!m)
+    return null;
+  const start = m.index + m[0].length;
+  const rest = prBody.slice(start);
+  const nextHeading = /^#{1,2}\s/m.exec(rest);
+  return nextHeading ? rest.slice(0, nextHeading.index) : rest;
+}
+function stripAnchorBlocks(sectionText) {
+  let result = sectionText;
+  for (const field of ["CLOSES", "PROJECT", "TIER", "PREMISE", "TEST-PLAN", "EVIDENCE"]) {
+    for (;; ) {
+      const bounds = anchoredRegionBounds(result, field);
+      if (!bounds)
+        break;
+      result = result.slice(0, bounds.outerStart) + result.slice(bounds.outerEnd);
+    }
+  }
+  return result;
+}
+function paragraphCount(sectionText) {
+  const stripped = stripCode(stripAnchorBlocks(sectionText)).trim();
+  if (stripped.length === 0)
+    return 0;
+  return stripped.split(/\n[ \t]*\n/).map((block) => block.trim()).filter((block) => block.length > 0).length;
+}
+function checkSectionDensity(prBody, heading) {
+  const body = headingSectionBody(prBody, heading);
+  if (body === null)
+    return { status: "pass", errors: [] };
+  const count = paragraphCount(body);
+  if (count <= 1)
+    return { status: "pass", errors: [] };
+  return {
+    status: "fail",
+    errors: [
+      `pr-report-density ${heading}: "## ${heading}" holds ${count} paragraphs — the canonical PR-report form (aeg-root/roles/developer.md § PR body) requires exactly one. Collapse it to one paragraph; move the rest into a section of your own below the canonical four ("Add anything you want beneath the four sections", developer.md), a commit message, or the changeset — never into the AEG:EVIDENCE block, which is emitted only, never hand-typed.`
+    ]
+  };
+}
+function checkSummaryDensity(prBody) {
+  return checkSectionDensity(prBody, "Summary");
+}
+function checkScopeDensity(prBody) {
+  return checkSectionDensity(prBody, "Scope");
+}
+function checkPrReportDensity(prBody) {
+  const results = [checkSummaryDensity(prBody), checkScopeDensity(prBody)];
+  return { errors: results.flatMap((r) => r.errors) };
+}
 // ../../packages/aeg-core/src/issue-validation.ts
 function hasRationaleField(body, labelPattern) {
   const re = new RegExp(`(?:\\*\\*|^#{1,4}\\s+)\\s*(?:${labelPattern})`, "im");
@@ -2768,6 +3237,17 @@ function checkD1(entries, issueToEntry, taskToEntry) {
       const depEntry = resolveDepEntry(dep, e.trancheSlug, issueToEntry, taskToEntry);
       if (!depEntry)
         continue;
+      const sameTask = depEntry.trancheSlug === e.trancheSlug && depEntry.task.id === e.task.id;
+      const sameIssue = depEntry.task.issue !== null && e.task.issue !== null && depEntry.task.issue === e.task.issue;
+      if (sameTask || sameIssue) {
+        failures.push({
+          issue: e.task.issue,
+          tranche: e.trancheSlug,
+          task: e.task.id,
+          reason: `INTERNAL: parsed a self-dependency (depends-on ${dep}) — this is a parser bug in parseRationaleDeps, not a real dependency. Please report it upstream.`
+        });
+        continue;
+      }
       const depFacts = depEntry.facts;
       const depClosed = depFacts?.issueState === "closed";
       if (!depClosed) {
@@ -2911,41 +3391,24 @@ function checkClosesN2(branch, prBody, trancheFiles, taskIssueRefs) {
   }
   return { ok: true, expectedIssue };
 }
-// ../../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 extractHeadSha(comment) {
-  const m = comment.match(HEAD_SHA_PATTERN);
-  return m ? m[1].toLowerCase() : null;
-}
-function extractVerdict(comments, valuePattern, missingLabel) {
-  const clearHits = comments.filter((c) => valuePattern.test(c));
-  if (clearHits.length > 0) {
-    const latest = clearHits[clearHits.length - 1];
-    const m = latest.match(valuePattern);
-    return {
-      value: m[1].toUpperCase().replace(/[_-]/g, " "),
-      headSha: extractHeadSha(latest),
-      danglingNote: null
-    };
-  }
-  return {
-    value: `no ${missingLabel} pass was run before merge — DANGLING, see below`,
-    headSha: null,
-    danglingNote: `no ${missingLabel} verdict comment found on this PR`
-  };
-}
-function extractCodeReviewVerdict(comments) {
-  return extractVerdict(comments, /^[ \t]*(?:\*{1,3}|_{1,3})?VERDICT:\s*(APPROVE|REQUEST[ _-]?CHANGES|LGTM)(?![A-Za-z0-9])/im, "code-reviewer");
-}
-function extractSecurityReviewVerdict(comments) {
-  return extractVerdict(comments, /^[ \t]*(?:\*{1,3}|_{1,3})?VERDICT:\s*(PASS|FAIL)(?![A-Za-z0-9])/im, "security-review");
-}
 // ../../packages/aeg-core/src/review-gate.ts
 function isBoundToHead(extraction, headSha) {
   if (!extraction.headSha)
     return false;
   return headSha.toLowerCase().startsWith(extraction.headSha.toLowerCase());
 }
+function isBoundByPatchIdentity(extraction, headSha, patchIdOf) {
+  if (patchIdOf === undefined || !extraction.headSha)
+    return false;
+  const judged = patchIdOf(extraction.headSha);
+  const current = patchIdOf(headSha);
+  if (judged === null || current === null)
+    return false;
+  return judged === current;
+}
+function isBoundToPatch(extraction, headSha, patchIdOf) {
+  return isBoundToHead(extraction, headSha) || isBoundByPatchIdentity(extraction, headSha, patchIdOf);
+}
 function checkReviewGate(input) {
   const principalAllowlist = input.principalAllowlist ?? PRINCIPAL_ALLOWLIST;
   const waived = isWaiverLabelActorVerified({
@@ -2961,6 +3424,8 @@ function checkReviewGate(input) {
       waived: true
     };
   }
+  const reportedMechanicalChecks = input.mechanicalChecks.filter((c) => c.bucket !== "skipping" && c.bucket !== "neutral");
+  const mechanicalChecksClean = reportedMechanicalChecks.length > 0 && reportedMechanicalChecks.every((c) => c.bucket === "pass");
   const verified = input.comments.filter((c) => isPrincipal(c.author, principalAllowlist));
   const ignoredCount = input.comments.filter((c) => !isPrincipal(c.author, principalAllowlist) && c.body.includes("VERDICT")).length;
   const verifiedBodies = verified.map((c) => c.body);
@@ -2968,12 +3433,12 @@ function checkReviewGate(input) {
   const security = extractSecurityReviewVerdict(verifiedBodies);
   const codeReviewClean = codeReview.value === "APPROVE";
   const securityClean = security.value === "PASS";
-  const codeReviewBound = isBoundToHead(codeReview, input.headSha);
-  const securityBound = isBoundToHead(security, input.headSha);
-  if (codeReviewClean && codeReviewBound && securityClean && securityBound) {
+  const codeReviewBound = isBoundToPatch(codeReview, input.headSha, input.patchIdOf);
+  const securityBound = isBoundToPatch(security, input.headSha, input.patchIdOf);
+  if (codeReviewClean && codeReviewBound && securityClean && securityBound && 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}.`,
+      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.`,
       waived: false
     };
   }
@@ -2988,6 +3453,9 @@ function checkReviewGate(input) {
   } else if (!securityBound) {
     problems.push(`the newest security-review verdict covers ${security.headSha ?? "no recorded commit"}, head is ${input.headSha}`);
   }
+  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(", ")}`);
+  }
   const ignoredNote = ignoredCount > 0 ? ` ${ignoredCount} verdict-shaped comment(s) from authors outside the principal allowlist were ignored.` : "";
   return {
     verdict: "fail",
@@ -3267,72 +3735,6 @@ function compareToBaseline(current, baseline) {
     perTool
   };
 }
-// ../../packages/aeg-core/src/doctrine-portability.ts
-var DEFAULT_SHIPS_PREFIX = "aeg-root/";
-var STATIC_PORTABLE_PREFIXES = [
-  "roles/",
-  "contracts/",
-  "skills/",
-  ".github/",
-  ".vinaya/",
-  ".claude/",
-  ".git/",
-  ".husky/"
-];
-var EXEMPT_LITERALS = new Set([
-  "path/inside/the/shipped/diff.ts",
-  "path/inside/the/surface.ts",
-  "apps/x/specs/..."
-]);
-var CITED_PATH_PATTERN = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]*)+$/;
-var NON_PATH_TOP_SEGMENTS = new Set(["origin", "refs", "HEAD", "vinaya", "fix"]);
-function extractCitedPaths(content) {
-  const found = [];
-  const spanPattern = /`([^`\n]+)`/g;
-  let match = spanPattern.exec(content);
-  while (match !== null) {
-    const cited = match[1] ?? "";
-    const topSegment = cited.slice(0, cited.indexOf("/"));
-    if (CITED_PATH_PATTERN.test(cited) && !NON_PATH_TOP_SEGMENTS.has(topSegment)) {
-      found.push({ cited, index: match.index });
-    }
-    match = spanPattern.exec(content);
-  }
-  return found;
-}
-function lineAtIndex(content, index) {
-  let line = 1;
-  for (let i = 0;i < index; i++) {
-    if (content.charCodeAt(i) === 10)
-      line++;
-  }
-  return line;
-}
-function isPortable(cited, shipsPrefix) {
-  if (cited.startsWith(shipsPrefix))
-    return true;
-  return STATIC_PORTABLE_PREFIXES.some((prefix) => cited.startsWith(prefix));
-}
-function checkDoctrinePortability(files, shipsPrefix = DEFAULT_SHIPS_PREFIX) {
-  const findings = [];
-  for (const file of files) {
-    if (!file.path.startsWith(shipsPrefix))
-      continue;
-    for (const { cited, index } of extractCitedPaths(file.content)) {
-      if (EXEMPT_LITERALS.has(cited))
-        continue;
-      if (isPortable(cited, shipsPrefix))
-        continue;
-      findings.push({
-        file: file.path,
-        line: lineAtIndex(file.content, index),
-        cited,
-        message: `cites "${cited}", a path that only exists in the authoring repository — not portable doctrine`
-      });
-    }
-  }
-  return findings;
-}
 // ../../packages/aeg-core/src/reader-resolvable-prose.ts
 var SHIPS_PREFIX = "aeg-root/";
 function shipsArchivePrefix(shipsPrefix) {
@@ -3668,6 +4070,12 @@ function scanRetiredVocabulary(files) {
 function isHandClosedByRecognizedPrincipal(dep, principalAllowlist) {
   return dep.issueState === "closed" && dep.stateReason === "completed" && isPrincipal(dep.closedByActor ?? null, principalAllowlist);
 }
+function isSelfDependency(dep, task, issue) {
+  if (dep.issue !== null && issue !== null && dep.issue === issue.number)
+    return true;
+  const bare = dep.id.trim().replace(/^#/, "");
+  return bare.toLowerCase() === task.id.trim().toLowerCase();
+}
 function checkDispatchReadiness(input) {
   const { trancheSlug, task } = input;
   const taskLabel = `task ${task.id} (tranche ${trancheSlug})`;
@@ -3682,6 +4090,11 @@ function checkDispatchReadiness(input) {
     blockers.push(`dispatch-gate rationale: Issue #${input.issue.number} for ${taskLabel} fails the rationale gate (checkIssueRationale) — the Planner must complete the eight-field rationale before this task is dispatchable.`);
   }
   for (const dep of input.dependsOn) {
+    if (isSelfDependency(dep, task, input.issue)) {
+      const issueStr = input.issue !== null ? `#${input.issue.number}` : "?";
+      blockers.push(`dispatch-gate INTERNAL: parsed a self-dependency for task ${task.id} (${issueStr}) — this is a parser bug in parseRationaleDeps, not a real dependency. Please report it upstream. Re-run once the rationale is corrected or the fix ships.`);
+      continue;
+    }
     if (dep.resolved === false) {
       blockers.push(`dispatch-gate depends-on: ${taskLabel} depends on "${dep.id}", which is UNRESOLVABLE — the resolver could not find a matching tranche/task/Issue for this edge (not a claim about merge status). Not dispatchable until the edge is corrected.`);
       continue;
@@ -3921,27 +4334,27 @@ function evaluateTestPlanGate(body, branch) {
     };
   }
   const checkboxLines = section.split(`
-`).map((line) => line.trimStart()).filter((line) => /^[-*]\s+\[[ xX]\]/.test(line));
+`).map((line) => line.trimStart()).filter((line) => /^[-*]\s+\[[ xX]\]\s*\*{0,2}\[principal\]\*{0,2}/i.test(line));
   if (checkboxLines.length === 0) {
     return {
       verdict: "pass",
       messages: [
-        "Test Plan section found but has no checkbox items.",
+        "Test Plan section found but has no `[principal]` checkbox items.",
         "PASS (advisory) — the section may be empty or expressed in prose; verification is the Principal's call."
       ]
     };
   }
   const unchecked = checkboxLines.filter((line) => /^[-*]\s+\[\s\]/.test(line));
   const checked = checkboxLines.filter((line) => /^[-*]\s+\[[xX]\]/.test(line));
-  const messages = [`Test Plan items: ${checked.length} ticked, ${unchecked.length} unticked.`];
+  const messages = [`Test Plan [principal] items: ${checked.length} ticked, ${unchecked.length} unticked.`];
   if (unchecked.length > 0) {
-    messages.push("", "FAIL — the following Test Plan items are unticked:");
+    messages.push("", "FAIL — the following [principal] Test Plan items are unticked:");
     for (const line of unchecked)
       messages.push(`  ${line}`);
-    messages.push("", "Per aeg-root/roles/developer.md (Verification), a PR is not mergeable while any Test Plan box is unticked.", "- [agent] items: the Developer-agent posts the actual command output as evidence and ticks the box.", "- [principal] items: the Principal runs the item in a real signed-in browser and ticks the box.", "Note: editing the PR body does not retrigger most workflows. If your PR body changes do not surface here, push an empty commit to re-run.");
+    messages.push("", "Per aeg-root/roles/developer.md (Verification), a PR is not mergeable while any [principal] Test Plan box is unticked.", "The Principal runs the item in a real signed-in browser and ticks the box.", "Note: editing the PR body does not retrigger most workflows. If your PR body changes do not surface here, push an empty commit to re-run.");
     return { verdict: "fail", messages };
   }
-  messages.push("All Test Plan items ticked — runtime verification complete.", "PASS.");
+  messages.push("All [principal] Test Plan items ticked — runtime verification complete.", "PASS.");
   return { verdict: "pass", messages };
 }
 // ../../packages/aeg-core/src/workspace-escape.ts
@@ -4022,12 +4435,351 @@ function findWorkspaceEscapes(files, knownPaths, workspaceDirs = DEFAULT_WORKSPA
   return findings;
 }
 // src/lib/diff-evidence.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { join as join2, relative, resolve as resolve2 } from "node:path";
+
+// src/lib/config.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { z } 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 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()
+}).superRefine((entry2, ctx) => {
+  if (!entry2.env)
+    return;
+  for (const [key, value] of Object.entries(entry2.env)) {
+    if (typeof value !== "object" || value === null || !("anyOf" in value))
+      continue;
+    const members = value.anyOf;
+    if (new Set(members).size !== members.length) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `env.${key}.anyOf has duplicate members`,
+        path: ["env", key, "anyOf"]
+      });
+    }
+    if (!members.includes(key)) {
+      ctx.addIssue({
+        code: z.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("/"), {
+    message: 'must be a path (contain at least one "/"), not a bare filename'
+  })
+});
+var BRIEF_BUILTINS = [
+  "tier",
+  "testPlan",
+  "testPlanExclusivity",
+  "principalPlaceholder",
+  "surfaceMap",
+  "docUpdateList",
+  "worktreeStep0",
+  "stopConditions",
+  "autonomyClause",
+  "project",
+  "for",
+  "closesN",
+  "premiseCoverage",
+  "issueRationale",
+  "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 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()
+});
+function isSafeRepoRelPath(p) {
+  if (p.length === 0)
+    return false;
+  if (p.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(p))
+    return false;
+  return p.split(/[\\/]/).every((seg) => seg !== ".." && seg !== "");
+}
+var SafeRepoRelPath = z.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/"];
+function isCanonicalHookBlockPath(p) {
+  return CANONICAL_HOOK_BLOCK_PREFIXES.some((prefix) => p.startsWith(prefix) && p.length > prefix.length);
+}
+var ManagedHookBlockPath = SafeRepoRelPath.refine(isCanonicalHookBlockPath, {
+  message: `must start with one of ${CANONICAL_HOOK_BLOCK_PREFIXES.join(", ")} (byte-exact, case-sensitive)`
+});
+var ManagedBlockRecordSchema = z.object({
+  path: ManagedHookBlockPath,
+  marker: z.string(),
+  comment: z.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 ProjectEntrySchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  path: z.string().min(1).optional()
+});
+function parseTokensCollectDeclaration(value) {
+  const m = value.trim().match(/^(\S+)\s+(\S+)$/);
+  if (!m)
+    return null;
+  const [, interpreter, script] = m;
+  if (!isSafeRepoRelPath(script))
+    return null;
+  return { interpreter, script };
+}
+var VinayaConfigSchema = z.object({
+  rings: z.object({
+    ring1_forgeWriteInterception: z.boolean(),
+    ring2_asyncAudits: z.boolean()
+  }).optional(),
+  checks: z.record(z.string(), CheckEntrySchema).optional(),
+  roles: z.record(z.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, {
+      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()
+  }).optional(),
+  projects: z.array(ProjectEntrySchema).optional()
+});
+var GLOBAL_VINAYA_HOME = join(homedir(), ".vinaya");
+var GLOBAL_CONFIG_PATH = join(GLOBAL_VINAYA_HOME, "config.json");
+var LOCAL_CONFIG_FILENAME = "vinaya.config.json";
+function findLocalConfig() {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join(dir, LOCAL_CONFIG_FILENAME);
+    if (existsSync(candidate))
+      return candidate;
+    if (existsSync(join(dir, ".git")))
+      return null;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function configPath() {
+  const local = findLocalConfig();
+  if (local)
+    return local;
+  if (existsSync(GLOBAL_CONFIG_PATH))
+    return GLOBAL_CONFIG_PATH;
+  return null;
+}
+function globalChecksIgnoredWarning(path) {
+  return `${path}: "checks" registration in the global config is ignored — checks may only be registered from a repo-local vinaya.config.json.`;
+}
+function globalPrincipalsIgnoredWarning(path) {
+  return `${path}: "principals" in the global config is ignored — principals may only be declared from a repo-local vinaya.config.json.`;
+}
+function globalRolesIgnoredWarning(path) {
+  return `${path}: "roles" registration in the global config is ignored — roles may only be registered from a repo-local vinaya.config.json.`;
+}
+function globalReleaseActorIgnoredWarning(path) {
+  return `${path}: "releaseActor" in the global config is ignored — releaseActor may only be declared from a repo-local vinaya.config.json.`;
+}
+function globalTokensCollectIgnoredWarning(path) {
+  return `${path}: "tokens" in the global config is ignored — tokens.collect may only be declared from a repo-local vinaya.config.json.`;
+}
+function stripGlobalOnlyKeys(config, path) {
+  if (path !== GLOBAL_CONFIG_PATH)
+    return config;
+  let result = config;
+  if (result.checks && Object.keys(result.checks).length > 0) {
+    console.error(`⚠ ${globalChecksIgnoredWarning(path)}`);
+    result = { ...result, checks: undefined };
+  }
+  if (result.roles && Object.keys(result.roles).length > 0) {
+    console.error(`⚠ ${globalRolesIgnoredWarning(path)}`);
+    result = { ...result, roles: undefined };
+  }
+  if (result.principals && result.principals.length > 0) {
+    console.error(`⚠ ${globalPrincipalsIgnoredWarning(path)}`);
+    result = { ...result, principals: undefined };
+  }
+  if (result.releaseActor) {
+    console.error(`⚠ ${globalReleaseActorIgnoredWarning(path)}`);
+    result = { ...result, releaseActor: undefined };
+  }
+  if (result.tokens) {
+    console.error(`⚠ ${globalTokensCollectIgnoredWarning(path)}`);
+    result = { ...result, tokens: undefined };
+  }
+  return result;
+}
+function resolvePrincipalAllowlist(config) {
+  return config?.principals ?? PRINCIPAL_ALLOWLIST;
+}
+function resolveReleaseActor(config) {
+  return config?.releaseActor ?? DEFAULT_RELEASE_ACTOR;
+}
+function trustAnchorRepo() {
+  const wellFormed = (slug) => /^[^/\s]+\/[^/\s]+$/.test(slug) ? slug : null;
+  const fromRunner = process.env.GITHUB_REPOSITORY?.trim();
+  if (fromRunner) {
+    const validated = wellFormed(fromRunner);
+    if (validated)
+      return validated;
+  }
+  try {
+    const url = execFileSync2("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    const m = url.match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?\/?$/);
+    return m?.[1] && m[2] ? wellFormed(`${m[1]}/${m[2]}`) : null;
+  } catch {
+    return null;
+  }
+}
+function ghFetchTrustAnchorConfig() {
+  const repo = trustAnchorRepo();
+  if (!repo)
+    throw new Error("could not resolve repo identity for the trust-anchor read");
+  return execFileSync2("gh", ["api", `repos/${repo}/contents/${LOCAL_CONFIG_FILENAME}`, "--jq", ".content"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function firstLine(err) {
+  return err?.message?.split(`
+`)[0] ?? "unknown error";
+}
+function isMissingFileError(err) {
+  const stderr = err?.stderr;
+  const haystack = [
+    err?.message ?? "",
+    typeof stderr === "string" ? stderr : stderr?.toString() ?? ""
+  ].join(`
+`);
+  return /\b404\b|not found/i.test(haystack);
+}
+function loadTrustAnchorConfig(fetcher = ghFetchTrustAnchorConfig) {
+  const warn = (why) => process.stdout.write(`⚠ could not read the trust-anchor config (\`principals\`/\`releaseActor\`) from the default branch (${why}) — falling back to vinaya's built-in defaults.
+`);
+  let base64;
+  try {
+    base64 = fetcher().trim();
+  } catch (err) {
+    if (!isMissingFileError(err))
+      warn(firstLine(err));
+    return null;
+  }
+  if (!base64)
+    return null;
+  try {
+    const raw = Buffer.from(base64, "base64").toString("utf-8");
+    const parsed = VinayaConfigSchema.safeParse(JSON.parse(raw));
+    if (parsed.success)
+      return parsed.data;
+    warn("it did not satisfy the config schema");
+    return null;
+  } catch {
+    warn("it was not readable as JSON");
+    return null;
+  }
+}
+function loadConfig() {
+  const path = configPath();
+  if (!path)
+    return null;
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf-8"));
+    return stripGlobalOnlyKeys(VinayaConfigSchema.parse(raw), path);
+  } catch {
+    return null;
+  }
+}
+var TOKENS_COLLECT_TRUST_PATH = join(GLOBAL_VINAYA_HOME, "tokens-collect-trust.json");
+
+// src/checks/contract.ts
+var CHECK_SCHEMA_VERSION = 1;
+function emitCheckError(error) {
+  process.stderr.write(`${JSON.stringify(error)}
+`);
+}
+
+// src/commands/review-post.ts
+function parseChangedLineRanges(diffOutput) {
+  const result = {};
+  let currentFile = null;
+  for (const line of diffOutput.split(`
+`)) {
+    if (line.startsWith("+++ ")) {
+      const path = line.slice(4).trim();
+      currentFile = path === "/dev/null" ? null : path.replace(/^b\//, "");
+      continue;
+    }
+    if (line.startsWith("@@") && currentFile) {
+      const m = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+      if (m) {
+        const start = Number(m[1]);
+        const count = m[2] !== undefined ? Number(m[2]) : 1;
+        if (count > 0) {
+          if (!result[currentFile])
+            result[currentFile] = [];
+          result[currentFile].push([start, start + count - 1]);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/lib/diff-evidence.ts
 function fileDiffAgainst(ref, path) {
   let out;
   try {
-    out = execFileSync2("git", ["diff", `${ref}...HEAD`, "--", path], {
+    out = execFileSync3("git", ["diff", `${ref}...HEAD`, "--", path], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -4038,7 +4790,7 @@ function fileDiffAgainst(ref, path) {
 }
 function revParse(ref) {
   try {
-    return execFileSync2("git", ["rev-parse", "--verify", ref], {
+    return execFileSync3("git", ["rev-parse", "--verify", ref], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -4048,7 +4800,7 @@ function revParse(ref) {
 }
 function repoRoot() {
   try {
-    return execFileSync2("git", ["rev-parse", "--show-toplevel"], {
+    return execFileSync3("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -4059,7 +4811,7 @@ function repoRoot() {
 function changedFiles(base) {
   let out;
   try {
-    out = execFileSync2("git", ["diff", "--name-only", `${base}...HEAD`], {
+    out = execFileSync3("git", ["diff", "--name-only", `${base}...HEAD`], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -4070,6 +4822,9 @@ function changedFiles(base) {
 `).map((s) => s.trim()).filter(Boolean);
 }
 function resolveChangedFiles(base = process.env.BASE_SHA || "origin/main") {
+  return resolveDiff(base)?.files ?? null;
+}
+function resolveDiff(base = process.env.BASE_SHA || "origin/main") {
   const root = repoRoot();
   if (root === null)
     return null;
@@ -4081,16 +4836,35 @@ function resolveChangedFiles(base = process.env.BASE_SHA || "origin/main") {
     const relPaths = changedFiles(ref);
     if (relPaths === null)
       continue;
-    return relPaths.map((p) => join(root, p));
+    return { base: ref, root, files: relPaths.map((p) => join2(root, p)) };
   }
   return null;
 }
-
-// src/checks/contract.ts
-var CHECK_SCHEMA_VERSION = 1;
-function emitCheckError(error) {
-  process.stderr.write(`${JSON.stringify(error)}
-`);
+function changedLineRanges(ref, path) {
+  const diff = fileDiffAgainst(ref, path);
+  if (diff === null)
+    return null;
+  return parseChangedLineRanges(diff)[path] ?? null;
+}
+function lineIsInRanges(line, ranges) {
+  return ranges.some(([start, end]) => line >= start && line <= end);
+}
+function findingsInThisDiff(findings) {
+  const diff = resolveDiff();
+  if (diff === null)
+    return [...findings];
+  const changed = new Set(diff.files);
+  const ranges = new Map;
+  return findings.filter((f) => {
+    const abs = resolve2(diff.root, f.file);
+    if (!changed.has(abs))
+      return false;
+    const relPath = relative(diff.root, abs);
+    if (!ranges.has(relPath))
+      ranges.set(relPath, changedLineRanges(diff.base, relPath));
+    const fileRanges = ranges.get(relPath) ?? null;
+    return fileRanges === null ? true : lineIsInRanges(f.line, fileRanges);
+  });
 }
 
 // src/checks/changeset-coverage-logic.ts
@@ -4163,7 +4937,7 @@ function evaluateChangesetCoverage(fixedGroup, changedFiles2, isReleaseBranch) {
 var CHECK_NAME = "changeset-coverage";
 function git(args) {
   try {
-    return execFileSync3("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return execFileSync4("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
   } catch {
     return "";
   }
@@ -4173,7 +4947,7 @@ function toPosix(p) {
 }
 function readPackageJson(path) {
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -4194,18 +4968,18 @@ function childDirs(absoluteDir) {
 function candidateMemberDirs(root, pattern) {
   if (pattern.endsWith("/*")) {
     const prefix = pattern.slice(0, -2);
-    return childDirs(join2(root, prefix)).map((name) => `${prefix}/${name}`);
+    return childDirs(join3(root, prefix)).map((name) => `${prefix}/${name}`);
   }
   if (!pattern.includes("*"))
     return [pattern];
   return [];
 }
 function resolveWorkspaceMembers(root) {
-  const rootPkg = readPackageJson(join2(root, "package.json"));
+  const rootPkg = readPackageJson(join3(root, "package.json"));
   const members = new Map;
   for (const pattern of workspacePatterns(rootPkg)) {
     for (const dir of candidateMemberDirs(root, pattern)) {
-      const pkg = readPackageJson(join2(root, dir, "package.json"));
+      const pkg = readPackageJson(join3(root, dir, "package.json"));
       const name = pkg?.name;
       const files = pkg?.files;
       if (typeof name !== "string" || !Array.isArray(files))
@@ -4216,7 +4990,7 @@ function resolveWorkspaceMembers(root) {
   return members;
 }
 function fixedGroupNames(root) {
-  const pkg = readPackageJson(join2(root, ".changeset", "config.json"));
+  const pkg = readPackageJson(join3(root, ".changeset", "config.json"));
   const fixed = pkg?.fixed;
   if (!Array.isArray(fixed))
     return [];
@@ -4238,7 +5012,7 @@ function main() {
   if (changedAbs.length === 0) {
     process.exit(0);
   }
-  const changedFiles2 = changedAbs.map((p) => toPosix(relative(root, p)));
+  const changedFiles2 = changedAbs.map((p) => toPosix(relative2(root, p)));
   const branch = git(["rev-parse", "--abbrev-ref", "HEAD"]);
   const isReleaseBranch = branch === CHANGESET_RELEASE_BRANCH;
   const workspaceMembers = resolveWorkspaceMembers(root);