@hawkeyexl/manni 4.2.0 → 4.3.1

package/dist/{chunk-TH565O2N.js → chunk-ZQBTK3DO.js}

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-IOYXPBCL.js";
 
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "4.2.0",
+  version: "4.3.1",
   description: "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   type: "module",
   bin: {
@@ -36,6 +35,7 @@ var package_default = {
   files: [
     "dist",
     "schemas",
+    "plugin",
     "shapes",
     "templates"
   ],
@@ -105,6 +105,7 @@ var package_default = {
     "@asciidoctor/core": "^3.0.4",
     "@axe-core/playwright": "^4.13.0",
     "@hawkeyexl/inference": "^0.4.0",
+    "@inquirer/prompts": "^7.10.1",
     "@types/n3": "^1.26.3",
     "@xmldom/xmldom": "^0.9.12",
     ajv: "^8.17.1",
@@ -636,30 +637,6 @@ import { realpathSync as realpathSync2 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { CommanderError } from "commander";
 
-// src/shared/errors.ts
-var ToolError = class extends Error {
-  /** clig.dev: 2 is operational/usage; 1 is reserved for findings. */
-  exitCode = 2;
-  constructor(message) {
-    super(message);
-    this.name = "ToolError";
-  }
-};
-function errorMessage(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  if (typeof err === "number" || typeof err === "bigint") return String(err);
-  if (typeof err === "object" && err !== null && "message" in err && typeof err.message === "string") {
-    return err.message;
-  }
-  try {
-    const json = JSON.stringify(err);
-    if (json !== void 0) return json;
-  } catch {
-  }
-  return String(err);
-}
-
 // src/shared/program-name.ts
 var name = "manni";
 function programName() {
@@ -8079,22 +8056,799 @@ var __default42 = {
               description: "A relative path. It starts with no `/`, `\\` or `~`, no drive letter, and no URL scheme."
             }
           }
-        },
-        "generated-assertion-hash": {
-          pattern: "^sha256-[0-9a-f]{64}$",
-          description: "`sha256-` and sixty-four lowercase hex digits."
+        },
+        "generated-assertion-hash": {
+          pattern: "^sha256-[0-9a-f]{64}$",
+          description: "`sha256-` and sixty-four lowercase hex digits."
+        }
+      }
+    }
+  }
+};
+
+// src/meta/schemas/artifact-evals-strict/1.0.0.json
+var __default43 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:artifact-evals-strict:1.0.0",
+  title: "manni artifact-evals strict overlay v1.0.0",
+  description: "The strict overlay for manni:artifact-evals:1.0.0. Stack it beside the open vocabulary, which owns every key, every required rule and every conditional. Inside `metadata`, it narrows provider and model names, exit codes, companion paths and the assertion hash as manni:evals-strict:1.0.0 does. It also closes `grader` to the named graders and `tool:` integrations.",
+  additionalProperties: true,
+  type: "object",
+  properties: {
+    metadata: {
+      description: "Strict narrows the object entries of `metadata.evals`. A string shorthand passes as the open vocabulary reads it, and every other member of `metadata` passes untouched.",
+      properties: {
+        evals: {
+          items: {
+            $ref: "#/$defs/entry"
+          }
+        },
+        "meta-provenance": {
+          description: "Strict holds each entry to the rules the ai-context overlay applies to the same shape. `generated-by` is a model id with no spaces, and each pointer is well formed.",
+          items: {
+            properties: {
+              "generated-by": {
+                pattern: "^[A-Za-z0-9][A-Za-z0-9._:/\\\\@-]*$",
+                description: "A model id of letters in either case, digits, `.`, `_`, `:`, `/`, `\\`, `@` and `-`, with no spaces. A Windows path to a local model passes."
+              },
+              fields: {
+                items: {
+                  pattern: "^(?:/(?:[^~/]|~[01])*)+$",
+                  description: "A JSON Pointer in which every `~` begins an RFC 6901 escape, `~0` or `~1`."
+                }
+              },
+              confidence: {
+                propertyNames: {
+                  pattern: "^(?:(?:/(?:[^~/]|~[01])*)+|[a-z0-9][a-z0-9-]*)$",
+                  description: "A well-formed JSON Pointer, or a kebab eval id."
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  $defs: {
+    entry: {
+      description: "The rules strict adds to an object entry.",
+      properties: {
+        grader: {
+          anyOf: [
+            {
+              enum: [
+                "ai",
+                "human",
+                "command",
+                "tool-usage",
+                "skill-invoked",
+                "file-access",
+                "turn-count",
+                "cost",
+                "regex",
+                "json-output"
+              ]
+            },
+            {
+              type: "string",
+              pattern: "^tool:[a-z0-9][a-z0-9-]*$"
+            }
+          ],
+          description: "One of the ten named graders, or a `tool:<kebab>` integration. Strict accepts no other kebab name."
+        },
+        provider: {
+          pattern: "^[a-z0-9][a-z0-9-]*$",
+          description: "A kebab provider name, such as `anthropic` or `llama-cpp`."
+        },
+        model: {
+          pattern: "^[A-Za-z0-9][A-Za-z0-9._:/\\\\@-]*$",
+          description: "A model id of letters in either case, digits, `.`, `_`, `:`, `/`, `\\`, `@` and `-`, with no spaces. A Windows path to a local model passes."
+        },
+        "success-exit-codes": {
+          uniqueItems: true,
+          items: {
+            type: "integer",
+            minimum: 0,
+            maximum: 255
+          },
+          description: "Distinct exit codes, each from 0 to 255, the range a process can return."
+        },
+        target: {
+          properties: {
+            path: {
+              pattern: "^(?![\\\\/~])(?![A-Za-z]:)(?![A-Za-z][A-Za-z0-9+.-]*://).+$",
+              description: "A relative path. It starts with no `/`, `\\` or `~`, no drive letter, and no URL scheme."
+            }
+          }
+        },
+        "generated-assertion-hash": {
+          pattern: "^sha256-[0-9a-f]{64}$",
+          description: "`sha256-` and sixty-four lowercase hex digits."
+        }
+      }
+    }
+  }
+};
+
+// src/meta/schemas/graph-strict/1.0.0.json
+var __default44 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:graph-strict:1.0.0",
+  title: "manni graph strict overlay v1.0.0",
+  description: "The strict overlay for manni:graph:1.0.0. Stack it beside the open vocabulary, which owns the closed `graph` block and its iiRDS enums. It narrows section keys to heading slugs and lineage references to single tokens.",
+  additionalProperties: true,
+  type: "object",
+  properties: {
+    graph: {
+      description: "Strict narrows `sections` keys, `revision-of` and `derived-from`. Every other member of the block passes as the open vocabulary reads it.",
+      properties: {
+        sections: {
+          propertyNames: {
+            pattern: "^[\\p{Ll}\\p{Lm}\\p{Lo}\\p{M}\\p{Nd}_-]+$",
+            description: "A heading slug of lowercase letters, caseless letters and their marks, digits, `_` and `-`. It admits slugs from scripts without case, such as Han, Arabic and Devanagari. The pattern uses Unicode property escapes, so a validator must compile it with the ECMA-262 `u` flag, as Ajv does for a 2020-12 schema."
+          }
+        },
+        "revision-of": {
+          $ref: "#/$defs/refList"
+        },
+        "derived-from": {
+          $ref: "#/$defs/refList"
+        }
+      }
+    }
+  },
+  $defs: {
+    refList: {
+      pattern: "^\\S(?:.*\\S)?$",
+      items: {
+        pattern: "^\\S(?:.*\\S)?$"
+      },
+      description: "A path or URL on one line with no surrounding space, alone or in each item of the list. A path may contain spaces."
+    }
+  }
+};
+
+// src/meta/schemas/citations-strict/1.0.0.json
+var __default45 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:citations-strict:1.0.0",
+  title: "manni citations strict overlay v1.0.0",
+  description: "The strict overlay for manni:citations:1.0.0. Stack it beside the open vocabulary, which owns every key and every required rule. It asks for the full commit hash a tool writes, and it pairs the pin's prefix with the source file.",
+  additionalProperties: true,
+  type: "object",
+  properties: {
+    citations: {
+      description: "Strict narrows each entry's `source`. An encrypted `file` takes an `hmac-sha256-` pin, a plain one takes a `sha256-` pin, and `commit-sha` is a full hash.",
+      items: {
+        properties: {
+          source: {
+            properties: {
+              "commit-sha": {
+                pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$",
+                description: "A full commit hash, forty lowercase hex digits or sixty-four in a SHA-256 repository."
+              }
+            },
+            if: {
+              properties: {
+                file: {
+                  pattern: "^~"
+                }
+              },
+              required: [
+                "file"
+              ]
+            },
+            then: {
+              properties: {
+                integrity: {
+                  pattern: "^hmac-sha256-",
+                  description: "An encrypted `file` is pinned `hmac-sha256-`."
+                }
+              }
+            },
+            else: {
+              properties: {
+                integrity: {
+                  pattern: "^sha256-",
+                  description: "A plain `file` is pinned `sha256-`."
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/meta/schemas/tgdp/1.1.json
+var __default46 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "tgdp:templates:1.1",
+  title: "The Good Docs Project templates v1.1",
+  description: "Requires `type` and recommends the 25 template slugs that The Good Docs Project publishes (upstream templates repo, main as of 2026-08-09). Any other non-empty string names a page type TGDP does not publish, and passes. Stack tgdp:templates-strict:1.1 beside it to close `type` to the 25 slugs. Adopting it states that every page has a type, so an untyped page is a gap. Diataxis classifies what a page *is* on the same key, so a page under both has to satisfy both. Pick one. It composes freely with a schema keyed on a different field, such as passo-uno:seven-action:1.0. See https://www.thegooddocsproject.dev/template",
+  type: "object",
+  additionalProperties: true,
+  required: [
+    "type"
+  ],
+  properties: {
+    type: {
+      anyOf: [
+        {
+          type: "string",
+          minLength: 1
+        },
+        {
+          enum: [
+            "api-getting-started",
+            "api-reference",
+            "bug-report",
+            "changelog",
+            "code-of-conduct",
+            "code-of-conduct-incident-record",
+            "code-of-conduct-remediation-record",
+            "code-of-conduct-response-plan",
+            "concept",
+            "contact-support",
+            "contributing-guide",
+            "glossary",
+            "how-to",
+            "installation-guide",
+            "our-team",
+            "quickstart",
+            "readme",
+            "reference",
+            "release-notes",
+            "sdk-overview",
+            "style-guide",
+            "terminology-system",
+            "troubleshooting",
+            "tutorial",
+            "user-personas"
+          ]
+        }
+      ],
+      description: "Which page type this page is, as a Good Docs Project template slug where one fits. The 25 slugs are the recommended values. The Core pack is `concept`, `how-to`, `readme`, `reference`, `release-notes`, `troubleshooting` and `tutorial`. The rest come from the Community and Misc packs. Any other non-empty string names a page type TGDP does not publish. The enum recommends and rejects nothing; stack tgdp:templates-strict:1.1 to close the list."
+    }
+  }
+};
+
+// src/meta/schemas/tgdp-strict/1.1.json
+var __default47 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "tgdp:templates-strict:1.1",
+  title: "The Good Docs Project templates strict overlay v1.1",
+  description: "The strict overlay for tgdp:templates:1.1. Stack it beside the open schema, which owns the key and the required rule. It closes `type` to the 25 template slugs and requires no key.",
+  additionalProperties: true,
+  type: "object",
+  properties: {
+    type: {
+      enum: [
+        "api-getting-started",
+        "api-reference",
+        "bug-report",
+        "changelog",
+        "code-of-conduct",
+        "code-of-conduct-incident-record",
+        "code-of-conduct-remediation-record",
+        "code-of-conduct-response-plan",
+        "concept",
+        "contact-support",
+        "contributing-guide",
+        "glossary",
+        "how-to",
+        "installation-guide",
+        "our-team",
+        "quickstart",
+        "readme",
+        "reference",
+        "release-notes",
+        "sdk-overview",
+        "style-guide",
+        "terminology-system",
+        "troubleshooting",
+        "tutorial",
+        "user-personas"
+      ],
+      description: "Stacked beside tgdp:templates:1.1, strict closes `type` to the 25 template slugs. That is the check tgdp:templates:1.0 makes in one file."
+    }
+  }
+};
+
+// src/meta/schemas/artifact-evals/1.1.0.json
+var __default48 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:artifact-evals:1.1.0",
+  title: "manni artifact-evals vocabulary v1.1.0",
+  description: "Eval declarations for instruction artifacts - skills, agent definitions, and project-rules files: assertions about what must have held in an agent session that used the artifact. A manni common vocabulary sharing the entry shape of manni:evals:1.0.0. The page-side keys appear here one level down - `metadata.evals` (one assertion or the list), `metadata.eval-skip`, and `metadata.meta-provenance`, the page-level attribution record of manni:ai-context:1.0.0 with the same entry shape - because an artifact's top-level frontmatter is the host tool's contract and `metadata` is its sanctioned extension bag; there is no container object inside it - the list is the value. `metadata` stays open so other tools' members pass untouched, and the `eval-` prefix is reserved and enforced inside it: an unrecognized `eval-*` member is rejected, the same loud-typo guard as the page side.",
+  type: "object",
+  additionalProperties: true,
+  properties: {
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        evals: {
+          type: [
+            "string",
+            "array"
+          ],
+          minLength: 1,
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/evalEntry"
+          },
+          description: "The evals for this artifact: one AI-judged assertion as a string, or a non-empty list of entries \u2014 string shorthands, or closed objects with a required id. An empty list is not a declaration; an artifact with no evals omits the key. Ids are unique within an artifact: two entries claiming one id is an error, not a last-one-wins override. JSON Schema cannot express that over a mixed-shape array - `uniqueItems` is whole-item equality - so it is a requirement on implementations, stated here so every tool agrees on the rule."
+        },
+        "eval-skip": {
+          type: "boolean",
+          default: false,
+          description: "Skip this artifact's evals entirely \u2014 reported as skipped, never silently ignored. The page-side key, one level down; default false."
+        },
+        "meta-provenance": {
+          type: "array",
+          minItems: 1,
+          items: {
+            $ref: "#/$defs/metaProvenanceEntry"
+          },
+          description: "Attribution for machine-proposed metadata, one entry per model (consumers merge by generated-by; the schema dedupes identical entries): which evals (by id) and which fields (by JSON Pointer) it proposed, at what confidence. A human deletes an entry once those are reviewed, so a surviving entry means unreviewed machine metadata. The page-level `meta-provenance`, one level down, with the entry shape repeated byte for byte. The name does not start with `eval-`, so the prefix guard does not apply to it.",
+          uniqueItems: true
+        }
+      },
+      patternProperties: {
+        "^eval-(?!skip$)": false
+      },
+      "x-manni-location": "external"
+    }
+  },
+  $defs: {
+    metaProvenanceEntry: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "generated-by"
+      ],
+      anyOf: [
+        {
+          required: [
+            "fields"
+          ]
+        },
+        {
+          required: [
+            "evals"
+          ]
+        }
+      ],
+      description: "One model's proposals: which metadata values and which evals it proposed, at what confidence. At least one of `fields` or `evals` is required, because an entry naming neither says nothing.",
+      properties: {
+        "generated-by": {
+          type: "string",
+          minLength: 1,
+          description: "Model or agent that proposed the fields or evals."
+        },
+        fields: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            pattern: "^/"
+          },
+          uniqueItems: true,
+          description: "The metadata values it proposed, as JSON Pointers: the same form `validate` reports. `/intent` names a top-level key and `/graph/label` reaches into a block. Pointers let one entry shape cover every vocabulary stacked on the document."
+        },
+        evals: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            pattern: "^[a-z0-9][a-z0-9-]*$"
+          },
+          uniqueItems: true,
+          description: "The evals it proposed, by kebab id, so a reordered eval list does not orphan them."
+        },
+        confidence: {
+          type: "object",
+          propertyNames: {
+            pattern: "^(?:/.*|[a-z0-9][a-z0-9-]*)$"
+          },
+          additionalProperties: {
+            type: "number",
+            minimum: 0,
+            maximum: 1
+          },
+          description: "Model confidence, 0..1, keyed by a pointer from `fields` or an id from `evals`. The two key forms cannot collide: a pointer starts with `/` and an id cannot. A confidence attached to a malformed key fails here instead of dangling."
+        }
+      }
+    },
+    evalEntry: {
+      if: {
+        type: "string"
+      },
+      then: {
+        type: "string",
+        minLength: 1
+      },
+      else: {
+        $ref: "#/$defs/inlineEval"
+      },
+      description: "One eval: a string shorthand (an AI-judged assertion at error severity \u2014 the legitimately id-less form), or a closed object. Branched with if/then rather than oneOf so a fault inside the object form is reported once, against the key that is wrong."
+    },
+    inlineEval: {
+      type: "object",
+      required: [
+        "id"
+      ],
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^[a-z0-9][a-z0-9-]*$",
+          description: "Unique (per artifact) kebab-case identifier. Required on the object form \u2014 position-derived names orphan cached verdicts whenever entries move; if an eval is worth an object, it is worth a stable name."
+        },
+        assertion: {
+          type: "string",
+          minLength: 1,
+          description: "What must have held in the session that used this artifact."
+        },
+        type: {
+          $ref: "#/$defs/evalType"
+        },
+        grader: {
+          $ref: "#/$defs/grader"
+        },
+        provider: {
+          type: "string",
+          minLength: 1,
+          description: "Which configured inference provider or agent judges an `ai`-graded eval. Legal values are whatever the inference dependency supports, validated at run time; omit for the config default."
+        },
+        model: {
+          type: "string",
+          minLength: 1,
+          description: "Model that judges an `ai`-graded eval, within `provider`. Legal values are whatever the inference dependency supports, validated at run time; omit for the config default. Two uses: an eval that matters can name a stronger judge than the default, and an eval can name a judge other than the model that produced the session it grades - a model asked whether its own session followed the rules is the sharpest form of self-preference bias there is. Meaningful only on `ai` evals."
+        },
+        runs: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          description: "Ensemble runs for this eval, overriding the tool's configured default. Lets a high-stakes or known-flaky assertion buy more agreement than a cheap one, which a corpus-wide setting cannot. Capped because it multiplies cost directly. Meaningful only on `ai` evals."
+        },
+        command: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            minLength: 1
+          },
+          description: "Command to execute for command-graded evals. {trace} is replaced with the session trace path \u2014 the artifact-side analog of the page side's {file} \u2014 and exit 0 (or `success-exit-codes`) is a pass. Omitting it is the generation contract: tooling generates a check script from the assertion, then writes `command` and `generated-assertion-hash` back. Legal only alongside `grader: command`."
+        },
+        "success-exit-codes": {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "integer"
+          },
+          default: [
+            0
+          ],
+          description: "Exit codes that count as a pass."
+        },
+        "timeout-ms": {
+          type: "integer",
+          minimum: 1,
+          description: "Timeout for command-graded evals."
+        },
+        "generated-assertion-hash": {
+          type: "string",
+          description: "sha256 of the assertion when the check script was generated \u2014 written back alongside `command`, and never legal without it. A mismatch with the current assertion triggers regeneration."
+        },
+        options: {
+          type: "object",
+          description: "Grader-specific options; validated by the grader at run time, deliberately outside this schema \u2014 a grader's options evolve on the grader's schedule."
+        },
+        severity: {
+          $ref: "#/$defs/severity"
+        },
+        weight: {
+          type: "number",
+          exclusiveMinimum: 0,
+          default: 1,
+          description: "Relative contribution to an aggregate score across evals. Does not change this eval's own pass/fail, nor its severity: an eval still passes or fails on its own terms, and weight only decides how much that outcome moves a run total. Zero is excluded deliberately - a weightless eval is a silent disable, and `skip` already means that, loudly."
+        },
+        "severity-map": {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/severity"
+          },
+          description: "Maps a tool grader's own severities onto eval severities. Meaningful only on `tool:*` evals \u2014 imported from the page side to keep the entry vocabularies congruent."
+        },
+        skip: {
+          type: "boolean"
+        },
+        evidence: {
+          type: "string",
+          minLength: 1,
+          description: "Hint telling the judge where in the session to look."
+        },
+        target: {
+          $ref: "#/$defs/target"
+        },
+        examples: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            pass: {
+              $ref: "#/$defs/anchorList"
+            },
+            fail: {
+              $ref: "#/$defs/anchorList"
+            }
+          },
+          description: "Anchor examples of passing and failing behavior for the judge \u2014 one or several each."
+        }
+      },
+      additionalProperties: false,
+      dependentRequired: {
+        "generated-assertion-hash": [
+          "command"
+        ]
+      },
+      allOf: [
+        {
+          if: {
+            properties: {
+              grader: {
+                const: "ai"
+              }
+            },
+            required: [
+              "grader"
+            ]
+          },
+          then: {
+            required: [
+              "assertion"
+            ]
+          }
+        },
+        {
+          if: {
+            not: {
+              required: [
+                "grader"
+              ]
+            }
+          },
+          then: {
+            required: [
+              "assertion"
+            ],
+            description: "No grader means the `ai` default, so the assertion the judge reads is required."
+          }
+        },
+        {
+          if: {
+            properties: {
+              grader: {
+                const: "human"
+              }
+            },
+            required: [
+              "grader"
+            ]
+          },
+          then: {
+            required: [
+              "assertion"
+            ]
+          }
+        },
+        {
+          if: {
+            properties: {
+              grader: {
+                const: "command"
+              }
+            },
+            required: [
+              "grader"
+            ]
+          },
+          then: {
+            anyOf: [
+              {
+                required: [
+                  "assertion"
+                ]
+              },
+              {
+                required: [
+                  "command"
+                ]
+              }
+            ],
+            description: "A command eval carries either the assertion its script is generated from, or the command itself - the generation contract writes the second from the first."
+          }
+        },
+        {
+          if: {
+            required: [
+              "command"
+            ]
+          },
+          then: {
+            properties: {
+              grader: {
+                const: "command"
+              }
+            },
+            required: [
+              "grader"
+            ],
+            description: "An entry carrying an executable command must say grader: command."
+          }
+        },
+        {
+          if: {
+            anyOf: [
+              {
+                required: [
+                  "success-exit-codes"
+                ]
+              },
+              {
+                required: [
+                  "timeout-ms"
+                ]
+              }
+            ]
+          },
+          then: {
+            properties: {
+              grader: {
+                const: "command"
+              }
+            },
+            required: [
+              "grader"
+            ],
+            description: "success-exit-codes and timeout-ms configure command execution, so they are legal only alongside grader: command \u2014 present, or generated later under the generation contract."
+          }
+        },
+        {
+          if: {
+            anyOf: [
+              {
+                required: [
+                  "provider"
+                ]
+              },
+              {
+                required: [
+                  "model"
+                ]
+              },
+              {
+                required: [
+                  "runs"
+                ]
+              }
+            ]
+          },
+          then: {
+            properties: {
+              grader: {
+                const: "ai"
+              }
+            },
+            description: "provider, model and runs configure the AI judge, so they are legal only on an `ai` eval. `grader` is not required alongside them because `ai` is the default."
+          }
+        }
+      ]
+    },
+    evalType: {
+      enum: [
+        "capability",
+        "regression"
+      ],
+      default: "regression",
+      description: "`capability` probes a boundary and is expected to fail sometimes; `regression` protects behavior that already works. Reported, not enforced."
+    },
+    severity: {
+      enum: [
+        "error",
+        "warning",
+        "notice"
+      ],
+      default: "error",
+      description: "Only error-severity failures fail the eval; warning and notice report but pass. The three levels are the family scale in manni's shared severity, so a finding reads the same in every tool. Default error \u2014 the string shorthand implies it."
+    },
+    grader: {
+      anyOf: [
+        {
+          type: "string",
+          pattern: "^(tool:)?[a-z0-9][a-z0-9-]*$"
+        },
+        {
+          enum: [
+            "ai",
+            "human",
+            "command",
+            "tool-usage",
+            "skill-invoked",
+            "file-access",
+            "turn-count",
+            "cost",
+            "regex",
+            "json-output",
+            "tool-order"
+          ]
+        }
+      ],
+      default: "ai",
+      description: "How the assertion is checked: the AI judge (`ai`); a human review queue (`human` \u2014 judged per session, since every trace is new, unlike the page side where a verdict persists until the page changes); an executable check over the trace (`command`); a deterministic session grader \u2014 `tool-usage`, `tool-order`, `skill-invoked`, `file-access`, `turn-count`, `cost`, `regex`, `json-output`; or a `tool:<kebab>` integration, the page side's namespace, accepted here so one grader spelling ports across both eval vocabularies. Recommended values, not a closed list: any kebab name is legal and validated against the grader registry at run time, so a new grader never needs a schema version \u2014 the one cost is that a stale or misspelled grader name passes this schema and is rejected by the registry instead."
+    },
+    anchorList: {
+      if: {
+        type: "array"
+      },
+      then: {
+        type: "array",
+        minItems: 1,
+        uniqueItems: true,
+        items: {
+          type: "string",
+          minLength: 1
+        }
+      },
+      else: {
+        type: "string",
+        minLength: 1
+      },
+      description: "One anchor example, or a non-empty list of them."
+    },
+    target: {
+      if: {
+        type: "object"
+      },
+      then: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "source",
+          "path"
+        ],
+        properties: {
+          source: {
+            const: "file"
+          },
+          path: {
+            type: "string",
+            minLength: 1,
+            description: "Path to the file to grade, relative to the session's working directory."
+          }
         }
-      }
+      },
+      else: {
+        enum: [
+          "transcript",
+          "last-message",
+          "files",
+          "artifact"
+        ]
+      },
+      default: "transcript",
+      description: "What the grader receives: the whole session (`transcript`), the final assistant message (`last-message`), the list of files the session wrote (`files`), the instruction artifact itself (`artifact`), or a named file. Distinct from `evidence`, which hints where to look within what is graded - this selects the bytes themselves, and it is structural, so deterministic graders honour it too. Named `target` rather than `focus` for that reason: a regex grader has no focus, it has a target. Branched with if/then rather than oneOf so a fault inside the object form is reported once, against the key that is wrong."
     }
   }
 };
 
-// src/meta/schemas/artifact-evals-strict/1.0.0.json
-var __default43 = {
+// src/meta/schemas/artifact-evals-strict/1.1.0.json
+var __default49 = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "manni:artifact-evals-strict:1.0.0",
-  title: "manni artifact-evals strict overlay v1.0.0",
-  description: "The strict overlay for manni:artifact-evals:1.0.0. Stack it beside the open vocabulary, which owns every key, every required rule and every conditional. Inside `metadata`, it narrows provider and model names, exit codes, companion paths and the assertion hash as manni:evals-strict:1.0.0 does. It also closes `grader` to the named graders and `tool:` integrations.",
+  $id: "manni:artifact-evals-strict:1.1.0",
+  title: "manni artifact-evals strict overlay v1.1.0",
+  description: "The strict overlay for manni:artifact-evals:1.1.0. Stack it beside the open vocabulary, which owns every key, every required rule and every conditional. Inside `metadata`, it narrows provider and model names, exit codes, companion paths and the assertion hash as manni:evals-strict:1.0.0 does. It also closes `grader` to the named graders and `tool:` integrations.",
   additionalProperties: true,
   type: "object",
   properties: {
@@ -8149,7 +8903,8 @@ var __default43 = {
                 "turn-count",
                 "cost",
                 "regex",
-                "json-output"
+                "json-output",
+                "tool-order"
               ]
             },
             {
@@ -8157,7 +8912,7 @@ var __default43 = {
               pattern: "^tool:[a-z0-9][a-z0-9-]*$"
             }
           ],
-          description: "One of the ten named graders, or a `tool:<kebab>` integration. Strict accepts no other kebab name."
+          description: "One of the eleven named graders, or a `tool:<kebab>` integration. Strict accepts no other kebab name."
         },
         provider: {
           pattern: "^[a-z0-9][a-z0-9-]*$",
@@ -8193,194 +8948,8 @@ var __default43 = {
   }
 };
 
-// src/meta/schemas/graph-strict/1.0.0.json
-var __default44 = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "manni:graph-strict:1.0.0",
-  title: "manni graph strict overlay v1.0.0",
-  description: "The strict overlay for manni:graph:1.0.0. Stack it beside the open vocabulary, which owns the closed `graph` block and its iiRDS enums. It narrows section keys to heading slugs and lineage references to single tokens.",
-  additionalProperties: true,
-  type: "object",
-  properties: {
-    graph: {
-      description: "Strict narrows `sections` keys, `revision-of` and `derived-from`. Every other member of the block passes as the open vocabulary reads it.",
-      properties: {
-        sections: {
-          propertyNames: {
-            pattern: "^[\\p{Ll}\\p{Lm}\\p{Lo}\\p{M}\\p{Nd}_-]+$",
-            description: "A heading slug of lowercase letters, caseless letters and their marks, digits, `_` and `-`. It admits slugs from scripts without case, such as Han, Arabic and Devanagari. The pattern uses Unicode property escapes, so a validator must compile it with the ECMA-262 `u` flag, as Ajv does for a 2020-12 schema."
-          }
-        },
-        "revision-of": {
-          $ref: "#/$defs/refList"
-        },
-        "derived-from": {
-          $ref: "#/$defs/refList"
-        }
-      }
-    }
-  },
-  $defs: {
-    refList: {
-      pattern: "^\\S(?:.*\\S)?$",
-      items: {
-        pattern: "^\\S(?:.*\\S)?$"
-      },
-      description: "A path or URL on one line with no surrounding space, alone or in each item of the list. A path may contain spaces."
-    }
-  }
-};
-
-// src/meta/schemas/citations-strict/1.0.0.json
-var __default45 = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "manni:citations-strict:1.0.0",
-  title: "manni citations strict overlay v1.0.0",
-  description: "The strict overlay for manni:citations:1.0.0. Stack it beside the open vocabulary, which owns every key and every required rule. It asks for the full commit hash a tool writes, and it pairs the pin's prefix with the source file.",
-  additionalProperties: true,
-  type: "object",
-  properties: {
-    citations: {
-      description: "Strict narrows each entry's `source`. An encrypted `file` takes an `hmac-sha256-` pin, a plain one takes a `sha256-` pin, and `commit-sha` is a full hash.",
-      items: {
-        properties: {
-          source: {
-            properties: {
-              "commit-sha": {
-                pattern: "^(?:[0-9a-f]{40}|[0-9a-f]{64})$",
-                description: "A full commit hash, forty lowercase hex digits or sixty-four in a SHA-256 repository."
-              }
-            },
-            if: {
-              properties: {
-                file: {
-                  pattern: "^~"
-                }
-              },
-              required: [
-                "file"
-              ]
-            },
-            then: {
-              properties: {
-                integrity: {
-                  pattern: "^hmac-sha256-",
-                  description: "An encrypted `file` is pinned `hmac-sha256-`."
-                }
-              }
-            },
-            else: {
-              properties: {
-                integrity: {
-                  pattern: "^sha256-",
-                  description: "A plain `file` is pinned `sha256-`."
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-// src/meta/schemas/tgdp/1.1.json
-var __default46 = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "tgdp:templates:1.1",
-  title: "The Good Docs Project templates v1.1",
-  description: "Requires `type` and recommends the 25 template slugs that The Good Docs Project publishes (upstream templates repo, main as of 2026-08-09). Any other non-empty string names a page type TGDP does not publish, and passes. Stack tgdp:templates-strict:1.1 beside it to close `type` to the 25 slugs. Adopting it states that every page has a type, so an untyped page is a gap. Diataxis classifies what a page *is* on the same key, so a page under both has to satisfy both. Pick one. It composes freely with a schema keyed on a different field, such as passo-uno:seven-action:1.0. See https://www.thegooddocsproject.dev/template",
-  type: "object",
-  additionalProperties: true,
-  required: [
-    "type"
-  ],
-  properties: {
-    type: {
-      anyOf: [
-        {
-          type: "string",
-          minLength: 1
-        },
-        {
-          enum: [
-            "api-getting-started",
-            "api-reference",
-            "bug-report",
-            "changelog",
-            "code-of-conduct",
-            "code-of-conduct-incident-record",
-            "code-of-conduct-remediation-record",
-            "code-of-conduct-response-plan",
-            "concept",
-            "contact-support",
-            "contributing-guide",
-            "glossary",
-            "how-to",
-            "installation-guide",
-            "our-team",
-            "quickstart",
-            "readme",
-            "reference",
-            "release-notes",
-            "sdk-overview",
-            "style-guide",
-            "terminology-system",
-            "troubleshooting",
-            "tutorial",
-            "user-personas"
-          ]
-        }
-      ],
-      description: "Which page type this page is, as a Good Docs Project template slug where one fits. The 25 slugs are the recommended values. The Core pack is `concept`, `how-to`, `readme`, `reference`, `release-notes`, `troubleshooting` and `tutorial`. The rest come from the Community and Misc packs. Any other non-empty string names a page type TGDP does not publish. The enum recommends and rejects nothing; stack tgdp:templates-strict:1.1 to close the list."
-    }
-  }
-};
-
-// src/meta/schemas/tgdp-strict/1.1.json
-var __default47 = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "tgdp:templates-strict:1.1",
-  title: "The Good Docs Project templates strict overlay v1.1",
-  description: "The strict overlay for tgdp:templates:1.1. Stack it beside the open schema, which owns the key and the required rule. It closes `type` to the 25 template slugs and requires no key.",
-  additionalProperties: true,
-  type: "object",
-  properties: {
-    type: {
-      enum: [
-        "api-getting-started",
-        "api-reference",
-        "bug-report",
-        "changelog",
-        "code-of-conduct",
-        "code-of-conduct-incident-record",
-        "code-of-conduct-remediation-record",
-        "code-of-conduct-response-plan",
-        "concept",
-        "contact-support",
-        "contributing-guide",
-        "glossary",
-        "how-to",
-        "installation-guide",
-        "our-team",
-        "quickstart",
-        "readme",
-        "reference",
-        "release-notes",
-        "sdk-overview",
-        "style-guide",
-        "terminology-system",
-        "troubleshooting",
-        "tutorial",
-        "user-personas"
-      ],
-      description: "Stacked beside tgdp:templates:1.1, strict closes `type` to the 25 template slugs. That is the check tgdp:templates:1.0 makes in one file."
-    }
-  }
-};
-
 // src/meta/schemas/stewardship/1.1.0.json
-var __default48 = {
+var __default50 = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
   $id: "manni:stewardship:1.1.0",
   title: "manni stewardship vocabulary v1.1.0",
@@ -8507,7 +9076,7 @@ var __default48 = {
 };
 
 // src/meta/schemas/stewardship-strict/1.1.0.json
-var __default49 = {
+var __default51 = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
   $id: "manni:stewardship-strict:1.1.0",
   title: "manni stewardship strict overlay v1.1.0",
@@ -8673,8 +9242,10 @@ var BUILTINS = /* @__PURE__ */ new Map([
   ["manni:citations-strict:1.0.0", __default45],
   ["tgdp:templates:1.1", __default46],
   ["tgdp:templates-strict:1.1", __default47],
-  ["manni:stewardship:1.1.0", __default48],
-  ["manni:stewardship-strict:1.1.0", __default49]
+  ["manni:artifact-evals:1.1.0", __default48],
+  ["manni:artifact-evals-strict:1.1.0", __default49],
+  ["manni:stewardship:1.1.0", __default50],
+  ["manni:stewardship-strict:1.1.0", __default51]
 ]);
 var ANNOTATION_ONLY_PREDECESSORS = /* @__PURE__ */ new Map([
   ["manni:stewardship:1.1.0", "manni:stewardship:1.0.0"],
@@ -8772,6 +9343,8 @@ var PUBLISHED_PATHS = [
   ["citations-strict/1.0.0.json", "manni:citations-strict:1.0.0"],
   ["tgdp/1.1.json", "tgdp:templates:1.1"],
   ["tgdp-strict/1.1.json", "tgdp:templates-strict:1.1"],
+  ["artifact-evals/1.1.0.json", "manni:artifact-evals:1.1.0"],
+  ["artifact-evals-strict/1.1.0.json", "manni:artifact-evals-strict:1.1.0"],
   ["stewardship/1.1.0.json", "manni:stewardship:1.1.0"],
   ["stewardship-strict/1.1.0.json", "manni:stewardship-strict:1.1.0"]
 ];
@@ -11727,9 +12300,7 @@ function renderSarif(results, opts = {}) {
   )}`;
 }
 
-// src/meta/reporters/junit.ts
-var SUITE_NAME = "manni";
-var CLASS_NAME = "manni.validate";
+// src/shared/xml.ts
 var XML_ENTITIES = {
   "&": "&amp;",
   "<": "&lt;",
@@ -11749,6 +12320,10 @@ function xmlEscape(value) {
   }
   return out;
 }
+
+// src/meta/reporters/junit.ts
+var SUITE_NAME = "manni";
+var CLASS_NAME = "manni.validate";
 var attr = (name2, value) => ` ${name2}="${xmlEscape(value)}"`;
 function renderJunit(results, opts = {}) {
   const tests = results.length;
@@ -11798,6 +12373,16 @@ function shouldColor(opts) {
   if (env.NO_COLOR != null && env.NO_COLOR !== "") return false;
   return Boolean(opts.isTTY);
 }
+function colorFor(command, isTTY, env) {
+  const noColor = colorOwner(command).opts().color === false;
+  return shouldColor({ noColor, isTTY, env });
+}
+function colorOwner(command) {
+  for (let c = command; c !== null; c = c.parent) {
+    if (c.options.some((o) => o.long === "--no-color")) return c;
+  }
+  return command;
+}
 
 // src/shared/github.ts
 function escapeWorkflowCommandMessage(message) {
@@ -12035,7 +12620,7 @@ async function readCapped(url, res, maxBytes) {
 }
 
 // src/meta/core/external-metadata.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { isAbsolute as isAbsolute5, relative as relative9, resolve as resolve14, sep as sep4 } from "node:path";
 import {
   LineCounter as LineCounter3,
@@ -12047,6 +12632,7 @@ import {
 } from "yaml";
 
 // src/shared/manifest-cas.ts
+import { readFile as readFile5 } from "node:fs/promises";
 import { posix as posix3 } from "node:path";
 var COMMIT_ATTEMPTS = 5;
 function conflictRefusal(file) {
@@ -12115,10 +12701,18 @@ async function settle(held, io) {
 function isMissing(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+async function readManifestOrEmpty(absPath, perPage) {
+  try {
+    return await readFile5(absPath, "utf8");
+  } catch (e) {
+    if (perPage && isMissing(e)) return "";
+    throw e;
+  }
+}
 
 // src/shared/encryption-key.ts
 import { spawnSync } from "node:child_process";
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { basename as basename4, dirname as dirname6, join as join7, relative as relative8, resolve as resolve13 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { isMap as isMap5, parseDocument as parseDocument4, parse as parseYaml3, stringify as stringify2 } from "yaml";
@@ -12188,7 +12782,7 @@ function errorCode3(err) {
 }
 async function readIfPresent(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (err) {
     if (errorCode3(err) === "ENOENT") return null;
     throw err;
@@ -12702,7 +13296,7 @@ function outsideRefusal(manifest, collection, pageRel) {
 }
 async function readPageManifest(abs, file) {
   try {
-    return await readFile6(abs, "utf8");
+    return await readFile7(abs, "utf8");
   } catch (err) {
     if (isMissing(err)) return "";
     throw unreadable(file, err);
@@ -12710,7 +13304,7 @@ async function readPageManifest(abs, file) {
 }
 async function readManifest(abs, file) {
   try {
-    return await readFile6(abs, "utf8");
+    return await readFile7(abs, "utf8");
   } catch (err) {
     throw unreadable(file, err);
   }
@@ -14421,7 +15015,7 @@ import { dirname as dirname9, resolve as resolve16 } from "node:path";
 
 // src/meta/core/derive/codeowners.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import { dirname as dirname7, relative as relative11, resolve as resolve15, sep as sep6 } from "node:path";
 import picomatch4 from "picomatch";
 var CODEOWNERS_LOCATIONS = [
@@ -14585,7 +15179,7 @@ async function deriveFromCodeowners(inputs, opts) {
     const key = `${path}\0${label}`;
     let file = parsed2.get(key);
     if (!file) {
-      file = readFile7(path, "utf8").then(
+      file = readFile8(path, "utf8").then(
         (text2) => parseCodeowners(text2, path, label)
       );
       parsed2.set(key, file);
@@ -16473,7 +17067,7 @@ async function deriveForTable(inputs, ctx, hint, fields) {
 }
 
 // src/meta/commands/validate.ts
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 
 // src/meta/core/page-marks.ts
 function pageMarks(opts) {
@@ -16551,9 +17145,32 @@ async function configMarks(configPath, cwd) {
     trustRoot: schemaTrustRoot(cwd, loaded.dir)
   });
 }
+async function metaSection(configPath, cwd) {
+  const loaded = await loadConfig(configPath, cwd);
+  if (loaded === null) return null;
+  return rebaseConfigSchemaRefs(loaded.config, loaded.dir, cwd);
+}
+function familyMarks(opts) {
+  let built;
+  const defaults = () => pageMarks({
+    validator: marksValidator({ config: null, cwd: opts.cwd, configDir: opts.configDir }),
+    config: null,
+    cwd: opts.cwd,
+    trustRoot: schemaTrustRoot(opts.cwd, opts.configDir)
+  });
+  return () => built ??= (async () => {
+    if (opts.configPath === void 0) return defaults();
+    try {
+      return await configMarks(opts.configPath, opts.cwd) ?? defaults();
+    } catch (err) {
+      if (err instanceof DocmetaError) return defaults();
+      throw err;
+    }
+  })();
+}
 
 // src/meta/core/relocation.ts
-import { access, readFile as readFile8, stat as stat7, unlink } from "node:fs/promises";
+import { access, readFile as readFile9, stat as stat7, unlink } from "node:fs/promises";
 import { basename as basename5, extname as extname3, isAbsolute as isAbsolute8, join as join9, relative as relative13, resolve as resolve17, sep as sep8 } from "node:path";
 import picomatch6 from "picomatch";
 import {
@@ -17302,13 +17919,13 @@ async function planRelocation(ctx, request) {
     let unreadable2;
     if (beyond) {
       try {
-        content = await readFile8(absPath, "utf8");
+        content = await readFile9(absPath, "utf8");
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
         unreadable2 = (errorMessage(err).split("\n")[0] ?? "").replace(/:\s*$/, "");
       }
     } else {
-      content = await readFile8(absPath, "utf8");
+      content = await readFile9(absPath, "utf8");
       try {
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
@@ -17749,7 +18366,7 @@ function assertNoStrandedEntries(m, index, pages2, configDir, fileOf) {
 }
 async function readManifestText(path, file, perPage) {
   try {
-    return await readFile8(path, "utf8");
+    return await readFile9(path, "utf8");
   } catch (err) {
     if (perPage && isMissing(err)) return null;
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
@@ -17779,7 +18396,7 @@ function keyLines2(text2, join12) {
 async function configTarget(ctx, configDir) {
   if (ctx.configPath !== void 0) {
     try {
-      const text2 = await readFile8(ctx.configPath, "utf8");
+      const text2 = await readFile9(ctx.configPath, "utf8");
       return { path: ctx.configPath, text: text2, disk: text2 };
     } catch (err) {
       if (err.code !== "ENOENT") {
@@ -17793,7 +18410,7 @@ async function configTarget(ctx, configDir) {
   for (const name2 of FAMILY_CONFIG_NAMES) {
     const path = join9(configDir, name2);
     try {
-      const text2 = await readFile8(path, "utf8");
+      const text2 = await readFile9(path, "utf8");
       return { path, text: text2, disk: text2 };
     } catch {
     }
@@ -17979,7 +18596,7 @@ async function applyRelocation(ctx, plan, io = {}) {
   for (const w of plan.writes) {
     let now;
     try {
-      now = await readFile8(w.path, "utf8");
+      now = await readFile9(w.path, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         throw new DocmetaError(`${label(w)} could not be read: ${errorMessage(err)}`);
@@ -18812,7 +19429,7 @@ async function runValidate(opts) {
     await processOne(STDIN_LABEL, content, forcedExtractor.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile9(resolve19(base, file), "utf8");
+    const content = await readFile10(resolve19(base, file), "utf8");
     await processOne(file, content, extname4(file));
   }
   if (unverified > 0) opts.onNotice?.(unverifiedWarning(unverified));
@@ -18958,7 +19575,7 @@ async function runValidate(opts) {
 }
 
 // src/meta/commands/get.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { resolve as resolve20, extname as extname5 } from "node:path";
 async function runGet(opts) {
   const cwd = opts.cwd ?? process.cwd();
@@ -19104,7 +19721,7 @@ async function runGet(opts) {
     await readOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile10(resolve20(base, file), "utf8");
+    const content = await readFile11(resolve20(base, file), "utf8");
     await readOne(file, content, extname5(file));
   }
   if (deriving) {
@@ -19230,7 +19847,7 @@ function parseJsonPointer(pointer) {
 
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile11 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile12 } from "node:fs/promises";
 import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join10, relative as relative16, resolve as resolve21, sep as sep10 } from "node:path";
 import { parseDocument as parseDocument8, parse as parseYaml6, stringify as stringify4 } from "yaml";
 function getSchemasInfo(registered2) {
@@ -19350,7 +19967,7 @@ async function runVendorSchema(opts) {
   }
   let unchanged = false;
   if (existsSync4(absFile)) {
-    const current = await readFile11(absFile);
+    const current = await readFile12(absFile);
     unchanged = bytes.equals(current);
     if (!unchanged && !folded.replaced) {
       throw new DocmetaError(
@@ -19360,7 +19977,7 @@ async function runVendorSchema(opts) {
   }
   await mkdir3(absDir, { recursive: true });
   await writeFileAtomic(absFile, bytes);
-  const existing = loaded ? await readFile11(configPath, "utf8") : null;
+  const existing = loaded ? await readFile12(configPath, "utf8") : null;
   const section = loaded ? loaded.section : META_SECTION;
   const text2 = renderConfig(existing, folded.entries, section);
   reparseConfig(text2, posixRelative(cwd, configPath) || DEFAULT_CONFIG_NAME, section);
@@ -19612,7 +20229,7 @@ async function runInferSchema(opts) {
     await scanOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile11(resolve21(base, file), "utf8");
+    const content = await readFile12(resolve21(base, file), "utf8");
     await scanOne(file, content, extname6(file));
   }
   for (const u of unreadable2) {
@@ -19673,7 +20290,7 @@ async function runInferSchema(opts) {
 // src/meta/commands/query.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { mkdir as mkdir4, open as open2, readFile as readFile12, rename as rename3, rm as rm3 } from "node:fs/promises";
+import { mkdir as mkdir4, open as open2, readFile as readFile13, rename as rename3, rm as rm3 } from "node:fs/promises";
 import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve22, extname as extname7, sep as sep11 } from "node:path";
 
 // src/shared/prompt.ts
@@ -20031,7 +20648,7 @@ async function runQuery(opts) {
     await readOne(STDIN_LABEL, opts.stdinContent ?? "", ext);
   }
   for (const file of files) {
-    const content = await readFile12(resolve22(base, file), "utf8");
+    const content = await readFile13(resolve22(base, file), "utf8");
     await readOne(file, content, extname7(file));
   }
   const db = opts.db === void 0 ? void 0 : { resolved: resolve22(cwd, opts.db), display: opts.db };
@@ -20691,7 +21308,7 @@ async function loadSetMembers(refs, ctx) {
     seenFiles.add(canon);
     let text2;
     try {
-      text2 = await readFile12(abs, "utf8");
+      text2 = await readFile13(abs, "utf8");
     } catch {
       throw new DocmetaError(
         `Schema file not found: "${ref}" (looked at ${abs}).`
@@ -21048,7 +21665,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
   if (configPath === void 0 || configDir === void 0) {
     return { changes: [], repointed: false };
   }
-  const text2 = await readFile12(configPath, "utf8");
+  const text2 = await readFile13(configPath, "utf8");
   const doc = parseDocument10(stripBom2(text2));
   const display = displayPath(ctx, configPath);
   const rawRefOf = (item) => {
@@ -21515,7 +22132,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       let text2;
       let expected;
       try {
-        text2 = await readFile12(home.absPath, "utf8");
+        text2 = await readFile13(home.absPath, "utf8");
         expected = text2;
       } catch (err) {
         if (!home.perPage || !isMissing(err)) {
@@ -21951,7 +22568,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     }
     const entry = byLabel.get(label);
     if (!entry) throw new DocmetaError(`No loaded entry for "${label}".`);
-    const content = await readFile12(path, "utf8");
+    const content = await readFile13(path, "utf8");
     const members = ctx.memberships(label);
     const current = (await mergeWithMarks(
       label,
@@ -22023,7 +22640,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     }
     let now;
     try {
-      now = await readFile12(w.path, "utf8");
+      now = await readFile13(w.path, "utf8");
     } catch {
       now = void 0;
     }
@@ -22036,7 +22653,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   for (const m of manifestWrites) {
     let now;
     try {
-      now = await readFile12(m.path, "utf8");
+      now = await readFile13(m.path, "utf8");
     } catch {
       now = null;
     }
@@ -22169,7 +22786,7 @@ function skipExpression(sql, from) {
 }
 
 // src/meta/commands/fill.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 import { resolve as resolve24, extname as extname9, join as join11 } from "node:path";
 import {
   completeValidatedJSON,
@@ -22589,7 +23206,7 @@ function single(alternatives2) {
 }
 
 // src/meta/commands/fill-hints.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import { extname as extname8, resolve as resolve23 } from "node:path";
 
 // src/shared/reference-fields.ts
@@ -22703,7 +23320,7 @@ async function readIds(collection, opts) {
     const path = resolve23(opts.configDir, file);
     let id;
     try {
-      id = extractor.extract(await readFile13(path, "utf8"), file).data.id;
+      id = extractor.extract(await readFile14(path, "utf8"), file).data.id;
     } catch {
       continue;
     }
@@ -22722,7 +23339,7 @@ function termLabelSource() {
 }
 
 // src/meta/core/manifest-writes.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 var manifestCodec = {
   apply(text2, op) {
     const where = { entry: op.entry, key: op.key, join: op.join, file: op.file };
@@ -22738,7 +23355,7 @@ function applyManifestOp(text2, op) {
 async function holdManifestFile(path, file, perPage = false) {
   let before;
   try {
-    before = await readFile14(path, "utf8");
+    before = await readFile15(path, "utf8");
   } catch (err) {
     if (perPage && isMissing(err)) return heldManifest(path, file, "", true);
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
@@ -22755,7 +23372,7 @@ async function settleManifest(held, io = {}) {
     codec: manifestCodec,
     // A per-page manifest (proposal 0058) may be the first file in its directory.
     write: io.write ?? ((at2, text2) => writeFileAtomic(at2, text2, { createParents: true })),
-    read: io.read ?? ((at2) => readFile14(at2, "utf8")),
+    read: io.read ?? ((at2) => readFile15(at2, "utf8")),
     toError: (message) => new DocmetaError(message)
   });
   rebaseline(held);
@@ -23869,7 +24486,7 @@ async function runFill(opts) {
   const prepareAll = async () => ({
     stdin: usingStdin ? await prepareOne("<stdin>", opts.stdinContent ?? "", forcedExtractor?.extensions[0] ?? "") : void 0,
     files: await mapConcurrent(files, concurrency, async (file) => {
-      const content = await readFile15(resolve24(base, file), "utf8");
+      const content = await readFile16(resolve24(base, file), "utf8");
       return prepareOne(file, content, extname9(file));
     })
   });
@@ -24287,7 +24904,7 @@ async function mapConcurrent(items2, limit, fn) {
 }
 
 // src/meta/commands/derive.ts
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 import { extname as extname10, relative as relative17, resolve as resolve25, sep as sep12 } from "node:path";
 var GENERATED_BY_ENV = "MANNI_GENERATED_BY";
 var SOURCE_HINT = "narrow --sources or --fields";
@@ -24440,7 +25057,7 @@ async function runDerive(opts) {
         });
         continue;
       }
-      const content = await readFile16(absPath, "utf8");
+      const content = await readFile17(absPath, "utf8");
       const elements = resolveElements(label, config, membersFor(label));
       try {
         loaded2.set(label, {
@@ -25635,10 +26252,10 @@ function cellFrom(value) {
 }
 
 export {
-  __export,
   package_default,
   palette,
   shouldColor,
+  colorFor,
   matchesFileGlob,
   hasPagePlaceholder,
   pageManifestPath,
@@ -25653,8 +26270,6 @@ export {
   generateEncryptionKey,
   encryptValue,
   decryptValue,
-  ToolError,
-  errorMessage,
   assertKnownProvider,
   assertModelHasProvider,
   PROVIDERS_KEY,
@@ -25746,6 +26361,7 @@ export {
   __default31 as __default,
   __default33 as __default2,
   __default34 as __default3,
+  __default48 as __default4,
   listBuiltins,
   classifyRef,
   fetchSchemaBytes,
@@ -25775,6 +26391,7 @@ export {
   loadMetaSection,
   resolveRunConfig,
   renderSarif,
+  xmlEscape,
   renderJunit,
   REPORT_FORMATS,
   formatList,
@@ -25794,6 +26411,7 @@ export {
   rebaseable,
   settle,
   isMissing,
+  readManifestOrEmpty,
   EXTERNAL_METADATA_FETCH_TIMEOUT_MS,
   EXTERNAL_METADATA_FETCH_MAX_BYTES,
   fetchExternalMetadata,
@@ -25826,6 +26444,8 @@ export {
   pageSchemaSet,
   marksValidator,
   configMarks,
+  metaSection,
+  familyMarks,
   relocateFailed,
   relocationContext,
   keyHome,
@@ -25895,4 +26515,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-TH565O2N.js.map
+//# sourceMappingURL=chunk-ZQBTK3DO.js.map