@hawkeyexl/manni 4.11.0 → 4.12.0

package/dist/{term-CQAGNG3Q.js → term-D2N7UN4P.js}

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
+import {
+  renderFindingsGithub
+} from "./chunk-QNDDPXFR.js";
 import {
   renderFindingsJson,
   renderFormatsJson,
   renderGetJson,
   renderListJson
-} from "./chunk-MSRU4D4P.js";
+} from "./chunk-UXMCHBOJ.js";
 import {
   renderFindingsPretty,
   renderFormatsPretty,
@@ -12,7 +15,7 @@ import {
   renderListPretty,
   renderValeWiring,
   renderWritePretty
-} from "./chunk-JPQDNYXH.js";
+} from "./chunk-STPGIKPY.js";
 import {
   FINDING_FORMATS,
   JUNIT_CLASSNAME,
@@ -24,22 +27,25 @@ import {
   runCheck,
   summarize,
   toResults
-} from "./chunk-4VBSTXN6.js";
+} from "./chunk-QDC7JPFG.js";
 import {
   LIST_FORMATS,
   runList
-} from "./chunk-B7XYNRJQ.js";
-import {
-  renderFindingsGithub
-} from "./chunk-LPIF5LIE.js";
+} from "./chunk-VFAKGIDG.js";
 import {
+  DEFAULT_CRAWL_MIN_PAGES,
+  DEFAULT_FILL_CACHE_DIR,
+  DEFAULT_FILL_CONFIDENCE,
   DEFAULT_LANGUAGE,
   DITA_HOLDS,
   DOCBOOK_HOLDS,
   LIST_HOLDS,
   MANIFEST_FORMAT,
+  SKOS,
+  SKOS_PROPERTIES,
   TBX_V3_NAMESPACE,
   TERM_FIELDS,
+  TERM_MATCH_FIELDS,
   TERM_READERS,
   TERM_RULES,
   TERM_WRITE_FORMATS,
@@ -70,52 +76,70 @@ import {
   resolveTermRun,
   rstEntry,
   sharedLanguage,
+  slugOf,
   tbxEntryLines,
   tbxInput,
   tbxSourceOf,
   valeConfigFor,
   xmlAttribute,
   xmlText
-} from "./chunk-J6IDQGJL.js";
-import "./chunk-77AINBYM.js";
+} from "./chunk-FKAZUZQU.js";
 import "./chunk-IKEWBMCN.js";
-import "./chunk-TU2WUBVZ.js";
-import "./chunk-LKP7QDFN.js";
+import "./chunk-YUTVAMWW.js";
+import "./chunk-JSSM7VVV.js";
 import {
-  registerTermLabelSource
-} from "./chunk-6HWBRZIN.js";
-import "./chunk-M42DZCOU.js";
-import "./chunk-PCQ7ELJH.js";
+  DEFAULT_CHUNK_CHARS,
+  splitBody
+} from "./chunk-PS257NIU.js";
 import {
-  collect,
-  readStdin,
-  splitList
-} from "./chunk-GV56WGL2.js";
+  mergeMetaProvenance
+} from "./chunk-2OZF2VUB.js";
 import {
   OMITTED_WHEN_CLEAN,
   renderJunit,
   renderSarif
-} from "./chunk-D4N2V43Z.js";
+} from "./chunk-SGR7ZAVE.js";
+import "./chunk-QEAGL4V5.js";
+import {
+  collect,
+  readStdin,
+  splitList
+} from "./chunk-SMHAYK6I.js";
+import "./chunk-DSWKBZWW.js";
 import {
   STDIN_TOKEN,
   extractorByName,
   extractorForExtension
-} from "./chunk-VSEBFHAY.js";
-import {
-  fail
-} from "./chunk-YEUYKR62.js";
+} from "./chunk-RGLFV4KO.js";
+import "./chunk-77AINBYM.js";
+import "./chunk-MNH7QO4Z.js";
 import {
   shouldColor
 } from "./chunk-RNVYGWIC.js";
-import "./chunk-MNH7QO4Z.js";
-import "./chunk-QLWC7MKD.js";
 import {
-  notice
+  fail
+} from "./chunk-YEUYKR62.js";
+import "./chunk-OTJOBZJ5.js";
+import {
+  notice,
+  warn
 } from "./chunk-HX44GB4Z.js";
-import "./chunk-QCHVR4ZM.js";
+import {
+  DEFAULT_PROVIDER,
+  LOCAL_FLAG_HELP,
+  assertKnownProvider,
+  assertLocalFlag,
+  assertModelHasProvider,
+  localNotice,
+  noOfflineModel,
+  offlineIdentity,
+  providerSpecFor,
+  resolveIdentity,
+  selectProvider
+} from "./chunk-VM7VAFJW.js";
 import {
   package_default
-} from "./chunk-2MJ62AYQ.js";
+} from "./chunk-DHGB4JBG.js";
 import "./chunk-OWBRDNRZ.js";
 import {
   errorMessage
@@ -125,6 +149,143 @@ import "./chunk-2H7UOFLK.js";
 // src/term/cli.ts
 import { Command } from "commander";
 
+// src/term/commands/fill.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname as dirname2, extname as extname2, join as join3, resolve as resolve2 } from "node:path";
+import {
+  JsonCache,
+  buildCacheKey,
+  completeValidatedJSON,
+  makeProvider as makeInferenceProvider,
+  sha256,
+  validatorFor
+} from "@hawkeyexl/inference";
+
+// src/term/core/fill-plan.ts
+import { dirname, extname } from "node:path";
+function fold(value) {
+  return value.trim().toLowerCase();
+}
+function termIndex(terms) {
+  const index = /* @__PURE__ */ new Map();
+  const claim = (key, term) => {
+    if (!index.has(fold(key))) index.set(fold(key), term);
+  };
+  for (const term of terms) {
+    claim(term.record.label, term);
+    claim(term.id, term);
+    for (const alt of term.record["alt-labels"] ?? []) claim(alt, term);
+  }
+  return index;
+}
+function addUnique(list, value) {
+  if (!list.some((v) => fold(v) === fold(value))) list.push(value);
+}
+var EDGE_LISTS = { broader: "broader", narrower: "narrower", "related-concepts": "related" };
+function namedConcepts(set) {
+  const alias = /* @__PURE__ */ new Map();
+  for (const block of set.blocks) {
+    for (const alt of block.altLabels ?? []) if (!alias.has(fold(alt))) alias.set(fold(alt), block.label);
+  }
+  const concepts = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const named = (value, at2, language) => {
+    const label = alias.get(fold(value)) ?? value;
+    let concept = byKey.get(fold(label));
+    if (concept === void 0) {
+      concept = { label: label.trim(), from: [], altLabels: [], broader: [], narrower: [], related: [] };
+      concepts.push(concept);
+      byKey.set(fold(label), concept);
+    }
+    if (concept.language === void 0 && language !== void 0) concept.language = language;
+    if (!concept.from.some((f) => f.file === at2.file && f.line === at2.line)) concept.from.push(at2);
+  };
+  const at = (file, line) => line === void 0 ? { file } : { file, line };
+  for (const reference of set.references) {
+    named(reference.label, at(reference.file, reference.line), reference.language);
+  }
+  for (const block of set.blocks) {
+    for (const edge of block.edges) named(edge.value, at(block.file, edge.line ?? block.line), block.language);
+  }
+  for (const block of set.blocks) {
+    const concept = byKey.get(fold(block.label));
+    if (concept !== void 0) enrich(concept, block);
+  }
+  return concepts;
+}
+function enrich(concept, block) {
+  for (const alt of block.altLabels ?? []) if (fold(alt) !== fold(concept.label)) addUnique(concept.altLabels, alt);
+  for (const edge of block.edges) addUnique(concept[EDGE_LISTS[edge.field]], edge.value);
+  if (concept.definition === void 0 && block.definition !== void 0) concept.definition = block.definition;
+}
+function planFromMetadata(set) {
+  const index = termIndex(set.terms);
+  const create = namedConcepts(set).filter((concept) => !index.has(fold(concept.label)));
+  const carried2 = /* @__PURE__ */ new Map();
+  for (const block of set.blocks) {
+    const term = index.get(fold(block.label));
+    if (term !== void 0 && block.definition !== void 0 && !carried2.has(term)) carried2.set(term, block.definition);
+  }
+  const missing = set.terms.filter((t) => t.record.definition === void 0 && t.record.see === void 0).map((term) => {
+    const definition = carried2.get(term);
+    return definition === void 0 ? { term } : { term, carried: definition };
+  });
+  return { create, missing };
+}
+function sharedTermDirectory(terms) {
+  const dirs = new Set(
+    terms.filter((t) => t.location.construct === "page" && t.location.path !== void 0).map((t) => dirname(t.location.path ?? ""))
+  );
+  return dirs.size === 1 ? [...dirs][0] : void 0;
+}
+var FILL_PAGE_FORMATS = {
+  ".md": "markdown",
+  ".mdx": "mdx",
+  ".adoc": "asciidoc",
+  ".rst": "rst",
+  ".html": "html",
+  ".dita": "dita"
+};
+function mostCommon(extensions) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const ext of extensions) if (ext in FILL_PAGE_FORMATS) counts.set(ext, (counts.get(ext) ?? 0) + 1);
+  let best;
+  for (const [ext, n] of counts) if (best === void 0 || n > (counts.get(best) ?? 0)) best = ext;
+  return best;
+}
+function pageExtension(terms, dir, pages) {
+  const inDir = terms.filter((t) => t.location.construct === "page" && t.location.path !== void 0).filter((t) => dirname(t.location.path ?? "") === dir).map((t) => extname(t.location.path ?? "").toLowerCase());
+  return mostCommon(inDir) ?? mostCommon(pages.map((p) => extname(p).toLowerCase())) ?? ".md";
+}
+function mergeFound(found) {
+  const out = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const f of found) {
+    let c = byKey.get(fold(f.label));
+    if (c === void 0) {
+      c = { label: f.label.trim(), altLabels: [], from: [] };
+      out.push(c);
+      byKey.set(fold(f.label), c);
+    }
+    for (const alt of f.altLabels ?? []) if (fold(alt) !== fold(c.label)) addUnique(c.altLabels, alt);
+    if (c.language === void 0 && f.language !== void 0) c.language = f.language;
+    if (!c.from.some((at) => at.file === f.file)) c.from.push(f.line === void 0 ? { file: f.file } : { file: f.file, line: f.line });
+    if (f.confidence !== void 0 && (c.confidence === void 0 || f.confidence > c.confidence)) {
+      c.confidence = f.confidence;
+      if (f.definition !== void 0) c.definition = f.definition;
+    } else if (c.definition === void 0 && f.definition !== void 0) {
+      c.definition = f.definition;
+    }
+  }
+  return out;
+}
+function newCandidates(candidates, known, minPages) {
+  return candidates.filter(
+    (c) => c.from.length >= minPages && !known.has(fold(c.label)) && !c.altLabels.some((a) => known.has(fold(a)))
+  );
+}
+
 // src/term/core/writers/documents.ts
 import { join } from "node:path";
 
@@ -515,92 +676,179 @@ var jsonWriter = {
 };
 
 // src/term/core/writers/skos.ts
-var HOLDS2 = [
-  "label",
-  "definition",
-  "alt-labels",
-  "hidden-labels",
-  "broader",
-  "narrower",
-  "related-terms",
-  "scope-note"
-];
-var CONTEXT = {
-  skos: "http://www.w3.org/2004/02/skos/core#",
+import { DataFactory, Writer } from "n3";
+var HOLDS2 = SKOS_PROPERTIES.map((p) => p.field);
+var REDIRECT_HOLDS = ["label", "see"];
+var RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+var PREFIXES = {
+  skos: SKOS,
   dcterms: "http://purl.org/dc/terms/"
 };
 var SCHEME_ID = "";
-function literal(term, value) {
-  return term.language === void 0 ? value : { "@value": value, "@language": term.language };
+var DESCRIPTION = "Generated by manni term write.";
+var SINGLE = /* @__PURE__ */ new Set([
+  "skos:inScheme",
+  "skos:topConceptOf",
+  "skos:prefLabel",
+  "skos:definition",
+  "skos:scopeNote",
+  "skos:notation",
+  "dcterms:description"
+]);
+function literal(term, text) {
+  return term.language === void 0 ? { text } : { text, language: term.language };
 }
 function resolve(terms, self, value) {
   const wanted = value.toLowerCase();
-  const others = terms.filter((t) => t !== self);
+  const others = terms.filter((t) => t.id !== self);
   return others.find((t) => t.record.label.toLowerCase() === wanted) ?? others.find((t) => t.id.toLowerCase() === wanted);
 }
-function references(terms, self, values) {
-  const ids = [];
-  for (const value of values ?? []) {
-    const target = resolve(terms, self, value);
-    if (target !== void 0 && !ids.includes(target.id)) ids.push(target.id);
-  }
-  return ids.map((id) => ({ "@id": `#${id}` }));
+function sameValue(a, b) {
+  if ("iri" in a) return "iri" in b && a.iri === b.iri;
+  return !("iri" in b) && a.text === b.text && a.language === b.language;
 }
-function concept(terms, term) {
-  const { record } = term;
-  const node = {
-    "@id": `#${term.id}`,
-    "@type": "skos:Concept",
-    "skos:inScheme": { "@id": SCHEME_ID },
-    "skos:prefLabel": literal(term, record.label)
-  };
-  if (record["alt-labels"] !== void 0) node["skos:altLabel"] = record["alt-labels"].map((v) => literal(term, v));
-  if (record["hidden-labels"] !== void 0) {
-    node["skos:hiddenLabel"] = record["hidden-labels"].map((v) => literal(term, v));
-  }
-  if (record.definition !== void 0) node["skos:definition"] = literal(term, record.definition);
-  if (record["scope-note"] !== void 0) node["skos:scopeNote"] = literal(term, record["scope-note"]);
-  const relations = [
-    ["skos:broader", record.broader],
-    ["skos:narrower", record.narrower],
-    ["skos:related", record["related-terms"]]
-  ];
-  for (const [key, values] of relations) {
-    const refs = references(terms, term, values);
-    if (refs.length > 0) node[key] = refs;
-  }
-  return node;
+function pushUnique(values, value) {
+  if (!values.some((v) => sameValue(v, value))) values.push(value);
 }
-var skosWriter = {
-  format: "skos",
-  shapes: ["file"],
-  holds: (_shape) => HOLDS2,
-  render(terms, target) {
-    requireShape("skos", target, "file");
-    const document = {
-      "@context": CONTEXT,
-      "@graph": [
-        {
-          "@id": SCHEME_ID,
-          "@type": "skos:ConceptScheme",
-          "dcterms:description": "Generated by manni term write."
-        },
-        ...terms.map((term) => concept(terms, term))
-      ]
+function graphOf(terms) {
+  const redirects = /* @__PURE__ */ new Map();
+  for (const term of terms) {
+    const target = term.record.see === void 0 ? void 0 : resolve(terms, term.id, term.record.see);
+    if (target !== void 0) redirects.set(term, target.id);
+  }
+  const concepts = terms.filter((t) => !redirects.has(t));
+  const conflicts = [];
+  const nodes = [];
+  const tops = [];
+  for (const group of conceptGroups(concepts)) {
+    const [first] = group;
+    if (first === void 0) continue;
+    const { id } = first;
+    const values = /* @__PURE__ */ new Map();
+    const add = (property, value) => {
+      const list = values.get(property) ?? [];
+      pushUnique(list, value);
+      values.set(property, list);
     };
-    const content = `${JSON.stringify(document, null, 2)}
+    for (const { property, field, kind } of SKOS_PROPERTIES) {
+      const name = `skos:${property}`;
+      if (kind === "code") {
+        const merged = mergeFirst(id, group.map((t) => ({ [field]: t.record[field] })));
+        conflicts.push(...merged.conflicts);
+        const text = merged.merged[field];
+        if (typeof text === "string") add(name, { text });
+        continue;
+      }
+      for (const term of group) {
+        const raw = term.record[field];
+        const list = raw === void 0 ? [] : typeof raw === "string" ? [raw] : raw;
+        for (const value of list) {
+          if (kind === "iris") add(name, { iri: value });
+          else if (kind === "concepts") {
+            const target = resolve(terms, id, value);
+            if (target !== void 0) add(name, { iri: `#${target.id}` });
+          } else add(name, literal(term, value));
+        }
+      }
+      if (property === "altLabel") {
+        for (const [redirect, target] of redirects) if (target === id) add(name, literal(redirect, redirect.record.label));
+      }
+    }
+    const top = !values.has("skos:broader");
+    if (top) tops.push({ iri: `#${id}` });
+    nodes.push({
+      id: `#${id}`,
+      type: "skos:Concept",
+      properties: [
+        ["skos:inScheme", [{ iri: SCHEME_ID }]],
+        ...top ? [["skos:topConceptOf", [{ iri: SCHEME_ID }]]] : [],
+        ...SKOS_PROPERTIES.flatMap(({ property }) => {
+          const list = values.get(`skos:${property}`);
+          return list === void 0 ? [] : [[`skos:${property}`, list]];
+        })
+      ]
+    });
+  }
+  const scheme = {
+    id: SCHEME_ID,
+    type: "skos:ConceptScheme",
+    properties: [["dcterms:description", [{ text: DESCRIPTION }]], ...tops.length === 0 ? [] : [["skos:hasTopConcept", tops]]]
+  };
+  const dropped = terms.flatMap((t) => droppedFields([t], redirects.has(t) ? REDIRECT_HOLDS : HOLDS2));
+  return { nodes: [scheme, ...nodes], dropped, conflicts };
+}
+function jsonValue(value) {
+  if ("iri" in value) return { "@id": value.iri };
+  return value.language === void 0 ? value.text : { "@value": value.text, "@language": value.language };
+}
+function jsonLd(nodes) {
+  const graph = nodes.map((node) => {
+    const out = { "@id": node.id, "@type": node.type };
+    for (const [property, values] of node.properties) {
+      const [only] = values;
+      out[property] = SINGLE.has(property) && values.length === 1 && only !== void 0 ? jsonValue(only) : values.map(jsonValue);
+    }
+    return out;
+  });
+  return `${JSON.stringify({ "@context": PREFIXES, "@graph": graph }, null, 2)}
 `;
-    return {
-      files: [{ path: target.path, content }],
-      removals: [],
-      dropped: droppedFields(terms, HOLDS2),
-      skipped: []
-    };
+}
+function expand(name) {
+  const [prefix = "", local = ""] = name.split(":");
+  if (!Object.hasOwn(PREFIXES, prefix)) throw new Error(`skos writer: unknown prefix "${prefix}" in ${name}`);
+  return `${PREFIXES[prefix]}${local}`;
+}
+function turtle(nodes) {
+  const iri = (value) => DataFactory.namedNode(value);
+  const writer = new Writer({ prefixes: PREFIXES });
+  for (const node of nodes) {
+    const subject = iri(node.id);
+    writer.addQuad(DataFactory.quad(subject, iri(RDF_TYPE), iri(expand(node.type))));
+    for (const [property, values] of node.properties) {
+      for (const value of values) {
+        const object = "iri" in value ? iri(value.iri) : DataFactory.literal(value.text, value.language);
+        writer.addQuad(DataFactory.quad(subject, iri(expand(property)), object));
+      }
+    }
   }
-};
+  let content = "";
+  writer.end((_error, result) => {
+    content = result;
+  });
+  return content;
+}
+function skosWriterFor(format, serialize) {
+  return {
+    format,
+    shapes: ["file"],
+    holds: (_shape) => HOLDS2,
+    render(terms, target) {
+      requireShape(format, target, "file");
+      const { nodes, dropped, conflicts } = graphOf(terms);
+      return {
+        files: [{ path: target.path, content: serialize(nodes) }],
+        removals: [],
+        dropped,
+        skipped: [],
+        ...conflicts.length === 0 ? {} : { conflicts }
+      };
+    }
+  };
+}
+var skosWriter = skosWriterFor("skos", jsonLd);
+var skosTtlWriter = skosWriterFor("skos-ttl", turtle);
 
 // src/term/core/writers/tbx.ts
-var NOT_HELD = ["abstract", "broader", "narrower", "related-terms", "see", "scope-note"];
+var NOT_HELD = [
+  "abstract",
+  "broader",
+  "narrower",
+  "related-terms",
+  "see",
+  "scope-note",
+  "notation",
+  ...TERM_MATCH_FIELDS
+];
 var HOLDS3 = TERM_FIELDS.filter((field) => !NOT_HELD.includes(field));
 var LINGUIST_FIELDS = ["register", "reading", "reading-note", "grammatical-number", "transfer-comments"];
 var ENTRY_INDENT = "      ";
@@ -902,11 +1150,514 @@ var valeWriter = {
 };
 
 // src/term/core/writers/interchange.ts
-var INTERCHANGE_WRITERS = [tbxWriter, tbx3Writer, skosWriter, csvWriter, jsonWriter, valeWriter];
+var INTERCHANGE_WRITERS = [tbxWriter, tbx3Writer, skosWriter, skosTtlWriter, csvWriter, jsonWriter, valeWriter];
 
 // src/term/core/writers/index.ts
 var TERM_WRITERS = [...DOCUMENT_WRITERS, ...INTERCHANGE_WRITERS];
 
+// src/term/commands/fill.ts
+var FILL_FORMATS = ["pretty", "json"];
+var TURN_BUDGET_REASON = "turn budget";
+var PROMPT_VERSION = 1;
+var META_PROVENANCE_KEY = "meta-provenance";
+var DEFINITION_SYSTEM = [
+  "You write glossary definitions for a documentation set's termbase.",
+  "Define the term in one sentence, as the pages quoted use it.",
+  "Give your confidence, from 0 to 1, that the definition is right for these pages.",
+  "When the context is too thin to be sure, say so with a low confidence rather than guessing."
+].join(" ");
+var DEFINITION_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["definition", "confidence"],
+  properties: { definition: { type: "string" }, confidence: { type: "number" } }
+};
+var CRAWL_SYSTEM = [
+  "You find the domain terms a documentation page uses: product concepts, technical terms and jargon a glossary should define.",
+  "Leave out everyday words, people, and code identifiers.",
+  "For each term give its label in singular form, any synonyms the page uses, a one-sentence definition from the page's context,",
+  "and your confidence, from 0 to 1, that it belongs in a glossary and that the definition is right."
+].join(" ");
+var CRAWL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["terms"],
+  properties: {
+    terms: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["label", "alt-labels", "definition", "confidence"],
+        properties: {
+          label: { type: "string" },
+          "alt-labels": { type: "array", items: { type: "string" } },
+          definition: { type: "string" },
+          confidence: { type: "number" }
+        }
+      }
+    }
+  }
+};
+var validateDefinition = validatorFor(DEFINITION_SCHEMA);
+var validateCrawl = validatorFor(CRAWL_SCHEMA);
+function score(value) {
+  return typeof value === "number" && value >= 0 && value <= 1 ? Math.round(value * 100) / 100 : 0;
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function strings(value) {
+  return Array.isArray(value) ? value.map(nonEmpty).filter((v) => v !== void 0) : [];
+}
+function keywordsOf(value) {
+  return typeof value === "string" ? strings([value]) : strings(value);
+}
+function wholeWord(label) {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])`, "iu");
+}
+function lineOf(content, label) {
+  const match = wholeWord(label).exec(content);
+  return match === null ? void 0 : content.slice(0, match.index).split("\n").length;
+}
+function fromList(from, cwd) {
+  return from.map((at) => {
+    const file = displayPath(at.file, cwd);
+    return at.line === void 0 ? file : `${file}:${String(at.line)}`;
+  });
+}
+var toTermError = (message) => new TermError(message);
+async function resolveModel(opts, run) {
+  const injected = (provider) => ({
+    provider,
+    identity: { provider: provider.provider(), model: provider.modelName() }
+  });
+  const offline = opts.offline === true;
+  if (opts.providerInstance !== void 0 && !offline) return injected(opts.providerInstance);
+  const flags = {
+    ...opts.provider === void 0 ? {} : { provider: opts.provider },
+    ...opts.model === void 0 ? {} : { model: opts.model },
+    ...opts.local === true ? { local: true } : {},
+    ...offline ? { offline: true } : {}
+  };
+  assertLocalFlag(flags, toTermError);
+  const family = run.configFile?.providers ?? {};
+  const selection = selectProvider(flags, [
+    {
+      ...run.config?.provider === void 0 ? {} : { provider: run.config.provider },
+      ...run.config?.model === void 0 ? {} : { model: run.config.model },
+      origin: "term.provider"
+    },
+    {
+      ...family.provider === void 0 ? {} : { provider: family.provider },
+      ...family.model === void 0 ? {} : { model: family.model },
+      origin: "providers.provider"
+    }
+  ]);
+  const { provider: name, model: chosen } = selection;
+  assertKnownProvider(name, toTermError);
+  assertModelHasProvider(name, chosen, "term.provider", toTermError);
+  const named = [flags.provider, flags.model, run.config?.provider, run.config?.model, family.provider, family.model].some(
+    (value) => value !== void 0 && value !== DEFAULT_PROVIDER
+  );
+  const notice2 = localNotice(selection, flags);
+  if (notice2 !== void 0) opts.onNotice?.(notice2);
+  try {
+    const spec = providerSpecFor(family, { provider: name, model: chosen ?? null });
+    const identity = offline ? await offlineIdentity(spec, toTermError) : await resolveIdentity(spec, toTermError);
+    if (identity === void 0) return void 0;
+    if (opts.providerInstance !== void 0) return injected(opts.providerInstance);
+    return { provider: makeInferenceProvider(providerSpecFor(family, identity)), identity };
+  } catch (error) {
+    if (named) opts.onNotice?.(`the configured provider "${name}" could not run: ${errorMessage(error)}`);
+    return void 0;
+  }
+}
+async function runFill(opts) {
+  const cwd = resolve2(opts.cwd ?? process.cwd());
+  const run = await resolveTermRun({
+    cwd,
+    inputs: opts.inputs,
+    ...opts.configPath === void 0 ? {} : { configPath: opts.configPath },
+    ...opts.collection === void 0 ? {} : { collection: opts.collection }
+  });
+  const pages = [];
+  const onPage = (input) => {
+    const language = input.metadata["language"];
+    const keywordsLine = input.lineFor("/keywords");
+    pages.push({
+      file: input.file,
+      ...input.path === void 0 ? {} : { path: input.path },
+      content: input.content,
+      metadata: input.metadata,
+      ...typeof language === "string" && language !== "" ? { language } : {},
+      ...keywordsLine === void 0 ? {} : { keywordsLine }
+    });
+  };
+  const set = await loadSet(run, { ...opts, cwd, allowEmpty: true, onPage });
+  const fillConfig = run.config?.fill ?? {};
+  const configDir = run.configDir ?? cwd;
+  const threshold = opts.confidence ?? fillConfig.confidenceThreshold ?? DEFAULT_FILL_CONFIDENCE;
+  const maxTurns = opts.maxTurns ?? fillConfig.maxTurns ?? null;
+  const minPages = fillConfig.crawl?.minPages ?? DEFAULT_CRAWL_MIN_PAGES;
+  const chunkChars = opts.chunkChars ?? DEFAULT_CHUNK_CHARS;
+  const crawl = opts.crawl === true;
+  const dryRun = opts.dryRun === true;
+  const plan = planFromMetadata(set);
+  const needsDir = crawl || plan.create.length > 0;
+  const outDir = !needsDir ? void 0 : opts.out !== void 0 ? resolve2(cwd, opts.out) : fillConfig.out !== void 0 ? resolve2(configDir, fillConfig.out) : sharedTermDirectory(set.terms);
+  if (needsDir && outDir === void 0) {
+    throw new TermError("new term pages need a directory; pass -o or set term.fill.out.");
+  }
+  const ext = outDir === void 0 ? ".md" : pageExtension(set.terms, outDir, pages.map((p) => p.file));
+  const format = FILL_PAGE_FORMATS[ext] ?? "markdown";
+  const wantsModel = crawl || plan.create.some((c) => c.definition === void 0) || plan.missing.some((m) => m.carried === void 0);
+  let model;
+  if (wantsModel) {
+    model = await resolveModel(opts, run);
+    if (model === void 0) {
+      if (crawl) {
+        throw new TermError(
+          opts.offline === true ? "--crawl needs a model, and none is available offline; drop --offline, or download a local model first." : "--crawl needs a model, and no provider is configured; pass --provider or set providers:."
+        );
+      }
+      warn(
+        opts.offline === true ? noOfflineModel("new terms have no definition") : "no model provider is configured, so new terms have no definition; pass --provider or --local."
+      );
+    }
+  }
+  const modelName = model === void 0 ? void 0 : `${model.identity.provider}/${model.identity.model}`;
+  const cache = new JsonCache(
+    resolve2(configDir, fillConfig.cacheDir ?? DEFAULT_FILL_CACHE_DIR),
+    opts.noCache !== true,
+    "manni"
+  );
+  let turns = 0;
+  const ask = async (m, kind, system, user, schema, validate) => {
+    const key = buildCacheKey([m.identity.provider, m.identity.model, `v${String(PROMPT_VERSION)}`, kind, sha256(user)]);
+    const cached = cache.get(key);
+    if (cached !== void 0 && validate(cached)) return cached;
+    if (maxTurns !== null && turns >= maxTurns) return void 0;
+    turns++;
+    const answer = await completeValidatedJSON({ provider: m.provider, system, user, schema, validate });
+    if (answer.result === void 0) throw new TermError(answer.error ?? "the model returned no answer.");
+    cache.set(key, answer.result);
+    return answer.result;
+  };
+  const pageByFile = new Map(pages.map((p) => [p.file, p]));
+  const definitionPrompt = (label, language, record, from) => {
+    const lines = [`Term: ${label}`];
+    if (language !== void 0) lines.push(`Language: ${language}`);
+    const lists = [
+      ["Also called", record["alt-labels"]],
+      ["Broader", record.broader],
+      ["Narrower", record.narrower],
+      ["Related", record["related-terms"]]
+    ];
+    for (const [name, values] of lists) if (values !== void 0 && values.length > 0) lines.push(`${name}: ${values.join(", ")}`);
+    const files = [...new Set(from.map((f) => f.file))].slice(0, 3);
+    for (const file of files) {
+      const page = pageByFile.get(file);
+      if (page === void 0) continue;
+      lines.push("", `Page ${file}`);
+      for (const key of ["title", "description"]) {
+        const value = nonEmpty(page.metadata[key]);
+        if (value !== void 0) lines.push(`${key}: ${value}`);
+      }
+      const word = wholeWord(label);
+      const uses = page.content.split("\n").filter((line) => word.test(line)).slice(0, 3);
+      for (const use of uses) lines.push(`> ${use.trim()}`);
+    }
+    return lines.join("\n");
+  };
+  const draft = async (label, language, record, from) => {
+    if (model === void 0) return void 0;
+    let answer;
+    try {
+      answer = await ask(model, "definition", DEFINITION_SYSTEM, definitionPrompt(label, language, record, from), DEFINITION_SCHEMA, validateDefinition);
+    } catch (error) {
+      return { skip: `model error: ${errorMessage(error)}` };
+    }
+    if (answer === void 0) return { skip: TURN_BUDGET_REASON };
+    const definition = nonEmpty(answer["definition"]);
+    const confidence = score(answer["confidence"]);
+    if (definition === void 0) return { skip: "the model gave no definition" };
+    return { status: confidence >= threshold ? "drafted" : "below-threshold", definition, confidence };
+  };
+  const entries2 = [];
+  const writes = [];
+  const planned = /* @__PURE__ */ new Set();
+  const known = new Set(termIndex(set.terms).keys());
+  const render = (term, provenance) => {
+    const writer = TERM_WRITERS.find((w) => w.format === format);
+    const target = { path: outDir ?? cwd, shape: "directory" };
+    const content = writer?.render([term], target, { existing: /* @__PURE__ */ new Map() }).files[0]?.content;
+    if (content === void 0) throw new TermError(`manni cannot write a ${format} term page.`);
+    if (provenance === void 0 || model === void 0) return content;
+    const merged = mergeMetaProvenance(
+      void 0,
+      model.identity.model,
+      "fields",
+      provenance.fields.map((name) => ({ name, confidence: provenance.confidence }))
+    );
+    const extractor = extractorForExtension(ext);
+    if (merged === void 0 || extractor?.apply === void 0) return content;
+    return extractor.apply(content, { [META_PROVENANCE_KEY]: merged.list }, { filePath: join3(target.path, `x${ext}`) });
+  };
+  const create = async (concept, source, definition) => {
+    const id = slugOf(concept.label);
+    const path = join3(outDir ?? cwd, `${id}${ext}`);
+    const base = {
+      file: displayPath(path, cwd),
+      id,
+      label: concept.label,
+      ...concept.language === void 0 ? {} : { language: concept.language },
+      source,
+      from: fromList(concept.from, cwd)
+    };
+    if (planned.has(path) || existsSync(path)) {
+      entries2.push({ action: "exists", ...base, definition: { status: "missing" } });
+      return;
+    }
+    const record = { label: concept.label };
+    const lists = [
+      ["alt-labels", concept.altLabels],
+      ["broader", concept.broader],
+      ["narrower", concept.narrower],
+      ["related-terms", concept.related]
+    ];
+    for (const [field, values] of lists) if (values !== void 0 && values.length > 0) record[field] = values;
+    let status = "missing";
+    let confidence;
+    let fields;
+    if (definition.carried !== void 0) {
+      record.definition = definition.carried;
+      status = "carried";
+    } else {
+      const got = definition.drafted ?? await draft(concept.label, concept.language, record, concept.from);
+      if (got !== void 0 && "skip" in got) {
+        entries2.push({ action: "skip", ...base, definition: { status: "missing" }, reason: got.skip });
+        return;
+      }
+      if (got !== void 0) {
+        confidence = got.confidence;
+        const below = "status" in got ? got.status === "below-threshold" : got.confidence < threshold;
+        if (below) {
+          status = "below-threshold";
+        } else {
+          record.definition = got.definition;
+          status = "drafted";
+          fields = definition.fields ?? ["/definition"];
+        }
+      }
+    }
+    const term = {
+      id,
+      record,
+      ...concept.language === void 0 ? {} : { language: concept.language },
+      location: { file: base.file, path, construct: "page", line: 1, fieldLines: {} }
+    };
+    planned.add(path);
+    known.add(fold(concept.label));
+    for (const alt of concept.altLabels) known.add(fold(alt));
+    writes.push({ path, content: render(term, fields === void 0 || confidence === void 0 ? void 0 : { fields, confidence }) });
+    entries2.push({
+      action: "create",
+      ...base,
+      definition: {
+        status,
+        ...confidence === void 0 ? {} : { confidence },
+        ...modelName === void 0 || confidence === void 0 ? {} : { model: modelName }
+      }
+    });
+  };
+  for (const concept of plan.create) {
+    await create(concept, "metadata", concept.definition === void 0 ? {} : { carried: concept.definition });
+  }
+  for (const { term, carried: carried2 } of plan.missing) {
+    if (carried2 === void 0 && model === void 0) continue;
+    const path = term.location.path;
+    const base = {
+      file: displayPath(term.location.file, cwd),
+      id: term.id,
+      label: term.record.label,
+      ...term.language === void 0 ? {} : { language: term.language },
+      source: "metadata",
+      from: [`${displayPath(term.location.file, cwd)}:${String(term.location.line)}`]
+    };
+    if (term.location.construct !== "page" || path === void 0) {
+      entries2.push({ action: "skip", ...base, definition: { status: "missing" }, reason: "not a term page" });
+      continue;
+    }
+    let definition;
+    let provenance;
+    if (carried2 !== void 0) {
+      definition = carried2;
+    } else {
+      const got = await draft(term.record.label, term.language, term.record, [{ file: term.location.file }]);
+      if (got === void 0) continue;
+      if ("skip" in got) {
+        entries2.push({ action: "skip", ...base, definition: { status: "missing" }, reason: got.skip });
+        continue;
+      }
+      if (got.status === "below-threshold") {
+        entries2.push({
+          action: "skip",
+          ...base,
+          definition: { status: "below-threshold", confidence: got.confidence, ...modelName === void 0 ? {} : { model: modelName } }
+        });
+        continue;
+      }
+      definition = got.definition;
+      provenance = { confidence: got.confidence };
+    }
+    writes.push({ path, content: await fillInPlace(path, term.location.file, definition, provenance, model) });
+    entries2.push({
+      action: "fill",
+      ...base,
+      definition: provenance === void 0 ? { status: "carried" } : { status: "drafted", confidence: provenance.confidence, ...modelName === void 0 ? {} : { model: modelName } }
+    });
+  }
+  if (crawl && model !== void 0) {
+    const found = [];
+    let spent = false;
+    for (const page of pages) {
+      const type = page.metadata["type"];
+      if (type === "term" || type === "term-set") continue;
+      for (const keyword of keywordsOf(page.metadata["keywords"])) {
+        found.push({
+          file: page.file,
+          label: keyword,
+          ...page.keywordsLine === void 0 ? {} : { line: page.keywordsLine },
+          ...page.language === void 0 ? {} : { language: page.language }
+        });
+      }
+      if (spent) continue;
+      const chunks = splitBody(page.content, chunkChars);
+      for (const [i, chunk] of chunks.entries()) {
+        const user = `Page ${page.file}${chunks.length > 1 ? ` (part ${String(i + 1)} of ${String(chunks.length)})` : ""}
+
+${chunk}`;
+        let answer;
+        try {
+          answer = await ask(model, "crawl", CRAWL_SYSTEM, user, CRAWL_SCHEMA, validateCrawl);
+        } catch (error) {
+          opts.onNotice?.(`${page.file}: the model could not read it: ${errorMessage(error)}`);
+          continue;
+        }
+        if (answer === void 0) {
+          spent = true;
+          opts.onNotice?.(`--max-turns reached (${String(maxTurns)}); some pages were not crawled.`);
+          break;
+        }
+        const terms = Array.isArray(answer["terms"]) ? answer["terms"] : [];
+        for (const item of terms) {
+          if (typeof item !== "object" || item === null) continue;
+          const t = item;
+          const label = nonEmpty(t["label"]);
+          if (label === void 0) continue;
+          const definition = nonEmpty(t["definition"]);
+          const line = lineOf(page.content, label);
+          found.push({
+            file: page.file,
+            label,
+            altLabels: strings(t["alt-labels"]),
+            ...definition === void 0 ? {} : { definition },
+            confidence: score(t["confidence"]),
+            ...line === void 0 ? {} : { line },
+            ...page.language === void 0 ? {} : { language: page.language }
+          });
+        }
+      }
+    }
+    for (const candidate of newCandidates(mergeFound(found), known, minPages)) {
+      const concept = { label: candidate.label, from: candidate.from, altLabels: candidate.altLabels, ...candidate.language === void 0 ? {} : { language: candidate.language } };
+      const fields = ["/label", ...candidate.altLabels.length > 0 ? ["/alt-labels"] : [], "/definition"];
+      if (candidate.confidence === void 0 || candidate.definition === void 0) {
+        const got = await draft(candidate.label, candidate.language, {}, candidate.from);
+        if (got === void 0 || "skip" in got || got.status === "below-threshold") {
+          entries2.push({
+            action: "skip",
+            file: displayPath(join3(outDir ?? cwd, `${slugOf(candidate.label)}${ext}`), cwd),
+            id: slugOf(candidate.label),
+            label: candidate.label,
+            ...candidate.language === void 0 ? {} : { language: candidate.language },
+            source: "crawl",
+            from: fromList(candidate.from, cwd),
+            ...got !== void 0 && "skip" in got ? { definition: { status: "missing" }, reason: got.skip } : {
+              definition: {
+                status: "below-threshold",
+                ...got === void 0 ? {} : { confidence: got.confidence },
+                ...modelName === void 0 ? {} : { model: modelName }
+              }
+            }
+          });
+          continue;
+        }
+        await create(concept, "crawl", { drafted: got, fields });
+        continue;
+      }
+      if (candidate.confidence < threshold) {
+        entries2.push({
+          action: "skip",
+          file: displayPath(join3(outDir ?? cwd, `${slugOf(candidate.label)}${ext}`), cwd),
+          id: slugOf(candidate.label),
+          label: candidate.label,
+          ...candidate.language === void 0 ? {} : { language: candidate.language },
+          source: "crawl",
+          from: fromList(candidate.from, cwd),
+          definition: { status: "below-threshold", confidence: candidate.confidence, ...modelName === void 0 ? {} : { model: modelName } }
+        });
+        continue;
+      }
+      await create(concept, "crawl", { drafted: { definition: candidate.definition, confidence: candidate.confidence }, fields });
+    }
+  }
+  if (!dryRun) {
+    for (const { path, content } of writes) {
+      await mkdir(dirname2(path), { recursive: true });
+      await writeFile(path, content, "utf8");
+    }
+  }
+  const count = (action) => entries2.filter((e) => e.action === action).length;
+  return {
+    entries: entries2,
+    summary: {
+      created: count("create"),
+      filled: count("fill"),
+      skipped: count("skip"),
+      withoutDefinition: entries2.filter(
+        (e) => (e.action === "create" || e.action === "skip") && e.definition.status !== "drafted" && e.definition.status !== "carried"
+      ).length,
+      turns
+    },
+    dryRun,
+    threshold
+  };
+}
+async function fillInPlace(path, file, definition, provenance, model) {
+  let content;
+  try {
+    content = await readFile(path, "utf8");
+  } catch (error) {
+    throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
+  }
+  const extractor = extractorForExtension(extname2(path)) ?? extractorByName("markdown");
+  if (extractor?.apply === void 0) throw new TermError(`${file}: manni cannot write its metadata.`);
+  const patch = { definition };
+  if (provenance !== void 0 && model !== void 0) {
+    const held = extractor.extract(content, path).data[META_PROVENANCE_KEY];
+    const merged = mergeMetaProvenance(held, model.identity.model, "fields", [{ name: "/definition", confidence: provenance.confidence }]);
+    if (merged !== void 0) patch[META_PROVENANCE_KEY] = merged.list;
+  }
+  try {
+    return extractor.apply(content, patch, { filePath: path });
+  } catch (error) {
+    throw new TermError(`${file}: ${errorMessage(error)}`);
+  }
+}
+
 // src/term/commands/formats.ts
 var FORMATS_FORMATS = ["pretty", "json"];
 var DOCUMENT_RENDERS = {
@@ -922,12 +1673,14 @@ var INTERCHANGE_LABELS = {
   tbx: "TBX v2",
   tbx3: "TBX v3",
   skos: "JSON-LD",
+  "skos-ttl": "Turtle",
   vale: "style"
 };
 function rendered(writers, format, construct) {
   return writers.some((writer) => {
     const render = DOCUMENT_RENDERS[writer.format];
-    if (render?.input !== format) return false;
+    if (render === void 0) return writer.format === format;
+    if (render.input !== format) return false;
     return writer.shapes.some((shape) => render.shapes[shape] === construct);
   });
 }
@@ -1001,9 +1754,9 @@ async function runGet(opts) {
 }
 
 // src/term/core/lint.ts
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 
 // src/term/core/vale.ts
 import { execFile } from "node:child_process";
@@ -1191,9 +1944,9 @@ async function lintTermSet(set, opts = {}) {
   }
   if (files.length === 0) return [];
   const runVale = opts.runVale ?? runValeJson;
-  const dir = await mkdtemp(join3(tmpdir(), "manni-term-lint-"));
+  const dir = await mkdtemp(join4(tmpdir(), "manni-term-lint-"));
   try {
-    for (const file of files) await writeFile(join3(dir, file.name), file.content, "utf8");
+    for (const file of files) await writeFile2(join4(dir, file.name), file.content, "utf8");
     const alerts = await runVale([dir], { config: opts.valeConfig, cwd: opts.cwd });
     const findings = [];
     for (const [path, list] of Object.entries(alerts)) {
@@ -1243,9 +1996,9 @@ async function runLint(opts) {
 }
 
 // src/term/commands/write.ts
-import { existsSync, statSync } from "node:fs";
-import { lstat, mkdir, readdir, readFile, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname, extname, join as join4, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync2, statSync } from "node:fs";
+import { lstat, mkdir as mkdir2, readdir, readFile as readFile2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, extname as extname3, join as join5, resolve as resolve3 } from "node:path";
 var SUGGESTED_SECTION = "*.md";
 var STYLE2 = "Terms";
 function writeFormats(writers = TERM_WRITERS) {
@@ -1267,11 +2020,11 @@ async function filesUnder(dir, into) {
     return;
   }
   for (const entry of entries2) {
-    const path = join4(dir, entry.name);
+    const path = join5(dir, entry.name);
     if (entry.isDirectory()) await filesUnder(path, into);
     else if (entry.isFile()) {
       const { size } = await lstat(path);
-      into.set(path, size > MAX_EXISTING_FILE_BYTES ? "" : await readFile(path, "utf8"));
+      into.set(path, size > MAX_EXISTING_FILE_BYTES ? "" : await readFile2(path, "utf8"));
     }
   }
 }
@@ -1279,8 +2032,8 @@ async function existingFor(target) {
   const existing = /* @__PURE__ */ new Map();
   if (target.shape === "directory") {
     await filesUnder(target.path, existing);
-  } else if (existsSync(target.path) && !isDirectory(target.path)) {
-    existing.set(target.path, await readFile(target.path, "utf8"));
+  } else if (existsSync2(target.path) && !isDirectory(target.path)) {
+    existing.set(target.path, await readFile2(target.path, "utf8"));
   }
   return existing;
 }
@@ -1299,23 +2052,23 @@ 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) ?? (existsSync(file.path) ? await readFile(file.path, "utf8") : void 0);
+    const before = existing.get(file.path) ?? (existsSync2(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) {
-      await mkdir(dirname(file.path), { recursive: true });
-      await writeFile2(file.path, file.content, "utf8");
+      await mkdir2(dirname3(file.path), { recursive: true });
+      await writeFile3(file.path, file.content, "utf8");
     }
   }
   for (const path of removals) {
-    if (!existsSync(path)) continue;
+    if (!existsSync2(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 = resolve2(opts.cwd ?? process.cwd());
+  const cwd = resolve3(opts.cwd ?? process.cwd());
   const writers = opts.writers ?? TERM_WRITERS;
   const readers = opts.readers ?? TERM_READERS;
   const check = opts.check === true;
@@ -1343,19 +2096,19 @@ async function runWrite(opts) {
         "Vale found no config file. Set tools.vale.config in manni.config.yaml, or pass -o <styles directory>."
       );
     }
-    targetPath = resolve2(cwd, resolved.stylesPath);
+    targetPath = resolve3(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(resolve2(cwd, resolved.rootIni), cwd),
+        rootIni: displayPath(resolve3(cwd, resolved.rootIni), cwd),
         section,
         styles: [...styles, STYLE2],
         addSection: first === void 0
       };
     }
   } else {
-    targetPath = resolve2(cwd, opts.out);
+    targetPath = resolve3(cwd, opts.out);
   }
   const shape = format === "vale" || /[\\/]$/.test(opts.out ?? "") || isDirectory(targetPath) ? "directory" : "file";
   const target = { path: targetPath, shape };
@@ -1368,7 +2121,7 @@ async function runWrite(opts) {
     throw error;
   }
   const changes = await applyChanges(render.files, render.removals, existing, cwd, !check && !dryRun);
-  const shown = format === "vale" ? displayPath(join4(targetPath, STYLE2), cwd) : opts.out ?? displayPath(targetPath, cwd);
+  const shown = format === "vale" ? displayPath(join5(targetPath, STYLE2), cwd) : opts.out ?? displayPath(targetPath, cwd);
   return {
     mode: "render",
     format,
@@ -1395,7 +2148,7 @@ function inputFor(content, path, construct, file) {
     return { content, file, path, format: MANIFEST_FORMAT, metadata: {}, lineFor: () => void 0 };
   }
   if (construct === "tbx-entry") return tbxInput(content, file, path);
-  const extractor = extractorForExtension(extname(path));
+  const extractor = extractorForExtension(extname3(path));
   if (extractor === void 0) throw new TermError(`${file}: no reader for its extension.`);
   return extractInput(content, file, path, extractor.name);
 }
@@ -1428,6 +2181,11 @@ async function writeInPlace(opts, check, dryRun) {
     if (path === void 0) {
       throw new TermError(`${term.location.file} has nowhere to write back to. Pass -f <format> -o <path>.`);
     }
+    if (construct === "skos") {
+      throw new TermError(
+        `${displayPath(term.location.file, cwd)} is SKOS and is not rewritten in place; render it with -f skos or -f skos-ttl.`
+      );
+    }
     const reader = readerForConstruct(construct, readers);
     if (reader?.apply === void 0) {
       const name = reader?.label ?? construct;
@@ -1445,7 +2203,7 @@ async function writeInPlace(opts, check, dryRun) {
   for (const [path, { file, constructs }] of byPath) {
     let original;
     try {
-      original = await readFile(path, "utf8");
+      original = await readFile2(path, "utf8");
     } catch (error) {
       throw new TermError(`${file}: could not be read: ${errorMessage(error)}`);
     }
@@ -1489,16 +2247,28 @@ function renderListCsv(terms) {
 var INFORMATION_URI = "https://hawkeyexl.github.io/manni/term/";
 var RULES_URI = "https://hawkeyexl.github.io/manni/term/reference/rules/";
 var RULE_DESCRIPTIONS = {
-  "undefined-term": "A page's concepts: names a label no entry claims as its preferred label.",
+  "undefined-term": "A page's concepts: names no entry, by label, id or alt-label.",
   "duplicate-id": "Two entries share an id.",
   "label-collision": "Two entries claim the same preferred label, ignoring case.",
   "alt-label-collision": "An entry's alt-label is another entry's preferred label, ignoring case.",
   "dangling-reference": "A value of broader, narrower, related-terms or see names no entry, by label or by id.",
   "broader-cycle": "A chain of broader returns to where it started.",
   "see-not-empty": "An entry with see also carries a definition.",
+  "missing-definition": "An entry has neither a definition nor see.",
+  "conflicting-matches": "One IRI is listed under two of an entry's match kinds.",
   "asymmetric-hierarchy": "A names B as broader, and B omits A from narrower, or the reverse.",
+  "alt-label-reference": "A page's concepts: names an entry by one of its alt-labels.",
   "abstract-too-long": "An abstract is longer than term.abstractMaxLength.",
-  "unused-term": "No page's concepts: names the entry's preferred label."
+  "unused-term": "No page's concepts: names the entry.",
+  "hierarchy-outside-termbase": "A page's graph: block gives a term a broader, narrower or related concept its own entry does not list.",
+  "label-overlap": "A hidden-label or alt-label repeats one of the entry's own names, or a hidden-label is another entry's label or alt-label.",
+  "asymmetric-related": "A names B in related-terms, and B omits A.",
+  "related-in-hierarchy": "A related term is also broader or narrower than the entry, at any depth.",
+  "ambiguous-alt-label": "Two entries share an alt-label, ignoring case.",
+  "deprecated-label": "The entry's label is deprecated or superseded in its designations.",
+  "related-siblings": "Two related terms share a broader term.",
+  "orphan-term": "An entry has no broader, narrower or related term, in a termbase with a hierarchy.",
+  "keyword-candidate": "A free keyword is on several pages and names no term."
 };
 var PROSE_PREFIX = `${RULE_ID_PREFIX}/prose/`;
 var FIELD_LABEL = new RegExp(`^(?:\\(root\\)|/(?:${TERM_FIELDS.join("|")})) `);
@@ -1535,21 +2305,53 @@ function renderFindingsJunit(report) {
   );
 }
 
-// src/term/commands/labels.ts
-async function termLabels(request) {
-  const run = await resolveTermRun({
-    cwd: request.cwd,
-    inputs: [],
-    ...request.configPath === void 0 ? {} : { configPath: request.configPath },
-    ...request.noConfig === true ? { noConfig: true } : {}
-  });
-  if (run.inputs.length === 0 && run.manifests.length === 0) return [];
-  const set = await loadSet(run, { inputs: [], allowEmpty: true });
-  return set.terms.map((term) => ({ label: term.record.label, id: term.id }));
+// src/term/reporters/fill.ts
+var DONE = { create: "created", fill: "filled", skip: "skipped", exists: "exists" };
+var WOULD = { create: "would create", fill: "would fill", skip: "skipped", exists: "exists" };
+function detail(entry, threshold) {
+  if (entry.reason !== void 0) return entry.reason;
+  const { status, confidence } = entry.definition;
+  if (entry.action === "exists") return "the file is already there";
+  switch (status) {
+    case "carried":
+      return "definition from graph: block";
+    case "drafted":
+      return `definition drafted (${(confidence ?? 0).toFixed(2)})`;
+    case "below-threshold": {
+      const under = `confidence ${(confidence ?? 0).toFixed(2)} is under ${String(threshold)}`;
+      return entry.action === "create" ? `stub, ${under}` : under;
+    }
+    case "missing":
+      return "stub, no definition";
+  }
+}
+function renderFillPretty(report) {
+  const words = report.dryRun ? WOULD : DONE;
+  const actionWidth = Math.max(0, ...report.entries.map((e) => words[e.action].length));
+  const fileWidth = Math.max(0, ...report.entries.map((e) => e.file.length)) + 3;
+  const labelWidth = Math.max(0, ...report.entries.map((e) => e.label.length)) + 3;
+  const lines = report.entries.map(
+    (e) => `${words[e.action].padEnd(actionWidth)} ${e.file.padEnd(fileWidth)}${e.label.padEnd(labelWidth)}${detail(e, report.threshold)}`
+  );
+  const { created, filled, skipped, withoutDefinition } = report.summary;
+  const skips = skipped > 0 ? `, ${String(skipped)} skipped` : "";
+  lines.push(
+    report.dryRun ? `${plural(created, "term")} would be created, ${String(filled)} would be filled, ${String(withoutDefinition)} left without a definition${skips}` : `${plural(created, "term")} created, ${String(filled)} filled, ${String(withoutDefinition)} left without a definition${skips}`
+  );
+  return lines.join("\n");
+}
+function renderFillJson(report) {
+  return JSON.stringify({ entries: report.entries, summary: report.summary }, null, 2);
 }
 
 // src/term/cli.ts
-registerTermLabelSource(termLabels);
+function numeric(name, value, min, max, integer = false) {
+  if (value === void 0) return;
+  if (!Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value)) {
+    const kind = integer ? "a whole number" : "a number";
+    throw new TermError(`${name} must be ${kind} between ${String(min)} and ${String(max)}, got ${String(value)}.`);
+  }
+}
 function colorFor(options) {
   return shouldColor({ noColor: !options.color, isTTY: process.stdout.isTTY });
 }
@@ -1574,11 +2376,11 @@ function print(text) {
   process.stdout.write(`${text}
 `);
 }
-function renderFindings(report, format, options, references2) {
+function renderFindings(report, format, options, references) {
   let text;
   switch (format) {
     case "pretty":
-      text = renderFindingsPretty(report, { color: colorFor(options), references: references2 });
+      text = renderFindingsPretty(report, { color: colorFor(options), references });
       break;
     case "json":
       text = renderFindingsJson(report);
@@ -1703,6 +2505,44 @@ function buildProgram() {
       fail(err);
     }
   });
+  withInputs(
+    program.command("fill").description("Create term pages for the concepts pages name, and draft missing definitions").argument("[paths...]", "files, directories, or globs to read (use - for stdin)")
+  ).option("-o, --out <dir>", "directory for new term pages").option("--crawl", "also ask the model for terms that page bodies and keywords use").option("--offline", "no network egress: only a model already downloaded, never a remote 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("--confidence <n>", "minimum confidence to write a definition (0-1)", parseFloat).option("--max-turns <n>", "stop after this many inference calls", parseFloat).option("--chunk-chars <n>", "characters of page per call under --crawl (default 12000)", parseFloat).option("--no-cache", "bypass the answer cache").option("--dry-run", "write nothing; print what would change").option("-f, --format <format>", `output: ${FILL_FORMATS.join(" | ")}`, "pretty").addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni term fill --offline --dry-run         # what is missing, nothing sent",
+      "  manni term fill                             # pages and drafted definitions",
+      "  manni term fill --crawl -o docs/glossary/   # terms no metadata named",
+      "  manni term fill --dry-run -f json           # for a script"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    try {
+      const format = formatChoice(options.format, FILL_FORMATS);
+      numeric("--confidence", options.confidence, 0, 1);
+      numeric("--max-turns", options.maxTurns, 1, Number.MAX_SAFE_INTEGER, true);
+      numeric("--chunk-chars", options.chunkChars, 1, Number.MAX_SAFE_INTEGER, true);
+      const report = await runFill({
+        ...await coreOptions(paths, options),
+        ...options.out === void 0 ? {} : { out: options.out },
+        ...options.crawl === true ? { crawl: true } : {},
+        ...options.offline === true ? { offline: true } : {},
+        ...options.provider === void 0 ? {} : { provider: options.provider },
+        ...options.model === void 0 ? {} : { model: options.model },
+        ...options.local === true ? { local: true } : {},
+        ...options.confidence === void 0 ? {} : { confidence: options.confidence },
+        ...options.maxTurns === void 0 ? {} : { maxTurns: options.maxTurns },
+        ...options.chunkChars === void 0 ? {} : { chunkChars: options.chunkChars },
+        ...options.cache ? {} : { noCache: true },
+        ...options.dryRun === true ? { dryRun: true } : {}
+      });
+      print(format === "json" ? renderFillJson(report) : renderFillPretty(report));
+      process.exitCode = 0;
+    } catch (err) {
+      fail(err);
+    }
+  });
   program.command("formats").description("List the constructs read and written, per format").option("-f, --format <format>", `output: ${FORMATS_FORMATS.join(" | ")}`, "pretty").action((options) => {
     try {
       const format = formatChoice(options.format, FORMATS_FORMATS);
@@ -1720,4 +2560,4 @@ export {
   TermError,
   buildProgram
 };
-//# sourceMappingURL=term-CQAGNG3Q.js.map
+//# sourceMappingURL=term-D2N7UN4P.js.map