explico 0.13.1 → 0.15.0

package/dist/compiler/cli-verify.js

@@ -0,0 +1,151 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+const VERIFY_DIR = join("node_modules", ".cache", "explico", "verify");
+const RECORD = "last-pass.json";
+const TAIL_LINES = 20;
+function verifyTreeHash(cwd) {
+  try {
+    const git = (args) => execFileSync("git", args, { cwd, maxBuffer: 1 << 30, stdio: ["ignore", "pipe", "ignore"] });
+    const hash = createHash("sha1");
+    hash.update(git(["rev-parse", "HEAD"]));
+    hash.update(git(["diff", "HEAD", "--binary"]));
+    const untracked = git(["ls-files", "--others", "--exclude-standard", "-z"]).toString("utf8").split("\0").filter(Boolean).sort();
+    for (const file of untracked) {
+      hash.update(`\0${file}\0`);
+      if (existsSync(join(cwd, file))) hash.update(readFileSync(join(cwd, file)));
+    }
+    return hash.digest("hex");
+  } catch {
+    return null;
+  }
+}
+function scriptCommand(script, args) {
+  const execpath = process.env.npm_execpath ?? "";
+  const manager = /pnpm/.test(execpath) ? "pnpm" : /yarn/.test(execpath) ? "yarn" : /npm/.test(execpath) ? "npm" : "pnpm";
+  const tail = manager === "npm" && args.length > 0 ? ["run", script, "--", ...args] : ["run", script, ...args];
+  const display = `${manager} ${tail.join(" ")}`;
+  if (execpath === "" || !execpath.includes(manager)) return { file: manager, argv: tail, display };
+  return /\.[cm]?js$/.test(execpath) ? { file: process.execPath, argv: [execpath, ...tail], display } : { file: execpath, argv: tail, display };
+}
+function binCommand(cwd, bin, args) {
+  return { file: join(cwd, "node_modules", ".bin", process.platform === "win32" ? `${bin}.cmd` : bin), argv: [...args], display: [bin, ...args].join(" ") };
+}
+function slug(name) {
+  return name.replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function tailOf(file) {
+  const lines = readFileSync(file, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => line !== "");
+  return lines.slice(-TAIL_LINES);
+}
+function runVerify(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const e2e = options.e2e ?? false;
+  const dir = join(cwd, VERIFY_DIR);
+  const recordFile = join(dir, RECORD);
+  if (!options.force && existsSync(recordFile)) {
+    try {
+      const record = JSON.parse(readFileSync(recordFile, "utf8"));
+      const tree2 = verifyTreeHash(cwd);
+      if (tree2 !== null && record.tree === tree2 && (record.e2e || !e2e)) {
+        return { ok: true, cached: true, since: record.when, tree: tree2, e2e: record.e2e, steps: record.steps };
+      }
+    } catch {
+    }
+  }
+  mkdirSync(dir, { recursive: true });
+  const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+  const scripts = pkg.scripts ?? {};
+  const has = (path) => existsSync(join(cwd, path));
+  const playwrightConfig = ["playwright.config.ts", "playwright.config.mts", "playwright.config.js", "playwright.config.mjs"].some(has);
+  const plans = [
+    scripts["validate:content"] === void 0 ? { name: "validate:content", reason: "package.json has no validate:content script", fail: true } : { name: "validate:content", command: scriptCommand("validate:content", []) },
+    scripts.content === void 0 ? { name: "check --changed", reason: "package.json has no content script", fail: true } : { name: "check --changed", command: scriptCommand("content", ["check", "--changed"]) },
+    // Without @astrojs/check, `astro check` stops to ask whether to install it.
+    has(join("node_modules", "@astrojs", "check", "package.json")) ? { name: "astro check", command: binCommand(cwd, "astro", ["check"]) } : { name: "astro check", reason: "@astrojs/check is not installed (pnpm add -D @astrojs/check typescript)" },
+    scripts.test === void 0 ? { name: "tests", reason: "package.json has no test script" } : { name: "tests", command: scriptCommand("test", []) },
+    { name: "astro build", command: binCommand(cwd, "astro", ["build"]) }
+  ];
+  if (e2e) {
+    plans.push(
+      scripts["test:e2e"] !== void 0 ? { name: "e2e", command: scriptCommand("test:e2e", []) } : playwrightConfig ? { name: "e2e", command: binCommand(cwd, "playwright", ["test"]) } : { name: "e2e", reason: "no test:e2e script and no playwright.config" }
+    );
+  }
+  const steps = [];
+  for (const plan of plans) {
+    options.onStep?.({ phase: "start", name: plan.name });
+    let step;
+    if (plan.command === void 0) {
+      step = { name: plan.name, status: plan.fail ? "fail" : "skipped", reason: plan.reason };
+    } else {
+      const log = join(dir, `${slug(plan.name)}.log`);
+      const fd = openSync(log, "w");
+      const started = Date.now();
+      let result;
+      try {
+        result = spawnSync(plan.command.file, plan.command.argv, {
+          cwd,
+          stdio: ["ignore", fd, fd],
+          shell: process.platform === "win32",
+          env: process.env
+        });
+      } finally {
+        closeSync(fd);
+      }
+      const seconds = Math.round((Date.now() - started) / 100) / 10;
+      const passed = result.error === void 0 && result.status === 0;
+      step = {
+        name: plan.name,
+        status: passed ? "pass" : "fail",
+        command: plan.command.display,
+        seconds,
+        log: relative(cwd, log),
+        ...result.error === void 0 ? {} : { reason: result.error.message },
+        ...passed ? {} : { tail: tailOf(log) }
+      };
+    }
+    steps.push(step);
+    options.onStep?.({ phase: "end", step });
+  }
+  const ok = steps.every((step) => step.status !== "fail");
+  const tree = verifyTreeHash(cwd);
+  if (ok && tree !== null) {
+    const record = { tree, e2e, when: (/* @__PURE__ */ new Date()).toISOString(), steps };
+    writeFileSync(recordFile, `${JSON.stringify(record, null, 2)}
+`);
+  }
+  return { ok, cached: false, tree, e2e, steps };
+}
+function formatVerifyReport(report) {
+  if (report.cached) {
+    return `verify: PASS, unchanged since ${report.since} (${report.e2e ? "with" : "without"} e2e); --force reruns
+`;
+  }
+  const out = [];
+  for (const step of report.steps) {
+    if (step.status !== "fail") continue;
+    out.push("", `${step.name} failed${step.reason === void 0 ? "" : `: ${step.reason}`}${step.log === void 0 ? "" : ` \u2014 last lines of ${step.log}:`}`);
+    for (const line of step.tail ?? []) out.push(`  ${line}`);
+  }
+  const failed = report.steps.filter((step) => step.status === "fail").map((step) => step.name);
+  out.push(
+    "",
+    failed.length === 0 ? `verify: PASS${report.tree === null ? " (not a git repository: nothing recorded)" : ""}` : `verify: FAIL \u2014 ${failed.join(", ")}; whole output under ${VERIFY_DIR}/`
+  );
+  return `${out.join("\n").replace(/^\n/, "")}
+`;
+}
+function formatVerifyStep(step) {
+  const verdict = step.status === "pass" ? "ok" : step.status === "fail" ? "FAIL" : "skipped";
+  const detail = step.seconds !== void 0 ? `${step.seconds.toFixed(1)}s` : step.reason ?? "";
+  return `  ${step.name.padEnd(18)} ${verdict.padEnd(7)} ${detail}
+`;
+}
+export {
+  VERIFY_DIR,
+  formatVerifyReport,
+  formatVerifyStep,
+  runVerify,
+  verifyTreeHash
+};

package/dist/compiler/cli.d.ts

@@ -1,12 +1,12 @@
 import { DiagnosticSeverity } from '../reference/types.js';
-import { EquationLink } from '../reference/gate-math.js';
-import { Manifest, ManifestLesson } from './manifest.js';
+import { EquationLink, ScopeEntry } from '../reference/gate-math.js';
+import { ManifestLesson, ManifestLessonFloat, Manifest } from './manifest.js';
 import { RenderDiagnostic } from './render-diagnostics.js';
+import { RetiredRule } from '../rules/catalog.js';
 import { RulesFilter, RuleInEffect } from '../rules/in-effect.js';
 import '../curriculum/validation.js';
 import '../reference/consistency.js';
-import '../course-config-rRtME5UV.js';
-import '../rules/catalog.js';
+import '../course-config-BLtIdkei.js';
 import '../rules/course-rules.js';
 import './collections.js';
 import '../reference/gate-retired-keys.js';
@@ -25,12 +25,17 @@ import '../reference/mixed-content.js';
 import '../reference/gloss.js';
 import '../rules/waivers.js';
 import './knowledge-version.js';
+import './page-versions.js';
+import './decks.js';
+import '../reference/decks-validate.js';
+import '../reference/deck-source.js';
 import './lesson-derivation.js';
 
 /**
  * The `content` CLI core (Phase G1).
  *
- * `scripts/content.ts` is a thin argv wrapper; every command's logic lives here
+ * `./cli-main` is the router (`runContentCli`), a course's `scripts/content.ts`
+ * a three-line shim over it; every command's logic lives here
  * as a pure-ish function that takes a compiled {@link Manifest} and returns a
  * plain data object. The router is **read-only** — only `content new` touches
  * the filesystem, and even then `scaffoldLesson` / `scaffoldTerm` only return
@@ -59,7 +64,7 @@ import './lesson-derivation.js';
  *     under the `render:` source.
  */
 
-type ContentCliCode = 'unknown-command' | 'usage' | 'unknown-lesson' | 'unknown-kind' | 'invalid-id' | 'exists' | 'not-a-lesson' | 'no-git';
+type ContentCliCode = 'unknown-command' | 'usage' | 'unknown-lesson' | 'unknown-kind' | 'invalid-id' | 'exists' | 'not-a-lesson' | 'no-git' | 'unknown-version' | 'migration-gap' | 'unknown-key' | 'no-changelog';
 /** A user-facing failure with a stable code and no stack in `--json` output. */
 declare class ContentCliError extends Error {
     readonly code: ContentCliCode;
@@ -74,6 +79,8 @@ interface CliDiagnostic {
      * which `tests/rules/catalog.test.ts` treats as a bug.
      */
     readonly rule?: string;
+    /** The owner's page and anchor under `docs/authoring/`, `notation.md#n4`. */
+    readonly doc?: string;
     readonly severity: DiagnosticSeverity;
     readonly message: string;
     readonly file?: string;
@@ -87,13 +94,23 @@ interface CliDiagnostic {
      */
     readonly equation?: EquationLink;
 }
+/** ` [N4 · notation.md#n4]` for a diagnostic the catalog owns; empty otherwise. */
+declare function ownerTag(diagnostic: Pick<CliDiagnostic, 'rule' | 'doc'>): string;
+/**
+ * One text line for a diagnostic, the shape every verb prints:
+ * `file:line:column: severity code [rule · doc]: message`. The location is
+ * left out when the diagnostic has no file, and reads `1:1` when the file is
+ * known but the position is not, so an editor opens the file. The rule and its page are on the
+ * line so a reader needs no second lookup to find what the code answers to.
+ */
+declare function formatCliDiagnostic(diagnostic: CliDiagnostic): string;
 /**
  * Every manifest diagnostic that names this lesson (by id or file), normalized
  * to {@link CliDiagnostic}. Corpus-wide checks (curriculum) are included only
  * when their message mentions the lesson; per-file checks (notation, math,
  * equations, consistency) are filtered by `file`.
  */
-declare function lessonDiagnostics(manifest: Manifest, lesson: ManifestLesson, rendered?: readonly RenderDiagnostic[]): CliDiagnostic[];
+declare function lessonDiagnostics(manifest: Manifest, lesson: CheckTarget, rendered?: readonly RenderDiagnostic[]): CliDiagnostic[];
 interface RenderResult {
     readonly rendered: boolean;
     readonly diagnostics: readonly CliDiagnostic[];
@@ -139,6 +156,34 @@ interface DomainFileSignatures {
 interface StatusReport {
     /** The course's published knowledge version (`about.version`). */
     readonly knowledgeVersion: string;
+    /**
+     * What an agent is told to read before working, in estimated tokens: the
+     * course's `AGENTS.md`, the repository's one level up when the course is a
+     * workspace package, and the rules-in-effect page. A budget to watch; the
+     * estimate is bytes over four.
+     */
+    readonly agentSurfaces: readonly {
+        readonly name: string;
+        readonly tokens: number;
+    }[];
+    /**
+     * Whether the course's own `AGENTS.md` points an agent at the engine's
+     * guide (`docs/authoring/agents.md`), and whether the procedures
+     * `content init-agent` installs are in `.claude/`.
+     */
+    readonly agentGuide: {
+        readonly agentsFile: string | null;
+        readonly linksGuide: boolean;
+        readonly skillsInstalled: boolean;
+    };
+    /**
+     * Rule C5: how many chapters and part pages carry a version of their own,
+     * and the slugs of those with a change `## [Unreleased]` has not released.
+     */
+    readonly pageVersions: {
+        readonly tracked: number;
+        readonly unreleased: readonly string[];
+    };
     readonly counts: {
         readonly lessons: number;
         readonly competencies: number;
@@ -166,6 +211,46 @@ interface DiagnosticsReport {
     readonly count: number;
     readonly diagnostics: readonly CliDiagnostic[];
 }
+/**
+ * The diagnostics list folded to what an agent decides from: how many, of
+ * what, and where. The default text output, since a course can have hundreds
+ * of lines of two codes and the list is what `--all` is for.
+ */
+interface DiagnosticsSummary {
+    readonly minimumSeverity: DiagnosticThreshold;
+    readonly count: number;
+    readonly bySeverity: {
+        readonly errors: number;
+        readonly warnings: number;
+        readonly infos: number;
+    };
+    /** One row per code and severity, most frequent first. */
+    readonly byCode: readonly {
+        readonly code: string;
+        readonly rule?: string;
+        readonly doc?: string;
+        readonly severity: DiagnosticSeverity;
+        readonly count: number;
+    }[];
+    /** One row per file, most diagnostics first; `(no file)` for the rest. */
+    readonly byFile: readonly {
+        readonly file: string;
+        readonly count: number;
+        readonly errors: number;
+        readonly warnings: number;
+        readonly infos: number;
+    }[];
+}
+declare function summarizeDiagnostics(report: DiagnosticsReport): DiagnosticsSummary;
+/** The diagnostics of one code (with or without its `source:` prefix) or of some files. */
+declare function filterDiagnostics(report: DiagnosticsReport, filter: {
+    readonly code?: string;
+    readonly files?: readonly string[];
+}): DiagnosticsReport;
+/** The summary as text: a severity line, then counts by code and by file, the file list capped. */
+declare function formatDiagnosticsSummary(summary: DiagnosticsSummary, options?: {
+    readonly fileCap?: number;
+}): string;
 interface WarningsReport {
     readonly count: number;
     readonly warnings: readonly CliDiagnostic[];
@@ -191,6 +276,8 @@ interface RulesReport {
 declare function parseRulesFilter(input: {
     readonly element?: string;
     readonly enforcement?: string;
+    /** `chapter` (the default page) or `deck` (`<lesson>.deck.mdx`). */
+    readonly edition?: string;
 }): RulesFilter;
 /** The rules this course has in effect, optionally narrowed. */
 declare function contentRules(manifest: Manifest, filter?: RulesFilter): RulesReport;
@@ -204,6 +291,8 @@ interface ContextReport {
         readonly teaches: readonly string[];
         readonly requires: readonly string[];
         readonly assumptions: readonly string[];
+        /** The version the page's content last changed in; `null` for a change not yet released (rule C5). */
+        readonly since: string | null;
         readonly notationLocal: unknown;
         readonly body: string;
     };
@@ -223,22 +312,10 @@ interface ContextReport {
         units?: string;
         formula?: string;
     }[];
-    readonly equations: readonly {
-        key: string;
-        number: string;
-    }[];
-    readonly tables: readonly {
-        key: string;
-        number: string;
-    }[];
-    readonly figures: readonly {
-        key: string;
-        number: string;
-    }[];
-    readonly diagrams: readonly {
-        key: string;
-        number: string;
-    }[];
+    readonly equations: readonly ManifestLessonFloat[];
+    readonly tables: readonly ManifestLessonFloat[];
+    readonly figures: readonly ManifestLessonFloat[];
+    readonly diagrams: readonly ManifestLessonFloat[];
     /** Worked-example sets: `short` is the title `[[ex-key]]` names. */
     readonly examples: readonly {
         key: string;
@@ -268,7 +345,298 @@ interface ContextReport {
     readonly diagnostics: readonly CliDiagnostic[];
     readonly tokens: TokenCounts;
 }
+interface MigrationSection {
+    readonly from: string;
+    readonly to: string;
+    readonly heading: string;
+    readonly markdown: string;
+    readonly tokens: number;
+}
+interface MigrateReport {
+    readonly from: string;
+    readonly to: string;
+    readonly file: string;
+    readonly sections: readonly MigrationSection[];
+    readonly tokens: number;
+}
+/** Every `## <from> → <to>` section of the guide, in file order (newest first). */
+declare function parseMigrationSections(markdown: string): MigrationSection[];
+/**
+ * The sections that take a course from `from` to `to`, oldest first: each
+ * section's left side matches where the previous one ended. A hole in the
+ * chain is an error naming the version no section continues from, since a
+ * skipped section is a skipped migration.
+ */
+declare function selectMigrationPath(sections: readonly MigrationSection[], from: string, to: string): MigrationSection[];
+/** The engine version the course has installed: the package beside it, or this one. */
+declare function installedEngineVersion(): string | undefined;
+/**
+ * The engine version `package.json` pins at HEAD — what the course last
+ * migrated to, before the working tree bumped it. `workspace:*` or a range
+ * is no version, so the caller asks for `--from`.
+ */
+declare function pinnedEngineVersion(): string | undefined;
+declare function contentMigrate(options?: {
+    readonly from?: string;
+    readonly to?: string;
+}): MigrateReport;
+/** The sections, oldest first, under one line that says how much is coming. */
+declare function formatMigrateReport(report: MigrateReport): string;
+interface SpanBinding {
+    readonly token: string;
+    readonly key: string;
+    /** The resolver's match kind; `explicit` for an `\explain` wrap. */
+    readonly how: string;
+}
+interface ExplicitWrap {
+    readonly key: string;
+    readonly inner: string;
+    /** The bare `inner` resolves to exactly this card: the wrap costs tokens and binds nothing new. */
+    readonly redundant: boolean;
+}
+interface UnresolvedGlyph {
+    readonly token: string;
+    readonly suspended?: string;
+    /** Rule N23: indexed entries whose base this bare letter is; none lends it a card. */
+    readonly lenders?: readonly string[];
+    /** Where `content symbol` finds the token defined: exact hits, then near misses. */
+    readonly defined: readonly {
+        readonly tier: SymbolTier;
+        readonly key: string;
+        readonly where: string;
+    }[];
+    readonly near: readonly {
+        readonly latex: string;
+        readonly key: string;
+    }[];
+}
+interface SpanBindings {
+    readonly bindings: readonly SpanBinding[];
+    readonly wraps: readonly ExplicitWrap[];
+    readonly unresolved: readonly Omit<UnresolvedGlyph, 'defined' | 'near'>[];
+    /** The resolver rejected the span (a KaTeX parse error or a rule it enforces, N13 say); its message. */
+    readonly error?: string;
+}
+interface BindingsSpan extends Omit<SpanBindings, 'unresolved'> {
+    readonly line: number;
+    readonly column: number;
+    readonly display: boolean;
+    readonly latex: string;
+    readonly unresolved: readonly UnresolvedGlyph[];
+}
+interface BindingsReport {
+    readonly lesson: string;
+    readonly file: string;
+    readonly scope: readonly {
+        readonly key: string;
+        readonly notation: string;
+        readonly scope: 'shared' | 'local';
+    }[];
+    readonly spans: readonly BindingsSpan[];
+    readonly counts: {
+        readonly spans: number;
+        readonly bindings: number;
+        readonly unresolved: number;
+        readonly wraps: number;
+        readonly redundantWraps: number;
+        readonly errors: number;
+    };
+}
+/**
+ * One span against a scope. Exported for tests and for a caller with a span
+ * of its own (`content equation`).
+ */
+declare function spanBindings(latex: string, scope: readonly ScopeEntry[], options?: {
+    readonly suspended?: readonly string[];
+    readonly derive?: boolean;
+}): SpanBindings;
+declare function contentBindings(manifest: Manifest, rawId: string): BindingsReport;
+/** The text form: a counts line, the scope, then one line per span. */
+declare function formatBindingsReport(report: BindingsReport): string;
+/**
+ * One LaTeX string, resolved the way the gate will: against a lesson's
+ * scope, or against every shared card when no lesson is named (the table a
+ * notation entry's body and formula use). The inner loop while drafting:
+ * a few lines out, non-zero exit when the build would refuse the span.
+ */
+interface EquationReport extends Omit<SpanBindings, 'unresolved'> {
+    readonly latex: string;
+    readonly against: {
+        readonly kind: 'lesson';
+        readonly lesson: string;
+        readonly cards: number;
+    } | {
+        readonly kind: 'shared';
+        readonly cards: number;
+    };
+    readonly unresolved: readonly UnresolvedGlyph[];
+    readonly ok: boolean;
+}
+declare function contentEquation(manifest: Manifest, latex: string, options?: {
+    readonly lesson?: string;
+}): EquationReport;
+declare function formatEquationReport(report: EquationReport): string;
+interface FileEdit {
+    /** Course-relative path. */
+    readonly file: string;
+    /** `null` when the file is created. */
+    readonly before: string | null;
+    /** `null` when the file is deleted. */
+    readonly after: string | null;
+}
+interface EditPlan {
+    readonly summary: readonly string[];
+    readonly edits: readonly FileEdit[];
+    /** What to run after writing. */
+    readonly next: readonly string[];
+}
+/** `[[old]]` and `\explain{old}` become `new`; nothing else is touched. Returns the count. */
+declare function rewriteKeyReferences(text: string, oldKey: string, newKey: string): {
+    text: string;
+    count: number;
+};
+/**
+ * Remove one `notation.local` item from a lesson file's text, by key, keeping
+ * the rest of the frontmatter byte for byte. An item runs from its `- key:`
+ * line to the next line indented no deeper than the dash; an emptied list
+ * becomes `local: []`.
+ */
+declare function removeLocalItem(text: string, key: string): {
+    text: string;
+    removed: boolean;
+};
+/**
+ * A shared card's file from a page-local entry's fields, nothing invented: no
+ * body (the glossary shows the meaning; what a reader needs beyond it is the
+ * author's to write, and a placeholder would publish), and the label only
+ * when the entry has one. `domain` is the caller's pick, else the key's
+ * prefix, else `general`.
+ */
+declare function sharedCardFromLocal(local: Record<string, unknown>, options: {
+    readonly key: string;
+    readonly fromLesson: string;
+    readonly domain?: string;
+}): string;
+/**
+ * `content move <lesson>:<key> [--to <key>]`: a page-local entry becomes a
+ * shared card. Every lesson that declares the key loses its copy (the card
+ * serves them all; copies that differ are reported, the named lesson's text
+ * wins), and with `--to` every `[[key]]` and `\explain{key}` follows.
+ */
+declare function planMove(manifest: Manifest, lessonId: string, key: string, options?: {
+    readonly to?: string;
+}): EditPlan;
+/** `content rename <old> <new>`: a shared card's key, everywhere it is named. */
+declare function planRename(manifest: Manifest, oldKey: string, newKey: string): EditPlan;
+/**
+ * `content fix <lesson>`: the diagnostics with one mechanical repair, applied.
+ * Today: every `\explain{key}{inner}` the gate reports as `explain-redundant`
+ * becomes `inner`.
+ */
+declare function planFix(manifest: Manifest, lessonId: string): EditPlan;
+/** `content fix` over several lessons (or every one, `--all`) as one plan: the lessons with nothing to fix are counted, not listed. */
+declare function planFixMany(manifest: Manifest, lessonIds: readonly string[]): EditPlan;
+/** The plan as a unified diff (git's), file by file, under its summary lines. */
+declare function renderEditPlan(plan: EditPlan): string;
+/** Write a plan's edits. Returns the files touched. */
+declare function applyEditPlan(plan: EditPlan): string[];
+/**
+ * The engine's course-facing agent procedures (`docs/course-agent/`): skills,
+ * the `rules-reviewer` agent and the `AGENTS.md` baseline, beside the
+ * installed package or above this module.
+ */
+declare function courseAgentDir(): string | undefined;
+/**
+ * `content init-agent [--write]`: install or refresh the engine's agent
+ * procedures in this course — every skill under `.claude/skills/`, the
+ * reviewer under `.claude/agents/` — and, only when the course has no
+ * `AGENTS.md`, the baseline one. An existing `AGENTS.md` is never edited;
+ * when it does not point at the engine's guide, the plan says what to add.
+ */
+declare function planInitAgent(): EditPlan;
+/**
+ * One rule, whole: the catalog entry as this course has it (enforcement,
+ * codes, settings in effect, whether it is on) and the rule page's own
+ * section, example included. About half a thousand tokens where opening the
+ * page costs twenty thousand.
+ */
+interface RuleReport {
+    readonly id: string;
+    readonly status: 'in-effect' | 'retired' | 'unknown';
+    readonly rule?: RuleInEffect;
+    readonly retired?: RetiredRule;
+    /** The rule page's section for this rule, when the page is at hand. */
+    readonly section?: {
+        readonly file: string;
+        readonly markdown: string;
+        readonly tokens: number;
+    };
+    /** For `unknown`: the IDs this course has, so the caller can pick one. */
+    readonly known: readonly string[];
+}
+/**
+ * The engine's `docs/authoring/`: beside the installed package in a course
+ * (`node_modules/explico/docs/authoring`, the path the rules-in-effect page
+ * links), or above this module in the repository and in the package itself.
+ */
+declare function authoringDocsDir(): string | undefined;
+/**
+ * The section of a rule page that `anchor` names: from the heading whose
+ * slug is the anchor (`## N4` → `n4`, `## Reference systems` →
+ * `reference-systems`) to the next heading of the same or a higher level,
+ * trailing rules and blank lines dropped.
+ */
+declare function ruleSection(page: string, anchor: string): string | undefined;
+declare function contentRule(manifest: Manifest, rawId: string): RuleReport;
+/** The text form of a rule report: the entry's facts, then the page section. */
+declare function formatRuleReport(report: RuleReport): string;
 declare function contentContext(manifest: Manifest, rawId: string): ContextReport;
+/** Where a hit is defined: a shared card, a lesson's `notation.local`, or a card's gloss. */
+type SymbolTier = 'shared' | 'local' | 'gloss';
+interface SymbolHit {
+    readonly tier: SymbolTier;
+    readonly key: string;
+    readonly latex: string;
+    readonly label: string;
+    readonly meaning?: string;
+    readonly units?: string;
+    /** How the query matched: the latex as written, an alias, or the key. */
+    readonly matchedBy: 'latex' | 'alias' | 'key';
+    /** shared: the entry file; local: the lesson id; gloss: the owning card. */
+    readonly where: string;
+    /** shared only: the pages (lessons and overview pages) whose bundle binds the card. */
+    readonly boundIn?: readonly string[];
+}
+interface SymbolReport {
+    readonly query: string;
+    readonly shared: readonly SymbolHit[];
+    readonly local: readonly SymbolHit[];
+    readonly glosses: readonly SymbolHit[];
+    /** Entries whose latex contains the query as a glyph, not matched above. */
+    readonly contains: readonly SymbolHit[];
+    /** How many `contains` candidates there were before the list was capped. */
+    readonly containsTotal: number;
+}
+declare function contentSymbol(manifest: Manifest, rawQuery: string): SymbolReport;
+/**
+ * The text form of a symbol report: one block per tier, then the near
+ * misses, then one line that counts what was found, worded for the next
+ * step an author takes.
+ */
+declare function formatSymbolReport(report: SymbolReport): string;
+/**
+ * A page `content check` checks: a lesson's (its chapter, or a slides-first
+ * lesson's deck), or a deck beside its chapter or a part's, by its page id.
+ */
+type CheckTarget = Pick<ManifestLesson, 'id' | 'file' | 'assessments'> & {
+    readonly notation: Pick<ManifestLesson['notation'], 'definitionIds'>;
+};
+/**
+ * The lesson `rawId` names, or the deck whose page it names: a deck beside
+ * its chapter by its route (`motion/range/slides`), a part's deck by its own
+ * (`motion/slides`).
+ */
+declare function findCheckTarget(manifest: Manifest, rawId: string): CheckTarget;
 interface CheckLessonResult {
     readonly lesson: string;
     readonly file: string;
@@ -299,6 +667,22 @@ interface Scaffold {
     }[];
 }
 declare function scaffoldLesson(rawId: string): Scaffold;
+/**
+ * `content new deck <lesson>`: the slide edition of a lesson, as a draft to
+ * rewrite (`docs/authoring/deck.md`). Beside an existing chapter it starts
+ * from the chapter: a `##` section per chapter section, a `###` frame per
+ * subsection (or one for a section without any), a `<Recall>` for each
+ * numbered equation, figure, table and diagram there, and the section's first
+ * sentence in the frame's notes. Without a chapter it is a slides-first
+ * lesson, with the lesson's frontmatter and a skeleton frame.
+ *
+ * `content new deck <part>`, for a part's directory with its page
+ * (`index.mdx`), drafts the part's deck (`<part>/index.deck.mdx`): a
+ * `## <chapter title> [chapter: <name>]` section per chapter, in the order
+ * the tracks read them, and a frame per section of the chapter, with a
+ * `<Recall>` for each float it numbers and its first sentence in the notes.
+ */
+declare function scaffoldDeck(rawId: string): Scaffold;
 declare function scaffoldTerm(rawKey: string): Scaffold;
 
-export { type CheckLessonResult, type CheckReport, type CliDiagnostic, type ContentCliCode, ContentCliError, type ContextReport, type DiagnosticThreshold, type DiagnosticsReport, type DomainFileSignatures, type RenderResult, type RulesReport, type Scaffold, type StatusReport, type TokenCounts, type WarningsReport, changedLessonIds, contentCheck, contentContext, contentDiagnostics, contentRules, contentStatus, contentWarnings, estimateTokens, findLesson, lessonDiagnostics, lessonSource, normalizeLessonId, parseRulesFilter, renderLesson, scaffoldLesson, scaffoldTerm };
+export { type BindingsReport, type BindingsSpan, type CheckLessonResult, type CheckReport, type CheckTarget, type CliDiagnostic, type ContentCliCode, ContentCliError, type ContextReport, type DiagnosticThreshold, type DiagnosticsReport, type DiagnosticsSummary, type DomainFileSignatures, type EditPlan, type EquationReport, type ExplicitWrap, type FileEdit, type MigrateReport, type MigrationSection, type RenderResult, type RuleReport, type RulesReport, type Scaffold, type SpanBinding, type SpanBindings, type StatusReport, type SymbolHit, type SymbolReport, type SymbolTier, type TokenCounts, type UnresolvedGlyph, type WarningsReport, applyEditPlan, authoringDocsDir, changedLessonIds, contentBindings, contentCheck, contentContext, contentDiagnostics, contentEquation, contentMigrate, contentRule, contentRules, contentStatus, contentSymbol, contentWarnings, courseAgentDir, estimateTokens, filterDiagnostics, findCheckTarget, findLesson, formatBindingsReport, formatCliDiagnostic, formatDiagnosticsSummary, formatEquationReport, formatMigrateReport, formatRuleReport, formatSymbolReport, installedEngineVersion, lessonDiagnostics, lessonSource, normalizeLessonId, ownerTag, parseMigrationSections, parseRulesFilter, pinnedEngineVersion, planFix, planFixMany, planInitAgent, planMove, planRename, removeLocalItem, renderEditPlan, renderLesson, rewriteKeyReferences, ruleSection, scaffoldDeck, scaffoldLesson, scaffoldTerm, selectMigrationPath, sharedCardFromLocal, spanBindings, summarizeDiagnostics };