@attalabs/vinaya 0.19.0 → 0.19.2

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

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
 // src/checks/bin/check-reader-resolvable-prose.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { join as join2 } from "node:path";
 // ../../packages/aeg-forge-state/src/strip-code.ts
 function maskCode(body) {
   const fill = (line) => " ".repeat(line.length);
@@ -567,6 +566,12 @@ function factsFromLegacyMilestone(milestone) {
     lifecycle: milestone.state === "closed" ? "complete" : "active"
   };
 }
+function resolveLegacyFacts(milestone, labelIssues) {
+  if (milestone.state === "closed" && labelIssues.length > 0) {
+    return { goal: milestone.description ?? "", lifecycle: lifecycleFromIssues(labelIssues) };
+  }
+  return factsFromLegacyMilestone(milestone);
+}
 function lifecycleFromIssues(issues) {
   if (issues.length === 0)
     return "planned";
@@ -583,9 +588,9 @@ function goalFromMilestones(milestones, slug) {
 function findMilestoneForSlug(owner, repo, slug) {
   const milestones = ghApiGet(`repos/${owner}/${repo}/milestones?state=all&per_page=100`);
   const legacy = matchesLegacyMilestone(milestones, slug);
-  if (legacy)
-    return factsFromLegacyMilestone(legacy);
   const issues = ghIssueListByLabel(owner, repo, trancheLabel(slug));
+  if (legacy)
+    return resolveLegacyFacts(legacy, issues);
   return { goal: goalFromMilestones(milestones, slug), lifecycle: lifecycleFromIssues(issues) };
 }
 
@@ -2772,16 +2777,18 @@ function checkDeadBranchPush(input) {
 }
 // ../../packages/aeg-core/src/reader-resolvable-prose.ts
 var SHIPS_PREFIX = "aeg-root/";
-var SHIPS_ARCHIVE_PREFIX = "aeg-root/tranches/completed/";
+function shipsArchivePrefix(shipsPrefix) {
+  return `${shipsPrefix}tranches/completed/`;
+}
 function isSpecFile2(path) {
   return path.startsWith("apps/") && path.includes("/specs/") && path.endsWith(".md");
 }
 function isClaudeMdFile(path) {
   return path === "CLAUDE.md" || path.endsWith("/CLAUDE.md");
 }
-function classifyProseFile(path, readerFacingPrefix, readerFacingSuffix) {
-  if (path.startsWith(SHIPS_PREFIX)) {
-    return path.startsWith(SHIPS_ARCHIVE_PREFIX) ? "internal" : "ships";
+function classifyProseFile(path, readerFacingPrefix, readerFacingSuffix, shipsPrefix = SHIPS_PREFIX) {
+  if (path.startsWith(shipsPrefix)) {
+    return path.startsWith(shipsArchivePrefix(shipsPrefix)) ? "internal" : "ships";
   }
   if (path.startsWith(readerFacingPrefix) && path.endsWith(readerFacingSuffix)) {
     return "reader-facing";
@@ -2816,7 +2823,7 @@ function legacySlugPattern(legacySlugs) {
   const alternation = legacySlugs.map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
   return new RegExp(`(^|[^a-zA-Z0-9\\n-])(${alternation})([^a-zA-Z0-9\\n-]|$)`, "g");
 }
-function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuffix, legacySlugs = []) {
+function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuffix, legacySlugs = [], shipsPrefix = SHIPS_PREFIX) {
   const findings = [];
   const legacyPattern = legacySlugPattern(legacySlugs);
   const patterns = [
@@ -2825,7 +2832,7 @@ function checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuff
     ...legacyPattern ? [{ pattern: legacyPattern, what: "an internal tranche slug", group: 2 }] : []
   ];
   for (const file of files) {
-    const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix);
+    const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix, shipsPrefix);
     if (!cls || !SWEPT_CLASSES.has(cls))
       continue;
     const scrubbed = stripNonProse(file.path, file.content);
@@ -2871,10 +2878,10 @@ function definesOrLinksGlossary(content, term) {
     return true;
   return /docs\/glossary|glossary\.md/i.test(content);
 }
-function checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix) {
+function checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix, shipsPrefix = SHIPS_PREFIX) {
   const findings = [];
   for (const file of files) {
-    const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix);
+    const cls = classifyProseFile(file.path, readerFacingPrefix, readerFacingSuffix, shipsPrefix);
     if (!cls || !SWEPT_CLASSES.has(cls))
       continue;
     const scrubbed = stripNonProse(file.path, file.content);
@@ -2893,10 +2900,10 @@ function checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, read
   }
   return findings;
 }
-function checkReaderResolvableProse(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix, legacySlugs = []) {
+function checkReaderResolvableProse(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix, legacySlugs = [], shipsPrefix = SHIPS_PREFIX) {
   return [
-    ...checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuffix, legacySlugs),
-    ...checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix)
+    ...checkUnresolvableReferences(files, readerFacingPrefix, readerFacingSuffix, legacySlugs, shipsPrefix),
+    ...checkUndefinedVocabulary(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix, shipsPrefix)
   ];
 }
 function parseGlossaryTerms(glossaryContent) {
@@ -2910,6 +2917,101 @@ function parseGlossaryTerms(glossaryContent) {
   }
   return terms;
 }
+// ../../packages/aeg-core/src/retired-vocabulary.ts
+var RETIRED_PATTERNS = [
+  String.raw`\bD-[0-9]{3}\b`,
+  "D-(###|NNN|nnn|xxx)",
+  "decision (entry|logged)",
+  "decision-log entry",
+  "decision log entry",
+  "decision log(s|ged|ging)?([^a-z]|$)",
+  "decision-log",
+  "decision entr",
+  "decisions? (are |is )?logged",
+  "log entries",
+  String.raw`decisions\.md`,
+  "decisions-legacy",
+  "CONTRADICTION",
+  "assumes Tier 3",
+  "Lock: ?YES",
+  "Lock: ?NO",
+  "lock approvals?",
+  "approves locks",
+  "Conforms to lock",
+  "Challenges lock",
+  "checkDecisionNumbersFresh",
+  String.raw`roles/team-leader\.md`,
+  String.raw`\(,`,
+  String.raw`,\)`,
+  String.raw`\(\.\)`
+];
+var RETIRED_EXEMPT_SUBSTRINGS = [
+  "docs/decisions-legacy.md",
+  "apps/herald-ai/docs/",
+  "apps/vada-ai/docs/",
+  "aeg-root/tranches/completed/",
+  "packages/aeg-core/src/docs/published-prose",
+  "packages/aeg-core/src/retired-vocabulary.test.ts",
+  "packages/aeg-core/src/retired-vocabulary.ts",
+  "/fixtures/",
+  "/node_modules/",
+  "/.next/",
+  "/.turbo/"
+];
+var PATTERN_EXEMPT = {
+  [String.raw`\bD-[0-9]{3}\b`]: ["./CLAUDE.md"],
+  [String.raw`decisions\.md`]: [
+    "docs-index.md",
+    "apps/vada-ai/specs/legacy/README.md",
+    "apps/vada-ai/specs/vada-product-spec.md",
+    "apps/vada-ai/web/CLAUDE.md",
+    "apps/vada-ai/CLAUDE.md"
+  ],
+  "decisions-legacy": [
+    "packages/aeg-core/src/file-classify.ts",
+    "packages/aeg-core/src/file-classify.test.ts",
+    "packages/aeg-core/src/pr-tier.test.ts",
+    "docs-index.md",
+    ".claude/skills/database/SKILL.md",
+    ".claude/skills/vada-architecture/SKILL.md",
+    "apps/vada-ai/specs/vada-byok-principles.md",
+    "apps/vada-ai/web/CLAUDE.md",
+    "apps/vada-ai/CLAUDE.md"
+  ],
+  CONTRADICTION: ["apps/vada-ai/specs/vada-reviewers-spec.md"]
+};
+function lineNumbers(content, pattern) {
+  const out = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    if (pattern.test(lines[i] ?? ""))
+      out.push(i + 1);
+  }
+  return out;
+}
+function scanRetiredVocabulary(files) {
+  const findings = [];
+  for (const file of files) {
+    if (RETIRED_EXEMPT_SUBSTRINGS.some((e) => file.path.includes(e)))
+      continue;
+    for (const pattern of RETIRED_PATTERNS) {
+      const patternExempt = PATTERN_EXEMPT[pattern] ?? [];
+      if (patternExempt.some((e) => file.path.includes(e)))
+        continue;
+      const re = new RegExp(pattern);
+      for (const line of lineNumbers(file.content, re)) {
+        findings.push({
+          file: file.path,
+          line,
+          pattern,
+          message: `claims a retired AEG mechanism is still live (matches /${pattern}/)`
+        });
+      }
+    }
+  }
+  return findings;
+}
 // ../../packages/aeg-core/src/dispatch-gate.ts
 function isHandClosedByRecognizedPrincipal(dep, principalAllowlist) {
   return dep.issueState === "closed" && dep.stateReason === "completed" && isPrincipal(dep.closedByActor ?? null, principalAllowlist);
@@ -3163,6 +3265,274 @@ function evaluateTestPlanGate(body, branch) {
   messages.push("All Test Plan items ticked — runtime verification complete.", "PASS.");
   return { verdict: "pass", messages };
 }
+// src/lib/config.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } 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 ManagedBlockRecordSchema = z.object({
+  path: SafeRepoRelPath,
+  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 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(),
+  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()
+});
+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 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 };
+  }
+  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(readFileSync(path, "utf-8"));
+    return stripGlobalOnlyKeys(VinayaConfigSchema.parse(raw), path);
+  } catch {
+    return null;
+  }
+}
+
 // src/checks/contract.ts
 var CHECK_SCHEMA_VERSION = 1;
 function emitCheckError(error) {
@@ -3171,12 +3541,14 @@ function emitCheckError(error) {
 }
 
 // src/checks/bin/check-reader-resolvable-prose.ts
-var REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "../../../../..");
-process.chdir(REPO_ROOT);
 var CHECK_NAME = "reader-resolvable-prose";
-var READER_FACING_ROOT = null;
-var READER_FACING_SUFFIX = "/page.tsx";
-function collect(dir, match, out = []) {
+var proseGates = loadConfig()?.proseGates;
+var DOCTRINE_ROOT = proseGates?.doctrineRoot ?? "aeg-root";
+var READER_FACING_PREFIX = proseGates?.readerFacingPrefix ?? null;
+var READER_FACING_SUFFIX = proseGates?.readerFacingSuffix ?? null;
+var READER_FACING_ACTIVE = READER_FACING_PREFIX !== null && READER_FACING_SUFFIX !== null;
+var LEGACY_SLUG_DIR = proseGates?.legacySlugDir ?? `${DOCTRINE_ROOT}/tranches/completed`;
+function collect(dir, out = []) {
   let entries;
   try {
     entries = readdirSync(dir);
@@ -3184,7 +3556,7 @@ function collect(dir, match, out = []) {
     return out;
   }
   for (const name of entries) {
-    const full = join(dir, name);
+    const full = join2(dir, name);
     let isDir;
     try {
       isDir = statSync(full).isDirectory();
@@ -3194,37 +3566,39 @@ function collect(dir, match, out = []) {
     if (isDir) {
       if (name === "node_modules" || name === ".next" || name === ".turbo")
         continue;
-      collect(full, match, out);
-    } else if (match(name)) {
+      collect(full, out);
+    } else {
       out.push(full);
     }
   }
   return out;
 }
 function readAll(paths) {
-  return paths.map((p) => ({ path: p, content: readFileSync(p, "utf8") }));
+  return paths.map((p) => ({ path: p, content: readFileSync2(p, "utf8") }));
 }
 function legacySlugs() {
-  const dir = join(REPO_ROOT, "aeg-root/tranches/completed");
-  if (!existsSync(dir))
+  if (!existsSync2(LEGACY_SLUG_DIR))
     return { slugs: [], dormant: true };
   try {
-    const slugs = readdirSync(dir).filter((f) => f.endsWith(".md") && !f.endsWith(".tokens.md")).map((f) => f.slice(0, -3)).filter((slug) => !/-v[0-9]+$/.test(slug));
+    const slugs = readdirSync(LEGACY_SLUG_DIR).filter((f) => f.endsWith(".md") && !f.endsWith(".tokens.md")).map((f) => f.slice(0, -3)).filter((slug) => !/-v[0-9]+$/.test(slug));
     return { slugs, dormant: false };
   } catch (err) {
-    console.error(`${CHECK_NAME}: could not read ${dir} (${err instanceof Error ? err.message : String(err)}) — legacy-slug class treated as dormant.`);
+    console.log(`${CHECK_NAME}: could not read ${LEGACY_SLUG_DIR} (${err instanceof Error ? err.message : String(err)}) — legacy-slug class treated as dormant.`);
     return { slugs: [], dormant: true };
   }
 }
 function main() {
-  const shipsPaths = collect("aeg-root", (name) => name.endsWith(".md"));
-  const readerFacingPaths = READER_FACING_ROOT !== null ? collect(READER_FACING_ROOT, (name) => name === "page.tsx") : [];
+  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 glossaryTerms = parseGlossaryTerms(readFileSync(join(REPO_ROOT, "aeg-root/glossary.md"), "utf8"));
+  const glossaryPath = join2(DOCTRINE_ROOT, "glossary.md");
+  const glossaryTerms = existsSync2(glossaryPath) ? parseGlossaryTerms(readFileSync2(glossaryPath, "utf8")) : [];
   const { slugs, dormant: legacySlugsDormant } = legacySlugs();
-  const readerFacingPrefix = READER_FACING_ROOT !== null ? `${READER_FACING_ROOT}/` : "/no-reader-facing-surface";
-  const findings = checkReaderResolvableProse(files, glossaryTerms, readerFacingPrefix, READER_FACING_SUFFIX, slugs);
-  console.error(`${CHECK_NAME}: reader-facing class ${READER_FACING_ROOT !== null ? "ran" : "dormant — no reader-facing surface (e.g. apps/*/web) in this repo"}; ` + `legacy-slug class ${legacySlugsDormant ? "dormant — aeg-root/tranches/completed is absent in this repo" : `ran (${slugs.length} slug(s))`}; ` + `${findings.length} finding(s)`);
+  const readerFacingPrefix = READER_FACING_ACTIVE && READER_FACING_PREFIX !== null ? `${READER_FACING_PREFIX}/` : "/no-reader-facing-surface";
+  const readerFacingSuffix = READER_FACING_ACTIVE && READER_FACING_SUFFIX !== null ? READER_FACING_SUFFIX : "/page.tsx";
+  const findings = checkReaderResolvableProse(files, glossaryTerms, readerFacingPrefix, readerFacingSuffix, slugs, shipsPrefix);
+  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 — ${LEGACY_SLUG_DIR} is absent` : `ran (${slugs.length} slug(s))`}; ` + `${findings.length} finding(s)`);
   for (const finding of findings) {
     emitCheckError({
       schema: CHECK_SCHEMA_VERSION,
@@ -3233,7 +3607,7 @@ function main() {
       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 `aeg-root/glossary.md` uses) at its first use on ' + "this page, or link to `/docs/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." : "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);