@attalabs/vinaya 0.19.3 → 0.21.0

package/dist/checks/bin/check-retired-vocabulary.js

@@ -2,20 +2,20 @@
 
 // src/checks/bin/check-retired-vocabulary.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5, resolve as resolve2 } from "node:path";
 // ../../packages/aeg-core/src/gate-audience.ts
 var GATE_AUDIENCE = {
-  "check-branch-topology": { shippedAs: "branch-topology" },
-  "check-first-push-dispatch": { shippedAs: "first-push-dispatch" },
-  "check-no-disk-state": { shippedAs: "no-disk-state" },
-  "verify-brief": { shippedAs: "brief-shape" },
-  "verify-coherence": { shippedAs: "coherence" },
-  "verify-dispatch": { shippedAs: "dispatch-readiness" },
-  "verify-docs": { shippedAs: ["doc-coverage", "doc-coverage-push"] },
-  "verify-registry": { shippedAs: "registry-gates" },
-  "verify-review-gate": { shippedAs: "review-gate" },
-  "verify-single-plan-pr": { shippedAs: "single-plan-pr" },
-  "verify-test-plan": { shippedAs: "test-plan" },
+  "check-branch-topology": { shippedAs: "branch-topology", ring: 0 },
+  "check-first-push-dispatch": { shippedAs: "first-push-dispatch", ring: 0 },
+  "check-no-disk-state": { shippedAs: "no-disk-state", ring: 0 },
+  "verify-brief": { shippedAs: "brief-shape", ring: 0 },
+  "verify-coherence": { shippedAs: "coherence", ring: 0 },
+  "verify-dispatch": { shippedAs: "dispatch-readiness", ring: 0 },
+  "verify-docs": { shippedAs: ["doc-coverage", "doc-coverage-push"], ring: 0 },
+  "verify-registry": { shippedAs: "registry-gates", ring: 0 },
+  "verify-review-gate": { shippedAs: "review-gate", ring: 1 },
+  "verify-single-plan-pr": { shippedAs: "single-plan-pr", ring: 0 },
+  "verify-test-plan": { shippedAs: "test-plan", ring: 1 },
   "check-direct-main-push": {
     internal: "Reaches adopters through `vinaya audit --only=direct-push`, not the check registry: it is a ring-2 sweep over merge history keyed on `GITHUB_SHA`, run by the generated archivist job on push to the default branch. It has no diff to key on, so there is nothing for `vinaya check` to run it against."
   },
@@ -190,6 +190,12 @@ var NEXT_HEADER = /\*\*[A-Z][^*]*\*\*/;
 var FIELD_LABEL = /^(Depends-on|Conflicts-with)\s*:\s*(.*)$/i;
 var ID_TOKEN = /^(?:[\w.-]+\s+)?#?\d+[a-z]?$/i;
 var SLUG_QUALIFIED_ID = /^([\w.-]+)\s+(#?\d+[a-z]?)$/i;
+function splitSlugQualifiedEdge(edge) {
+  const m = edge.trim().match(SLUG_QUALIFIED_ID);
+  if (!m)
+    return null;
+  return { slug: m[1], bareId: m[2] };
+}
 function isEmptyMarker(s) {
   const t = s.trim();
   return t === "" || t === "—" || t === "-" || t === "–";
@@ -327,6 +333,13 @@ var LABELS = [
     form: "literal",
     carries: "Execution is halted pending an external unblock; wins over every other derived status."
   },
+  {
+    key: "backlog",
+    id: "vinaya/backlog",
+    category: "state",
+    form: "literal",
+    carries: "The Issue is deliberately unplanned — belongs to no tranche and is excluded from dispatch, until a Planner promotes it."
+  },
   {
     key: "tier-0",
     id: "vinaya/tier:0",
@@ -1779,6 +1792,151 @@ var DERIVED_STATUSES = [
   "incoherent"
 ];
 var DERIVABLE_STATUSES = DERIVED_STATUSES.filter((s) => s !== "backlog");
+// ../../packages/aeg-core/src/report-tokens.ts
+var DASH_LOOKALIKES = {
+  "-": "‑",
+  "–": "‒",
+  "—": "―"
+};
+var DASH_CHARS = new Set(Object.keys(DASH_LOOKALIKES));
+// ../../packages/aeg-core/src/claude-code-transcript.ts
+function summarizeTranscript(jsonl) {
+  const seen = new Set;
+  const components = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0
+  };
+  let model = null;
+  let messageCount = 0;
+  for (const rawLine of jsonl.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    let entry2;
+    try {
+      entry2 = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!entry2 || typeof entry2 !== "object")
+      continue;
+    const obj = entry2;
+    if (obj.type !== "assistant")
+      continue;
+    const message = obj.message;
+    const id = message?.id;
+    const usage = message?.usage;
+    if (typeof id !== "string" || !id || !usage || seen.has(id))
+      continue;
+    seen.add(id);
+    messageCount++;
+    components.inputTokens += numberOr(usage.input_tokens, 0);
+    components.outputTokens += numberOr(usage.output_tokens, 0);
+    components.cacheCreationInputTokens += numberOr(usage.cache_creation_input_tokens, 0);
+    components.cacheReadInputTokens += numberOr(usage.cache_read_input_tokens, 0);
+    const messageModel = message?.model;
+    if (typeof messageModel === "string" && messageModel)
+      model = messageModel;
+  }
+  return { components, model, messageCount };
+}
+function numberOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function sanitizeKey(value) {
+  return value.replace(/[^A-Za-z0-9]+/g, "-");
+}
+function transcriptPointerPath(projectDir, tmpDir) {
+  return `${tmpDir}/claude-transcript-${sanitizeKey(projectDir)}.txt`;
+}
+function resolvePointer(explicitTranscriptPath, deps) {
+  if (explicitTranscriptPath)
+    return { path: explicitTranscriptPath, corroborated: true };
+  const projectDir = deps.env.CLAUDE_PROJECT_DIR ?? deps.cwd;
+  const tmpDir = deps.env.TMPDIR ?? "/tmp";
+  const pointerPath = transcriptPointerPath(projectDir, tmpDir);
+  const currentSessionId = deps.env.CLAUDE_CODE_SESSION_ID;
+  if (!deps.exists(pointerPath)) {
+    return {
+      pointerExisted: false,
+      corroborated: false,
+      error: `No transcript pointer at ${pointerPath} and no --transcript given. ` + "Either this repo installs no track-transcript.sh Stop hook (lacking one is not a defect — " + "name the transcript directly instead), or no session has completed a turn yet."
+    };
+  }
+  let contents;
+  try {
+    contents = deps.readFile(pointerPath).replace(/\r?\n+$/, "");
+  } catch (err) {
+    return {
+      pointerExisted: true,
+      oursByLocation: true,
+      error: `Transcript pointer at ${pointerPath} could not be read: ${err.message}. ` + "Remove that file to clear this — the Stop hook rewrites it on the next turn."
+    };
+  }
+  const [pointerSessionId, transcriptPath] = contents.split("\t");
+  if (!transcriptPath) {
+    return {
+      pointerExisted: true,
+      oursByLocation: true,
+      error: `Transcript pointer file ${pointerPath} is malformed: "${contents.slice(0, 120)}${contents.length > 120 ? "…" : ""}". ` + "Remove that file to clear this — the Stop hook rewrites it on the next turn."
+    };
+  }
+  if (currentSessionId && pointerSessionId && currentSessionId !== pointerSessionId) {
+    return {
+      pointerExisted: true,
+      corroborated: false,
+      error: `Transcript pointer at ${pointerPath} is stale: written for session ${pointerSessionId}, ` + `but this session is ${currentSessionId}. Name your own transcript with --transcript instead of ` + "reporting another session's figures as yours."
+    };
+  }
+  return { path: transcriptPath, corroborated: Boolean(currentSessionId && pointerSessionId) };
+}
+function resolveMeteringCapability(deps, explicitTranscriptPath) {
+  const resolved = resolvePointer(explicitTranscriptPath, deps);
+  if ("error" in resolved) {
+    const ours = resolved.pointerExisted && (resolved.corroborated || resolved.oursByLocation);
+    if (ours)
+      return { capable: false, reason: "pointer-unusable", detail: resolved.error };
+    return {
+      capable: false,
+      reason: "no-transcript-resolved",
+      detail: resolved.pointerExisted ? `A transcript pointer exists but belongs to another session, so this session has no wiring of its own to use. (Underlying condition, for diagnosis only: ${resolved.error})` : resolved.error
+    };
+  }
+  const downstream = (r, detail) => resolved.corroborated ? { reason: r, detail } : {
+    reason: "no-transcript-resolved",
+    detail: `A transcript pointer was found but could not be shown to belong to this session, so it is not treated as this session's wiring. (Underlying condition, for diagnosis only: ${detail})`
+  };
+  if (!deps.exists(resolved.path)) {
+    return {
+      capable: false,
+      ...downstream("transcript-unreadable", `Resolved transcript path ${resolved.path} is not readable as a regular file owned by this user.`)
+    };
+  }
+  let jsonl;
+  try {
+    jsonl = deps.readFile(resolved.path);
+  } catch (err) {
+    return {
+      capable: false,
+      ...downstream("transcript-unreadable", `Transcript at ${resolved.path} could not be read: ${err.message}`)
+    };
+  }
+  const summary = summarizeTranscript(jsonl);
+  if (summary.messageCount === 0) {
+    return {
+      capable: false,
+      ...downstream("transcript-empty", `Transcript at ${resolved.path} yielded zero assistant messages with usage data — ` + "it's empty, unparseable, or not yet flushed to disk.")
+    };
+  }
+  return { capable: true, transcriptPath: resolved.path, summary };
+}
+function isTokenCollectionWiringBroken(capability) {
+  if (capability.capable)
+    return false;
+  return capability.reason !== "no-transcript-resolved";
+}
 // ../../packages/aeg-core/src/file-classify.ts
 function isCodeFile(p) {
   if (p.endsWith(".md"))
@@ -1985,7 +2143,59 @@ function overrideActive(opts) {
   return false;
 }
 // ../../packages/aeg-core/src/premise-check.ts
+import { createHash } from "node:crypto";
 var ASSERTION_KINDS = new Set(["contains", "absent", "sha256"]);
+function isPremiseHeader(line) {
+  const stripped = line.replace(/[*#]/g, "").trim();
+  return /^premise\s*:?$/i.test(stripped);
+}
+var PREMISE_LINE = /^[-*]\s*(\S+)\s+(contains|absent|sha256)\s*:\s*(.+)$/i;
+function parsePremiseBlock(prBody) {
+  const searchIn = anchoredRegion(prBody, "PREMISE") ?? prBody;
+  const lines = searchIn.split(/\r?\n/);
+  const assertions = [];
+  let inBlock = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!inBlock) {
+      if (isPremiseHeader(line))
+        inBlock = true;
+      continue;
+    }
+    if (line === "")
+      break;
+    const m = line.match(PREMISE_LINE);
+    if (!m)
+      break;
+    const [, path, kindRaw, value] = m;
+    const kind = kindRaw.toLowerCase();
+    if (!ASSERTION_KINDS.has(kind))
+      continue;
+    assertions.push({ kind, path, value: value.trim() });
+  }
+  return assertions;
+}
+function checkPremises(assertions, fileReader) {
+  const failures = [];
+  for (const a of assertions) {
+    const content = fileReader(a.path);
+    if (content === null) {
+      failures.push(`premise-check: ${a.path} does not exist on disk (premise asserted \`${a.kind}: ${a.value}\`) — the surface moved since this brief was authored; re-dig before proceeding.`);
+      continue;
+    }
+    if (a.kind === "contains" && !content.includes(a.value)) {
+      failures.push(`premise-check: ${a.path} no longer contains "${a.value}" — the premise this brief pinned has moved; re-dig before proceeding.`);
+    } 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 = createHash("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.`);
+      }
+    }
+  }
+  return { pass: failures.length === 0, failures };
+}
 
 // ../../packages/aeg-core/src/test-plan-section.ts
 var HEADING_FORM_RE = /^#{1,4}[ \t]*(?:\d+[a-z]?\.[ \t]*)?\*{0,2}Test Plan\*{0,2}[ \t]*$/im;
@@ -2789,6 +2999,7 @@ function checkG1(rows, existsFn) {
   }
   return { check: "G1", status: findings.length > 0 ? "fail" : "pass", findings };
 }
+var SCAFFOLD_PLACEHOLDER = "[undocumented — fill in why]";
 function checkG2(rows, candidateFiles) {
   const implementations = new Set(rows.map((r) => r.implementation).filter((p) => p !== ""));
   const findings = [];
@@ -2800,6 +3011,16 @@ function checkG2(rows, candidateFiles) {
       });
     }
   }
+  for (const row of rows) {
+    const carriesPlaceholder = [row.summary, row.description, row.spec].some((cell) => cell === SCAFFOLD_PLACEHOLDER);
+    if (carriesPlaceholder) {
+      findings.push({
+        row: row.action,
+        path: row.implementation,
+        reason: `${row.ring} row "${row.action}" still carries the scaffold placeholder marker — the why is owed`
+      });
+    }
+  }
   return { check: "G2", status: findings.length > 0 ? "info" : "pass", findings };
 }
 function checkG3(ring0Rows, crossingFiles) {
@@ -3147,6 +3368,100 @@ 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"]);
+var START_PATTERN = /<!--\s*AEG:QUOTES-FILE:START:(\S+?)\s*-->/g;
+var END_PATTERN = /<!--\s*AEG:QUOTES-FILE:END\s*-->/;
+function isValidCitedFilePath(path) {
+  if (path.length === 0)
+    return false;
+  if (path.startsWith("/") || path.startsWith("\\"))
+    return false;
+  if (/^[A-Za-z]:[\\/]/.test(path))
+    return false;
+  return !path.split(/[\\/]+/).includes("..");
+}
+function quotedCommandLineAt(content, index) {
+  let line = 1;
+  for (let i = 0;i < index; i++) {
+    if (content.charCodeAt(i) === 10)
+      line++;
+  }
+  return line;
+}
+function extractQuotedText(raw) {
+  const trimmed = raw.trim();
+  const fenced = /^(?:`{3,}|~{3,})[^\n]*\n([\s\S]*?)\n?(?:`{3,}|~{3,})$/.exec(trimmed);
+  if (fenced)
+    return (fenced[1] ?? "").trim();
+  const inline = /^`([^`]+)`$/.exec(trimmed);
+  if (inline)
+    return (inline[1] ?? "").trim();
+  return trimmed;
+}
+function findQuotesInFile(path, content) {
+  const masked = maskCode(content);
+  const quotes = [];
+  START_PATTERN.lastIndex = 0;
+  let start = START_PATTERN.exec(masked);
+  while (start !== null) {
+    const citedFile = start[1];
+    const innerStart = start.index + start[0].length;
+    const end = END_PATTERN.exec(masked.slice(innerStart));
+    if (end === null) {
+      START_PATTERN.lastIndex = innerStart;
+      start = START_PATTERN.exec(masked);
+      continue;
+    }
+    const innerEnd = innerStart + end.index;
+    if (isValidCitedFilePath(citedFile)) {
+      const quotedText = extractQuotedText(content.slice(innerStart, innerEnd));
+      if (quotedText.length > 0) {
+        quotes.push({ file: path, line: quotedCommandLineAt(content, innerStart), quotedText, citedFile });
+      }
+    }
+    START_PATTERN.lastIndex = innerEnd + end[0].length;
+    start = START_PATTERN.exec(masked);
+  }
+  return quotes;
+}
+function findCitedQuotes(files, readerFacingPrefix, readerFacingSuffix, shipsPrefix = QUOTED_COMMAND_SHIPS_PREFIX) {
+  const quotes = [];
+  for (const file of files) {
+    const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix, shipsPrefix);
+    if (!cls || !QUOTED_COMMAND_SWEPT_CLASSES.has(cls))
+      continue;
+    quotes.push(...findQuotesInFile(file.path, file.content));
+  }
+  return quotes;
+}
+function evaluateCitedQuotes(citedQuotes, citedFileContents) {
+  const findings = [];
+  for (const quote of citedQuotes) {
+    const content = citedFileContents.get(quote.citedFile);
+    if (content === undefined) {
+      findings.push({
+        file: quote.file,
+        line: quote.line,
+        citedFile: quote.citedFile,
+        quotedText: quote.quotedText,
+        message: `${quote.file}:${quote.line} quotes "${quote.quotedText}" as citing \`${quote.citedFile}\`, but that file could not be read`
+      });
+      continue;
+    }
+    if (!content.includes(quote.quotedText)) {
+      findings.push({
+        file: quote.file,
+        line: quote.line,
+        citedFile: quote.citedFile,
+        quotedText: quote.quotedText,
+        message: `${quote.file}:${quote.line} quotes "${quote.quotedText}" as citing \`${quote.citedFile}\`, but \`${quote.citedFile}\` no longer contains that text verbatim`
+      });
+    }
+  }
+  return findings;
+}
 // ../../packages/aeg-core/src/retired-vocabulary.ts
 var RETIRED_PATTERNS = [
   String.raw`\bD-[0-9]{3}\b`,
@@ -3260,6 +3575,10 @@ 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 (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;
+    }
     if (!dep.merged && !isHandClosedByRecognizedPrincipal(dep, principalAllowlist)) {
       const issueStr = dep.issue !== null ? ` (#${dep.issue})` : "";
       blockers.push(`dispatch-gate depends-on: ${taskLabel} depends on ${dep.id}${issueStr}, whose PR is not merged yet — not dispatchable, it serializes behind it.`);
@@ -3319,6 +3638,29 @@ function isNewDiskStateFile(path, status) {
     return false;
   return ANY_DEPTH_TRANCHES_MD.test(path) || TOKENS_FILE.test(path);
 }
+// ../../packages/aeg-core/src/main-branch-refusal.ts
+function checkMainBranchRefusal(facts) {
+  const { currentSymbolicBranch, defaultBranch } = facts;
+  if (currentSymbolicBranch === null)
+    return null;
+  if (defaultBranch === null) {
+    return {
+      reason: "default-branch-undetermined",
+      severity: "warning",
+      currentBranch: currentSymbolicBranch,
+      defaultBranch: null
+    };
+  }
+  if (currentSymbolicBranch === defaultBranch) {
+    return {
+      reason: "on-default-branch",
+      severity: "error",
+      currentBranch: currentSymbolicBranch,
+      defaultBranch
+    };
+  }
+  return null;
+}
 // ../../packages/aeg-core/src/branch-topology-gate.ts
 function taskBranchTopologyFields(branch) {
   if (!/^task\/.*\/.*$/.test(branch))
@@ -3609,9 +3951,9 @@ function resolveDoctrineRoot(pkg = packageRoot(import.meta.url)) {
 
 // src/lib/config.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname3, join as join3, resolve } from "node:path";
 import { z } from "zod";
 
 // src/lib/agent-vendors.ts
@@ -3700,8 +4042,15 @@ function isSafeRepoRelPath(p) {
 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: SafeRepoRelPath,
+  path: ManagedHookBlockPath,
   marker: z.string(),
   comment: z.enum(["hash", "html"])
 });
@@ -3712,6 +4061,20 @@ var ManagedManifestSchema = z.object({
   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(),
@@ -3724,13 +4087,19 @@ var VinayaConfigSchema = z.object({
   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()
+  }).optional(),
+  projects: z.array(ProjectEntrySchema).optional()
 });
 var GLOBAL_VINAYA_HOME = join3(homedir(), ".vinaya");
 var GLOBAL_CONFIG_PATH = join3(GLOBAL_VINAYA_HOME, "config.json");
@@ -3769,6 +4138,9 @@ function globalRolesIgnoredWarning(path) {
 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;
@@ -3789,6 +4161,10 @@ function stripGlobalOnlyKeys(config, path) {
     console.error(`⚠ ${globalReleaseActorIgnoredWarning(path)}`);
     result = { ...result, releaseActor: undefined };
   }
+  if (result.tokens) {
+    console.error(`⚠ ${globalTokensCollectIgnoredWarning(path)}`);
+    result = { ...result, tokens: undefined };
+  }
   return result;
 }
 function resolvePrincipalAllowlist(config) {
@@ -3874,6 +4250,7 @@ function loadConfig() {
     return null;
   }
 }
+var TOKENS_COLLECT_TRUST_PATH = join3(GLOBAL_VINAYA_HOME, "tokens-collect-trust.json");
 
 // src/checks/contract.ts
 var CHECK_SCHEMA_VERSION = 1;
@@ -3882,6 +4259,71 @@ function emitCheckError(error) {
 `);
 }
 
+// src/lib/diff-evidence.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { join as join4 } from "node:path";
+function fileDiffAgainst(ref, path) {
+  let out;
+  try {
+    out = execFileSync3("git", ["diff", `${ref}...HEAD`, "--", path], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+  return out === "" ? null : out;
+}
+function revParse(ref) {
+  try {
+    return execFileSync3("git", ["rev-parse", "--verify", ref], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function repoRoot() {
+  try {
+    return execFileSync3("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function changedFiles(base) {
+  let out;
+  try {
+    out = execFileSync3("git", ["diff", "--name-only", `${base}...HEAD`], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+  return out === "" ? [] : out.split(`
+`).map((s) => s.trim()).filter(Boolean);
+}
+function resolveChangedFiles(base = process.env.BASE_SHA || "origin/main") {
+  const root = repoRoot();
+  if (root === null)
+    return null;
+  const head = revParse("HEAD");
+  for (const ref of [base, "main"]) {
+    const resolved = revParse(ref);
+    if (resolved === null || resolved === head)
+      continue;
+    const relPaths = changedFiles(ref);
+    if (relPaths === null)
+      continue;
+    return relPaths.map((p) => join4(root, p));
+  }
+  return null;
+}
+
 // src/checks/bin/check-retired-vocabulary.ts
 var CHECK_NAME = "retired-vocabulary";
 var DOCTRINE_ROOT = loadConfig()?.proseGates?.doctrineRoot ?? resolveDoctrineRoot() ?? "aeg-root";
@@ -3896,7 +4338,7 @@ function collect(dir, out = []) {
     return out;
   }
   for (const name of entries) {
-    const full = join4(dir, name);
+    const full = join5(dir, name);
     let isDir;
     try {
       isDir = statSync(full).isDirectory();
@@ -3920,8 +4362,12 @@ function main() {
   const paths = collect(DOCTRINE_ROOT);
   const files = readAll(paths);
   const findings = scanRetiredVocabulary(files);
-  console.log(`${CHECK_NAME}: doctrine root "${DOCTRINE_ROOT}"; ${paths.length} file(s) swept; ${findings.length} finding(s)`);
-  for (const finding of findings) {
+  const changedFilesList = resolveChangedFiles();
+  const changed = changedFilesList === null ? null : new Set(changedFilesList);
+  const pathBase = repoRoot() ?? process.cwd();
+  const reportable = changed === null ? findings : findings.filter((f) => changed.has(resolve2(pathBase, f.file)));
+  console.log(`${CHECK_NAME}: doctrine root "${DOCTRINE_ROOT}"; ${paths.length} file(s) swept; ${findings.length} finding(s), ${reportable.length} in this diff`);
+  for (const finding of reportable) {
     emitCheckError({
       schema: CHECK_SCHEMA_VERSION,
       check: CHECK_NAME,