@erclx/canon 4.120.0 → 4.122.0

package/claude/skills/write-human/REQUIREMENT.md

@@ -7,7 +7,7 @@ description: Scope boundary between the writing rules a scan enforces and the on
 
 ## Gap
 
-Without this skill, a session is graded on the words it avoids and never on how the prose reads. The banned words, characters, and spellings ship as data the CLI and the installed hook both read, so that half is measured on every run. The voice half sat under a heading in a standard nothing opened, so a session wrote the whole passage without it and the audit reported a clean exit over prose that read machine-written.
+Without this skill, a session is graded on the words it avoids and never on how the prose reads. The banned characters ship as data the CLI and the installed hook both read, so that half is measured on every run. The voice half sat under a heading in a standard nothing opened, so a session wrote the whole passage without it and the audit reported a clean exit over prose that read machine-written.
 
 The output of that arrangement is specific rather than general. Paragraphs come back with every sentence landing within a few words of the last, with consecutive sentences opening on the same word and the same grammatical shape, and with the compression rule applied until the verb is gone, so the passage trades uniform sentences for uniform fragments. A session told to be terse and told nothing about cadence produces exactly that, since cutting is the only instruction it holds.
 
@@ -21,13 +21,15 @@ Importing that catalog wholesale fails on a different measurement. External mate
 - State cadence as something to measure, giving the sentence-length spread and the repeated-opening count a session can check, since a rule to vary sentence length is one a session satisfies by assertion
 - Ban the fragment trade by name, since compression is the instruction a terse register already carries and the verb is what it drops first
 - Name the machine tells a scan cannot reach, and hold the catalog behind a stated trigger so a run that needs none pays no read for it
-- Point at the banned words rather than restating them, since they ship as package data a command reads and a second copy drifts with nothing comparing the two
+- Carry the marketing words and vague qualifiers as word-choice guidance, since no command reads them and a word ban catches the token and misses the habit behind it
+- Point at the banned characters rather than restating them, since they ship as package data a command reads and a second copy drifts with nothing comparing the two
 - Record which external patterns were adopted, which were declined, and the measurement behind each, so a later session extends the position instead of re-deriving it
 - Yield voice to a surface that states its own, and hold rhythm, density, and the tells on every surface
 
 ## Must not
 
-- Restate the banned words, characters, or spellings, at any length or as an example set
+- Restate the banned characters, at any length or as an example set
+- Present the word guidance as a gate, or restate it on a second surface, since this body is its one copy
 - Claim the reported failure is closed. Cadence is a property of a passage and nothing measures the output against these rules yet, so this skill states the rule and the measurement is owed separately.
 - Rewrite a term the corpus already uses because an external source bans it, without the count and a recorded position
 - Grow a second voice register inside this body. One baseline covers every surface, and a register a real surface needs arrives as an overlay that yields on voice alone.
@@ -39,7 +41,8 @@ Importing that catalog wholesale fails on a different measurement. External mate
 
 ## Out of scope
 
-- The banned words, characters, and spellings, which `markdown.md` states for a reader and `canon markdown audit` gates from package data
+- The banned characters, which `markdown.md` states for a reader and `canon markdown audit` gates from package data
+- Spelling, which a project's spell checker enforces
 - Markdown mechanics, being headings, lists, code spans, punctuation, and file references
 - Restating text that already exists in plainer words, which `restate-plainly` owns on a different trigger, since a restatement is asked for by name and this arrives on a glob match. The rules here still govern how that restatement reads, and that body cites this one rather than carrying a copy.
 - What voice a given surface declares, which belongs to the standard governing that surface

package/claude/skills/write-human/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: write-human
-description: Carries the voice, rhythm, sentence construction, and information density rules a banned-word list cannot express, plus the catalog of machine tells that survive a clean ban scan. Use when writing or revising prose a person will read, when a passage reads flat or uniform, or when asked to "make this read like a person", "fix the cadence", "this reads like AI wrote it", "vary the sentences", or "tighten this without gutting it". Do NOT use for banned words, characters, or spellings, which `markdown.md` states and `canon markdown audit` gates, and do NOT use to restate text that already exists in plainer words, which is `restate-plainly`, whose body loads these rules from here.
+description: Carries the voice, word choice, rhythm, sentence construction, and information density rules a banned-character scan cannot express, plus the catalog of machine tells that survive a clean ban scan. Use when writing or revising prose a person will read, when a passage reads flat or uniform, or when asked to "make this read like a person", "fix the cadence", "this reads like AI wrote it", "vary the sentences", or "tighten this without gutting it". Do NOT use for banned characters, which `markdown.md` states and `canon markdown audit` gates, and do NOT use to restate text that already exists in plainer words, which is `restate-plainly`, whose body loads these rules from here.
 ---
 
 # Write human
@@ -9,7 +9,7 @@ Write prose that reads as though a person wrote it. A ban list subtracts words a
 
 Load this before drafting a passage rather than after. A revision pass recovers the words and never recovers the structure the draft already settled.
 
-The banned words, characters, and spellings sit in `${CLAUDE_SKILL_DIR}/../../standards/markdown.md`. They stay in force here. This skill adds to them and never restates them, since `canon markdown audit` reads them from the package and a second copy would drift.
+The banned characters sit in `${CLAUDE_SKILL_DIR}/../../standards/markdown.md`. They stay in force here. This skill adds to them and never restates them, since `canon markdown audit` reads them from the package and a second copy would drift. The word guidance under `## Voice` is the one copy of that list, and no command reads it.
 
 ## What yields and what does not
 
@@ -23,6 +23,8 @@ The banned words, characters, and spellings sit in `${CLAUDE_SKILL_DIR}/../../st
 - Use active voice, and present tense unless past or future is factually correct.
 - Name the actor in a sentence that has one. Passive voice with an unnamed actor hides who acts and reads as evasion.
 - Prefer direct verbs and plain words. Write `use` over `utilize`, `help` over `facilitate`, `is` over `serves as`.
+- Drop marketing words: `seamless`, `robust`, `powerful`, `revolutionary`, `enhanced`, `allows`, and `leverage`. Each claims a quality without showing it, so state what the thing does and let the reader judge it.
+- Drop vague qualifiers: `simply`, `just`, `easily`, `quickly`, `very`, and `really`. Cut the word where the sentence stands without it, and give the measurement where the degree matters.
 - Be direct on an established fact. Hedge on a genuinely uncertain claim and say which it is.
 - Assume developer-level knowledge. Skip the explanation the reader already carries.
 - Front-load the key information in a paragraph, and give every sentence something the reader did not have.

package/claude/skills/write-human/references/machine-tells.md

@@ -5,7 +5,7 @@ description: Patterns that survive a clean ban scan, why each is invisible to a
 
 # Machine tells
 
-Each pattern below is a shape rather than a token, so no closed word set matches it and `canon markdown audit` reports a clean exit over a passage carrying every one. Read this when revising text a model drafted, or when a passage passes the scan and still reads wrong.
+Each pattern below is a shape rather than a token, so no closed word set matches it and the character scan `canon markdown audit` runs reports a clean exit over a passage carrying every one. Read this when revising text a model drafted, or when a passage passes the scan and still reads wrong.
 
 Work top down. The first three account for most of what a reader calls machine-written.
 

package/claude/skills/write-human/references/source-material.md

@@ -21,10 +21,13 @@ The ambiguity rules travel with that layer for the same reason. Compression is w
 
 - **The ban on abstract metaphor nouns.** The nouns it names are load-bearing terms in this corpus rather than decoration, and the count below is what decides it.
 - **Document mode as a selector.** The source has the writer pick a mode before drafting. In this corpus a document's shape is already fixed by the standard governing its type, so a mode selector adds a second authority over one question and the two will disagree.
-- **Any restatement of a banned word set.** The bans ship as package data that `canon markdown audit` reads, and a copy here would be a second source for one list with a machine reading the other.
 - **A voice register per surface.** One baseline covers every surface. A surface needing a warmer register states its own voice and claims the yield, which lifts voice alone and leaves the bans, the rhythm rules, and the tells in force.
 
-The first of those four rests on a count. The source names `surface` among the nouns it bans, and tracked markdown in the authoring repository used `surface` 593 times, `harness` 95, `scaffolding` 17, and `primitive` 4. Adopting the item either rewrites established vocabulary across the corpus or is ignored in silence, and a reader arriving later cannot tell which happened.
+The first of those three rests on a count. The source names `surface` among the nouns it bans, and tracked markdown in the authoring repository used `surface` 593 times, `harness` 95, `scaffolding` 17, and `primitive` 4. Adopting the item either rewrites established vocabulary across the corpus or is ignored in silence, and a reader arriving later cannot tell which happened.
+
+## What moved in from the markdown standard
+
+The marketing words and vague qualifiers under `## Voice` were a gated word set in the markdown standard until the audit narrowed to characters. A word ban catches the token and misses the habit behind it, so a writer swaps `robust` for a synonym and the claim stays unproven. The list now lives here as guidance a reader applies, and this body is its one copy, since no command reads it and a second copy would drift with nothing comparing the two.
 
 ## Where this diverges
 

package/docs/agents/architecture-record.md

@@ -0,0 +1,26 @@
+---
+title: Architecture record
+description: The four findings canon context audit reads off the architecture record, being the entry cap and length gates the record states for itself, the claim coverage report, and the word counts
+---
+
+# Architecture record
+
+Four findings from `canon context audit` read `canon/ARCHITECTURE.md` rather than a folder, and only the first two are facts. The other checks the audit runs are in `context-audit-checks.md`.
+
+The entry cap check counts the record's decisions against the cap it states for itself, in a clause of the form `This record holds at most 12 decisions.` Like the length check, the cap belongs to the record rather than to the toolkit, so a record stating none is measured and never gated. A decision is a `###` heading outside a fenced block, so the template a standard shows does not count, and a heading carrying two decisions counts once. The JSON record carries what it read as `architecture.entryCap`, absent where the record states no cap, and the audit catalog counts a record past it as `recordOverCount`.
+
+The length check compares the record against the ceiling it derives for itself, and only a record that states its own allowances has one. No standard sets a length rule for this document, so the numbers belong to whichever record declares them. The check reads a frame allowance and an allowance per decision out of the record's own prose and puts the ceiling at the frame plus the allowance times the decision count. The JSON record carries what it read as `architecture.allowances` and the reading as `architecture.lines` against `architecture.ceiling`.
+
+A record stating no such rule is measured and reported and never gated, which is the ordinary shape of a project that wrote an architecture record and no convention about its length. Holding a pair of numbers in the toolkit and gating every project against them would fail a record on a ceiling that project never agreed to, and the framed line would credit the rule to a file that does not state it.
+
+What the derivation costs where it does apply is that the ceiling rises when a decision is added and falls for nothing, so the check passes exactly when the file grew. It gates anyway, because a record that states a limit for itself and makes it computable from a count has turned it into a fact, which is what separates it from every judgment the audit reports. A rewrite of the declaring sentence past the clauses the check reads falls back to reporting rather than to a stale ceiling, so the failure shows up in the run's own output.
+
+The coverage report classifies each decision as carrying a countable claim, a structural invariant, or neither, then reports each testable entry against whether it names a check that exists. A countable claim carries a figure a run could recompute, and an invariant quantifies over a named tree closely enough that a walk could falsify it. A check is a `scripts/**.sh` path the entry spells that is on disk, or a `canon` invocation matching a registered audit, so coverage reads the entry rather than the tree and a claim some check happens to cover without the entry saying so reads as unchecked.
+
+Three limits are stated on every run rather than hidden. The countable signal reads digits alone, so a measured claim written in words reads as uncounted. Entries are counted by heading, and one heading holding several decisions counts once. Nothing is stored, so an entry rewritten tomorrow is classified afresh the next time the verb runs and no verdict goes stale.
+
+The report gates nothing. Deciding whether a sentence states a claim is a judgment no parser settles, so the output names candidates for a reader. This answers a different question from the verification anchors `standards/architecture.md` describes, which record that one cited number was re-read. That mechanism says whether a marked figure held, and this one says how much of the record could be checked at all.
+
+The third finding is a word count, measured in words rather than lines: one figure for the whole record and one per decision. `standards/architecture.md` asks a session to judge the file's weight by reading it rather than by counting it, and reads the word figure alongside that judgment when one is available. A paragraph written one source line to a paragraph passes the rendered-line measure other checks use while still reading heavy, which is the gap a word count closes without turning into a second cap.
+
+The `## Risks / open questions` section is weighed the same way, reported apart from the whole-record figure since the standard singles it out for holding only what is still open. This finding gates nothing under any mode. The JSON record carries the whole-record figure as `architecture.words`, the section figure as `architecture.risksWords` where the record carries the heading, and the per-decision figure as `architecture.decisions[].words`.

package/docs/agents/audits.md

@@ -36,7 +36,7 @@ Each is invoked as the CLI the caller is running rather than as a global `canon`
 
 ## What gates and what reports
 
-Five findings fail the run: an unresolved context citation, a banned character, word, or spelling, a relative link resolving to nothing on disk, a skill folder carrying no `REQUIREMENT.md`, and a credential-shaped value in the tree the package ships. Each is a fact with no false-positive class behind it.
+Five findings fail the run: an unresolved context citation, a banned character, a relative link resolving to nothing on disk, a skill folder carrying no `REQUIREMENT.md`, and a credential-shaped value in the tree the package ships. Each is a fact with no false-positive class behind it.
 
 Four of the five are the ones `canon gate run` already fails a push on. The secret scan is the one entry gating without a stage behind it, added on that same fact-or-judgment test rather than as a side effect of registering a measure, and the toolkit already ranks content leaving the repository above content that stays.
 

package/docs/agents/commands.md

@@ -1,6 +1,6 @@
 ---
 title: Command catalog
-description: Every project-level command and every domain subcommand, plus the shape each domain exposes
+description: Every top-level command with its purpose, each domain's subcommands and the page describing them, the browser commands, and the version skew report
 ---
 
 # Command catalog
@@ -9,107 +9,51 @@ Full help: `canon <command> --help`. Bare `canon --help` lists every top-level c
 
 ## Project-level
 
-| Command                          | Purpose                                                                                                                                                                                                                                                                                                                      |
-| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `canon init [path]`              | Bootstrap a project with selected toolkit domains                                                                                                                                                                                                                                                                            |
-| `canon sync [path]`              | Sync all installed domains in a target project                                                                                                                                                                                                                                                                               |
-| `canon sync --check`             | Report toolkit drift and the installed version against the newest published (`--json`, `--exit-code`)                                                                                                                                                                                                                        |
-| `canon sandbox [cat:cmd]`        | Run sandbox scenarios (interactive or routed), toolkit-only like the tree it reads                                                                                                                                                                                                                                           |
-| `canon sandbox reset`            | Reset sandbox to baseline                                                                                                                                                                                                                                                                                                    |
-| `canon sandbox clean`            | Wipe the sandbox                                                                                                                                                                                                                                                                                                             |
-| `canon sandbox check`            | Score a provisioned sandbox against a scenario expectation (`--json` for the verdict)                                                                                                                                                                                                                                        |
-| `canon sandbox coverage`         | Report which scenarios declare expectations (`--json`, `--strict`, `--skills`)                                                                                                                                                                                                                                               |
-| `canon indexes regen`            | Regenerate `index.md` files from sibling frontmatter                                                                                                                                                                                                                                                                         |
-| `canon indexes list [path]`      | Flatten every folder index under a path into one `{path, title, description}` catalog (`--json`)                                                                                                                                                                                                                             |
-| `canon docs [topic]`             | Emit toolkit reference docs (`list`, or a topic by name)                                                                                                                                                                                                                                                                     |
-| `canon design render`            | Render `canon/DESIGN.md` tokens to HTML and CSS, declaring each vendored face the typography table names with `--embed-fonts`                                                                                                                                                                                                |
-| `canon design regen`             | Rewrite this repository's `canon/DESIGN.md` from `src/design/tokens.ts` and `src/design/base.css` from `src/design/neutral.ts`                                                                                                                                                                                               |
-| `canon design board`             | Generate a static page set indexing tokens, surfaces, wireframes, past candidates, components, and references against a caller-resolved `--root` (`--out`), defaulting to the main worktree                                                                                                                                  |
-| `canon design css`               | Emit the design tokens and components as CSS on stdout (`--no-components` for properties alone)                                                                                                                                                                                                                              |
-| `canon design install`           | Install the neutral base stylesheet into a project at `.claude/design/base.css`                                                                                                                                                                                                                                              |
-| `canon design sync`              | Update a base stylesheet already installed under `.claude/design/`                                                                                                                                                                                                                                                           |
-| `canon slides render`            | Render a `.claude/SLIDES.md` source into a PowerPoint deck, reporting any unrecognized layout name on stderr                                                                                                                                                                                                                 |
-| `canon slides list`              | List the available slide layouts (`--json` for the catalog)                                                                                                                                                                                                                                                                  |
-| `canon feedback`                 | Write toolkit feedback from stdin to `.canon/feedback/`, or open a GitHub issue with `--github`, refusing either when a required field is absent                                                                                                                                                                             |
-| `canon transcripts <url>`        | Fetch a YouTube transcript with metadata frontmatter (needs `yt-dlp`)                                                                                                                                                                                                                                                        |
-| `canon tasks archive`            | Move a shipped task and its plan off the board, clear its ordering row, and regenerate the index                                                                                                                                                                                                                             |
-| `canon tasks decline`            | Move a decided-against task and its plan into `.canon/tasks/declined/`, recording who decided and why (`--reason`, `--by`, `--json`)                                                                                                                                                                                         |
-| `canon tasks pull-request`       | Record a pull request number on the task a branch closes, by stem or `--plan` (`--json`)                                                                                                                                                                                                                                     |
-| `canon tasks plan-link`          | Write or correct a task's `Plan:` line to point at a plan, by stem and plan path or slug (`--json`)                                                                                                                                                                                                                          |
-| `canon tasks outcome`            | Mark outcomes `[x]` on a task by position, repeating `--close` (`--json`)                                                                                                                                                                                                                                                    |
-| `canon tasks validate`           | Report board rows whose shape, order, plan, task file, group, file set, or blocker does not hold (`--json`)                                                                                                                                                                                                                  |
-| `canon tasks next-label`         | Report the next unused phase label across the board and its archive (`--json`)                                                                                                                                                                                                                                               |
-| `canon intake list`              | Report intake folder counts, or one folder's items, keeping what is unread with `--unread` (`--json`)                                                                                                                                                                                                                        |
-| `canon intake answer`            | Write selections into one cluster's answer slots, repeating `--set <item>=<answer>` (`--json`)                                                                                                                                                                                                                               |
-| `canon teach list`               | Report learning workspaces and the ordinal a new one takes, or what one workspace holds and what its records schedule (`--json`)                                                                                                                                                                                             |
-| `canon teach open`               | Open a workspace at the next ordinal with its mission, resources, and glossary files (`--json`)                                                                                                                                                                                                                              |
-| `canon teach resource`           | Record sources and leads in a workspace, repeating `--read` or `--lead` as `<title>=<url>` (`--json`)                                                                                                                                                                                                                        |
-| `canon teach glossary`           | Add terms to a workspace glossary alphabetically, repeating `--term <term>=<definition>` (`--json`)                                                                                                                                                                                                                          |
-| `canon teach lesson`             | Resolve the numbered path, shared stylesheet, mission success lines, and one quiz option order per question for the next lesson, writing nothing (`--json`)                                                                                                                                                                  |
-| `canon teach stylesheet`         | Seed a workspace stylesheet from the design source, leaving an existing one alone without `--force` (`--json`)                                                                                                                                                                                                               |
-| `canon teach nav`                | Rewrite the teach-root listing, a workspace's contents page, each lesson's chrome from its four marker regions, and each reference page's rendered HTML sibling (`--json`)                                                                                                                                                   |
-| `canon teach render`             | Render a JSON block list (heading, paragraph with `cites`, list, refs, raw) from stdin to HTML through the shared components, refusing `bad-input` by block index (`--json`)                                                                                                                                                 |
-| `canon records validate`         | Report a session record or a standard against the standard governing it, per kind (`--json`)                                                                                                                                                                                                                                 |
-| `canon records migrate`          | Rewrite the records a validate finding names a recoverable transform for (`--write`, `--json`)                                                                                                                                                                                                                               |
-| `canon records ordinal`          | Report or claim the next ordinal `intake` and `groundwork` share, creating the folder atomically (`--claim`, `--json`)                                                                                                                                                                                                       |
-| `canon records size`             | Report what each record folder holds and how much of it is recent, heaviest first (`--json`)                                                                                                                                                                                                                                 |
-| `canon records prune-tmp`        | Report scratch nobody has touched inside an age window and delete it (`--write`, `--older-than`, `--json`)                                                                                                                                                                                                                   |
-| `canon records push`             | Commit every record folder less the exclusion set and push it to a private records remote, refusing an oversized or credential-bearing file (`--json`)                                                                                                                                                                       |
-| `canon records pull`             | Fetch the records remote and write it back, refusing rather than discarding unpushed records (`--json`)                                                                                                                                                                                                                      |
-| `canon migrate rename`           | Rewrite every unprotected `aitk` token to `canon` and move the paths that carry the name, reporting the plan without `--write` (`--scope`, `--json`)                                                                                                                                                                         |
-| `canon migrate skill-names`      | Move the prefixed skill folders onto their two-word names and rewrite every citation, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                                                                              |
-| `canon migrate records`          | Move the gitignored session records to `.canon/` and repoint every tracked citation, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                                                                               |
-| `canon migrate surface-roots`    | Move the tracked surfaces (`context/`, `decisions/`, `wireframes/`, the three loose documents, and the install stamp folder) from `.claude/` to `canon/` with `git mv` and repoint every tracked citation, reporting the plan without `--write` (`--root`, `--json`)                                                         |
-| `canon migrate record-tree`      | Repoint the old-root citations inside the records themselves, scoped to the live folders and reporting every line without `--write` (`--root`, `--json`)                                                                                                                                                                     |
-| `canon migrate rule-layout`      | Move a target's installed rules from the flat `.claude/rules/<subdir>/` layout to `.claude/rules/canon/<subdir>/`, reporting the plan without `--write` (`--root`, `--json`)                                                                                                                                                 |
-| `canon migrate scratch-evidence` | Move a folder under `.tmp/` that a durable record cites as evidence to a numbered `.canon/evidence/<nn>-<folder>/`, repointing every citation live or archived, reporting the plan without `--write` (`--root`, `--json`)                                                                                                    |
-| `canon migrate record-layout`    | Fold review receipts and the retired-entry archive under the memory pen, and move everything under `.canon/review/` that is not a review out to its own folder, repointing each citation that reaches into a moved folder or names a moved file, live or archived, reporting the plan without `--write` (`--root`, `--json`) |
-| `canon sessions list`            | Resolve live sessions to the worktree and branch each holds, filtered by `--branch` (`--json`)                                                                                                                                                                                                                               |
-| `canon sessions export`          | Pack a session transcript, its side folder, and a manifest into one local gzip bundle, never uploading it (`--out`, `--json`)                                                                                                                                                                                                |
-| `canon sessions import`          | Place an exported session under the local project folder so `claude --resume` finds it, refusing to overwrite (`--root`, `--json`)                                                                                                                                                                                           |
-| `canon worktrees list`           | Report which worktrees are reclaimable, keyed on the pull request having merged, with every refusal and the removal route named (`--json`)                                                                                                                                                                                   |
-| `canon worktrees reclaim`        | Remove every reclaimable worktree and the branch behind it, reporting without acting under `--dry-run` (`--json`)                                                                                                                                                                                                            |
-| `canon comments scan`            | Measure comment density by language and comment kind, with a trend recomputed from git                                                                                                                                                                                                                                       |
-| `canon context audit`            | Report required sections, length, cited paths, reference form, catalog tables, provenance, index drift, the architecture record against its own ceiling and entry cap and its word weight, and wireframe states against their evidence folders                                                                               |
-| `canon context classify diff`    | Classify the chunks a git range changed, each with its enclosing section, as keep, replace, history, or move (`--base`, `--doc-types`, `--json`)                                                                                                                                                                             |
-| `canon context classify sweep`   | Classify every section of the five canonical doc types, split at H3, as keep, rewrite, or move (`--doc-types`, `--json`)                                                                                                                                                                                                     |
-| `canon context classifier show`  | Report the resolved classifier backend and model and which source decided them (`--json`)                                                                                                                                                                                                                                    |
-| `canon context classifier set`   | Write the project classifier setting to `canon/config/classifier.toml` (`--backend`, `--model`, `--json`)                                                                                                                                                                                                                    |
-| `canon markdown audit`           | Fail any markdown path on a banned character, word, or spelling, or a dead relative link, and report the structural checkpoints                                                                                                                                                                                              |
-| `canon claude skills audit`      | Report both skill corpora against the mechanical rules in `standards/skill.md`                                                                                                                                                                                                                                               |
-| `canon standards audit`          | Report the corpus against the success-criterion gate `standards/standard.md` states, failing only on a standard new to the branch (`--json`, `--arrivals-only`)                                                                                                                                                              |
-| `canon claude skills drift`      | Name the shipped skill bodies rewritten between a given ref and `HEAD`, and the installed version against the newest published (`--json`)                                                                                                                                                                                    |
-| `canon claude skills reach`      | Report the bodies in either skill corpus citing a toolkit path no target project receives, exiting 2 on an unqualified one                                                                                                                                                                                                   |
-| `canon claude skills rank`       | Score either skill corpus's descriptions against a case corpus by TF-IDF cosine similarity, reporting rank-one and top-three (`--cases <path>`)                                                                                                                                                                              |
-| `canon claude routing`           | Report per `CLAUDE.md` section how many bullets name a path and how many of those a path-scoped rule already covers (`--json`)                                                                                                                                                                                               |
-| `canon claude plugin-update`     | Match the installed marketplace plugin against `claude/.claude-plugin/plugin.json`'s own name and run `claude plugin update` on it, reading the version back off `claude plugin list --json` since the update call reports none of its own (`--json`)                                                                        |
-| `canon gov test-order`           | Report where an implementation reached history ahead of the test covering it (`--json`)                                                                                                                                                                                                                                      |
-| `canon gov superseded`           | Report where the tree still asserts a value a changed convention no longer produces, keyed on the value and on the family stem behind a templated citation (`--json`)                                                                                                                                                        |
-| `canon gov restated`             | Report every instruction the always-loaded file or a rule shares with the seed, a shipped skill body, or another rule, classed and with its anchors named (`--json`)                                                                                                                                                         |
-| `canon gov citations`            | Resolve every path a rule cites and every internal frontmatter glob, failing on one reaching nothing (`--json`)                                                                                                                                                                                                              |
-| `canon secrets scan`             | Report credential-shaped values in the tree the package ships, keyed on issued values rather than on words (`--json`)                                                                                                                                                                                                        |
-| `canon deps audit`               | Report published advisories against the resolved dependency set, refusing rather than reporting clean when the index is unreachable (`--json`)                                                                                                                                                                               |
-| `canon labels audit`             | Report the labels a changed set earns from the pull request label map and the paths no row reaches (`--json`)                                                                                                                                                                                                                |
-| `canon labels scan`              | Fail a pull request or a posted review whose title, body, or review comment carries a phase label, a label a code span quotes, a gitignored record path, a session link, a title word no dictionary holds, or a title breaking `standards/pr.md`'s format, casing, or length rule (`--event`, `--body-file`, `--json`)       |
-| `canon autoship classify`        | Decide whether a changed set needs the review pass, naming the file and the test that decided it (`--json`)                                                                                                                                                                                                                  |
-| `canon pr key-changes`           | Compare the files a pull request body's Key Changes names against its own diff, in both directions (`--body`, `--base`, `--json`)                                                                                                                                                                                            |
-| `canon pr head`                  | Compare the head a pull request object reports against the branch tip the remote carries, naming both shas (`--root`, `--json`)                                                                                                                                                                                              |
-| `canon pr checks`                | Report the check runs belonging to the branch tip, reading pending for a tip carrying none rather than clean, and `conflicted` when the branch conflicts with its base (`--root`, `--json`)                                                                                                                                  |
-| `canon pr review-state`          | Report the commit and instant the last review pass covered, off the pass's own marker rather than the fields GitHub stamps at submission (`--root`, `--json`)                                                                                                                                                                |
-| `canon pr evidence`              | Render a before-and-after comment comparing changed `evidence/` images against the merge base, editing its own prior comment in place rather than posting a second (`--root`, `--json`, `--preview`, `--checklist`, `--local`)                                                                                               |
-| `canon pr preview`               | Dispatch the Pages deploy on a pull request's branch and report the preview address the run prints, refusing a deploy that passes no `--branch` (`--root`, `--json`, `--timeout`)                                                                                                                                            |
-| `canon pr local`                 | Report the `localhost` address of the dev server this worktree is running, never one in another worktree, or replace that line on the evidence comment with a note on `--remove` (`--root`, `--json`, `--remove`, `--note`)                                                                                                  |
-| `canon repo metadata propose`    | Compare a description, homepage, and topic set computed from the README and `package.json` against what the remote carries, writing nothing (`--root`, `--json`)                                                                                                                                                             |
-| `canon repo metadata apply`      | Write an explicitly supplied description, homepage, or topic set to the remote through `gh repo edit` (`--description`, `--homepage`, `--topics`, `--root`, `--json`)                                                                                                                                                        |
-| `canon census [path]`            | Report tracked file count, a breakdown by extension, and a line total that skips whatever reads as binary (`--json`)                                                                                                                                                                                                         |
-| `canon audits run`               | Run every audit as one set, report per check under one verdict, and compare each count to the recorded baseline (`--json`, `--record`, `--corpus`)                                                                                                                                                                           |
-| `canon audits list`              | List every audit the set runs, with the corpus each reads and whether it gates (`--json`)                                                                                                                                                                                                                                    |
-| `canon gate run`                 | Run every stage that guards a branch here, scoping shell, types, and tests to the changed set (`--all`, `--no-write`, `--nested`, `--json`)                                                                                                                                                                                  |
-| `canon inventory [subject]`      | Walk every route a project declares and group its elements by the property each computes, as a listing rather than a gate (`--json`)                                                                                                                                                                                         |
-| `canon drive <url> <run>`        | Walk a page through named interactions and measure each state it reaches, reporting findings rather than gating (`--json`)                                                                                                                                                                                                   |
-| `canon capture [source]`         | Render an HTML source or an `http(s)://` URL to PNG and prove the font each one declares resolved (`--selector` required, `--out`, `--width`)                                                                                                                                                                                |
-| `canon serve [dir]`              | Serve a directory on the loopback interface and print the link that opens it, running until interrupted (`--port`, `--entry`, `--index`, `--json`)                                                                                                                                                                           |
-| `canon upgrade`                  | Reinstall the CLI globally with the package manager the install path names (`--json`)                                                                                                                                                                                                                                        |
+One row per top-level command, in the order `canon --help` prints them. A domain's subcommands are in `## Domain commands` below.
+
+| Command                     | Purpose                                                                         |
+| --------------------------- | ------------------------------------------------------------------------------- |
+| `canon init [path]`         | Bootstrap a project with selected toolkit domains                               |
+| `canon sync [path]`         | Sync every installed domain, or report drift and version skew with `--check`    |
+| `canon upgrade`             | Reinstall the CLI globally with the package manager the install path names      |
+| `canon migrate <verb>`      | Move a project off a retired name or layout, reporting the plan until `--write` |
+| `canon targets <verb>`      | Report the projects this toolkit installed into                                 |
+| `canon gov <verb>`          | Install and sync governance rules, and audit the tree against them              |
+| `canon standards <verb>`    | List, audit, or print a standard by name                                        |
+| `canon snippets <verb>`     | List or scaffold prompt snippets                                                |
+| `canon tooling <verb>`      | Sync, diff, and verify tooling stacks                                           |
+| `canon claude <verb>`       | Install the Claude workflow and audit both skill corpora                        |
+| `canon wiki <verb>`         | Scaffold the wiki pages                                                         |
+| `canon indexes <verb>`      | Regenerate `index.md` files from sibling frontmatter, or flatten them           |
+| `canon docs [topic]`        | Emit toolkit reference docs (`list`, or a topic by name)                        |
+| `canon design <verb>`       | Render `canon/DESIGN.md` tokens, build the board, install the base stylesheet   |
+| `canon slides <verb>`       | Render a `.claude/SLIDES.md` deck, or list its layouts                          |
+| `canon capture [source]`    | Render HTML or a URL to PNG and prove each declared font resolved               |
+| `canon serve [dir]`         | Serve a directory on loopback and print the link that opens it                  |
+| `canon demo <verb>`         | Compile and record a running app                                                |
+| `canon inventory [subject]` | Group every route's elements by one computed property, never gating             |
+| `canon drive <url> <run>`   | Walk a page through named interactions and measure each state                   |
+| `canon transcripts <url>`   | Fetch a YouTube transcript with metadata frontmatter (needs `yt-dlp`)           |
+| `canon teach <verb>`        | Open and author learning workspaces                                             |
+| `canon sandbox [cat:cmd]`   | Run sandbox scenarios, toolkit-only like the tree it reads                      |
+| `canon tasks <verb>`        | Read and write the task board, the plans it cites, and its archive              |
+| `canon intake <verb>`       | Report intake folders and write answers into them                               |
+| `canon records <verb>`      | Validate, size, prune, and back up the session records                          |
+| `canon sessions <verb>`     | Resolve live sessions to worktree and branch, and move one between machines     |
+| `canon worktrees <verb>`    | Report and remove worktrees whose pull request merged                           |
+| `canon autoship <verb>`     | Decide whether a changed set needs the review pass                              |
+| `canon pr <verb>`           | Read a pull request's diff, head, checks, and review, and post its evidence     |
+| `canon feedback`            | Write toolkit feedback from stdin, or open an issue with `--github`             |
+| `canon audits <verb>`       | Run every audit as one set under one verdict against the recorded baseline      |
+| `canon gate <verb>`         | Run every stage that guards a branch here                                       |
+| `canon secrets <verb>`      | Report credential-shaped values in the tree the package ships                   |
+| `canon deps <verb>`         | Report published advisories against the resolved dependency set                 |
+| `canon labels <verb>`       | Read a changed set against the label map, and scan pull request text            |
+| `canon comments <verb>`     | Measure comment density by language and kind, with a trend from git             |
+| `canon context <verb>`      | Report context folder health, and classify changed or stale sections            |
+| `canon markdown <verb>`     | Fail markdown on a banned character or a dead link, and report its structure    |
+| `canon repo <verb>`         | Propose and apply the remote's description, homepage, and topics                |
+| `canon census [path]`       | Report tracked file count, extensions, and a line total skipping binaries       |
 
 `canon serve` drives no browser, which is what separates it from the four that do. All four ship now that `capture` does, so the line between them is the engine rather than the package. A generated page loses its script to an editor preview and to a `file://` open, so the link is the delivery rather than a convenience, and every generated surface here reaches a reader through one. A teach lesson's stylesheet is embedded rather than linked, so only its script still needs a server. It binds `127.0.0.1` and never a wildcard, because what it is pointed at is routinely a gitignored record tree. It sends `cache-control: no-store`, since a preview exists to be edited and reloaded and a cached stylesheet reads as a fix that did not work.
 
@@ -135,34 +79,40 @@ query = "button, a[href], input, select, textarea, [tabindex]"
 
 ## Domain commands
 
-Each domain exposes a consistent shape where applicable: `list`, `install`, `sync`, `create`.
-
-| Domain      | Subcommands                                                                                                                           |
-| ----------- | ------------------------------------------------------------------------------------------------------------------------------------- |
-| `tooling`   | `list`, `sync`, `ref`, `create`, `verify`, `inject`, `prune-gitignore`                                                                |
-| `snippets`  | `list`, `create`                                                                                                                      |
-| `standards` | `list`, `audit`, `<name>`                                                                                                             |
-| `gov`       | `list`, `install`, `sync`, `build`, `regen`, `test-order`, `superseded`, `citations`                                                  |
-| `claude`    | `init`, `sync`, `routing`, `seeds list`, `skills list`, `skills audit`, `skills drift`, `skills reach`, `skills rank`, `setup [dest]` |
-| `demo`      | `compile`, `run`                                                                                                                      |
-| `inventory` | `run`                                                                                                                                 |
-| `wiki`      | `init`                                                                                                                                |
-| `design`    | `regen`, `css`, `render`, `install`, `sync`                                                                                           |
-| `slides`    | `render`, `list`                                                                                                                      |
-| `tasks`     | `archive`, `validate`                                                                                                                 |
-| `intake`    | `list`, `answer`                                                                                                                      |
-| `teach`     | `list`, `open`, `resource`, `glossary`, `lesson`, `stylesheet`, `nav`, `render`                                                       |
-| `comments`  | `scan`                                                                                                                                |
-| `context`   | `audit`, `classify diff`, `classify sweep`, `classifier show`, `classifier set`                                                       |
-| `markdown`  | `audit`                                                                                                                               |
-| `secrets`   | `scan`                                                                                                                                |
-| `deps`      | `audit`                                                                                                                               |
-| `labels`    | `audit`                                                                                                                               |
-| `migrate`   | `rename`, `skill-names`, `records`                                                                                                    |
-| `autoship`  | `classify`                                                                                                                            |
-| `pr`        | `key-changes`, `head`, `checks`                                                                                                       |
-| `audits`    | `run`, `list`                                                                                                                         |
-| `gate`      | `run`                                                                                                                                 |
+Each domain exposes a consistent shape where applicable: `list`, `install`, `sync`, `create`. The page named beside a domain carries its flags, records, and refusals, and `canon <domain> --help` lists the flags of any subcommand.
+
+- `migrate`, in `migrate.md`: `rename`, `skill-names`, `records`, `surface-roots`, `record-tree`, `rule-layout`, `scratch-evidence`, `record-layout`
+- `targets`, in `targets.md`: `list`, `pulls`
+- `gov`, in `install-and-sync.md`: `list`, `install`, `sync`, `build`, `regen`, `test-order`, `counts`, `superseded`, `citations`, `restated`
+- `standards`, in `standards-audit.md`: `list`, `audit`, `<name>`
+- `snippets`, in `install-and-sync.md`: `list`, `create`
+- `tooling`, in `install-and-sync.md`: `list`, `sync`, `diff`, `reference`, `create`, `verify`, `inject`, `prune-gitignore`
+- `claude`, in `skills-audit.md`: `init`, `sync`, `setup`, `routing`, `plugin-update`, `seeds list`, `skills list`, `skills audit`, `skills drift`, `skills reach`, `skills rank`
+- `wiki`, in `scripting.md`: `init`
+- `indexes`, in `indexes.md`: `regen`, `list`
+- `docs`, in `docs.md`: `list`, `<topic>`
+- `design`, in `design-board.md`: `render`, `regen`, `board`, `css`, `install`, `sync`
+- `slides`, described below: `render`, `list`
+- `demo`, in `demo.md`: `compile`, `run`, `frames`
+- `inventory`, described above: `run`
+- `teach`, in `teach.md`: `list`, `open`, `resource`, `glossary`, `lesson`, `stylesheet`, `nav`, `render`
+- `sandbox`, in `sandbox.md`: `reset`, `clean`, `check`, `coverage`
+- `tasks`, in `tasks.md`: `next-label`, `archive`, `decline`, `plan-citations`, `plan-answers`, `plan-branch`, `plan-reach`, `plan-link`, `pull-request`, `outcome`, `list`, `validate`
+- `intake`, in `intake.md`: `list`, `answer`
+- `records`, in `records.md`: `validate`, `migrate`, `ordinal`, `size`, `stale`, `prune-tmp`, `push`, `pull`
+- `sessions`, in `sessions.md`: `list`, `export`, `import`
+- `worktrees`, in `worktrees.md`: `list`, `reclaim`
+- `autoship`, in `review-classification.md`: `classify`
+- `pr`, in `pr-reads.md`: `key-changes`, `head`, `checks`, `review-state`, `evidence`, `preview`, `local`
+- `audits`, in `audits.md`: `run`, `list`
+- `gate`, in `gate.md`: `run`
+- `secrets`, in `state-scoped-risk.md`: `scan`
+- `deps`, in `state-scoped-risk.md`: `audit`
+- `labels`, in `label-coverage.md`: `audit`, `scan`
+- `comments`, in `comments.md`: `scan`
+- `context`, in `context-audit.md`: `audit`, `classify diff`, `classify sweep`, `classifier show`, `classifier set`
+- `markdown`, in `markdown-audit.md`: `audit`
+- `repo`, described below: `metadata propose`, `metadata apply`
 
 Common patterns:
 
@@ -171,31 +121,14 @@ Common patterns:
 - `sync <path>` → reapply all installed entries in a target project.
 - `create [name]` → scaffold a new authoring entry in this repo.
 
-`migrate rename` moves a project off the retired `aitk` name. It reports until `--write` is passed, and `--scope target` rewrites the toolkit-owned folders alone, reporting every other citation as one the project owns rather than editing prose somebody wrote. A project installing `canon` fresh never needs it.
+Subcommands no other page describes:
 
-`migrate skill-names` moves the plugin skills that carried a `claude-` prefix onto their two-word names and rewrites every citation of one. It shares its engine with `migrate rename` and differs in what it is scanning for: a skill name is a whole name rather than a word stem, so it matches only where the word ends, which is what keeps a longer word that merely opens with a skill name, such as `claude-worktrees`, out of it. It takes no `--scope`, since the skill folders it moves are authored in the toolkit and no target holds a copy of that catalog, which leaves a target's own citations of a renamed skill as the whole of what it rewrites there. The changelog and the eval transcripts are passed over on the argument the other sweep already carries, that each records what shipped or what a session ran under whatever name was current then.
-
-`migrate records` moves a project's session records from `.claude/` to `.canon/` and rewrites every tracked file that cites one. It reports until `--write` is passed, and refuses outright when the project does not already ignore `.canon/`, since every folder it relocates is ignored where it stands and landing one under a tracked root commits the memory pen. Take the ignore entry with `canon tooling sync --write` first.
-
-A record folder already present at the destination is a refusal rather than a merge, and a line carrying `canon-keep-record-root`, or the nearest non-blank line below it, keeps the old spelling for prose that dates a decision. The records themselves are never swept: everything under `.canon/` and every `.claude/` record folder is passed over and reported as a count on its own line, which is what keeps the run that follows the ignore collapse touching the same files as one before it. Running it twice rewrites nothing, which is the check that the exclusions, the markers, and that skip all fired.
-
-`migrate surface-roots` moves the tracked surfaces from `.claude/` to `canon/`: `context/`, `decisions/`, `wireframes/`, `ARCHITECTURE.md`, `REQUIREMENTS.md`, `DESIGN.md`, and the install stamp folder, respelled `canon/config/` since a project under `canon/` reserves the bare `canon` name for the CLI's own install. Every path is tracked, so each file moves with `git mv` and its history follows it, and every tracked citation of one is rewritten in the same run. `rules/`, `skills/`, `hooks/`, and `settings.json` stay where Claude Code reads them. It reports until `--write` is passed, and a destination already present under `canon/` refuses the whole plan rather than splitting a surface across both roots.
-
-A line carrying `canon-keep-surface-root`, or the nearest non-blank line above it, keeps the old spelling. A rule's frontmatter `paths:` glob, a citation shaped like a path into another repository, and one inside a dated paragraph are reported by file and line and left alone. Running it twice rewrites nothing, which is the idempotence check. A project that never runs it keeps resolving each surface under `.claude/`, since every reader takes whichever root holds the entry.
-
-`migrate record-tree` is what reaches the records the sweep above passes over, and the two share no scope. That one enumerates through git, so it sees every tracked file and none of the records, which are gitignored by construction. This one walks `.canon/` itself and is scoped to the folders a session still follows a path into: `diagrams`, `memory`, `plans`, `proposals`, `review`, `tasks`, and `teach`, each minus its own `archive/` subtree. A closed groundwork or intake trail, the scratch folder, and the backup history are reported as counts and never rewritten, because a path inside a closed trail sits in a sentence about work that already ended. Run it after the move, since there is no new root to walk before one.
-
-Every citation in scope is reported with its file, its line number, and the line text. The record tree is untracked, so a wrong rewrite has no git undo, and that report is what a reader judges before passing `--write`. Marking a line that has to keep the old spelling uses the same `canon-keep-record-root` comment, and a second run rewriting nothing is the idempotence check.
-
-`migrate rule-layout` moves a target still on the flat installed-rule layout onto the `canon/`-wrapped one. It classifies each flat file against the target's own recorded stamp: an unchanged hash is clean, a changed one is edited, and a name neither the stamp nor the current rule catalog can vouch for is unclaimed and left in place. Clean and edited files both relocate with their content untouched, since moving a rule is a different decision from re-syncing it. The one renumbered rule reads its destination from a table rather than from its own current name, so it never lands as a second copy under the retired number.
-
-`migrate scratch-evidence` moves a folder out of `.tmp/` for good rather than repointing a citation in place. A promoted folder is one a durable record, live or archived, cites as its evidence, and no source file under `claude/`, `scripts/`, `src/`, `governance/`, or `standards/` names by path, which is what a script still writing into it fails. It walks every `canon records push` folder rather than the live ones alone, since most of what it repoints sits in `tasks/archive/`, `plans/archive/`, and `groundwork/`. A destination already occupied is a refusal, and a second run rewriting nothing is the same idempotence check `migrate record-tree` uses.
-
-A destination that already holds the same bytes marks the flat file a duplicate, which `--write` deletes rather than moves. One holding different bytes is a real collision: neither file is touched, it is reported by name, and every other planned move still applies independently. Run this before `canon gov install` or `canon gov sync` against a target still on the flat layout, since neither bootstrap verb detects or clears it on its own.
-
-`migrate record-layout` folds two record folders under the memory pen: review receipts move from `.canon/review/memory/` to `.canon/memory/review/`, and retired entries move from `.canon/tmp/memory-archive/` to `.canon/memory/archive/`, backed for the first time since `memory/` is a folder `canon records push` carries and `tmp/` is not. Each move is refused independently when its destination already exists, and the citation repoint sweeps every folder `canon records push` carries, archives included, since an archived receipt still cites the row it retired. The same `canon-keep-record-root` marker and second-run idempotence check apply. A receipt sitting at the flat `review/` root, from before `.canon/review/memory/` existed, matches neither mapped move and is reported by name rather than moved.
-
-The same verb leaves `.canon/review/` holding only reviews. Feedback moves to `.canon/feedback/`, and the design, board, slides, and diagram renders move to `.canon/tmp/render/<kind>/`, off the records remote since the commands regenerate them. Reference images move to `.canon/picks/references/`. A branch report flattens from `review/branch/review-<slug>.md` to `review/branch-<slug>.md`, and a flat `review/ui-checklist-<slug>.md` moves into `.canon/tmp/handoff/ui-checklist/`. Each folder under `review/evidence/` is decided from what it holds: one directly carrying an `arm-<id>` capture or a `design-handoff.md` is a pick and moves to `.canon/picks/<slug>/`, and any other is evidence and moves to `.canon/evidence/<nn>-<slug>/`. Evidence folders are numbered by the oldest file each holds, continuing past any ordinal `evidence/` already carries. The dry run labels each derived destination `(pick)` or `(evidence)`, so a misfiled folder shows before `--write`, and one filed wrong moves back by hand. A bare mention of an emptied folder, such as `review/evidence/` with no slug or `review/branch/` with no report name, matches no row and stays as written.
+- `claude plugin-update` matches the installed marketplace plugin against `claude/.claude-plugin/plugin.json`'s own name and runs `claude plugin update` on it, reading the version back off `claude plugin list --json`, since the update call reports none of its own (`--json`).
+- `claude skills rank` scores either skill corpus's descriptions against a case corpus by TF-IDF cosine similarity, reporting rank-one and top-three (`--cases <path>`).
+- `design regen` rewrites this repository's `canon/DESIGN.md` from `src/design/tokens.ts` and `src/design/base.css` from `src/design/neutral.ts`. `design css` emits the tokens and components as CSS on stdout, with `--no-components` for properties alone, and `design render` declares each vendored face the typography table names under `--embed-fonts`.
+- `slides render` renders a `.claude/SLIDES.md` source into a PowerPoint deck and reports any unrecognized layout name on stderr, and `slides list --json` emits the layout catalog.
+- `labels scan` fails a pull request or a posted review whose title, body, or review comment carries a phase label, a label a code span quotes, a gitignored record path, a session link, a title word no dictionary holds, or a title breaking `standards/pr.md`'s format, casing, or length rule (`--event`, `--body-file`, `--json`).
+- `repo metadata propose` compares a description, homepage, and topic set computed from the README and `package.json` against what the remote carries, writing nothing, and `repo metadata apply` writes an explicitly supplied set through `gh repo edit` (`--description`, `--homepage`, `--topics`).
 
 ## Version skew
 

package/docs/agents/context-audit-checks.md

@@ -1,6 +1,6 @@
 ---
 title: Context audit checks
-description: What each non-gating check reports, the unit each checkpoint is measured in, the architecture record's length and entry cap gates and claim coverage, which folders each check reaches, and what moved to the attribute tier
+description: What each non-gating check reports, the unit each checkpoint is measured in, where the architecture record's findings are described, which folders each check reaches, and what moved to the attribute tier
 ---
 
 # Context audit checks
@@ -65,25 +65,7 @@ Fenced blocks are excluded, which keeps a pinned version in an install command f
 
 ## The architecture record
 
-Four findings read `canon/ARCHITECTURE.md` rather than a folder, and only the first two are facts.
-
-The entry cap check counts the record's decisions against the cap it states for itself, in a clause of the form `This record holds at most 12 decisions.` Like the length check, the cap belongs to the record rather than to the toolkit, so a record stating none is measured and never gated. A decision is a `###` heading outside a fenced block, so the template a standard shows does not count, and a heading carrying two decisions counts once. The JSON record carries what it read as `architecture.entryCap`, absent where the record states no cap, and the audit catalog counts a record past it as `recordOverCount`.
-
-The length check compares the record against the ceiling it derives for itself, and only a record that states its own allowances has one. No standard sets a length rule for this document, so the numbers belong to whichever record declares them. The check reads a frame allowance and an allowance per decision out of the record's own prose and puts the ceiling at the frame plus the allowance times the decision count. The JSON record carries what it read as `architecture.allowances` and the reading as `architecture.lines` against `architecture.ceiling`.
-
-A record stating no such rule is measured and reported and never gated, which is the ordinary shape of a project that wrote an architecture record and no convention about its length. Holding a pair of numbers in the toolkit and gating every project against them would fail a record on a ceiling that project never agreed to, and the framed line would credit the rule to a file that does not state it.
-
-What the derivation costs where it does apply is that the ceiling rises when a decision is added and falls for nothing, so the check passes exactly when the file grew. It gates anyway, because a record that states a limit for itself and makes it computable from a count has turned it into a fact, which is what separates it from every judgment below. A rewrite of the declaring sentence past the clauses the check reads falls back to reporting rather than to a stale ceiling, so the failure shows up in the run's own output.
-
-The coverage report classifies each decision as carrying a countable claim, a structural invariant, or neither, then reports each testable entry against whether it names a check that exists. A countable claim carries a figure a run could recompute, and an invariant quantifies over a named tree closely enough that a walk could falsify it. A check is a `scripts/**.sh` path the entry spells that is on disk, or a `canon` invocation matching a registered audit, so coverage reads the entry rather than the tree and a claim some check happens to cover without the entry saying so reads as unchecked.
-
-Three limits are stated on every run rather than hidden. The countable signal reads digits alone, so a measured claim written in words reads as uncounted. Entries are counted by heading, and one heading holding several decisions counts once. Nothing is stored, so an entry rewritten tomorrow is classified afresh the next time the verb runs and no verdict goes stale.
-
-The report gates nothing. Deciding whether a sentence states a claim is a judgment no parser settles, so the output names candidates for a reader. This answers a different question from the verification anchors `standards/architecture.md` describes, which record that one cited number was re-read. That mechanism says whether a marked figure held, and this one says how much of the record could be checked at all.
-
-The third finding is a word count, measured in words rather than lines: one figure for the whole record and one per decision. `standards/architecture.md` asks a session to judge the file's weight by reading it rather than by counting it, and reads the word figure alongside that judgment when one is available. A paragraph written one source line to a paragraph passes the rendered-line measure other checks use while still reading heavy, which is the gap a word count closes without turning into a second cap.
-
-The `## Risks / open questions` section is weighed the same way, reported apart from the whole-record figure since the standard singles it out for holding only what is still open. This finding gates nothing under any mode. The JSON record carries the whole-record figure as `architecture.words`, the section figure as `architecture.risksWords` where the record carries the heading, and the per-decision figure as `architecture.decisions[].words`.
+Four findings read `canon/ARCHITECTURE.md` rather than a folder: an entry cap and a length ceiling, each gating only where the record states it for itself, a claim coverage report, and a word count. What each reads and why the last two gate nothing are in `architecture-record.md`.
 
 ## Wireframe states
 

package/docs/agents/context-audit.md

@@ -5,7 +5,7 @@ description: Running the audit, its flags and folder scope, the exit codes, the
 
 # Context audit
 
-`canon context audit [path]` reports the structural state of the folders following the index-plus-entry contract, meaning a generated `index.md` beside entries carrying frontmatter, and it measures `canon/ARCHITECTURE.md` beside them. It reads and reports. Fixing what it finds is separate work. What each finding means is in `context-audit-checks.md`.
+`canon context audit [path]` reports the structural state of the folders following the index-plus-entry contract, meaning a generated `index.md` beside entries carrying frontmatter, and it measures `canon/ARCHITECTURE.md` beside them. It reads and reports. Fixing what it finds is separate work. What each finding means is in `context-audit-checks.md`, and what the architecture record's four findings mean is in `architecture-record.md`.
 
 Findings stated over every markdown file rather than over a context entry are measured by `canon markdown audit`, described in `markdown-audit.md`. That command resolves no folder, so it reaches trees this one refuses.
 

package/docs/agents/context-classify.md

@@ -5,7 +5,7 @@ description: Classifying canonical-doc content as keep, replace/rewrite, history
 
 # Doc classifier
 
-`canon context classify` reads content from the five canonical doc types (`context/<domain>.md`, `ARCHITECTURE.md`, `wireframes/<surface>.md`, `DESIGN.md`, `REQUIREMENTS.md`) and reports whether each piece states the project as it stands or should be rewritten, narrated elsewhere, or moved to another surface. It reports and never gates: a finding is a judgment for a writer to act on, not a fact a push fails over. The `docs-fold` skill calls this verb in diff mode over its own diff baseline. Wiring it into the merge gate or `canon context audit` is separate work this verb does not do.
+`canon context classify` reads content from the five canonical doc types (`context/<domain>.md`, `ARCHITECTURE.md`, `wireframes/<surface>.md`, `DESIGN.md`, `REQUIREMENTS.md`) and reports whether each piece states the project as it stands or should be rewritten, narrated elsewhere, or moved to another surface. It reports and never gates: a finding is a judgment for a writer to act on, not a fact a push fails over. The `context-fold` skill calls this verb in diff mode over its own diff baseline. Wiring it into the merge gate or `canon context audit` is separate work this verb does not do.
 
 Two modes read different units. Diff mode reads the chunks a git range changed, each with the section it landed in, which is what a session checks right after an edit. Sweep mode reads every section of the five doc types, split at H3, which is what a cleanup pass or a periodic re-scan runs over a whole corpus.