@nimiplatform/nimi-coding 0.3.1 → 0.5.0

package/cli/help.mjs

@@ -1,28 +1,19 @@
 import { VERSION } from "./constants.mjs";
+import { AUTHORITY_ANCHOR_GRAMMAR_HELP } from "./lib/authority/anchors.mjs";
+import { AUTHORITY_COMMAND_USAGE } from "./commands/authority.mjs";
 import { localize, styleCommand, styleHeading, styleMuted } from "./lib/ui.mjs";
 
 export function helpText() {
   const commands = [
+    // The authority list comes from the command module itself so help and the
+    // parser cannot describe different surfaces.
+    ...AUTHORITY_COMMAND_USAGE,
     "nimicoding start [--yes]",
     "nimicoding sync [--apply|--check|--dry-run] [--json]",
     "nimicoding clear [--yes]",
     "nimicoding doctor [--verbose|--json]",
-    "nimicoding blueprint-audit [--blueprint-root <path>] [--canonical-root <path>] [--json] [--write-local]",
-    "nimicoding validate-spec-tree [.nimi/spec]",
-    "nimicoding validate-spec-audit [.nimi/local/state/spec-generation/spec-generation-audit.yaml]",
-    "nimicoding classify-spec-tree --profile <profile-id> --root .nimi/spec [--emit <path>] [--json]",
-    "nimicoding generate-spec-migration-plan --profile <profile-id> --root .nimi/spec --emit .nimi/local/state/spec-surface/migration-plan.json [--json]",
-    "nimicoding validate-placement --profile <profile-id> --root .nimi/spec [--json]",
-    "nimicoding validate-table-family --profile <profile-id> --root .nimi/spec [--json]",
-    "nimicoding validate-projection-edges --profile <profile-id> --root .nimi/spec [--json]",
-    "nimicoding validate-guidance-bodies --profile <profile-id> --root .nimi/spec [--json]",
-    "nimicoding validate-domain-admission --profile <profile-id> --root .nimi/spec [--json]",
-    "nimicoding validate-tracked-output-admission --profile <profile-id> --root .nimi/spec [--json]",
-    "nimicoding validate-spec-governance --profile <profile-id> --scope <all|host-defined-scope>",
-    "nimicoding generate-spec-derived-docs --profile <profile-id> --scope <all|host-defined-scope> [--check]",
-    "nimicoding validate-ai-governance --profile <profile-id> --scope <all|agents-freshness|context-budget|structure-budget|high-risk-doc-metadata>",
+    "nimicoding validate-ai-governance --profile <profile-id> --scope <all|agents-freshness|context-budget|structure-budget|high-risk-doc-metadata>  # optional L3 repository governance",
   ];
-
   return [
     styleHeading(`nimicoding ${VERSION}`),
     "",
@@ -31,9 +22,11 @@ export function helpText() {
     `  ${styleCommand("nimicoding --version")}`,
     ...commands.map((command) => `  ${styleCommand(command)}`),
     "",
+    AUTHORITY_ANCHOR_GRAMMAR_HELP,
+    "",
     styleMuted(localize(
-      "Nimi Coding defines methodology, canonical spec construction, and deterministic governance checks. AI task planning and execution belong to the host.",
-      "Nimi Coding 只定义方法论、canonical spec 构建和确定性治理校验；AI 任务规划与执行由宿主负责。",
+      "Nimi Coding provides canonical authority methodology, formatting, compiler primitives, and deterministic gates. The optional L3 repository-governance command is not authority admission. AI task planning and execution belong to the host.",
+      "Nimi Coding 提供 canonical authority 方法论、格式化、编译器原语与确定性 gate。可选 L3 repository-governance 命令不属于 authority admission；AI 任务规划与执行由宿主负责。",
     )),
     "",
   ].join("\n");

package/cli/index.mjs

@@ -1,43 +1,19 @@
-import { runBlueprintAudit } from "./commands/blueprint-audit.mjs";
-import { runClassifySpecTree } from "./commands/classify-spec-tree.mjs";
+import { runAuthority } from "./commands/authority.mjs";
 import { runClear } from "./commands/clear.mjs";
 import { runDoctor } from "./commands/doctor.mjs";
-import { runGenerateSpecDerivedDocs } from "./commands/generate-spec-derived-docs.mjs";
-import { runGenerateSpecMigrationPlan } from "./commands/generate-spec-migration-plan.mjs";
 import { runStart } from "./commands/start.mjs";
 import { runSync } from "./commands/sync.mjs";
 import { runValidateAiGovernance } from "./commands/validate-ai-governance.mjs";
-import { runValidateDomainAdmission } from "./commands/validate-domain-admission.mjs";
-import { runValidateGuidanceBodies } from "./commands/validate-guidance-bodies.mjs";
-import { runValidatePlacement } from "./commands/validate-placement.mjs";
-import { runValidateProjectionEdges } from "./commands/validate-projection-edges.mjs";
-import { runValidateSpecAudit } from "./commands/validate-spec-audit.mjs";
-import { runValidateSpecGovernance } from "./commands/validate-spec-governance.mjs";
-import { runValidateSpecTree } from "./commands/validate-spec-tree.mjs";
-import { runValidateTableFamily } from "./commands/validate-table-family.mjs";
-import { runValidateTrackedOutputAdmission } from "./commands/validate-tracked-output-admission.mjs";
 import { helpText } from "./help.mjs";
 import { VERSION } from "./constants.mjs";
 import { configureCliUi, localize, parseGlobalUiOptions } from "./lib/ui.mjs";
 
 const COMMANDS = {
+  authority: runAuthority,
   start: runStart,
   sync: runSync,
   clear: runClear,
   doctor: runDoctor,
-  "blueprint-audit": runBlueprintAudit,
-  "validate-spec-governance": runValidateSpecGovernance,
-  "validate-spec-audit": runValidateSpecAudit,
-  "validate-spec-tree": runValidateSpecTree,
-  "classify-spec-tree": runClassifySpecTree,
-  "validate-placement": runValidatePlacement,
-  "validate-table-family": runValidateTableFamily,
-  "validate-projection-edges": runValidateProjectionEdges,
-  "validate-guidance-bodies": runValidateGuidanceBodies,
-  "validate-domain-admission": runValidateDomainAdmission,
-  "validate-tracked-output-admission": runValidateTrackedOutputAdmission,
-  "generate-spec-derived-docs": runGenerateSpecDerivedDocs,
-  "generate-spec-migration-plan": runGenerateSpecMigrationPlan,
   "validate-ai-governance": runValidateAiGovernance,
 };
 
@@ -47,47 +23,30 @@ export async function runCli(args) {
     process.stderr.write(parsedUi.error);
     return 2;
   }
-
-  configureCliUi({
-    locale: parsedUi.locale,
-    colorEnabled: parsedUi.colorEnabled,
-  });
-
+  configureCliUi({ locale: parsedUi.locale, colorEnabled: parsedUi.colorEnabled });
   const [command] = parsedUi.args;
   const rest = parsedUi.args.slice(1);
 
   if (!command || command === "--help" || command === "-h" || command === "help") {
     if (rest.length > 0) {
-      process.stderr.write(localize(
-        `nimicoding help refused: unexpected arguments: ${rest.join(" ")}\n`,
-        `nimicoding help 拒绝执行：存在未预期参数：${rest.join(" ")}\n`,
-      ));
+      process.stderr.write(localize(`nimicoding help refused: unexpected arguments: ${rest.join(" ")}\n`, `nimicoding help 拒绝执行：存在未预期参数：${rest.join(" ")}\n`));
       return 2;
     }
     process.stdout.write(helpText());
     return 0;
   }
-
   if (command === "--version" || command === "-v" || command === "version") {
     if (rest.length > 0) {
-      process.stderr.write(localize(
-        `nimicoding version refused: unexpected arguments: ${rest.join(" ")}\n`,
-        `nimicoding version 拒绝执行：存在未预期参数：${rest.join(" ")}\n`,
-      ));
+      process.stderr.write(localize(`nimicoding version refused: unexpected arguments: ${rest.join(" ")}\n`, `nimicoding version 拒绝执行：存在未预期参数：${rest.join(" ")}\n`));
       return 2;
     }
     process.stdout.write(`${VERSION}\n`);
     return 0;
   }
-
   const runner = COMMANDS[command];
   if (!runner) {
-    process.stderr.write(localize(
-      `Unknown command: ${command}\n\n${helpText()}`,
-      `未知命令：${command}\n\n${helpText()}`,
-    ));
+    process.stderr.write(localize(`Unknown command: ${command}\n\n${helpText()}`, `未知命令：${command}\n\n${helpText()}`));
     return 2;
   }
-
   return runner(rest);
 }

package/cli/lib/authority/anchors.mjs

@@ -0,0 +1,491 @@
+import { Buffer } from "node:buffer";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import { compileAuthorityPath } from "./compile.mjs";
+import { compareText, makeDiagnostic, sortDiagnostics } from "./diagnostics.mjs";
+import { AuthorityInputError } from "./format.mjs";
+import { AuthorityReviewRefusal } from "./git-snapshot.mjs";
+import {
+  CODE_EXTENSIONS,
+  SEGMENT_PATTERN,
+  continuesPathToken,
+  continuesPathTokenAfter,
+  normativeFields,
+} from "./lexicon.mjs";
+import { resolveRepositoryCorpus } from "./repository-corpus.mjs";
+import { repositoryInventory } from "./repository-inventory.mjs";
+import { loadScopeBindings } from "./scope-bindings.mjs";
+
+const ANCHORS_FORMAT = "nimicoding.authority-anchors/v1";
+const SCRIPT_NAME = /^[a-z][a-z0-9:-]*$/;
+export const PNPM_BUILTIN_SUBCOMMANDS = new Set([
+  "add", "audit", "create", "dlx", "exec", "install", "link", "list",
+  "outdated", "patch", "publish", "remove", "run", "update", "why",
+]);
+const NON_WHITESPACE = /\S+/gu;
+const UTF8 = new TextDecoder("utf-8", { fatal: true });
+
+export const AUTHORITY_ANCHOR_GRAMMAR_HELP = [
+  "Authority anchors use a closed lexical grammar over active statement, condition, failure, and meaning fields:",
+  `  A: a maximal non-whitespace token containing "/" and ending exactly in .<${CODE_EXTENSIONS.join("|")}>.`,
+  `  A excludes tokens beginning with "~" (including "~/"), "/", an ASCII-letter Windows drive prefix such as "C:\\" or "C:/", or "\\\\" (UNC).`,
+  "  B: pnpm, one ASCII space, and a maximal non-whitespace script-name token; the name must contain ':' or fully match [a-z][a-z0-9:-]*.",
+  `  B excludes pnpm builtin subcommands: ${[...PNPM_BUILTIN_SUBCOMMANDS].join(", ")}.`,
+  `  C: with --embedded-paths, maximal embedded <root>/<segment>(/<segment>)*.<${CODE_EXTENSIONS.join("|")}> substrings, where segment is [A-Za-z0-9_.-]+ and roots come from Git tracked top-level segments plus .nimi.`,
+  "Admitted tokens are checked exactly without path normalization or command execution.",
+].join("\n");
+
+function validBudget(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+function baseDiagnostic(code, reason, repair, file = ".", range = null, pointer = "") {
+  return makeDiagnostic({
+    code,
+    file,
+    range: range ?? { start: { line: 1, column: 1 }, end: { line: 1, column: 1 } },
+    pointer,
+    reason,
+    repair,
+  });
+}
+
+function budgetDiagnostic(kind, required, admitted, mapped = null) {
+  return baseDiagnostic(
+    "AUTH_ANCHOR_BUDGET",
+    `complete authority anchor validation requires ${required} ${kind} but ${kind === "UTF-8 bytes" ? "max-bytes" : kind === "active units" ? "max-units" : "max-anchors"} is ${admitted}`,
+    "increase the explicit anchor budget; partial lexical anchor validation is forbidden",
+    mapped?.file ?? ".",
+    mapped?.range,
+    mapped?.sourcePointer ?? "",
+  );
+}
+
+function refused(diagnostics, { fileCount = 0, anchorsBytes = 0 } = {}) {
+  return {
+    ok: false,
+    complete: false,
+    partial: false,
+    diagnostics: sortDiagnostics(diagnostics),
+    fileCount,
+    unitCount: 0,
+    anchorsChecked: 0,
+    anchorsBytes,
+  };
+}
+
+function fieldLocation(compiled, unitIndex, field) {
+  return compiled.sourceMap.fields[`/units/${unitIndex}/semantic/${field}`] ?? null;
+}
+
+function unitLocation(compiled, unitIndex) {
+  return compiled.sourceMap.fields[`/units/${unitIndex}/id`] ?? null;
+}
+
+function tokenRecords(text) {
+  return [...text.matchAll(NON_WHITESPACE)].map((match) => ({ text: match[0], start: match.index, end: match.index + match[0].length }));
+}
+
+function hasNonRepositoryPathPrefix(token) {
+  const firstCodeUnit = token.charCodeAt(0);
+  const hasAsciiDrivePrefix = token.length >= 3
+    && ((firstCodeUnit >= 65 && firstCodeUnit <= 90) || (firstCodeUnit >= 97 && firstCodeUnit <= 122))
+    && token[1] === ":"
+    && (token[2] === "/" || token[2] === "\\");
+  return token.startsWith("~")
+    || token.startsWith("/")
+    || token.startsWith("\\\\")
+    || hasAsciiDrivePrefix;
+}
+
+function isPathAnchor(token) {
+  return !hasNonRepositoryPathPrefix(token)
+    && !token.includes("<")
+    && !token.includes(">")
+    && token.includes("/")
+    && CODE_EXTENSIONS.some((extension) => token.endsWith(`.${extension}`));
+}
+
+export function extractLexicalAnchors(text) {
+  const tokens = tokenRecords(text);
+  const anchors = [];
+  for (const token of tokens) {
+    if (isPathAnchor(token.text)) anchors.push({ type: "path", text: token.text });
+  }
+  for (let index = 0; index + 1 < tokens.length; index += 1) {
+    const command = tokens[index];
+    const script = tokens[index + 1];
+    if (command.text !== "pnpm" || text.slice(command.end, script.start) !== " ") continue;
+    if (PNPM_BUILTIN_SUBCOMMANDS.has(script.text)) continue;
+    if (!script.text.includes(":") && !SCRIPT_NAME.test(script.text)) continue;
+    anchors.push({ type: "script", text: `pnpm ${script.text}`, script: script.text });
+  }
+  return anchors;
+}
+
+function compareAnchor(left, right) {
+  return compareText(left.unitId, right.unitId)
+    || compareText(left.text, right.text)
+    || compareText(left.field, right.field)
+    || compareText(left.type, right.type);
+}
+
+function escapeRegularExpression(text) {
+  return text.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+function repositoryPathRoots(trackedFiles) {
+  const roots = new Set([".nimi"]);
+  for (const file of trackedFiles) {
+    const separator = file.indexOf("/");
+    const root = separator === -1 ? file : file.slice(0, separator);
+    if (root.length > 0) roots.add(root);
+  }
+  return [...roots].sort((left, right) => right.length - left.length || compareText(left, right));
+}
+
+function hasExcludedEmbeddedPathCharacter(token, start, end) {
+  const pathLike = /[A-Za-z0-9_./*<>-]/u;
+  let contextStart = start;
+  let contextEnd = end;
+  while (contextStart > 0 && pathLike.test(token[contextStart - 1])) contextStart -= 1;
+  while (contextEnd < token.length && pathLike.test(token[contextEnd])) contextEnd += 1;
+  const context = token.slice(contextStart, contextEnd);
+  return context.includes("*") || context.includes("<") || context.includes(">");
+}
+
+function extractEmbeddedPathAnchors(text, roots) {
+  const rootExpression = roots.map(escapeRegularExpression).join("|");
+  if (rootExpression.length === 0) return [];
+  const segment = SEGMENT_PATTERN;
+  const extensions = [...CODE_EXTENSIONS].sort((left, right) => right.length - left.length || compareText(left, right));
+  const expression = new RegExp(
+    `(?:${rootExpression})/${segment}(?:/${segment})*\\.(?:${extensions.join("|")})`,
+    "gu",
+  );
+  const anchors = [];
+  for (const token of tokenRecords(text)) {
+    if (isPathAnchor(token.text)) continue;
+    for (const match of token.text.matchAll(expression)) {
+      // The boundary test must use the same alphabet the segment pattern
+      // admits. Testing only [A-Za-z0-9] let "retired-src/live.ts" report a
+      // live "src/live.ts" that no file was ever named, while treating every
+      // leading separator as a longer path hid "./src/dead.ts" entirely.
+      if (continuesPathToken(token.text, match.index)) continue;
+      if (continuesPathTokenAfter(token.text, match.index + match[0].length)) continue;
+      if (hasExcludedEmbeddedPathCharacter(token.text, match.index, match.index + match[0].length)) continue;
+      anchors.push({ type: "embedded-path", text: match[0] });
+    }
+  }
+  return anchors;
+}
+
+function extractCorpusAnchors(compiled) {
+  const active = [];
+  const anchors = [];
+  compiled.ir.units.forEach((unit, unitIndex) => {
+    if (unit.lifecycle !== "active") return;
+    active.push({ unit, unitIndex });
+    const fields = normativeFields(unit.kind);
+    for (const field of fields) {
+      for (const anchor of extractLexicalAnchors(unit.semantic[field])) {
+        anchors.push({
+          ...anchor,
+          unitId: unit.id,
+          field,
+          location: fieldLocation(compiled, unitIndex, field),
+        });
+      }
+    }
+  });
+  anchors.sort(compareAnchor);
+  return { active, anchors };
+}
+
+function extractCorpusEmbeddedPathAnchors(compiled, trackedFiles) {
+  const anchors = [];
+  const roots = repositoryPathRoots(trackedFiles);
+  compiled.ir.units.forEach((unit, unitIndex) => {
+    if (unit.lifecycle !== "active") return;
+    const fields = normativeFields(unit.kind);
+    for (const field of fields) {
+      for (const anchor of extractEmbeddedPathAnchors(unit.semantic[field], roots)) {
+        anchors.push({
+          ...anchor,
+          unitId: unit.id,
+          field,
+          location: fieldLocation(compiled, unitIndex, field),
+        });
+      }
+    }
+  });
+  return anchors;
+}
+
+function anchorDiagnostic(anchor, code, reason, repair) {
+  return {
+    ...baseDiagnostic(
+      code,
+      reason,
+      repair,
+      anchor.location?.file ?? ".",
+      anchor.location?.range,
+      anchor.location?.sourcePointer ?? "",
+    ),
+    unitId: anchor.unitId,
+    field: anchor.field,
+    anchor: anchor.text,
+  };
+}
+
+function globRegularExpression(glob) {
+  let expression = "^";
+  for (let index = 0; index < glob.length; index += 1) {
+    const character = glob[index];
+    if (character === "*" && glob[index + 1] === "*") {
+      if (glob[index + 2] === "/") {
+        expression += "(?:.*/)?";
+        index += 2;
+      } else {
+        expression += ".*";
+        index += 1;
+      }
+    } else if (character === "*") expression += "[^/]*";
+    else if (character === "?") expression += "[^/]";
+    else expression += character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  }
+  return new RegExp(`${expression}$`, "u");
+}
+
+function scopeGlobDiagnostics(scopes, trackedFiles) {
+  const diagnostics = [];
+  for (const entry of scopes) {
+    for (const binding of entry.bindings) {
+      if (binding.kind !== "path_glob") continue;
+      const matches = globRegularExpression(binding.value);
+      if (trackedFiles.some((file) => matches.test(file))) continue;
+      diagnostics.push({
+        ...baseDiagnostic(
+          "AUTH_ANCHOR_SCOPE_GLOB_UNRESOLVED",
+          `scope path_glob matches no Git tracked file: scope=${entry.scope}; glob=${binding.value}`,
+          "correct the explicit scope path_glob or add the intended file to the Git index; do not infer a repository binding",
+          binding.location.file,
+          binding.location.range,
+          binding.location.sourcePointer,
+        ),
+        scope: entry.scope,
+        glob: binding.value,
+      });
+    }
+  }
+  return diagnostics;
+}
+
+async function repositoryScriptNames(repository) {
+  const manifest = path.join(repository, "package.json");
+  let bytes;
+  try {
+    bytes = await readFile(manifest);
+  } catch (error) {
+    return { names: new Set(), error: `repository root package.json is not readable: ${error.message}` };
+  }
+  let text;
+  try {
+    text = UTF8.decode(bytes);
+  } catch {
+    return { names: new Set(), error: "repository root package.json is not valid UTF-8" };
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    return { names: new Set(), error: `repository root package.json is not valid JSON: ${error.message}` };
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)
+    || value.scripts === null || typeof value.scripts !== "object" || Array.isArray(value.scripts)) {
+    return { names: new Set(), error: "repository root package.json requires one scripts object" };
+  }
+  return { names: new Set(Object.keys(value.scripts)), error: null };
+}
+
+function compareAnchorDiagnostic(left, right) {
+  const leftAnchor = left.unitId !== undefined;
+  const rightAnchor = right.unitId !== undefined;
+  if (leftAnchor && rightAnchor) {
+    return compareText(left.unitId, right.unitId)
+      || compareText(left.anchor, right.anchor)
+      || compareText(left.field, right.field)
+      || compareText(left.code, right.code);
+  }
+  if (leftAnchor !== rightAnchor) return leftAnchor ? -1 : 1;
+  if (left.scope !== undefined && right.scope !== undefined) {
+    return compareText(left.scope, right.scope) || compareText(left.glob, right.glob);
+  }
+  return compareText(left.path, right.path)
+    || left.range.start.line - right.range.start.line
+    || left.range.start.column - right.range.start.column
+    || compareText(left.code, right.code);
+}
+
+function canonicalAnchorsBytes(summary, diagnostics) {
+  return Buffer.byteLength(JSON.stringify({
+    format: ANCHORS_FORMAT,
+    complete: true,
+    summary,
+    diagnostics,
+  }), "utf8");
+}
+
+function corpusInputDiagnostic(error) {
+  return baseDiagnostic(
+    "AUTH_ANCHOR_CORPUS_INVALID",
+    error.message,
+    "provide one complete admitted canonical authority corpus; partial or unsupported input is forbidden",
+  );
+}
+
+function repositoryDiagnostic(error) {
+  return baseDiagnostic(
+    "AUTH_ANCHOR_REPOSITORY_INVALID",
+    error.message,
+    "provide one exact readable Git worktree root; lexical anchors are never checked against a partial repository inventory",
+    error.file ?? ".",
+  );
+}
+
+export async function anchorsAuthorityRepository(repositoryPath, specPath, scopeBindingsPath, { maxUnits, maxAnchors, maxBytes, embeddedPaths = false }) {
+  if (![maxUnits, maxAnchors, maxBytes].every(validBudget)) {
+    return refused([baseDiagnostic(
+      "AUTH_ANCHOR_BUDGET",
+      "authority anchor budgets must be positive safe integers",
+      "provide explicit positive safe max-units, max-anchors, and max-bytes budgets",
+    )]);
+  }
+
+  try {
+    await resolveRepositoryCorpus(repositoryPath, specPath, "authority anchor");
+  } catch (error) {
+    return refused([baseDiagnostic("AUTH_ANCHOR_CORPUS_INVALID", error.message, "provide the repository authority corpus at .nimi/spec")]);
+  }
+
+  let compiled;
+  try {
+    compiled = await compileAuthorityPath(specPath);
+  } catch (error) {
+    if (error instanceof AuthorityInputError) return refused([corpusInputDiagnostic(error)]);
+    throw error;
+  }
+  if (!compiled.ok) return refused(compiled.diagnostics, { fileCount: compiled.fileCount });
+
+  const extracted = extractCorpusAnchors(compiled);
+  if (extracted.active.length > maxUnits) {
+    return refused([budgetDiagnostic(
+      "active units",
+      extracted.active.length,
+      maxUnits,
+      unitLocation(compiled, extracted.active[0]?.unitIndex ?? 0),
+    )], { fileCount: compiled.fileCount });
+  }
+
+  let scopes = [];
+  if (scopeBindingsPath !== null) {
+    const parsed = await loadScopeBindings(scopeBindingsPath);
+    if (!parsed.ok) return refused(parsed.diagnostics, { fileCount: compiled.fileCount });
+    scopes = parsed.scopes;
+  }
+
+  let inventory;
+  if (embeddedPaths) {
+    try {
+      inventory = await repositoryInventory(repositoryPath);
+    } catch (error) {
+      if (error instanceof AuthorityReviewRefusal) return refused([repositoryDiagnostic(error)], { fileCount: compiled.fileCount });
+      throw error;
+    }
+    extracted.anchors.push(...extractCorpusEmbeddedPathAnchors(compiled, inventory.files));
+    extracted.anchors.sort(compareAnchor);
+  }
+
+  if (extracted.anchors.length > maxAnchors) {
+    return refused([budgetDiagnostic(
+      "lexical anchors",
+      extracted.anchors.length,
+      maxAnchors,
+      extracted.anchors[0]?.location,
+    )], { fileCount: compiled.fileCount });
+  }
+
+  if (inventory === undefined) {
+    try {
+      inventory = await repositoryInventory(repositoryPath);
+    } catch (error) {
+      if (error instanceof AuthorityReviewRefusal) return refused([repositoryDiagnostic(error)], { fileCount: compiled.fileCount });
+      throw error;
+    }
+  }
+  const tracked = new Set(inventory.files);
+  const diagnostics = scopeGlobDiagnostics(scopes, inventory.files);
+  const scriptAnchors = extracted.anchors.filter((anchor) => anchor.type === "script");
+  const scripts = scriptAnchors.length > 0
+    ? await repositoryScriptNames(inventory.repository)
+    : { names: new Set(), error: null };
+
+  for (const anchor of extracted.anchors) {
+    if (anchor.type === "path" && !tracked.has(anchor.text)) {
+      diagnostics.push(anchorDiagnostic(
+        anchor,
+        "AUTH_ANCHOR_PATH_UNRESOLVED",
+        `active unit ${anchor.unitId} field ${anchor.field} references a path anchor that is not a Git tracked file: ${anchor.text}`,
+        "correct the exact lexical path or add the intended file to the Git index; path normalization and inference are forbidden",
+      ));
+    } else if (anchor.type === "embedded-path" && !tracked.has(anchor.text)) {
+      diagnostics.push(anchorDiagnostic(
+        anchor,
+        "AUTH_ANCHOR_EMBEDDED_PATH_UNRESOLVED",
+        `active unit ${anchor.unitId} field ${anchor.field} references an embedded repository path that is not a Git tracked file: ${anchor.text}`,
+        "correct the embedded repository path in the unit text or add the intended file to the Git index; do not infer a target",
+      ));
+    } else if (anchor.type === "script" && !scripts.names.has(anchor.script)) {
+      const detail = scripts.error === null ? "is absent from repository root package.json scripts" : `cannot be resolved because ${scripts.error}`;
+      diagnostics.push(anchorDiagnostic(
+        anchor,
+        "AUTH_ANCHOR_SCRIPT_UNRESOLVED",
+        `active unit ${anchor.unitId} field ${anchor.field} references script ${anchor.text}, which ${detail}`,
+        "declare the exact repository-root package script or correct the lexical anchor; no command is executed",
+      ));
+    }
+  }
+  diagnostics.sort(compareAnchorDiagnostic);
+  const summary = {
+    units: extracted.active.length,
+    anchorsChecked: extracted.anchors.length,
+    diagnostics: diagnostics.length,
+  };
+  const anchorsBytes = canonicalAnchorsBytes(summary, diagnostics);
+  if (anchorsBytes > maxBytes) {
+    return refused([budgetDiagnostic("UTF-8 bytes", anchorsBytes, maxBytes)], {
+      fileCount: compiled.fileCount,
+      anchorsBytes,
+    });
+  }
+  return {
+    ok: diagnostics.length === 0,
+    complete: true,
+    partial: false,
+    diagnostics,
+    fileCount: compiled.fileCount,
+    unitCount: extracted.active.length,
+    anchorsChecked: extracted.anchors.length,
+    anchorsBytes,
+    trackedPathSetDigest: inventory.trackedPathSetDigest,
+  };
+}
+
+export function refuseAnchorsOutputBudget(requiredBytes, admittedBytes) {
+  return refused([budgetDiagnostic("UTF-8 bytes", requiredBytes, admittedBytes)], {
+    anchorsBytes: requiredBytes,
+  });
+}
+
+export { ANCHORS_FORMAT, CODE_EXTENSIONS };