@erclx/canon 5.34.0 → 5.36.0

package/src/gate/stages.ts

@@ -25,7 +25,6 @@ import {
   skillFamily,
   skillPracticeShape,
   skillProvenance,
-  standardCriteria,
   unreferencedRules,
   visualPathGlobs,
 } from '@/gate/measures'
@@ -502,11 +501,6 @@ export const STAGES: readonly Stage[] = [
     label: 'Skill family',
     checks: [{ kind: 'measure', measure: skillFamily }],
   },
-  {
-    id: 'standard-criteria',
-    label: 'Standard success criteria',
-    checks: [{ kind: 'measure', measure: standardCriteria }],
-  },
   {
     id: 'sandbox-coverage',
     label: 'Sandbox coverage',
@@ -522,18 +516,6 @@ export const STAGES: readonly Stage[] = [
     label: 'Plugin manifests',
     checks: [{ kind: 'measure', measure: pluginManifests }],
   },
-  {
-    id: 'spelling',
-    label: 'Spelling',
-    checks: [
-      {
-        kind: 'command',
-        argv: ['bun', 'run', 'check:spell'],
-        failure: 'Spell check failed',
-      },
-    ],
-    success: 'Spell check passed',
-  },
   {
     id: 'shell',
     label: 'Shell',

package/src/gov/citations.ts

@@ -1,12 +1,11 @@
 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'
 import { listRuleFiles } from '@/gov/payload'
 import { parseFrontmatter } from '@/indexes/frontmatter'
-import { movedStandardPath } from '@/standards/read'
 import { findBacktickSpans } from '@/markdown/backticks'
 
 /**
@@ -42,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 three resolve
- * against different roots and a reader repairing one needs to know which.
- *
- * `standard` is the live form, carried by 20 rules. `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' | 'standard' | 'sibling'
+export type CitationForm = 'path'
 
 /**
  * What the sweep decided about one citation.
@@ -116,16 +112,6 @@ const FENCE = /^\s*(?:```|~~~)/
 
 const FRONTMATTER_DELIMITER = /^---\s*$/
 
-/**
- * The verb form, with the name captured. A leading letter or digit is required,
- * which is what leaves `canon standards <name>` unmatched: that line teaches the
- * form rather than citing a standard, and it is the only one in either corpus.
- */
-const STANDARD_CALL = /canon standards ([A-Za-z0-9][A-Za-z0-9._-]*)/g
-
-/** 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.
@@ -146,8 +132,8 @@ function isNotRepositoryPath(span: string): boolean {
  * This is what separates a citation from the folder and module conventions the
  * corpus is full of. `next/font`, `try/except`, `react-hooks/set-state-in-effect`,
  * and `oven-sh/setup-bun@v2` all carry a slash and name no file, and a trailing
- * slash is a folder rather than a document. The cost is that `claude/standards`
- * is a real path this declines to check, which is the bound the report states.
+ * slash is a folder rather than a document. The cost is that a real folder path
+ * goes unchecked, which is the bound the report states.
  */
 function namesAFile(span: string): boolean {
   if (span.endsWith('/')) return false
@@ -160,46 +146,15 @@ function namesAFile(span: string): boolean {
  * sweep can resolve.
  *
  * The whole span is classified rather than a trailing pattern inside it.
- * Extracting `standards/tooling-reference.md` out of
- * `internal/standards/tooling-reference.md` and resolving that against the
- * standards root manufactures a dead citation out of a file that exists, which
- * a session measuring this corpus did before the check was written.
+ * Extracting a trailing `<folder>/<name>.md` out of a longer path and resolving
+ * that against another root manufactures a dead citation out of a file that
+ * exists, which a session measuring this corpus did before the check was
+ * written.
  */
 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 standard name takes the authoring root alone, matching `standardRoots` in
- * `@/standards/read`, which reads `standards/` at the working root and then the
- * package corpus, plus the skill reference a retired name moved to. This verb
- * refuses a tree holding no rule corpus, so it runs only where those two roots
- * are one directory. `internal/standards/` is
- * deliberately absent: `canon standards <name>` never reaches it, so admitting it
- * here would pass a citation that refuses for the session opening it, which is a
- * gate failing open.
- *
- * 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 === 'standard') {
-    const moved = movedStandardPath(cited)
-
-    return [join('standards', `${cited}.md`), ...(moved ? [moved] : [])]
-  }
-  if (form === 'sibling') return [join(dirname(ruleFile), cited)]
-  return [cited]
+  return span.includes('/') ? 'path' : undefined
 }
 
 interface RawCitation {
@@ -244,16 +199,6 @@ export function collectCitations(text: string): RawCitation[] {
         : trimmed
     const marked = isMarked(lines, index, CITATION_MARKER)
 
-    for (const match of line.matchAll(STANDARD_CALL)) {
-      found.push({
-        line: index + 1,
-        form: 'standard',
-        cited: match[1] ?? '',
-        preview,
-        marked,
-      })
-    }
-
     // A backticked span is the only carrier a rule writes a citation in. No
     // rule in either corpus uses a markdown link, and matching running prose
     // would report every sentence that happens to name a file.
@@ -300,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*$/
@@ -442,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)),
         )
@@ -471,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'
 }
 
@@ -488,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/bans.ts

@@ -16,7 +16,7 @@ const CHARACTERS = ['—', ';'] as const
  * Parsing the prose was the alternative and it put a parser contract on a
  * document authored for people. The set is closed rather than extensible,
  * since a character is the one class a literal match settles. A word is left
- * to `write-human` as guidance and a spelling to cspell, because a word ban
+ * to `write-human` as guidance and a spelling to no check at all, because a word ban
  * catches the token and misses the habit behind it.
  */
 export const BAN_SETS: BanSets = {

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[]
 }
 
 /**

package/src/markdown/heading-case.ts

@@ -0,0 +1,74 @@
+import { bodyLines, maskDisplayed } from '@/markdown/scan'
+
+export interface HeadingCaseFinding {
+  readonly line: number
+  /** The heading or title as written, markers removed. */
+  readonly text: string
+  /** Every word after the first that opens on a capital. */
+  readonly words: readonly string[]
+}
+
+const HEADING = /^#{1,6}\s+(.*?)(?:\s+#+)?\s*$/
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n?/
+const TITLE = /^title:\s*(["']?)(.*?)\1\s*$/
+const CODE_SPAN = /(`+)(?:(?!\1).)*\1/g
+const CAPITALIZED = /^[A-Z][a-z]/
+
+/**
+ * The words of `text` that break sentence case.
+ *
+ * A code span stands for one lowercase word, so a heading opening on one
+ * counts that span as its first word. The first word with a letter in it is
+ * exempt, which keeps a leading numeral from promoting the next word.
+ */
+function capitalizedAfterFirst(text: string): string[] {
+  const masked = maskDisplayed(text.replace(CODE_SPAN, 'code'))
+    .replace(/\s+/g, ' ')
+    .trim()
+  const words = masked === '' ? [] : masked.split(' ')
+  const flagged: string[] = []
+  let seenFirst = false
+
+  for (const raw of words) {
+    const word = raw.replace(/^[^\p{L}]+/u, '')
+    if (!/\p{L}/u.test(raw)) continue
+    if (!seenFirst) {
+      seenFirst = true
+      continue
+    }
+    if (CAPITALIZED.test(word)) flagged.push(word)
+  }
+
+  return flagged
+}
+
+/**
+ * Finds a heading or a frontmatter `title` carrying a capitalized word after
+ * its first, outside code spans and all-caps tokens.
+ *
+ * A proper noun is the one case it cannot tell from title case, so the finding
+ * is a warning and no names list backs it.
+ */
+export function findHeadingCase(source: string): HeadingCaseFinding[] {
+  const found: HeadingCaseFinding[] = []
+  const check = (line: number, text: string): void => {
+    const words = capitalizedAfterFirst(text)
+    if (words.length > 0) found.push({ line, text, words })
+  }
+
+  const frontmatter = FRONTMATTER.exec(source)
+  if (frontmatter) {
+    for (const [index, text] of frontmatter[1].split('\n').entries()) {
+      const title = TITLE.exec(text)
+      if (title) check(index + 2, title[2])
+    }
+  }
+
+  for (const line of bodyLines(source)) {
+    if (line.fenced) continue
+    const heading = HEADING.exec(line.text)
+    if (heading) check(line.number, heading[1])
+  }
+
+  return found
+}

package/src/migrate/scratch-evidence.ts

@@ -6,7 +6,7 @@
  * durable record naming a folder under it as its evidence is a citation into
  * something the backup never covers. The nine promoted here are every folder
  * under scratch that a live or archived record cites and no source file under
- * `claude/`, `scripts/`, `src/`, `governance/`, or `standards/` names by path,
+ * `claude/`, `scripts/`, `src/`, or `governance/` names by path,
  * which is what separates them from a folder a script still writes into on its
  * own schedule.
  *
@@ -42,7 +42,7 @@ import { recordDir, SCRATCH } from '@/roots/record'
  * Derived by the two-clause test `canon migrate scratch-evidence` exists to
  * apply mechanically: a durable record under a `BACKED_FOLDERS` entry, live
  * or archived, names the folder as its evidence, and no file under `claude/`,
- * `scripts/`, `src/`, `governance/`, or `standards/` names that path. Measured
+ * `scripts/`, `src/`, or `governance/` names that path. Measured
  * 2026-09-06 against nine folders holding thirteen files.
  *
  * `verify-astro` and `verify-vite-react` pass the same test and are excluded