explico 0.5.0 → 0.7.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,12 @@ 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 }
     });
   }
   for (const diagnostic of manifest.diagnostics.equations) {
@@ -81,7 +85,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 +102,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 +111,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 +305,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 +320,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 +360,65 @@ 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 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";
+      diagnostics.push({
+        code: `${group}:${detail}`,
+        severity,
+        message: String(diagnostic.message ?? detail),
+        ...file === void 0 ? {} : { file },
+        ...line === void 0 ? {} : { line },
+        ...column === void 0 ? {} : { column }
+      });
     }
+  }
+  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 +658,9 @@ export {
   changedLessonIds,
   contentCheck,
   contentContext,
+  contentDiagnostics,
   contentStatus,
+  contentWarnings,
   estimateTokens,
   findLesson,
   lessonDiagnostics,

package/dist/compiler/course-config.d.ts

@@ -107,6 +107,33 @@ interface CourseAbout {
     /** Link to the published content changelog (repo blob, docs page, …). */
     readonly changelogHref?: string;
 }
+/**
+ * A course's chosen initial open/closed state for the engine's own built-in
+ * collapsible sections — the "Page notation" panel (`NotationLayer.astro`)
+ * and the generated "References" section (`remark-citation.mjs`). Each is
+ * independent of `defaultCollapsible.sections`/`.subsections` (an author's
+ * own `##` headings): both of these are engine-authored, not written by a
+ * lesson, so they need their own default rather than inheriting the site's
+ * general heading default.
+ *
+ * `true` starts open, `false` (or omitted) starts closed — the engine's own
+ * default is closed either way, matching a long panel a reader usually
+ * doesn't need open on arrival.
+ */
+interface CourseDisclosureDefaults {
+    /** Initial state of the "Page notation" panel. Default: closed. */
+    readonly notation?: boolean;
+    /** Initial state of the generated "References" section. Default: closed. */
+    readonly references?: boolean;
+}
+/** The stable, non-optional form `NormalizedLessonExports` mirrors. */
+interface NormalizedDisclosureDefaults {
+    readonly notation: boolean;
+    readonly references: boolean;
+}
+/** Validate and canonicalize `CourseConfig.disclosureDefaults`. Absent (or
+ *  an absent sub-field) resolves to closed, the engine's own default. */
+declare function normalizeDisclosureDefaults(config: CourseConfig): NormalizedDisclosureDefaults;
 /** Optional, build-time lesson artifacts exposed to readers. */
 interface LessonExportsConfig {
     /** Emit one self-contained, offline-capable HTML file per lesson. */
@@ -151,6 +178,9 @@ interface CourseConfig {
     readonly abbreviations?: CourseAbbreviations;
     /** Per-lesson export actions and downloadable artifacts. Disabled when omitted. */
     readonly lessonExports?: LessonExportsConfig;
+    /** Initial open/closed state for the engine's own built-in collapsible
+     *  sections ("Page notation", "References"). Closed when omitted. */
+    readonly disclosureDefaults?: CourseDisclosureDefaults;
 }
 /** Validate and canonicalize the build-facing lesson-export configuration. */
 declare function normalizeLessonExports(config: CourseConfig): NormalizedLessonExports;
@@ -161,4 +191,4 @@ declare function normalizeLessonExports(config: CourseConfig): NormalizedLessonE
  */
 declare function coursePartsOf(config: CourseConfig): readonly CoursePart[];
 
-export { type CourseAbbreviations, type CourseAbout, type CourseAuthor, type CourseConfig, type CourseConventions, type CourseOperators, type CoursePart, type CourseRomanLabels, type CourseSection, type LessonExportsConfig, type NormalizedLessonExports, coursePartsOf, normalizeLessonExports };
+export { type CourseAbbreviations, type CourseAbout, type CourseAuthor, type CourseConfig, type CourseConventions, type CourseDisclosureDefaults, type CourseOperators, type CoursePart, type CourseRomanLabels, type CourseSection, type LessonExportsConfig, type NormalizedDisclosureDefaults, type NormalizedLessonExports, coursePartsOf, normalizeDisclosureDefaults, normalizeLessonExports };

package/dist/compiler/course-config.js

@@ -1,3 +1,9 @@
+function normalizeDisclosureDefaults(config) {
+  return {
+    notation: config.disclosureDefaults?.notation === true,
+    references: config.disclosureDefaults?.references === true
+  };
+}
 function normalizeLessonExports(config) {
   const standaloneHtml = config.lessonExports?.standaloneHtml === true;
   const print = config.lessonExports?.print === true;
@@ -35,5 +41,6 @@ function coursePartsOf(config) {
 }
 export {
   coursePartsOf,
+  normalizeDisclosureDefaults,
   normalizeLessonExports
 };

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,109 @@
+/**
+ * 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;
+}
+/** `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] message`, matching what the console has always printed. */
+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,107 @@
+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}] `;
+  return at === "" ? `${prefix}${diagnostic.message}` : `${prefix}${at}: ${diagnostic.message}`;
+}
+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

@@ -10,7 +10,7 @@ import { MathGateDiagnostic } from '../reference/gate-math.js';
 import { ContentSegment } from '../reference/mixed-content.js';
 import { GlyphScopeEntry } from '../reference/gloss.js';
 import { NotationDefinitionRecord, NotationPageBundle, NotationBacklink, NotationDiagnostic, EditorialStatus, NotationGlossEntry } from '../reference/types.js';
-import { NormalizedLessonExports, CourseConfig } from './course-config.js';
+import { NormalizedLessonExports, NormalizedDisclosureDefaults, CourseConfig } from './course-config.js';
 import { KnowledgeVersionDiagnostic } from './knowledge-version.js';
 import { SidebarGroup } from './lesson-derivation.js';
 import './collections.js';
@@ -90,8 +90,18 @@ import '../reference/keyed-float-validate.js';
  * validation and can never get a stable number or `[[…]]` reference; this
  * flags it (warning-only — the manifest shape a client already reads is
  * unchanged).
+ * v14 (disclosure defaults, additive): `disclosureDefaults` — the resolved
+ * initial open/closed state for the "Page notation" panel and the generated
+ * "References" section, from `CourseConfig.disclosureDefaults`. Both are
+ * 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 = 13;
+declare const MANIFEST_SCHEMA_VERSION = 15;
 declare const MANIFEST_PATH: string;
 interface ManifestCitation {
     readonly id: string;
@@ -256,6 +266,8 @@ interface Manifest {
     readonly schemaVersion: number;
     /** Normalized build/UI settings for opt-in per-lesson exports. */
     readonly lessonExports: NormalizedLessonExports;
+    /** Initial open/closed state for "Page notation" and "References". */
+    readonly disclosureDefaults: NormalizedDisclosureDefaults;
     /** Reader-facing identity + versions (the `[?]` About panel). */
     readonly about: ManifestAbout;
     readonly notation: {
@@ -316,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

@@ -45,6 +45,7 @@ import {
   gateProseNotationInAssessments
 } from "../reference/gate-prose-notation.js";
 import { gateAbbreviations } from "../reference/gate-abbreviations.js";
+import { gateHeadingLength } from "../reference/gate-heading-length.js";
 import {
   splitMixedContent
 } from "../reference/mixed-content.js";
@@ -54,7 +55,8 @@ import { formulaGlyphScope } from "../reference/gloss.js";
 import { resolveReferenceId } from "../reference/references.js";
 import {
   coursePartsOf,
-  normalizeLessonExports
+  normalizeLessonExports,
+  normalizeDisclosureDefaults
 } from "./course-config.js";
 import {
   resolveKnowledgeVersion
@@ -73,7 +75,7 @@ import {
   isLessonSlug,
   lessonIdFromSlug
 } from "./lesson-derivation.js";
-const MANIFEST_SCHEMA_VERSION = 13;
+const MANIFEST_SCHEMA_VERSION = 15;
 const REPOSITORY_ROOT = process.cwd();
 const CONTENT_ROOT = join(REPOSITORY_ROOT, "content");
 const MANIFEST_PATH = join(REPOSITORY_ROOT, "build", "manifest.json");
@@ -243,7 +245,8 @@ async function compileManifest(courseConfig) {
       notationInput,
       abbreviations: abbreviationsInput,
       courseAbbreviations: courseConfig.abbreviations
-    })
+    }),
+    ...gateHeadingLength(notationInput.lessons)
   ];
   const notationLessonById = new Map(
     notationInput.lessons.map((lesson) => [lesson.lessonId, lesson])
@@ -517,6 +520,7 @@ async function compileManifest(courseConfig) {
   return {
     schemaVersion: MANIFEST_SCHEMA_VERSION,
     lessonExports: normalizeLessonExports(courseConfig),
+    disclosureDefaults: normalizeDisclosureDefaults(courseConfig),
     about,
     notation: {
       definitions: registry.definitions,

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;