typeglish 0.1.0

package/dist/chunk-KRYC4OTL.js

@@ -0,0 +1,3573 @@
+import { classifyLines, switchBlockMask, parseSwitches, testBlockLines, exampleBlockLines, buildStructure, matchSectionTag, addresseeSubjects, parseTools, resolveDeclarations, aliasMap, structuralConflicts, resolveConfigSchema, BUILTIN_CONFIG_SCHEMA, parseConfigRules, configParamDiagnostics, configRuleDiagnostics, looseContentLines, headingsOutsideSections, checkModel, maskInlineSwitches, parseExpr, evalExpr, selectPredicateArm, selectTupleArm, selectArm, exprAtoms, resolveInlineText, parseServices, parseConfigBlocks, compileToXml, resolveAnchors, extractSuite, rubricExpectLines, findEnumDeclaration, collectObjects, singularizeNoun, pluralizeNoun, boundText, isHeadingLine, parseInlineSwitches, parseActionCount, parseCardinalBody } from './chunk-YH4ZLQ4G.js';
+import { MODAL_KEYWORDS, COMPARISON_SYMBOLS, FREQUENCY_WORDS, QUANTIFIER_WORDS, keywordAlternation, GUARD_OPENERS, illustrationZoneMask, toolBlockMask, defEntries, examplesMask, defListMask, TAG_ONLY_LINE, stripAnnotation, lineOrdinals, proseExemptLines, configSectionMask, isAnnotationLine, hasTrailingAnnotation, maskQuotes, lower, parseLine, stripInlineComment, splitSentences, predicatesFromProse, displayLine, MODAL_HINT, classifyClause, TRANSCLUSION_LINE_RE, DEF_ENTRY, SNAKE_RE, toolsFromLines, parsePredicate, isAntonym, copulaAlternation, normAtom, canonicalActionKey, TAG_NAME_SRC } from './chunk-Y64EAEYB.js';
+
+// src/core/highlight.ts
+function classifyValence(raw) {
+  const t = raw.trim().replace(/^#{1,6}\s+/, "").replace(/^>\s?/, "").replace(/^(?:[-*+]|\d+\.)\s+/, "").trim().toLowerCase();
+  if (/^(never|don'?t|do not|avoid|must not|cannot|no\b)/.test(t)) return "prohibition";
+  if (/^(always|must\b|ensure|make sure|be sure|you must|require)/.test(t)) return "directive";
+  if (/^(if|when|whenever|unless|in case|should)/.test(t)) return "conditional";
+  if (/^(e\.?g\.?\b|for example|example:|input:|output:|for instance)/.test(t)) return "example";
+  if (/(respond (with|only|in)|output (a|the|only|in)|return (a|the|only)|format:|json|markdown|use the following format)/.test(
+    t
+  )) {
+    return "format";
+  }
+  if (/^(you are|you'?re|act as|your role|your job|as an?\b)/.test(t)) return "role";
+  return "plain";
+}
+var INLINE_RULES = [
+  { re: /^`[^`\n]+`/, cls: "md-code-inline", delim: 1 },
+  { re: /^\*\*\*[^*\n]+\*\*\*/, cls: "md-strong-em", delim: 3 },
+  { re: /^\*\*[^*\n]+\*\*/, cls: "md-strong", delim: 2 },
+  { re: /^~~[^~\n]+~~/, cls: "md-strike", delim: 2 },
+  { re: /^\*[^*\s][^*\n]*\*/, cls: "md-em", delim: 1 }
+];
+var LINK_RE = /^\[([^\]\n]+)\]\(([^)\n]+)\)/;
+function tokenizeInline(text) {
+  const tokens2 = [];
+  let buf = "";
+  const flush = () => {
+    if (buf) {
+      tokens2.push({ text: buf });
+      buf = "";
+    }
+  };
+  let i = 0;
+  while (i < text.length) {
+    const sub = text.slice(i);
+    const lm = sub.match(LINK_RE);
+    if (lm) {
+      flush();
+      tokens2.push({ text: "[", cls: "md-marker" });
+      tokens2.push({ text: lm[1] ?? "", cls: "md-link" });
+      tokens2.push({ text: "](", cls: "md-marker" });
+      tokens2.push({ text: lm[2] ?? "", cls: "md-link-url" });
+      tokens2.push({ text: ")", cls: "md-marker" });
+      i += lm[0].length;
+      continue;
+    }
+    let matched = false;
+    for (const r of INLINE_RULES) {
+      const m = sub.match(r.re);
+      if (m) {
+        flush();
+        const full = m[0];
+        tokens2.push({ text: full.slice(0, r.delim), cls: "md-marker" });
+        tokens2.push({ text: full.slice(r.delim, full.length - r.delim), cls: r.cls });
+        tokens2.push({ text: full.slice(full.length - r.delim), cls: "md-marker" });
+        i += full.length;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      buf += text[i] ?? "";
+      i += 1;
+    }
+  }
+  flush();
+  return tokens2;
+}
+function lineLevel(raw) {
+  const h = raw.match(/^\s*#{1,6}\s+/);
+  if (h) return { lineClass: "md-heading", contentStart: h[0].length };
+  const q = raw.match(/^\s*>\s?/);
+  if (q) return { lineClass: "md-quote", contentStart: q[0].length };
+  const li = raw.match(/^\s*(?:[-*+]|\d+\.)\s+/);
+  if (li) return { contentStart: li[0].length };
+  return { contentStart: 0 };
+}
+function renderLines(rawLines) {
+  const kinds = classifyLines(rawLines);
+  const out = [];
+  let inFence = false;
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const raw = rawLines[i] ?? "";
+    const kind = kinds[i] ?? "content";
+    const t = raw.trim();
+    const isFence = t.startsWith("```") || t.startsWith("~~~");
+    if (inFence) {
+      if (isFence) inFence = false;
+      out.push({ kind, lineClass: "md-code", valence: "plain", tokens: [{ text: raw }] });
+      continue;
+    }
+    if (kind === "comment") {
+      out.push({ kind, lineClass: "ol-comment", valence: "plain", tokens: [{ text: raw }] });
+      continue;
+    }
+    if (isFence) {
+      inFence = true;
+      out.push({ kind, lineClass: "md-code", valence: "plain", tokens: [{ text: raw }] });
+      continue;
+    }
+    if (kind === "blank") {
+      out.push({ kind, valence: "plain", tokens: [{ text: raw }] });
+      continue;
+    }
+    const { lineClass, contentStart } = lineLevel(raw);
+    const marker = contentStart > 0 ? [{ text: raw.slice(0, contentStart), cls: "md-marker" }] : [];
+    out.push({
+      kind,
+      lineClass,
+      valence: classifyValence(raw),
+      tokens: [...marker, ...tokenizeInline(raw.slice(contentStart))]
+    });
+  }
+  return out;
+}
+
+// src/core/fmt.ts
+var INDENT_UNIT = 2;
+new RegExp(`;\\s*(?:and\\s+|but\\s+)?(${MODAL_KEYWORDS.join("|")})\\b`, "i");
+function wrappedContinuations(rawLines) {
+  const render = renderLines(rawLines);
+  const exempt = proseExemptLines(rawLines);
+  const tests = testBlockLines(rawLines);
+  const tools = toolBlockMask(rawLines);
+  const cfg = configSectionMask(rawLines);
+  const out = /* @__PURE__ */ new Map();
+  let prevContent = -1;
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const raw = rawLines[i] ?? "";
+    if (tests.has(i)) continue;
+    if (tools[i] || cfg[i]) {
+      prevContent = -1;
+      continue;
+    }
+    const r = render[i];
+    if (!r || r.kind !== "content" || r.lineClass === "md-code") continue;
+    if (r.lineClass === "md-heading") {
+      prevContent = -1;
+      continue;
+    }
+    const before = prevContent;
+    prevContent = i;
+    if (before === -1 || exempt.has(i) || exempt.has(before)) continue;
+    const parsed = parseLine(raw);
+    if (parsed.list !== "none") continue;
+    const clause = parsed.clause.trim();
+    if (clause === "" || !/^[a-z]/.test(clause)) continue;
+    if (classifyClause(clause) !== "prose") continue;
+    const prevText = (rawLines[before] ?? "").trim();
+    if (prevText === "" || /[.!?:;"'`)\]]$/.test(prevText)) continue;
+    out.set(i, before);
+  }
+  return out;
+}
+
+// src/core/layout.ts
+function layoutColumns(rawLines) {
+  const n = rawLines.length;
+  const col = new Array(n).fill(null);
+  const substep = new Array(n).fill(false);
+  const render = renderLines(rawLines);
+  const zoneMask = illustrationZoneMask(rawLines);
+  const toolMask = toolBlockMask(rawLines);
+  const swMask = switchBlockMask(rawLines);
+  const chainStarts = new Set(parseSwitches(rawLines).filter((b) => b.error === null).map((b) => b.headerLine));
+  const testLines = testBlockLines(rawLines);
+  const exampleLines = exampleBlockLines(rawLines);
+  const doc = buildStructure(rawLines);
+  const baseCol = new Array(n).fill(0);
+  const tagCol = /* @__PURE__ */ new Map();
+  for (const s of doc.sections) {
+    if (s.syntax !== "xml") continue;
+    const end = Math.min(s.endLine ?? n, n);
+    tagCol.set(s.startLine, 2 * s.depth);
+    const closeLine = end - 1;
+    if (closeLine > s.startLine && matchSectionTag(rawLines[closeLine] ?? "") !== null) {
+      tagCol.set(closeLine, 2 * s.depth);
+    }
+    for (let i = s.startLine + 1; i < closeLine; i += 1) {
+      baseCol[i] = Math.max(baseCol[i] ?? 0, 2 * (s.depth + 1));
+    }
+  }
+  const defBody = /* @__PURE__ */ new Map();
+  for (const e of defEntries(rawLines)) {
+    let fence = false;
+    const stack = [];
+    let curCol = e.indent + 2;
+    for (const li of e.lines) {
+      if (li === e.line) continue;
+      const raw = rawLines[li] ?? "";
+      const t = raw.trim();
+      if (t.startsWith("```") || t.startsWith("~~~")) {
+        defBody.set(li, fence ? null : curCol);
+        fence = !fence;
+        continue;
+      }
+      if (fence || t === "") {
+        defBody.set(li, null);
+        continue;
+      }
+      if (t.startsWith("- ")) {
+        const si = raw.length - raw.trimStart().length;
+        while (stack.length > 0 && (stack[stack.length - 1] ?? 0) >= si) stack.pop();
+        stack.push(si);
+        curCol = e.indent + 2 * stack.length;
+        defBody.set(li, curCol);
+        continue;
+      }
+      defBody.set(li, null);
+    }
+  }
+  for (let i = 0; i < n; i += 1) {
+    const raw = rawLines[i] ?? "";
+    const t = raw.trim();
+    if (t === "") continue;
+    if (render[i]?.lineClass === "md-code") continue;
+    if (defBody.has(i)) {
+      col[i] = defBody.get(i) ?? null;
+      continue;
+    }
+    if (testLines.has(i)) continue;
+    if (exampleLines.has(i)) continue;
+    if (zoneMask[i] === true && !tagCol.has(i)) continue;
+    if (toolMask[i] === true && !/^\s*\$(?:TOOL|SERVICE)\b/i.test(raw)) continue;
+    if (swMask[i] === true && !chainStarts.has(i)) continue;
+    if (t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) continue;
+    const leadWs = (raw.match(/^[ \t]*/) ?? [""])[0];
+    if (leadWs.includes("	")) continue;
+    col[i] = tagCol.get(i) ?? baseCol[i] ?? 0;
+    substep[i] = /^(?:[a-z]\.|\d+(?:\.\d+)+\.?)\s/i.test(t);
+  }
+  return { col, substep };
+}
+
+// src/core/charset.ts
+var BOUND = Object.fromEntries(
+  COMPARISON_SYMBOLS.flatMap((c) => c.bound ? c.symbols.map((s) => [s, c.bound]) : [])
+);
+var CHARSET_RULES = [
+  // Emoji first, as full ZWJ sequences, so a joiner inside one is never re-flagged as an invisible.
+  // ©®™ are Extended_Pictographic but meaning-bearing marks, not decoration — excluded.
+  {
+    re: /(?![©®™])\p{Extended_Pictographic}(?:️)?(?:‍(?![©®™])\p{Extended_Pictographic}(?:️)?)*/gu,
+    source: "structure/special-character",
+    msg: "Emoji is outside the language: the instruction plane is checkable English, and models mirror prompt decoration into output. Remove it, or demonstrate it inside <examples>."
+  },
+  // En-dash between digits is a RANGE — the fix is a hyphen, not a comma.
+  {
+    re: /(?<=\d) ?– ?(?=\d)/g,
+    source: "structure/em-dash",
+    msg: "Typographic dash in a range: write a plain hyphen (3-5). The en-dash is a lookalike the parsers do not read.",
+    fix: () => ({ title: '\u2192 "-"', replacement: "-" })
+  },
+  {
+    re: / ?[—–] ?/g,
+    source: "structure/em-dash",
+    msg: "An em-dash splices two statements into one line: the checker reads one unparseable blob, and models mirror the tic (the canonical AI-tell). Split the statements, or use a comma or colon.",
+    fix: (m, text) => (m.index ?? 0) > 0 && (m.index ?? 0) + m[0].length < text.length ? { title: '\u2192 ","', replacement: ", " } : null
+  },
+  {
+    re: /[“”„]/g,
+    source: "structure/curly-quote",
+    msg: 'A curly quote is not a TG string literal: only straight " binds an utterance, so this text is invisible to the quote doctrine. Straighten it.',
+    fix: () => ({ title: '\u2192 "', replacement: '"' })
+  },
+  {
+    re: /[‘’‚]/g,
+    source: "structure/curly-quote",
+    msg: "A curly apostrophe is a lookalike: the parsers read ASCII ', so possession and contractions written with it are invisible to the consistency checker. Straighten it.",
+    fix: () => ({ title: "\u2192 '", replacement: "'" })
+  },
+  {
+    re: /≤ ?/g,
+    source: "structure/special-character",
+    msg: `The numeric tier parses bounds written in English: '\u2264 3' lowers with no bound while '${BOUND["\u2264"]} 3' is Z3-provable. Write it out.`,
+    fix: () => ({ title: `\u2192 "${BOUND["\u2264"]}"`, replacement: `${BOUND["\u2264"]} ` })
+  },
+  {
+    re: /≥ ?/g,
+    source: "structure/special-character",
+    msg: `The numeric tier parses bounds written in English: '\u2265 3' lowers with no bound while '${BOUND["\u2265"]} 3' is Z3-provable. Write it out.`,
+    fix: () => ({ title: `\u2192 "${BOUND["\u2265"]}"`, replacement: `${BOUND["\u2265"]} ` })
+  },
+  {
+    re: / ?≠ ?/g,
+    source: "structure/special-character",
+    msg: "The parsers read negation in English: write 'is not'.",
+    fix: () => ({ title: '\u2192 "is not"', replacement: " is not " })
+  },
+  {
+    re: /−/g,
+    // U+2212 minus sign, a hyphen lookalike
+    source: "structure/special-character",
+    msg: 'Unicode minus sign: a hyphen lookalike the parsers do not read. Use "-".',
+    fix: () => ({ title: '\u2192 "-"', replacement: "-" })
+  },
+  {
+    re: /(?<=\d) ?× ?(?=\d)/g,
+    source: "structure/special-character",
+    msg: 'Multiplication sign: write a plain "x" (3x) \u2014 the \xD7 is a lookalike outside the language.',
+    fix: () => ({ title: '\u2192 "x"', replacement: "x" })
+  },
+  {
+    re: /…/g,
+    source: "structure/special-character",
+    msg: 'Unicode ellipsis: write "..." \u2014 or finish the statement.',
+    fix: () => ({ title: '\u2192 "..."', replacement: "..." })
+  },
+  {
+    re: /(?<=^\s*)[•◦▪‣·] ?/g,
+    source: "structure/special-character",
+    msg: 'Not a list bullet the parser reads: use "- ".',
+    fix: () => ({ title: '\u2192 "- "', replacement: "- " })
+  },
+  {
+    re: /[→←⇒⇐↔⇔↦➜➤▶◀]/g,
+    source: "structure/special-character",
+    msg: 'An arrow encodes sequence or mapping the language already has words for: use THEN for flow, "to" for mappings. Arrows belong only inside <examples> demos.'
+  },
+  {
+    re: /[   ]/g,
+    // no-break space family — invisible, breaks token/word matching
+    source: "structure/special-character",
+    msg: "Non-breaking space: an invisible lookalike that breaks word matching and is a known injection surface. Use a plain space.",
+    fix: () => ({ title: "\u2192 space", replacement: " " })
+  },
+  {
+    re: /[​‌‍⁠️]/g,
+    // zero-width family — pure sabotage
+    source: "structure/special-character",
+    msg: "Zero-width character: invisible to a human, real to the model \u2014 a documented injection vector. Remove it.",
+    fix: () => ({ title: "Remove", replacement: "" })
+  },
+  {
+    re: /[─-╿]/g,
+    // box drawing
+    source: "structure/special-character",
+    msg: 'Box-drawing character: verbatim layouts belong in a <"name"> literal zone or a fence, not the instruction plane.'
+  },
+  {
+    re: /[•◦▪‣·★☆✦✧✱✳✴❇✨†‡¶≈×÷±∞]/g,
+    source: "structure/special-character",
+    msg: "Decorative or symbolic Unicode is outside the language: every mark here has an English or ASCII form the checker reads. Use plain text; illustrations belong in <examples>."
+  }
+];
+var SPECIAL_ANY = /[—–“”„‘’‚…•◦▪‣·≥≤≠≈×÷±∞−★☆✦✧✱✳✴❇✨†‡¶→←⇒⇐↔⇔↦➜➤▶◀   ​-‍⁠️─-╿]|\p{Extended_Pictographic}/u;
+var CHARSET_DOC = {
+  id: "charset",
+  title: "Character set",
+  lead: 'The instruction plane is plain ASCII: typographic and decorative codepoints are **compile errors**, each with a one-click ASCII fix. Not aesthetics \u2014 every mark here hides meaning from a tier that parses the ASCII/English form (a curly apostrophe conceals a possession contradiction; `\u2264 3` lowers with no bound while `at most 3` is Z3-provable; an em-dash splices two statements into one line). Symbols are legal only inside the literal zones: `<examples>`, `<"name">`, fences, and `"quotes"`.',
+  headers: ["Not allowed", "Fix", "Why"],
+  rows: [
+    ["`\u2014` `\u2013` em/en dash", "`,` or `:`", "Splices two statements into one line; the canonical AI-tell, mirrored into output"],
+    ["`\u201C \u201D` `\u2018 \u2019` curly quotes", "straighten to ASCII", "Only a straight quote binds a string literal; a curly apostrophe hides a possession contradiction"],
+    ["`\u2264` `\u2265` `\u2260`", `\`${BOUND["\u2264"]}\` \`${BOUND["\u2265"]}\` \`is not\``, "A bound in English is Z3-provable; the symbol lowers with no bound"],
+    ["`\u2026` `\u2212` `\xD7`", "`...` `-` `x`", "Lookalikes the parsers do not read"],
+    ["`\u2022` `\u25E6` `\u25AA` bullets", "`- `", "Not a list bullet the parser reads"],
+    ["`\u2192` `\u21D2` `\u2194` arrows", "`THEN` or the word `to`", "The language already has words for flow and mapping"],
+    ["non-breaking / zero-width space", "a plain space, or remove", "Invisible saboteurs and a documented injection surface"],
+    ["box-drawing, `\u2605 \xF7 \xB1 \xB6`, emoji", 'a fence or `<"name">` zone', "Verbatim layout and decoration belong in the literal zones"]
+  ]
+};
+
+// src/core/logic.ts
+var TRUE = { t: "true" };
+function atomsOf(f, into) {
+  if (f.t === "atom") into.add(f.name);
+  else if (f.t === "not") atomsOf(f.f, into);
+  else if (f.t === "and" || f.t === "or") f.fs.forEach((x) => atomsOf(x, into));
+}
+function evalF(f, a) {
+  switch (f.t) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "atom":
+      return a.get(f.name) ?? false;
+    case "not":
+      return !evalF(f.f, a);
+    case "and":
+      return f.fs.every((x) => evalF(x, a));
+    case "or":
+      return f.fs.some((x) => evalF(x, a));
+  }
+}
+function satisfiable(f) {
+  const set = /* @__PURE__ */ new Set();
+  atomsOf(f, set);
+  const atoms = [...set];
+  const n = atoms.length;
+  if (n > 20) return true;
+  for (let mask = 0; mask < 1 << n; mask += 1) {
+    const a = /* @__PURE__ */ new Map();
+    for (let i = 0; i < n; i += 1) a.set(atoms[i] ?? "", (mask & 1 << i) !== 0);
+    if (evalF(f, a)) return true;
+  }
+  return false;
+}
+var PROHIBIT = ["MUST NOT", "DO NOT", "DON'T", "NEVER"];
+var OBLIGATE = ["NEEDS TO", "NEED TO", "HAVE TO", "HAS TO", "MUST", "ALWAYS", "REQUIRE", "ENSURE"];
+function foldLeadingNegation(kind, action) {
+  let k = kind;
+  let a = action.trim();
+  for (; ; ) {
+    const m = /^(?:not|never)\s+/i.exec(a);
+    if (!m) return { kind: k, action: a };
+    k = k === "obligate" ? "prohibit" : "obligate";
+    a = a.slice(m[0].length);
+  }
+}
+function negate(f) {
+  if (f.t === "true") return { t: "false" };
+  if (f.t === "false") return TRUE;
+  return { t: "not", f };
+}
+function implies(a, b) {
+  return !satisfiable({ t: "and", fs: [a, negate(b)] });
+}
+function guardsCollide(c1, c2) {
+  return implies(c1, c2) || implies(c2, c1);
+}
+function parseCondition(text) {
+  const t = text.trim();
+  if (t === "") return TRUE;
+  const ors = t.split(/\s+OR\s+/i).map((op) => {
+    const ands = op.split(/\s+AND\s+/i).map((ap) => ap.trim()).filter((x) => x !== "").map((term) => {
+      const neg = /^NOT\s+/i.test(term);
+      const atom = { t: "atom", name: normAtom(neg ? term.replace(/^NOT\s+/i, "") : term) };
+      return neg ? { t: "not", f: atom } : atom;
+    });
+    return ands.length === 0 ? TRUE : ands.length === 1 ? ands[0] ?? TRUE : { t: "and", fs: ands };
+  });
+  return ors.length === 1 ? ors[0] ?? TRUE : { t: "or", fs: ors };
+}
+var FREQ_KIND_TO_FREQ = { existential: "some", majority: "most", minority: "few" };
+var FREQ_ALT = FREQUENCY_WORDS.flatMap((f) => f.words.map((w) => ({ w, freq: FREQ_KIND_TO_FREQ[f.kind] }))).sort((a, b) => b.w.length - a.w.length);
+var FREQ_LEAD_RE = new RegExp(`^(?:you\\s+)?(${FREQ_ALT.map((x) => x.w.replace(/ /g, "\\s+")).join("|")})\\b,?\\s+(.+)$`, "i");
+function peelFrequency(text) {
+  const m = text.trim().match(FREQ_LEAD_RE);
+  if (!m) return { freq: null, rest: text };
+  const word = (m[1] ?? "").toUpperCase().replace(/\s+/g, " ");
+  const hit = FREQ_ALT.find((x) => x.w === word);
+  return hit ? { freq: hit.freq, rest: m[2] ?? "" } : { freq: null, rest: text };
+}
+function pInterval(kind, freq) {
+  if (kind === "obligate") {
+    if (freq === "all") return { lo: 1, hi: 1, loOpen: false, hiOpen: false };
+    if (freq === "most") return { lo: 0.5, hi: 1, loOpen: true, hiOpen: false };
+    if (freq === "few") return { lo: 0, hi: 0.5, loOpen: true, hiOpen: true };
+    return { lo: 0, hi: 1, loOpen: true, hiOpen: false };
+  }
+  if (freq === "all") return { lo: 0, hi: 0, loOpen: false, hiOpen: false };
+  if (freq === "most") return { lo: 0, hi: 0.5, loOpen: false, hiOpen: true };
+  if (freq === "few") return { lo: 0.5, hi: 1, loOpen: true, hiOpen: true };
+  return { lo: 0, hi: 1, loOpen: false, hiOpen: true };
+}
+var disjointP = (a, b) => {
+  if (a.hi < b.lo || b.hi < a.lo) return true;
+  if (a.hi === b.lo) return a.hiOpen || b.loOpen;
+  if (b.hi === a.lo) return b.hiOpen || a.loOpen;
+  return false;
+};
+var subsetP = (a, b) => {
+  const loOk = a.lo > b.lo || a.lo === b.lo && (b.loOpen ? a.loOpen : true);
+  const hiOk = a.hi < b.hi || a.hi === b.hi && (b.hiOpen ? a.hiOpen : true);
+  return loOk && hiOk;
+};
+var FREQ_PHRASE = { all: "on every occasion", most: "on most occasions", some: "on some occasions", few: "on few occasions" };
+var freqPhrase = (c) => `${c.kind === "obligate" ? "required" : "skipped"} ${FREQ_PHRASE[c.freq]}`;
+function keyedClause(kind, action, scope, tools) {
+  const { key, parsed, canonical } = canonicalActionKey(action, tools);
+  let k = kind;
+  let viaAntonym = false;
+  if (canonical && parsed && parsed.lexicalPolarity === -1) {
+    k = k === "obligate" ? "prohibit" : "obligate";
+    viaAntonym = true;
+  }
+  return { kind: k, atom: scope + key, display: action.trim(), canonical, viaAntonym };
+}
+function matchModalAt(rest, subject, tools, addressees) {
+  const canon = subject !== "you" && addressees?.has(subject) === true ? "you" : subject;
+  const scope = canon === "you" ? "" : `${canon}: `;
+  const u = rest.toUpperCase();
+  const graded = (kind0, raw) => {
+    const pre = peelFrequency(raw);
+    const f = foldLeadingNegation(kind0, pre.rest);
+    const post = peelFrequency(f.action);
+    return { ...keyedClause(f.kind, post.rest, scope, tools), freq: pre.freq ?? post.freq ?? "all" };
+  };
+  for (const p of PROHIBIT) {
+    if (u.startsWith(`${p} `)) return graded("prohibit", rest.slice(p.length));
+  }
+  for (const o of OBLIGATE) {
+    if (u.startsWith(`${o} `)) return graded("obligate", rest.slice(o.length));
+  }
+  return null;
+}
+function detectModal(seg, tools, addressees) {
+  const s = seg.trim();
+  const bare = matchModalAt(s, "you", tools, addressees);
+  if (bare) return bare;
+  const words = s.split(/\s+/);
+  for (let i = 1; i < words.length; i += 1) {
+    const subject = words.slice(0, i).join(" ").replace(/^(?:the|a|an)\s+/i, "").trim().toLowerCase();
+    const m = matchModalAt(words.slice(i).join(" "), subject === "" ? "you" : subject, tools, addressees);
+    if (m) return m;
+  }
+  return null;
+}
+function splitGuard(sentence) {
+  const s = sentence.trim();
+  if (!/^IF\b/i.test(s)) return null;
+  const rest = s.slice(2);
+  for (let i = rest.indexOf(","); i !== -1; i = rest.indexOf(",", i + 1)) {
+    const body = rest.slice(i + 1).trim().replace(/^(?:you\s+then\s+|then\s+you\s+)/i, "you ").replace(/^then\s+/i, "");
+    if (body !== "" && stripDeonticLead(body).matched) return { cond: rest.slice(0, i), body };
+  }
+  const thenSplit = s.match(/^IF\b(.+?)\bTHEN\b(.+)$/i);
+  if (thenSplit) return { cond: thenSplit[1] ?? "", body: (thenSplit[2] ?? "").trim() };
+  return null;
+}
+function stripDeonticLead(segment, opts) {
+  const direct = (text, subject) => {
+    const u = text.toUpperCase();
+    for (const p of PROHIBIT) if (u.startsWith(`${p} `)) return { body: text.slice(p.length + 1), prohibited: true, matched: true, subject };
+    for (const o of OBLIGATE) {
+      if (u.startsWith(`${o} `)) {
+        const rest = text.slice(o.length + 1);
+        const neg = rest.match(/^not\s+/i);
+        return neg ? { body: rest.slice(neg[0].length), prohibited: true, matched: true, subject } : { body: rest, prohibited: false, matched: true, subject };
+      }
+    }
+    return null;
+  };
+  const s = segment.trim().replace(/^you\s+/i, "");
+  const hit = direct(s, "you");
+  if (hit) return hit;
+  if (opts?.peelSubject === true) {
+    const words = s.split(/\s+/);
+    for (let i = 1; i <= 3 && i < words.length; i += 1) {
+      const raw = words.slice(0, i);
+      if (!raw.every((w) => /^[A-Za-z][A-Za-z'-]*$/.test(w) && !/^(?:if|then|otherwise|and|or|when|while|unless)$/i.test(w))) break;
+      const m = direct(words.slice(i).join(" "), raw.join(" ").toLowerCase().replace(/^(?:the|a|an)\s+/, "") || "you");
+      if (m) return m;
+    }
+  }
+  return { body: s, prohibited: false, matched: false, subject: "you" };
+}
+function pushSegments(text, cond, line, out, tools, imperativesAllowed = false, addressees) {
+  for (const seg of text.split(";")) {
+    const lead = peelFrequency(seg);
+    const core = lead.freq === null ? seg : lead.rest;
+    const m = detectModal(core, tools, addressees);
+    if (m && m.atom) {
+      out.push({ ...m, freq: lead.freq ?? m.freq, cond, line });
+      continue;
+    }
+    if (!imperativesAllowed || false) continue;
+    const t = core.trim();
+    if (t === "") continue;
+    const parsed = parsePredicate(t, tools);
+    if (parsed && (parsed.confidence === "lexicon" || lead.freq !== null)) {
+      const clause = keyedClause("obligate", t.replace(/[.!?]+$/, ""), "", tools);
+      out.push({ ...clause, freq: lead.freq ?? "all", cond, line });
+    }
+  }
+}
+function extractClauses(rawLine, line, tools, exempt, addressees) {
+  const imperativesAllowed = exempt === void 0 ? false : !exempt.has(line);
+  const { clause } = parseLine(rawLine);
+  const masked = maskQuotes(clause);
+  const out = [];
+  const sentences = splitSentences(masked);
+  const segments = sentences.length > 1 ? sentences.map((s) => s.text) : [masked];
+  for (const sentence of segments) {
+    let cond = TRUE;
+    let body = sentence;
+    const g = splitGuard(sentence);
+    if (g) {
+      cond = parseCondition(g.cond);
+      body = g.body;
+    }
+    const ow = g ? body.match(/^(.+?)\bOTHERWISE\b(.+)$/i) : null;
+    if (ow) {
+      pushSegments(ow[1] ?? "", cond, line, out, tools, imperativesAllowed, addressees);
+      pushSegments(ow[2] ?? "", negate(cond), line, out, tools, imperativesAllowed, addressees);
+    } else {
+      pushSegments(body, cond, line, out, tools, imperativesAllowed, addressees);
+    }
+  }
+  return out;
+}
+function checkConsistency(lines, addressees) {
+  const tools = toolsFromLines(lines);
+  const exempt = proseExemptLines(lines);
+  const clauses = [];
+  lines.forEach((l, i) => clauses.push(...extractClauses(l, i, tools, exempt, addressees)));
+  const byAtom = /* @__PURE__ */ new Map();
+  for (const c of clauses) {
+    const list = byAtom.get(c.atom);
+    if (list) list.push(c);
+    else byAtom.set(c.atom, [c]);
+  }
+  const conflicts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [atom, cs] of byAtom) {
+    for (let i = 0; i < cs.length; i += 1) {
+      for (let j = i + 1; j < cs.length; j += 1) {
+        const a = cs[i];
+        const b = cs[j];
+        const ia = pInterval(a.kind, a.freq);
+        const ib = pInterval(b.kind, b.freq);
+        const hard = disjointP(ia, ib);
+        const equal = !hard && subsetP(ia, ib) && subsetP(ib, ia);
+        const strong = hard || equal ? null : subsetP(ia, ib) ? a : subsetP(ib, ia) ? b : null;
+        if (!hard && strong === null) continue;
+        if (!guardsCollide(a.cond, b.cond)) continue;
+        const conflictLines = [.../* @__PURE__ */ new Set([a.line, b.line])].sort((x, y) => x - y);
+        const key = `${hard ? "hard" : "strength"}|${atom}|${conflictLines.join(",")}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const viaAntonym = a.viaAntonym || b.viaAntonym;
+        if (hard) {
+          const o = a.kind === "obligate" ? a : b;
+          const p2 = o === a ? b : a;
+          const name = o.canonical || p2.canonical ? o.display === p2.display ? o.display : `${o.display}" vs "${p2.display}` : atom;
+          conflicts.push({
+            atom,
+            lines: conflictLines,
+            viaAntonym,
+            message: a.freq === "all" && b.freq === "all" ? `Logical conflict \u2014 "${name}" is both required and forbidden. Keep one, or scope the two rules so they cannot both apply (IF <condition> THEN ...).` : `Frequency conflict \u2014 "${name}" is ${freqPhrase(o)} but ${freqPhrase(p2)}. The occasions cannot both hold.`
+          });
+        } else if (strong !== null) {
+          const weak = strong === a ? b : a;
+          conflicts.push({
+            atom,
+            lines: conflictLines,
+            viaAntonym,
+            strength: true,
+            message: `One rule, two strengths \u2014 "${strong.display}" (${freqPhrase(strong)}) already entails "${weak.display}" (${freqPhrase(weak)}); a model may read the weaker as "not always". Keep the stronger line.`
+          });
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function checkRedundancy(lines, addressees) {
+  const tools = toolsFromLines(lines);
+  const exempt = proseExemptLines(lines);
+  const clauses = [];
+  lines.forEach((l, i) => clauses.push(...extractClauses(l, i, tools, exempt, addressees)));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const c of clauses) {
+    const key = `${c.kind}|${c.freq}|${c.atom}`;
+    const list = byKey.get(key);
+    if (list) list.push(c);
+    else byKey.set(key, [c]);
+  }
+  const groups = [];
+  for (const cs of byKey.values()) {
+    if (cs.length < 2) continue;
+    const used = new Array(cs.length).fill(false);
+    for (let a = 0; a < cs.length; a += 1) {
+      const ca = cs[a];
+      if (used[a] || !ca) continue;
+      used[a] = true;
+      const cluster = [ca];
+      for (let b = a + 1; b < cs.length; b += 1) {
+        const cb = cs[b];
+        if (used[b] || !cb) continue;
+        if (implies(ca.cond, cb.cond) && implies(cb.cond, ca.cond)) {
+          used[b] = true;
+          cluster.push(cb);
+        }
+      }
+      const distinct = [...new Set(cluster.map((c) => c.line))].sort((x, y) => x - y);
+      if (distinct.length >= 2) groups.push({ atom: ca.canonical ? ca.display : ca.atom, display: ca.display, kind: ca.kind, lines: distinct });
+    }
+  }
+  return groups;
+}
+function checkSubsumption(lines, addressees) {
+  const tools = toolsFromLines(lines);
+  const exempt = proseExemptLines(lines);
+  const clauses = [];
+  lines.forEach((l, i) => clauses.push(...extractClauses(l, i, tools, exempt, addressees)));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const c of clauses) {
+    const key = `${c.kind}|${c.freq}|${c.atom}`;
+    const list = byKey.get(key);
+    if (list) list.push(c);
+    else byKey.set(key, [c]);
+  }
+  const out = [];
+  const reported = /* @__PURE__ */ new Set();
+  for (const cs of byKey.values()) {
+    if (cs.length < 2) continue;
+    for (const x of cs) {
+      if (reported.has(x.line)) continue;
+      const cover = cs.find((y) => y.line !== x.line && implies(x.cond, y.cond) && !implies(y.cond, x.cond));
+      if (!cover) continue;
+      reported.add(x.line);
+      out.push({ atom: x.canonical ? x.display : x.atom, kind: x.kind, redundantLine: x.line, coveringLine: cover.line });
+    }
+  }
+  return out;
+}
+function deadRules(rawLines) {
+  const dead = [];
+  rawLines.forEach((raw, i) => {
+    const g = splitGuard(maskQuotes(parseLine(raw).clause));
+    if (!g) return;
+    const cond = parseCondition(g.cond);
+    if (cond.t !== "true" && !satisfiable(cond)) dead.push(i);
+  });
+  return dead;
+}
+
+// src/core/order.ts
+function normNode(s) {
+  return s.trim().toLowerCase().replace(/^the\s+/, "").replace(/[.,;:!?]+$/, "").replace(/\s+/g, " ").trim();
+}
+var GREATER = /* @__PURE__ */ new Set([
+  "higher",
+  "greater",
+  "more",
+  "larger",
+  "bigger",
+  "better",
+  "faster",
+  "stronger",
+  "longer",
+  "taller",
+  "heavier",
+  "older",
+  "newer",
+  "hotter",
+  "harder",
+  "wider",
+  "broader",
+  "deeper"
+]);
+var LESSER = /* @__PURE__ */ new Set([
+  "lower",
+  "less",
+  "smaller",
+  "worse",
+  "slower",
+  "weaker",
+  "shorter",
+  "younger",
+  "lighter",
+  "narrower"
+]);
+function comparativeEdges(clauses) {
+  const byDim = /* @__PURE__ */ new Map();
+  for (const { clause, line } of clauses) {
+    const m = clause.match(/^(.+?)\s+(?:is|are|was|were)\s+(.+?)\s+than\s+(.+)$/i);
+    if (!m) continue;
+    const a = normNode(m[1] ?? "");
+    const b = normNode(m[3] ?? "");
+    if (!a || !b) continue;
+    const words = (m[2] ?? "").trim().toLowerCase().replace(/^(?:a|an|the)\s+/, "").split(/\s+/);
+    const dir = words[0] ?? "";
+    let edge = null;
+    if (GREATER.has(dir)) edge = { from: a, to: b, line };
+    else if (LESSER.has(dir)) edge = { from: b, to: a, line };
+    if (!edge) continue;
+    const key = words.slice(1).join(" ") || "_ord_";
+    if (!byDim.has(key)) byDim.set(key, []);
+    byDim.get(key)?.push(edge);
+  }
+  return byDim;
+}
+function timeValue(token) {
+  const named = token.trim().toLowerCase();
+  if (named === "noon" || named === "midday") return 12 * 60;
+  if (named === "midnight") return 0;
+  let m = token.match(/^(\d{1,2})(?::?(\d{2}))?\s*(am|pm)$/i);
+  if (m) {
+    let h = Number(m[1]) % 12;
+    if (/pm/i.test(m[3] ?? "")) h += 12;
+    return h * 60 + Number(m[2] || 0);
+  }
+  m = token.match(/^(\d{1,2}):(\d{2})$/);
+  if (m) return Number(m[1]) * 60 + Number(m[2]);
+  return null;
+}
+function stemEvent(node) {
+  const parts = node.split(" ");
+  const w = parts[0] ?? "";
+  if (w.length > 5 && w.endsWith("ing")) {
+    let base = w.slice(0, -3);
+    const last = base[base.length - 1] ?? "";
+    if (last !== "" && last === base[base.length - 2] && !"aeiou".includes(last)) base = base.slice(0, -1);
+    parts[0] = base;
+  }
+  return parts.join(" ");
+}
+function temporalEdges(clauses) {
+  const edges = [];
+  const points = /* @__PURE__ */ new Set();
+  for (const { clause, line } of clauses) {
+    const m = clause.match(/^(.+?)\s+(before|after|prior to|earlier than|later than)\s+(.+)$/i);
+    if (!m) continue;
+    const x = stemEvent(normNode(m[1] ?? ""));
+    const y = stemEvent(normNode(m[3] ?? ""));
+    if (!x || !y) continue;
+    const rel = (m[2] ?? "").toLowerCase();
+    const before = rel === "before" || rel === "prior to" || rel === "earlier than";
+    edges.push(before ? { from: x, to: y, line } : { from: y, to: x, line });
+    if (timeValue(x) !== null) points.add(x);
+    if (timeValue(y) !== null) points.add(y);
+  }
+  const sorted = [...points].map((p) => ({ p, v: timeValue(p) ?? 0 })).sort((m, n) => m.v - n.v);
+  for (let i = 0; i < sorted.length - 1; i += 1) {
+    const lo = sorted[i];
+    const hi = sorted[i + 1];
+    if (lo && hi && lo.v < hi.v) edges.push({ from: lo.p, to: hi.p, line: -1 });
+  }
+  return edges;
+}
+function findCycle(edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!adj.has(e.from)) adj.set(e.from, []);
+    adj.get(e.from)?.push({ to: e.to, line: e.line });
+  }
+  const color = /* @__PURE__ */ new Map();
+  const path = [];
+  const dfs = (u) => {
+    color.set(u, 1);
+    for (const { to, line } of adj.get(u) ?? []) {
+      path.push(line);
+      if (color.get(to) === 1) return [...new Set(path.filter((l) => l >= 0))].sort((m, n) => m - n);
+      if (!color.has(to)) {
+        const found = dfs(to);
+        if (found) return found;
+      }
+      path.pop();
+    }
+    color.set(u, 2);
+    return null;
+  };
+  for (const node of adj.keys()) {
+    if (!color.has(node)) {
+      path.length = 0;
+      const found = dfs(node);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function checkOrder(rawLines) {
+  const clauses = rawLines.map((raw, line) => ({ clause: maskQuotes(parseLine(raw).clause), line })).filter((c) => c.clause.trim() !== "");
+  const out = [];
+  for (const edges of comparativeEdges(clauses).values()) {
+    const cycle = findCycle(edges);
+    if (cycle && cycle.length > 0) {
+      out.push({ lines: cycle, message: "Logical conflict \u2014 these comparative claims (more/better/higher than) chain back onto themselves, so no consistent ranking exists. Remove or reverse one link of the loop." });
+    }
+  }
+  const temporal = findCycle(temporalEdges(clauses));
+  if (temporal && temporal.length > 0) {
+    out.push({ lines: temporal, message: "Logical conflict \u2014 these before/after claims chain back onto themselves, so no consistent timeline exists. Remove or reverse one link of the loop." });
+  }
+  return out;
+}
+
+// src/core/definiteness.ts
+var KIND_NOUN = { tool: "tool", section: "section", step: "step", variable: "variable", input: "variable", route: "route" };
+var kindLabel = { tool: "tool", section: "section", step: "step", variable: "variable", route: "route" };
+var DEF_BINDING = new RegExp(`\\bthe\\s+([a-z]+)\\s+(?:${copulaAlternation})\\s+([a-z][a-z0-9_-]*)\\b`, "i");
+function checkDefiniteness(rawLines) {
+  const ix = buildStructure(rawLines).index;
+  const registry = {
+    tool: ix.tools,
+    section: ix.sections,
+    step: ix.steps,
+    variable: ix.inputs,
+    route: ix.routes
+  };
+  const kinds = classifyLines(rawLines);
+  const litMask = examplesMask(rawLines);
+  const bindings = [];
+  let inFence = false;
+  rawLines.forEach((line, i) => {
+    const t = line.trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      inFence = !inFence;
+      return;
+    }
+    if (inFence || litMask[i] || kinds[i] === "comment" || isHeadingLine(line)) return;
+    const masked = maskQuotes(stripAnnotation(line)).replace(/\s+\/\/.*$/, (m2) => " ".repeat(m2.length));
+    const m = masked.match(DEF_BINDING);
+    if (!m) return;
+    const kind = KIND_NOUN[(m[1] ?? "").toLowerCase()];
+    if (!kind) return;
+    bindings.push({ kind, value: (m[2] ?? "").toLowerCase(), line: i });
+  });
+  const out = [];
+  const byKind = /* @__PURE__ */ new Map();
+  for (const b of bindings) byKind.set(b.kind, [...byKind.get(b.kind) ?? [], b]);
+  for (const [kind, bs] of byKind) {
+    const distinct = /* @__PURE__ */ new Map();
+    for (const b of bs) if (!distinct.has(b.value)) distinct.set(b.value, b.line);
+    const label = kindLabel[kind];
+    if (distinct.size >= 2) {
+      const vals = [...distinct.keys()].map((v) => `"${v}"`).join(", ");
+      out.push({
+        lines: [...distinct.values()].sort((a, b) => a - b),
+        code: "definite-ambiguous",
+        message: `Ambiguous definite reference \u2014 "the ${label}" is bound to ${distinct.size} different ${label}s (${vals}). A definite "the ${label}" names exactly one \u2014 say which.`
+      });
+    } else if (registry[kind].size === 0) {
+      const [line] = [...distinct.values()];
+      out.push({
+        lines: [line ?? bs[0]?.line ?? 0],
+        code: "definite-undeclared",
+        message: `Dangling definite reference \u2014 "the ${label}" names a ${label}, but no ${label} is declared. Declare it, or drop "the".`
+      });
+    }
+  }
+  return out;
+}
+
+// src/core/quantifier.ts
+var QUANT_CONTRARY_FIRES = true;
+var KIND_OF = new Map(QUANTIFIER_WORDS.flatMap((q) => q.words.map((w) => [w.toLowerCase(), q.kind])));
+var SUBJECT_QUANT_ALT = QUANTIFIER_WORDS.filter((q) => q.kind !== "exclusive").flatMap((q) => q.words).map((w) => w.toLowerCase()).join("|");
+var EXCLUSIVE_ALT = QUANTIFIER_WORDS.filter((q) => q.kind === "exclusive").flatMap((q) => q.words).map((w) => w.toLowerCase()).join("|");
+var EXCLUSIVE_RE = new RegExp(`^(?:${EXCLUSIVE_ALT})\\s+(.+)$`, "i");
+var SUBJECT_QUANT_RE = new RegExp(`^(${SUBJECT_QUANT_ALT})\\s+(?:of\\s+(?:the\\s+)?)?(\\w+)\\s+(.+)$`, "i");
+function corner(kind, negated) {
+  switch (kind) {
+    case "universal":
+      return negated ? "E" : "A";
+    case "negative":
+      return negated ? "A" : "E";
+    case "existential":
+      return negated ? "O" : "I";
+    case "majority":
+      return negated ? "M-" : "M+";
+    case "exclusive":
+      return null;
+  }
+}
+function opposes(a, b) {
+  const has = (x, y) => a === x && b === y || a === y && b === x;
+  if (has("A", "O") || has("E", "I")) return "hard";
+  if (has("M+", "M-") || has("M+", "E") || has("M-", "A")) return "hard";
+  if (has("A", "E")) return "contrary";
+  return null;
+}
+var normNoun = singularizeNoun;
+function bareProperty(rest) {
+  return rest.replace(/^(?:must(?:\s+be)?|should(?:\s+be)?|shall(?:\s+be)?|will(?:\s+be)?|is|are|be|gets?|always)\s+/i, "").trim();
+}
+function parseScope(rest) {
+  const strip = (s) => s.replace(/[.,;:!?]+$/, "").trim();
+  const neg = rest.match(/\b(?:is\s+not|are\s+not|was\s+not|were\s+not|isn't|wasn't|do\s+not|does\s+not|don't|must\s+not|should\s+not|never|not)\s+(.+)$/i);
+  if (neg) return { negated: true, text: strip(bareProperty(neg[1] ?? "")) };
+  return { negated: false, text: strip(bareProperty(rest)) };
+}
+function normMember(s) {
+  return s.toLowerCase().replace(/^(?:a|an|the)\s+/, "").replace(/[.,;:!?]+$/, "").replace(/\s+/g, " ").trim();
+}
+function disjoint(a, b, sets) {
+  const ma = normMember(a);
+  const mb = normMember(b);
+  return ma !== "" && mb !== "" && ma !== mb && sets.some((s) => s.has(ma) && s.has(mb));
+}
+var relationKey = (p) => `${p.head}(${p.theme ?? ""})`;
+function parseQuantified(clause, line, tools) {
+  let guard = TRUE;
+  let body = clause.trim();
+  const ifm = body.match(/^IF\b(.+?)\bTHEN\b(.+)$/i);
+  if (ifm) {
+    guard = parseCondition(ifm[1] ?? "");
+    body = (ifm[2] ?? "").trim();
+  }
+  const only = body.match(EXCLUSIVE_RE);
+  if (only) {
+    const p = parsePredicate(only[1] ?? "", tools);
+    if (!p || p.confidence !== "lexicon" || p.roles.goal === void 0) return null;
+    return { relation: relationKey(p), target: p.roles.goal, scopeText: (only[1] ?? "").replace(/[.,;:!?]+$/, "").trim(), guard, line };
+  }
+  const qm = body.match(SUBJECT_QUANT_RE);
+  const im = qm ? null : body.match(/^(this|that|the)\s+(\w+)\s+(.+)$/i);
+  const m = qm ?? im;
+  if (!m) return null;
+  const kind = qm ? KIND_OF.get((qm[1] ?? "").toLowerCase()) ?? "existential" : "existential";
+  const restrictor = normNoun(m[2] ?? "");
+  const { negated: surfaceNeg, text } = parseScope(m[3] ?? "");
+  if (text === "") return null;
+  const { key, parsed } = canonicalActionKey(text, tools);
+  const polarityNeg = parsed?.confidence === "lexicon" && parsed.lexicalPolarity === -1;
+  const negated = surfaceNeg !== polarityNeg;
+  return { det: (m[1] ?? "").toLowerCase(), kind, restrictor, scope: key, scopeText: text, parsed, negated, corner: corner(kind, negated), guard, line };
+}
+var isExclusive = (x) => "relation" in x;
+function describe(c) {
+  const q = c.det === "this" || c.det === "that" || c.det === "the" ? `this ${c.restrictor}` : `${c.det} ${c.restrictor}`;
+  return `${q} is ${c.negated ? "not " : ""}"${c.scopeText}"`;
+}
+function parseCardinal(clause, line) {
+  const g = splitGuard(clause.trim());
+  const guard = g ? parseCondition(g.cond) : TRUE;
+  const body = g ? g.body : clause.trim();
+  const bound = parseCardinalBody(body);
+  return bound === null ? null : { ...bound, guard, line };
+}
+function collectActionCounts(clause, line) {
+  const out = [];
+  for (const sentence of splitSentences(clause).map((x) => x.text.trim()).filter((x) => x !== "")) {
+    if (/\bOTHERWISE\b/i.test(sentence)) continue;
+    const g = splitGuard(sentence);
+    const guard = g ? parseCondition(g.cond) : TRUE;
+    const body = g ? g.body : sentence;
+    for (const seg of body.split(/[;,]/)) {
+      const t = seg.trim().replace(/^then\s+/i, "");
+      if (t === "") continue;
+      const lead = stripDeonticLead(t, { peelSubject: true });
+      if (lead.prohibited) continue;
+      const ac = parseActionCount(lead.body);
+      if (ac) out.push({ ...ac, guard, line, subject: lead.subject });
+    }
+  }
+  return out;
+}
+function parseAll(rawLines) {
+  const exempt = proseExemptLines(rawLines);
+  const tools = /* @__PURE__ */ new Set();
+  const clauses = [];
+  const exclusives = [];
+  const cardinals = [];
+  const actions = [];
+  rawLines.forEach((raw, line) => {
+    if (exempt.has(line)) return;
+    const clause = maskQuotes(parseLine(raw).clause).trim();
+    if (clause === "") return;
+    actions.push(...collectActionCounts(clause, line));
+    const card = parseCardinal(clause, line);
+    if (card) {
+      cardinals.push(card);
+      return;
+    }
+    const parsed = parseQuantified(clause, line, tools);
+    if (!parsed) return;
+    if (isExclusive(parsed)) exclusives.push(parsed);
+    else clauses.push(parsed);
+  });
+  return { clauses, exclusives, cardinals, actions };
+}
+function collectQuantified(rawLines) {
+  return parseAll(rawLines).clauses;
+}
+function checkQuantifier(rawLines) {
+  const parsed = parseAll(rawLines);
+  const { clauses, exclusives } = parsed;
+  const addr = addresseeSubjects(rawLines);
+  const foldSubject = (sub) => sub !== "you" && addr.has(sub) ? "you" : sub;
+  const actions = parsed.actions.map((a) => ({ ...a, subject: foldSubject(a.subject) }));
+  const cardinals = parsed.cardinals.map((c) => c.owner === void 0 ? c : { ...c, owner: foldSubject(c.owner) });
+  for (const [key, obj] of collectObjects(rawLines)) {
+    const members = obj.listMembers ?? [];
+    if (members.length === 0) continue;
+    cardinals.push({
+      noun: singularizeNoun(key),
+      lo: members.length,
+      hi: Infinity,
+      text: `${key} INCLUDING ${members.join(", ")}`,
+      tail: "",
+      guard: TRUE,
+      line: obj.lines[0] ?? 0,
+      fromList: true
+    });
+  }
+  const exempt = proseExemptLines(rawLines);
+  const tools = /* @__PURE__ */ new Set();
+  const disjointSets = [];
+  for (const raw of rawLines) {
+    const e = findEnumDeclaration(raw);
+    if (e) disjointSets.push(new Set(e.members.map(normMember).filter((x) => x !== "")));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < clauses.length; i += 1) {
+    for (let j = i + 1; j < clauses.length; j += 1) {
+      const a = clauses[i];
+      const b = clauses[j];
+      if (a.restrictor !== b.restrictor || a.corner === null || b.corner === null) continue;
+      if (!guardsCollide(a.guard, b.guard)) continue;
+      let rel = null;
+      if (a.scope === b.scope) {
+        rel = opposes(a.corner, b.corner);
+      } else if (disjoint(a.scopeText, b.scopeText, disjointSets)) {
+        const reframe = (c) => c === "A" ? "E" : c === "I" ? "O" : null;
+        const rb = reframe(b.corner);
+        const ra = reframe(a.corner);
+        rel = rb && opposes(a.corner, rb) || ra && opposes(b.corner, ra) || null;
+      }
+      const demonstrative = (c) => c.det === "this" || c.det === "that" || c.det === "the";
+      const subaltern = (x, y) => x === "A" && y === "I" || x === "E" && y === "O";
+      if (rel === null && a.scope === b.scope && !demonstrative(a) && !demonstrative(b) && (subaltern(a.corner, b.corner) || subaltern(b.corner, a.corner))) {
+        const strong = a.corner === "A" || a.corner === "E" ? a : b;
+        const weak = strong === a ? b : a;
+        const lines2 = [.../* @__PURE__ */ new Set([a.line, b.line])].sort((x, y) => x - y);
+        const dedupe2 = `strength|${lines2.join(",")}`;
+        if (seen.has(dedupe2)) continue;
+        seen.add(dedupe2);
+        const exception = strong.corner === "A" ? `Some ${weak.restrictor}s are not ${weak.scopeText}.` : `Some ${weak.restrictor}s are ${weak.scopeText}.`;
+        out.push({
+          lines: lines2,
+          kind: "strength",
+          message: `One quantity per fact \u2014 ${describe(strong)} already entails ${describe(weak)}, so this fact carries two strengths (a model may read the weaker "some" as "not all"). Keep the stronger line, or state the exception you meant: "${exception}".`
+        });
+        continue;
+      }
+      if (rel !== "hard" && !(rel === "contrary" && QUANT_CONTRARY_FIRES)) continue;
+      const lines = [.../* @__PURE__ */ new Set([a.line, b.line])].sort((x, y) => x - y);
+      const dedupe = lines.join(",");
+      if (seen.has(dedupe)) continue;
+      seen.add(dedupe);
+      const majority = a.corner.startsWith("M") || b.corner.startsWith("M");
+      const proof = rel === "contrary" ? cardinals.find((c) => c.owner === void 0 && c.tail === "" && c.lo >= 1 && (c.noun === a.restrictor || pluralizeNoun(c.noun) === a.restrictor || c.noun === singularizeNoun(a.restrictor))) : void 0;
+      out.push({
+        lines,
+        kind: majority ? "majority" : "opposition",
+        message: majority ? `Majority conflict \u2014 ${describe(a)} and ${describe(b)} can't both hold; each needs over half of "${a.restrictor}".` : `Quantifier conflict \u2014 ${describe(a)}, but ${describe(b)}. Both cannot hold${proof !== void 0 ? ` \u2014 and "${proof.text}" proves the set is nonempty` : ""}.`
+      });
+    }
+  }
+  for (let i = 0; i < cardinals.length; i += 1) {
+    for (let j = i + 1; j < cardinals.length; j += 1) {
+      const a = cardinals[i];
+      const b = cardinals[j];
+      if (a.noun !== b.noun || (a.owner ?? "") !== (b.owner ?? "") || a.tail !== b.tail) continue;
+      if (!guardsCollide(a.guard, b.guard)) continue;
+      const lines = [.../* @__PURE__ */ new Set([a.line, b.line])].sort((x, y) => x - y);
+      const setName = `${pluralizeNoun(a.noun)}${a.tail !== "" ? ` ${a.tail}` : ""}`;
+      if (Math.max(a.lo, b.lo) <= Math.min(a.hi, b.hi)) {
+        const inside = (x, y) => y.lo <= x.lo && x.hi <= y.hi;
+        const counted = (x) => x.fromList !== true && x.phrase !== "a" && x.phrase !== "an";
+        if (!counted(a) || !counted(b)) continue;
+        if (a.lo === b.lo && a.hi === b.hi) continue;
+        if (!inside(a, b) && !inside(b, a)) continue;
+        const strong = inside(a, b) ? a : b;
+        const weak = strong === a ? b : a;
+        const dedupe2 = `cardstrength|${lines.join(",")}`;
+        if (seen.has(dedupe2)) continue;
+        seen.add(dedupe2);
+        out.push({
+          lines,
+          kind: "strength",
+          message: `One count per set \u2014 "${strong.text}" (${boundText(strong.lo, strong.hi)}) already entails "${weak.text}" (${boundText(weak.lo, weak.hi)}): two strengths for "${setName}". Keep the stronger claim.`
+        });
+        continue;
+      }
+      const dedupe = `card|${lines.join(",")}`;
+      if (seen.has(dedupe)) continue;
+      seen.add(dedupe);
+      const list = a.fromList === true ? a : b.fromList === true ? b : null;
+      const stated = list === a ? b : a;
+      out.push({
+        lines,
+        kind: "cardinality",
+        message: list !== null ? `The list disproves the count \u2014 "${list.text}" names ${list.lo} member${list.lo === 1 ? "" : "s"}, but "${stated.text}" bounds "${setName}" to ${boundText(stated.lo, stated.hi)}.` : `Cardinality conflict \u2014 "${a.text}" (${boundText(a.lo, a.hi)}) but "${b.text}" (${boundText(b.lo, b.hi)}). The counts cannot both hold \u2014 state how many "${setName}" ${a.owner !== void 0 ? `"${a.owner}" has` : "there are"} once.`
+      });
+    }
+  }
+  const orderedStep = /* @__PURE__ */ new Set();
+  rawLines.forEach((raw, i) => {
+    if (/^\s*\d+(?:\.\d+)*[.)]\s/.test(raw)) orderedStep.add(i);
+  });
+  for (let i = 0; i < actions.length; i += 1) {
+    for (let j = i + 1; j < actions.length; j += 1) {
+      const a = actions[i];
+      const b = actions[j];
+      if (a.line === b.line) continue;
+      if (orderedStep.has(a.line) && orderedStep.has(b.line)) continue;
+      if (a.verb !== b.verb || a.noun !== b.noun || a.tail !== b.tail) continue;
+      if (a.subject !== b.subject) continue;
+      if (a.lo === b.lo && a.hi === b.hi) continue;
+      if (!guardsCollide(a.guard, b.guard)) continue;
+      const lines = [.../* @__PURE__ */ new Set([a.line, b.line])].sort((x, y) => x - y);
+      const dedupe = `act|${lines.join(",")}|${a.verb}|${a.noun}`;
+      if (seen.has(dedupe)) continue;
+      seen.add(dedupe);
+      const slot = `${a.verb} ${pluralizeNoun(a.noun)}${a.tail !== "" ? ` ${a.tail}` : ""}`;
+      out.push({
+        lines,
+        kind: "action-count",
+        message: `One action, two counts \u2014 "${a.text}" but "${b.text}". A directive carries ONE count for "${slot}" \u2014 state how many once.`
+      });
+    }
+  }
+  for (const supply of cardinals) {
+    if (supply.owner !== void 0 || supply.hi === Infinity) continue;
+    for (const demand of actions) {
+      if (supply.noun !== demand.noun || supply.tail !== demand.tail) continue;
+      if (demand.lo <= supply.hi) continue;
+      if (!guardsCollide(supply.guard, demand.guard)) continue;
+      const lines = [.../* @__PURE__ */ new Set([supply.line, demand.line])].sort((x, y) => x - y);
+      const dedupe = `sup|${lines.join(",")}|${demand.verb}|${demand.noun}`;
+      if (seen.has(dedupe)) continue;
+      seen.add(dedupe);
+      out.push({
+        lines,
+        kind: "insufficient-set",
+        message: `The set cannot cover the directive \u2014 "${demand.text}" needs ${demand.lo} ${pluralizeNoun(demand.noun)}, but "${supply.text}" bounds the set to ${boundText(supply.lo, supply.hi)}. Raise the count or shrink the demand.`
+      });
+    }
+  }
+  for (const ex of exclusives) {
+    if (!guardsCollide(ex.guard, TRUE)) continue;
+    rawLines.forEach((raw, line) => {
+      if (exempt.has(line) || line === ex.line) return;
+      const clause = maskQuotes(parseLine(raw).clause).trim();
+      const only = clause.match(EXCLUSIVE_RE);
+      const p = parsePredicate(only ? only[1] ?? "" : clause, tools);
+      if (!p || p.confidence !== "lexicon" || relationKey(p) !== ex.relation) return;
+      const goal = p.roles.goal;
+      if (goal === void 0 || goal === ex.target) return;
+      const lines = [ex.line, line].sort((x, y) => x - y);
+      const key = `only|${lines.join(",")}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      out.push({ lines, kind: "exclusivity", message: `Exclusivity violation \u2014 "only ${ex.scopeText}" closes this to "${ex.target}", but "${goal}" is added. Drop one, or remove "only".` });
+    });
+  }
+  return out;
+}
+function checkSyllogism(rawLines) {
+  const clauses = collectQuantified(rawLines).filter((c) => (c.corner === "A" || c.corner === "E") && c.guard.t === "true");
+  const setKey = (s) => s.toLowerCase().replace(/^(?:a|an|the)\s+/, "").replace(/s$/, "").trim();
+  const subsetEdges = [];
+  const disjointEdges = [];
+  for (const c of clauses) {
+    const s = setKey(c.restrictor);
+    const p = setKey(c.scope);
+    if (s === p || s === "" || p === "") continue;
+    if (c.corner === "A") subsetEdges.push({ s, p, line: c.line });
+    else disjointEdges.push({ x: s, y: p, line: c.line });
+  }
+  if (subsetEdges.length === 0 || disjointEdges.length === 0) return [];
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of subsetEdges) adj.set(e.s, [...adj.get(e.s) ?? [], { to: e.p, line: e.line }]);
+  const pathsFrom = (src) => {
+    const seen = /* @__PURE__ */ new Map([[src, []]]);
+    const q = [src];
+    while (q.length > 0) {
+      const n = q.shift();
+      for (const e of adj.get(n) ?? []) {
+        if (!seen.has(e.to)) {
+          seen.set(e.to, [...seen.get(n) ?? [], e.line]);
+          q.push(e.to);
+        }
+      }
+    }
+    return seen;
+  };
+  const witnesses = /* @__PURE__ */ new Set([...subsetEdges.map((e) => e.s), ...disjointEdges.flatMap((d) => [d.x, d.y])]);
+  const out = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const d of disjointEdges) {
+    for (const w of witnesses) {
+      const reach = pathsFrom(w);
+      const px = reach.get(d.x);
+      const py = reach.get(d.y);
+      if (!px || !py) continue;
+      const lines = [.../* @__PURE__ */ new Set([...px, ...py, d.line])].sort((a, b) => a - b);
+      if (lines.length < 3) continue;
+      const key = lines.join(",");
+      if (emitted.has(key)) continue;
+      emitted.add(key);
+      out.push({ lines, message: `Contradictory chain \u2014 the rules on these lines force an overlap between "${d.x}" and "${d.y}", which they also declare mutually exclusive. Relax one rule.` });
+    }
+  }
+  return out;
+}
+
+// src/core/security.ts
+var SECRET_PATTERNS = [
+  { re: /\bsk-ant-[A-Za-z0-9_-]{16,}/g, what: "Anthropic API key", severity: "error" },
+  { re: /\bsk-(?!ant-)[A-Za-z0-9]{20,}/g, what: "OpenAI-style API key", severity: "error" },
+  { re: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g, what: "GitHub token", severity: "error" },
+  { re: /\bgithub_pat_[A-Za-z0-9_]{20,}/g, what: "GitHub fine-grained token", severity: "error" },
+  { re: /\bAKIA[0-9A-Z]{16}\b/g, what: "AWS access key id", severity: "error" },
+  { re: /\bxox[baprs]-[A-Za-z0-9-]{10,}/g, what: "Slack token", severity: "error" },
+  { re: /\bAIza[0-9A-Za-z_-]{30,}/g, what: "Google API key", severity: "error" },
+  { re: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}/g, what: "Stripe key", severity: "error" },
+  { re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g, what: "private key material", severity: "error" },
+  { re: /\bBearer\s+[A-Za-z0-9_\-.=+/]{25,}/g, what: "bearer token", severity: "error" },
+  // Generic assignment (`api_key: …`, `password=…`) — warn: precise enough to surface, but a
+  // documented config shape can look identical, so it never gates on its own.
+  {
+    re: /\b(?:api[_-]?key|apikey|secret|passwd|password|auth[_-]?token|access[_-]?token)\s*[:=]\s*['"]?([A-Za-z0-9_\-.+/]{12,})/gi,
+    what: "credential assignment",
+    severity: "warn"
+  }
+];
+var PLACEHOLDER = /\{|\$|<|\bYOUR[_-]|\bEXAMPLE\b|X{4,}|\*{3,}|\.\.\./i;
+function leakedSecrets(line, i) {
+  const out = [];
+  for (const p of SECRET_PATTERNS) {
+    p.re.lastIndex = 0;
+    let m;
+    while ((m = p.re.exec(line)) !== null) {
+      const value = m[1] ?? m[0];
+      if (PLACEHOLDER.test(value)) continue;
+      out.push({
+        source: "security/leaked-secret",
+        severity: p.severity,
+        line: i,
+        start: m.index,
+        end: m.index + m[0].length,
+        message: `Leaked secret \u2014 this looks like a real ${p.what}. Remove it and rotate the credential; reference it as a {variable} instead.`
+      });
+    }
+  }
+  return out;
+}
+var INJECTION_PATTERNS = [
+  {
+    re: /\b(?:ignore|disregard|forget)\s+(?:all\s+|any\s+)?(?:previous|prior|above|earlier)\s+(?:instructions?|prompts?|rules?|messages?)/gi,
+    what: "instruction-override phrasing"
+  },
+  { re: /\byou\s+are\s+now\s+(?:DAN|jailbroken|unrestricted)\b/gi, what: "role-hijack phrasing" },
+  { re: /\b(?:pretend|act)\s+(?:that\s+)?you\s+have\s+no\s+(?:restrictions|guidelines|rules)\b/gi, what: "restriction-bypass phrasing" },
+  { re: /\bdo\s+anything\s+now\b/gi, what: "DAN-style phrasing" }
+];
+function injectionPatterns(line, i) {
+  const masked = maskQuotes(line);
+  const out = [];
+  for (const p of INJECTION_PATTERNS) {
+    p.re.lastIndex = 0;
+    let m;
+    while ((m = p.re.exec(masked)) !== null) {
+      out.push({
+        source: "security/injection",
+        severity: "warn",
+        line: i,
+        start: m.index,
+        end: m.index + m[0].length,
+        message: `Injection pattern \u2014 "${m[0]}" is ${p.what}. If this is a rule ABOUT such phrases, quote the phrase to mark it literal.`
+      });
+    }
+  }
+  return out;
+}
+
+// src/core/coverage.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "to",
+  "of",
+  "for",
+  "and",
+  "or",
+  "not",
+  "is",
+  "are",
+  "be",
+  "you",
+  "your",
+  "it",
+  "that",
+  "this",
+  "with",
+  "in",
+  "on",
+  "at",
+  "by",
+  "do",
+  "does",
+  "must",
+  "never",
+  "always",
+  "should",
+  "may",
+  "every",
+  "any",
+  "all",
+  "when",
+  "if",
+  "then",
+  "than",
+  "as",
+  "so",
+  "no",
+  "yes"
+]);
+function tokens(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const w of text.toLowerCase().match(/[a-z][a-z'-]{2,}/g) ?? []) {
+    const t = w.replace(/'s$/, "").replace(/s$/, "");
+    if (!STOP.has(w) && !STOP.has(t) && t.length >= 3) out.add(t);
+  }
+  return out;
+}
+function caseTokens(suite, id) {
+  const parts = [];
+  const tc = suite.testCases.find((c) => c.id === id);
+  if (tc) parts.push(tc.input, tc.expectation ?? "");
+  for (const a of suite.asserts[id] ?? []) {
+    if (a.kind === "contains") parts.push(a.value);
+    else if (a.kind === "matches") parts.push(a.source.replace(/\\[a-z]/gi, " "));
+    else if (a.kind === "atMost" || a.kind === "atLeast") parts.push(a.unit);
+  }
+  return tokens(parts.join(" "));
+}
+function sameWord(a, b) {
+  if (a === b) return true;
+  return a.length >= 4 && b.length >= 4 && (a.startsWith(b) || b.startsWith(a));
+}
+function hasWord(toks, word) {
+  for (const t of toks) if (sameWord(t, word)) return true;
+  return false;
+}
+function linked(rule, caseToks) {
+  const head = rule.predicate?.head;
+  const theme = rule.predicate?.theme;
+  const themeToks = theme ? tokens(theme) : /* @__PURE__ */ new Set();
+  if (head && hasWord(caseToks, head)) return true;
+  for (const t of themeToks) if (hasWord(caseToks, t)) return true;
+  const ruleToks = tokens(rule.action.text);
+  let shared = 0;
+  for (const t of ruleToks) if (hasWord(caseToks, t)) shared += 1;
+  return shared >= 2;
+}
+function ruleCoverage(ir, suite) {
+  const hard = ir.nodes.filter(
+    (n) => n.kind === "directive" && (n.deontic === "obligate" || n.deontic === "prohibit")
+  );
+  const tokensByCase = new Map(suite.testCases.map((c) => [c.id, caseTokens(suite, c.id)]));
+  const perRule = hard.map((rule) => {
+    const cases = [...tokensByCase.entries()].filter(([, toks]) => linked(rule, toks)).map(([id]) => id);
+    return { line: rule.line, action: rule.action.text, covered: cases.length > 0, cases };
+  });
+  const coveredRate = hard.length === 0 ? 1 : perRule.filter((r) => r.covered).length / hard.length;
+  return { perRule, coveredRate };
+}
+
+// src/core/diagnostics.ts
+var SEV_RANK = { info: 1, warn: 2, error: 3 };
+var WORDY = [
+  { re: /\bin order to\b/gi, to: "to" },
+  { re: /\bdue to the fact that\b/gi, to: "because" },
+  { re: /\bat this point in time\b/gi, to: "now" },
+  { re: /\bin the event that\b/gi, to: "if" },
+  { re: /\bfor the purpose of\b/gi, to: "to" },
+  { re: /\bwith regard to\b/gi, to: "about" },
+  { re: /\ba large number of\b/gi, to: "many" },
+  { re: /\bin spite of the fact that\b/gi, to: "although" }
+];
+function wordy(line, i) {
+  const out = [];
+  for (const w of WORDY) {
+    w.re.lastIndex = 0;
+    let m;
+    while ((m = w.re.exec(line)) !== null) {
+      out.push({
+        source: "style/wordy",
+        severity: "info",
+        line: i,
+        start: m.index,
+        end: m.index + m[0].length,
+        message: `Wordy \u2014 "${m[0]}" can be "${w.to}".`,
+        fix: { title: `\u2192 "${w.to}"`, replacement: w.to }
+      });
+    }
+  }
+  return out;
+}
+var WHOLE_LINE_QUOTE = /^\s*"([^"]*)"\s*$/;
+function quotedProse(line, i) {
+  const m = line.match(WHOLE_LINE_QUOTE);
+  if (m === null) return [];
+  const start = line.indexOf('"');
+  return [
+    {
+      source: "style/quoted-prose",
+      severity: "warn",
+      line: i,
+      start,
+      end: line.lastIndexOf('"') + 1,
+      message: 'A whole-line quote hides this statement from the checker \u2014 reserve "\u2026" for exact words to say (an utterance after a speech verb, or a sample in <examples>). Unquote it: a plain statement renders and stays checkable.',
+      fix: { title: "Unquote", replacement: m[1] ?? "" }
+    }
+  ];
+}
+var TERMINATED = /[.!?:]["')\]]*\s*$/;
+function unterminated(line, i, end) {
+  const start = Math.max(0, Math.min(line.length - line.trimStart().length, end - 1));
+  return {
+    source: "structure/missing-period",
+    severity: "error",
+    line: i,
+    start,
+    end,
+    message: 'Unterminated statement \u2014 end it with a period (or ! ?; a lead-in may end with ":"). Statement boundaries are a compile contract.',
+    fix: { title: 'Add "."', replacement: `${line.slice(start, end)}.` }
+  };
+}
+function missingPeriod(line, i) {
+  const stmt = stripInlineComment(line);
+  const end = stmt.trimEnd().length;
+  if (end === 0 || TERMINATED.test(stmt)) return [];
+  if (TRANSCLUSION_LINE_RE.test(stmt)) return [];
+  return [unterminated(line, i, end)];
+}
+function missingPeriodLiteral(line, i) {
+  const end = line.trimEnd().length;
+  if (end === 0 || TERMINATED.test(line)) return [];
+  return [unterminated(line, i, end)];
+}
+function oneOfColon(line, i) {
+  const masked = maskQuotes(stripInlineComment(line));
+  const m = /\bone\s+of\s*:(?=\s*\S)/i.exec(masked);
+  if (!m) return [];
+  const start = m.index;
+  const end = m.index + m[0].length;
+  return [
+    {
+      source: "structure/one-of-colon",
+      severity: "error",
+      line: i,
+      start,
+      end,
+      message: `"one of" never takes a colon \u2014 the quantifier is the same everywhere (declarations, domains, tool types, conditions). Write "${line.slice(start, end - 1).trimEnd()} ${line.slice(end).trimStart().split(",")[0] ?? ""}, \u2026" \u2014 just drop the ":".`,
+      fix: { title: 'Drop ":"', replacement: line.slice(start, end - 1).trimEnd() }
+    }
+  ];
+}
+function inlineMarker(line, i) {
+  const text = maskQuotes(stripAnnotation(stripInlineComment(line)));
+  const head = line.match(DEF_ENTRY);
+  const scanStart = head ? (head[1] ?? "").length + (head[2] ?? "").length + (head[3] ?? "").length + 2 : 0;
+  const out = [];
+  for (const m of text.matchAll(/:{2,}/g)) {
+    const ci = m.index ?? 0;
+    if (ci < scanStart) continue;
+    let s = ci;
+    let e = ci + m[0].length;
+    while (s > 0 && /[A-Za-z0-9_?-]/.test(line[s - 1] ?? "")) s -= 1;
+    while (e < line.length && /[A-Za-z0-9_?-]/.test(line[e] ?? "")) e += 1;
+    const sample = line.slice(s, e);
+    out.push({
+      source: "structure/inline-marker",
+      severity: "error",
+      line: i,
+      start: s,
+      end: e,
+      message: `"::" opens a definition at a line head \u2014 here it is inline. Give the second object its own "- " bullet (a sub-definition), or quote "${sample}" as a sample.`,
+      fix: { title: `Quote "${sample}"`, replacement: `"${sample}"` }
+    });
+  }
+  return out;
+}
+function specialCharacters(line, i) {
+  const text = maskQuotes(stripAnnotation(stripInlineComment(line)));
+  if (!SPECIAL_ANY.test(text)) return [];
+  const out = [];
+  const claimed = new Array(text.length).fill(false);
+  for (const p of CHARSET_RULES) {
+    for (const m of text.matchAll(p.re)) {
+      const s = m.index ?? 0;
+      const e = s + m[0].length;
+      if (e === s) continue;
+      let clash = false;
+      for (let k = s; k < e; k += 1) if (claimed[k]) clash = true;
+      if (clash) continue;
+      for (let k = s; k < e; k += 1) claimed[k] = true;
+      const fix = p.fix ? p.fix(m, text) : null;
+      out.push({
+        source: p.source,
+        severity: "error",
+        line: i,
+        start: s,
+        end: e,
+        message: p.msg,
+        ...fix ? { fix } : {}
+      });
+    }
+  }
+  return out;
+}
+var TRAILING_WS = /[ \t]+$/;
+function trailingSpace(line, i) {
+  const m = line.match(TRAILING_WS);
+  if (!m || m.index === void 0 || line.trim() === "") return [];
+  return [
+    {
+      source: "structure/trailing-space",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: line.length,
+      message: "Trailing whitespace: invisible noise every diff and every token count carries. Strip it.",
+      fix: { title: "Strip", replacement: "" }
+    }
+  ];
+}
+function tabCharacters(line, i) {
+  const out = [];
+  for (let k = line.indexOf("	"); k !== -1; k = line.indexOf("	", k + 1)) {
+    out.push({
+      source: "structure/tab",
+      severity: "error",
+      line: i,
+      start: k,
+      end: k + 1,
+      message: "Tab character: the indent unit is 2 spaces \u2014 a tab is an invisible, variable-width impostor.",
+      fix: { title: "\u2192 spaces", replacement: "  " }
+    });
+  }
+  return out;
+}
+var PHANTOM_RUN = /(?<=\S) {2,}(?=\S)/g;
+function phantomColumns(line, i, literalBody) {
+  const masked = maskQuotes(line);
+  const cut = literalBody ? masked.length : stripAnnotation(stripInlineComment(line)).trimEnd().length;
+  const out = [];
+  for (const m of masked.matchAll(PHANTOM_RUN)) {
+    const s = m.index ?? 0;
+    if (s > cut) continue;
+    out.push({
+      source: "structure/phantom-column",
+      severity: "error",
+      line: i,
+      start: s,
+      end: s + m[0].length,
+      message: `Phantom column: a space run doing alignment's job. One space between things \u2014 commentary belongs in a // comment, layout tables in a fence or <"name"> zone.`,
+      fix: { title: "\u2192 one space", replacement: " " }
+    });
+  }
+  return out;
+}
+var HEDGES = /\b(try to|tries to|try your best to|do your best to|should probably|might want to|you may want to|it would be good to|it might be good to|if possible|when possible|where possible|as much as possible|attempt to|attempts to|strive to|aim to|feel free to|ideally|maybe|perhaps|kind of|sort of)\b/gi;
+function hedging(line, i) {
+  const out = [];
+  HEDGES.lastIndex = 0;
+  let m;
+  while ((m = HEDGES.exec(line)) !== null) {
+    out.push({
+      source: "prompt/hedging",
+      severity: "info",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `Hedging \u2014 "${m[0]}" turns this instruction into a suggestion the model may skip. Delete the hedge, or commit to a modal (${MODAL_HINT}).`
+    });
+  }
+  return out;
+}
+var VAGUE = /\b(appropriately|appropriate|as needed|as appropriate|as necessary|as required|if needed|if necessary|if applicable|when necessary|when appropriate|where appropriate|in a timely manner|properly|reasonable|relevant|somehow|various|etc\.?|and so on|and so forth)\b/gi;
+function vague(line, i) {
+  const out = [];
+  VAGUE.lastIndex = 0;
+  let m;
+  while ((m = VAGUE.exec(line)) !== null) {
+    out.push({
+      source: "prompt/vague",
+      severity: "info",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `Vague \u2014 "${m[0]}" names a judgment call without the criterion to judge by, so nothing can check it. Replace it with a measurable form ("at most 3 sentences", "within 24 hours", "cite the source").`
+    });
+  }
+  return out;
+}
+function wrappedFragments(rawLines, disp = (i) => i + 1) {
+  const out = [];
+  for (const [i, before] of wrappedContinuations(rawLines)) {
+    const raw = rawLines[i] ?? "";
+    const lead = raw.length - raw.trimStart().length;
+    const body = raw.slice(lead);
+    const capitalized = body.replace(/[a-z]/, (c) => c.toUpperCase());
+    out.push({
+      source: "structure/wrapped-fragment",
+      severity: "warn",
+      line: i,
+      start: lead,
+      end: raw.length,
+      message: `Reads as a hard-wrapped continuation of line ${disp(before)} \u2014 it starts lowercase, classifies as plain prose, and line ${disp(before)} has no terminator. If they are ONE statement, join them (tg fmt --join); if this line stands alone, capitalize its first word (and terminate line ${disp(before)}).`,
+      ...capitalized !== body ? { fix: { title: "Capitalize", replacement: capitalized } } : {}
+    });
+  }
+  return out;
+}
+var QUALITY_ACTION = /^(?:be|being|stay|remain|sound|seem|appear|act|feel)\b/i;
+function unmeasurableDirectives(rawLines, exempt) {
+  const out = [];
+  const flagged = /* @__PURE__ */ new Set();
+  const doc = buildStructure(rawLines);
+  for (const node of lower(rawLines.join("\n"), { tools: doc.index.tools }).nodes) {
+    if (node.kind !== "directive") continue;
+    if (node.deontic !== "obligate" && node.deontic !== "prohibit") continue;
+    if (node.predicate !== null || node.numeric !== null) continue;
+    if (!QUALITY_ACTION.test(node.action.text.trim())) continue;
+    if (exempt.has(node.line) || flagged.has(node.line)) continue;
+    flagged.add(node.line);
+    out.push({
+      source: "prompt/unmeasurable",
+      severity: "warn",
+      line: node.line,
+      start: node.span.start,
+      end: node.span.end,
+      message: 'Unmeasurable rule \u2014 no observable action or bound, so nothing can check compliance. Name a concrete action ("cite the source", "at most 3 sentences") or move it to a prose block.'
+    });
+  }
+  const render = renderLines(rawLines);
+  rawLines.forEach((raw, i) => {
+    if (flagged.has(i) || exempt.has(i)) return;
+    const r = render[i];
+    if (!r || r.kind !== "content" || r.lineClass === "md-code" || r.lineClass === "md-heading") return;
+    const clause = parseLine(raw).clause.trim();
+    if (!/^be\s+\w/i.test(clause) || classifyClause(clause) !== "prose") return;
+    out.push({
+      source: "prompt/unmeasurable",
+      severity: "warn",
+      line: i,
+      start: raw.length - raw.trimStart().length,
+      end: raw.length,
+      message: 'Unmeasurable rule \u2014 "be <quality>" names no observable action, so nothing can check compliance. Name a concrete action, or move it to a prose block (persona prose is allowed to be soft).'
+    });
+  });
+  return out;
+}
+function untestedRules(rawLines, testLines) {
+  if (testLines.size === 0) return [];
+  const source = rawLines.join("\n");
+  const suite = extractSuite(source);
+  if (suite.testCases.length === 0) return [];
+  const doc = buildStructure(rawLines);
+  const coverage = ruleCoverage(lower(source, { tools: doc.index.tools }), suite);
+  return coverage.perRule.filter((r) => !r.covered).map((r) => {
+    const raw = rawLines[r.line] ?? "";
+    return {
+      source: "prompt/untested-rule",
+      severity: "info",
+      line: r.line,
+      start: raw.length - raw.trimStart().length,
+      end: raw.length,
+      message: 'No $TEST case exercises this rule \u2014 its behavioral impact is unmeasurable until one does. Add a $TEST whose "- input::" triggers the rule, with a "- expect::" sub-bullet that checks the required behavior.'
+    };
+  });
+}
+var NUM_WORDS = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10
+};
+function determinableForm(text) {
+  const t = text.trim();
+  const q = /^(?:the\s+(?:reply|response|answer|output)\s+)?(?:mentions?|includes?|contains?|says?|quotes?|uses?|references?)\s+(?:the\s+(?:word|phrase|term)\s+)?"([^"]+)"[.!]?$/i.exec(t);
+  if (q) return `contains "${q[1] ?? ""}"`;
+  const w = /^(?:the\s+(?:reply|response|answer|output)\s+)?(?:mentions?|includes?|contains?|says?|references?|names?)\s+(?:the\s+(?:word|phrase|term)\s+)?([A-Za-z][A-Za-z0-9_-]*)[.!]?$/i.exec(t);
+  if (w) return `contains "${w[1] ?? ""}"`;
+  const b = /^(?:is\s+|stays?\s+(?:to\s+|within\s+)?|keeps?\s+(?:to\s+)?|responds?\s+in\s+)?(at\s+most|at\s+least|no\s+more\s+than|no\s+longer\s+than)\s+(\d+|one|two|three|four|five|six|seven|eight|nine|ten)\s+(sentences?|words?|characters?)(?:\s+(?:long|or\s+fewer|or\s+less|max))?[.!]?$/i.exec(t);
+  if (b) {
+    const rawN = (b[2] ?? "").toLowerCase();
+    const n = /^\d+$/.test(rawN) ? Number(rawN) : NUM_WORDS[rawN];
+    if (n === void 0) return null;
+    const dir = /least/i.test(b[1] ?? "") ? "at least" : "at most";
+    const unit = (b[3] ?? "").toLowerCase().replace(/s?$/, "s");
+    return `${dir} ${n} ${unit}`;
+  }
+  return null;
+}
+function determinableExpects(rawLines) {
+  return rubricExpectLines(rawLines).flatMap(({ line, start, text }) => {
+    const form = determinableForm(text);
+    if (form === null) return [];
+    const raw = rawLines[line] ?? "";
+    return [
+      {
+        source: "prompt/determinable-expect",
+        severity: "info",
+        line,
+        start,
+        end: raw.length,
+        message: `Judge-scored expectation with a deterministic form \u2014 the sub-bullet \`- ${form}\` checks this free, instantly, with zero variance.`,
+        fix: { title: `\u2192 ${form}`, replacement: form }
+      }
+    ];
+  });
+}
+var DOUBLE_WORD = /\b(\w+)\s+\1\b/gi;
+function doubleWord(line, i) {
+  const out = [];
+  const masked = maskQuotes(line);
+  DOUBLE_WORD.lastIndex = 0;
+  let m;
+  while ((m = DOUBLE_WORD.exec(masked)) !== null) {
+    if (line[m.index - 1] === "#") continue;
+    out.push({
+      source: "grammar/double-word",
+      severity: "warn",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `Repeated word \u2014 "${m[0]}".`,
+      fix: { title: "Remove duplicate", replacement: m[1] ?? m[0] }
+    });
+  }
+  return out;
+}
+var MISSPELLINGS = {
+  // ie / ei
+  recieve: "receive",
+  recieved: "received",
+  reciept: "receipt",
+  beleive: "believe",
+  beleived: "believed",
+  acheive: "achieve",
+  acheived: "achieved",
+  wierd: "weird",
+  freind: "friend",
+  peice: "piece",
+  thier: "their",
+  feild: "field",
+  // doubled / undoubled consonants
+  occured: "occurred",
+  occuring: "occurring",
+  occurance: "occurrence",
+  occurence: "occurrence",
+  occassion: "occasion",
+  occassionally: "occasionally",
+  refered: "referred",
+  prefered: "preferred",
+  begining: "beginning",
+  commited: "committed",
+  comming: "coming",
+  runing: "running",
+  stoped: "stopped",
+  embarass: "embarrass",
+  embarassing: "embarrassing",
+  harrass: "harass",
+  accomodate: "accommodate",
+  paralell: "parallel",
+  threshhold: "threshold",
+  // -ant / -ent, -ance / -ence
+  independant: "independent",
+  persistant: "persistent",
+  consistant: "consistent",
+  existance: "existence",
+  relevent: "relevant",
+  // multi-word run together (non-words)
+  alot: "a lot",
+  infront: "in front",
+  incase: "in case",
+  aswell: "as well",
+  // -ly / -ally / -ful
+  definately: "definitely",
+  seperately: "separately",
+  basicly: "basically",
+  publically: "publicly",
+  succesfully: "successfully",
+  immediatly: "immediately",
+  completly: "completely",
+  finaly: "finally",
+  truely: "truly",
+  usefull: "useful",
+  greatful: "grateful",
+  // high-frequency singles
+  seperate: "separate",
+  neccessary: "necessary",
+  necesary: "necessary",
+  accross: "across",
+  untill: "until",
+  wich: "which",
+  teh: "the",
+  hte: "the",
+  becuase: "because",
+  adress: "address",
+  arguement: "argument",
+  buisness: "business",
+  concious: "conscious",
+  dissapoint: "disappoint",
+  enviroment: "environment",
+  enviromental: "environmental",
+  goverment: "government",
+  garantee: "guarantee",
+  gaurantee: "guarantee",
+  guage: "gauge",
+  langauge: "language",
+  lenght: "length",
+  strenght: "strength",
+  tommorow: "tomorrow",
+  tomorow: "tomorrow",
+  writen: "written",
+  succesful: "successful",
+  sucessful: "successful",
+  responce: "response",
+  reccomend: "recommend",
+  recomend: "recommend",
+  priviledge: "privilege",
+  familar: "familiar",
+  foward: "forward"
+};
+var MISSPELL_RE = new RegExp(
+  `\\b(${Object.keys(MISSPELLINGS).sort((a, b) => b.length - a.length).join("|")})\\b`,
+  "gi"
+);
+function recase(correct, matched) {
+  if (matched === matched.toUpperCase() && matched !== matched.toLowerCase()) return correct.toUpperCase();
+  const first = matched[0] ?? "";
+  if (first !== "" && first === first.toUpperCase() && first !== first.toLowerCase()) {
+    return (correct[0] ?? "").toUpperCase() + correct.slice(1);
+  }
+  return correct;
+}
+function maskNonProse(line) {
+  const blankSpan = (m) => " ".repeat(m.length);
+  return line.replace(/\b(?:https?:\/\/|www\.)\S+/gi, blankSpan).replace(/`[^`]*`/g, blankSpan).replace(/[{[][^}\]]*[}\]]/g, blankSpan);
+}
+function spelling(line, i) {
+  const out = [];
+  const masked = maskNonProse(line);
+  MISSPELL_RE.lastIndex = 0;
+  let m;
+  while ((m = MISSPELL_RE.exec(masked)) !== null) {
+    const hit = m[0];
+    const correct = MISSPELLINGS[hit.toLowerCase()];
+    if (correct === void 0) continue;
+    const fixed = recase(correct, hit);
+    out.push({
+      source: "spelling/typo",
+      severity: "warn",
+      line: i,
+      start: m.index,
+      end: m.index + hit.length,
+      message: `Misspelling \u2014 "${hit}" should be "${fixed}".`,
+      fix: { title: `\u2192 "${fixed}"`, replacement: fixed }
+    });
+  }
+  return out;
+}
+var SPACE_BEFORE_PUNCT = /(\w|["')\]])(\s+)([,;:!?]+)/g;
+function spacing(line, i) {
+  const out = [];
+  const masked = maskNonProse(line);
+  SPACE_BEFORE_PUNCT.lastIndex = 0;
+  let m;
+  while ((m = SPACE_BEFORE_PUNCT.exec(masked)) !== null) {
+    const punct = m[3] ?? "";
+    const after = masked[m.index + m[0].length];
+    if (/^[:;]/.test(punct) && (after === ")" || after === "(")) continue;
+    const spaceStart = m.index + (m[1] ?? "").length;
+    const spaceEnd = spaceStart + (m[2] ?? "").length;
+    out.push({
+      source: "grammar/spacing",
+      severity: "info",
+      line: i,
+      start: spaceStart,
+      end: spaceEnd,
+      message: `Space before "${punct}" \u2014 remove it.`,
+      fix: { title: "Remove space", replacement: "" }
+    });
+  }
+  return out;
+}
+var STANDALONE_I = /(^|[^\w'])(i)(?=$|[\s,;!?]|'[a-z])/g;
+function standaloneI(line, i) {
+  const out = [];
+  const masked = maskNonProse(line);
+  STANDALONE_I.lastIndex = 0;
+  let m;
+  while ((m = STANDALONE_I.exec(masked)) !== null) {
+    const start = m.index + (m[1] ?? "").length;
+    out.push({
+      source: "grammar/standalone-i",
+      severity: "warn",
+      line: i,
+      start,
+      end: start + 1,
+      message: 'Lowercase "i" \u2014 the pronoun is always capital "I".',
+      fix: { title: '\u2192 "I"', replacement: "I" }
+    });
+  }
+  return out;
+}
+var WORD_TOKEN = /[A-Za-z][A-Za-z'’]*/g;
+function unknownWords(line, i, isWord, allow) {
+  const out = [];
+  const masked = maskNonProse(line);
+  WORD_TOKEN.lastIndex = 0;
+  let m;
+  while ((m = WORD_TOKEN.exec(masked)) !== null) {
+    const tok = m[0];
+    if (tok.length < 3) continue;
+    if (/[A-Z]/.test(tok.slice(1))) continue;
+    const lower2 = tok.toLowerCase().replace(/[’']s$/, "");
+    if (lower2.length < 3) continue;
+    if (allow.has(lower2)) continue;
+    if (Object.prototype.hasOwnProperty.call(MISSPELLINGS, lower2)) continue;
+    if (isWord(tok) || isWord(lower2)) continue;
+    out.push({
+      source: "spelling/unknown-word",
+      severity: "info",
+      line: i,
+      start: m.index,
+      end: m.index + tok.length,
+      message: `Unrecognized word \u2014 "${tok}" isn't in the dictionary. Fix the spelling, or add it to your dictionary.`
+    });
+  }
+  return out;
+}
+var GUARD_OPENER_RE = new RegExp(`^\\s*(${keywordAlternation(GUARD_OPENERS)})\\b`, "i");
+function conditionalNeedsThen(raw, i) {
+  const parsed = parseLine(raw);
+  if (classifyClause(parsed.clause) !== "conditional") return [];
+  const opener = parsed.clause.match(GUARD_OPENER_RE);
+  if (!opener || /\bTHEN\b/i.test(parsed.clause)) return [];
+  const kw = (opener[1] ?? "IF").replace(/\s+/g, " ").toUpperCase();
+  const lead = raw.length - raw.trimStart().length;
+  return [
+    {
+      source: "typeglish/if-then",
+      severity: "warn",
+      line: i,
+      start: lead,
+      end: raw.length,
+      message: `${kw} needs a THEN \u2014 write ${kw} <condition> THEN <action>.`
+    }
+  ];
+}
+function undefinedReference(raw, i, declared, fileAliases) {
+  const out = [];
+  const sigil = /@\{([A-Za-z][A-Za-z0-9_.]*)\}/g;
+  let m;
+  while ((m = sigil.exec(raw)) !== null) {
+    const name = m[1] ?? "";
+    const key = name.toLowerCase();
+    const base = key.split(".")[0] ?? key;
+    if (fileAliases.has(base)) {
+      out.push({
+        source: "structure/undefined-ref",
+        severity: "error",
+        line: i,
+        start: m.index,
+        end: m.index + m[0].length,
+        message: `Wrong bracket \u2014 "${base}" is a file import, and a file transcludes as a SECTION pointer. Replace @{${name}} with @<${key}>.`,
+        fix: { title: `Point with @<${key}>`, replacement: `@<${key}>` }
+      });
+      continue;
+    }
+    if (declared.has(key) || declared.has(base)) continue;
+    out.push({
+      source: "structure/undefined-ref",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `Dangling pointer \u2014 @{${name}} names nothing. Declare it with "$REQUIRE variable ${name}" (a runtime variable), or "${name} IS \u2026" (a fixed value).`
+    });
+  }
+  const bare = /(?<!@)\{([A-Za-z][A-Za-z0-9_]*(?:[.#][A-Za-z0-9_]+)?)\}|(?<!@)\[([a-z][a-z0-9_]*(?:[.#][a-z0-9_]+)?)\]/gi;
+  while ((m = bare.exec(raw)) !== null) {
+    const name = m[1] ?? m[2] ?? "";
+    const square = m[1] === void 0;
+    const key = name.toLowerCase();
+    const base = key.split(/[.#]/)[0] ?? key;
+    const isFile = fileAliases.has(base);
+    if (square && !isFile) continue;
+    if (!square && !isFile && !declared.has(key) && !declared.has(base)) continue;
+    const pointer = isFile ? `@<${key}>` : `@{${key}}`;
+    out.push({
+      source: "structure/retired-brace-ref",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `Bare ${square ? "squares" : "braces"} are prose \u2014 they no longer reference. "${name}" is ${isFile ? "a file import" : "a declared name"}, so point at it: replace ${m[0]} with ${pointer}.`,
+      fix: { title: `Point with ${pointer}`, replacement: pointer }
+    });
+  }
+  return out;
+}
+function retiredLiteralSigil(raw, i) {
+  const out = [];
+  const masked = maskQuotes(raw);
+  const rewriteAt = (m2) => {
+    const found = raw.slice(m2.index, m2.index + m2[0].length);
+    const mm = found.match(/^<(\/?)[="]([a-z][a-z0-9_]*)"?((?:\s[^>]*)?)>$/i);
+    return mm ? { found, rewrite: `<${mm[1] ?? ""}"${mm[2] ?? ""}"${mm[3] ?? ""}>` } : null;
+  };
+  let m;
+  const retired = /<\/?=[a-z][a-z0-9_]*(?:\s[^>]*)?>/gi;
+  while ((m = retired.exec(masked)) !== null) {
+    const r = rewriteAt(m);
+    if (!r) continue;
+    out.push({
+      source: "structure/retired-literal-sigil",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `The "=" literal-zone sigil is retired \u2014 the sigil is the quote pair now (one escape, every scale). Replace ${r.found} with ${r.rewrite}.`,
+      fix: { title: `Quote it: ${r.rewrite}`, replacement: r.rewrite }
+    });
+  }
+  const half = /<\/?"[a-z][a-z0-9_]*(?!")(?:\s[^>]*)?>/gi;
+  while ((m = half.exec(masked)) !== null) {
+    const r = rewriteAt(m);
+    if (!r) continue;
+    out.push({
+      source: "structure/half-quoted-literal",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `A literal section quotes its WHOLE name \u2014 both quotes, ${r.rewrite}.`,
+      fix: { title: `Quote it: ${r.rewrite}`, replacement: r.rewrite }
+    });
+  }
+  return out;
+}
+function undefinedToolInline(raw, i, defined, imported) {
+  const out = [];
+  const re = /@\[([a-z][a-z0-9_]*)\]/gi;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    const name = m[1] ?? "";
+    if (defined.has(name.toLowerCase()) || imported.has(name.toLowerCase())) continue;
+    out.push({
+      source: "structure/undefined-tool-inline",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `@[${name}] \u2014 no $TOOL or $IMPORT tool named "${name}" in this file. Define it ("$TOOL ${name}") or import it ("$IMPORT tool ${name}") so the pointer has a target.`
+    });
+  }
+  return out;
+}
+function bareToolRef(raw, i, toolKeys) {
+  if (toolKeys.size === 0) return [];
+  const out = [];
+  const blank = (s, re) => s.replace(re, (m2) => "_".repeat(m2.length));
+  let masked = maskQuotes(stripAnnotation(stripInlineComment(raw)));
+  masked = blank(masked, /@\{[^}\n]*\}|@<[^>\n]*>|@\[[^\]\n]*\]/g);
+  masked = blank(masked, new RegExp(`<\\/?${TAG_NAME_SRC}(?:\\s[^>]*)?>`, "gi"));
+  SNAKE_RE.lastIndex = 0;
+  let m;
+  while ((m = SNAKE_RE.exec(masked)) !== null) {
+    const key = m[0].toLowerCase();
+    if (!toolKeys.has(key)) continue;
+    out.push({
+      source: "structure/bare-tool-ref",
+      severity: "error",
+      line: i,
+      start: m.index,
+      end: m.index + m[0].length,
+      message: `"${m[0]}" is a tool, but this mention is bare prose \u2014 the compiler cannot bind it. Point it with @[${key}] (a checked reference), or quote it ("${m[0]}") to speak the name as plain text.`,
+      fix: { title: `Point with @[${key}]`, replacement: `@[${key}]` }
+    });
+  }
+  return out;
+}
+function normItem(s) {
+  return s.toLowerCase().replace(/[.,;:!?]+$/, "").replace(/\s+/g, " ").trim();
+}
+function normMember2(s) {
+  return s.toLowerCase().replace(/^(?:a|an|the)\s+/, "").replace(/[.,;:!?]+$/, "").replace(/\s+/g, " ").trim();
+}
+function membersDisjoint(a, b, sets) {
+  for (const ai of a) {
+    const ma = normMember2(ai);
+    if (ma === "") continue;
+    for (const bj of b) {
+      const mb = normMember2(bj);
+      if (mb !== "" && ma !== mb && sets.some((s) => s.has(ma) && s.has(mb))) return true;
+    }
+  }
+  return false;
+}
+function conflictingDeclarations(rawLines, disp = (i) => i + 1) {
+  const disjointSets = [];
+  for (const raw of rawLines) {
+    const e = findEnumDeclaration(raw);
+    if (e) disjointSets.push(new Set(e.members.map(normMember2).filter((x) => x !== "")));
+  }
+  if (disjointSets.length === 0) return [];
+  const decls = resolveDeclarations(rawLines);
+  const aliases = aliasMap(decls);
+  const byName = /* @__PURE__ */ new Map();
+  for (const d of decls) {
+    if (d.negated || d.path || d.owns || d.items.length === 0) continue;
+    const key = aliases.get(d.name.toLowerCase()) ?? d.name.toLowerCase();
+    const list = byName.get(key);
+    if (list) list.push({ line: d.line, items: d.items });
+    else byName.set(key, [{ line: d.line, items: d.items }]);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const decls2 of byName.values()) {
+    for (let a = 0; a < decls2.length; a += 1) {
+      for (let b = a + 1; b < decls2.length; b += 1) {
+        const da = decls2[a];
+        const db = decls2[b];
+        if (!da || !db || !membersDisjoint(da.items, db.items, disjointSets)) continue;
+        for (const [self, peer] of [
+          [da, db],
+          [db, da]
+        ]) {
+          const dedupe = `${self.line}|${peer.line}`;
+          if (seen.has(dedupe)) continue;
+          seen.add(dedupe);
+          const raw = rawLines[self.line] ?? "";
+          const lead = raw.length - raw.trimStart().length;
+          out.push({
+            source: "logic/redeclaration",
+            severity: "error",
+            line: self.line,
+            start: lead,
+            end: raw.length,
+            message: `Mutually-exclusive values \u2014 this line asserts "${self.items.join(", ")}" while line ${disp(peer.line)} asserts "${peer.items.join(", ")}", and both belong to one closed "one of" set (an object holds exactly ONE member). Keep one assertion, or widen the declared set.`
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+function declarationRedundancy(rawLines, disp = (i) => i + 1) {
+  const decls = resolveDeclarations(rawLines);
+  const aliases = aliasMap(decls);
+  const canon = (name) => aliases.get(name.toLowerCase()) ?? name.toLowerCase();
+  const byName = /* @__PURE__ */ new Map();
+  for (const d of decls) {
+    if (d.negated || d.path || d.owns) continue;
+    const items = new Set(d.items.map(normItem).filter((x) => x !== ""));
+    if (items.size === 0) continue;
+    const key = canon(d.name);
+    const list = byName.get(key);
+    if (list) list.push({ line: d.line, items });
+    else byName.set(key, [{ line: d.line, items }]);
+  }
+  const out = [];
+  const flagged = /* @__PURE__ */ new Set();
+  for (const [name, entries] of byName) {
+    if (entries.length < 2) continue;
+    for (const d of entries) {
+      if (flagged.has(d.line)) continue;
+      const cover = entries.find(
+        (e) => e.line !== d.line && [...d.items].every((it) => e.items.has(it)) && (d.items.size < e.items.size || e.line < d.line)
+      );
+      if (!cover) continue;
+      flagged.add(d.line);
+      const raw = rawLines[d.line] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const identical = d.items.size === cover.items.size;
+      out.push({
+        source: "clarity/duplicate",
+        severity: "warn",
+        line: d.line,
+        start: lead,
+        end: raw.length,
+        message: identical ? `Duplicate declaration \u2014 "${name}" is already declared identically on line ${disp(cover.line)}. Remove this one.` : `Redundant declaration \u2014 everything "${name}" asserts here is already covered by line ${disp(cover.line)}. Merge or remove it.`
+      });
+    }
+  }
+  return out;
+}
+function negatedFactConflicts(rawLines, disp = (i) => i + 1) {
+  const decls = resolveDeclarations(rawLines);
+  const aliases = aliasMap(decls);
+  const canon = (name) => aliases.get(name.toLowerCase()) ?? name.toLowerCase();
+  const facts = /* @__PURE__ */ new Map();
+  for (const d of decls) {
+    if (d.path || d.owns) continue;
+    for (const rawItem of d.items) {
+      const item = normItem(rawItem);
+      if (item === "") continue;
+      const key = `${canon(d.name)}|${item}`;
+      const rec = facts.get(key) ?? { name: d.name, item: rawItem.trim(), pos: [], neg: [] };
+      (d.negated ? rec.neg : rec.pos).push(d.line);
+      facts.set(key, rec);
+    }
+  }
+  const out = [];
+  for (const rec of facts.values()) {
+    if (rec.pos.length === 0 || rec.neg.length === 0) continue;
+    const posLine = rec.pos[0] ?? 0;
+    const negLine = rec.neg[0] ?? 0;
+    for (const ln of [posLine, negLine]) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = ln === posLine ? negLine : posLine;
+      out.push({
+        source: "logic/contradiction",
+        severity: "error",
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: `Contradiction \u2014 "${rec.name}" is asserted to be and not be "${rec.item}" (line ${disp(other)}).`
+      });
+    }
+  }
+  return out;
+}
+function propertyConflicts(rawLines) {
+  const decls = resolveDeclarations(rawLines);
+  const aliases = aliasMap(decls);
+  const canon = (name) => aliases.get(name.toLowerCase()) ?? name.toLowerCase();
+  const fields = /* @__PURE__ */ new Map();
+  for (const d of decls) {
+    if (!d.path) continue;
+    const key = `${canon(d.name)}|${d.path.join(".")}`;
+    const rec = fields.get(key) ?? { cardinality: "one", pos: /* @__PURE__ */ new Map(), neg: /* @__PURE__ */ new Map() };
+    if (d.cardinality === "many") rec.cardinality = "many";
+    for (const rawItem of d.items) {
+      const item = normItem(rawItem);
+      if (item === "") continue;
+      const bucket = d.negated ? rec.neg : rec.pos;
+      bucket.set(item, [...bucket.get(item) ?? [], d.line]);
+    }
+    fields.set(key, rec);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const flag = (lines, message) => {
+    for (const ln of lines) {
+      if (seen.has(ln)) continue;
+      seen.add(ln);
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      out.push({ source: "logic/contradiction", severity: "error", line: ln, start: lead, end: raw.length, message });
+    }
+  };
+  for (const [key, rec] of fields) {
+    const label = key.replace("|", ".");
+    for (const [item, posLines] of rec.pos) {
+      const negLines = rec.neg.get(item);
+      if (negLines && negLines.length > 0) {
+        flag([posLines[0] ?? 0, negLines[0] ?? 0], `Contradiction \u2014 "${label}" is both assigned and denied the value "${item}".`);
+      }
+    }
+    if (rec.cardinality === "one" && rec.pos.size >= 2) {
+      const vals = [...rec.pos.keys()].map((v) => `"${v}"`).join(", ");
+      flag(
+        [...rec.pos.values()].map((ls) => ls[0] ?? 0),
+        `Contradiction \u2014 single-valued "${label}" is assigned ${rec.pos.size} different values (${vals}).`
+      );
+    }
+  }
+  return out;
+}
+function ownershipConflicts(rawLines) {
+  const decls = resolveDeclarations(rawLines);
+  const aliases = aliasMap(decls);
+  const canon = (name) => aliases.get(name.toLowerCase()) ?? name.toLowerCase();
+  const things = /* @__PURE__ */ new Map();
+  for (const d of decls) {
+    if (!d.owns) continue;
+    const thing = normMember2(d.owns);
+    if (thing === "") continue;
+    const owner = canon(d.name);
+    const owners = things.get(thing) ?? /* @__PURE__ */ new Map();
+    owners.set(owner, [...owners.get(owner) ?? [], d.line]);
+    things.set(thing, owners);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [thing, owners] of things) {
+    if (owners.size < 2) continue;
+    const names = [...owners.keys()].join(", ");
+    for (const ln of [...owners.values()].flat().sort((a, b) => a - b)) {
+      if (seen.has(ln)) continue;
+      seen.add(ln);
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      out.push({
+        source: "logic/contradiction",
+        severity: "error",
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: `Contradiction \u2014 "${thing}" is owned by ${owners.size} different owners (${names}).`
+      });
+    }
+  }
+  return out;
+}
+function runDiagnostics(rawLines, _rubric, opts = {}) {
+  const render = renderLines(rawLines);
+  const toolMask = toolBlockMask(rawLines);
+  const exMask = examplesMask(rawLines);
+  const defMask = defListMask(rawLines);
+  const zoneMask = illustrationZoneMask(rawLines);
+  const scoped = rawLines.map((l, i) => toolMask[i] || exMask[i] || TAG_ONLY_LINE.test(l) ? "" : stripAnnotation(l));
+  const addressees = addresseeSubjects(scoped, opts.addressees ?? []);
+  const ordinals = lineOrdinals(rawLines);
+  const disp = (i) => displayLine(ordinals, i);
+  const doc = buildStructure(rawLines);
+  const parsed = parseTools(rawLines);
+  const definedTools = parsed.tools;
+  const toolDefKeys = new Set(definedTools.map((t) => t.name.toLowerCase()));
+  const importedToolKeys = new Set(doc.imports.filter((im) => im.kind === "tool").map((im) => im.key));
+  const allToolKeys = /* @__PURE__ */ new Set([...toolDefKeys, ...importedToolKeys]);
+  const declared = /* @__PURE__ */ new Set();
+  const decls = resolveDeclarations(rawLines);
+  for (const d of decls) {
+    if (!d.negated) declared.add(d.name.toLowerCase());
+  }
+  for (const aliasKey of aliasMap(decls).keys()) declared.add(aliasKey);
+  for (const im of doc.imports) if (im.kind === "variable") declared.add(im.key);
+  for (const name of doc.defines.keys()) declared.add(name);
+  const fileAliases = new Set(doc.fileImports.map((f) => f.key));
+  const allow = /* @__PURE__ */ new Set();
+  const addAllow = (s) => {
+    for (const part of s.toLowerCase().match(/[a-z][a-z'’]*/g) ?? []) if (part.length >= 3) allow.add(part);
+  };
+  for (const name of declared) addAllow(name);
+  let importLines = /* @__PURE__ */ new Set();
+  if (opts.isWord) {
+    importLines = /* @__PURE__ */ new Set([...doc.importLines, ...doc.configLines]);
+    for (const im of doc.imports) addAllow(im.name);
+    for (const base of doc.variables.keys()) addAllow(base);
+    for (const anchor of doc.index.anchors) addAllow(anchor);
+    for (const t of definedTools) {
+      addAllow(t.name);
+      for (const p of t.params) addAllow(p.name);
+    }
+  }
+  const out = [];
+  const exempt = proseExemptLines(rawLines);
+  const testLines = testBlockLines(rawLines);
+  const exampleLines = exampleBlockLines(rawLines);
+  const cfgMask = configSectionMask(rawLines);
+  const chainArms = new Set(parseSwitches(rawLines).flatMap((b) => b.error === null ? b.arms.map((a) => a.headerLine) : []));
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const line = rawLines[i] ?? "";
+    out.push(...leakedSecrets(line, i));
+    if (testLines.has(i) || exampleLines.has(i) || cfgMask[i] && !toolMask[i]) continue;
+    const r = render[i];
+    if (!r || r.kind !== "content" || r.lineClass === "md-code" || r.lineClass === "md-heading") {
+      continue;
+    }
+    out.push(
+      ...wordy(line, i),
+      ...hedging(line, i),
+      ...vague(line, i),
+      ...doubleWord(line, i),
+      ...spelling(line, i),
+      ...spacing(line, i),
+      ...standaloneI(line, i),
+      ...toolMask[i] || chainArms.has(i) ? [] : conditionalNeedsThen(line, i),
+      ...toolMask[i] ? [] : quotedProse(line, i),
+      ...toolMask[i] ? [] : specialCharacters(line, i),
+      ...trailingSpace(line, i),
+      ...tabCharacters(line, i),
+      ...phantomColumns(line, i, defMask[i] === true || toolMask[i] === true),
+      ...defMask[i] || toolMask[i] || chainArms.has(i) || exempt.has(i) || isAnnotationLine(line) || line.trimStart().startsWith("$") || TAG_ONLY_LINE.test(line) || matchSectionTag(line) !== null ? [] : missingPeriod(line, i),
+      ...oneOfColon(line, i),
+      ...toolMask[i] || zoneMask[i] ? [] : inlineMarker(line, i),
+      ...toolMask[i] ? [] : undefinedReference(line, i, declared, fileAliases),
+      ...toolMask[i] || zoneMask[i] ? [] : retiredLiteralSigil(line, i),
+      ...toolMask[i] ? [] : undefinedToolInline(line, i, toolDefKeys, importedToolKeys),
+      ...toolMask[i] || isAnnotationLine(line) || line.trimStart().startsWith("$") ? [] : bareToolRef(line, i, allToolKeys),
+      ...exempt.has(i) ? [] : injectionPatterns(line, i),
+      ...opts.isWord && !importLines.has(i) ? unknownWords(line, i, opts.isWord, allow) : []
+    );
+  }
+  for (const e of defEntries(rawLines)) {
+    if (zoneMask[e.line] || toolMask[e.line] || testLines.has(e.line) || exampleLines.has(e.line)) continue;
+    let fence = false;
+    for (const li of e.lines) {
+      const raw = rawLines[li] ?? "";
+      const t = raw.trim();
+      if (fence) {
+        if (t.startsWith("```") || t.startsWith("~~~")) fence = false;
+        continue;
+      }
+      if (t.startsWith("```") || t.startsWith("~~~")) {
+        fence = true;
+        continue;
+      }
+      if (t === "") continue;
+      if (li === e.line || t.startsWith("- ")) {
+        out.push(...missingPeriodLiteral(raw, li));
+        continue;
+      }
+      const lead = raw.length - raw.trimStart().length;
+      out.push({
+        source: "structure/wrapped-definition",
+        severity: "error",
+        line: li,
+        start: lead,
+        end: raw.length,
+        message: 'One statement per line: this hard-wrapped continuation belongs to the statement above. Merge it into that line (the editor wraps long lines), or make it its own "- " sub-item.'
+      });
+    }
+  }
+  {
+    const spec = layoutColumns(rawLines);
+    for (let i = 0; i < rawLines.length; i += 1) {
+      const raw = rawLines[i] ?? "";
+      if (raw.trim() === "") continue;
+      const expected = spec.col[i];
+      if (expected === null || expected === void 0) continue;
+      const actual = (raw.match(/^ */) ?? [""])[0].length;
+      if (actual === expected || spec.substep[i] === true && actual === expected + 2) continue;
+      const depthLabel = expected / 2;
+      out.push({
+        source: "structure/bad-indent",
+        severity: "error",
+        line: i,
+        start: 0,
+        end: actual,
+        message: `Indentation mirrors section nesting: expected column ${expected} (${depthLabel} level${depthLabel === 1 ? "" : "s"} deep), found ${actual}. The indent unit is 2 spaces.`,
+        fix: { title: `\u2192 col ${expected}`, replacement: " ".repeat(expected) }
+      });
+    }
+  }
+  out.push(...wrappedFragments(rawLines, disp));
+  out.push(...unmeasurableDirectives(scoped, exempt));
+  out.push(...untestedRules(scoped, testLines));
+  out.push(...determinableExpects(rawLines));
+  out.push(...conflictingDeclarations(scoped, disp));
+  out.push(...declarationRedundancy(scoped, disp));
+  out.push(...negatedFactConflicts(scoped, disp));
+  out.push(...propertyConflicts(scoped));
+  out.push(...ownershipConflicts(scoped));
+  const ANTONYM_CONFLICT_SEVERITY = "error";
+  for (const conflict of checkConsistency(scoped, addressees)) {
+    for (const ln of conflict.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = conflict.lines.find((x) => x !== ln);
+      out.push({
+        source: conflict.strength === true ? "logic/quantifier-strength" : "logic/contradiction",
+        severity: conflict.viaAntonym === true ? ANTONYM_CONFLICT_SEVERITY : "error",
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: other !== void 0 ? `${conflict.message} (conflicts with line ${disp(other)})` : conflict.message
+      });
+    }
+  }
+  for (const conflict of checkOrder(scoped)) {
+    for (const ln of conflict.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const others = conflict.lines.filter((x) => x !== ln).map((x) => disp(x));
+      out.push({
+        source: "logic/order",
+        severity: "error",
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: others.length > 0 ? `${conflict.message} (the loop runs through line${others.length > 1 ? "s" : ""} ${others.join(", ")})` : conflict.message
+      });
+    }
+  }
+  for (const conflict of checkQuantifier(scoped)) {
+    for (const ln of conflict.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = conflict.lines.find((x) => x !== ln);
+      const message = other !== void 0 ? `${conflict.message} (conflicts with line ${disp(other)})` : conflict.message;
+      const base = { severity: "error", line: ln, start: lead, end: raw.length, message };
+      if (conflict.kind === "exclusivity") out.push({ source: "logic/exclusivity", ...base });
+      else if (conflict.kind === "majority") out.push({ source: "logic/majority", ...base });
+      else if (conflict.kind === "strength") out.push({ source: "logic/quantifier-strength", ...base });
+      else if (conflict.kind === "cardinality") out.push({ source: "logic/cardinality", ...base });
+      else if (conflict.kind === "action-count") out.push({ source: "logic/action-count", ...base });
+      else if (conflict.kind === "insufficient-set") out.push({ source: "logic/insufficient-set", ...base });
+      else out.push({ source: "logic/quantifier", ...base });
+    }
+  }
+  for (const conflict of checkSyllogism(scoped)) {
+    for (const ln of conflict.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const others = conflict.lines.filter((x) => x !== ln).map((x) => disp(x));
+      const message = others.length > 0 ? `${conflict.message} (with lines ${others.join(", ")})` : conflict.message;
+      out.push({ source: "logic/syllogism", severity: "error", line: ln, start: lead, end: raw.length, message });
+    }
+  }
+  for (const conflict of checkDefiniteness(rawLines)) {
+    for (const ln of conflict.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = conflict.lines.find((x) => x !== ln);
+      const message = other !== void 0 ? `${conflict.message} (also line ${disp(other)})` : conflict.message;
+      const base = { severity: "error", line: ln, start: lead, end: raw.length, message };
+      if (conflict.code === "definite-ambiguous") out.push({ source: "logic/definite-ambiguous", ...base });
+      else out.push({ source: "logic/definite-undeclared", ...base });
+    }
+  }
+  for (const c of structuralConflicts(rawLines)) {
+    for (const ln of c.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = c.lines.find((x) => x !== ln);
+      out.push({
+        source: `structure/${c.code}`,
+        severity: c.severity,
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: other !== void 0 ? `${c.message} (conflicts with line ${disp(other)})` : c.message
+      });
+    }
+  }
+  const configSchema = opts.glishConfig ? resolveConfigSchema(opts.glishConfig) : BUILTIN_CONFIG_SCHEMA;
+  const configRules = opts.glishConfig ? parseConfigRules(opts.glishConfig) : [];
+  const serviceNames = new Set(parsed.services.map((s) => s.name));
+  for (const f of [...configParamDiagnostics(rawLines, configSchema, serviceNames), ...configRuleDiagnostics(rawLines, configRules)]) {
+    out.push({ source: f.code, severity: f.severity, line: f.line, start: f.start, end: f.end, message: f.message });
+  }
+  for (const ln of deadRules(scoped)) {
+    const raw = rawLines[ln] ?? "";
+    const lead = raw.length - raw.trimStart().length;
+    out.push({
+      source: "clarity/dead-rule",
+      severity: "warn",
+      line: ln,
+      start: lead,
+      end: raw.length,
+      message: "Dead rule \u2014 the IF-condition contradicts ITSELF (the shape of `IF c AND NOT c`), so it can never hold and the rule never fires. Fix the condition's logic, or remove the rule."
+    });
+  }
+  for (const { line, start } of looseContentLines(rawLines)) {
+    out.push({
+      source: "structure/loose-content",
+      severity: "warn",
+      line,
+      start,
+      end: (rawLines[line] ?? "").length,
+      message: "This content is outside any section \u2014 put it inside a <tag> (a heading ends where a tag or the next heading begins)."
+    });
+  }
+  {
+    const entries = defEntries(rawLines);
+    const seen = /* @__PURE__ */ new Map();
+    for (let k = 0; k < entries.length; k += 1) {
+      const e = entries[k];
+      if (!e) continue;
+      const prev = entries[k - 1];
+      const contiguous = prev !== void 0 && e.line === (prev.lines[prev.lines.length - 1] ?? prev.line) + 1;
+      if (!contiguous) seen.clear();
+      const first = seen.get(e.term);
+      if (first !== void 0) {
+        out.push({
+          source: "structure/duplicate-term",
+          severity: "warn",
+          line: e.line,
+          start: e.termCol,
+          end: e.termCol + e.term.length + 2,
+          message: `Duplicate term "${e.term}" \u2014 this list already defines it on line ${disp(first)}.`
+        });
+      } else {
+        seen.set(e.term, e.line);
+      }
+    }
+  }
+  for (const { line, start } of headingsOutsideSections(rawLines)) {
+    out.push({
+      source: "structure/heading-outside-section",
+      severity: "warn",
+      line,
+      start,
+      end: (rawLines[line] ?? "").length,
+      message: "This heading is outside every <tag> section \u2014 when a prompt uses XML sections, headings must live inside them."
+    });
+  }
+  {
+    const lineKind = (raw) => {
+      if (raw === void 0) return "the end of the file";
+      const t = raw.trim();
+      if (t === "") return "a blank line";
+      if (t.startsWith("//") || t.startsWith("/*")) return "a comment";
+      if (t.startsWith("```") || t.startsWith("~~~")) return "a code fence";
+      if (TAG_ONLY_LINE.test(raw)) return "a section tag";
+      if (t.startsWith("#")) return "a heading";
+      if (/^\$(?:IF|ELSE|SWITCH)\b/i.test(t)) return null;
+      if (t.startsWith("$")) return "a compiler command";
+      if (stripAnnotation(stripInlineComment(raw)).trim() === "") return "stripped metadata";
+      return null;
+    };
+    let inFence = false;
+    for (let i = 0; i < rawLines.length; i += 1) {
+      const raw = rawLines[i] ?? "";
+      const t = raw.trim();
+      if (t.startsWith("```") || t.startsWith("~~~")) {
+        inFence = !inFence;
+        continue;
+      }
+      if (inFence) continue;
+      if (exMask[i]) continue;
+      if (isAnnotationLine(raw)) {
+        const lead = raw.length - raw.trimStart().length;
+        const next = rawLines[i + 1];
+        if (next !== void 0 && isAnnotationLine(next)) {
+          out.push({
+            source: "structure/stacked-annotation",
+            severity: "error",
+            line: i,
+            start: lead,
+            end: raw.length,
+            message: "Stacked annotations: a `@@` note documents the ONE statement directly below it, and the line below is another `@@`. Merge the notes into one line, or give each note its own statement."
+          });
+        } else {
+          const kind = lineKind(next);
+          if (kind !== null) {
+            out.push({
+              source: "structure/unattached-annotation",
+              severity: "error",
+              line: i,
+              start: lead,
+              end: raw.length,
+              message: `A \`@@\` annotation documents the statement DIRECTLY below it \u2014 here the next line is ${kind}. Move the note to the line immediately above its statement.`
+            });
+          }
+        }
+        continue;
+      }
+      if (hasTrailingAnnotation(raw)) {
+        const at = raw.indexOf("@@");
+        out.push({
+          source: "structure/misplaced-annotation",
+          severity: "warn",
+          line: i,
+          start: at < 0 ? 0 : at,
+          end: raw.length,
+          message: "A `@@` statement annotation belongs on its own line, before the statement it documents \u2014 move it above."
+        });
+      }
+    }
+  }
+  for (const group of checkRedundancy(scoped, addressees)) {
+    const force = group.kind === "obligate" ? "required" : "forbidden";
+    for (const ln of group.lines) {
+      const raw = rawLines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const others = group.lines.filter((x) => x !== ln).map((x) => x + 1);
+      out.push({
+        source: "clarity/duplicate",
+        severity: "warn",
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: `Duplicate rule \u2014 "${group.atom}" is ${force} in ${group.lines.length} places (also ${others.length > 1 ? "lines" : "line"} ${others.join(", ")}). State it once and reference it.`
+      });
+    }
+  }
+  for (const s of checkSubsumption(scoped, addressees)) {
+    const raw = rawLines[s.redundantLine] ?? "";
+    const lead = raw.length - raw.trimStart().length;
+    const force = s.kind === "obligate" ? "required" : "forbidden";
+    out.push({
+      source: "clarity/duplicate",
+      severity: "warn",
+      line: s.redundantLine,
+      start: lead,
+      end: raw.length,
+      message: `Subsumed rule \u2014 "${s.atom}" is already ${force} by a broader rule on line ${disp(
+        s.coveringLine
+      )}, so this narrower condition never changes the outcome. Drop the condition or remove this line.`
+    });
+  }
+  for (const f of checkModel(rawLines)) {
+    out.push({ source: "config/unknown-model", severity: f.severity, line: f.line, start: f.start, end: f.end, message: f.message });
+  }
+  const noteAt = rawLines.map((l) => {
+    if (isAnnotationLine(l)) return 0;
+    const m = l.match(/(^|\s)@@/);
+    return m && m.index !== void 0 ? m.index + (m[1] ?? "").length : -1;
+  });
+  const isAnnotationDiag = (src) => src === "structure/misplaced-annotation" || src === "structure/unattached-annotation" || src === "structure/stacked-annotation";
+  const judgesConstruct = (src) => src === "structure/duplicate-term";
+  const contentRuleInDefs = (src) => src === "structure/missing-period" || src === "structure/wrapped-definition" || src === "structure/em-dash" || src === "structure/curly-quote" || src === "structure/special-character" || src === "structure/inline-marker" || src === "structure/bad-indent" || src === "structure/phantom-column" || src === "structure/trailing-space" || src === "structure/tab";
+  return out.filter((d) => {
+    if (!isAnnotationDiag(d.source)) {
+      const a = noteAt[d.line] ?? -1;
+      if (a >= 0 && d.start >= a) return false;
+    }
+    return !exMask[d.line] || d.source.startsWith("spelling/") || d.source.startsWith("security/") || // The determinable-expect nudge ONLY ever lands on a $TEST `- expect::` sub-bullet (that is all
+    // rubricExpectLines yields), and those rows are def-SHAPED, so examplesMask marks them literal.
+    // It is a control-plane nudge, not example content — it survives the literal-zone sweep by
+    // construction. (Before the bullet refactor, `EXPECT …` wasn't def-shaped, so it slipped past.)
+    d.source === "prompt/determinable-expect" || judgesConstruct(d.source) || defMask[d.line] === true && zoneMask[d.line] !== true && contentRuleInDefs(d.source);
+  });
+}
+function applyFix(value, d) {
+  if (!d.fix) return value;
+  const lines = value.split("\n");
+  const line = lines[d.line];
+  if (line === void 0) return value;
+  lines[d.line] = line.slice(0, d.start) + d.fix.replacement + line.slice(d.end);
+  return lines.join("\n");
+}
+function composeSpans(tokens2, diags) {
+  const text = tokens2.map((t) => t.text).join("");
+  const n = text.length;
+  const mdCls = [];
+  for (const t of tokens2) for (let k2 = 0; k2 < t.text.length; k2 += 1) mdCls.push(t.cls);
+  const sev = new Array(n).fill(void 0);
+  for (const d of diags) {
+    for (let k2 = Math.max(0, d.start); k2 < Math.min(n, d.end); k2 += 1) {
+      const cur = sev[k2];
+      if (!cur || SEV_RANK[d.severity] > SEV_RANK[cur]) sev[k2] = d.severity;
+    }
+  }
+  const spans = [];
+  let k = 0;
+  while (k < n) {
+    const md = mdCls[k];
+    const s = sev[k];
+    let j = k + 1;
+    while (j < n && mdCls[j] === md && sev[j] === s) j += 1;
+    const cls = [md, s ? `diag-${s}` : void 0].filter(Boolean).join(" ") || void 0;
+    spans.push({ text: text.slice(k, j), cls });
+    k = j;
+  }
+  return spans;
+}
+
+// src/core/catalog.ts
+var RANK = { critical: 3, important: 2, advisory: 1 };
+function atLeastImportant(a, b) {
+  return RANK[a] >= RANK[b];
+}
+var CORRECTNESS = /* @__PURE__ */ new Set(["structure", "logic", "security", "config", "typeglish", "clarity"]);
+var OVERRIDES = {};
+function categoryOf(code) {
+  const i = code.indexOf("/");
+  return i < 0 ? code : code.slice(0, i);
+}
+function importanceOf(code, severity) {
+  const override = OVERRIDES[code];
+  if (override) return override;
+  if (severity === "error") return "critical";
+  return CORRECTNESS.has(categoryOf(code)) ? "important" : "advisory";
+}
+
+// src/core/edits.ts
+var IDENT = /^[a-z][a-z0-9_]*$/i;
+var RESERVED = /* @__PURE__ */ new Set(["not", "and", "or", "is", "one", "of"]);
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var fail = (source, error) => ({ ok: false, source, changed: 0, error });
+function rename(source, kind, from, to) {
+  const lines = source.split("\n");
+  const doc = buildStructure(lines);
+  const fromKey = from.toLowerCase();
+  const toKey = to.toLowerCase();
+  if (!IDENT.test(to)) return fail(source, `"${to}" isn't a valid name \u2014 use letters, digits, and underscore, starting with a letter.`);
+  if (RESERVED.has(toKey)) return fail(source, `"${to}" is a reserved word (${[...RESERVED].join(", ")}) \u2014 it would reparse as an operator.`);
+  const declLine = kind === "define" ? doc.defines.get(fromKey)?.line : doc.imports.find((im) => im.kind === "variable" && im.key === fromKey)?.line;
+  if (declLine === void 0) return fail(source, `no ${kind === "define" ? "$DEFINE" : "$REQUIRE variable"} named "${from}".`);
+  if (doc.index.inputs.has(toKey) || doc.defines.has(toKey)) return fail(source, `"${to}" is already declared \u2014 pick a name that's free.`);
+  if (fromKey === toKey) return fail(source, `"${to}" is already the name \u2014 nothing to rename.`);
+  const toolMask = toolBlockMask(lines);
+  const refPattern = new RegExp(`@\\{${escapeRegex(fromKey)}\\}|\\$${escapeRegex(fromKey)}\\b`, "gi");
+  let changed = 0;
+  const out = lines.map((line, i) => {
+    let s = line;
+    if (i === declLine) {
+      if (kind === "define") {
+        s = s.replace(/^(\s*\$DEFINE\s+)([a-z][a-z0-9_]*)/i, (m, pre, name) => name.toLowerCase() === fromKey ? (changed += 1, `${pre}${to}`) : m);
+      } else {
+        s = s.replace(/^(\s*(?:\$REQUIRE\s+variable|\$IMPORT\s+input)\s+)([^:]*)/i, (_m, pre, names) => `${pre}${names.replace(new RegExp(`\\b${escapeRegex(fromKey)}\\b`, "i"), () => (changed += 1, to))}`);
+      }
+    }
+    if (!toolMask[i]) {
+      const safe = maskQuotes(s).replace(/\s+\/\/.*$/, (c) => " ".repeat(c.length));
+      const hits = [...safe.matchAll(refPattern)].map((m) => ({ idx: m.index ?? 0, len: m[0].length }));
+      for (const h of hits.reverse()) {
+        s = `${s.slice(0, h.idx)}@{${to}}${s.slice(h.idx + h.len)}`;
+        changed += 1;
+      }
+    }
+    return s;
+  });
+  return { ok: true, source: out.join("\n"), changed };
+}
+
+// src/core/semantic/atoms.ts
+function fnv32(s, seed) {
+  let h = seed >>> 0;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function atomId(text, guard) {
+  const key = `${text.trim().toLowerCase()}|${(guard ?? "").trim().toLowerCase()}`;
+  const a = fnv32(key, 2166136261).toString(16).padStart(8, "0");
+  const b = fnv32(key, 3421674724).toString(16).padStart(8, "0");
+  return a + b;
+}
+function condToText(c) {
+  switch (c.t) {
+    case "true":
+      return null;
+    case "false":
+      return "never";
+    case "atom":
+      return c.text.trim();
+    case "not": {
+      const inner = condToText(c.f);
+      return inner === null ? "never" : `not ${inner}`;
+    }
+    case "and":
+      return c.fs.map((f) => condToText(f) ?? "").filter((x) => x !== "").join(" and ");
+    case "or":
+      return c.fs.map((f) => condToText(f) ?? "").filter((x) => x !== "").join(" or ");
+  }
+}
+var FORCE = {
+  obligate: "must",
+  prohibit: "must not",
+  recommend: "should",
+  discourage: "should not",
+  permit: "may"
+};
+function directiveAtom(d) {
+  const guard = condToText(d.cond) ?? void 0;
+  const subj = d.subject === "" ? "you" : d.subject;
+  const action = d.action.text.replace(/[.!?\s]+$/, "");
+  const base = `${subj} ${FORCE[d.deontic]} ${action}`;
+  const text = guard ? `When ${guard}, ${base}.` : `${base}.`;
+  return {
+    id: atomId(text, guard),
+    line: d.line,
+    span: d.span,
+    text,
+    kind: "directive",
+    deontic: d.deontic,
+    subject: d.subject,
+    guard,
+    predicates: d.predicate ? [d.predicate] : void 0
+  };
+}
+function declarationAtom(d) {
+  const value = d.value.replace(/[.!?\s]+$/, "");
+  const text = d.negated ? `${d.name} is not ${value}.` : `${d.name} is ${value}.`;
+  return {
+    id: atomId(text, void 0),
+    line: d.line,
+    span: d.span,
+    text,
+    kind: "declaration",
+    subject: d.name.toLowerCase()
+  };
+}
+function decompose(source) {
+  const rawLines = source.replace(/\r\n/g, "\n").split("\n");
+  const render = renderLines(rawLines);
+  const doc = buildStructure(rawLines);
+  const tools = doc.index.tools;
+  const maskedSource = maskInlineSwitches(source);
+  const maskedLines = maskedSource.replace(/\r\n/g, "\n").split("\n");
+  const conditional = /* @__PURE__ */ new Set();
+  for (const b of parseSwitches(rawLines)) for (let l = b.headerLine; l < b.blockEnd; l += 1) conditional.add(l);
+  for (const s of doc.sections) if (s.guard) for (let l = s.startLine; l < s.endLine; l += 1) conditional.add(l);
+  const cfgMask = configSectionMask(rawLines);
+  const toolMask = toolBlockMask(rawLines);
+  const byLine = /* @__PURE__ */ new Map();
+  for (const node of lower(maskedSource, { tools }).nodes) {
+    const list = byLine.get(node.line);
+    if (list) list.push(node);
+    else byLine.set(node.line, [node]);
+  }
+  const out = [];
+  rawLines.forEach((raw, i) => {
+    const r = render[i];
+    if (!r || r.kind !== "content" || r.lineClass === "md-code" || r.lineClass === "md-heading") return;
+    if (doc.importLines.has(i) || doc.configLines.has(i) || doc.defineLines.has(i) || conditional.has(i) || toolMask[i]) return;
+    if (doc.testLines.has(i) || cfgMask[i]) return;
+    const nodes = byLine.get(i) ?? [];
+    if (nodes.length > 0) {
+      for (const n of nodes) out.push(n.kind === "directive" ? directiveAtom(n) : declarationAtom(n));
+      return;
+    }
+    const { clause } = parseLine(stripInlineComment(maskedLines[i] ?? raw));
+    const lead = raw.length - raw.trimStart().length;
+    for (const sentence of splitSentences(clause)) {
+      for (const seg of sentence.text.split(";")) {
+        const text = seg.trim().replace(/[,]+$/, "");
+        if (text === "") continue;
+        const claim = /[.!?]$/.test(text) ? text : `${text}.`;
+        const predicates = predicatesFromProse(claim, tools);
+        out.push({
+          id: atomId(claim, void 0),
+          line: i,
+          span: { start: lead, end: raw.length },
+          text: claim,
+          kind: "prose",
+          predicates: predicates.length > 0 ? predicates : void 0
+        });
+      }
+    }
+  });
+  return out;
+}
+
+// src/core/semantic/config.ts
+var NLI_MODEL_VERSION = "Xenova/nli-deberta-v3-base@q8";
+var THETA_EQUIV = 0.8;
+var THETA_COVER = 0.85;
+var THETA_CONTRA = 0.97;
+var THETA_COVERED = 0.85;
+var THETA_DIRECTION_ACTIONABLE = 0.7;
+var NLI_DIRECTION_CAP = 0.5;
+var JACCARD_GATE = 0.1;
+var MAX_PAIRS = 4e3;
+var THETA_REDUNDANCY_WARN = 0.1;
+var THETA_EQUIVALENT_WARN = 0.95;
+
+// src/core/semantic/candidates.ts
+var STOP2 = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "you",
+  "your",
+  "that",
+  "this",
+  "with",
+  "are",
+  "was",
+  "will",
+  "can",
+  "when",
+  "should",
+  "must",
+  "not",
+  "but",
+  "its",
+  "our",
+  "their",
+  "they",
+  "them",
+  "from",
+  "have",
+  "has",
+  "had",
+  "any",
+  "all",
+  "each",
+  "every",
+  "then",
+  "than",
+  "into",
+  "out",
+  "only",
+  "also",
+  "more",
+  "some",
+  "such",
+  "about",
+  "which",
+  "what",
+  "who",
+  "how",
+  "why",
+  "where",
+  "here",
+  "there",
+  "these",
+  "those",
+  "never",
+  "always",
+  "may",
+  "one",
+  "per",
+  "via",
+  "after",
+  "before",
+  "once"
+]);
+function contentWords(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const w of text.toLowerCase().match(/[a-z0-9_][a-z0-9_'-]{2,}/g) ?? []) {
+    if (!STOP2.has(w)) out.add(w);
+  }
+  return out;
+}
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const w of a) if (b.has(w)) inter += 1;
+  return inter / (a.size + b.size - inter);
+}
+function predicateGate(a, b) {
+  for (const pa of a.predicates ?? []) {
+    for (const pb of b.predicates ?? []) {
+      if (pa.tool !== void 0 && pa.tool === pb.tool) return true;
+      if (pa.frame !== void 0 && pa.frame === pb.frame) return true;
+      if (isAntonym(pa, pb)) return true;
+      if (pa.head === pb.head) return true;
+    }
+  }
+  return false;
+}
+function candidatePairs(atoms) {
+  const words = atoms.map((a) => contentWords(a.text));
+  const pairs = [];
+  for (let i = 0; i < atoms.length; i += 1) {
+    for (let j = i + 1; j < atoms.length; j += 1) {
+      const a = atoms[i];
+      const b = atoms[j];
+      if (!a || !b || a.line === b.line) continue;
+      const wa = words[i];
+      const wb = words[j];
+      if (!wa || !wb) continue;
+      const score = jaccard(wa, wb);
+      const lexical = score >= JACCARD_GATE;
+      const predicate = predicateGate(a, b);
+      if (!lexical && !predicate) continue;
+      pairs.push({ a, b, jaccard: score, via: lexical && predicate ? "both" : lexical ? "lexical" : "predicate" });
+    }
+  }
+  pairs.sort((x, y) => y.jaccard + (y.via !== "lexical" ? 0.1 : 0) - (x.jaccard + (x.via !== "lexical" ? 0.1 : 0)));
+  const truncated = Math.max(0, pairs.length - MAX_PAIRS);
+  return { pairs: pairs.slice(0, MAX_PAIRS), truncated };
+}
+
+// src/core/semantic/classify.ts
+function classifyPair(s) {
+  const entMax = Math.max(s.entAB, s.entBA);
+  if (Math.min(s.conAB, s.conBA) >= THETA_CONTRA && entMax < THETA_EQUIV) return { relation: "contradicts", directionConfidence: 0 };
+  if (s.entAB >= THETA_EQUIV && s.entBA >= THETA_EQUIV) return { relation: "equivalent", directionConfidence: 0 };
+  if (s.entAB >= THETA_COVER && s.entBA < THETA_COVER) {
+    return { relation: "covers", directionConfidence: Math.min(NLI_DIRECTION_CAP, s.entAB - s.entBA) };
+  }
+  if (s.entBA >= THETA_COVER && s.entAB < THETA_COVER) {
+    return { relation: "covered_by", directionConfidence: Math.min(NLI_DIRECTION_CAP, s.entBA - s.entAB) };
+  }
+  return { relation: "distinct", directionConfidence: 0 };
+}
+function verdictFrom(a, b, s, tier = "nli") {
+  const { relation, directionConfidence } = classifyPair(s);
+  return {
+    a,
+    b,
+    relation,
+    entAB: s.entAB,
+    entBA: s.entBA,
+    conMax: Math.max(s.conAB, s.conBA),
+    conMin: Math.min(s.conAB, s.conBA),
+    directionConfidence,
+    tier,
+    modelVersion: NLI_MODEL_VERSION
+  };
+}
+function assembleAudits(atoms, verdicts, coverage) {
+  const atomById = new Map(atoms.map((a) => [a.id, a]));
+  const covByAtom = new Map(coverage.map((c) => [c.atom, c]));
+  const byLine = /* @__PURE__ */ new Map();
+  for (const a of atoms) {
+    const list = byLine.get(a.line);
+    if (list) list.push(a);
+    else byLine.set(a.line, [a]);
+  }
+  const audits = [];
+  for (const [line, lineAtoms] of [...byLine.entries()].sort((x, y) => x[0] - y[0])) {
+    const coverers = /* @__PURE__ */ new Map();
+    let minCoverage = 1;
+    let allCovered = true;
+    for (const atom of lineAtoms) {
+      const cov = covByAtom.get(atom.id);
+      const score = cov?.score ?? 0;
+      minCoverage = Math.min(minCoverage, score);
+      if (score < THETA_COVERED) allCovered = false;
+      if (!cov) continue;
+      for (const covererId of cov.coveredBy) {
+        const coverer = atomById.get(covererId);
+        if (!coverer || coverer.line === line) continue;
+        const rec = coverers.get(coverer.line) ?? { atoms: /* @__PURE__ */ new Set(), ent: 1 };
+        rec.atoms.add(covererId);
+        rec.ent = Math.min(rec.ent, score);
+        coverers.set(coverer.line, rec);
+      }
+    }
+    const conflicts = /* @__PURE__ */ new Map();
+    for (const v of verdicts) {
+      if (v.relation !== "contradicts") continue;
+      const la = atomById.get(v.a)?.line;
+      const lb = atomById.get(v.b)?.line;
+      const other = la === line ? lb : lb === line ? la : void 0;
+      if (other === void 0 || other === line) continue;
+      const prev = conflicts.get(other);
+      conflicts.set(other, {
+        conf: Math.max(prev?.conf ?? 0, v.conMin),
+        confirmed: (prev?.confirmed ?? false) || v.tier === "nli+judge"
+      });
+    }
+    audits.push({
+      line,
+      atoms: lineAtoms.map((a) => a.id),
+      residual: 1 - minCoverage,
+      coveredBy: [...coverers.entries()].map(([l, rec]) => ({ line: l, atoms: [...rec.atoms], ent: rec.ent })).sort((x, y) => y.ent - x.ent),
+      contradicts: [...conflicts.entries()].map(([l, rec]) => ({ line: l, conf: rec.conf, confirmed: rec.confirmed })).sort((x, y) => y.conf - x.conf),
+      proposedRemovable: lineAtoms.length > 0 && allCovered
+    });
+  }
+  return audits;
+}
+function buildReport(atoms, verdicts, coverage, stats) {
+  return { atoms, pairs: verdicts, coverage, lines: assembleAudits(atoms, verdicts, coverage), stats };
+}
+
+// src/core/semantic/reduce.ts
+async function proposeReduction(source, analyze, opts = {}) {
+  const maxCuts = Math.max(1, opts.maxCuts ?? 25);
+  let lines = source.replace(/\r\n/g, "\n").split("\n");
+  let origin = lines.map((_, i) => i);
+  const steps = [];
+  while (steps.length < maxCuts) {
+    const report2 = await analyze(lines.join("\n"));
+    const removable = report2.lines.filter((l) => l.proposedRemovable).sort((a, b) => a.residual - b.residual);
+    const target = removable[0];
+    if (!target) break;
+    steps.push({
+      order: steps.length + 1,
+      line: origin[target.line] ?? target.line,
+      text: (lines[target.line] ?? "").trim(),
+      residualAtCut: target.residual,
+      coveredBy: target.coveredBy.map((c) => ({ line: origin[c.line] ?? c.line, ent: c.ent }))
+    });
+    lines = lines.filter((_, i) => i !== target.line);
+    origin = origin.filter((_, i) => i !== target.line);
+  }
+  return steps;
+}
+
+// src/core/semantic/report.ts
+function lineRange(rawLines, line) {
+  const raw = rawLines[line] ?? "";
+  return { start: raw.length - raw.trimStart().length, end: raw.length };
+}
+var fmtLines = (ls, disp = (i) => i + 1) => `line${ls.length > 1 ? "s" : ""} ${ls.map((l) => disp(l)).join(", ")}`;
+function semanticDiagnostics(report2, source, displaySource = source) {
+  const rawLines = source.replace(/\r\n/g, "\n").split("\n");
+  const ordinals = lineOrdinals(displaySource.replace(/\r\n/g, "\n").split("\n"));
+  const disp = (i) => displayLine(ordinals, i);
+  const atomById = new Map(report2.atoms.map((a) => [a.id, a]));
+  const out = [];
+  const equivalentWith = /* @__PURE__ */ new Map();
+  for (const v of report2.pairs) {
+    if (v.relation !== "equivalent") continue;
+    const la = atomById.get(v.a)?.line;
+    const lb = atomById.get(v.b)?.line;
+    if (la === void 0 || lb === void 0 || la === lb) continue;
+    const strength = Math.min(v.entAB, v.entBA);
+    for (const [self, other] of [[la, lb], [lb, la]]) {
+      const map = equivalentWith.get(self) ?? /* @__PURE__ */ new Map();
+      map.set(other, Math.max(map.get(other) ?? 0, strength));
+      equivalentWith.set(self, map);
+    }
+  }
+  for (const audit of report2.lines) {
+    const { start, end } = lineRange(rawLines, audit.line);
+    const push = (sourceName, severity, message) => {
+      out.push({ source: sourceName, severity, line: audit.line, start, end, message });
+    };
+    const conflict = audit.contradicts.find((c) => c.confirmed);
+    if (conflict) {
+      push(
+        "semantic/contradicts",
+        "warn",
+        `Semantic conflict \u2014 this appears to contradict line ${disp(conflict.line)} (confidence ${conflict.conf.toFixed(2)}). Advisory: review both lines.`
+      );
+      continue;
+    }
+    if (audit.proposedRemovable && audit.coveredBy.length > 0) {
+      const coverLines = audit.coveredBy.map((c) => c.line);
+      const minEnt = Math.min(...audit.coveredBy.map((c) => c.ent));
+      const high = audit.residual <= THETA_REDUNDANCY_WARN;
+      push(
+        "semantic/covered",
+        high ? "warn" : "info",
+        `${high ? "High redundancy" : "Covered"} \u2014 everything this line asserts is already said by ${fmtLines(coverLines, disp)} (the semantic tier reads entailment \u2265 ${minEnt.toFixed(2)}), leaving only ${Math.round(audit.residual * 100)}% of its meaning as its own (residual ${audit.residual.toFixed(2)}). Consolidate into one statement \u2014 and verify with the test suite before cutting.`
+      );
+      continue;
+    }
+    const dupes = equivalentWith.get(audit.line);
+    if (dupes && dupes.size > 0) {
+      const strongest = Math.max(...dupes.values());
+      const high = strongest >= THETA_EQUIVALENT_WARN;
+      push(
+        "semantic/equivalent",
+        high ? "warn" : "info",
+        `${high ? "High redundancy \u2014 interchangeable with" : "Duplicate meaning \u2014 says the same thing as"} ${fmtLines([...dupes.keys()], disp)} (each implies the other, mutual entailment \u2265 ${strongest.toFixed(2)}). State it once and reference it.`
+      );
+    }
+  }
+  for (const v of report2.pairs) {
+    if (v.relation !== "covers" && v.relation !== "covered_by" || v.directionConfidence < THETA_DIRECTION_ACTIONABLE) continue;
+    const narrowAtom = v.relation === "covers" ? v.b : v.a;
+    const broadAtom = v.relation === "covers" ? v.a : v.b;
+    const narrow = atomById.get(narrowAtom);
+    const broad = atomById.get(broadAtom);
+    if (!narrow || !broad || narrow.line === broad.line) continue;
+    if (out.some((d) => d.line === narrow.line)) continue;
+    const { start, end } = lineRange(rawLines, narrow.line);
+    out.push({
+      source: "semantic/covered",
+      severity: "info",
+      line: narrow.line,
+      start,
+      end,
+      message: `Subsumed \u2014 a broader rule on line ${disp(broad.line)} already implies this (confidence ${v.directionConfidence.toFixed(2)}). Consider removing the narrower restatement.`
+    });
+  }
+  return out;
+}
+
+// src/core/resolve.ts
+var norm = (v) => String(v ?? "").trim().toLowerCase();
+function resolve(source, bag, opts = {}) {
+  const lines = source.split("\n");
+  return applyResolve(lines, buildStructure(lines), parseSwitches(lines), bag, opts);
+}
+function applyResolve(lines, doc, switches, bag, opts = {}) {
+  const fullBag = { ...bag };
+  const defs = [];
+  for (const [name, d] of doc.defines) {
+    const ast = parseExpr(d.expr).ast;
+    if (ast) defs.push({ name, ast });
+  }
+  for (let pass = 0; pass < defs.length; pass += 1) for (const { name, ast } of defs) fullBag[name] = evalExpr(ast, fullBag);
+  const rewrite = /* @__PURE__ */ new Map();
+  const blockVars = (block) => {
+    if (block.kind === "value") return [block.varName];
+    if (block.kind === "tuple") return block.varNames ?? [];
+    const names = /* @__PURE__ */ new Set();
+    for (const arm of block.arms) {
+      if (arm.predicate === void 0) continue;
+      const { ast } = parseExpr(arm.predicate);
+      if (ast) for (const a of exprAtoms(ast)) names.add(a.name);
+    }
+    return [...names];
+  };
+  const allBound = (vars) => vars.every((v) => v in fullBag);
+  for (const block of switches) {
+    if (block.error !== null) continue;
+    if (!allBound(blockVars(block))) continue;
+    for (let l = block.headerLine; l < block.blockEnd; l += 1) rewrite.set(l, null);
+    let p = block.headerLine - 1;
+    while (p >= 0 && ((lines[p] ?? "").trim() === "" || (lines[p] ?? "").trim().startsWith("//"))) p -= 1;
+    if (p >= 0 && isAnnotationLine(lines[p] ?? "")) rewrite.set(p, null);
+    const arm = block.kind === "predicate" ? selectPredicateArm(block, (expr) => {
+      const { ast } = parseExpr(expr);
+      return ast === null ? false : evalExpr(ast, fullBag);
+    }) : block.kind === "tuple" ? selectTupleArm(block, (block.varNames ?? []).map((n) => norm(fullBag[n]))) : selectArm(block, norm(fullBag[block.varName]));
+    if (arm === null) continue;
+    if (arm.inlineBody !== "") rewrite.set(arm.headerLine, " ".repeat(block.indent) + arm.inlineBody);
+    const lead = (s) => s.length - s.trimStart().length;
+    const bodyLines = [];
+    for (let l = arm.headerLine + 1; l < arm.spanEnd; l += 1) bodyLines.push(l);
+    const nonBlank = bodyLines.filter((l) => (lines[l] ?? "").trim() !== "");
+    if (nonBlank.length === 0) continue;
+    const base = Math.min(...nonBlank.map((l) => lead(lines[l] ?? "")));
+    for (const l of bodyLines) {
+      const raw = lines[l] ?? "";
+      if (raw.trim() === "") {
+        rewrite.set(l, "");
+        continue;
+      }
+      rewrite.set(l, " ".repeat(block.indent + Math.max(0, lead(raw) - base)) + raw.trimStart());
+    }
+  }
+  const stripWhen = (line) => (lines[line] ?? "").replace(/\s*\bwhen=[^>]*>/i, ">");
+  for (const sec of doc.sections) {
+    if (sec.syntax !== "xml" || !sec.guard) continue;
+    const { ast } = parseExpr(sec.guard.text);
+    const guardVars = ast ? exprAtoms(ast).map((a) => a.name) : [];
+    if (!allBound(guardVars)) {
+      if (opts.keepUndecidedGuards !== true) rewrite.set(sec.startLine, stripWhen(sec.startLine));
+      continue;
+    }
+    const keep = ast === null ? true : evalExpr(ast, fullBag);
+    if (keep) rewrite.set(sec.startLine, stripWhen(sec.startLine));
+    else for (let l = sec.startLine; l < sec.endLine; l += 1) rewrite.set(l, null);
+  }
+  const pick = (v) => norm(fullBag[v]);
+  const out = [];
+  lines.forEach((line, i) => {
+    if (!rewrite.has(i)) {
+      out.push(resolveInlineText(line, pick));
+      return;
+    }
+    const r = rewrite.get(i);
+    if (r !== null && r !== void 0) out.push(resolveInlineText(r, pick));
+  });
+  return out.join("\n");
+}
+
+// src/core/compile.ts
+function resolveModel(blocks, services) {
+  const m = blocks.find((b) => b.kind === "model");
+  if (!m || m.value === "") return void 0;
+  const num = (k) => {
+    const v = m.params.get(k);
+    const n = v === void 0 ? NaN : Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  };
+  const via = m.params.get("via");
+  const svc = via !== void 0 && via !== "" ? services.find((s) => s.name === via) : void 0;
+  return {
+    id: m.value,
+    maxTokens: num("max_tokens"),
+    temperature: num("temperature"),
+    ...svc ? { service: { name: svc.name, base: svc.base, headers: svc.headers } } : {}
+  };
+}
+function compile(source, opts = {}) {
+  const rawLines = source.split("\n");
+  const diagnostics = runDiagnostics(rawLines, opts.rubric ?? [], { isWord: opts.isWord, addressees: opts.addressees, glishConfig: opts.glishConfig });
+  const doc = buildStructure(rawLines);
+  const model = resolveModel(parseConfigBlocks(rawLines), parseServices(rawLines).services);
+  return {
+    ir: lower(source),
+    diagnostics,
+    agent: { config: Object.fromEntries(doc.config), model, tools: doc.toolDefs },
+    consistent: !diagnostics.some((d) => d.source.startsWith("logic/") && d.severity === "error"),
+    wellFormed: !diagnostics.some((d) => d.source.startsWith("structure/") && d.severity === "error"),
+    // Step anchors (`#greet`) are author-facing identity — resolve them to step numbers and strip declarations
+    // before tagging, so the compiled prompt the model runs is clean and its step references are followable.
+    xml: compileToXml(resolveAnchors(source), resolveAnchors(opts.instructions ?? ""))
+  };
+}
+function numericDiagnostics(conflicts, source) {
+  const lines = source.split("\n");
+  const ordinals = lineOrdinals(lines);
+  const disp = (i) => displayLine(ordinals, i);
+  const out = [];
+  for (const c of conflicts) {
+    for (const ln of c.lines) {
+      const raw = lines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = c.lines.find((x) => x !== ln);
+      out.push({
+        source: "logic/numeric",
+        severity: "error",
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: other !== void 0 ? `${c.message} (conflicts with line ${disp(other)})` : c.message
+      });
+    }
+  }
+  return out;
+}
+function structuralDiagnostics(conflicts, source) {
+  const lines = source.split("\n");
+  const ordinals = lineOrdinals(lines);
+  const disp = (i) => displayLine(ordinals, i);
+  const out = [];
+  for (const c of conflicts) {
+    for (const ln of c.lines) {
+      const raw = lines[ln] ?? "";
+      const lead = raw.length - raw.trimStart().length;
+      const other = c.lines.find((x) => x !== ln);
+      out.push({
+        source: `structure/${c.code}`,
+        severity: c.severity,
+        line: ln,
+        start: lead,
+        end: raw.length,
+        message: other !== void 0 ? `${c.message} (conflicts with line ${disp(other)})` : c.message
+      });
+    }
+  }
+  return out;
+}
+function prepareTemplate(source) {
+  const lines = source.split("\n");
+  const doc = buildStructure(lines);
+  const switches = parseSwitches(lines);
+  return {
+    source,
+    resolve: (bag) => applyResolve(lines, doc, switches, bag),
+    render: (bag) => compileToXml(applyResolve(lines, doc, switches, bag), "")
+  };
+}
+
+// src/core/report.ts
+var SEV_RANK2 = { error: 3, warn: 2, info: 1 };
+function splitCode(source) {
+  const i = source.indexOf("/");
+  return i < 0 ? { category: source, name: source } : { category: source.slice(0, i), name: source.slice(i + 1) };
+}
+function effectiveSeverity(d, category, importance, policy) {
+  const listed = (list) => !!list && (list.includes(d.source) || list.includes(category));
+  if (listed(policy.relax)) return "info";
+  if (d.severity === "error") return "error";
+  const raise = listed(policy.escalate) || policy.escalateImportance !== void 0 && atLeastImportant(importance, policy.escalateImportance) || policy.strict === true && d.severity === "warn";
+  return raise ? "error" : d.severity;
+}
+function describeType(type) {
+  if (!type) return "untyped";
+  return type.kind === "enum" ? `enum(${(type.members ?? []).join("|")})` : type.kind;
+}
+function summarize(source) {
+  const lines = source.split("\n");
+  const doc = buildStructure(lines);
+  const blocks = parseSwitches(lines);
+  const count = (kind) => blocks.filter((b) => b.kind === kind && b.error === null).length;
+  return {
+    inputs: doc.imports.filter((im) => im.kind === "variable").map((im) => ({ name: im.name, type: describeType(doc.inputTypes.get(im.name)) })),
+    defines: [...doc.defines.keys()],
+    sections: doc.sections.map((s) => s.tag),
+    tools: [...doc.index.tools],
+    routes: [...doc.index.routes],
+    steps: doc.steps.length,
+    switches: { value: count("value"), predicate: count("predicate"), tuple: count("tuple"), inline: parseInlineSwitches(lines).filter((s) => s.error === null).length }
+  };
+}
+function report(source, opts = {}) {
+  const policy = opts.policy ?? {};
+  const compiled = compile(source, opts.compile);
+  const all = [...compiled.diagnostics, ...opts.extraDiagnostics ?? []];
+  const diagnostics = all.map((d) => {
+    const { category, name } = splitCode(d.source);
+    const importance = importanceOf(d.source, d.severity);
+    const eff = effectiveSeverity(d, category, importance, policy);
+    return {
+      code: d.source,
+      category,
+      name,
+      importance,
+      severity: d.severity,
+      effectiveSeverity: eff,
+      blocking: eff === "error",
+      range: { line: d.line + 1, column: d.start + 1, endColumn: d.end + 1 },
+      message: d.message,
+      ...d.fix ? { fix: d.fix } : {}
+    };
+  }).sort((a, b) => a.range.line - b.range.line || SEV_RANK2[b.effectiveSeverity] - SEV_RANK2[a.effectiveSeverity]);
+  const counts = {
+    error: diagnostics.filter((d) => d.effectiveSeverity === "error").length,
+    warn: diagnostics.filter((d) => d.effectiveSeverity === "warn").length,
+    info: diagnostics.filter((d) => d.effectiveSeverity === "info").length
+  };
+  return {
+    ok: counts.error === 0,
+    consistent: compiled.consistent,
+    wellFormed: compiled.wellFormed,
+    counts,
+    diagnostics,
+    program: summarize(source),
+    xml: compiled.xml
+  };
+}
+
+export { CHARSET_DOC, INDENT_UNIT, OBLIGATE, PROHIBIT, applyFix, assembleAudits, atLeastImportant, buildReport, candidatePairs, classifyPair, compile, composeSpans, decompose, importanceOf, layoutColumns, numericDiagnostics, prepareTemplate, proposeReduction, rename, renderLines, report, resolve, ruleCoverage, runDiagnostics, semanticDiagnostics, structuralDiagnostics, verdictFrom };
+//# sourceMappingURL=chunk-KRYC4OTL.js.map
+//# sourceMappingURL=chunk-KRYC4OTL.js.map