@erclx/canon 5.34.0 → 5.35.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

@@ -6,7 +6,6 @@ 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,14 @@ 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
+ * 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.
  *
- * `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.
+ * `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.
  */
-export type CitationForm = 'path' | 'standard' | 'sibling'
+export type CitationForm = 'path' | 'sibling'
 
 /**
  * What the sweep decided about one citation.
@@ -116,13 +115,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$/
 
@@ -146,8 +138,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,10 +152,10 @@ 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
@@ -176,15 +168,6 @@ export function classifySpan(span: string): CitationForm | 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.
  */
@@ -193,11 +176,6 @@ function candidatesFor(
   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]
 }
@@ -244,16 +222,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.

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/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

package/src/records/validate.ts

@@ -7,7 +7,6 @@ import {
   recordDir as resolveRecordDir,
   recordDirs as resolveRecordDirs,
 } from '@/roots/record'
-import { ATTRIBUTE_MARKER, governedPaths, readScope } from '@/standards/scope'
 import {
   TEACH_GLOSSARY,
   TEACH_MISSION,
@@ -18,34 +17,10 @@ import {
   WORKSPACE_NAME,
 } from '@/teach/workspace'
 
-export const RECORD_KINDS = [
-  'plans',
-  'groundwork',
-  'intake',
-  'standards',
-  'teach',
-] as const
+export const RECORD_KINDS = ['plans', 'groundwork', 'intake', 'teach'] as const
 
 export type RecordKind = (typeof RECORD_KINDS)[number]
 
-/**
- * The folders standards reads, in precedence order.
- *
- * It carries two because the corpus authors at the project root and installs
- * under `.claude/`. The authoring root wins where both exist, since the
- * installed tree is a generated copy here and a finding fixed there is
- * overwritten by the next regen. A project that consumed the corpus holds only
- * the second, so one order serves both.
- *
- * Every other kind is a session record and takes the record roots instead,
- * resolved by `@/roots/record`. Standards is the one kind that is tracked, so it
- * does not move and spells its own two candidates here.
- */
-const STANDARDS_FOLDERS: readonly string[] = [
-  'standards',
-  join('.claude', 'standards'),
-]
-
 /**
  * `unknown-kind` is raised at the argument boundary rather than by the walk, and
  * it sits here because both reach a caller through the same `reason` field. A
@@ -60,7 +35,6 @@ export const FINDING_KINDS = [
   'name-malformed',
   'title-missing',
   'section-missing',
-  'scope-unanchored',
   'entry-unreasoned',
   'suggestion-missing',
   'question-unanswerable',
@@ -103,10 +77,6 @@ export type ValidateOutcome = ValidateReport | ValidateRefused
 
 /** Every folder a kind would accept, whether or not it is on disk. */
 export function recordDirs(root: string, kind: RecordKind): string[] {
-  if (kind === 'standards') {
-    return STANDARDS_FOLDERS.map((folder) => join(root, folder))
-  }
-
   return resolveRecordDirs(root, kind)
 }
 
@@ -114,19 +84,8 @@ export function recordDirs(root: string, kind: RecordKind): string[] {
  * The folder a kind reads. The first candidate on disk wins, and the creation
  * default stands in when none exists, so a refusal and a test fixture both name
  * the location the kind would be written to.
- *
- * The default is where this parts company with `dirs[0]`, which the record
- * kinds can no longer take: their first candidate is the root the move lands at
- * and nothing creates there yet, so a fallback reading it would name a folder no
- * verb would ever write. Standards has no such split, since it is tracked and
- * its first candidate is where it is authored.
  */
 export function recordsDir(root: string, kind: RecordKind): string {
-  if (kind === 'standards') {
-    const dirs = recordDirs(root, kind)
-    return dirs.find((dir) => existsSync(dir)) ?? dirs[0]
-  }
-
   return resolveRecordDir(root, kind)
 }
 
@@ -134,18 +93,6 @@ export function isRecordKind(value: string): value is RecordKind {
   return (RECORD_KINDS as readonly string[]).includes(value)
 }
 
-/**
- * Whether a kind's folder is shared session scratch at the main worktree root.
- *
- * The five record folders are, so every session validates the records every
- * other session reads. The corpus is tracked instead, so a linked worktree holds
- * its own edited copy, and defaulting that kind to the main root would report on
- * a tree the session never touched and say nothing about which one it read.
- */
-export function isSharedScratch(kind: RecordKind): boolean {
-  return kind !== 'standards'
-}
-
 const NONE_IDENTIFIED = 'None identified.'
 const NUMBERED_FILE = /^\d{2}-[a-z0-9]+(-[a-z0-9]+)*\.md$/
 
@@ -920,127 +867,6 @@ async function checkWorkspace(dir: string, slug: string): Promise<Finding[]> {
   ]
 }
 
-const STANDARD_INDEX = 'index.md'
-const STANDARD_FIELDS = ['title', 'description'] as const
-
-const DOES_NOT_GOVERN = 'Does not govern:'
-
-/**
- * The words a governed path offers a filename. Each segment gives its own word
- * and, where it carries a prefix or a placeholder, the parts either side of a
- * hyphen, so `.canon/tasks/session-<slug>.md` offers `tasks` and `session`.
- *
- * A dotted segment gives nothing. It names the folder holding the artifact
- * rather than the artifact, and a standard named for it would pass this check
- * while naming the container every sibling shares.
- */
-export function pathWords(path: string): string[] {
-  const words: string[] = []
-
-  for (const segment of path.split('/')) {
-    if (segment.startsWith('.')) continue
-
-    const stem = segment.replace(/\.[a-z]+$/i, '').toLowerCase()
-    words.push(stem)
-    if (stem.includes('-')) words.push(...stem.split('-'))
-  }
-
-  return words.filter((word) => /^[a-z]+$/.test(word))
-}
-
-/**
- * Accepts the singular and the plural of one word. A standard over a single
- * document is named for the document and one over a folder of them is named for
- * either, and picking a side would report a conforming half of the corpus.
- */
-function namesWord(stem: string, word: string): boolean {
-  return stem === word || `${stem}s` === word || stem === `${word}s`
-}
-
-function checkStandardName(name: string, statement: string): Finding[] {
-  const paths = governedPaths(statement)
-
-  // The marker is read only where the first sentence backticks nothing, which
-  // is the catalog's own rule. A statement naming a path publishes that path
-  // however the rest of the statement describes itself.
-  if (paths.length === 0) {
-    if (statement.includes(ATTRIBUTE_MARKER)) return []
-
-    return [
-      finding(
-        'scope-unanchored',
-        name,
-        name,
-        'backticks no path in its first scope sentence and does not call itself an attribute standard, so it names no artifact to be named for.',
-      ),
-    ]
-  }
-
-  const stem = name.replace(/\.md$/, '')
-  const words = paths.flatMap(pathWords)
-
-  if (words.some((word) => namesWord(stem, word))) return []
-
-  return [
-    finding(
-      'name-malformed',
-      name,
-      name,
-      `names no part of ${paths.join(', ')}, which is what it governs. A rename reaches every target that installed the corpus and every surface citing it by bare filename.`,
-    ),
-  ]
-}
-
-export function checkStandard(name: string, text: string): Finding[] {
-  const findings: Finding[] = []
-  const frontmatter = parseFrontmatter(text)
-
-  const missing = STANDARD_FIELDS.filter(
-    (field) => !readField(frontmatter, field),
-  )
-
-  if (missing.length > 0) {
-    findings.push(
-      finding(
-        'frontmatter-incomplete',
-        name,
-        name,
-        `carries no ${missing.join(' and no ')}.`,
-      ),
-    )
-  }
-
-  const scope = readScope(text)
-
-  // The name derives from the scope statement, so an absent section leaves
-  // nothing to derive against. Reporting the name as well would name one defect
-  // twice and point the fix at the wrong file.
-  if (!scope) {
-    return [
-      ...findings,
-      finding(
-        'section-missing',
-        name,
-        '## Scope',
-        'is absent, so the standard claims no jurisdiction and can refuse no rule.',
-      ),
-    ]
-  }
-
-  if (!scope.lines.some((line) => line.trim().startsWith(DOES_NOT_GOVERN))) {
-    findings.push(
-      finding(
-        'section-missing',
-        name,
-        DOES_NOT_GOVERN,
-        'is absent from the scope section, so no boundary names the owner it hands off to.',
-      ),
-    )
-  }
-
-  return [...findings, ...checkStandardName(name, scope.statement)]
-}
-
 /**
  * The three kinds whose records are folders rather than files. Keyed by kind so
  * a seventh arrives as an entry here and the compiler names the walk it owes,
@@ -1048,7 +874,7 @@ export function checkStandard(name: string, text: string): Finding[] {
  */
 const FOLDER_CHECK: Readonly<
   Record<
-    Exclude<RecordKind, 'plans' | 'standards'>,
+    Exclude<RecordKind, 'plans'>,
     (dir: string, slug: string) => Promise<Finding[]>
   >
 > = {
@@ -1066,9 +892,8 @@ async function validateFiles(
   dir: string,
   kind: RecordKind,
   check: (name: string, text: string) => Finding[],
-  skip: (file: string) => boolean = () => false,
 ): Promise<ValidateReport> {
-  const files = (await listMarkdown(dir)).filter((file) => !skip(file))
+  const files = await listMarkdown(dir)
 
   const perFile = await Promise.all(
     files.map(async (file) =>
@@ -1080,12 +905,9 @@ async function validateFiles(
 }
 
 /**
- * Reports what every record in one folder claims against the shape its standard
- * fixes. It writes nothing whichever kind runs, and the reason differs by kind.
- * A session record is per-machine scratch with no history behind it, so a repair
- * that guessed wrong could not be undone. A standard installs into every target
- * and is cited by bare filename, so a rename costs more than the file move it
- * looks like.
+ * Reports what every record in one folder claims against the shape its reference
+ * fixes. It writes nothing, since a session record is per-machine scratch with
+ * no history behind it, so a repair that guessed wrong could not be undone.
  */
 export async function validateRecords(
   root: string,
@@ -1102,16 +924,6 @@ export async function validateRecords(
 
   if (kind === 'plans') return validateFiles(dir, kind, checkPlan)
 
-  // The walk stays flat, matching install and the catalog.
-  if (kind === 'standards') {
-    return validateFiles(
-      dir,
-      kind,
-      checkStandard,
-      (file) => file === STANDARD_INDEX,
-    )
-  }
-
   const folders = await listFolders(dir)
   const check = FOLDER_CHECK[kind]
   const perFolder = await Promise.all(

package/src/sandbox/provision.ts

@@ -220,11 +220,6 @@ function install(
   fail(`Could not install ${label} into the sandbox.`)
 }
 
-/**
- * No standards install. The corpus installs into no target, so a scenario
- * driving a skill that reads one takes the `canon standards <name>` path a real
- * project takes.
- */
 function setupAssets(
   root: string,
   sandbox: string,

package/src/secrets/shipped.ts

@@ -13,8 +13,7 @@ import { join } from 'node:path'
  *
  * What it does not cover is the plugin, which a marketplace install reads live
  * from `claude/` rather than from a tarball. That folder is a `files` entry
- * too, and its `standards` symlink resolves into a tree the field lists in its
- * own right, so both routes land inside the same corpus.
+ * too, so both routes land inside the same corpus.
  */
 export type ShipEntries =
   /** The field declares a corpus, which is what this check reads. */

package/src/serve/static.ts

@@ -200,8 +200,7 @@ export function resolveWithin(
 /**
  * Re-tests containment after following symlinks. `resolveWithin` is lexical
  * and `resolve` does not follow a link, so a link inside the root clears that
- * test while the file it points at sits outside. This repository is a live
- * instance, since `claude/standards` is a link out of `claude/`.
+ * test while the file it points at sits outside.
  *
  * Only a path that exists is checked, because a link can be followed only once
  * there is something on the other end, and a path that resolves to nothing is

package/src/shipped/references.ts

@@ -10,8 +10,7 @@ import { isMarked } from '@/sweep/exempt-marker'
  * on purpose rather than by omission. What decides membership here is whether
  * anything serves the file to a reader who does not hold this repository: a
  * skill body loads into a session, a docs page is read through `canon docs`, a
- * standard through `canon standards`, a rule through a glob match, and a seed
- * through an install. A `src/` doc comment
+ * rule through a glob match, and a seed through an install. A `src/` doc comment
  * is read by someone working on the toolkit, in this checkout, where every
  * number resolves.
  *
@@ -19,18 +18,12 @@ import { isMarked } from '@/sweep/exempt-marker'
  * `src/design/base.css` and `src/design/tokens.ts` carry sixteen values shaped
  * `#191512`, which no width or boundary rule separates from a pull request
  * number, so telling them apart would need the line's syntactic position.
- *
- * `claude/standards` is a symlink into one of the roots below, and a walk that
- * followed it would read that corpus twice and report every finding in it
- * under two paths. Nothing is lost by not following, since it is a corpus here
- * in its own right.
  */
 export const SHIPPED_CORPORA = [
   'claude',
   'docs',
   'governance',
   'scripts',
-  'standards',
   'tooling',
 ] as const
 
@@ -146,37 +139,15 @@ const SAME_REPOSITORY =
 const DOCS_PATH = /(?<![\w./-])docs\/[^\s`)\]]*\.md\b/g
 
 /**
- * A bare `standards/<name>.md` citation from a body under `claude/skills/`,
- * which `598-authoring-layout.md` fixes as the broken form there:
- * `${CLAUDE_SKILL_DIR}` is what resolves off the `claude/standards` symlink
- * in every plugin cache, and a raw path has nothing to expand it.
- *
- * Scoped to that one corpus rather than every `isShippedCorpus` reads,
- * because `docs/agents/` and `docs/workflow/` carry the identical
- * `standards/<name>.md` shape correctly: a docs page resolves from this
- * checkout's own root rather than through a skill's `${CLAUDE_SKILL_DIR}`,
- * so the same string is the fix in one corpus and the defect in the other.
- * Widening the pattern to every corpus turns it into a mass false-positive
- * over the dozens of correct citations those two folders carry.
- *
- * The same leading-boundary discipline as `DOCS_PATH` excludes the already
- * correct form: a `/` sits ahead of `standards` in
- * `${CLAUDE_SKILL_DIR}/../../standards/<name>.md`, which the negative
- * lookbehind rejects, so a citation already rewritten to the resolving form
- * does not fail this check a second time.
+ * A call to `canon standards`, a verb no installed CLI carries any more. A
+ * shipped body naming it sends a target reader to an unknown-command error,
+ * so every corpus reports it, `docs/` included. A page saying the verb is gone
+ * carries the reference marker on that line.
  *
- * Reported unless `isStandardsPathReportable` reads the match as a
- * deliberate placeholder rather than a real citation. A body illustrating
- * the shape a project's own `standards/<name>.md` takes writes a bracketed
- * token this pattern also matches, such as `standards/<slug>.md`
- * in a skill that drafts one, which names no real file. A bare,
- * non-bracketed match now reports whether or not the file exists, unlike
- * `DOCS_PATH`, which still gates on existence: a same-repository citation
- * under this corpus names no target project's own tree the way a `docs/`
- * path can, so shape alone separates a placeholder from a broken citation
- * here with no false-positive class existence was catching.
+ * The trailing lookahead keeps a hyphenated token such as a `standards-audit`
+ * page name from matching, since that names a file rather than a call.
  */
-const STANDARDS_PATH = /(?<![\w./-])standards\/[^\s`)\]]*\.md\b/g
+const STANDARDS_CALL = /\bcanon standards(?![\w-])/g
 
 /**
  * A phase-label-shaped token: exactly two numeric groups, with a negative
@@ -223,7 +194,7 @@ export interface ShippedReference {
     | 'pull-request'
     | 'commit'
     | 'docs-path'
-    | 'standards-path'
+    | 'retired-verb'
     | 'phase-label'
     | 'rule-path'
   /** The reference as written, so a report names the token to qualify. */
@@ -272,50 +243,31 @@ function isDocsPathReportable(
 }
 
 /**
- * Whether `file` sits in the one corpus `STANDARDS_PATH` and `RULE_PATH`
- * both gate: a shipped skill body, minus its own `REQUIREMENT.md`.
+ * Whether `file` sits in the one corpus `RULE_PATH` gates: a shipped skill
+ * body, minus its own `REQUIREMENT.md`.
  *
- * Both patterns share this scope because both bans live in
- * `598-authoring-layout.md`, stated for the same reader: a session loading
- * the `SKILL.md` body a target actually receives. `REQUIREMENT.md` is
- * excluded for the reason that file states there, since a maintainer or an
- * audit command reads it rather than a session loading it, so neither
- * resolver rule this pair enforces ever applies to it. One predicate serves
- * both call sites rather than two copies drifting apart with nothing
- * comparing them.
+ * The ban lives in `598-authoring-layout.md`, stated for one reader: a
+ * session loading the `SKILL.md` body a target actually receives.
+ * `REQUIREMENT.md` is excluded for the reason that file states there, since a
+ * maintainer or an audit command reads it rather than a session loading it,
+ * so the resolver rule never applies to it.
  */
 function isSkillBodyScope(file: string): boolean {
   return file.startsWith('claude/skills/') && !file.endsWith('/REQUIREMENT.md')
 }
 
-/**
- * Whether a `STANDARDS_PATH` match should be reported: every match that is
- * not a placeholder, whether or not the named file exists.
- *
- * Existence used to gate this the same way `isDocsPathReportable` gates its
- * corpus, which conflated a deliberate placeholder with a genuinely broken,
- * real-looking citation: both fail existence and both passed muted. A bare
- * `standards/<name>.md` names no target-project tree the way a `docs/` path
- * can, so shape alone separates the two classes here with no false-positive
- * class existence was catching.
- */
-function isStandardsPathReportable(path: string): boolean {
-  return !isPlaceholderPath(path)
-}
-
 /**
  * Every reference in one shipped file that no marker mutes.
  *
  * The corpus walk is deliberately absent, which lets most of the shape be
  * tested against a string rather than against a fixture. That is the seam
  * `headingCitationsIn` draws in `src/claude/skills-headings.ts` and `citationsIn`
- * draws in `skills-reach.ts`. `DOCS_PATH` and `STANDARDS_PATH` are the two
- * patterns that still need a filesystem, since resolving against this
- * checkout is the only thing that separates a real citation from an
- * illustration for either, so `referencesIn` takes `root` as the one
- * caller-supplied exception to that rule. `root` is required rather than
- * defaulted, since a caller that dropped it silently would report zero
- * findings for both rather than raising, which is the wrong failure
+ * draws in `skills-reach.ts`. `DOCS_PATH` is the one pattern that still
+ * needs a filesystem, since resolving against this checkout is the only thing
+ * that separates a real citation from an illustration, so `referencesIn`
+ * takes `root` as the one caller-supplied exception to that rule. `root` is
+ * required rather than defaulted, since a caller that dropped it silently
+ * would report zero findings rather than raising, which is the wrong failure
  * direction for a gate.
  *
  * The unit is the match rather than the line, unlike those two, because one
@@ -375,16 +327,13 @@ export function referencesIn(
       })
     }
 
-    if (isSkillBodyScope(file)) {
-      for (const match of line.matchAll(STANDARDS_PATH)) {
-        if (!isStandardsPathReportable(match[0])) continue
-        references.push({
-          file,
-          line: index + 1,
-          kind: 'standards-path',
-          text: match[0],
-        })
-      }
+    for (const match of line.matchAll(STANDARDS_CALL)) {
+      references.push({
+        file,
+        line: index + 1,
+        kind: 'retired-verb',
+        text: match[0],
+      })
     }
 
     for (const match of line.matchAll(PHASE_LABEL)) {