@hawkeyexl/manni 4.0.3 → 4.2.0

package/dist/cli.js

@@ -1,65 +1,108 @@
 #!/usr/bin/env node
 import {
-  buildProgram,
-  collect,
-  configOption,
-  explicitFalse,
-  readStdin,
-  reportConfig,
-  splitList
-} from "./chunk-DEP5AMVA.js";
+  buildProgram
+} from "./chunk-BNHQWIAE.js";
 import {
+  ALL_FILL_FIELDS,
+  CONFIG_SECTION,
   CiteError,
+  DEFAULT_CONFIG_FILENAME2 as DEFAULT_CONFIG_FILENAME,
+  DEFAULT_EXTENSIONS,
+  DocevalsError,
+  EXECUTION_GRANTS,
+  EXPORT_TARGETS,
+  GraphError,
   INFER_FORMATS,
   KeyError,
   LINT_JOBS,
   LintError,
+  REPORT_FORMATS as REPORT_FORMATS2,
   RULE_ID_PREFIX,
+  SEARCH_MODES,
   SEVERITIES,
   SEVERITY_LIST,
+  STDIN,
+  SUMMARY_FORMATS,
   TOOLS_BY_JOB,
   asCiteError,
+  assertInputFormat,
+  bundledShapesPath,
   codeEndAt,
   codeRegions,
+  compactIri,
   errorSite,
   findingMessage,
   isCiteRule,
   isInferFormat,
   isSeverity,
-  loadConfig,
+  listReviews,
+  loadConfig3 as loadConfig,
+  loadGraph,
+  loadRunConfig,
   meetsSeverity,
+  parseFormat,
   rebaseConfig,
   render,
+  render2,
+  renderCalibration,
   renderCheckGithub,
   renderCheckJson,
   renderCheckPretty,
+  renderEmbed,
+  renderFill,
+  renderFill2,
+  renderList,
+  renderQuery,
   renderRemoveJson,
   renderRemovePretty,
+  renderReviews,
+  renderSearch,
+  renderStats,
   renderTemplates,
   renderTools,
+  renderTraverse,
   renderUpdateJson,
   renderUpdatePretty,
   resolveStructureTool,
   runAdd,
+  runBuild,
+  runCalibrate,
   runCheck,
+  runEmbed,
+  runExport,
+  runFill,
+  runFill2,
+  runGenerate,
+  runInit,
   runKeyRotate,
   runKeySet,
   runLint,
+  runList,
+  runPromote,
+  runQuery,
   runRemove,
+  runReview,
+  runRun,
+  runSearch,
+  runStats,
   runTemplates,
   runTemplatesInfer,
   runTools,
+  runTraverse,
   runUpdate,
+  seedGoldenCases,
   shortCommit,
   shortLine,
   shortPin,
   shortSrc,
-  spellSource
-} from "./chunk-JYRY7SKD.js";
+  spellSource,
+  validateGraph
+} from "./chunk-UYDRDFYF.js";
 import {
   COMMON_FORMAT_LIST,
   CONCEPT_FIELDS,
   FAMILY_CONFIG_NAMES,
+  LOCAL_FLAG_HELP,
   OMITTED_WHEN_CLEAN,
   REPORT_FORMATS,
   REPORT_FORMAT_LIST,
@@ -68,9 +111,12 @@ import {
   TERM_RELATION_FIELDS,
   ToolError,
   assertNonEmpty,
+  collect,
+  configOption,
   errorMessage,
   escapeWorkflowCommandMessage,
   escapeWorkflowCommandProperty,
+  explicitFalse,
   extractorByName,
   extractorForExtension,
   fail,
@@ -87,23 +133,28 @@ import {
   palette,
   programName,
   readConfigFile,
+  readStdin,
   registerTermLabelSource,
   renderJunit,
   renderSarif,
+  reportConfig,
   resolveBaselineRequest,
   resolveTargetSet,
   runIfMain,
   selectCollections,
   settleBaseline,
   shouldColor,
+  splitList,
   splitPageArgument,
   terminalConfirm,
   valeConfigPath,
-  valueAt
-} from "./chunk-TQG3WCJY.js";
+  valueAt,
+  warn,
+  writeTextAtomic
+} from "./chunk-TH565O2N.js";
 
 // src/cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/a11y/cli.ts
 import { Command } from "commander";
@@ -203,17 +254,19 @@ async function crawl(opts, analyzer) {
       url = normalizeUrl(raw);
       key = dedupeKey(url);
     } catch {
-      return;
+      return { as: "invalid" };
     }
-    if (source !== "seed" && !isPageLink(url)) return;
-    if (!opts.seeds.some((seed) => sameHost(seed, url))) return;
-    if (opts.exclude?.matches(url) === true) {
+    if (source !== "seed" && !isPageLink(url)) return { as: "asset" };
+    if (!opts.seeds.some((seed) => sameHost(seed, url))) return { as: "off-host" };
+    const pattern = opts.exclude?.match(url) ?? null;
+    if (pattern !== null) {
       excluded.add(key);
-      return;
+      return { as: "excluded", pattern };
     }
-    if (seen.has(key)) return;
+    if (seen.has(key)) return { as: "seen" };
     seen.add(key);
     frontier.push({ url, key, source });
+    return { as: "queued" };
   };
   const landed = (finalUrl) => {
     if (finalUrl === void 0) return;
@@ -230,6 +283,7 @@ async function crawl(opts, analyzer) {
     progress({ kind: "excluded", urls: excluded.size, patterns: opts.exclude?.patterns.length ?? 0 });
   }
   const pages = [];
+  const redirects = [];
   let duplicates = 0;
   const capped = () => opts.maxPages !== void 0 && pages.length >= opts.maxPages;
   for (let next = 0; next < frontier.length && !capped(); next++) {
@@ -242,10 +296,28 @@ async function crawl(opts, analyzer) {
     }
     visited.add(key);
     const index = pages.length + 1;
-    if (index === 1) progress({ kind: "browser" });
+    if (pages.length + redirects.length === 0) progress({ kind: "browser" });
     progress({ kind: "page", index, queued: frontier.length, url });
     try {
       const analyzed = await analyzer.analyze(url, opts.analyze);
+      if ("redirect" in analyzed) {
+        const to = normalized(analyzed.redirect);
+        redirects.push({ url, to, source });
+        progress({ kind: "redirected", index, url, to });
+        const outcome2 = enqueue(to, source);
+        if (source === "seed") {
+          if (!isHttpUrl(to)) {
+            throw new A11yError(`${url} redirects to ${to}, which is not an http(s) URL.`);
+          }
+          if (outcome2.as === "off-host") {
+            throw new A11yError(`${url} redirects to ${to}, which is on another host. Check ${to} instead.`);
+          }
+          if (outcome2.as === "excluded") {
+            throw new A11yError(`${outcome2.pattern.source} excludes ${to}, where the seed ${url} redirects.`);
+          }
+        }
+        continue;
+      }
       pages.push({ ...analyzed.result, url, source });
       landed(analyzed.finalUrl);
       if (opts.crawl) for (const link of analyzed.links) enqueue(link, "link");
@@ -257,9 +329,23 @@ async function crawl(opts, analyzer) {
       progress({ kind: "checked", index, url, violations: 0, error });
     }
   }
-  const skipped2 = frontier.length - pages.length - duplicates;
+  const skipped2 = frontier.length - pages.length - duplicates - redirects.length;
   progress({ kind: "done", checked: pages.length, skipped: skipped2 });
-  return { pages, discovered: frontier.length, skipped: skipped2, duplicates, excluded: excluded.size };
+  return {
+    pages,
+    discovered: frontier.length,
+    skipped: skipped2,
+    duplicates,
+    redirects,
+    excluded: excluded.size
+  };
+}
+function normalized(url) {
+  try {
+    return normalizeUrl(url);
+  } catch {
+    return url;
+  }
 }
 
 // src/a11y/core/exclude.ts
@@ -501,6 +587,7 @@ async function runCheck2(opts, deps) {
     const results = outcome2.pages.map((page) => finishPage(page, opts.severity));
     return {
       results,
+      redirects: outcome2.redirects,
       summary: summarize(results, outcome2, sitemap, opts.crawl)
     };
   } finally {
@@ -514,7 +601,7 @@ function finishPage(page, floor) {
   const score = applicable === 0 ? null : Math.round(100 * page.passes / applicable);
   return { ...page, violations, score };
 }
-function summarize(results, { discovered, skipped: skipped2, duplicates, excluded }, sitemap, crawl2) {
+function summarize(results, { discovered, skipped: skipped2, duplicates, redirects, excluded }, sitemap, crawl2) {
   const bySeverity = { notice: 0, warning: 0, error: 0 };
   let failed = 0;
   let violations = 0;
@@ -530,6 +617,7 @@ function summarize(results, { discovered, skipped: skipped2, duplicates, exclude
     checked: results.length,
     skipped: skipped2,
     duplicates,
+    redirects: redirects.length,
     excluded,
     failed,
     violations,
@@ -574,33 +662,18 @@ function createPlaywrightAnalyzer() {
   return {
     async analyze(url, opts) {
       const { page } = await open();
+      const navigations = [];
+      const onRequest = (request) => {
+        if (request.isNavigationRequest() && request.frame() === page.mainFrame() && request.redirectedFrom() === null) {
+          navigations.push(request);
+        }
+      };
+      page.on("request", onRequest);
       try {
-        await page.goto(url, { waitUntil: "load", timeout: opts.timeout });
-      } catch (err) {
-        throw new A11yError(`Could not load ${url}: ${reason(err)}`);
-      }
-      const links = await page.$$eval(
-        "a[href]",
-        (anchors) => anchors.map((a) => a.href)
-      );
-      let builder = new AxeBuilder({ page });
-      if (opts.tags.length > 0) builder = builder.withTags(opts.tags);
-      let results;
-      try {
-        results = await builder.analyze();
-      } catch (err) {
-        throw new A11yError(`Could not analyze ${url}: ${reason(err)}`);
+        return await analyzePage(page, url, opts, navigations);
+      } finally {
+        page.off("request", onRequest);
       }
-      return {
-        result: {
-          url,
-          violations: results.violations.map(toViolation),
-          passes: results.passes.length,
-          incomplete: results.incomplete.length
-        },
-        links,
-        finalUrl: page.url()
-      };
     },
     async close() {
       if (session === null) return;
@@ -614,6 +687,103 @@ function createPlaywrightAnalyzer() {
     }
   };
 }
+async function analyzePage(page, url, opts, navigations) {
+  let response;
+  try {
+    response = await page.goto(url, { waitUntil: "load", timeout: opts.timeout });
+  } catch (err) {
+    throw new A11yError(`Could not load ${url}: ${reason(err)}`);
+  }
+  const loaded = response?.url() ?? page.url();
+  const nextNavigation = () => {
+    let first = response?.request() ?? null;
+    for (let from = first?.redirectedFrom() ?? null; from !== null; from = from.redirectedFrom()) {
+      first = from;
+    }
+    const own = first === null ? 0 : navigations.indexOf(first);
+    return own === -1 ? void 0 : navigations[own + 1];
+  };
+  const destination = () => nextNavigation()?.url() ?? page.url();
+  const navigatedAway = async () => {
+    if (nextNavigation() === void 0 && samePage(page.url(), loaded)) return null;
+    try {
+      await page.waitForURL((u) => !samePage(u.href, loaded), {
+        waitUntil: "commit",
+        timeout: opts.timeout
+      });
+      return { redirect: destination() };
+    } catch {
+      return null;
+    }
+  };
+  let read8;
+  try {
+    read8 = await page.evaluate(readPage);
+  } catch (err) {
+    const moved = await navigatedAway();
+    if (moved !== null) return moved;
+    throw new A11yError(`Could not analyze ${url}: ${reason(err)}`);
+  }
+  const refresh = refreshTarget(read8.refresh, page.url());
+  if (refresh !== null) return { redirect: refresh };
+  let builder = new AxeBuilder({ page });
+  if (opts.tags.length > 0) builder = builder.withTags(opts.tags);
+  let results;
+  try {
+    results = await builder.analyze();
+  } catch (err) {
+    const moved = await navigatedAway();
+    if (moved !== null) return moved;
+    throw new A11yError(`Could not analyze ${url}: ${reason(err)}`);
+  }
+  if (!samePage(page.url(), loaded)) return { redirect: destination() };
+  return {
+    result: {
+      url,
+      violations: results.violations.map(toViolation),
+      passes: results.passes.length,
+      incomplete: results.incomplete.length
+    },
+    links: read8.links,
+    finalUrl: page.url()
+  };
+}
+function readPage() {
+  const doc = globalThis.document;
+  return {
+    links: Array.from(doc.querySelectorAll("a[href]"), (a) => a.href),
+    refresh: doc.querySelector('meta[http-equiv="refresh" i]')?.getAttribute("content") ?? null
+  };
+}
+function refreshUrl(content) {
+  const match = /^\s*[\d.]*\s*[;,]\s*(?:url\s*=\s*)?(.*)$/is.exec(content);
+  let target = match?.[1]?.trim() ?? "";
+  const quote = target[0];
+  if (quote === "'" || quote === '"') {
+    const end = target.indexOf(quote, 1);
+    target = (end === -1 ? target.slice(1) : target.slice(1, end)).trim();
+  }
+  return target === "" ? null : target;
+}
+function refreshTarget(content, base) {
+  if (content === null) return null;
+  const target = refreshUrl(content);
+  if (target === null) return null;
+  let to;
+  try {
+    to = new URL(target, base).href;
+  } catch {
+    return null;
+  }
+  return samePage(to, base) ? null : to;
+}
+function samePage(a, b) {
+  try {
+    return dedupeKey(a) === dedupeKey(b);
+  } catch {
+    return a === b;
+  }
+}
 function severityOf(impact) {
   switch (impact) {
     case "critical":
@@ -798,8 +968,13 @@ function renderPretty(run, opts) {
     );
     for (const v of page.violations) lines.push(...violationLines(v, c));
   }
+  if (!opts.quiet) {
+    for (const r of run.redirects) {
+      lines.push(`${c.dim("\u21AA")} ${c.cyan(r.url)}  redirects to ${c.cyan(r.to)}`);
+    }
+  }
   const failed = summary.failed;
-  const footer = `${summary.violations} violation${summary.violations === 1 ? "" : "s"} on ${failed} of ${summary.checked} pages` + (summary.skipped > 0 ? `; ${summary.skipped} skipped (--max-pages)` : "") + (summary.duplicates > 0 ? `; ${summary.duplicates} duplicate${summary.duplicates === 1 ? "" : "s"} dropped` : "") + (summary.excluded > 0 ? `; ${summary.excluded} excluded` : "");
+  const footer = `${summary.violations} violation${summary.violations === 1 ? "" : "s"} on ${failed} of ${summary.checked} pages` + (summary.skipped > 0 ? `; ${summary.skipped} skipped (--max-pages)` : "") + (summary.duplicates > 0 ? `; ${summary.duplicates} duplicate${summary.duplicates === 1 ? "" : "s"} dropped` : "") + (summary.redirects > 0 ? `; ${summary.redirects} redirect${summary.redirects === 1 ? "" : "s"}` : "") + (summary.excluded > 0 ? `; ${summary.excluded} excluded` : "");
   lines.push("");
   lines.push(failed > 0 ? c.red(footer) : c.green(footer));
   return lines.join("\n");
@@ -858,7 +1033,7 @@ var A11Y_FORMAT_LIST = A11Y_FORMATS.join(" | ");
 function isA11yFormat(value) {
   return A11Y_FORMATS.includes(value);
 }
-function render2(format, run, opts) {
+function render3(format, run, opts) {
   switch (format) {
     case "pretty":
       return renderPretty(run, opts);
@@ -918,6 +1093,9 @@ function terminalReporter(opts) {
       case "checked":
         showUrl(`${c.dim(counter(event.index, queued))} ${outcome(event, c)}`, event.url);
         return;
+      case "redirected":
+        showUrl(`${c.dim(counter(event.index, queued))} ${c.dim("\u21AA")} redirects to `, event.to);
+        return;
       case "done":
         stream.write(CLEAR_LINE);
         return;
@@ -958,6 +1136,9 @@ function plainReporter(stream) {
         else say(`${head} \u2717 ${plural(event.violations, "violation")}`);
         return;
       }
+      case "redirected":
+        say(`${counter(event.index, queued)} \u21AA redirects to ${event.to}`);
+        return;
       case "done":
         say(`checked ${plural(event.checked, "page")}, ${event.skipped} skipped`);
         return;
@@ -1109,7 +1290,7 @@ function buildProgram2() {
         { analyzer: createPlaywrightAnalyzer(), onProgress: progress.listener }
       );
       const color = resolveColor(parent, process.stdout);
-      const text2 = render2(format, run, { color, quiet: Boolean(options.quiet) });
+      const text2 = render3(format, run, { color, quiet: Boolean(options.quiet) });
       if (text2.length > 0 || format !== "github") {
         process.stdout.write(`${text2}
 `);
@@ -1583,8 +1764,414 @@ function buildProgram3() {
   return program;
 }
 
-// src/key/cli.ts
+// src/docevals/cli.ts
 import { Command as Command3 } from "commander";
+function colorFor2(command, isTTY, env) {
+  const noColor = colorOwner2(command).opts().color === false;
+  return shouldColor({ noColor, isTTY, env });
+}
+function colorOwner2(command) {
+  for (let c = command; c !== null; c = c.parent) {
+    if (c.options.some((o) => o.long === "--no-color")) return c;
+  }
+  return command;
+}
+function buildProgram4() {
+  const program = new Command3();
+  program.name("docevals").description(
+    "Deterministic and LLM-as-judge evals for documentation pages, driven by frontmatter."
+  ).version(package_default.version).option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
+  function collectGrant(value, previous) {
+    if (!EXECUTION_GRANTS.includes(value)) {
+      fail(
+        new DocevalsError(
+          `--allow-execution must be one of ${EXECUTION_GRANTS.join(" | ")}, got "${value}"`
+        )
+      );
+    }
+    return [...previous, value];
+  }
+  function parseIntArg(name) {
+    return (value) => {
+      const n = Number.parseInt(value, 10);
+      if (Number.isNaN(n) || n < 1) {
+        fail(new DocevalsError(`${name} must be a positive integer, got "${value}"`));
+      }
+      return n;
+    };
+  }
+  function collectArg(value, previous) {
+    return [...previous, value];
+  }
+  function parseFloatArg(name) {
+    return (value) => {
+      const n = Number.parseFloat(value);
+      if (Number.isNaN(n) || n < 0) {
+        fail(new DocevalsError(`${name} must be a non-negative number, got "${value}"`));
+      }
+      return n;
+    };
+  }
+  function parseFormatArg(name, allowed) {
+    return (value) => {
+      try {
+        return parseFormat(value, allowed, name);
+      } catch (e) {
+        fail(e);
+      }
+    };
+  }
+  function documentInputs(command, verb) {
+    return command.argument(
+      "[paths...]",
+      `Files, directories, or globs to ${verb} (default: the configured collections)`
+    ).option(
+      "--collection <name>",
+      "Configured collection to read (repeatable)",
+      collect,
+      []
+    ).option("--exclude <glob>", "Glob to exclude (repeatable)", collect, []).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file");
+  }
+  function documentOptions(opts) {
+    const { configPath, noConfig } = configOption(opts.config);
+    return {
+      ...configPath === void 0 ? {} : { config: configPath },
+      ...noConfig === true ? { noConfig } : {},
+      ...opts.collection === void 0 ? {} : { collection: opts.collection },
+      ...opts.exclude === void 0 ? {} : { exclude: opts.exclude }
+    };
+  }
+  documentInputs(
+    program.command("list").description("Show the resolved eval plan per page without running anything"),
+    "list"
+  ).option(
+    "-f, --format <format>",
+    `Output format: ${SUMMARY_FORMATS.join(" | ")}`,
+    parseFormatArg("--format", SUMMARY_FORMATS),
+    "pretty"
+  ).option("--eval <name>", "Show only this eval (repeatable)", collectArg, []).option("--suite <name>", "Show only evals in this suite").action(
+    async (paths, opts, command) => {
+      try {
+        const run = await runList(paths, {
+          ...documentOptions(opts),
+          format: opts.format,
+          evalNames: opts.eval,
+          suite: opts.suite
+        });
+        console.log(
+          renderList(run, opts.format, {
+            color: colorFor2(command, process.stdout.isTTY)
+          })
+        );
+        process.exitCode = run.exitCode;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  documentInputs(
+    program.command("run").description("Run evals against documentation pages"),
+    "evaluate"
+  ).option(
+    "-f, --format <format>",
+    `Output format: ${REPORT_FORMATS2.join(" | ")}`,
+    parseFormatArg("--format", REPORT_FORMATS2),
+    "pretty"
+  ).option("--deterministic-only", "Run only command/tool graders, skip the AI judge").option("--ai-only", "Run only AI-judged evals, skip deterministic graders").option(
+    // `<kind>`, not `<kind...>`: a variadic option greedily eats the
+    // positional `[paths...]` that follow it, so `--allow-execution
+    // frontmatter-commands docs/**` would silently swallow the glob and run
+    // over the default file set instead. Repeat the flag to grant twice.
+    "--allow-execution <kind>",
+    "Grant content-authored execution: frontmatter-commands",
+    collectGrant,
+    []
+  ).option("--no-execution", "Clear every execution grant for this run").option("--no-generate", "Do not generate scripts for command evals missing a command").option("--no-cache", "Bypass the judge response cache").option("--fail-on-review", "Exit 1 when any eval lands in the human-review zone").option("--provider <name>", "Judge provider: auto (default) | anthropic | openai | claude-cli | llama-cpp").option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).option("--runs <n>", "Ensemble runs per eval", parseIntArg("--runs")).option(
+    "--chunk-chars <n>",
+    "Characters of page per judge call; longer pages are read in parts",
+    parseIntArg("--chunk-chars")
+  ).option(
+    "--eval <name>",
+    "Run only this eval (repeatable); suite targets are not evaluated on a filtered run",
+    collectArg,
+    []
+  ).option("--suite <name>", "Run only evals in this suite").option(
+    "--since <ref>",
+    "Evaluate only pages whose file or eval manifest changed between this git ref and HEAD"
+  ).option(
+    "--max-turns <n>",
+    "Stop after this many ensemble runs (a cached ensemble costs none)",
+    parseIntArg("--max-turns")
+  ).option(
+    "--baseline [path]",
+    "Fail only on findings a recorded baseline does not already hold"
+  ).option("--no-baseline", "Ignore the configured baseline for this run").option(
+    "--write-baseline [path]",
+    "Record this run's findings as the baseline; without a path, the configured one"
+  ).action(async (paths, opts, command) => {
+    try {
+      const report = await runRun(paths, {
+        ...documentOptions({
+          config: opts.config,
+          collection: opts.collection,
+          exclude: opts.exclude
+        }),
+        // parseFormatArg validated this at parse time; the cast only re-narrows
+        // from the `unknown` that the Record-typed options bag erases it to.
+        format: opts.format,
+        deterministicOnly: opts.deterministicOnly,
+        aiOnly: opts.aiOnly,
+        allowExecution: opts.allowExecution,
+        execution: opts.execution,
+        generate: opts.generate,
+        cache: opts.cache,
+        failOnReview: opts.failOnReview,
+        provider: opts.provider,
+        model: opts.model,
+        local: opts.local,
+        runs: opts.runs,
+        chunkChars: opts.chunkChars,
+        maxTurns: opts.maxTurns,
+        evalNames: opts.eval,
+        suite: opts.suite,
+        since: opts.since,
+        // commander collapses `--baseline` to true and `--no-baseline` to
+        // false on the same key; a string is an explicit path.
+        baseline: opts.baseline,
+        writeBaseline: opts.writeBaseline,
+        toolVersion: package_default.version
+      });
+      console.log(
+        render(report, opts.format, {
+          color: colorFor2(command, process.stdout.isTTY)
+        })
+      );
+      process.exitCode = report.exitCode;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  documentInputs(
+    program.command("generate").description(
+      "Generate check scripts for command evals with a plain-language assertion but no command"
+    ),
+    "read"
+  ).option("--provider <name>", "Provider: auto (default) | anthropic | openai | claude-cli | llama-cpp").option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).action(
+    async (paths, opts, command) => {
+      try {
+        const pc = palette(colorFor2(command, process.stdout.isTTY));
+        const result = await runGenerate(paths, {
+          ...documentOptions(opts),
+          provider: opts.provider,
+          model: opts.model,
+          local: opts.local
+        });
+        if (result.targets === 0) {
+          console.log("Nothing to generate \u2014 every command eval has a command.");
+          return;
+        }
+        console.log(
+          `Generated ${result.generatedPaths.length}/${result.targets} check script(s):`
+        );
+        for (const p of result.generatedPaths) console.log(`  ${p}`);
+        for (const r of result.refusals) console.log(pc.red(`  ${r.message}`));
+        if (result.generatedPaths.length < result.targets) {
+          process.exitCode = 1;
+        }
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  documentInputs(
+    program.command("fill").description(
+      "Propose frontmatter evals for pages with an LLM; writes proposals at or above the confidence threshold"
+    ),
+    "fill"
+  ).option(
+    "-f, --format <format>",
+    `Output format: ${SUMMARY_FORMATS.join(" | ")}`,
+    parseFormatArg("--format", SUMMARY_FORMATS),
+    "pretty"
+  ).option("--dry-run", "Report proposals without writing frontmatter").option(
+    "--confidence <n>",
+    "Minimum confidence to write (0-1, default: config fill.confidenceThreshold)",
+    parseFloatArg("--confidence")
+  ).option(
+    "--max-turns <n>",
+    "Stop after this many inference calls (a cached page costs none)",
+    parseIntArg("--max-turns")
+  ).option("--no-cache", "Bypass the fill proposal cache").option(
+    "--chunk-chars <n>",
+    "Characters of page per fill call; longer pages are proposed in parts",
+    parseIntArg("--chunk-chars")
+  ).option("--provider <name>", "Provider: auto (default) | anthropic | openai | claude-cli | llama-cpp").option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).action(async (paths, opts, command) => {
+    try {
+      const confidence = opts.confidence;
+      if (confidence !== void 0 && confidence > 1) {
+        fail(new DocevalsError(`--confidence must be between 0 and 1, got ${confidence}`));
+      }
+      const report = await runFill(paths, {
+        ...documentOptions({
+          config: opts.config,
+          collection: opts.collection,
+          exclude: opts.exclude
+        }),
+        dryRun: opts.dryRun,
+        confidence,
+        maxTurns: opts.maxTurns,
+        noCache: opts.cache === false ? true : void 0,
+        provider: opts.provider,
+        model: opts.model,
+        local: opts.local,
+        // P1 (proposal 0047): offered only on a terminal, where there is
+        // someone to answer. Off one the evals go to the page and the W1
+        // line says so.
+        confirm: terminalConfirm(),
+        onNotice: notice,
+        onRelocated: (result) => {
+          const manifests = result.manifests.map((m) => m.file).join(", ");
+          notice(
+            `moved ${String(result.summary.moved)} value(s) into ${manifests}.`
+          );
+        }
+      });
+      console.log(
+        renderFill(report, opts.format, {
+          color: colorFor2(command, process.stdout.isTTY)
+        })
+      );
+      process.exitCode = report.exitCode;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  documentInputs(
+    program.command("promote").description(
+      "Find ai-graded evals expressible as deterministic checks; --write converts them"
+    ),
+    "read"
+  ).option("--write", "Apply promotions (write scripts and rewrite evals)").option("--provider <name>", "Provider: auto (default) | anthropic | openai | claude-cli | llama-cpp").option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).action(
+    async (paths, opts, command) => {
+      try {
+        const pc = palette(colorFor2(command, process.stdout.isTTY));
+        const proposals = await runPromote(paths, {
+          ...documentOptions(opts),
+          write: opts.write,
+          provider: opts.provider,
+          model: opts.model,
+          local: opts.local
+        });
+        if (proposals.length === 0) {
+          console.log("No ai-graded evals found.");
+          return;
+        }
+        for (const p of proposals) {
+          const tag = p.promotable ? p.applied ? pc.green("promoted") : pc.cyan("promotable") : pc.dim("keep-ai");
+          const script = p.scriptPath ? pc.dim(` -> ${p.scriptPath}`) : "";
+          console.log(`${tag} ${p.evalName} (${p.source}, ${p.file})${script}`);
+          console.log(pc.dim(`  ${p.rationale}`));
+          if (p.error !== void 0) console.log(pc.red(`  ${p.error}`));
+        }
+        if (!opts.write && proposals.some((p) => p.promotable)) {
+          console.log(pc.cyan("\nRe-run with --write to apply promotions."));
+        }
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("calibrate").description(
+    "Measure judge agreement against a human-verified golden set (.manni/docevals/golden/*.yaml)"
+  ).option("-c, --config <path>", "Path to manni.config.yaml").option("--golden <dir>", "Golden set directory", ".manni/docevals/golden").option(
+    "--seed",
+    "Write golden candidates from recorded reviews and exit; judges nothing, needs no provider"
+  ).option("--provider <name>", "Provider: auto (default) | anthropic | openai | claude-cli | llama-cpp").option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).option("--runs <n>", "Ensemble runs per case", parseIntArg("--runs")).option(
+    "--max-turns <n>",
+    "Stop after this many ensemble runs (a cached ensemble costs none)",
+    parseIntArg("--max-turns")
+  ).option("--no-cache", "Bypass the judge response cache").action(
+    async (opts, command) => {
+      try {
+        const color = colorFor2(command, process.stdout.isTTY);
+        const pc = palette(color);
+        if (opts.seed) {
+          const seeded = seedGoldenCases({ golden: opts.golden });
+          if (seeded.total === 0) {
+            console.log(
+              "No recorded reviews to seed from \u2014 run `manni docevals review <file> <eval> <pass|fail>` first."
+            );
+            return;
+          }
+          const changed = seeded.added + seeded.updated;
+          console.log(
+            changed === 0 ? `No new reviews to seed \u2014 ${seeded.total} golden case(s) already in ${seeded.path}.` : `Wrote ${changed} golden candidate(s) to ${seeded.path} (${seeded.added} new, ${seeded.updated} updated; ${seeded.total} total).`
+          );
+          if (seeded.unreviewed > 0) {
+            console.log(
+              pc.yellow(
+                `${seeded.unreviewed} case(s) are \`reviewed: false\`. Read them and set \`reviewed: true\` \u2014 a golden set assembled without a human is not one.`
+              )
+            );
+          }
+          return;
+        }
+        const report = await runCalibrate({
+          config: opts.config,
+          golden: opts.golden,
+          provider: opts.provider,
+          model: opts.model,
+          local: opts.local,
+          runs: opts.runs,
+          maxTurns: opts.maxTurns,
+          noCache: opts.cache === false
+        });
+        console.log(renderCalibration(report, { color }));
+        process.exitCode = report.meetsThreshold && report.unjudged === 0 && report.balanced ? 0 : 1;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("init").description("Create a starter manni.config.yaml in the current directory").action(() => {
+    try {
+      console.log(`Created ${runInit()}`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  program.command("review").description(
+    "Record a human verdict for an eval in the human-review zone (or list recorded reviews)"
+  ).argument("[file]", "Page path").argument("[eval]", "Eval name").argument("[verdict]", "pass | fail").option("--reviewer <name>", "Reviewer name recorded with the verdict").option("--note <text>", "Optional note").action(
+    (file, evalName, verdict, opts, command) => {
+      try {
+        if (!file) {
+          console.log(
+            renderReviews(listReviews(), {
+              color: colorFor2(command, process.stdout.isTTY)
+            })
+          );
+          return;
+        }
+        if (!evalName || !verdict) {
+          throw new DocevalsError(
+            "Usage: manni docevals review <file> <eval> <pass|fail>"
+          );
+        }
+        const entry = runReview(file, evalName, verdict, opts);
+        console.log(
+          `Recorded ${entry.verdict} for ${entry.evalName} on ${entry.file}`
+        );
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  return program;
+}
+
+// src/key/cli.ts
+import { Command as Command4 } from "commander";
 
 // src/key/reporters/json.ts
 function renderRotateJson(result) {
@@ -1681,8 +2268,8 @@ var ROTATE_FORMATS = ["pretty", "json"];
 function isRotateFormat(value) {
   return ROTATE_FORMATS.includes(value);
 }
-function buildProgram4() {
-  const program = new Command3();
+function buildProgram5() {
+  const program = new Command4();
   program.name("key").description("Set and rotate the family key that encrypted values are encrypted with.").version(package_default.version, "-V, --version").option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
   const color = () => shouldColor({ noColor: program.opts().color === false, isTTY: process.stdout.isTTY });
   program.command("set").description("Write the family encryption key to manni.config.yaml; generate one when no value is given").argument("[value]", "the key, at least 32 hex or base64url characters (default: 64 random hex)").option(
@@ -1765,8 +2352,616 @@ function buildProgram4() {
   return program;
 }
 
+// src/graph/cli.ts
+import { Command as Command5 } from "commander";
+
+// src/graph/reporters/index.ts
+var GRAPH_FORMATS = ["pretty", "json"];
+var GRAPH_FORMAT_LIST = GRAPH_FORMATS.join(" | ");
+var CHECK_FORMATS = [...GRAPH_FORMATS, "github"];
+var CHECK_FORMAT_LIST = CHECK_FORMATS.join(" | ");
+
+// src/graph/commands/check.ts
+import { resolve } from "node:path";
+
+// src/graph/reporters/github.ts
+function renderCheckGithub2(report) {
+  const lines = [];
+  for (const f of report.findings) {
+    const file = f.docs[0];
+    const where2 = file === void 0 ? "" : ` file=${escapeWorkflowCommandProperty(file)}`;
+    const message = escapeWorkflowCommandMessage(
+      `${f.message} (${compactIri(f.focusNode)})`
+    );
+    lines.push(`::${f.severity}${where2}::${message}`);
+  }
+  return lines.join("\n");
+}
+
+// src/graph/commands/check.ts
+async function runCheck3(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const store = loadGraph(resolve(cwd, opts.graph ?? config.out));
+  const shapesInput = opts.shapes && opts.shapes.length > 0 ? opts.shapes : config.check.shapes;
+  const shapes = shapesInput.length > 0 ? shapesInput.map((p) => resolve(cwd, p)) : [bundledShapesPath(import.meta.url)];
+  const findings = await validateGraph(store, shapes);
+  const count = (severity) => findings.filter((f) => f.severity === severity).length;
+  const errors = count("error");
+  return {
+    findings,
+    errors,
+    warnings: count("warning"),
+    notices: count("notice"),
+    shapes,
+    // Only an `error` fails the run; a warning and a notice are reported and
+    // pass, as they were when they were called violations and warnings.
+    exitCode: errors > 0 ? 1 : 0
+  };
+}
+function plural3(n, word) {
+  return `${String(n)} ${word}${n === 1 ? "" : "s"}`;
+}
+function renderCheck(report, format) {
+  if (format === "json") {
+    const { exitCode: _exitCode, ...rest } = report;
+    return JSON.stringify(rest, null, 2);
+  }
+  if (format === "github") return renderCheckGithub2(report);
+  const lines = [];
+  for (const f of report.findings) {
+    const where2 = f.docs.length > 0 ? ` [${f.docs.join(", ")}]` : "";
+    lines.push(
+      `${f.severity}: ${compactIri(f.focusNode)}${f.path ? ` ${compactIri(f.path)}` : ""} \u2014 ${f.message}${where2}`
+    );
+  }
+  if (report.findings.length > 0) lines.push("");
+  lines.push(
+    `${plural3(report.errors, "error")}, ${plural3(report.warnings, "warning")}, ${plural3(report.notices, "notice")}`
+  );
+  return lines.join("\n");
+}
+
+// src/graph/commands/init.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { parse as parseYaml } from "yaml";
+var HEADER = `# manni.config.yaml \u2014 shared configuration for the manni family of tools.
+# Each tool reads its own top-level key; manni graph reads "graph:".
+`;
+var STARTER = `# Base IRI for every minted node. Set this to a namespace you control;
+# without it, IRIs fall back to the urn:manni:graph: placeholder.
+# baseIri: https://example.com/graph/
+
+# There is no document set here. \`manni graph build\` and \`manni graph fill\` read the
+# paths you name, or the collections declared once for every tool at the TOP
+# level of this file, beside \`graph:\` rather than inside it:
+#
+#   collections:
+#     - name: site
+#       paths: ["docs/**/*.md"]
+#
+# Output of \`manni graph build\`.
+out: graph/graph.ttl
+
+# Map published-site routes back to source files so route-style links
+# (/docs/actions/find) become graph edges. A route may also carry the BCP-47
+# \`language\` labelling every document under its root; a page's own \`lang\`
+# frontmatter wins. Uncomment and adjust:
+# routes:
+#   - basePath: /docs
+#     root: docs
+#     extensions: [.md, .mdx, .markdown]
+#     indexFiles: [index, README]
+#   - basePath: /docs/de
+#     root: docs/de
+#     language: de
+
+# What to derive triples from. Remove entries to opt out.
+build:
+  derive: [frontmatter, sections, links, tags, images, code, provenance]
+
+# PROV-O settings. Git history is detected, not switched: per-file dates and
+# author agents, rename -> prov:wasRevisionOf, and the build activity's HEAD
+# committer date are derived wherever git can run over a repository, and a run
+# that cannot says so once and builds the rest. Deterministic per commit;
+# wall-clock time never enters the graph.
+# qualified: emit prov:qualifiedAttribution/qualifiedAssociation nodes
+#   with roles alongside the direct properties.
+provenance:
+  qualified: true
+
+# Which fields a published graph may carry is read from x-manni-graph-output in
+# the schema set \`manni meta validate\` resolves for each page. Set that under
+# meta: (schemas, strict, register), not here. The default set keeps the
+# stewardship people fields (owner, stakeholders, reviewed-by) out.
+
+# SHACL shapes \`manni graph check\` validates the built graph against. Default:
+# the shapes contract bundled with manni (shapes/graph/shapes-1.0.0.ttl).
+# check:
+#   shapes: ["./my-shapes.ttl"]
+
+# Metadata coverage gate for \`manni graph stats --check\`. A number applies to
+# every measured field; a map gates named fields only. Unset gates nothing.
+# stats:
+#   coverageThreshold:
+#     title: 100
+#     description: 50
+
+# Which provider \`manni graph fill\` sends pages to. Unset, the family's
+# top-level providers: map decides, and then \`auto\`, which detects one: an
+# Anthropic key, then an OpenAI key, then the Claude CLI, then a local model.
+# Connection settings (apiKeyEnv, baseUrl, command) live in that map, declared
+# once for every manni tool. \`--provider\` wins over this, \`--local\` over both.
+# provider: anthropic          # auto | anthropic | openai | claude-cli | llama-cpp
+# model: claude-sonnet-4-5     # the provider's default when omitted
+
+# LLM settings for \`manni graph fill\` (SKOS frontmatter proposals).
+fill:
+  temperature: 0
+  # Stop after this many inference calls. One page is one turn, and a cached
+  # page spends none. Unset is unbounded.
+  # maxTurns: 50
+  cacheDir: .manni/graph/cache
+  # fill proposes every field; confidence (0..1 per field) gates what is
+  # written. Fields scored below the threshold are reported, not written.
+  confidenceThreshold: 0.7
+  # fields: defaults to every fillable field \u2014 uncomment to restrict.
+  # Record meta-provenance (model + /graph/ pointers + confidence) on filled docs.
+  writeProvenance: true
+  # Reject proposals that would violate the SHACL shapes contract
+  # (broader/narrower cycles, conflicting labels).
+  validateGraph: true
+  # Also propose per-section metadata. Off by default: it costs more output per
+  # call, and section metadata is explicit-only, so review it as carefully.
+  sections: false
+
+# Local embeddings for semantic search (\`manni graph embed\`). Needs the optional
+# peer: npm install @huggingface/transformers
+# embed:
+#   model: onnx-community/granite-embedding-small-english-r2-ONNX
+#   dtype: q8            # q8 keeps embedding reproducible across platforms
+#   out: graph              # directory for the per-language vector sidecars
+#   cacheDir: .manni/graph/embed-cache
+
+# Optional enrichment for \`manni graph export iirds\` (the iiRDS package).
+# Absent, a minimal valid package is still produced.
+# export:
+#   iirds:
+#     title: My Docs        # package title (default: "manni graph export")
+#     creator: Acme Corp     # Creator iirds:Party + vcard:Organization
+#     version: "1.3"         # iiRDS version literal: "1.2" | "1.3"
+`;
+function starterSection() {
+  const body = STARTER.split("\n").map((line) => line === "" ? "" : `  ${line}`).join("\n");
+  return `${CONFIG_SECTION}:
+${body}`;
+}
+async function runInit2(cwd = process.cwd()) {
+  const path = resolve2(cwd, DEFAULT_CONFIG_FILENAME);
+  if (!existsSync(path)) {
+    await writeTextAtomic(path, `${HEADER}${starterSection()}`);
+    return path;
+  }
+  const text2 = readFileSync(path, "utf8");
+  let doc;
+  try {
+    doc = parseYaml(text2);
+  } catch (e) {
+    throw new GraphError(
+      `Invalid YAML in ${DEFAULT_CONFIG_FILENAME}: ${errorMessage(e)}`
+    );
+  }
+  if (doc != null && (typeof doc !== "object" || Array.isArray(doc))) {
+    throw new GraphError(
+      `${DEFAULT_CONFIG_FILENAME}: top level must be a mapping \u2014 not adding a \`${CONFIG_SECTION}:\` section to it.`
+    );
+  }
+  if (doc != null && Object.hasOwn(doc, CONFIG_SECTION)) {
+    throw new GraphError(
+      `${DEFAULT_CONFIG_FILENAME} already has a \`${CONFIG_SECTION}:\` section \u2014 not overwriting.`
+    );
+  }
+  const separator = text2 === "" || text2.endsWith("\n") ? "" : "\n";
+  const blank = text2 === "" ? "" : "\n";
+  await writeTextAtomic(
+    path,
+    `${text2}${separator}${blank}${starterSection()}`
+  );
+  return path;
+}
+
+// src/graph/cli.ts
+function buildProgram6() {
+  const program = new Command5();
+  program.name("graph").description(
+    "Deterministic knowledge graphs derived from documentation frontmatter and formatting."
+  ).version(package_default.version).option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
+  function numericOption(flag, { min, max, integer }) {
+    return (raw) => {
+      const value = Number.parseFloat(raw);
+      if (!Number.isFinite(value)) {
+        throw new GraphError(`${flag} expects a number, got "${raw}".`);
+      }
+      if (integer && !Number.isInteger(value)) {
+        throw new GraphError(`${flag} expects a whole number, got ${value}.`);
+      }
+      if (value < min || max !== void 0 && value > max) {
+        const range = max === void 0 ? `>= ${min}` : `${min}..${max}`;
+        throw new GraphError(`${flag} must be ${range}, got ${value}.`);
+      }
+      return value;
+    };
+  }
+  function countOption(flag, min = 1) {
+    return numericOption(flag, { min, integer: true });
+  }
+  function enumOption(flag, allowed) {
+    return (raw) => {
+      if (!allowed.includes(raw)) {
+        throw new GraphError(
+          `${flag} must be one of ${allowed.join(" | ")}, got "${raw}".`
+        );
+      }
+      return raw;
+    };
+  }
+  function choiceOption(flag, allowed) {
+    return (raw) => {
+      if (!allowed.includes(raw)) {
+        throw new GraphError(`Unknown ${flag} "${raw}". Use ${allowed.join(" | ")}.`);
+      }
+      return raw;
+    };
+  }
+  const formatOption = choiceOption("--format", GRAPH_FORMATS);
+  const checkFormatOption = choiceOption("--format", CHECK_FORMATS);
+  const fieldsOption = (raw) => splitList(raw).map((value) => enumOption("--fields", ALL_FILL_FIELDS)(value));
+  function documentInputs(command, verb) {
+    return command.argument(
+      "[paths...]",
+      `files, directories, or globs to ${verb} (use - for stdin)`
+    ).option(
+      "--collection <name>",
+      "Configured collection to read (repeatable)",
+      collect,
+      []
+    ).option("--exclude <glob>", "Glob to exclude (repeatable)", collect, []).option("--as <format>", "force an input format (markdown, mdx)").option(
+      "--ext <list>",
+      "comma-separated extensions for directory walks",
+      DEFAULT_EXTENSIONS.join(",")
+    ).option("--allow-empty", "treat zero matched files as success").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file");
+  }
+  async function inputOptions2(paths, opts) {
+    assertInputFormat(paths, opts.as);
+    return {
+      ...opts.as === void 0 ? {} : { as: opts.as },
+      ext: splitList(opts.ext),
+      ...opts.allowEmpty === true ? { allowEmpty: true } : {},
+      ...paths.includes(STDIN) ? { stdinContent: await readStdin() } : {}
+    };
+  }
+  function configInputs(command) {
+    return command.option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file");
+  }
+  function rest(opts) {
+    const { config, ...others } = opts;
+    return others;
+  }
+  function documentOptions(opts) {
+    const { configPath, noConfig } = configOption(opts.config);
+    return {
+      ...configPath === void 0 ? {} : { config: configPath },
+      ...noConfig === true ? { noConfig } : {},
+      ...opts.collection === void 0 ? {} : { collection: opts.collection },
+      ...opts.exclude === void 0 ? {} : { exclude: opts.exclude }
+    };
+  }
+  program.command("init").description("Add a starter `graph:` section to manni.config.yaml in the current directory").action(async () => {
+    try {
+      console.log(`Created ${await runInit2()}`);
+    } catch (e) {
+      fail(e);
+    }
+  });
+  documentInputs(
+    program.command("build").description("Derive the knowledge graph and write deterministic Turtle"),
+    "build"
+  ).option("-o, --out <path>", "Output .ttl path (default: config out)").action(async (paths, opts) => {
+    try {
+      const result = await runBuild({
+        paths,
+        ...documentOptions(opts),
+        ...await inputOptions2(paths, opts),
+        out: opts.out
+      });
+      for (const warning of result.warnings) warn(warning);
+      console.log(
+        `Wrote ${result.outPath} (${result.docs} docs, ${result.quads} triples)`
+      );
+    } catch (e) {
+      fail(e);
+    }
+  });
+  configInputs(
+    program.command("check").description(
+      "Validate the built graph against the bundled SHACL shapes (errors exit 1)"
+    )
+  ).option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "--shapes <path>",
+    "Shapes .ttl file; repeatable (default: config check.shapes, then bundled)",
+    collect,
+    []
+  ).option(
+    "-f, --format <format>",
+    `Output: ${CHECK_FORMAT_LIST}`,
+    checkFormatOption,
+    "pretty"
+  ).action(
+    async (opts) => {
+      try {
+        const report = await runCheck3({ ...rest(opts), ...documentOptions(opts) });
+        console.log(renderCheck(report, opts.format));
+        process.exitCode = report.exitCode;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  documentInputs(
+    program.command("fill").description(
+      "Propose `graph:` frontmatter fields with an LLM, gated by confidence, and write them back"
+    ),
+    "fill"
+  ).option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).option("--dry-run", "Report proposals without writing files").option("--force", "Overwrite human-set graph fields").option("--no-cache", "Bypass the proposal cache").option("--no-validate-graph", "Skip the SHACL graph guardrail on proposals").option("--sections", "Also propose per-section metadata").option(
+    "--max-turns <n>",
+    "Stop after this many inference calls (a cached page costs none)",
+    countOption("--max-turns")
+  ).option(
+    "--confidence <n>",
+    "Minimum model confidence (0..1) to write a field (default: config, 0.7)",
+    numericOption("--confidence", { min: 0, max: 1 })
+  ).option(
+    // Comma-separated and given once: one separator per list (proposal 0034).
+    "--fields <list>",
+    `Fields to propose (comma-separated; default: config, then every field)`,
+    fieldsOption
+  ).option(
+    "--provider <name>",
+    "Provider: auto (default) | anthropic | openai | claude-cli | llama-cpp"
+  ).option("--model <model>", "Model override; needs a named provider, from here or config").option("--local", LOCAL_FLAG_HELP).action(async (paths, opts) => {
+    try {
+      const report = await runFill2({
+        paths,
+        ...documentOptions(opts),
+        ...await inputOptions2(paths, opts),
+        dryRun: opts.dryRun,
+        force: opts.force,
+        noCache: opts.cache === false,
+        noValidateGraph: opts.validateGraph === false,
+        sections: opts.sections,
+        maxTurns: opts.maxTurns,
+        confidence: opts.confidence,
+        fields: opts.fields,
+        provider: opts.provider,
+        model: opts.model,
+        local: opts.local
+      });
+      for (const warning of report.warnings) warn(warning);
+      const rendered2 = renderFill2(report, opts.format);
+      if (paths.includes(STDIN)) {
+        if (report.stdinDocument !== void 0) {
+          process.stdout.write(report.stdinDocument);
+        }
+        if (rendered2.length > 0) process.stderr.write(`${rendered2}
+`);
+      } else {
+        console.log(rendered2);
+      }
+      process.exitCode = report.exitCode;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  program.command("query").description(
+    "Match triple patterns against the built graph (omit a term for wildcard)"
+  ).option("--subject <term>", "Subject IRI or prefixed name").option("--predicate <term>", "Predicate IRI or prefixed name").option("--object <term>", "Object IRI, prefixed name, or literal value").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    (opts) => {
+      try {
+        const { subject, predicate, object, ...others } = rest(opts);
+        const result = runQuery({
+          ...others,
+          ...documentOptions(opts),
+          ...subject === void 0 ? {} : { s: subject },
+          ...predicate === void 0 ? {} : { p: predicate },
+          ...object === void 0 ? {} : { o: object }
+        });
+        console.log(renderQuery(result, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("stats").description(
+    "Summarize the built graph: counts, orphans, broken links, hubs, metadata coverage"
+  ).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).option(
+    "--check",
+    "Exit 1 when broken internal links exist or coverage is below threshold"
+  ).option(
+    "--top <n>",
+    "How many most-connected docs to list",
+    countOption("--top")
+  ).option(
+    "--coverage-threshold <pct>",
+    "Minimum metadata coverage % (all fields); overrides config for this run",
+    // A percentage, so 0..100 rather than the 0..1 of a confidence. NaN here is
+    // worse than a wrong number: `pct < NaN` is false for every field, so the
+    // gate this flag exists to tighten would silently pass instead.
+    numericOption("--coverage-threshold", { min: 0, max: 100 })
+  ).action(
+    (opts) => {
+      try {
+        const report = runStats({ ...rest(opts), ...documentOptions(opts) });
+        console.log(renderStats(report, opts.format));
+        process.exitCode = report.exitCode;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("search").description("Rank graph nodes for a text query (needs `export search`)").argument("<query>", "Text query").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-i, --index <dir>",
+    "Directory holding the indexes and manifest (default: beside the graph)"
+  ).option(
+    "--lang <tag>",
+    "Which localization to search (required when the corpus has more than one)"
+  ).option("--limit <n>", "Maximum results (default 10)", countOption("--limit")).option(
+    "--vectors <path>",
+    "Vector sidecar path (default: from the manifest)"
+  ).option(
+    "--mode <mode>",
+    `Which legs to run: ${SEARCH_MODES.join(" | ")} (default: hybrid when vectors exist)`,
+    choiceOption("--mode", SEARCH_MODES)
+  ).option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    async (query, opts) => {
+      try {
+        const report = await runSearch({
+          ...rest(opts),
+          ...documentOptions(opts),
+          query
+        });
+        console.log(renderSearch(report, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("traverse").description(
+    "Walk the graph from a node, honoring scope rules, with the full trace"
+  ).argument("<node>", "Starting node: a full IRI or a prefix:local CURIE").option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-d, --depth <n>",
+    "Maximum hops from the node (default 1; 3 under --impact)",
+    // Zero is allowed: it means the node itself, which is a real answer.
+    countOption("--depth", 0)
+  ).option(
+    "--predicates <list>",
+    "Only follow these predicates (comma-separated)"
+  ).option("--reverse", "Follow inbound edges (who points at this node)").option("--impact", "Transitive inbound reach: what a change here affects").option(
+    "--variant <variant>",
+    "Scope filter: product variant IRI, title, or slug"
+  ).option("--software-subject <subject>", "Scope filter: software subject").option("--lang <tag>", "Scope filter: BCP-47 language tag, matched in any case").option("--limit <n>", "Stop after this many nodes", countOption("--limit")).option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    (node, opts) => {
+      try {
+        const { softwareSubject, ...others } = rest(opts);
+        const report = runTraverse({
+          ...others,
+          ...documentOptions(opts),
+          ...softwareSubject === void 0 ? {} : { subject: softwareSubject },
+          node,
+          predicates: opts.predicates === void 0 ? void 0 : splitList(opts.predicates)
+        });
+        console.log(renderTraverse(report, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("embed").description(
+    "Compute local embeddings for the search index (needs @huggingface/transformers)"
+  ).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-i, --index <dir>",
+    "Directory holding the indexes and manifest (default: beside the graph)"
+  ).option(
+    "-o, --out <dir>",
+    "Directory for the sidecars (default: the index directory)"
+  ).option(
+    "--embedding-model <id>",
+    "Embedding model id (any id; `mock` for offline runs)"
+  ).option("--dtype <dtype>", "Weight quantization (default q8)").option("--no-cache", "Ignore the vector cache").option(
+    "-f, --format <format>",
+    `Output: ${GRAPH_FORMAT_LIST}`,
+    formatOption,
+    "pretty"
+  ).action(
+    async (opts) => {
+      try {
+        const { embeddingModel, ...others } = rest(opts);
+        const report = await runEmbed({
+          ...others,
+          ...documentOptions(opts),
+          ...embeddingModel === void 0 ? {} : { model: embeddingModel },
+          noCache: opts.cache === false
+        });
+        console.log(renderEmbed(report, opts.format));
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  program.command("export").description(
+    "Reserialize the built graph into a consumer format (jsonld file, iirds package, or search index)"
+  ).argument("<target>", `What to write: ${EXPORT_TARGETS.join(" | ")}`).option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file").option("-g, --graph <path>", "Graph .ttl path (default: config out)").option(
+    "-o, --out <path>",
+    "Output path (default: the graph path with the target's extension)"
+  ).action(
+    async (target, opts) => {
+      try {
+        if (!EXPORT_TARGETS.includes(target)) {
+          throw new GraphError(
+            `Unknown export target "${target}". Use ${EXPORT_TARGETS.join(" | ")}.`
+          );
+        }
+        const result = await runExport({
+          ...documentOptions(opts),
+          graph: opts.graph,
+          format: target,
+          out: opts.out
+        });
+        for (const warning of result.warnings) warn(warning);
+        console.log(
+          `Wrote ${result.nodes} node${result.nodes === 1 ? "" : "s"} to ${result.outPath}`
+        );
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  return program;
+}
+
 // src/lint/cli.ts
-import { Command as Command4 } from "commander";
+import { Command as Command6 } from "commander";
 var LIST_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
 var TOOL_OPTIONS_GROUP = "Tool options:";
 function resolveColor2(program) {
@@ -1844,8 +3039,8 @@ function inputOptions(paths, options) {
     onNotice: notice
   };
 }
-function buildProgram5() {
-  const program = new Command4();
+function buildProgram7() {
+  const program = new Command6();
   program.name("lint").description(
     "Validate document structure against doctype templates. Deterministic, CI-friendly."
   ).version(package_default.version, "-V, --version").option("--no-color", "disable colored output").showHelpAfterError().exitOverride();
@@ -1870,7 +3065,7 @@ function buildProgram5() {
     });
     const color = resolveColor2(command.parent ?? command);
     const chosen = explain ? "explain" : format;
-    const text2 = render(run, chosen, { color });
+    const text2 = render2(run, chosen, { color });
     if (text2.length > 0 || !omittedWhenClean(chosen)) {
       process.stdout.write(`${text2}
 `);
@@ -2044,13 +3239,13 @@ function buildProgram5() {
 }
 
 // src/term/cli.ts
-import { Command as Command5 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/term/commands/check.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 
 // src/term/core/config.ts
-import { resolve } from "node:path";
+import { resolve as resolve3 } from "node:path";
 
 // src/term/errors.ts
 var TermError = class extends ToolError {
@@ -2230,11 +3425,11 @@ function toLoaded(file) {
     tools: file.tools
   };
 }
-var STDIN = "-";
+var STDIN2 = "-";
 async function resolveTermRun(opts) {
-  const cwd = resolve(opts.cwd);
+  const cwd = resolve3(opts.cwd);
   const wanted = opts.collection ?? [];
-  if (wanted.length > 0 && opts.inputs.some((input) => input !== STDIN)) {
+  if (wanted.length > 0 && opts.inputs.some((input) => input !== STDIN2)) {
     throw new TermError(
       "--collection selects a configured collection; it cannot be combined with paths."
     );
@@ -2249,7 +3444,7 @@ async function resolveTermRun(opts) {
   const fromCollections = opts.inputs.length === 0;
   const inputs = fromCollections ? collections.flatMap((c) => c.paths) : opts.inputs;
   const base = fromCollections && inputs.length > 0 && loaded ? loaded.dir : cwd;
-  const manifests = loaded ? (loaded.config.manifests ?? []).map((written) => ({ path: resolve(loaded.dir, written), written })) : [];
+  const manifests = loaded ? (loaded.config.manifests ?? []).map((written) => ({ path: resolve3(loaded.dir, written), written })) : [];
   return {
     config: loaded ? loaded.config : null,
     inputs,
@@ -2566,12 +3761,12 @@ function compareFindings2(a, b) {
 }
 
 // src/term/commands/run.ts
-import { existsSync } from "node:fs";
-import { isAbsolute, relative, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { isAbsolute, relative, resolve as resolve5 } from "node:path";
 
 // src/term/core/load-set.ts
 import { readFile } from "node:fs/promises";
-import { extname, resolve as resolve2 } from "node:path";
+import { extname, resolve as resolve4 } from "node:path";
 
 // src/term/core/writers/markup.ts
 function xmlText(value) {
@@ -4153,7 +5348,7 @@ async function loadTermSet(opts) {
     });
     const namedFiles = new Set(named);
     for (const file of files) {
-      const path = resolve2(run.base, file);
+      const path = resolve4(run.base, file);
       if (namedFiles.has(file) && MANIFEST_EXTENSIONS.has(extname(file).toLowerCase())) {
         let content2;
         try {
@@ -4204,7 +5399,7 @@ async function loadTermSet(opts) {
 
 // src/term/commands/run.ts
 async function loadTerms(opts) {
-  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const cwd = resolve5(opts.cwd ?? process.cwd());
   const run = await resolveTermRun({
     cwd,
     inputs: opts.inputs,
@@ -4250,18 +5445,18 @@ function displayPath(path, cwd) {
 function valeConfigFor(run) {
   if (run.configDir === void 0) return void 0;
   const path = valeConfigPath(run.tools, run.configDir);
-  if (path !== void 0 && !existsSync(path)) {
+  if (path !== void 0 && !existsSync2(path)) {
     const source = run.configSource ?? "manni.config.yaml";
     throw new TermError(`${source}: tools.vale.config "${run.tools.vale?.config ?? path}" does not exist.`);
   }
   return path;
 }
-function plural3(n, one, many = `${one}s`) {
+function plural4(n, one, many = `${one}s`) {
   return `${String(n)} ${n === 1 ? one : many}`;
 }
 
 // src/term/commands/check.ts
-async function runCheck3(opts) {
+async function runCheck4(opts) {
   const { cwd, run, set } = await loadTerms(opts);
   const config = run.config;
   const findings = checkTermSet(set, {
@@ -4277,7 +5472,7 @@ async function runCheck3(opts) {
     cwd,
     { current: DEFAULT_TERM_BASELINE_PATH }
   );
-  if (request !== null && !existsSync2(request.absPath)) {
+  if (request !== null && !existsSync3(request.absPath)) {
     if (opts.baseline !== true) {
       throw new TermError(
         `Baseline "${request.label}" not found. Record one with \`manni term check --baseline\`.`
@@ -4303,7 +5498,7 @@ async function runCheck3(opts) {
 import { join } from "node:path";
 
 // src/term/core/writers/page.ts
-import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
 function pageMetadata(term) {
   const { record } = term;
   const metadata = { title: record.label };
@@ -4330,7 +5525,7 @@ ${stringifyYaml2(metadata, { lineWidth: 0 })}---
 function metaContent(value) {
   if (typeof value === "string" && !value.includes("\n")) {
     try {
-      if (parseYaml(value) === value) return value;
+      if (parseYaml2(value) === value) return value;
     } catch {
     }
   }
@@ -4661,7 +5856,7 @@ var SCHEME_ID = "";
 function literal(term, value) {
   return term.language === void 0 ? value : { "@value": value, "@language": term.language };
 }
-function resolve4(terms, self, value) {
+function resolve6(terms, self, value) {
   const wanted = value.toLowerCase();
   const others = terms.filter((t) => t !== self);
   return others.find((t) => t.record.label.toLowerCase() === wanted) ?? others.find((t) => t.id.toLowerCase() === wanted);
@@ -4669,7 +5864,7 @@ function resolve4(terms, self, value) {
 function references(terms, self, values) {
   const ids = [];
   for (const value of values ?? []) {
-    const target = resolve4(terms, self, value);
+    const target = resolve6(terms, self, value);
     if (target !== void 0 && !ids.includes(target.id)) ids.push(target.id);
   }
   return ids.map((id) => ({ "@id": `#${id}` }));
@@ -4995,9 +6190,9 @@ var INTERCHANGE_LABELS = {
 };
 function rendered(writers, format, construct) {
   return writers.some((writer) => {
-    const render3 = DOCUMENT_RENDERS[writer.format];
-    if (render3?.input !== format) return false;
-    return writer.shapes.some((shape) => render3.shapes[shape] === construct);
+    const render4 = DOCUMENT_RENDERS[writer.format];
+    if (render4?.input !== format) return false;
+    return writer.shapes.some((shape) => render4.shapes[shape] === construct);
   });
 }
 function listFormats(opts = {}) {
@@ -5066,7 +6261,7 @@ async function runGet(opts) {
     set.terms.flatMap((t) => [t.id, t.record.label])
   );
   const hint = nearest === void 0 ? "." : `; did you mean "${nearest}"?`;
-  throw new TermError(`no term "${opts.term}". ${plural3(set.terms.length, "term")}${hint}`);
+  throw new TermError(`no term "${opts.term}". ${plural4(set.terms.length, "term")}${hint}`);
 }
 
 // src/term/core/lint.ts
@@ -5313,15 +6508,15 @@ async function runLint2(opts) {
 
 // src/term/commands/list.ts
 var LIST_FORMATS2 = ["pretty", "json", "csv"];
-async function runList(opts) {
+async function runList2(opts) {
   const { set } = await loadTerms(opts);
   return { terms: set.terms, set };
 }
 
 // src/term/commands/write.ts
-import { existsSync as existsSync3, statSync } from "node:fs";
+import { existsSync as existsSync4, statSync } from "node:fs";
 import { lstat, mkdir, readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname, extname as extname2, join as join4, resolve as resolve5 } from "node:path";
+import { dirname, extname as extname2, join as join4, resolve as resolve7 } from "node:path";
 var SUGGESTED_SECTION = "*.md";
 var STYLE2 = "Terms";
 function writeFormats(writers = TERM_WRITERS) {
@@ -5355,7 +6550,7 @@ async function existingFor(target) {
   const existing = /* @__PURE__ */ new Map();
   if (target.shape === "directory") {
     await filesUnder(target.path, existing);
-  } else if (existsSync3(target.path) && !isDirectory(target.path)) {
+  } else if (existsSync4(target.path) && !isDirectory(target.path)) {
     existing.set(target.path, await readFile2(target.path, "utf8"));
   }
   return existing;
@@ -5375,7 +6570,7 @@ function droppedFrom(format, shape, readers) {
 async function applyChanges(files, removals, existing, cwd, write) {
   const changes = [];
   for (const file of files) {
-    const before = existing.get(file.path) ?? (existsSync3(file.path) ? await readFile2(file.path, "utf8") : void 0);
+    const before = existing.get(file.path) ?? (existsSync4(file.path) ? await readFile2(file.path, "utf8") : void 0);
     if (before === file.content) continue;
     changes.push({ path: displayPath(file.path, cwd), action: before === void 0 ? "create" : "change" });
     if (write) {
@@ -5384,14 +6579,14 @@ async function applyChanges(files, removals, existing, cwd, write) {
     }
   }
   for (const path of removals) {
-    if (!existsSync3(path)) continue;
+    if (!existsSync4(path)) continue;
     changes.push({ path: displayPath(path, cwd), action: "remove" });
     if (write) await rm2(path, { force: true });
   }
   return changes;
 }
 async function runWrite(opts) {
-  const cwd = resolve5(opts.cwd ?? process.cwd());
+  const cwd = resolve7(opts.cwd ?? process.cwd());
   const writers = opts.writers ?? TERM_WRITERS;
   const readers = opts.readers ?? TERM_READERS;
   const check = opts.check === true;
@@ -5419,31 +6614,31 @@ async function runWrite(opts) {
         "Vale found no config file. Set tools.vale.config in manni.config.yaml, or pass -o <styles directory>."
       );
     }
-    targetPath = resolve5(cwd, resolved.stylesPath);
+    targetPath = resolve7(cwd, resolved.stylesPath);
     if (!Object.values(resolved.baseStyles).some((styles) => styles.includes(STYLE2))) {
       const first = Object.entries(resolved.baseStyles)[0];
       const [section, styles] = first ?? [SUGGESTED_SECTION, []];
       wiring = {
-        rootIni: displayPath(resolve5(cwd, resolved.rootIni), cwd),
+        rootIni: displayPath(resolve7(cwd, resolved.rootIni), cwd),
         section,
         styles: [...styles, STYLE2],
         addSection: first === void 0
       };
     }
   } else {
-    targetPath = resolve5(cwd, opts.out);
+    targetPath = resolve7(cwd, opts.out);
   }
   const shape = format === "vale" || /[\\/]$/.test(opts.out ?? "") || isDirectory(targetPath) ? "directory" : "file";
   const target = { path: targetPath, shape };
   const existing = await existingFor(target);
-  let render3;
+  let render4;
   try {
-    render3 = writer.render(set.terms, target, { existing });
+    render4 = writer.render(set.terms, target, { existing });
   } catch (error) {
     if (error instanceof TermError) throw relativized(error, [...existing.keys(), targetPath], cwd);
     throw error;
   }
-  const changes = await applyChanges(render3.files, render3.removals, existing, cwd, !check && !dryRun);
+  const changes = await applyChanges(render4.files, render4.removals, existing, cwd, !check && !dryRun);
   const shown = format === "vale" ? displayPath(join4(targetPath, STYLE2), cwd) : opts.out ?? displayPath(targetPath, cwd);
   return {
     mode: "render",
@@ -5452,11 +6647,11 @@ async function runWrite(opts) {
     target: shown,
     terms: set.terms.length,
     changes,
-    files: render3.files.map((file) => ({ path: displayPath(file.path, cwd), content: file.content })),
+    files: render4.files.map((file) => ({ path: displayPath(file.path, cwd), content: file.content })),
     // A Vale style holds designations only, by design; its dropped definitions are not news.
-    dropped: format === "vale" ? [] : render3.dropped,
+    dropped: format === "vale" ? [] : render4.dropped,
     droppedFrom: droppedFrom(format, shape, readers),
-    skipped: render3.skipped,
+    skipped: render4.skipped,
     check,
     dryRun,
     ...wiring === void 0 ? {} : { wiring }
@@ -5692,7 +6887,7 @@ function renderListPretty(terms) {
   const rows = terms.map(
     (t) => `${t.id.padEnd(idWidth)}${t.record.label.padEnd(labelWidth)}${(t.record["alt-labels"] ?? []).join(", ")}`.trimEnd()
   );
-  return [...rows, plural3(terms.length, "term")].join("\n");
+  return [...rows, plural4(terms.length, "term")].join("\n");
 }
 var GET_FIELDS = [
   "alt-labels",
@@ -5733,21 +6928,21 @@ function severityText(c, severity) {
 function counts(findings) {
   const parts = [];
   const n = (severity) => findings.filter((f) => f.severity === severity).length;
-  if (n("error") > 0) parts.push(plural3(n("error"), "error"));
-  if (n("warning") > 0) parts.push(plural3(n("warning"), "warning"));
-  if (n("notice") > 0) parts.push(plural3(n("notice"), "notice"));
+  if (n("error") > 0) parts.push(plural4(n("error"), "error"));
+  if (n("warning") > 0) parts.push(plural4(n("warning"), "warning"));
+  if (n("notice") > 0) parts.push(plural4(n("notice"), "notice"));
   return parts.join(", ");
 }
 function renderFindingsPretty(report, opts) {
   const c = palette(opts.color);
   const { baseline } = report;
   if (baseline?.written === true) {
-    return `${c.green("\u2713")} ${plural3(report.found, "finding")} recorded in ${baseline.path}`;
+    return `${c.green("\u2713")} ${plural4(report.found, "finding")} recorded in ${baseline.path}`;
   }
   const baselined = baseline !== void 0 && baseline.suppressed > 0 ? `, ${String(baseline.suppressed)} baselined` : "";
-  const terms = plural3(report.terms, "term");
+  const terms = plural4(report.terms, "term");
   if (report.findings.length === 0) {
-    const references2 = opts.references === false ? "" : `, ${plural3(report.references, "reference")}`;
+    const references2 = opts.references === false ? "" : `, ${plural4(report.references, "reference")}`;
     return `${c.green("\u2713")} ${terms}${references2}, no findings${baselined}`;
   }
   const ruleWidth = Math.max(RULE_WIDTH, ...report.findings.map((f) => f.ruleId.length + 2));
@@ -5797,11 +6992,11 @@ function valeLines(report) {
   const acronyms = [];
   for (const file of report.files) {
     const name = baseName2(file.path);
-    if (CASING_RULES.has(name)) rows.push([name, plural3(swapCount(file.content), "label")]);
-    else if (name === "Deprecated.yml") rows.push([name, plural3(swapCount(file.content), "swap")]);
+    if (CASING_RULES.has(name)) rows.push([name, plural4(swapCount(file.content), "label")]);
+    else if (name === "Deprecated.yml") rows.push([name, plural4(swapCount(file.content), "swap")]);
     else acronyms.push(name);
   }
-  if (acronyms.length > 0) rows.push([acronyms.join(", "), plural3(acronyms.length, "acronym")]);
+  if (acronyms.length > 0) rows.push([acronyms.join(", "), plural4(acronyms.length, "acronym")]);
   const width = Math.max(0, ...rows.map(([name]) => name.length)) + 2;
   return rows.map(([name, what]) => `  ${name.padEnd(width)}${what}`);
 }
@@ -5814,13 +7009,13 @@ function droppedLine(report) {
     ids.set(field, set);
   }
   const fields = [...ids.entries()].map(([field, set]) => ({ field, n: set.size })).sort((a, b) => a.n - b.n || TERM_FIELDS.indexOf(a.field) - TERM_FIELDS.indexOf(b.field));
-  const parts = fields.map(({ field, n }, i) => `${field} on ${i === 0 ? plural3(n, "term") : String(n)}`);
+  const parts = fields.map(({ field, n }, i) => `${field} on ${i === 0 ? plural4(n, "term") : String(n)}`);
   return `  dropped from ${report.droppedFrom ?? report.format ?? "the render"}: ${parts.join(", ")}`;
 }
 function skippedLine(report) {
   if (report.skipped.length === 0) return void 0;
   const construct = report.droppedFrom ?? report.format ?? "the render";
-  const count = plural3(report.skipped.length, "term");
+  const count = plural4(report.skipped.length, "term");
   return `  skipped ${count} ${construct} cannot read without a definition: ${report.skipped.join(", ")}`;
 }
 function renderNotes(report) {
@@ -5838,11 +7033,11 @@ function renderWritePretty(report) {
     return [...changes, ...renderNotes(report)].join("\n");
   }
   if (report.mode === "in-place") {
-    return report.changes.length === 0 ? "Nothing to write" : `Wrote ${plural3(report.changes.length, "file")}`;
+    return report.changes.length === 0 ? "Nothing to write" : `Wrote ${plural4(report.changes.length, "file")}`;
   }
   const each = report.shape === "directory" && report.format !== "vale" ? ", one file each" : "";
   const written = report.terms - report.skipped.length;
-  const lines = [`Wrote ${plural3(written, "term")} to ${report.target ?? ""}${each}`];
+  const lines = [`Wrote ${plural4(written, "term")} to ${report.target ?? ""}${each}`];
   if (report.format === "vale") lines.push(...valeLines(report));
   lines.push(...renderNotes(report));
   return lines.join("\n");
@@ -5877,7 +7072,7 @@ async function termLabels(request) {
 
 // src/term/cli.ts
 registerTermLabelSource(termLabels);
-function colorFor2(options) {
+function colorFor3(options) {
   return shouldColor({ noColor: !options.color, isTTY: process.stdout.isTTY });
 }
 async function coreOptions(paths, options) {
@@ -5905,7 +7100,7 @@ function renderFindings(report, format, options, references2) {
   let text2;
   switch (format) {
     case "pretty":
-      text2 = renderFindingsPretty(report, { color: colorFor2(options), references: references2 });
+      text2 = renderFindingsPretty(report, { color: colorFor3(options), references: references2 });
       break;
     case "json":
       text2 = renderFindingsJson(report);
@@ -5923,8 +7118,8 @@ function renderFindings(report, format, options, references2) {
   if (text2.length > 0 || !OMITTED_WHEN_CLEAN.has(format)) print(text2);
   process.exitCode = report.summary.failed > 0 ? 1 : 0;
 }
-function buildProgram6() {
-  const program = new Command5();
+function buildProgram8() {
+  const program = new Command7();
   program.name("term").description("Check, lint and render a docset's terms and the references into them.").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride();
   withInputs(
     program.command("list").description("List the resolved entries").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
@@ -5940,7 +7135,7 @@ function buildProgram6() {
   ).action(async (paths, options) => {
     try {
       const format = formatChoice(options.format, LIST_FORMATS2);
-      const { terms } = await runList(await coreOptions(paths, options));
+      const { terms } = await runList2(await coreOptions(paths, options));
       print(format === "json" ? renderListJson(terms) : format === "csv" ? renderListCsv(terms) : renderListPretty(terms));
       process.exitCode = 0;
     } catch (err) {
@@ -5956,7 +7151,7 @@ function buildProgram6() {
     try {
       const format = formatChoice(options.format, GET_FORMATS);
       const found = await runGet({ ...await coreOptions(paths, options), term });
-      print(format === "json" ? renderGetJson(found) : renderGetPretty(found, { color: colorFor2(options) }));
+      print(format === "json" ? renderGetJson(found) : renderGetPretty(found, { color: colorFor3(options) }));
       process.exitCode = 0;
     } catch (err) {
       fail(err);
@@ -5976,7 +7171,7 @@ function buildProgram6() {
   ).action(async (paths, options) => {
     try {
       const format = formatChoice(options.format, FINDING_FORMATS);
-      const report = await runCheck3({
+      const report = await runCheck4({
         ...await coreOptions(paths, options),
         ...options.baseline === true ? { baseline: true } : {}
       });
@@ -6042,12 +7237,12 @@ function buildProgram6() {
 }
 
 // src/cli.ts
-function buildProgram7() {
+function buildProgram9() {
   const meta = buildProgram().name("meta").description(
     "Validate, read, query and fill document metadata against JSON Schema"
   );
   const metaCommands = new Set(meta.commands.map((c) => c.name()));
-  const program = new Command6();
+  const program = new Command8();
   program.name("manni").description("Tools for documentation that is meant to be checked.").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride().configureOutput({
     outputError: (str, write) => {
       write(str);
@@ -6073,20 +7268,30 @@ function buildProgram7() {
     )
   );
   program.addCommand(
-    buildProgram5().name("lint").description(
+    buildProgram7().name("lint").description(
       "Validate document structure against doctype templates, routed by a page's type"
     )
   );
   program.addCommand(
-    buildProgram6().name("term").description("Check, lint and render a docset's terms and the references into them")
+    buildProgram4().name("docevals").description(
+      "Deterministic and LLM-as-judge evals for documentation pages, driven by frontmatter"
+    )
+  );
+  program.addCommand(
+    buildProgram8().name("term").description("Check, lint and render a docset's terms and the references into them")
+  );
+  program.addCommand(
+    buildProgram6().name("graph").description(
+      "Deterministic knowledge graphs derived from documentation frontmatter and formatting"
+    )
   );
   program.addCommand(
-    buildProgram4().name("key").description("Set and rotate the family key that encrypted values are encrypted with.")
+    buildProgram5().name("key").description("Set and rotate the family key that encrypted values are encrypted with.")
   );
   return program;
 }
-runIfMain(import.meta.url, buildProgram7);
+runIfMain(import.meta.url, buildProgram9);
 export {
-  buildProgram7 as buildProgram
+  buildProgram9 as buildProgram
 };
 //# sourceMappingURL=cli.js.map