@erclx/canon 5.35.0 → 5.37.0

package/src/design/parse.ts

@@ -25,6 +25,23 @@ export interface DesignDoc {
   iconography: string
 }
 
+/**
+ * The three headings the standard renamed toward Google's DESIGN.md, each read
+ * as the section it became. Records the seed and `canvas-board` wrote before
+ * the rename sit in targets and will not rename themselves, and an unmatched
+ * heading parses to nothing without saying so. The field names on `DesignDoc`
+ * keep the old words, since the preview reading them is retired separately.
+ */
+export const LEGACY_HEADINGS: Readonly<Record<string, string>> = {
+  Personality: 'Overview',
+  Color: 'Colors',
+  Borders: 'Shapes',
+}
+
+export function canonicalHeading(heading: string): string {
+  return LEGACY_HEADINGS[heading] ?? heading
+}
+
 const VERIFY_TAG = /\s*\?\s*verify\s*$/
 
 /** A cell whose whole content is one balanced code span and nothing else. */
@@ -34,11 +51,11 @@ export function parseDesignDoc(path: string): DesignDoc {
   const raw = readFileSync(path, 'utf8')
   const sections = splitSections(raw)
   return {
-    personality: prose(sections['Personality']),
-    color: table(sections['Color']),
+    personality: prose(sections['Overview']),
+    color: table(sections['Colors']),
     typography: table(sections['Typography']),
     spacing: table(sections['Spacing']),
-    borders: table(sections['Borders']),
+    borders: table(sections['Shapes']),
     motion: prose(sections['Motion']),
     iconography: prose(sections['Iconography']),
   }
@@ -53,7 +70,7 @@ function splitSections(raw: string): Record<string, string> {
     const match = line.match(/^##\s+(.+?)\s*$/)
     if (match) {
       if (current) out[current] = buffer.join('\n')
-      current = match[1]
+      current = canonicalHeading(match[1])
       buffer = []
     } else if (current) {
       buffer.push(line)

package/src/design/render.ts

@@ -268,7 +268,7 @@ ${sections.join('\n')}
 
 function sectionPersonality(text: string): string {
   if (!text) return ''
-  return `<h2>Personality</h2>\n<p>${escape(text)}</p>`
+  return `<h2>Overview</h2>\n<p>${escape(text)}</p>`
 }
 
 function sectionColor(rows: Row[]): string {
@@ -283,7 +283,7 @@ function sectionColor(rows: Row[]): string {
       return `<tr><td>${swatch}${cellText(r, 'Role')}</td><td>${cellText(r, 'Intent')}</td><td><code>${shown}</code>${mark(r, 'Value')}</td></tr>`
     })
     .join('\n')
-  return `<h2>Color</h2>\n<table><thead><tr><th>Role</th><th>Intent</th><th>Value</th></tr></thead><tbody>${body}</tbody></table>`
+  return `<h2>Colors</h2>\n<table><thead><tr><th>Role</th><th>Intent</th><th>Value</th></tr></thead><tbody>${body}</tbody></table>`
 }
 
 function sectionTypography(rows: Row[]): string {
@@ -325,7 +325,7 @@ function sectionBorders(rows: Row[]): string {
       return `<tr><td>${cellText(r, 'Role')}</td><td><code>${escape(radius)}</code>${mark(r, 'Radius')}</td><td><code>${escape(width)}</code>${mark(r, 'Width')}</td><td>${cellText(r, 'When used')}</td><td>${sample}</td></tr>`
     })
     .join('\n')
-  return `<h2>Borders</h2>\n<table><thead><tr><th>Role</th><th>Radius</th><th>Width</th><th>When used</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
+  return `<h2>Shapes</h2>\n<table><thead><tr><th>Role</th><th>Radius</th><th>Width</th><th>When used</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
 }
 
 /** A section the record writes as one-line rules draws them as a list. */

package/src/gate/measures.ts

@@ -18,9 +18,18 @@ import {
 import { familyKeys } from '@/claude/skills-families'
 import { measureDesignProse } from '@/design/budget'
 import { DESIGN_DOCUMENT } from '@/design/regen'
-import { listRepositoryFiles } from '@/git/files'
+import {
+  listChangedFiles,
+  listFilesAtRef,
+  listRepositoryFiles,
+  readFileAtRef,
+  resolveBaseRef,
+} from '@/git/files'
 import { ceilingFindings } from '@/markdown/ceiling'
 import { resolveMarkdown } from '@/markdown/files'
+import { grownBlocks, normalizeProse } from '@/markdown/growth'
+import { bodyLines } from '@/markdown/scan'
+import { bulletStacks as findBulletStacks } from '@/markdown/stacks'
 import { CHECKPOINTS } from '@/markdown/structure'
 import {
   isShippedCorpus,
@@ -501,6 +510,182 @@ export const documentCeiling: Measure = async (ctx) => {
   }
 }
 
+/**
+ * The tracked documents a bullet run is held against: the context entries, the
+ * docs pages, and the skill bodies and references of both skill trees.
+ *
+ * Rules and the requirement records stay out, since a rule is one imperative
+ * per bullet and a requirement is a record of its own. Named here and nowhere
+ * else, so the stage and its tests read one scope.
+ */
+const STACK_SCOPE = [
+  /^canon\/context\/.+\.md$/,
+  /^docs\/.+\.md$/,
+  /^(?:claude|\.claude)\/skills\/[^/]+\/SKILL\.md$/,
+  /^(?:claude|\.claude)\/skills\/[^/]+\/references\/.+\.md$/,
+]
+
+/** Whether a path is one the bullet cap holds. */
+export function inStackScope(rel: string): boolean {
+  return STACK_SCOPE.some((pattern) => pattern.test(rel))
+}
+
+/** The context entries alone, where length drifts because `context-fold` appends after every merge. */
+const GROWTH_SCOPE = /^canon\/context\/.+\.md$/
+
+/** Whether a path is one the growth check reads. */
+export function inGrowthScope(rel: string): boolean {
+  return GROWTH_SCOPE.test(rel)
+}
+
+/**
+ * Every in-scope document against the five-bullet cap.
+ *
+ * The failure names each file with its longest run and where it opens. Read
+ * in-process rather than through `canon markdown audit`, whose exit code stays
+ * bans and dead links only, for the reason `documentCeiling` gives: the plan
+ * and groundwork skills run that audit on gitignored records, where a long
+ * list is not a defect.
+ */
+export const bulletStacks: Measure = async (ctx) => {
+  const files = await listRepositoryFiles(ctx.root)
+  if (files === undefined) {
+    return {
+      emissions: [],
+      unmeasured: 'git could not list the tree, so no bullet run was measured.',
+    }
+  }
+
+  const scoped = files.filter(inStackScope)
+  const failing: { rel: string; count: number; line: number }[] = []
+
+  for (const rel of scoped) {
+    let source: string
+    try {
+      source = readFileSync(join(ctx.root, rel), 'utf8')
+    } catch {
+      continue
+    }
+    const runs = findBulletStacks(bodyLines(source))
+    if (runs.length === 0) continue
+    const longest = runs.reduce((a, b) => (b.count > a.count ? b : a))
+    failing.push({ rel, count: longest.count, line: longest.line })
+  }
+
+  if (failing.length === 0) {
+    return {
+      emissions: [
+        info(
+          `No run of more than 5 plain bullets across ${plural(scoped.length, 'document')}`,
+        ),
+      ],
+    }
+  }
+
+  const where = failing
+    .sort((a, b) => b.count - a.count)
+    .map((f) => `${f.rel}:${f.line} ${f.count} bullets`)
+    .join(', ')
+  return {
+    emissions: [],
+    failure: `${plural(failing.length, 'document')} carrying a run of more than 5 plain bullets: ${where}. Split each run under H3 headings with a few bullets or prose beneath, or open every item with a bold label or a link.`,
+  }
+}
+
+/**
+ * A context entry's paragraph or top-level bullet past its checkpoint that
+ * this branch added or changed.
+ *
+ * A block fails when its text is absent from every context entry the merge
+ * base held, so an unchanged long block passes wherever it now sits and an
+ * edited or new one fails. Reading the whole base folder rather than the same
+ * path is what lets a block move into a sibling entry. No resolvable base
+ * reports unmeasured rather than a pass, since a missing base would otherwise
+ * read every block as new or none as new.
+ *
+ * Only context entries are held to it. Length drifts there because
+ * `context-fold` appends after every merge, and in docs and skills it stays the
+ * audit's advisory warning.
+ */
+export const paragraphGrowth: Measure = async (ctx) => {
+  const base = await resolveBaseRef(ctx.root)
+  if (base === undefined) {
+    return {
+      emissions: [],
+      unmeasured:
+        'no merge base resolved, so no paragraph or bullet was compared against it.',
+    }
+  }
+
+  const changed = await listChangedFiles(ctx.root, base)
+  if (changed === undefined) {
+    return {
+      emissions: [],
+      unmeasured:
+        'git could not list the branch range, so no block was compared.',
+    }
+  }
+
+  const grown: {
+    rel: string
+    kind: string
+    line: number
+    characters: number
+  }[] = []
+  let corpus: string | undefined
+
+  for (const rel of changed.filter(inGrowthScope)) {
+    let source: string
+    try {
+      source = readFileSync(join(ctx.root, rel), 'utf8')
+    } catch {
+      continue
+    }
+
+    const own = normalizeProse((await readFileAtRef(ctx.root, base, rel)) ?? '')
+    const first = grownBlocks(source, own)
+    if (first.length === 0) continue
+
+    if (corpus === undefined) {
+      const paths =
+        (await listFilesAtRef(ctx.root, base, 'canon/context')) ?? []
+      const texts = await Promise.all(
+        paths
+          .filter(inGrowthScope)
+          .map((path) => readFileAtRef(ctx.root, base, path)),
+      )
+      corpus = normalizeProse(texts.filter((t) => t !== undefined).join('\n'))
+    }
+
+    for (const block of grownBlocks(source, corpus)) {
+      grown.push({
+        rel,
+        kind: block.kind,
+        line: block.line,
+        characters: block.characters,
+      })
+    }
+  }
+
+  if (grown.length === 0) {
+    return {
+      emissions: [
+        info(
+          `No paragraph past ${CHECKPOINTS.paragraph} characters and no bullet past ${CHECKPOINTS.bullet} grew in a context entry`,
+        ),
+      ],
+    }
+  }
+
+  const where = grown
+    .map((g) => `${g.rel}:${g.line} ${g.kind} ${g.characters} characters`)
+    .join(', ')
+  return {
+    emissions: [],
+    failure: `${plural(grown.length, 'block')} past the checkpoint added or changed on this branch: ${where}. Split each at a seam, or cut it under ${CHECKPOINTS.paragraph} characters for a paragraph and ${CHECKPOINTS.bullet} for a bullet.`,
+  }
+}
+
 /**
  * Whether a path's stem, its basename up to the first `.`, repeats its
  * immediate parent folder, either whole or as a `<folder>-` prefix.
@@ -659,7 +844,7 @@ export const markdownBans: Measure = async (ctx) => {
     return {
       emissions: [output(frame.all)],
       failure:
-        'Markdown prose carries a banned character, or a relative link resolves to nothing on disk. Rewrite the sentence or fix the link, and reach for a code span only where the token is genuinely an identifier under discussion.',
+        'Markdown prose carries a banned character, or a relative link resolves to nothing on disk. Rewrite the sentence, since a colon or a comma standing where the em dash was is the same sentence, or fix the link, and reach for a code span only where the token is genuinely an identifier under discussion.',
     }
   }
 

package/src/gate/sequencer.ts

@@ -113,8 +113,6 @@ export function readProcLoad(): LoadReading | undefined {
 }
 
 export interface GateContext extends MeasureContext {
-  /** Whether the format stage writes or checks. */
-  readonly write: boolean
   /**
    * The changed set a scoped stage is read against, or `undefined` where
    * scoping is off and every stage runs.
@@ -444,8 +442,6 @@ export async function runStages(
   const results: StageResult[] = []
 
   for (const stage of stages) {
-    if (stage.when !== undefined && !stage.when({ write: ctx.write })) continue
-
     const result = await runStage(stage, ctx)
     results.push(result)
     onResult?.(result)

package/src/gate/stages.ts

@@ -11,10 +11,12 @@ import {
   captureStamps,
   clientCommandCitations,
   designProse,
+  bulletStacks,
   documentCeiling,
   folderEchoedNames,
   markdownBans,
   type Measure,
+  paragraphGrowth,
   pluginManifests,
   readmeCitations,
   recordIdempotence,
@@ -81,11 +83,6 @@ export interface Stage {
   readonly scope?: RegExp
   /** What a scoped-out stage says, so a skip never reads as a pass. */
   readonly skipped?: string
-  /**
-   * Whether this stage belongs in the run at all, read off the write grant
-   * rather than the changed set. Absent means it always belongs.
-   */
-  readonly when?: (options: { readonly write: boolean }) => boolean
   readonly checks: readonly Check[]
   /**
    * The machine lock this stage holds while its checks run, so one box runs it
@@ -144,28 +141,15 @@ const script = (name: string, failure: string): Check => ({
  * whole set at once.
  */
 export const STAGES: readonly Stage[] = [
-  {
-    id: 'format',
-    label: 'Formatting',
-    when: ({ write }) => write,
-    checks: [
-      {
-        kind: 'command',
-        argv: ['bun', 'run', 'format'],
-        failure: 'Format failed',
-      },
-    ],
-    success: 'Format applied',
-  },
   {
     id: 'format-check',
     label: 'Format check',
-    when: ({ write }) => !write,
     checks: [
       {
         kind: 'command',
         argv: ['bun', 'run', 'check:format'],
-        failure: 'Format check failed',
+        failure:
+          'Format check failed. Run bun run format and commit the result.',
       },
     ],
     success: 'Format check passed',
@@ -335,19 +319,23 @@ export const STAGES: readonly Stage[] = [
     checks: [{ kind: 'measure', measure: unreferencedRules }],
   },
   {
-    // Only the citation half of the audit gates. Its length, depth, table, and
-    // index findings are judgment thresholds, and failing a push on one would
-    // make the stage something to route around. The one length reading that
-    // gates is the whole-document ceiling, which the Document ceiling stage
-    // below owns rather than this audit.
+    // The facts the audit can answer from the files gate: a cited path that
+    // does not resolve, a required section an entry does not declare, an H2
+    // outside the closed set of four, and an index disagreeing with its folder.
+    // Its length, depth, bullet, table, and provenance findings are judgment
+    // thresholds, and failing a push on one would make the stage something to
+    // route around. The length readings that gate sit in their own stages
+    // below, apart from the audit's exit code: the whole-document ceiling, the
+    // bullet cap, and the growth of a paragraph or a bullet past its
+    // checkpoint.
     id: 'context-citations',
     label: 'Context citations',
     checks: [
       {
         kind: 'cli',
-        argv: ['context', 'audit', '--citations-only'],
+        argv: ['context', 'audit', '--gate'],
         failure:
-          'A cited context path does not resolve. Run bun src/cli.ts context audit.',
+          'A cited context path does not resolve, an entry lacks a required section or carries an H2 outside Overview, Layout, Decisions, and Gotchas, or an index disagrees with its folder. Run bun src/cli.ts context audit --gate.',
       },
     ],
     success: 'Context citations resolve',
@@ -366,6 +354,23 @@ export const STAGES: readonly Stage[] = [
     label: 'Document ceiling',
     checks: [{ kind: 'measure', measure: documentCeiling }],
   },
+  {
+    // Unscoped, since any branch can add a bullet to any entry. A run of more
+    // than 5 plain bullets fails the push in the context entries, the docs
+    // pages, and the skill bodies and references. Apart from the audit's exit
+    // code for the reason the Document ceiling stage above states.
+    id: 'bullet-stacks',
+    label: 'Bullet stacks',
+    checks: [{ kind: 'measure', measure: bulletStacks }],
+  },
+  {
+    // Context entries only, where length drifts. A paragraph past 700
+    // characters or a top-level bullet past 250 fails when this branch added or
+    // changed it, and an unchanged one passes until it is edited.
+    id: 'paragraph-growth',
+    label: 'Paragraph growth',
+    checks: [{ kind: 'measure', measure: paragraphGrowth }],
+  },
   {
     // Unscoped, since any branch can add a file anywhere and one git ls-files
     // costs nothing. Reads paths rather than markdown, so it sits here rather

package/src/git/files.ts

@@ -165,3 +165,33 @@ export async function listRepositoryFiles(
 
   return [...new Set([...tracked, ...untracked])].sort()
 }
+
+/**
+ * A file as `ref` holds it, or undefined where the ref holds no such path or
+ * git cannot answer. A path absent at the ref and a failed read are the same
+ * answer for a caller asking what the copy before this branch said.
+ */
+export async function readFileAtRef(
+  root: string,
+  ref: string,
+  rel: string,
+): Promise<string | undefined> {
+  return git(root, ['show', `${ref}:${rel}`])
+}
+
+/** Every path under `prefix` that `ref` holds, or undefined where git cannot answer. */
+export async function listFilesAtRef(
+  root: string,
+  ref: string,
+  prefix: string,
+): Promise<string[] | undefined> {
+  const listed = await git(root, [
+    'ls-tree',
+    '-r',
+    '--name-only',
+    ref,
+    '--',
+    prefix,
+  ])
+  return listed === undefined ? undefined : listed.split('\n').filter(Boolean)
+}

package/src/gov/adapter.ts

@@ -98,8 +98,8 @@ export function createGovAdapter(root: string): SyncAdapter {
 }
 
 /**
- * Where the target already holds a rule, in whichever band folder. A
- * successor held outside the source's band stays where it is, the same way
+ * Where the target already holds a rule, in whichever rule folder. A
+ * successor held outside the source's folder stays where it is, the same way
  * `locateSource` syncs a moved rule in place, rather than gaining a second copy.
  *
  * Holding the predecessor is the whole entitlement test, so no stamped chain

package/src/gov/citations.ts

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
+import { join, resolve } from 'node:path'
 import { $ } from 'bun'
 import { isMarked } from '@/sweep/exempt-marker'
 import { gitEnv } from '@/git/env'
@@ -41,14 +41,11 @@ export const RULE_DIRS: readonly string[] = [
 export const GLOB_CORPUS = join('internal', 'rules')
 
 /**
- * How the citation was written, kept on the finding because the two resolve
- * against different roots and a reader repairing one needs to know which.
- *
- * `path` is a backticked repository path. `sibling` is a rule naming another
- * rule by filename alone, which resolves inside the folder the citing rule
- * sits in.
+ * How the citation was written, being a backticked repository path. A bare
+ * filename is no form, since with no folder around it nothing tells a rule
+ * from a convention such as `index.md`.
  */
-export type CitationForm = 'path' | 'sibling'
+export type CitationForm = 'path'
 
 /**
  * What the sweep decided about one citation.
@@ -115,9 +112,6 @@ const FENCE = /^\s*(?:```|~~~)/
 
 const FRONTMATTER_DELIMITER = /^---\s*$/
 
-/** A rule filename, which is how a rule names a sibling with no folder around it. */
-const SIBLING_RULE = /^\d{3}-[a-z0-9-]+\.md$/
-
 /**
  * A character that puts the span outside this repository, or outside paths
  * altogether.
@@ -160,24 +154,7 @@ function namesAFile(span: string): boolean {
 export function classifySpan(span: string): CitationForm | undefined {
   if (isNotRepositoryPath(span)) return undefined
   if (!namesAFile(span)) return undefined
-  if (span.includes('/')) return 'path'
-  return SIBLING_RULE.test(span) ? 'sibling' : undefined
-}
-
-/**
- * Where a citation could answer, which is wherever the reader's own tools look
- * and nowhere else.
- *
- * A sibling resolves inside the folder the citing rule sits in, since that is
- * the only place a bare rule filename means anything.
- */
-function candidatesFor(
-  form: CitationForm,
-  cited: string,
-  ruleFile: string,
-): string[] {
-  if (form === 'sibling') return [join(dirname(ruleFile), cited)]
-  return [cited]
+  return span.includes('/') ? 'path' : undefined
 }
 
 interface RawCitation {
@@ -268,7 +245,7 @@ function isGoverned(cited: string, declared: readonly string[]): boolean {
  *
  * Anchored on the entry shape rather than searched for as a substring. A bare
  * scan for the glob text finds it in the `description:` line first wherever a
- * rule names what it governs in prose, which is how `596-claude-md.md` reported
+ * rule names what it governs in prose, which is how `seed-mirror.md` reported
  * its `CLAUDE.md` glob against line 2 instead of line 4.
  */
 const LIST_ENTRY = /^\s*-\s*(?:'([^']*)'|"([^"]*)"|(\S.*?))\s*$/
@@ -410,7 +387,7 @@ export async function readCitations(root: string): Promise<CitationReport> {
       }
 
       for (const raw of collectCitations(text)) {
-        const candidates = candidatesFor(raw.form, raw.cited, file)
+        const candidates = [raw.cited]
         const resolved = candidates.find((path) =>
           existsSync(resolve(root, path)),
         )
@@ -439,7 +416,7 @@ function classifyStatus(
 ): CitationStatus {
   if (resolved !== undefined) return 'resolved'
   if (raw.marked) return 'exempt'
-  if (raw.form === 'path' && isGoverned(raw.cited, declared)) return 'governed'
+  if (isGoverned(raw.cited, declared)) return 'governed'
   return 'dead'
 }
 
@@ -456,7 +433,7 @@ async function applyIgnored(
   measured: Extract<CitationReport, { kind: 'measured' }>,
 ): Promise<CitationReport> {
   const pending = measured.citations.filter(
-    (citation) => citation.status === 'dead' && citation.form === 'path',
+    (citation) => citation.status === 'dead',
   )
   if (pending.length === 0) return measured
 

package/src/gov/install.ts

@@ -28,7 +28,7 @@ export function canonRulesDir(target: string): string {
 
 /**
  * This repository's own toolkit-only rules, installed beside `canon/` rather
- * than interleaved into its bands. No target ever holds this folder.
+ * than interleaved into its folders. No target ever holds this folder.
  */
 export function installedInternalRulesDir(target: string): string {
   return join(installedRulesDir(target), 'internal')
@@ -134,7 +134,7 @@ export function lookupRules(
 
 /**
  * Copies each rule into the subdirectory it was authored in, so the installed
- * tree keeps the band structure `governance/rules/` carries. Returns the
+ * tree keeps the rule folder structure `governance/rules/` carries. Returns the
  * target-relative paths the timeline prints.
  *
  * `destSubdir` picks which wrapper the rule lands under: `canon` for every

package/src/gov/list.ts

@@ -74,7 +74,7 @@ export function buildStackEntries(root: string): StackEntry[] {
 
 /**
  * Reads the catalog straight off the source tree. A rule's domain is the
- * subdirectory it sits in, which is the band grouping install preserves, and
+ * subdirectory it sits in, which is the rule folder grouping install preserves, and
  * its `detect` entry is the evidence that proposes it, null for a rule
  * `detect.toml` does not name.
  */

package/src/gov/payload.ts

@@ -5,7 +5,7 @@ import { stripFrontmatter } from '@/markdown/frontmatter'
 /**
  * Lists installed rules in the order the payload concatenates them. Sorting by
  * path keeps the numeric filename prefixes ordered inside each subdirectory,
- * which is how the rule bands are meant to read.
+ * which is how the rule folders are meant to read.
  */
 export function listRuleFiles(rulesDir: string): string[] {
   return [

package/src/gov/stacks.ts

@@ -78,9 +78,9 @@ export function loadGovStack(
  * entry resolves to itself, so a folder and a slug reach the caller as one
  * shape rather than two the caller has to tell apart.
  *
- * The directory wins over a rule file of the same name. They cannot collide
- * while `claude/skills/create-rule/references/rule.md` requires a numeric prefix on a rule slug, since a
- * band folder carries none.
+ * The directory wins over a rule file of the same name, which would leave
+ * that rule unreachable from a stack entry. `src/gov/rule-layout.test.ts`
+ * fails on any rule basename equal to a folder name, so the two never meet.
  */
 export function expandStackEntry(root: string, entry: string): string[] {
   const dir = join(rulesSourceDir(root), entry)
@@ -163,7 +163,7 @@ export function unreferencedRules(root: string): string[] {
  * does not hold. `resolveRules` already walks a stack's `extends` ancestors,
  * so reading its leaf entry is enough; no second walk resolves the chain
  * itself. A stack the toolkit no longer ships resolves to nothing rather than
- * throwing, the same way `readNewRules`'s band fallback already treats it.
+ * throwing, the same way `readNewRules`'s folder fallback already treats it.
  *
  * A held rule's declared successor counts as held, since the sync that
  * renames the old file installs it.

package/src/inventory/subjects.ts

@@ -27,7 +27,7 @@ export interface Subject {
 
 /**
  * Reports what each element changes about itself when it takes focus, which is
- * the reading `governance/rules/ui/410-a11y.md` states three rules against and
+ * the reading `governance/rules/ui/a11y.md` states three rules against and
  * nothing measures.
  *
  * The difference between rest and focus is the treatment, rather than the

package/src/markdown/ceiling.ts

@@ -34,9 +34,14 @@ export interface CeilingFinding {
   readonly exempt: string | null
 }
 
+/** Whether the release tool writes this document, which no measure reads. */
+export function isChangelog(rel: string): boolean {
+  return basename(rel) === CHANGELOG
+}
+
 /** The reason a document is exempt from the ceiling, or null where it is not. */
 export function lengthExemption(rel: string, source: string): string | null {
-  if (basename(rel) === CHANGELOG) return CHANGELOG_REASON
+  if (isChangelog(rel)) return CHANGELOG_REASON
 
   for (const line of bodyLines(source)) {
     if (line.fenced) continue