@hawkeyexl/manni 4.1.0 → 4.3.0

package/dist/cli.js

@@ -1,37 +1,43 @@
 #!/usr/bin/env node
 import {
-  buildProgram,
-  collect,
-  configOption,
-  explicitFalse,
-  readStdin,
-  reportConfig,
-  splitList
-} from "./chunk-JODRT4NF.js";
+  buildProgram
+} from "./chunk-MFDD3YGU.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,
   listReviews,
-  loadConfig2 as loadConfig,
+  loadConfig3 as loadConfig,
+  loadGraph,
+  loadRunConfig,
   meetsSeverity,
   parseFormat,
   rebaseConfig,
@@ -41,41 +47,71 @@ import {
   renderCheckGithub,
   renderCheckJson,
   renderCheckPretty,
+  renderEmbed,
   renderFill,
+  renderFill2,
   renderList,
+  renderList2,
+  renderQuery,
   renderRemoveJson,
   renderRemovePretty,
   renderReviews,
+  renderSearch,
+  renderStats,
   renderTemplates,
   renderTools,
+  renderTraverse,
   renderUpdateJson,
   renderUpdatePretty,
   resolveStructureTool,
   runAdd,
+  runBuild,
   runCalibrate,
   runCheck,
+  runEmbed,
+  runExport,
   runFill,
+  runFill2,
+  runFill3,
   runGenerate,
   runInit,
   runKeyRotate,
   runKeySet,
   runLint,
   runList,
+  runList2,
   runPromote,
+  runQuery,
   runRemove,
   runReview,
   runRun,
+  runSearch,
+  runStats,
   runTemplates,
   runTemplatesInfer,
   runTools,
+  runTraverse,
   runUpdate,
   seedGoldenCases,
   shortCommit,
   shortLine,
   shortPin,
   shortSrc,
-  spellSource
-} from "./chunk-S3NDEIOW.js";
+  spellSource,
+  validateGraph
+} from "./chunk-O6RVQKK6.js";
+import {
+  CALIBRATE_FORMATS,
+  REPORT_FORMATS as REPORT_FORMATS3,
+  SUMMARY_FORMATS as SUMMARY_FORMATS2,
+  parseFormat as parseFormat2,
+  runRun as runRun2
+} from "./chunk-CI2GOU3A.js";
+import "./chunk-QROCFW5S.js";
+import {
+  allowExecutionMessage,
+  isExecutionGrant
+} from "./chunk-MOQXWXSG.js";
 import {
   COMMON_FORMAT_LIST,
   CONCEPT_FIELDS,
@@ -87,11 +123,13 @@ import {
   STDIN_LABEL,
   STDIN_TOKEN,
   TERM_RELATION_FIELDS,
-  ToolError,
   assertNonEmpty,
-  errorMessage,
+  collect,
+  colorFor,
+  configOption,
   escapeWorkflowCommandMessage,
   escapeWorkflowCommandProperty,
+  explicitFalse,
   extractorByName,
   extractorForExtension,
   fail,
@@ -108,23 +146,35 @@ import {
   palette,
   programName,
   readConfigFile,
+  readStdin,
   registerTermLabelSource,
   renderJunit,
   renderSarif,
+  reportConfig,
   resolveBaselineRequest,
   resolveTargetSet,
   runIfMain,
   selectCollections,
   settleBaseline,
   shouldColor,
+  splitList,
   splitPageArgument,
   terminalConfirm,
   valeConfigPath,
-  valueAt
-} from "./chunk-I57KBF45.js";
+  valueAt,
+  warn,
+  writeTextAtomic
+} from "./chunk-DP2ZA3WH.js";
+import {
+  TracevalsError
+} from "./chunk-3R23C5DT.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-IOYXPBCL.js";
 
 // src/cli.ts
-import { Command as Command7 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/a11y/cli.ts
 import { Command } from "commander";
@@ -224,17 +274,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;
@@ -251,6 +303,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++) {
@@ -263,10 +316,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");
@@ -278,9 +349,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
@@ -522,6 +607,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 {
@@ -535,7 +621,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;
@@ -551,6 +637,7 @@ function summarize(results, { discovered, skipped: skipped2, duplicates, exclude
     checked: results.length,
     skipped: skipped2,
     duplicates,
+    redirects: redirects.length,
     excluded,
     failed,
     violations,
@@ -595,33 +682,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;
@@ -635,6 +707,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":
@@ -819,8 +988,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");
@@ -939,6 +1113,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;
@@ -979,6 +1156,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;
@@ -1215,7 +1395,7 @@ function renderCheckJunit(run) {
 // src/cite/cli.ts
 var UPDATE_FORMATS = ["pretty", "json"];
 var REMOVE_FORMATS = UPDATE_FORMATS;
-function colorFor(command, isTTY, env) {
+function colorFor2(command, isTTY, env) {
   const noColor = colorOwner(command).opts().color === false;
   return shouldColor({ noColor, isTTY, env });
 }
@@ -1342,7 +1522,7 @@ function buildProgram3() {
       switch (format) {
         case "pretty":
           text2 = renderCheckPretty(run, {
-            color: colorFor(command, process.stdout.isTTY),
+            color: colorFor2(command, process.stdout.isTTY),
             quiet: Boolean(options.quiet),
             showDiff: Boolean(options.showDiff),
             reveal: Boolean(options.reveal)
@@ -1506,7 +1686,7 @@ function buildProgram3() {
         dryRun
       });
       const text2 = format === "json" ? renderUpdateJson(run) : renderUpdatePretty(run, {
-        color: colorFor(command, process.stdout.isTTY),
+        color: colorFor2(command, process.stdout.isTTY),
         // The diffs are the point of a dry run; a real run prints
         // what it rewrote and leaves the file to say the rest.
         showDiff: dryRun
@@ -1581,7 +1761,7 @@ function buildProgram3() {
         dryRun
       });
       const text2 = format === "json" ? renderRemoveJson(run) : renderRemovePretty(run, {
-        color: colorFor(command, process.stdout.isTTY),
+        color: colorFor2(command, process.stdout.isTTY),
         // The diffs are the point of a dry run; a real run prints
         // what it removed and leaves the file to say the rest.
         showDiff: dryRun,
@@ -1606,28 +1786,14 @@ function buildProgram3() {
 
 // 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}"`
-        )
-      );
+    if (!isExecutionGrant(value)) {
+      fail(new DocevalsError(allowExecutionMessage(value)));
     }
     return [...previous, value];
   }
@@ -1700,7 +1866,7 @@ function buildProgram4() {
         });
         console.log(
           renderList(run, opts.format, {
-            color: colorFor2(command, process.stdout.isTTY)
+            color: colorFor(command, process.stdout.isTTY)
           })
         );
         process.exitCode = run.exitCode;
@@ -1723,7 +1889,7 @@ function buildProgram4() {
     // 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",
+    "Run only these execution grants (repeatable): 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(
@@ -1738,6 +1904,9 @@ function buildProgram4() {
   ).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(
+    "--newer-than <duration>",
+    "Evaluate only pages whose file or eval manifest changed within this window, such as 30m, 24h, 7d or 2w; in CI, prefer --since"
   ).option(
     "--max-turns <n>",
     "Stop after this many ensemble runs (a cached ensemble costs none)",
@@ -1761,7 +1930,9 @@ function buildProgram4() {
         format: opts.format,
         deterministicOnly: opts.deterministicOnly,
         aiOnly: opts.aiOnly,
-        allowExecution: opts.allowExecution,
+        // Commander's default is `[]`, which is "no flag", not "run nothing":
+        // only a list someone typed narrows the run.
+        allowExecution: opts.allowExecution.length > 0 ? opts.allowExecution : void 0,
         execution: opts.execution,
         generate: opts.generate,
         cache: opts.cache,
@@ -1775,6 +1946,7 @@ function buildProgram4() {
         evalNames: opts.eval,
         suite: opts.suite,
         since: opts.since,
+        newerThan: opts.newerThan,
         // commander collapses `--baseline` to true and `--no-baseline` to
         // false on the same key; a string is an explicit path.
         baseline: opts.baseline,
@@ -1783,7 +1955,7 @@ function buildProgram4() {
       });
       console.log(
         render(report, opts.format, {
-          color: colorFor2(command, process.stdout.isTTY)
+          color: colorFor(command, process.stdout.isTTY)
         })
       );
       process.exitCode = report.exitCode;
@@ -1799,7 +1971,7 @@ function buildProgram4() {
   ).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 pc = palette(colorFor(command, process.stdout.isTTY));
         const result = await runGenerate(paths, {
           ...documentOptions(opts),
           provider: opts.provider,
@@ -1878,7 +2050,7 @@ function buildProgram4() {
       });
       console.log(
         renderFill(report, opts.format, {
-          color: colorFor2(command, process.stdout.isTTY)
+          color: colorFor(command, process.stdout.isTTY)
         })
       );
       process.exitCode = report.exitCode;
@@ -1894,7 +2066,7 @@ function buildProgram4() {
   ).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 pc = palette(colorFor(command, process.stdout.isTTY));
         const proposals = await runPromote(paths, {
           ...documentOptions(opts),
           write: opts.write,
@@ -1933,7 +2105,7 @@ function buildProgram4() {
   ).option("--no-cache", "Bypass the judge response cache").action(
     async (opts, command) => {
       try {
-        const color = colorFor2(command, process.stdout.isTTY);
+        const color = colorFor(command, process.stdout.isTTY);
         const pc = palette(color);
         if (opts.seed) {
           const seeded = seedGoldenCases({ golden: opts.golden });
@@ -1988,7 +2160,7 @@ function buildProgram4() {
         if (!file) {
           console.log(
             renderReviews(listReviews(), {
-              color: colorFor2(command, process.stdout.isTTY)
+              color: colorFor(command, process.stdout.isTTY)
             })
           );
           return;
@@ -2192,8 +2364,616 @@ function buildProgram5() {
   return program;
 }
 
-// src/lint/cli.ts
+// 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 Command6 } from "commander";
 var LIST_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
 var TOOL_OPTIONS_GROUP = "Tool options:";
 function resolveColor2(program) {
@@ -2271,8 +3051,8 @@ function inputOptions(paths, options) {
     onNotice: notice
   };
 }
-function buildProgram6() {
-  const program = new Command5();
+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();
@@ -2471,13 +3251,13 @@ function buildProgram6() {
 }
 
 // src/term/cli.ts
-import { Command as Command6 } 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 {
@@ -2657,11 +3437,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."
     );
@@ -2676,7 +3456,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,
@@ -2993,12 +3773,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) {
@@ -4580,7 +5360,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 {
@@ -4631,7 +5411,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,
@@ -4677,18 +5457,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, {
@@ -4704,7 +5484,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\`.`
@@ -4730,7 +5510,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 };
@@ -4757,7 +5537,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 {
     }
   }
@@ -5088,7 +5868,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);
@@ -5096,7 +5876,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}` }));
@@ -5493,7 +6273,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
@@ -5740,15 +6520,15 @@ async function runLint2(opts) {
 
 // src/term/commands/list.ts
 var LIST_FORMATS2 = ["pretty", "json", "csv"];
-async function runList2(opts) {
+async function runList3(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) {
@@ -5782,7 +6562,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;
@@ -5802,7 +6582,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) {
@@ -5811,14 +6591,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;
@@ -5846,19 +6626,19 @@ 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 };
@@ -6119,7 +6899,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",
@@ -6160,21 +6940,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));
@@ -6224,11 +7004,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}`);
 }
@@ -6241,13 +7021,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) {
@@ -6265,11 +7045,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");
@@ -6350,8 +7130,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 buildProgram7() {
-  const program = new Command6();
+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)")
@@ -6367,7 +7147,7 @@ function buildProgram7() {
   ).action(async (paths, options) => {
     try {
       const format = formatChoice(options.format, LIST_FORMATS2);
-      const { terms } = await runList2(await coreOptions(paths, options));
+      const { terms } = await runList3(await coreOptions(paths, options));
       print(format === "json" ? renderListJson(terms) : format === "csv" ? renderListCsv(terms) : renderListPretty(terms));
       process.exitCode = 0;
     } catch (err) {
@@ -6403,7 +7183,7 @@ function buildProgram7() {
   ).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 } : {}
       });
@@ -6468,13 +7248,376 @@ function buildProgram7() {
   return program;
 }
 
+// src/tracevals/cli.ts
+import { Command as Command8 } from "commander";
+var { version } = package_default;
+function buildProgram9() {
+  const program = new Command8();
+  program.name("tracevals").description(
+    "Deterministic and LLM-as-judge adherence evals for AI agent session traces."
+  ).version(version).option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride();
+  function collectGrant(value, previous) {
+    if (!isExecutionGrant(value)) fail(new TracevalsError(allowExecutionMessage(value)));
+    return [...previous, value];
+  }
+  function addConfigFlags(cmd) {
+    return cmd.option("-c, --config <path>", "Path to manni.config.yaml").option("--no-config", "Ignore any discovered config file");
+  }
+  function configOptions(opts) {
+    const { configPath, noConfig } = configOption(opts.config);
+    return {
+      ...configPath === void 0 ? {} : { config: configPath },
+      ...noConfig === true ? { noConfig } : {}
+    };
+  }
+  function parseFormatArg(name, allowed) {
+    return (value) => {
+      try {
+        return parseFormat2(value, allowed, name);
+      } catch (e) {
+        fail(e);
+      }
+    };
+  }
+  const range = (min, max) => Number.isFinite(max) ? `between ${min} and ${max}` : `of at least ${min}`;
+  function numeric(name, value, min, max = Number.POSITIVE_INFINITY) {
+    if (value === void 0) return;
+    if (Number.isFinite(value) && value >= min && value <= max) return;
+    throw new TracevalsError(
+      `${name} must be a number ${range(min, max)}, got ${value}`
+    );
+  }
+  function whole(name, value, min, max = Number.POSITIVE_INFINITY) {
+    if (value === void 0) return;
+    if (Number.isInteger(value) && value >= min && value <= max) return;
+    throw new TracevalsError(
+      `${name} must be a whole number ${range(min, max)}, got ${value}`
+    );
+  }
+  function sharedRunOptions(opts) {
+    whole("--runs", opts.runs, 1);
+    whole("--limit", opts.limit, 1);
+    whole("--max-turns", opts.maxTurns, 1);
+    return {
+      ...configOptions(opts),
+      project: opts.project,
+      provider: opts.provider,
+      model: opts.model,
+      local: opts.local,
+      // `undefined` rather than `false` when absent, so a future config
+      // `offline:` still decides on a run where the flag was never typed.
+      offline: opts.offline ? true : void 0,
+      runs: opts.runs,
+      deterministicOnly: opts.deterministicOnly,
+      noCache: opts.cache === false,
+      maxTurns: opts.maxTurns,
+      format: opts.format ?? "pretty",
+      output: opts.output,
+      // Undefined when neither spelling is passed, so the config still decides.
+      // Both spellings are declared for precisely that reason: commander
+      // defaults a lone `--no-x` to `true`, which makes the config's own value
+      // unreachable from the command line.
+      failOnReview: opts.failOnReview,
+      // Commander's default is `[]`, which is "no flag", not "run nothing": only
+      // a list someone typed narrows the run, and `--no-execution` runs none.
+      ...opts.execution === false ? { allowExecution: [] } : (opts.allowExecution ?? []).length > 0 ? { allowExecution: opts.allowExecution } : {},
+      reportUnusedArtifacts: opts.reportUnusedArtifacts,
+      ...opts.require !== void 0 ? { require: opts.require } : {},
+      ...opts.allProjects !== void 0 ? { allProjects: opts.allProjects } : {},
+      ...opts.newerThan !== void 0 ? { newerThan: opts.newerThan } : {},
+      ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+    };
+  }
+  async function executeRun(traces, opts, color) {
+    const shared = {
+      ...sharedRunOptions(opts),
+      color,
+      // Run-only, both of them: `--history` is a point in one session's
+      // timeline, and a manifest belongs to exactly one session (ADR 01024).
+      history: opts.history,
+      ...opts.manifest !== void 0 ? { manifest: opts.manifest } : {}
+    };
+    const selecting = opts.allProjects === true || opts.newerThan !== void 0 || opts.limit !== void 0;
+    if (traces.length > 1 || selecting) {
+      if (opts.manifest !== void 0) {
+        throw new TracevalsError(
+          "--manifest names one session's manifest, so it cannot be used with a corpus; drop it and each trace will find its own"
+        );
+      }
+      const { runBatch } = await import("./batch-7JJWXWSF.js");
+      const { report: report2, rendered: rendered3 } = await runBatch({
+        ...shared,
+        ...traces.length > 0 ? { traces } : {}
+      });
+      console.log(rendered3);
+      process.exitCode = report2.exitCode;
+      return;
+    }
+    let trace = traces[0];
+    if (trace === void 0) {
+      if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        throw new TracevalsError(
+          "no trace given; pass a trace file or run `manni tracevals list`"
+        );
+      }
+      const { pickTrace } = await import("./picker-6HRMETE7.js");
+      trace = await pickTrace();
+    }
+    const { report, rendered: rendered2 } = await runRun2({ ...shared, tracePath: trace });
+    console.log(rendered2);
+    process.exitCode = report.exitCode;
+  }
+  function addRunFlags(cmd, options = {}) {
+    const withHistory = options.history !== false;
+    const formats = options.formats ?? REPORT_FORMATS3;
+    const base = addConfigFlags(cmd).option(
+      "--project <dir>",
+      "artifact-lookup root (overrides the trace's recorded cwd)"
+    ).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", (v) => Number(v)).option("--deterministic-only", "skip LLM-judged evals").option(
+      "--offline",
+      "never fetch a remote manifest; read external metadata from local manifests"
+    ).option("--no-cache", "bypass the judge cache").option(
+      "--max-turns <n>",
+      "Stop after this many ensemble runs (a cached ensemble costs none)",
+      (v) => Number(v)
+    ).option(
+      "-f, --format <format>",
+      `Output format: ${formats.join(" | ")}`,
+      parseFormatArg("--format", formats),
+      "pretty"
+    ).option("-o, --output <file>", "also write the report to a file").option(
+      "--report-unused-artifacts",
+      "list every skill and agent the session was offered and never used"
+    ).option("--fail-on-review", "Exit 1 when any eval lands in the human-review zone (the default)").option("--no-fail-on-review", "Do not fail the run on evals left for human review").option(
+      "--allow-execution <kind>",
+      "Run only these execution grants (repeatable): frontmatter-commands",
+      collectGrant,
+      []
+    ).option("--no-execution", "Clear every execution grant for this run").option(
+      "--require <module>",
+      "load a grader plugin; repeatable, and added to config plugins",
+      collect,
+      []
+    ).option("--all-projects", "evaluate every project's traces in the session store").option(
+      "--newer-than <duration>",
+      "only traces modified within this window, such as 30m, 24h, 7d or 2w"
+    ).option("--limit <n>", "maximum traces to evaluate", (v) => Number(v));
+    return withHistory ? base.option(
+      "--history",
+      "append to history and compare with the previous run"
+    ) : base;
+  }
+  addRunFlags(
+    // No `isDefault` (proposal 0034): `run` is a verb, so a bare
+    // `manni tracevals` prints the help and exits 2, and a trace path with no
+    // verb is commander's unknown-command refusal rather than a silent run.
+    program.command("run [traces...]").description(
+      "Evaluate one or more traces against the skills and instructions they used"
+    )
+  ).option(
+    "--manifest <file>",
+    "session manifest to compare artifacts against; without it one is looked for beside the trace and under the project"
+  ).action(async (traces, opts, command) => {
+    try {
+      await executeRun(traces, opts, colorFor(command, process.stdout.isTTY));
+    } catch (e) {
+      fail(e);
+    }
+  });
+  addRunFlags(
+    program.command("calibrate [traces...]").description(
+      "Measure judged and graded verdicts against a labels file: false passes, false fails, and review volume"
+    ).option(
+      "--labels <file>",
+      "calibration labels sidecar (default: calibrate.labels)"
+    ).option(
+      "--sweep",
+      "re-score the corpus across the configured grid of zones and ensemble sizes, from cached verdicts"
+    ).option(
+      "--max-false-pass <n>",
+      "exit 1 above this many false passes",
+      (v) => Number(v)
+    ).option(
+      "--max-false-fail <n>",
+      "exit 1 above this many false fails",
+      (v) => Number(v)
+    ).option(
+      "--max-review <n>",
+      "exit 1 above this many needs-review outcomes",
+      (v) => Number(v)
+    ),
+    { history: false, formats: CALIBRATE_FORMATS }
+  ).action(
+    async (traces, opts, command) => {
+      try {
+        const shared = {
+          ...sharedRunOptions(opts),
+          color: colorFor(command, process.stdout.isTTY)
+        };
+        whole("--max-false-pass", opts.maxFalsePass, 0);
+        whole("--max-false-fail", opts.maxFalseFail, 0);
+        whole("--max-review", opts.maxReview, 0);
+        const { runCalibrate: runCalibrate2 } = await import("./calibrate-IA2ARFMH.js");
+        const { report, rendered: rendered2 } = await runCalibrate2({
+          ...shared,
+          ...traces.length > 0 ? { traces } : {},
+          ...opts.labels !== void 0 ? { labels: opts.labels } : {},
+          ...opts.sweep !== void 0 ? { sweep: opts.sweep } : {},
+          ...opts.maxFalsePass !== void 0 ? { maxFalsePass: opts.maxFalsePass } : {},
+          ...opts.maxFalseFail !== void 0 ? { maxFalseFail: opts.maxFalseFail } : {},
+          ...opts.maxReview !== void 0 ? { maxReview: opts.maxReview } : {}
+        });
+        console.log(rendered2);
+        process.exitCode = report.exitCode;
+      } catch (e) {
+        fail(e);
+      }
+    }
+  );
+  addConfigFlags(
+    program.command("fill [paths...]").description(
+      "Propose evals for skills, agent definitions, and project rules, and write those above the confidence threshold"
+    )
+  ).option("--project <dir>", "project root to scan (default: current directory)").option("--exclude <glob>", "Glob to exclude (repeatable)", collect, []).option("--dry-run", "report proposals without writing them").option(
+    "--confidence <n>",
+    "minimum confidence to write (0-1)",
+    (v) => parseFloat(v)
+  ).option(
+    "--max-evals <n>",
+    "maximum evals per artifact, including existing ones",
+    (v) => Number(v)
+  ).option(
+    "--max-turns <n>",
+    "Stop after this many inference calls (a cached artifact costs none)",
+    (v) => Number(v)
+  ).option("--no-cache", "bypass the proposal cache").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(
+    "--offline",
+    "never fetch a remote manifest; read external metadata from local manifests"
+  ).option(
+    "--require <module>",
+    "load a grader plugin; repeatable, and added to config plugins",
+    collect,
+    []
+  ).option(
+    "-f, --format <format>",
+    `Output format: ${SUMMARY_FORMATS2.join(" | ")}`,
+    parseFormatArg("--format", SUMMARY_FORMATS2),
+    "pretty"
+  ).action(async (paths, opts, command) => {
+    try {
+      numeric("--confidence", opts.confidence, 0, 1);
+      whole("--max-evals", opts.maxEvals, 1);
+      whole("--max-turns", opts.maxTurns, 1);
+      const { report, rendered: rendered2 } = await runFill3({
+        ...configOptions(opts),
+        ...paths.length > 0 ? { paths } : {},
+        ...opts.project !== void 0 ? { project: opts.project } : {},
+        ...opts.exclude !== void 0 ? { exclude: opts.exclude } : {},
+        ...opts.dryRun !== void 0 ? { dryRun: opts.dryRun } : {},
+        ...opts.confidence !== void 0 ? { confidence: opts.confidence } : {},
+        ...opts.maxEvals !== void 0 ? { maxEvals: opts.maxEvals } : {},
+        ...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
+        ...opts.cache === false ? { noCache: true } : {},
+        ...opts.provider !== void 0 ? { provider: opts.provider } : {},
+        ...opts.model !== void 0 ? { model: opts.model } : {},
+        ...opts.local !== void 0 ? { local: opts.local } : {},
+        ...opts.offline === true ? { offline: true } : {},
+        ...opts.require !== void 0 ? { require: opts.require } : {},
+        // P1 (proposal 0047): offered only on a terminal, where there is
+        // someone to answer. Off one the block goes to the artifact 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}.`);
+        },
+        color: colorFor(command, process.stdout.isTTY)
+      });
+      console.log(
+        opts.format === "json" ? JSON.stringify(report, null, 2) : rendered2
+      );
+      process.exitCode = report.exitCode;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  addConfigFlags(
+    program.command("capture").description(
+      "Record a session manifest: sha256 of every instruction artifact plus the git SHA, read from a Claude Code hook payload on stdin"
+    )
+  ).option("--project <dir>", "project root to scan (default: the payload's cwd)").option("--session-id <id>", "session id (default: the payload's session_id)").option("-o, --out <file>", "write here instead of the configured directory").option(
+    "-f, --format <format>",
+    `Output format: ${SUMMARY_FORMATS2.join(" | ")}`,
+    parseFormatArg("--format", SUMMARY_FORMATS2),
+    "pretty"
+  ).action(async (opts) => {
+    try {
+      const { runCapture } = await import("./capture-C32JXIFN.js");
+      const result = await runCapture({
+        version,
+        ...configOptions(opts),
+        ...opts.project !== void 0 ? { project: opts.project } : {},
+        ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
+        ...opts.out !== void 0 ? { out: opts.out } : {},
+        format: opts.format ?? "pretty"
+      });
+      if (result.stdout !== "") console.log(result.stdout);
+      if (result.stderr !== "") notice(result.stderr);
+      process.exitCode = result.exitCode;
+    } catch (e) {
+      fail(e);
+    }
+  });
+  program.command("list").description("List discoverable traces (Claude Code session files)").option(
+    "--project <dir>",
+    "project directory to scope to (default: current directory)"
+  ).option("--all-projects", "scan every project in the session store").option(
+    "--newer-than <duration>",
+    "only traces modified within this window, such as 30m, 24h, 7d or 2w"
+  ).option("--limit <n>", "maximum traces to list", (v) => Number(v)).option(
+    "-f, --format <format>",
+    `Output format: ${SUMMARY_FORMATS2.join(" | ")}`,
+    parseFormatArg("--format", SUMMARY_FORMATS2),
+    "pretty"
+  ).action(async (opts, command) => {
+    try {
+      whole("--limit", opts.limit, 1);
+      const run = await runList2({
+        project: opts.project,
+        allProjects: opts.allProjects,
+        ...opts.newerThan !== void 0 ? { newerThan: opts.newerThan } : {},
+        limit: opts.limit
+      });
+      console.log(
+        opts.format === "json" ? JSON.stringify(run, null, 2) : renderList2(run, { color: colorFor(command, process.stdout.isTTY) })
+      );
+    } catch (e) {
+      fail(e);
+    }
+  });
+  return program;
+}
+
 // src/cli.ts
-function buildProgram8() {
+function buildProgram10() {
   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 Command7();
+  const program = new Command9();
   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);
@@ -6500,7 +7643,7 @@ function buildProgram8() {
     )
   );
   program.addCommand(
-    buildProgram6().name("lint").description(
+    buildProgram7().name("lint").description(
       "Validate document structure against doctype templates, routed by a page's type"
     )
   );
@@ -6510,15 +7653,25 @@ function buildProgram8() {
     )
   );
   program.addCommand(
-    buildProgram7().name("term").description("Check, lint and render a docset's terms and the references into them")
+    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(
+    buildProgram9().name("tracevals").description(
+      "Deterministic and LLM-as-judge adherence evals for AI agent session traces"
+    )
   );
   program.addCommand(
     buildProgram5().name("key").description("Set and rotate the family key that encrypted values are encrypted with.")
   );
   return program;
 }
-runIfMain(import.meta.url, buildProgram8);
+runIfMain(import.meta.url, buildProgram10);
 export {
-  buildProgram8 as buildProgram
+  buildProgram10 as buildProgram
 };
 //# sourceMappingURL=cli.js.map