@erclx/canon 5.63.0 → 5.65.0

package/governance/ledger/skills/test-craft/component.md

@@ -0,0 +1,49 @@
+---
+title: Component tests reference ledger
+description: Sources for claude/skills/test-craft/references/component.md, one row per bullet
+---
+
+# Component tests reference ledger
+
+The field is UI testing, where Testing Library and Kent C. Dodds's guidance carry how a rendered component is queried, driven, and waited on. Vitest and Playwright carry the real-browser runners. Each row cites the bullet's own inline link where the reference carries one.
+
+## What belongs here
+
+| Bullet                                 | Source                                                                                                                                                                                                                                        | Read       |
+| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Every state a component shows          | [Vocke, The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html): in a UI test, "data should be presented to the user, the UI state should change as expected"                                              | 2026-10-24 |
+| Every interaction that changes it      | [Vocke, The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html): "User input should trigger the right actions"                                                                                             | 2026-10-24 |
+| Conditional rendering, keys, and focus | [Testing Library, user-event](https://testing-library.com/docs/user-event/intro): it "manipulates the DOM just like a user interaction in the browser would", and "wouldn't let a user click a hidden element or type in a disabled text box" | 2026-10-24 |
+| Not layout, scroll, or motion          | [Vitest, Why Browser Mode](https://vitest.dev/guide/browser/why): jsdom and happy-dom "only simulate a browser environment and not an actual browser, which may result in some discrepancies"                                                 | 2026-10-24 |
+
+## Render
+
+| Bullet                               | Source                                                                                                                                                                                                                    | Read       |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Real children                        | [Dodds, Write tests](https://kentcdodds.com/blog/write-tests): "When you mock something you're removing all confidence in the integration between what you're testing and what's being mocked."                           | 2026-10-24 |
+| The network doubled at its edge      | [Mock Service Worker, Philosophy](https://mswjs.io/docs/philosophy): it intercepts "outgoing network traffic", which "means having zero changes to your code altogether"                                                  | 2026-10-24 |
+| Props and fixtures through a factory | [Pryce, Test Data Builders](http://www.natpryce.com/articles/000714.html): a builder "Has "chainable" public methods for overriding the values in its instance variables", so a test spells only the values it depends on | 2026-10-24 |
+
+## Query and act like a user
+
+| Bullet                            | Source                                                                                                                                                                                                                                             | Read       |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Role and name first, test id last | [Dodds, Common mistakes with React Testing Library](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library): "Which query should I use?" lists "the queries you should attempt to use in the order you should attempt to use them" | 2026-10-24 |
+| User events over synthetic ones   | [Dodds, Common mistakes with React Testing Library](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library): user-event "provides several methods that resemble the user interactions more closely"                                | 2026-10-24 |
+| Assert what the user perceives    | [Testing Library, Guiding Principles](https://testing-library.com/docs/guiding-principles): a test "should deal with DOM nodes rather than component instances"                                                                                    | 2026-10-24 |
+
+## Wait on one condition
+
+| Bullet                         | Source                                                                                                                                                                                                                                           | Read       |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------- |
+| One assertion inside each wait | [Dodds, Common mistakes with React Testing Library](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library): "Advice: only put one assertion in a callback."                                                                     | 2026-10-24 |
+| No side effect inside a wait   | [Dodds, Common mistakes with React Testing Library](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library): the callback runs "a non-deterministic number of times", so "your side-effect could run multiple times!"            | 2026-10-24 |
+| The query that waits           | [Dodds, Common mistakes with React Testing Library](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library): "find* queries use waitFor under the hood), but the second is simpler and the error message you get will be better" | 2026-10-24 |
+
+## When a simulated DOM cannot render it
+
+| Bullet                          | Source                                                                                                                                                                                                                                                                                                  | Read       |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Vitest browser mode             | [Vitest, Browser Mode](https://vitest.dev/guide/browser/): the feature "allows you to run your tests in the browser natively, providing access to browser globals like window and document"                                                                                                             | 2026-10-24 |
+| Astro through its client module | [Astro, Testing](https://docs.astro.build/en/guides/testing/): "Use Astro’s getViteConfig() helper in your vitest.config.ts configuration file to set up Vitest with your Astro project’s settings", while [Vitest's component list](https://vitest.dev/guide/browser/component-testing) names no Astro | 2026-10-24 |
+| Playwright component testing    | [Playwright, Components](https://playwright.dev/docs/test-components): "It is stable. Tests import test and expect from plain @playwright/test", and a user of the removed packages should "stay on Playwright 1.62 until you have followed the migration guide"                                        | 2026-10-24 |

package/governance/ledger/skills/test-craft/e2e.md

@@ -0,0 +1,55 @@
+---
+title: End to end tests reference ledger
+description: Sources for claude/skills/test-craft/references/e2e.md, one row per bullet
+---
+
+# End to end tests reference ledger
+
+The field is browser test automation. Playwright's own documentation carries the runner rules, at the version the reference states, and Ham Vocke's pyramid carries which journeys earn a browser run. Each row cites the bullet's own inline link where the reference carries one.
+
+The two worked failures report what one project's suite did, so each of their rows is a house choice naming the failure the incident shows rather than an outside citation.
+
+## What earns a browser run
+
+| Bullet                               | Source                                                                                                                                                                                                                                    | Read       |
+| ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| A journey the product cannot lose    | [Vocke, The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html): "your most valuable customer journey could be a user searching for a product, putting it in the shopping basket and doing a checkout" | 2026-10-24 |
+| What only a real browser computes    | [Vitest, Why Browser Mode](https://vitest.dev/guide/browser/why): "To achieve the highest level of confidence in our tests, it's crucial to test in a real browser environment."                                                          | 2026-10-24 |
+| Not a state a component test reaches | [Vocke, The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html): end-to-end tests "are notoriously flaky and often fail for unexpected and unforeseeable reasons"                                      | 2026-10-24 |
+| Not copy                             | [obra/superpowers, Writing Good Tests](https://github.com/obra/superpowers/blob/5bf4e78/skills/test-driven-development/writing-good-tests.md): a test pinning "exact message wording" "fires on redesign and sleeps through bugs"         | 2026-10-24 |
+
+## Settle on conditions
+
+| Bullet                                 | Source                                                                                                                                                                                                                                                                           | Read       |
+| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Web-first assertions                   | [Playwright, Best Practices](https://playwright.dev/docs/best-practices): "By using web first assertions Playwright will wait until the expected condition is met."                                                                                                              | 2026-10-24 |
+| Actionability waits, a read does not   | [Playwright, Actionability](https://playwright.dev/docs/actionability): an element is "Stable , as in not animating or completed animation", while with "isVisible() the test won't wait a single second", per [Best Practices](https://playwright.dev/docs/best-practices)      | 2026-10-24 |
+| No fixed pause for a condition         | [Fowler, Eradicating Non-Determinism in Tests](https://martinfowler.com/articles/nonDeterminism.html): "Never use bare sleeps to wait for asynchonous responses: use a callback or polling.", typo as published                                                                  | 2026-10-24 |
+| A smooth scroll settles on `scrollend` | [MDN, Element: scrollend event](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollend_event): "The scrollend event fires when element scrolling has completed." The stillness fallback is a House choice: a target already in view never scrolls, so no event comes | 2026-10-24 |
+
+## Motion off by default
+
+| Bullet                                    | Source                                                                                                                                                                                                                                                                        | Read       |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Reduced unless the test asserts motion    | [Playwright, Browser](https://playwright.dev/docs/api/class-browser#browser-new-context): `reducedMotion` "Emulates 'prefers-reduced-motion' media feature", and a test opts back in through `page.emulateMedia()`                                                            | 2026-10-24 |
+| Set once in `use.contextOptions`          | [Playwright, Browser](https://playwright.dev/docs/api/class-browser#browser-new-context): `reducedMotion` "Defaults to 'no-preference'", and [TestOptions](https://playwright.dev/docs/api/class-testoptions) shows `use : { contextOptions : { reducedMotion : 'reduce' } }` | 2026-10-24 |
+| A top-level `use.reducedMotion` from 1.50 | [Playwright, TestOptions](https://playwright.dev/docs/api/class-testoptions): `testOptions.reducedMotion` was added in Playwright 1.50 and "Emulates 'prefers-reduced-motion' media feature", with `use : { reducedMotion : 'reduce' }` as its usage                          | 2026-10-25 |
+
+## Isolation and speed
+
+| Bullet                              | Source                                                                                                                                                                                                                                                  | Read       |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Every test its own state            | [Playwright, Isolation](https://playwright.dev/docs/browser-contexts): "Tests written with Playwright execute in isolated clean-slate environments called browser contexts."                                                                            | 2026-10-24 |
+| Workers and sharding over cut waits | [Playwright, Best Practices](https://playwright.dev/docs/best-practices): "Playwright runs tests in parallel by default", and "Playwright can shard a test suite, so that it can be executed on multiple machines"                                      | 2026-10-24 |
+| A suite failing as workers rise     | House choice: an assertion that passes on one worker and fails on four depends on machine load, and no settle at that layer removes the dependence                                                                                                      | 2026-10-24 |
+| A trace on the first retry          | [Playwright, Best Practices](https://playwright.dev/docs/best-practices): traces "are set to run on CI on the first retry of a failed test. We don't recommend setting this to on so that traces are run on every test as it's very performance heavy." | 2026-10-24 |
+| Count the cost before adding a test | House choice: a test's runtime multiplies by every engine and every push, so a suite grown one cheap-looking test at a time is what makes the gate slow                                                                                                 | 2026-10-24 |
+
+## Two worked failures
+
+| Bullet                                   | Source                                                                                                                                                               | Read       |
+| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| A copy edit was a decision, not a bug    | House choice: an assertion on exact wording in a browser run is a change detector, failing every engine on an edit nobody would call a bug                           | 2026-10-24 |
+| The copy belonged at unit                | House choice: a copy assertion run in a browser holds a deploy on every wording change, where a unit test beside the copy fails once and fast                        | 2026-10-24 |
+| The settle was right and the layer wrong | House choice: an assertion whose result depends on CI load keeps failing at the layer where load decides it, however correct its settle                              | 2026-10-24 |
+| The focus behavior moves down a layer    | House choice: a focus assertion on the whole-site run flakes its file and skips a deploy, where a real-browser component test observes focus without the site's load | 2026-10-24 |

package/governance/ledger/skills/test-craft/unit.md

@@ -0,0 +1,54 @@
+---
+title: Unit and integration tests reference ledger
+description: Sources for claude/skills/test-craft/references/unit.md, one row per bullet and ordered step
+---
+
+# Unit and integration tests reference ledger
+
+The field is unit testing practice. `addyosmani/agent-skills` and `obra/superpowers`, the two sources the reference cites inline, carry the doubles order, DAMP, and the mutation check. Software Engineering at Google, Fowler, and the Go wiki carry the rest.
+
+The four ordered steps under `## Doubles` and the three under `## The mutation check` each take a row, the way a bullet does.
+
+## Doubles
+
+| Bullet                                   | Source                                                                                                                                                                                                                                      | Read       |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Real first                               | [addyosmani/agent-skills, Test-Driven Development](https://github.com/addyosmani/agent-skills/blob/c004a74/skills/test-driven-development/SKILL.md): "1. Real implementation → Highest confidence, catches real bugs"                       | 2026-10-24 |
+| Fake second                              | [addyosmani/agent-skills, Test-Driven Development](https://github.com/addyosmani/agent-skills/blob/c004a74/skills/test-driven-development/SKILL.md): "2. Fake → In-memory version of a dependency (e.g., fake DB)"                          | 2026-10-24 |
+| Stub third                               | [addyosmani/agent-skills, Test-Driven Development](https://github.com/addyosmani/agent-skills/blob/c004a74/skills/test-driven-development/SKILL.md): "3. Stub → Returns canned data, no behavior"                                           | 2026-10-24 |
+| Mock last, when the call is the contract | [Software Engineering at Google, ch. 13](https://abseil.io/resources/swe-book/html/ch13.html): "interaction testing is useful in certain situations but should be avoided when possible because overuse can easily result in brittle tests" | 2026-10-24 |
+| Double only at an unowned boundary       | [addyosmani/agent-skills, Test-Driven Development](https://github.com/addyosmani/agent-skills/blob/c004a74/skills/test-driven-development/SKILL.md): "Mock only at boundaries where real deps are slow or non-deterministic"                | 2026-10-24 |
+| Never assert a mock exists               | [obra/superpowers, Writing Good Tests](https://github.com/obra/superpowers/blob/5bf4e78/skills/test-driven-development/writing-good-tests.md): "A mock assertion passes when the mock is present and fails when it is absent"               | 2026-10-24 |
+| Clock and randomness injected            | [Fowler, Eradicating Non-Determinism in Tests](https://martinfowler.com/articles/nonDeterminism.html): "always wrap the system clock with routines that can be replaced with a seeded value for testing"                                    | 2026-10-24 |
+
+## Descriptive over shared
+
+| Bullet                              | Source                                                                                                                                                                                                                                                     | Read       |
+| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| DAMP over DRY                       | [addyosmani/agent-skills, Test-Driven Development](https://github.com/addyosmani/agent-skills/blob/c004a74/skills/test-driven-development/SKILL.md): "each test should tell a complete story without requiring the reader to trace through shared helpers" | 2026-10-24 |
+| A factory with the key values shown | [Software Engineering at Google, ch. 12](https://abseil.io/resources/swe-book/html/ch12.html): a test is not complete when "important details are hidden away in helper methods that the reader can’t see"                                                 | 2026-10-24 |
+| No shared mutable state             | [Fowler, Eradicating Non-Determinism in Tests](https://martinfowler.com/articles/nonDeterminism.html): "If one test creates some data in the database and leaves it lying around, it can corrupt the run of another test"                                  | 2026-10-24 |
+
+## Table-driven cases
+
+| Bullet                                  | Source                                                                                                                                                                                                                 | Read       |
+| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| One table for inputs differing by value | [Go wiki, TableDrivenTests](https://go.dev/wiki/TableDrivenTests): "Each table entry is a complete test case with inputs and expected results, and sometimes with additional information such as a test name"          | 2026-10-24 |
+| A row holds input and expected output   | [obra/superpowers, Writing Good Tests](https://github.com/obra/superpowers/blob/5bf4e78/skills/test-driven-development/writing-good-tests.md): "table-driven tests with literal `want` values are the preferred shape" | 2026-10-24 |
+| Split the table on a new assertion      | [Go wiki, TableDrivenTests](https://go.dev/wiki/TableDrivenTests): "the actual test simply iterates through all table entries and for each entry performs the necessary tests", one test body every row shares         | 2026-10-24 |
+
+## Integration at a boundary
+
+| Bullet                                 | Source                                                                                                                                                                                                                                      | Read       |
+| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Through the callers' interface         | [Vocke, The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html): "Narrow integration tests live at the boundary of your service", "triggering an action that leads to integrating with the outside part" | 2026-10-24 |
+| A temporary directory or database each | [Fowler, Eradicating Non-Determinism in Tests](https://martinfowler.com/articles/nonDeterminism.html): tests need "a well-known state at the beginning of the test", and "Properly isolated tests can be run in any sequence."              | 2026-10-24 |
+| The failure path at the boundary       | [Software Engineering at Google, ch. 11](https://abseil.io/resources/swe-book/html/ch11.html): a review is easier with "thorough tests that demonstrate code correctness, edge cases, and error conditions"                                 | 2026-10-24 |
+
+## The mutation check
+
+| Bullet                              | Source                                                                                                                                                                                                                                                | Read       |
+| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| Name three to five breaks           | [obra/superpowers, Writing Good Tests](https://github.com/obra/superpowers/blob/5bf4e78/skills/test-driven-development/writing-good-tests.md): "mentally mutate the production code", and "at least one test should fail for each realistic mutation" | 2026-10-24 |
+| Say which test fails for each       | [Stryker, What is mutation testing?](https://stryker-mutator.io/docs/): "If your tests fail then the mutant is killed", and "If your tests passed, the mutant survived"                                                                               | 2026-10-24 |
+| An uncaught break is a missing case | [obra/superpowers, Writing Good Tests](https://github.com/obra/superpowers/blob/5bf4e78/skills/test-driven-development/writing-good-tests.md): "A mutation nothing catches marks the behavior as unprotected"                                         | 2026-10-24 |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "5.63.0",
+  "version": "5.65.0",
   "description": "Runs your agent's work and keeps its code good, on one setup for every repo.",
   "license": "MIT",
   "bin": {
@@ -69,8 +69,8 @@
     "astro": "^6.1.9",
     "husky": "^9.1.7",
     "micromatch": "^4.0.8",
-    "oxfmt": "0.73.0",
-    "oxlint": "1.88.0",
+    "oxfmt": "0.74.0",
+    "oxlint": "1.89.0",
     "prettier": "^3.8.1",
     "prettier-plugin-astro": "^0.14.1",
     "prettier-plugin-tailwindcss": "^0.8.1",

package/src/audits/catalog.ts

@@ -2,7 +2,6 @@ import type { SkillsAuditRefusal } from '@/claude/skills-audit'
 import type { RankRefusal } from '@/claude/skills-rank'
 import type { ReachRefusal } from '@/claude/skills-reach'
 import type { ContextAuditRefusal } from '@/context/audit'
-import type { SweepVerdict } from '@/context/classify/patterns'
 import type { AuditRefusal } from '@/deps/audit'
 import type { RuleAuditRefusal } from '@/gov/audit'
 import type { RestatedRefusal } from '@/gov/restated'
@@ -161,45 +160,6 @@ function requirementsCounts(
   return { requirementsOverWords: record.words > record.wordCap ? 1 : 0 }
 }
 
-/**
- * The retained key for each verdict the sweep can return. A record rather than
- * a list, so the compiler fails here when the classifier gains a verdict,
- * instead of that verdict's sections dropping out of the tally.
- */
-const PLACEMENT_KEYS: Record<SweepVerdict, string> = {
-  KEEP: 'keep',
-  REWRITE: 'rewrite',
-  MOVE: 'move',
-}
-
-function isPlacementVerdict(value: unknown): value is SweepVerdict {
-  return typeof value === 'string' && Object.hasOwn(PLACEMENT_KEYS, value)
-}
-
-/**
- * Tallies the sweep's findings by verdict, with a zero for a verdict nothing
- * returned, so a baseline reads the same three keys on every run.
- *
- * `KEEP` is retained beside the two that ask for a change. It moves when a
- * section is added or split, which is what tells a falling `rewrite` count
- * from a corpus that shrank.
- */
-function placementCounts(record: unknown): Record<string, number> | undefined {
-  const findings = asObject(record)?.findings
-  if (!Array.isArray(findings)) return undefined
-
-  const counts: Record<string, number> = Object.fromEntries(
-    Object.values(PLACEMENT_KEYS).map((key) => [key, 0]),
-  )
-  for (const finding of findings) {
-    const verdict = asObject(finding)?.verdict
-    if (!isPlacementVerdict(verdict)) return undefined
-    counts[PLACEMENT_KEYS[verdict]] += 1
-  }
-
-  return counts
-}
-
 function contextCounts(record: unknown): Record<string, number> | undefined {
   const root = asObject(record)
   if (root === undefined) return undefined
@@ -526,18 +486,6 @@ export const AUDITS: readonly AuditSpec[] = [
     absentReasons: ['no-folders'] satisfies ContextAuditRefusal[],
     counts: contextCounts,
   },
-  {
-    id: 'placement',
-    label: 'Context placement',
-    // Pinned to the regex layer rather than the resolved classifier setting.
-    // A count that moves with whichever model a machine runs is not
-    // comparable across clones, and the model layer turns a sub-second read
-    // into a multi-minute one. `document-health` is where the model reads.
-    argv: ['context', 'classify', 'sweep', '--backend', 'off', '--json'],
-    gatingExits: [],
-    corpus: 'tracked',
-    counts: placementCounts,
-  },
   {
     id: 'markdown',
     label: 'Markdown corpus',

package/src/claude/skills-audit.ts

@@ -5,8 +5,8 @@ import { plural } from '@/cli/ui'
 import {
   compareLedger,
   countLedgerRows,
+  type HeadingCount,
   type LedgerMismatch,
-  measureRule,
 } from '@/gov/audit'
 import { parseFrontmatter, readField } from '@/indexes/frontmatter'
 import {
@@ -84,19 +84,56 @@ export const LEDGER_SKILLS: readonly string[] = [
   join(SHIPPED_CORPUS, 'ui-craft'),
 ]
 
+function references(...names: string[]): string[] {
+  return names.map((name) => join('references', `${name}.md`))
+}
+
+export interface BulletLedgerScope {
+  /** References left off, each a checklist or glossary naming no new source. */
+  readonly exempt: readonly string[]
+  /** True when `SKILL.md` carries directives of its own to ledger. */
+  readonly body: boolean
+}
+
 /**
  * The ledger-listed skills whose every reference but the source record carries
  * a ledger of its own, one table row per bullet under each H2, the way a rule
- * in a practice folder does. The ledgers sit outside the plugin as rule
- * ledgers do, so a target pays nothing for them.
+ * in a practice folder does. A reference is ledgered unless exempted by name,
+ * so one added later fails until its rows land rather than passing unread. The
+ * ledgers sit outside the plugin as rule ledgers do, so a target pays nothing
+ * for them.
  */
-export const BULLET_LEDGER_SKILLS: readonly string[] = [
-  join(SHIPPED_CORPUS, 'ui-craft'),
-]
+export const BULLET_LEDGER_SKILLS: Readonly<Record<string, BulletLedgerScope>> =
+  {
+    [join(SHIPPED_CORPUS, 'ui-craft')]: { exempt: [], body: false },
+    [join(SHIPPED_CORPUS, 'api-design')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'code-craft')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'deprecation-migration')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'design-taste')]: {
+      exempt: references('preflight', 'vocabulary'),
+      body: true,
+    },
+    [join(SHIPPED_CORPUS, 'review-craft')]: {
+      exempt: references('ui'),
+      body: true,
+    },
+    [join(SHIPPED_CORPUS, 'teach-craft')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'test-craft')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'codebase-layout')]: { exempt: [], body: true },
+  }
 
-/** Where a per-bullet ledger lives, as `<skill>/<reference>.md` below it. */
+/** Where a per-bullet ledger lives, as `<skill>/<file>.md` below it. */
 export const SKILL_LEDGERS = join('governance', 'ledger', 'skills')
 
+/**
+ * The ledger a ledgered file pairs with, keyed by the file's own name, so a
+ * reference drops its `references/` segment and a `SKILL.md` keeps its name.
+ */
+export function skillLedgerPath(folder: string, file: string): string {
+  const inside = relative('references', file)
+  return join(SKILL_LEDGERS, folder, inside.startsWith('..') ? file : inside)
+}
+
 /** The closing H2s a practice skill carries, matched exactly outside fences. */
 export const PRACTICE_SECTIONS: readonly string[] = [
   'Excuses and rebuttals',
@@ -104,6 +141,16 @@ export const PRACTICE_SECTIONS: readonly string[] = [
   'Before handing over',
 ]
 
+/**
+ * The H2s that end a listed body's concern groups. The closing sections
+ * restate the groups' rules as excuses, signs, and checks, and the delegates
+ * section routes, so neither states a rule of its own to source.
+ */
+export const BODY_CLOSERS: readonly string[] = [
+  ...PRACTICE_SECTIONS,
+  'What this delegates',
+]
+
 /** The source ledger every practice skill carries beside its body. */
 export const PRACTICE_LEDGER = join('references', 'adopted.md')
 
@@ -157,6 +204,12 @@ const ISSUE_NUMBER = /(?<![\w&/#])#\d+\b/g
 
 const TOP_LEVEL_BULLET = /^(?:[-*+]|\d+[.)])\s/
 
+/**
+ * A line a skill ledger pairs with a row: a top-level `- ` bullet as a rule
+ * writes one, or a top-level ordered step, which states a directive as surely.
+ */
+const LEDGERED_LINE = /^(?:- |\d+[.)]\s)/
+
 const WORD = /\S*[\p{L}\p{N}]\S*/gu
 
 export interface SkillFinding {
@@ -213,8 +266,10 @@ interface SkillSource {
    * requirement is where the standard sends a date.
    */
   readonly bodies: readonly SkillText[]
-  /** One entry per reference of a skill on the per-bullet ledger list. */
+  /** One entry per ledgered file of a skill on the per-bullet ledger list. */
   readonly referenceLedgers: readonly ReferenceLedger[]
+  /** Exempted references the skill no longer carries, which exempt nothing. */
+  readonly staleExemptions: readonly string[]
 }
 
 interface ReferenceLedger {
@@ -342,15 +397,22 @@ async function readSkill(
 
   const fields = parseFrontmatter(body)
   const skillRel = join(rel, folder)
-  const referenceLedgers = BULLET_LEDGER_SKILLS.includes(skillRel)
-    ? await readReferenceLedgers(
-        root,
-        skillRel,
-        folder,
-        references,
-        referenceTexts,
-      )
-    : []
+  const scope = BULLET_LEDGER_SKILLS[skillRel]
+  const referenceLedgers =
+    scope === undefined
+      ? []
+      : await readReferenceLedgers(root, skillRel, folder, [
+          ...(scope.body ? [{ path: 'SKILL.md', text: body }] : []),
+          ...references
+            .map((path, index) => ({ path, text: referenceTexts[index] ?? '' }))
+            .filter(
+              ({ path }) =>
+                path !== PRACTICE_LEDGER && !scope.exempt.includes(path),
+            ),
+        ])
+  const staleExemptions = (scope?.exempt ?? [])
+    .filter((path) => !references.includes(path))
+    .map((path) => join(skillRel, path))
 
   return {
     rel: skillRel,
@@ -373,44 +435,61 @@ async function readSkill(
       })),
     ],
     referenceLedgers,
+    staleExemptions,
   }
 }
 
 /**
- * Pairs each reference's bullets with its ledger's rows through the rule
- * audit's own comparison, so a reference and a rule are held to one count.
- * The source record names authorities rather than stating bullets, so it is
- * the one reference asked for no ledger.
+ * Pairs each ledgered file's directives with its ledger's rows through the rule
+ * audit's own comparison, so a skill file and a rule mismatch alike.
  */
 async function readReferenceLedgers(
   root: string,
   skillRel: string,
   folder: string,
-  references: readonly string[],
-  texts: readonly string[],
+  files: readonly { path: string; text: string }[],
 ): Promise<ReferenceLedger[]> {
   return Promise.all(
-    references
-      .map((path, index) => ({ path, text: texts[index] ?? '' }))
-      .filter(({ path }) => path !== PRACTICE_LEDGER)
-      .map(async ({ path, text }) => {
-        const ledgerRel = join(
-          SKILL_LEDGERS,
-          folder,
-          relative('references', path),
-        )
-        const ledgerPath = join(root, ledgerRel)
-        const mismatches = existsSync(ledgerPath)
-          ? compareLedger(
-              measureRule(text).groups,
-              countLedgerRows(await Bun.file(ledgerPath).text()),
-            )
-          : undefined
-        return { rel: join(skillRel, path), ledgerRel, mismatches }
-      }),
+    files.map(async ({ path, text }) => {
+      const ledgerRel = skillLedgerPath(folder, path)
+      const ledgerPath = join(root, ledgerRel)
+      const mismatches = existsSync(ledgerPath)
+        ? compareLedger(
+            ledgerGroups(text, path === 'SKILL.md'),
+            countLedgerRows(await Bun.file(ledgerPath).text()),
+          )
+        : undefined
+      return { rel: join(skillRel, path), ledgerRel, mismatches }
+    }),
   )
 }
 
+/**
+ * Directives per H2, `null` for any above the first. A contents list repeats
+ * the headings rather than stating a rule, so `## Contents` takes no rows. A
+ * nested bullet elaborates its parent, so only a top-level line counts. A body
+ * stops at its first closer, and a ledger table under one then reads as rows
+ * with no bullets rather than passing unread.
+ */
+function ledgerGroups(text: string, isBody: boolean): HeadingCount[] {
+  const counts = new Map<string | null, number>()
+  let heading: string | null = null
+
+  for (const line of bodyLines(text)) {
+    if (line.fenced) continue
+    const section = SECTION.exec(line.text)?.[1]
+    if (section !== undefined) {
+      if (isBody && BODY_CLOSERS.includes(section)) break
+      heading = section
+      continue
+    }
+    if (heading === CONTENTS_SECTION || !LEDGERED_LINE.test(line.text)) continue
+    counts.set(heading, (counts.get(heading) ?? 0) + 1)
+  }
+
+  return [...counts].map(([key, count]) => ({ heading: key, count }))
+}
+
 /**
  * A key carrying an empty value declares nothing, so blank reads as absent
  * rather than as a name that disagrees with every folder.
@@ -603,6 +682,10 @@ function practiceFindings(source: SkillSource): SkillFinding[] {
     ...sections,
     ...ledgerFindings(source),
     ...source.referenceLedgers.flatMap(referenceLedgerFindings),
+    ...source.staleExemptions.map((rel) => ({
+      rel,
+      detail: 'missing file: exempt from a ledger',
+    })),
   ]
 }
 

package/src/cli/retired.ts

@@ -9,6 +9,8 @@ export interface RetiredVerb {
 const DESIGN_MOVED =
   'the design values now live in the stylesheet your canon/DESIGN.md lead names'
 
+const CONTEXT_MOVED = '`canon context audit`, which reports placement findings'
+
 /**
  * Every verb a release dropped, with the release and where the work went. The
  * router reads this ahead of the parser, and `canon migrate status` reads it to
@@ -41,6 +43,12 @@ export const RETIRED_VERBS: readonly RetiredVerb[] = [
     release: '5.53.0',
     movedTo: 'a tool built for composed video',
   },
+  { path: ['context', 'classify'], release: '5.64.0', movedTo: CONTEXT_MOVED },
+  {
+    path: ['context', 'classifier'],
+    release: '5.64.0',
+    movedTo: CONTEXT_MOVED,
+  },
 ]
 
 /**

package/src/commands/claude.ts

@@ -168,6 +168,15 @@ interface RoutingOptions {
 const SEEDED_FILES: readonly string[] = ['REQUIREMENTS.md', 'DESIGN.md']
 const SEEDED_DIRS: readonly string[] = ['tasks']
 
+/**
+ * Where a `SEEDED_FILES` entry resolves for the sync presence check, at either
+ * surface root, so a target holding its records under `canon/` is not sent to
+ * `canon claude init`.
+ */
+export function seededFilePath(resolved: string, name: string): string {
+  return surfaceDir(resolved, name)
+}
+
 /**
  * Where a `SEEDED_DIRS` entry resolves for the sync presence check.
  *
@@ -679,7 +688,7 @@ async function runSync(target: string): Promise<number> {
   // already holds.
   logStep('Seeded')
   for (const name of SEEDED_FILES) {
-    if (existsSync(join(resolved, '.claude', name))) logInfo(name)
+    if (existsSync(seededFilePath(resolved, name))) logInfo(name)
     else logWarn(`${name} missing. Run \`canon claude init\``)
   }
   for (const name of SEEDED_DIRS) {
@@ -1771,7 +1780,7 @@ function reportPracticeShape(report: SkillsAudit): void {
     `A listed practice skill closes with ${PRACTICE_SECTIONS.map((section) => `## ${section}`).join(', ')}, and every skill on the wider ledger list carries ${PRACTICE_LEDGER}.`,
   )
   logInfo(
-    `A skill on the per-bullet list, ${plural(BULLET_LEDGER_SKILLS.length, 'skill')} here, also matches each other reference to a ledger under ${SKILL_LEDGERS}, one row per bullet under each H2.`,
+    `A skill on the per-bullet list, ${plural(Object.keys(BULLET_LEDGER_SKILLS).length, 'skill')} here, also matches each reference it does not exempt, and a listed body, to a ledger under ${SKILL_LEDGERS}, one row per bullet under each H2.`,
   )
   logInfo(
     `Both lists are kept here and name ${plural(PRACTICE_SKILLS.length, 'practice skill')} and ${plural(LEDGER_SKILLS.length, 'ledger skill')}, so a skill outside ${SHIPPED_CORPUS} is never read.`,