@hawkeyexl/manni 4.0.2 → 4.1.0

package/dist/cli.js

@@ -7,16 +7,20 @@ import {
   readStdin,
   reportConfig,
   splitList
-} from "./chunk-KSH7XS2R.js";
+} from "./chunk-JODRT4NF.js";
 import {
   CiteError,
+  DocevalsError,
+  EXECUTION_GRANTS,
   INFER_FORMATS,
   KeyError,
   LINT_JOBS,
   LintError,
+  REPORT_FORMATS as REPORT_FORMATS2,
   RULE_ID_PREFIX,
   SEVERITIES,
   SEVERITY_LIST,
+  SUMMARY_FORMATS,
   TOOLS_BY_JOB,
   asCiteError,
   codeEndAt,
@@ -26,40 +30,57 @@ import {
   isCiteRule,
   isInferFormat,
   isSeverity,
-  loadConfig,
+  listReviews,
+  loadConfig2 as loadConfig,
   meetsSeverity,
+  parseFormat,
   rebaseConfig,
   render,
+  render2,
+  renderCalibration,
   renderCheckGithub,
   renderCheckJson,
   renderCheckPretty,
+  renderFill,
+  renderList,
   renderRemoveJson,
   renderRemovePretty,
+  renderReviews,
   renderTemplates,
   renderTools,
   renderUpdateJson,
   renderUpdatePretty,
   resolveStructureTool,
   runAdd,
+  runCalibrate,
   runCheck,
+  runFill,
+  runGenerate,
+  runInit,
   runKeyRotate,
   runKeySet,
   runLint,
+  runList,
+  runPromote,
   runRemove,
+  runReview,
+  runRun,
   runTemplates,
   runTemplatesInfer,
   runTools,
   runUpdate,
+  seedGoldenCases,
   shortCommit,
   shortLine,
   shortPin,
   shortSrc,
   spellSource
-} from "./chunk-L26XRFBJ.js";
+} from "./chunk-S3NDEIOW.js";
 import {
   COMMON_FORMAT_LIST,
   CONCEPT_FIELDS,
   FAMILY_CONFIG_NAMES,
+  LOCAL_FLAG_HELP,
   OMITTED_WHEN_CLEAN,
   REPORT_FORMATS,
   REPORT_FORMAT_LIST,
@@ -100,10 +121,10 @@ import {
   terminalConfirm,
   valeConfigPath,
   valueAt
-} from "./chunk-TK5PYPFU.js";
+} from "./chunk-I57KBF45.js";
 
 // src/cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/a11y/cli.ts
 import { Command } from "commander";
@@ -858,7 +879,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);
@@ -1109,7 +1130,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 +1604,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 +2108,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(
@@ -1766,7 +2193,7 @@ function buildProgram4() {
 }
 
 // src/lint/cli.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 var LIST_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
 var TOOL_OPTIONS_GROUP = "Tool options:";
 function resolveColor2(program) {
@@ -1844,8 +2271,8 @@ function inputOptions(paths, options) {
     onNotice: notice
   };
 }
-function buildProgram5() {
-  const program = new Command4();
+function buildProgram6() {
+  const program = new Command5();
   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 +2297,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,7 +2471,7 @@ function buildProgram5() {
 }
 
 // src/term/cli.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/term/commands/check.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -4995,9 +5422,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 = {}) {
@@ -5313,7 +5740,7 @@ 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 };
 }
@@ -5436,14 +5863,14 @@ async function runWrite(opts) {
   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 +5879,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 }
@@ -5877,7 +6304,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 +6332,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 +6350,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 buildProgram7() {
+  const program = new Command6();
   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 +6367,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 +6383,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);
@@ -6042,12 +6469,12 @@ function buildProgram6() {
 }
 
 // src/cli.ts
-function buildProgram7() {
+function buildProgram8() {
   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 Command7();
   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 +6500,25 @@ function buildProgram7() {
     )
   );
   program.addCommand(
-    buildProgram5().name("lint").description(
+    buildProgram6().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(
+    buildProgram7().name("term").description("Check, lint and render a docset's terms and the references into them")
   );
   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, buildProgram8);
 export {
-  buildProgram7 as buildProgram
+  buildProgram8 as buildProgram
 };
 //# sourceMappingURL=cli.js.map