explico 0.6.0 → 0.8.0

package/dist/compiler/cli.js

@@ -30,6 +30,9 @@ class ContentCliError extends Error {
     this.code = code;
   }
 }
+function diagnosticSeverity(value) {
+  return value === "info" || value === "warning" ? value : "error";
+}
 function mentions(message, lessonId, file) {
   return message.includes(lessonId) || message.includes(file) || message.includes(file.replace(/^content\/docs\//, ""));
 }
@@ -42,7 +45,7 @@ function lessonDiagnostics(manifest, lesson) {
     if (!mentions(issue.message, id, file)) continue;
     out.push({
       code: `curriculum:${issue.kind}`,
-      severity: issue.severity === "warning" ? "warning" : "error",
+      severity: diagnosticSeverity(issue.severity),
       message: issue.message
     });
   }
@@ -57,7 +60,7 @@ function lessonDiagnostics(manifest, lesson) {
     }
     out.push({
       code: `${group}:${entry.code}`,
-      severity: entry.severity === "warning" ? "warning" : "error",
+      severity: diagnosticSeverity(entry.severity),
       message: entry.message,
       ...withFile(entryFile)
     });
@@ -68,11 +71,13 @@ function lessonDiagnostics(manifest, lesson) {
     );
     if (!forLesson) continue;
     out.push({
-      code: `math:${diagnostic.context}`,
+      code: `math:${diagnostic.code ?? diagnostic.context}`,
       severity: diagnostic.severity,
       message: diagnostic.message,
       file: diagnostic.file,
-      ...diagnostic.line === void 0 ? {} : { line: diagnostic.line }
+      ...diagnostic.line === void 0 ? {} : { line: diagnostic.line },
+      ...diagnostic.column === void 0 ? {} : { column: diagnostic.column },
+      ...diagnostic.equation === void 0 ? {} : { equation: diagnostic.equation }
     });
   }
   for (const diagnostic of manifest.diagnostics.equations) {
@@ -81,7 +86,7 @@ function lessonDiagnostics(manifest, lesson) {
     }
     out.push({
       code: `equations:${diagnostic.code}`,
-      severity: diagnostic.severity === "warning" ? "warning" : "error",
+      severity: diagnosticSeverity(diagnostic.severity),
       message: diagnostic.message,
       ...withFile(diagnostic.file)
     });
@@ -98,7 +103,7 @@ function lessonDiagnostics(manifest, lesson) {
     }
     out.push({
       code: diagnostic.code,
-      severity: diagnostic.severity === "warning" ? "warning" : "error",
+      severity: diagnosticSeverity(diagnostic.severity),
       message: diagnostic.message,
       ...withFile(diagnostic.file)
     });
@@ -107,7 +112,7 @@ function lessonDiagnostics(manifest, lesson) {
     if (diagnostic.file !== file && diagnostic.lessonId !== id) continue;
     out.push({
       code: `consistency:${diagnostic.code}`,
-      severity: "warning",
+      severity: diagnostic.severity,
       message: diagnostic.message,
       ...withFile(diagnostic.file)
     });
@@ -301,7 +306,7 @@ function contentStatus(manifest) {
   const draftNotation = manifest.notation.definitions.filter((definition) => definition.status === "draft").map((definition) => definition.id).sort();
   const orphans = manifest.notation.diagnostics.filter((diagnostic) => diagnostic.code === "unused-definition").map((diagnostic) => ({
     code: `notation:${diagnostic.code}`,
-    severity: diagnostic.severity === "warning" ? "warning" : "error",
+    severity: diagnosticSeverity(diagnostic.severity),
     message: diagnostic.message,
     ...diagnostic.source?.file === void 0 ? {} : { file: diagnostic.source.file }
   })).sort((a, b) => a.message.localeCompare(b.message));
@@ -316,7 +321,7 @@ function contentStatus(manifest) {
     ...manifest.diagnostics.diagrams.map((d) => d.severity),
     ...manifest.diagnostics.checks.map((d) => d.severity),
     ...manifest.diagnostics.rawFloats.map((d) => d.severity),
-    ...manifest.diagnostics.consistency.map(() => "warning"),
+    ...manifest.diagnostics.consistency.map((d) => d.severity),
     ...manifest.diagnostics.knowledge.map((d) => d.severity)
   ];
   const keyedEquations = manifest.lessons.reduce(
@@ -356,10 +361,72 @@ function contentStatus(manifest) {
     orphans,
     diagnostics: {
       errors: allDiagnostics.filter((severity) => severity === "error").length,
-      warnings: allDiagnostics.filter((severity) => severity === "warning").length
+      warnings: allDiagnostics.filter((severity) => severity === "warning").length,
+      infos: allDiagnostics.filter((severity) => severity === "info").length
     }
   };
 }
+function equationLink(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const { key, href } = value;
+  return typeof key === "string" && typeof href === "string" ? { key, href } : void 0;
+}
+function numericLocation(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+const SEVERITY_RANK = {
+  info: 0,
+  warning: 1,
+  error: 2
+};
+function contentDiagnostics(manifest, minimumSeverity = "info") {
+  const lessonFileByHint = /* @__PURE__ */ new Map();
+  for (const lesson of manifest.lessons) {
+    lessonFileByHint.set(lesson.id, lesson.file);
+    lessonFileByHint.set(lesson.slug, lesson.file);
+    lessonFileByHint.set(lesson.file, lesson.file);
+  }
+  const groups = Object.entries(manifest.diagnostics);
+  const diagnostics = [];
+  for (const [group, values] of groups) {
+    for (const value of values) {
+      const diagnostic = value;
+      const severity = diagnosticSeverity(diagnostic.severity);
+      if (SEVERITY_RANK[severity] < SEVERITY_RANK[minimumSeverity]) continue;
+      const source = diagnostic.source !== null && typeof diagnostic.source === "object" ? diagnostic.source : void 0;
+      const rawFile = typeof diagnostic.file === "string" ? diagnostic.file : typeof source?.file === "string" ? source.file : void 0;
+      const lessonId = typeof diagnostic.lessonId === "string" ? diagnostic.lessonId : void 0;
+      const file = (rawFile === void 0 ? void 0 : lessonFileByHint.get(rawFile)) ?? (lessonId === void 0 ? void 0 : lessonFileByHint.get(lessonId)) ?? rawFile;
+      const line = numericLocation(diagnostic.line) ?? numericLocation(source?.line);
+      const column = numericLocation(diagnostic.column) ?? numericLocation(source?.column);
+      const detail = typeof diagnostic.code === "string" ? diagnostic.code : typeof diagnostic.kind === "string" ? diagnostic.kind : "diagnostic";
+      const equation = equationLink(diagnostic.equation);
+      diagnostics.push({
+        code: `${group}:${detail}`,
+        severity,
+        message: String(diagnostic.message ?? detail),
+        ...file === void 0 ? {} : { file },
+        ...line === void 0 ? {} : { line },
+        ...column === void 0 ? {} : { column },
+        ...equation === void 0 ? {} : { equation }
+      });
+    }
+  }
+  diagnostics.sort(
+    (left, right) => (left.file ?? "").localeCompare(right.file ?? "") || (left.line ?? 0) - (right.line ?? 0) || (left.column ?? 0) - (right.column ?? 0) || left.code.localeCompare(right.code) || left.message.localeCompare(right.message)
+  );
+  return {
+    minimumSeverity,
+    count: diagnostics.length,
+    diagnostics
+  };
+}
+function contentWarnings(manifest) {
+  const warnings = contentDiagnostics(manifest, "warning").diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "warning"
+  );
+  return { count: warnings.length, warnings };
+}
 function contentContext(manifest, rawId) {
   const lesson = findLesson(manifest, rawId);
   const { frontmatter, body } = lessonRaw(lesson);
@@ -599,7 +666,9 @@ export {
   changedLessonIds,
   contentCheck,
   contentContext,
+  contentDiagnostics,
   contentStatus,
+  contentWarnings,
   estimateTokens,
   findLesson,
   lessonDiagnostics,

package/dist/compiler/collections.js

@@ -25,12 +25,24 @@ function filesBelow(directory, extensions) {
     return entry.isFile() && extensions.some((extension) => entry.name.endsWith(extension)) ? [path] : [];
   }).sort();
 }
+function bodyStartLine(raw, body) {
+  const offset = raw.endsWith(body) ? raw.length - body.length : raw.indexOf(body);
+  if (offset <= 0) return 1;
+  let line = 1;
+  for (let index = 0; index < offset; index += 1) {
+    if (raw.charCodeAt(index) === 10) line += 1;
+  }
+  return line;
+}
 function parseDocument(path) {
-  const parsed = parseFrontmatter(readFileSync(path, "utf8"));
+  const raw = readFileSync(path, "utf8");
+  const parsed = parseFrontmatter(raw);
+  const body = parsed.content.replace(/^\n/, "");
   return {
     file: relative(REPOSITORY_ROOT, path),
     data: parsed.frontmatter ?? {},
-    body: parsed.content.replace(/^\n/, "")
+    body,
+    bodyLine: bodyStartLine(raw, body)
   };
 }
 function record(value, label) {
@@ -322,7 +334,7 @@ function notationLessonEntries() {
   for (const path of filesBelow(join(CONTENT_ROOT, "docs"), [".md", ".mdx"])) {
     const slug = docSlug(path);
     if (!isLessonSlug(slug)) continue;
-    const { file, data, body } = parseDocument(path);
+    const { file, data, body, bodyLine } = parseDocument(path);
     const notation = record(data.notation ?? {}, `${file} notation`);
     const local = Array.isArray(notation.local) ? notation.local : [];
     lessons.push({
@@ -333,6 +345,7 @@ function notationLessonEntries() {
       ),
       references: extractNotationReferences(body, file, void 0),
       body,
+      bodyLine,
       source: { file }
     });
   }

package/dist/compiler/exports/standalone-html.js

@@ -584,6 +584,18 @@ async function inlineResourceAttribute(node, name, context) {
   const path = await resolveLocalFile(reference, context.sourceFile, context.outputRoot);
   setAttribute(node, name, await assetDataUrl(path, context));
 }
+const INLINEABLE_LINK_RELS = /* @__PURE__ */ new Set([
+  "stylesheet",
+  "icon",
+  "shortcut icon",
+  "apple-touch-icon",
+  "apple-touch-icon-precomposed",
+  "mask-icon"
+]);
+function isInlineableLinkRel(node) {
+  const rel = attribute(node, "rel");
+  return rel !== void 0 && INLINEABLE_LINK_RELS.has(rel.trim().toLowerCase());
+}
 function parseSourceSet(value) {
   const candidates = value.match(/(?:[^\s,]+)(?:\s+(?:\d+w|\d+(?:\.\d+)?x))?/gu) ?? [];
   return candidates.map((candidate) => {
@@ -609,6 +621,7 @@ async function inlineMedia(document, context) {
         "Standalone HTML does not support an iframe src; use self-contained semantic DOM instead."
       );
     }
+    if (node.tagName === "link" && !isInlineableLinkRel(node)) continue;
     const names = resources[node.tagName] ?? [];
     for (const name of names) await inlineResourceAttribute(node, name, context);
     if (node.tagName === "use" || node.tagName === "image") {

package/dist/compiler/logging.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Run logs for `pnpm validate:content`, in Python's `logging` format.
+ *
+ * The terminal keeps the compact `[code] message` lines it has always shown.
+ * This module is the second handler over the same records: it writes them to
+ * `build/logs/<timestamp>/` in the format Python's `logging` emits, so a run
+ * can be grepped by level and by subsystem long after the terminal scrolled
+ * away.
+ *
+ *     %(asctime)s %(levelname)s %(name)s: %(message)s
+ *
+ *     2026-09-18 03:22:47,482 WARNING explico.notation: [undefined-reference] …
+ *
+ * Three files per run, each a superset of the one above it, so you open the
+ * narrowest one that still answers the question:
+ *
+ *     build/logs/2026-09-18T03-22-47/
+ *       error.log     errors only
+ *       warning.log   errors + warnings
+ *       info.log      errors + warnings + info
+ *
+ * Nothing is pruned — `build/` is git-ignored, so old runs are yours to clean
+ * up — and `build/logs/latest` points at the newest run.
+ *
+ * Levels carry their Python meaning. `error` is a blocking diagnostic (the
+ * caller still throws; this module only records), `warning` is a non-blocking
+ * finding, and `info` is the run summary plus the severity-`info` diagnostics
+ * the engine has always produced but never printed.
+ *
+ * Each level method **returns its message**, so a call site can log and print
+ * in one expression without the two drifting apart:
+ *
+ *     console.warn(log.warning('notation', `[${d.code}] ${d.message}`));
+ */
+/** Sits beside `build/manifest.json` and `build/resolution/` (Phase F). */
+declare const LOGS_DIR: string;
+/** Python's levels, narrowed to the three the engine actually emits. */
+type LogLevel = 'ERROR' | 'WARNING' | 'INFO';
+/**
+ * Python's `%(asctime)s` — local time, with the comma before the milliseconds
+ * that `logging.Formatter` writes by default.
+ */
+declare function formatTimestamp(date: Date): string;
+/** A filesystem-safe local-time stamp for the run directory's name. */
+declare function formatRunStamp(date: Date): string;
+/**
+ * `explico.<source>` — the logger name is the diagnostic's subsystem, so
+ * filtering by name is filtering by subsystem. `rawFloats` becomes
+ * `explico.raw-floats`; anything already lowercase passes through.
+ */
+declare function loggerName(source: string): string;
+/** One formatted line, without its trailing newline. */
+declare function formatRecord(level: LogLevel, source: string, message: string, date: Date): string;
+interface RunLogSummary {
+    /** Absolute path of this run's directory. */
+    readonly directory: string;
+    /** Repo-relative form, for printing. */
+    readonly relativeDirectory: string;
+    readonly counts: Readonly<Record<LogLevel, number>>;
+}
+/** One diagnostic, across every category's slightly different shape. */
+interface AnyDiagnostic {
+    readonly severity?: string;
+    readonly message: string;
+    readonly code?: string;
+    readonly kind?: string;
+    readonly file?: string;
+    readonly line?: number;
+    readonly column?: number;
+    /** `{ key, href }` when the finding belongs to a `\label{eq:…}` equation. */
+    readonly equation?: {
+        readonly key: string;
+        readonly href: string;
+    };
+}
+/** `manifest.diagnostics`, structurally — one array per subsystem. */
+type DiagnosticGroups = Readonly<Record<string, readonly AnyDiagnostic[]>>;
+interface RunLog {
+    /** Absolute path of this run's directory. */
+    readonly directory: string;
+    /** Records at `ERROR` and returns `message`. */
+    error(source: string, message: string): string;
+    /** Records at `WARNING` and returns `message`. */
+    warning(source: string, message: string): string;
+    /** Records at `INFO` and returns `message`. */
+    info(source: string, message: string): string;
+    /**
+     * Sweeps every severity-`info` diagnostic in a manifest's `diagnostics` into
+     * `info.log`. Errors and warnings are deliberately **not** taken from here:
+     * they are recorded at the call site that also prints the console line, so
+     * the two can never drift.
+     */
+    infoDiagnostics(diagnostics: DiagnosticGroups): number;
+    /** Refreshes `latest` and reports what the run recorded. */
+    close(): RunLogSummary;
+}
+/**
+ * `[code] file:line:column: message`, matching what the console has always
+ * printed, with ` (eq:<key> -> <href>)` appended when the finding belongs to a
+ * keyed equation — so a size-only finding inside a long `aligned` block names
+ * the result it is about, not just its coordinates.
+ */
+declare function diagnosticLine(diagnostic: AnyDiagnostic): string;
+interface RunLogOptions {
+    /** Overridden in tests; defaults to `build/logs` under the repository root. */
+    readonly root?: string;
+    /** Overridden in tests so the directory name is deterministic. */
+    readonly now?: Date;
+    /** Set `false` to skip the `latest` symlink. */
+    readonly latest?: boolean;
+}
+/**
+ * Opens a run directory and returns its log. The directory and its three files
+ * are created up front, so a run that crashes before {@link RunLog.close} still
+ * leaves everything recorded up to that point on disk.
+ */
+declare function createRunLog(options?: RunLogOptions): RunLog;
+
+export { type AnyDiagnostic, type DiagnosticGroups, LOGS_DIR, type LogLevel, type RunLog, type RunLogOptions, type RunLogSummary, createRunLog, diagnosticLine, formatRecord, formatRunStamp, formatTimestamp, loggerName };

package/dist/compiler/logging.js

@@ -0,0 +1,108 @@
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync
+} from "node:fs";
+import { join, relative } from "node:path";
+const REPOSITORY_ROOT = process.cwd();
+const LOGS_DIR = join(REPOSITORY_ROOT, "build", "logs");
+const LEVELS = ["ERROR", "WARNING", "INFO"];
+const FILES = [
+  { name: "error.log", level: "ERROR" },
+  { name: "warning.log", level: "WARNING" },
+  { name: "info.log", level: "INFO" }
+];
+function includes(file, record) {
+  return LEVELS.indexOf(record) <= LEVELS.indexOf(file);
+}
+function pad(value, width = 2) {
+  return String(value).padStart(width, "0");
+}
+function formatTimestamp(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())},${pad(date.getMilliseconds(), 3)}`;
+}
+function formatRunStamp(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+}
+function loggerName(source) {
+  const normalized = source.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  return normalized.startsWith("explico.") ? normalized : `explico.${normalized}`;
+}
+function formatRecord(level, source, message, date) {
+  return `${formatTimestamp(date)} ${level} ${loggerName(source)}: ${message}`;
+}
+function diagnosticLine(diagnostic) {
+  const code = diagnostic.code ?? diagnostic.kind;
+  const at = [diagnostic.file, diagnostic.line, diagnostic.column].filter((part) => part !== void 0).join(":");
+  const prefix = code === void 0 ? "" : `[${code}] `;
+  const equation = diagnostic.equation === void 0 ? "" : ` (eq:${diagnostic.equation.key} -> ${diagnostic.equation.href})`;
+  return at === "" ? `${prefix}${diagnostic.message}${equation}` : `${prefix}${at}: ${diagnostic.message}${equation}`;
+}
+function createRunLog(options = {}) {
+  const root = options.root ?? LOGS_DIR;
+  const started = options.now ?? /* @__PURE__ */ new Date();
+  const stamp = formatRunStamp(started);
+  let directory = join(root, stamp);
+  for (let suffix = 2; existsSync(directory); suffix += 1) {
+    directory = join(root, `${stamp}-${suffix}`);
+  }
+  mkdirSync(directory, { recursive: true });
+  for (const file of FILES) writeFileSync(join(directory, file.name), "");
+  const counts = { ERROR: 0, WARNING: 0, INFO: 0 };
+  const record = (level, source, message) => {
+    counts[level] += 1;
+    const line = `${formatRecord(level, source, message, /* @__PURE__ */ new Date())}
+`;
+    for (const file of FILES) {
+      if (includes(file.level, level)) {
+        appendFileSync(join(directory, file.name), line);
+      }
+    }
+    return message;
+  };
+  return {
+    directory,
+    error: (source, message) => record("ERROR", source, message),
+    warning: (source, message) => record("WARNING", source, message),
+    info: (source, message) => record("INFO", source, message),
+    infoDiagnostics(diagnostics) {
+      let written = 0;
+      for (const [source, group] of Object.entries(diagnostics)) {
+        if (!Array.isArray(group)) continue;
+        for (const diagnostic of group) {
+          if (diagnostic.severity !== "info") continue;
+          record("INFO", source, diagnosticLine(diagnostic));
+          written += 1;
+        }
+      }
+      return written;
+    },
+    close() {
+      if (options.latest !== false) {
+        const link = join(root, "latest");
+        try {
+          rmSync(link, { force: true });
+          symlinkSync(directory, link, "dir");
+        } catch {
+        }
+      }
+      return {
+        directory,
+        relativeDirectory: relative(REPOSITORY_ROOT, directory),
+        counts: { ...counts }
+      };
+    }
+  };
+}
+export {
+  LOGS_DIR,
+  createRunLog,
+  diagnosticLine,
+  formatRecord,
+  formatRunStamp,
+  formatTimestamp,
+  loggerName
+};

package/dist/compiler/manifest.d.ts

@@ -96,8 +96,12 @@ import '../reference/keyed-float-validate.js';
  * engine-authored sections, not written by a lesson, so they get their own
  * default independent of a course's `##` heading default; closed unless the
  * course sets one.
+ * v15 (diagnostic severity): public diagnostic severity unions add `info` for
+ * optional advice. Unused keys/definitions and restructuring candidates move
+ * from `warning` to `info`; their diagnostic codes and container fields stay
+ * unchanged.
  */
-declare const MANIFEST_SCHEMA_VERSION = 14;
+declare const MANIFEST_SCHEMA_VERSION = 16;
 declare const MANIFEST_PATH: string;
 interface ManifestCitation {
     readonly id: string;
@@ -324,11 +328,11 @@ interface Manifest {
         readonly notation: readonly NotationDiagnostic[];
         readonly alignment: readonly NotationDiagnostic[];
         readonly math: readonly MathGateDiagnostic[];
-        /** Tier-3 corpus consistency checks (D6). Warnings only. */
+        /** Tier-3 corpus consistency checks (D6). Warnings and optional info. */
         readonly consistency: readonly ConsistencyDiagnostic[];
         /** Knowledge-version checks (C3): `about.version` vs `content/CHANGELOG.md`. Warnings only. */
         readonly knowledge: readonly KnowledgeVersionDiagnostic[];
-        /** Equation-identity checks (D7): `eq-duplicate-key`, `eq-ref-resolves` (error); `eq-key-unused` (warning). */
+        /** Equation identity: broken identities are errors; unused keys are info. */
         readonly equations: readonly EquationDiagnostic[];
         /** `<Table>` identity checks (F-tables-figures) — same codes, `tab-` prefixed. */
         readonly tables: readonly TableDiagnostic[];

package/dist/compiler/manifest.js

@@ -75,7 +75,7 @@ import {
   isLessonSlug,
   lessonIdFromSlug
 } from "./lesson-derivation.js";
-const MANIFEST_SCHEMA_VERSION = 14;
+const MANIFEST_SCHEMA_VERSION = 16;
 const REPOSITORY_ROOT = process.cwd();
 const CONTENT_ROOT = join(REPOSITORY_ROOT, "content");
 const MANIFEST_PATH = join(REPOSITORY_ROOT, "build", "manifest.json");

package/dist/reference/base-abbreviations.mjs

@@ -20,12 +20,18 @@ export const BASE_ABBREVIATIONS = Object.freeze(
     'e.g.',
     'i.e.',
     'etc.',
+    'e.t.c.',
     'cf.',
     'vs.',
-    'a.m.',
-    'p.m.',
     'a.k.a.',
     'et al.',
+    // time of day, in each casing/punctuation style a lesson might use
+    'a.m.',
+    'p.m.',
+    'A.M.',
+    'P.M.',
+    'AM',
+    'PM',
     // generic acronyms with no domain-specific meaning in this engine
     'AI',
     'ID',

package/dist/reference/consistency.d.ts

@@ -8,11 +8,11 @@ import { NotationRegistry, NotationRegistryInput } from './types.js';
  * Corpus consistency checks (Step D6) — the Tier 1–2 checks from the cleanup
  * plan's "Enforced checks" section that no earlier step covers.
  *
- * Every check here enters as a **Tier-3 warning**: `pnpm validate:content`
- * surfaces the counts, `manifest.diagnostics.consistency` records the detail,
- * and `resolution/consistency-report.json` is the committed, diff-checkable
- * snapshot. Nothing here changes content — each finding is an open item for a
- * separate human-quantitative-reviewed pass. A finding is silenced only by a
+ * Every check here is non-blocking Tier 3: repairable violations are warnings
+ * and optional restructuring advice is info. `pnpm validate:content` surfaces
+ * warning counts, `manifest.diagnostics.consistency` records every detail, and
+ * `resolution/consistency-report.json` is the committed, diff-checkable
+ * snapshot. Nothing here changes content. A finding is silenced only by a
  * reviewed line in `lint-ignore.yml` (see `./lint-ignore`).
  *
  *   (a) glyph-unique-in-corpus       one rendered glyph → one meaning corpus-wide
@@ -20,8 +20,6 @@ import { NotationRegistry, NotationRegistryInput } from './types.js';
  *                                     unit strings drawn from a controlled vocab
  *   (c) convention-single-definition  a sign / cash-flow-perspective convention a
  *                                     lesson uses resolves to one declaration
- *   (e) numerals-tagged              numerals in `$…$` / result tables are tagged
- *                                     to a `src/domain/` call or a source locator
  *   (f) weak-local                   a `notation.local` symbol used only in its
  *                                     own defining equation and prose
  *   (g) notation-source-locator      every notation `sources` entry has a locator
@@ -37,11 +35,11 @@ import { NotationRegistry, NotationRegistryInput } from './types.js';
  * `src/content/resolution-report.ts`.
  */
 
-type ConsistencyCode = 'glyph-unique-in-corpus' | 'notation-units' | 'units-vocab' | 'convention-single-definition' | 'numerals-tagged' | 'weak-local' | 'notation-source-locator' | 'gloss-wants-promoting' | 'card-wants-demoting' | 'gloss-name-shape' | 'operator-explained' | 'roman-label-explained';
+type ConsistencyCode = 'glyph-unique-in-corpus' | 'notation-units' | 'units-vocab' | 'convention-single-definition' | 'weak-local' | 'notation-source-locator' | 'gloss-wants-promoting' | 'card-wants-demoting' | 'gloss-name-shape' | 'operator-explained' | 'roman-label-explained';
 interface ConsistencyDiagnostic {
     readonly code: ConsistencyCode;
-    /** Tier 3 — every finding here is a warning until content is brought clean. */
-    readonly severity: 'warning';
+    /** Tier 3 — repairable violations are warnings; optional advice is info. */
+    readonly severity: 'warning' | 'info';
     readonly message: string;
     readonly file?: string;
     readonly lessonId?: string;

package/dist/reference/consistency.js

@@ -17,23 +17,6 @@ function mathSpans(body) {
   }
   return spans;
 }
-function tableRows(body) {
-  const rows = [];
-  for (const line of stripCode(body).split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("|") || !trimmed.slice(1).includes("|")) continue;
-    if (/^\s*\|[\s:|-]+\|\s*$/.test(line)) continue;
-    rows.push(line);
-  }
-  return rows;
-}
-const NUMERAL_RE = /(?<![\w.])-?\d+(?:\.\d+)?/g;
-function numeralCount(text) {
-  return (text.replace(/\\[a-zA-Z]+/g, " ").match(NUMERAL_RE) ?? []).length;
-}
-function isTagged(text) {
-  return /\[@[a-z0-9]/i.test(text) || /<!--\s*domain:/i.test(text);
-}
 function glyphMatcher(latex) {
   const trimmed = latex.trim();
   if (trimmed === "") return void 0;
@@ -141,31 +124,6 @@ function checkConventionSingleDefinition(input, out) {
     });
   }
 }
-function checkNumeralsTagged(input, out) {
-  for (const lesson of input.notationInput.lessons) {
-    if (input.lintIgnore.matches("numerals-tagged", lesson.lessonId)) continue;
-    let math = 0;
-    for (const span of mathSpans(lesson.body)) {
-      if (isTagged(span.latex)) continue;
-      math += numeralCount(span.latex);
-    }
-    let table = 0;
-    for (const row of tableRows(lesson.body)) {
-      if (isTagged(row)) continue;
-      table += numeralCount(row.replace(/\$[^$\n]*\$/g, " "));
-    }
-    const count = math + table;
-    if (count === 0) continue;
-    out.push({
-      code: "numerals-tagged",
-      severity: "warning",
-      lessonId: lesson.lessonId,
-      file: lesson.source.file,
-      count,
-      message: `${lesson.lessonId}: ${count} numeral(s) in $\u2026$ / result tables (${math} in math, ${table} in tables) are not tagged to a src/domain/ call or a source locator`
-    });
-  }
-}
 function checkWeakLocal(input, out) {
   for (const lesson of input.notationInput.lessons) {
     const spans = mathSpans(lesson.body).map((span) => span.latex);
@@ -177,7 +135,7 @@ function checkWeakLocal(input, out) {
       if (uses > 1) continue;
       out.push({
         code: "weak-local",
-        severity: "warning",
+        severity: "info",
         lessonId: lesson.lessonId,
         file: lesson.source.file,
         key: definition.key,
@@ -228,7 +186,7 @@ function checkGlossWantsPromoting(input, out) {
     if (input.lintIgnore.matches("gloss-wants-promoting", glyph)) continue;
     out.push({
       code: "gloss-wants-promoting",
-      severity: "warning",
+      severity: "info",
       glyph,
       message: `gloss ${JSON.stringify(glyph)} (${label}) is declared on ${keys.size} entries (${[...keys].sort().join(", ")}); a meaning reused this widely wants promoting to a card`
     });
@@ -250,7 +208,7 @@ function checkCardWantsDemoting(input, out) {
     }
     out.push({
       code: "card-wants-demoting",
-      severity: "warning",
+      severity: "info",
       key: definition.key,
       file: definition.source.file,
       count: words,
@@ -381,7 +339,6 @@ const CHECKS = [
   checkGlyphUniqueness,
   checkNotationUnits,
   checkConventionSingleDefinition,
-  checkNumeralsTagged,
   checkWeakLocal,
   checkNotationSourceLocator,
   checkGlossWantsPromoting,
@@ -403,7 +360,6 @@ function consistencyCounts(diagnostics) {
     "notation-units": 0,
     "units-vocab": 0,
     "convention-single-definition": 0,
-    "numerals-tagged": 0,
     "weak-local": 0,
     "notation-source-locator": 0,
     "gloss-wants-promoting": 0,