@erclx/canon 5.35.0 → 5.36.0

package/src/commands/markdown.ts

@@ -3,9 +3,14 @@ import { readFile } from 'node:fs/promises'
 import { dirname, relative, resolve } from 'node:path'
 import type { Command } from 'commander'
 import { BAN_SETS, emptyBanSets } from '@/markdown/bans'
-import { lengthExemption } from '@/markdown/ceiling'
+import { isChangelog, lengthExemption } from '@/markdown/ceiling'
+import { type ColonFinding, findColons } from '@/markdown/colons'
 import { type MarkdownAuditRefusal, resolveMarkdown } from '@/markdown/files'
 import { isGating } from '@/markdown/gate'
+import {
+  findHeadingCase,
+  type HeadingCaseFinding,
+} from '@/markdown/heading-case'
 import { decodePath, findBrokenLinks, type LinkFinding } from '@/markdown/links'
 import {
   type BanFinding,
@@ -52,6 +57,8 @@ interface FileReport {
   readonly rel: string
   readonly bans: readonly BanFinding[]
   readonly links: readonly LinkFinding[]
+  readonly colons: readonly ColonFinding[]
+  readonly headingCase: readonly HeadingCaseFinding[]
   readonly structure: StructureReport
   readonly renderedLines: number
   /** The stated reason, or null where the document is not exempt. */
@@ -90,6 +97,10 @@ export function register(program: Command): void {
         'Bullet, paragraph, and depth weight are judgments a reader settles,',
         'so all three report and none of them fails a run.',
         '',
+        'A mid-sentence colon and a heading with a capital after its first word',
+        'report the same way. A proper noun is the one case the second cannot',
+        'tell from title case, and the first is sometimes right.',
+        '',
         'Length reports a whole document past the ceiling and never exits 2.',
         'The Document ceiling gate stage owns that verdict, since this audit also',
         'runs on a record kept out of version control, where a long plan is not',
@@ -100,7 +111,7 @@ export function register(program: Command): void {
         'it correctly and a flat paragraph there is not a defect.',
         '',
         'Rewrite the sentence carrying a hit rather than swapping the token for',
-        'a near-synonym. A code span clears the report and is the answer only',
+        'a near-synonym or a colon or a comma. A code span clears the report and is the answer only',
         'where the token is genuinely an identifier under discussion, which is',
         'what markdown.md reserves the span for.',
         '',
@@ -160,9 +171,13 @@ async function runAudit(
       const abs = resolve(root, rel)
       const source = await readFile(abs, 'utf8')
       const lines = bodyLines(source)
+      // The release tool writes a changelog, so neither advisory reads it.
+      const advisory = !isChangelog(rel)
       return {
         rel,
         bans: scanBans(lines, bans),
+        colons: advisory ? findColons(lines) : [],
+        headingCase: advisory ? findHeadingCase(source) : [],
         links: findBrokenLinks(lines, (path) =>
           existsSync(resolve(dirname(abs), path)),
         ),
@@ -177,6 +192,8 @@ async function runAudit(
   reportScope(scope.files, scope.unmatched)
   reportBans(reports, bans, empty)
   reportLinks(reports, root)
+  reportColons(reports)
+  reportHeadingCase(reports)
   reportBullets(reports, checkpoints)
   reportParagraphs(reports, checkpoints)
   reportCadence(reports, checkpoints)
@@ -210,6 +227,8 @@ async function runAudit(
           path: report.rel,
           bans: report.bans,
           links: report.links,
+          colons: report.colons,
+          headingCase: report.headingCase,
           longestRun: report.structure.longestRun,
           longestRunLine: report.structure.longestRunLine,
           heavyBullets: report.structure.heavyBullets,
@@ -230,6 +249,8 @@ async function runAudit(
     bans: reports.flatMap((report) => report.bans),
     links: reports.flatMap((report) => report.links),
     structure: reports.map((report) => report.structure),
+    colons: reports.flatMap((report) => report.colons),
+    headingCase: reports.flatMap((report) => report.headingCase),
   })
 
   return gating ? EXIT_GATE : 0
@@ -310,7 +331,7 @@ function reportBans(
   logWarn(`${plural(total, 'hit')} across ${plural(carrying.length, 'file')}`)
   logWarn('This fails the run. Every other check below reports.')
   logInfo(
-    'Rewrite the sentence rather than swapping the token for a near-synonym.',
+    "Rewrite the sentence rather than swapping the token for a near-synonym, or a colon or a comma in the dash's place. That is the same sentence.",
   )
   logInfo(
     'A code span clears the report and is the answer only where the token is genuinely an identifier under discussion, which is what markdown.md reserves the span for.',
@@ -383,6 +404,78 @@ function reportLinks(reports: readonly FileReport[], root: string): void {
   )
 }
 
+function reportColons(reports: readonly FileReport[]): void {
+  logStep('Colons')
+  logInfo(
+    'A colon followed by more text in a prose line, outside a label, a code span, and a link.',
+  )
+  logInfo(
+    'A heading, a table row, a fenced block, and a line-final colon are excluded. This never fails a run.',
+  )
+
+  const carrying = reports
+    .filter((report) => report.colons.length > 0)
+    .sort((a, b) => b.colons.length - a.colons.length)
+
+  if (carrying.length === 0) {
+    logInfo('No colon joining two clauses.')
+    return
+  }
+
+  const total = carrying.reduce((sum, report) => sum + report.colons.length, 0)
+  logWarn(`${plural(total, 'colon')} across ${plural(carrying.length, 'file')}`)
+  logInfo(
+    'Split the sentence or rewrite it. A colon belongs after a label or at the end of a line introducing a list.',
+  )
+  pipeOutput(
+    carrying
+      .map(
+        (report) =>
+          `${report.rel}  ${plural(report.colons.length, 'colon')}\n${report.colons
+            .map((found) => `  :${found.line}:${found.column + 1}`)
+            .join('\n')}`,
+      )
+      .join('\n'),
+  )
+}
+
+function reportHeadingCase(reports: readonly FileReport[]): void {
+  logStep('Heading case')
+  logInfo(
+    'A heading or frontmatter title with a capitalized word after its first, outside code spans and all-caps tokens.',
+  )
+  logInfo(
+    'A proper noun reports too and is left as it is. This never fails a run.',
+  )
+
+  const carrying = reports
+    .filter((report) => report.headingCase.length > 0)
+    .sort((a, b) => b.headingCase.length - a.headingCase.length)
+
+  if (carrying.length === 0) {
+    logInfo('No heading carrying a capital after its first word.')
+    return
+  }
+
+  const total = carrying.reduce(
+    (sum, report) => sum + report.headingCase.length,
+    0,
+  )
+  logWarn(
+    `${plural(total, 'heading')} across ${plural(carrying.length, 'file')}`,
+  )
+  pipeOutput(
+    carrying
+      .map(
+        (report) =>
+          `${report.rel}  ${plural(report.headingCase.length, 'heading')}\n${report.headingCase
+            .map((found) => `  :${found.line}  ${found.text}`)
+            .join('\n')}`,
+      )
+      .join('\n'),
+  )
+}
+
 function reportBullets(
   reports: readonly FileReport[],
   checkpoints: Checkpoints,

package/src/commands/records.ts

@@ -81,7 +81,7 @@ export function register(program: Command): void {
   const records = program
     .command('records')
     .description(
-      'Check a governed corpus against its standard, and back up the session records under .claude/',
+      'Check a governed corpus against its standard, and back up the session records under .canon/',
     )
     .helpOption('-h, --help', 'Show this help message')
 

package/src/commands/sync.ts

@@ -57,6 +57,17 @@ export function register(program: Command): void {
     .addHelpText(
       'after',
       [
+        '',
+        'Runs `canon gov sync`, `canon design sync`, and `canon claude sync`',
+        'on each domain installed, so each carries its own replace behavior:',
+        'governance replaces an edited rule and deletes a retired one, design',
+        'replaces its shipped files, and claude writes .gitignore alone.',
+        'Tooling is not synced. Refuses a dirty working tree.',
+        '',
+        'Exit codes:',
+        '  0  synced, no domain installed, or --check without --exit-code',
+        '  1  the target or a dirty tree was refused, opening the pull request',
+        '     failed, or --check --exit-code found drift',
         '',
         'Examples:',
         '  canon sync',

package/src/commands/tooling.ts

@@ -106,6 +106,14 @@ export function register(program: Command): void {
         'what `canon sync --check --exit-code` spells with a flag. Pass --check',
         'to report the same list and always exit 0.',
         '',
+        '--write replaces every golden config that differs from the stack.',
+        'Seeds are copy-once, so a seed the target already holds is left alone.',
+        '',
+        'Exit codes:',
+        '  0  synced, up to date, cancelled, or run with --check',
+        '  1  refused, or run headlessly with neither flag while a file would',
+        '     be replaced',
+        '',
       ].join('\n'),
     )
     .action(

package/src/design/budget.ts

@@ -1,3 +1,5 @@
+import { canonicalHeading } from '@/design/parse'
+
 /**
  * The prose budget `claude/skills/canvas-board/references/design.md` sets for a design record, and the
  * counter the `design` gate stage reads it through.
@@ -11,21 +13,23 @@
  * `<` is dropped the way `prose()` drops it, and so is a fenced block or an
  * HTML comment spanning several lines, which `prose()` would read in part. A
  * `###` subsection counts toward the `##` section holding it, since the
- * standard fixes the sections and a subheading is no way past the cap.
+ * standard fixes the sections and a subheading is no way past the cap. A
+ * legacy `## Personality` takes the Overview cap through the parser's alias,
+ * and a finding names the heading as the record wrote it.
  */
 export const DESIGN_BUDGET = {
   /** Words before the first `##` section, the title excluded. */
   leadWords: 40,
-  /** Words in `## Personality`, held to one paragraph. */
-  personalityWords: 60,
-  personalityParagraphs: 1,
+  /** Words in `## Overview`, held to one paragraph. */
+  overviewWords: 60,
+  overviewParagraphs: 1,
   /** Bullets or paragraphs in any other section, beside its table. */
   rules: 3,
   /** Words in one of those rules, the proxy for one line. */
   ruleWords: 25,
 } as const
 
-const PERSONALITY = 'Personality'
+const OVERVIEW = 'Overview'
 
 /** A list item at any depth, which starts a rule of its own. */
 const BULLET = /^\s*(?:[-*+]|\d+[.)])\s+/
@@ -52,15 +56,15 @@ export function measureDesignProse(source: string): string[] {
           `The lead holds ${total} words against a cap of ${DESIGN_BUDGET.leadWords}`,
         )
       }
-    } else if (section.heading === PERSONALITY) {
-      if (rules.length > DESIGN_BUDGET.personalityParagraphs) {
+    } else if (canonicalHeading(section.heading) === OVERVIEW) {
+      if (rules.length > DESIGN_BUDGET.overviewParagraphs) {
         findings.push(
-          `${PERSONALITY} holds ${rules.length} paragraphs against a cap of ${DESIGN_BUDGET.personalityParagraphs}`,
+          `${section.heading} holds ${rules.length} paragraphs against a cap of ${DESIGN_BUDGET.overviewParagraphs}`,
         )
       }
-      if (total > DESIGN_BUDGET.personalityWords) {
+      if (total > DESIGN_BUDGET.overviewWords) {
         findings.push(
-          `${PERSONALITY} holds ${total} words against a cap of ${DESIGN_BUDGET.personalityWords}`,
+          `${section.heading} holds ${total} words against a cap of ${DESIGN_BUDGET.overviewWords}`,
         )
       }
     } else {

package/src/design/document.ts

@@ -114,10 +114,10 @@ export function renderDesignDocument(tokens: DesignTokens = TOKENS): string {
     '',
     LEAD,
     '',
-    section('Personality', tokens.personality),
+    section('Overview', tokens.personality),
     '',
     section(
-      'Color',
+      'Colors',
       bullets(tokens.colorRules),
       formatTable(['Role', 'Intent', 'Value'], colorRows(tokens.color)),
     ),
@@ -137,8 +137,10 @@ export function renderDesignDocument(tokens: DesignTokens = TOKENS): string {
       formatTable(['Step', 'Multiplier', 'Value'], spaceRows(tokens.spacing)),
     ),
     '',
+    section('Layout', bullets(tokens.layout)),
+    '',
     section(
-      'Borders',
+      'Shapes',
       bullets(tokens.bordersRules),
       formatTable(
         ['Role', 'Radius', 'Width', 'When used'],
@@ -146,8 +148,6 @@ export function renderDesignDocument(tokens: DesignTokens = TOKENS): string {
       ),
     ),
     '',
-    section('Layout', bullets(tokens.layout)),
-    '',
     section('Motion', bullets(tokens.motion)),
     '',
     section('Iconography', bullets(tokens.iconography)),

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

@@ -659,7 +659,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/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/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)

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

package/src/markdown/colons.ts

@@ -0,0 +1,86 @@
+import { type BodyLine, LINK, maskDisplayed } from '@/markdown/scan'
+
+export interface ColonFinding {
+  readonly line: number
+  /** Zero-based, the colon itself. */
+  readonly column: number
+  /** The whole source line, so a reader can match it against new text. */
+  readonly text: string
+  /**
+   * The run of non-space characters ending at the colon. A hook matches it
+   * against new text, since `column` is a UTF-16 offset that a reader counting
+   * code points would misplace after an emoji.
+   */
+  readonly lead: string
+}
+
+const HEADING = /^#{1,6}\s/
+const TABLE_ROW = /^\s*\|/
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/
+const QUOTE_MARKER = /^(?:\s*>\s?)+/
+
+/** A colon followed by whitespace and more text, ruling out `10:30` and a scheme. */
+const COLON = /:(?=\s+\S)/g
+
+const BOLD_LABEL = /^(\*\*|__)[^*_]+\1$/
+
+/** Blanks a span while holding its width, so a column stays where it was. */
+function blank(match: string): string {
+  return ' '.repeat(match.length)
+}
+
+/**
+ * Whether the text before a line's first colon is a label rather than a
+ * clause: the lead of a list item, or a prefix that is only emphasis and a
+ * masked code span.
+ */
+function isLabel(prefix: string, listItem: boolean): boolean {
+  if (BOLD_LABEL.test(prefix.trim())) return true
+
+  const words = prefix.replace(/[*_]/g, ' ').trim()
+  if (words === '') return true
+  return listItem && words.split(/\s+/).length <= 4
+}
+
+/**
+ * Finds a colon joining two clauses in the middle of a prose sentence.
+ *
+ * A heading, a table row, a fence, a code span, a link, and a line-final colon
+ * are left alone, and so is the first colon of a list item or of a line opening
+ * on a bold or code label. The measure is advisory, because a colon is
+ * sometimes right and the corpus count shows a gate would be a sweep nobody
+ * asked for.
+ */
+export function findColons(lines: readonly BodyLine[]): ColonFinding[] {
+  const found: ColonFinding[] = []
+
+  for (const line of lines) {
+    if (line.fenced || HEADING.test(line.text) || TABLE_ROW.test(line.text)) {
+      continue
+    }
+
+    const masked = maskDisplayed(line.text.replace(LINK, blank))
+    const quote = QUOTE_MARKER.exec(masked)?.[0] ?? ''
+    const marker = LIST_MARKER.exec(masked.slice(quote.length))?.[0] ?? ''
+    const start = quote.length + marker.length
+    let labelled = false
+
+    for (const match of masked.matchAll(COLON)) {
+      if (match.index < start) continue
+
+      if (!labelled) {
+        labelled = true
+        if (isLabel(masked.slice(start, match.index), marker !== '')) continue
+      }
+
+      found.push({
+        line: line.number,
+        column: match.index,
+        text: line.text,
+        lead: line.text.slice(0, match.index).replace(/^.*\s/, ''),
+      })
+    }
+  }
+
+  return found
+}

package/src/markdown/gate.ts

@@ -1,3 +1,5 @@
+import type { ColonFinding } from '@/markdown/colons'
+import type { HeadingCaseFinding } from '@/markdown/heading-case'
 import type { LinkFinding } from '@/markdown/links'
 import type { BanFinding } from '@/markdown/scan'
 import type { StructureReport } from '@/markdown/structure'
@@ -16,6 +18,19 @@ export interface GateInput {
    * alone states the same rule and leaves no place to assert it.
    */
   readonly structure: readonly StructureReport[]
+  /**
+   * Every mid-sentence colon the run measured, read by nothing here.
+   *
+   * A colon is sometimes right and the corpus carries over a thousand
+   * candidates, so the measure warns and a push never fails on it.
+   */
+  readonly colons: readonly ColonFinding[]
+  /**
+   * Every heading or title with a capital after its first word, read by
+   * nothing here. A proper noun is the one case it cannot tell from title
+   * case, and gating it would need a names list and an escape marker.
+   */
+  readonly headingCase: readonly HeadingCaseFinding[]
 }
 
 /**