@erclx/canon 4.114.0 → 4.115.0

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "canon",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "4.114.0",
+  "version": "4.115.0",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/document-health/references/axes.md

@@ -40,7 +40,7 @@ Weight is a judgment a reader settles rather than a defect, which the verb state
 
 **Evidence class:** `measured` for the audit's findings, `classified` for the sweep's verdicts.
 
-The audit answers required sections, entry length, citation resolution, reference form, catalog tables, provenance, and index drift. A citation resolving to nothing is a fact and gates. Entry length, reference form, table shape, and provenance are judgments under every flag.
+The audit answers required sections, entry length, citation resolution, reference form, catalog tables, provenance, and index drift. Required sections reach wireframes as well as context entries, naming each wireframe short of the regions, states, copy, or exclusions section its standard requires, which is how a surface on an older wireframe shape reports rather than reading as clean. A citation resolving to nothing is a fact and gates. Entry length, reference form, table shape, and provenance are judgments under every flag.
 
 The sweep classifies each section as keep, replace or rewrite, history, or move. A `move` verdict is the placement finding proper, naming content sitting in the wrong document. Each verdict carries its own confidence, which is why the class is `classified` rather than `measured`, and a low-confidence `move` is a prompt to look rather than an instruction to cut.
 

package/claude/skills/target-setup/SKILL.md

@@ -92,7 +92,7 @@ Step 2: `canon tooling sync <tooling-stack> --write` installs stack deps, script
 CANON_NON_INTERACTIVE=1 canon tooling sync <tooling-stack> <target> --write
 ```
 
-Monorepo with multiple language roots: run `canon init` once at the repo root so `base` (husky, prettier, cspell, commitlint, CI) lands single, then sync each subtree with `--skip base` so the shared layer is not re-dropped.
+Monorepo with multiple language roots: run `canon init` once at the repo root so `base` (husky, prettier, cspell, commitlint, CI) lands single, then sync each subtree with `--skip base` so the shared layer is not re-dropped. Take the subtree commands from the per-root rows the preview printed rather than picking folders by hand. Detection found each root and its stack, and the two commands below show the shape.
 
 ```bash
 CANON_NON_INTERACTIVE=1 canon tooling sync vite-react ./frontend --skip base --write

package/claude/skills/target-setup/references/detect.md

@@ -27,19 +27,53 @@ since the chain reaches the tooling resolution a moment later.
 
 ## Detect
 
-Read these from the project root in parallel, skipping any that do not exist:
+A monorepo keeps its languages in subfolders, so read the markers from every
+folder to depth two rather than from the root alone. Collect the language roots
+first:
+
+```bash
+git ls-files --cached --others --exclude-standard \
+  | grep -E '(^|/)(package\.json|pyproject\.toml|go\.mod|composer\.json|Cargo\.toml)$' \
+  | awk -F/ 'NF <= 3'
+```
+
+Every folder holding a marker is a language root, and the repository root is
+one when it holds a marker itself. Going through git keeps ignored trees such as
+`node_modules/`, `vendor/`, and `.venv/` off the list, since each carries
+markers of its own. Outside a git repository, fall back to
+`find . -maxdepth 3 \( -path '*/.*' -o -name node_modules -o -name vendor \) -prune -o -type f -print`
+filtered to the same five names.
+
+Depth two reaches a service folder at depth one and a workspace package under
+`packages/<name>/` at depth two. Deeper, the walk starts finding fixtures and
+examples as false roots.
+
+Then read these per language root in parallel, skipping any that do not exist:
 
 - `package.json`: `dependencies` and `devDependencies`
-- Root configs: `astro.config.*`, `next.config.*`, `vite.config.*`, `tailwind.config.*`, `tsconfig.json`, `pyproject.toml`, `go.mod`, `composer.json`, `Cargo.toml`
+- The root's own configs: `astro.config.*`, `next.config.*`, `vite.config.*`, `tailwind.config.*`, `tsconfig.json`, `pyproject.toml`, `go.mod`, `composer.json`, `Cargo.toml`
+
+A non-JavaScript marker outranks a `package.json` in the same folder. A Go or
+Composer service often carries a `package.json` only to host scripts, so that
+folder is a Go or PHP root rather than a JavaScript one.
+
+Read these once, from the repository root:
+
 - `canon/REQUIREMENTS.md` and `canon/ARCHITECTURE.md` if present
 - Directory structure via `ls -1` of the project root and `src/` if present
 
 ## Resolve arguments
 
-- **Stack:** pick the closest governance stack by matching detected runtime or framework against stack names in the catalog. If nothing matches, fall back to `base` and carry the fallback into the preview.
-- **Tooling stack:** pick the closest tooling stack from `canon tooling list --json` (e.g. `vite-react`, `astro`, `nextjs`). Distinct from the governance stack. Fall back to `base` if no framework match, and carry that fallback into the preview too.
-- **Next.js:** map `next` in `package.json` dependencies, or a root `next.config.ts`/`.js`/`.mjs` file, to the `nextjs` governance stack and the `nextjs` tooling stack. The dependency name does not match either stack name by itself.
-- **Extras:** identify technologies not already covered by the picked stack. For each, find a rule whose `description` or `paths` points at that technology and pass it via `--add`. Dedupe against the stack's own rules. Do not add a rule the stack already pulls in.
+Governance installs once, at the repository root, and a rule's `paths:` globs
+already reach every subfolder. Tooling installs per folder. So resolve one
+governance stack for the whole repository and one tooling stack per language
+root.
+
+- **Stack:** pick the closest governance stack by matching the repository root's detected runtime or framework against stack names in the catalog. If the root matched nothing, `base` is the stack, including when subfolders matched, since no subfolder owns the repository and picking one by order would state a preference nobody gave. Mark it `fallback` in the preview only when no root matched anywhere.
+- **Tooling stack:** for each language root, pick the closest tooling stack from `canon tooling list --json` (e.g. `vite-react`, `astro`, `nextjs`). Distinct from the governance stack. Fall back to `base` for a root with no framework or language match, and carry that fallback into its preview row.
+- **Next.js:** map `next` in a root's `package.json` dependencies, or a `next.config.ts`/`.js`/`.mjs` file in that root, to the `nextjs` governance stack and the `nextjs` tooling stack. The dependency name does not match either stack name by itself.
+- **Extras:** identify technologies not already covered by the picked governance stack, across every language root. A subfolder that matched a governance stack of its own contributes that stack's rules, read from `canon gov list --json`, and every root contributes its language rule. For each technology, find a rule whose `description` or `paths` points at it and pass it via `--add`. Dedupe against the picked stack's own rules. Do not add a rule the stack already pulls in.
+- **Subfolder tooling:** a language root below the repository root takes its own `canon tooling sync <stack> <path> --skip base`, since `canon init` already lands `base` once at the root. Leave a root whose stack resolves to `base` out of the commands, since that sync would land nothing. A repository-root `package.json` hosting only formatters and hooks is that case, and it adds no row.
 - **Skip (`--skip`):** `wiki` installs by default. Add `--skip wiki` only when the user explicitly wants it left out.
 
 ## Gap handling
@@ -67,10 +101,10 @@ toolkit repository, and option 2 hands the project-local file to `create-rule`.
 
 Before executing, output:
 
-- **Detected:** each technology with its evidence file
+- **Detected:** each technology with its evidence file, path included, so a subfolder marker reads as one
 - **Stack:** picked governance stack and resolved rule count. Mark it `fallback` when no detected runtime or framework matched a catalog name.
-- **Tooling stack:** picked tooling stack. Mark it `fallback` on the same test, and name what `base` lands: configs, seeds, and gitignore entries in every case, plus the JavaScript development dependencies, scripts, and hook activation wherever a `package.json` exists to carry them. A project outside that ecosystem runs none of the second group and keeps the first. Omit this line entirely on the `gov` phase, which syncs no tooling.
-- **Extras:** each `--add` rule with a one-line reason
+- **Tooling stack:** one row per language root, each carrying its path, its picked tooling stack, a `fallback` mark on the same test, and its own command. On the repository root's row, name what `base` lands: configs, seeds, and gitignore entries in every case, plus the JavaScript development dependencies, scripts, and hook activation wherever a `package.json` exists to carry them. A project outside that ecosystem runs none of the second group and keeps the first. Omit these rows entirely on the `gov` phase, which syncs no tooling.
+- **Extras:** each `--add` rule with a one-line reason, listed in full. A second matched stack reaches the install only through this list, since `canon init --stack` takes one stack, so a shortened list reads as that stack dropped.
 - **Skip:** any `--skip` entries with reason
 - **Target:** resolved target path
 - **Commands:** the full chain that will run

package/claude/skills/teach-workspace/SKILL.md

@@ -86,7 +86,7 @@ Reading the last record alone is what the schedule replaces. A topic missed thre
 Two outputs with two lifetimes, and the split decides the format.
 
 - A lesson is a self-contained page carrying its own quiz, a teach-back block, and the feedback for each question. It embeds one shared stylesheet rather than restating styles, and it is disposable and never promoted.
-- A reference page goes to `reference/<slug>.md`, written for a reader with no learner in it. This is the half that survives the workspace, so it is written in markdown to pass the authoring gates a promotion would put it through.
+- A reference page goes to `reference/<slug>.md`, written for a reader with no learner in it. This is the half that survives the workspace, so it is written in markdown to pass the authoring gates a promotion would put it through. `canon teach nav` renders it to a `reference/<slug>.html` sibling, and a lesson links that sibling, since a served `.md` opens as plain text.
 
 Resolve the lesson before writing it, rather than composing its name or its quiz order by hand:
 
@@ -167,12 +167,14 @@ Follow `${CLAUDE_SKILL_DIR}/references/lesson-craft.md` for what makes a lesson
 
 ### Hand over a link, never a path
 
-A lesson is a page carrying a script, and an editor preview cannot run it, so a path alone opens markup with no working quiz. Serve the teach root and give the learner a link they can click:
+A lesson is a page carrying a script, and an editor preview cannot run it, so a path alone opens markup with no working quiz. Serve the teach root and give the learner a link they can click. Take the serve line from the `Open` step of `canon teach list <topic>`, which resolves the teach folder against the directory the session runs in:
 
 ```bash
-canon serve .canon/teach --entry <nn>-<topic>/index.html --json
+canon teach list <topic>
 ```
 
+Run the line it prints with `--json` appended, rather than writing `canon serve .canon/teach` by hand. `canon serve` resolves its folder against the cwd, so that literal serves an absent folder from a linked worktree, where the list verb reads the main worktree root.
+
 Start it in the background so the session keeps going, and read `url` off the record rather than composing one. The verb walks past a port already in use, so the port it took is exactly the half a guessed URL gets wrong. Report the refusal and its `reason` when `ok` is false, and report it rather than proceeding silently when the verb does not resolve at all, which is an installed CLI predating it.
 
 Do this on every run that opens or resumes a workspace, including one that writes no lesson, since the learner's route into what is already there is the same link.

package/docs/agents/audits.md

@@ -24,11 +24,13 @@ canon audits list --json
 
 ## What it runs
 
-Nineteen verbs, listed by `canon audits list`. Each runs once in its fullest form, and the aggregate reads that verb's own record rather than imposing a shared envelope on it. Every one of those records already has consumers naming its keys, so a common shape would be a breaking change bought for tidiness.
+Twenty-one verbs, listed by `canon audits list`. Each runs once in its fullest form, and the aggregate reads that verb's own record rather than imposing a shared envelope on it. Every one of those records already has consumers naming its keys, so a common shape would be a breaking change bought for tidiness.
 
 The verbs walk separate trees and share no state, so they run together. Measured on the authoring machine at twelve verbs, a run finished in 0.8 seconds of wall clock against 4.4 seconds of processor, which is under every other stage in `bun run check`. `canon deps audit` is the one that changes that reading, since it reaches a network rather than a tree and its latency is the index's rather than this machine's: three clean runs measured 44.7, 77.6, and 62.9 seconds, and a stalled lookup runs to an explicit 120-second timeout rather than to bun's own 299-second ceiling. `--corpus` is what keeps a caller from paying that cost when it wants only the corpora on this disk.
 
-Sixteen of the nineteen read a tree on this disk, the one added by `restated.md` and the one added by `census.md` among them, since the first reads four such trees against each other and the second counts every file in one. The two added by `state-scoped-risk.md` read committed state rather than an arriving change, which is the gap every review surface here leaves by construction, and the one added by `label-coverage.md` reads a branch range against a map the project declares.
+Eighteen of the twenty-one read a tree on this disk, the one added by `restated.md` and the one added by `census.md` among them, since the first reads four such trees against each other and the second counts every file in one. The two added by `state-scoped-risk.md` read committed state rather than an arriving change, which is the gap every review surface here leaves by construction, and the one added by `label-coverage.md` reads a branch range against a map the project declares.
+
+The placement entry runs `canon context classify sweep` pinned to `--backend off`, so it reads the regex layer alone whatever classifier setting the project resolves. A count that moves with whichever model a machine runs is not comparable across clones, and the model layer turned a sub-second read into one measured at about 17 minutes over this repository's context and wireframe sections on the authoring machine. It retains one tally per verdict, `keep`, `rewrite`, and `move`, and gates on nothing, since each verdict is a judgment. `document-health` is the surface that reads the same sections with the model.
 
 Each is invoked as the CLI the caller is running rather than as a global `canon`. A globally installed binary resolves to the main checkout no matter which worktree is executing, so the aggregate would measure a tree the branch never touched and report a pass over it.
 

package/docs/agents/commands.md

@@ -47,7 +47,7 @@ Full help: `canon <command> --help`. Bare `canon --help` lists every top-level c
 | `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, and each lesson's chrome from its four marker regions (`--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, list, 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`)                                                                                                                                                                                                                               |

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

@@ -9,11 +9,11 @@ What each finding from `canon context audit` means. The command surface, its fla
 
 ## Required sections
 
-The required-section check reports what does not declare `## Overview` and `## Layout`, the two sections `standards/context.md` marks required. The list is held in code beside the numeric checkpoints rather than parsed out of the standard, so it fails on a defect rather than on a rewrite of the wording around it. A heading at any level counts, because a domain that split into a folder carries its overview in a sibling named `overview.md` where the section is the `#` title and an `##` beneath it would repeat the filename. Matching exactly is what keeps `## Layout catalog` from satisfying `Layout`.
+The required-section check reports what does not declare the sections its folder's standard requires. A context entry owes `## Overview` and `## Layout`, the two sections `standards/context.md` marks required. A wireframe owes `## Regions`, `## States`, `## Copy`, and `## Not on this surface`, the sections answering the four questions `standards/wireframes.md` tests a surface against. `## Behavior` is expected of a wireframe rather than required, since a static surface has no interaction to state. The lists are held in code beside the numeric checkpoints rather than parsed out of the standard, so it fails on a defect rather than on a rewrite of the wording around it. A heading at any level counts, because a domain that split into a folder carries its overview in a sibling named `overview.md` where the section is the `#` title and an `##` beneath it would repeat the filename. Matching exactly is what keeps `## Layout catalog` from satisfying `Layout`.
 
-Which unit answers depends on the folder. Entries of the folder named under `.claude/` are one domain each, so each answers for itself and a finding names the entry. Entries of a folder a domain split into describe that one domain between them, so any sibling answers and a finding names the folder. Holding a split folder to the rule per file would report every child beside its `overview.md`, and rolling the named folder up would let one conforming entry stand in for every other domain sitting next to it.
+Which unit answers depends on the folder. Entries of the folder named under `.claude/` are one domain each, so each answers for itself and a finding names the entry. Entries of a folder a domain split into describe that one domain between them, so any sibling answers and a finding names the folder. Holding a split folder to the rule per file would report every child beside its `overview.md`, and rolling the named folder up would let one conforming entry stand in for every other domain sitting next to it. A wireframe answers for itself in every folder, nested or not, since its standard keeps one surface per file and a subfolder of wireframes groups surfaces rather than splitting one.
 
-It reports rather than gates by default, the closer call because a missing section reads more like a fact than the other judgments. What settles it is that the standard sanctions omitting `## Layout` from a domain owning no paths in the repo, and no measure separates that from an entry that forgot it. A domain covering only external tools is that case, and it reports on every run. The JSON record carries the findings as `missingSections` and the list as `checkpoints.requiredSections`.
+It reports rather than gates by default, the closer call because a missing section reads more like a fact than the other judgments. What settles it is that the standard sanctions omitting `## Layout` from a domain owning no paths in the repo, and no measure separates that from an entry that forgot it. A domain covering only external tools is that case, and it reports on every run. The JSON record carries the findings as `missingSections`, the lists per folder name as `checkpoints.requiredSectionsByFolder`, and the context list alone as `checkpoints.requiredSections`, the flat key it carried before wireframes owed a section.
 
 `--gate` promotes the finding to a failing exit code, which the seed stage runs and no other caller does. That mode needs an answer to the sanctioned omission above, so a file declaring `stub: true` in its frontmatter is dropped before the check and reported nowhere. Both are described in `context-audit.md`.
 
@@ -127,11 +127,11 @@ All three wireframe findings are printed under a bare run. The states-mismatch f
 
 ## Which folders each check reaches
 
-The provenance, required-section, and narration checks cover `canon/context/` alone, the reference-form check covers the split folders inside it, length and the table finding reach every audited folder, and the wireframe states check covers `canon/wireframes/` alone.
+The provenance and narration checks cover `canon/context/` alone, the reference-form check covers the split folders inside it, the required-section check covers `canon/context/` and `canon/wireframes/`, length and the table finding reach every audited folder, and the wireframe states check covers `canon/wireframes/` alone.
 
-What narrows the three is stated in `standards/context.md`, which opens its scope by handing diagrams and wireframes to `diagrams.md` and `wireframes.md`, and the sibling standards do not restate it. A marker reported in a diagram entry would cite a rule that entry's own standard routes elsewhere, and a diagram entry carries a heading per kind rather than a run of bullets deciding anything. The split is between kinds of rule rather than kinds of folder, and what decides it is which tier states the rule rather than what the check measures.
+What narrows the first two is stated in `standards/context.md`, which opens its scope by handing diagrams and wireframes to `diagrams.md` and `wireframes.md`, and the sibling standards do not restate it. A marker reported in a diagram entry would cite a rule that entry's own standard routes elsewhere, and a diagram entry carries a heading per kind rather than a run of bullets deciding anything. The split is between kinds of rule rather than kinds of folder, and what decides it is which tier states the rule rather than what the check measures.
 
-Length and the table finding generalize as judgments about how far a reader travels, so both reach wherever the audit is pointed. Required sections narrow for a plainer reason: the names are the context standard's own, and neither sibling standard states a required section at all.
+Length and the table finding generalize as judgments about how far a reader travels, so both reach wherever the audit is pointed. Required sections narrow for a plainer reason: each list is one standard's own, so it reaches the folder that standard governs. The context and wireframe standards each state a set, and the diagram standard states none.
 
 The same test is what moved depth and bullet weight out of this command entirely. A rule stated at the attribute tier reaches every markdown file, and a check reaching every markdown file has no reason to require a folder that resolves.
 

package/docs/agents/context-audit.md

@@ -88,7 +88,7 @@ The pattern spells both record-root prefixes, so a citation into a folder that h
 
 ## The wireframe states gate
 
-Every entry under `canon/wireframes/` carrying a `## States` table is checked one-to-one against its evidence folders, matching the table's `State` and `Evidence` columns by header text rather than position, so a project reordering the template's own columns still resolves. An entry with no such table reports nothing, which is what leaves a project on an older wireframe shape silent until it adopts one.
+Every entry under `canon/wireframes/` carrying a `## States` table is checked one-to-one against its evidence folders, matching the table's `State` and `Evidence` columns by header text rather than position, so a project reordering the template's own columns still resolves. An entry with no such table has no rows to match, and the required-section check reports it as short of `## States` instead, so a project on an older wireframe shape is told what it lacks rather than read as clean.
 
 An evidence cell resolves as the literal path it names, taken from the project root. A state whose cited folder does not exist is a states mismatch, and so is a folder sitting under a cited evidence root that no row names. A `not captured` cell is the one exception the standard admits, and it excuses that row from both readings. A `plaintext` sketch still carried once a state's evidence exists on disk is a third finding this check adds, reading the entry as a whole rather than one row.
 

package/docs/agents/context-classify.md

@@ -96,4 +96,4 @@ Sweep mode's findings carry a `heading` field alongside `file` and use the sweep
 | `0`  | the run completed, whatever the findings say                  |
 | `1`  | refused: a bad range, an unreadable file, or a malformed flag |
 
-Findings never set a failing exit code, in either mode. Diff mode refuses on a git range it cannot resolve. Both modes refuse on a file the run could not read.
+Findings never set a failing exit code, in either mode. `canon audits run` carries sweep mode as its placement entry for the same reason, pinned to `--backend off` so the tally it retains is the regex layer's on every machine. `docs/agents/audits.md` states why. Diff mode refuses on a git range it cannot resolve. Both modes refuse on a file the run could not read.

package/docs/agents/teach.md

@@ -192,6 +192,12 @@ One detector decides both regions. A lesson carrying `<button class="opt"`, the
 
 Splicing the stepper into a lesson of either shape was measured against a browser and reverted. Its rules match a button question, which can never hold a checked radio, so a lesson given both hides every question past the first for good and outranks the class the script reveals feedback with. Nothing else caught that: the markup is valid, the splice succeeds, and the page renders.
 
+### Reference pages
+
+Each reference page is rendered to a `reference/<slug>.html` sibling carrying the same chrome, and the contents page links that sibling rather than the markdown, which `canon serve` hands over as plain text. The render drops the frontmatter, turns tables into `<table>` markup, and escapes raw HTML written in the markdown rather than passing it through. A body with no H1 gets one from the frontmatter `title`. A relative link to another reference page's markdown points at that page's `.html` sibling, and one to the workspace `GLOSSARY.md` points at the glossary on the contents page, `../index.html#gloss`. Every other link, such as `../RESOURCES.md`, stays as written. The markdown file is never touched.
+
+Every rendered page carries a `<meta name="generator" content="canon teach nav">` tag. A `.html` file under `reference/` whose markdown is gone is deleted when it carries that tag, and a hand-written HTML file there, carrying none, is left alone. The record's `reference` field counts the pages rendered. On a Bun with no `Bun.markdown`, each reference page lands in `skipped` with `Bun.markdown` as what is missing, and the rest of the run goes on.
+
 ## Opening a workspace
 
 No `canon teach` verb serves the workspace. `canon serve` does, taking the teach root as its directory and the workspace contents page as its entry:

package/docs/target-projects.md

@@ -86,13 +86,15 @@ Each diagram entry records the commit and date it was last verified against, and
 
 The default path is `base`. `canon init` on `base` installs base tooling configs, Claude seeds, and governance core rules, and scaffolds an empty `.claude/wiki/`. Most projects need nothing more.
 
-Escalate only for real web apps. The `target-setup` skill reads `package.json` and root configs, then picks the matching tooling stack (`canon tooling list --json` names the current set) and the matching governance stack (`react`, `nextjs`, `astro`, `node`). A Next.js app lands on `nextjs`, which extends `react` with the App Router rule a Vite React app does not get.
+Escalate only for real web apps. The `target-setup` skill reads `package.json` and the framework configs, then picks the matching tooling stack (`canon tooling list --json` names the current set) and the matching governance stack (`react`, `nextjs`, `astro`, `node`). A Next.js app lands on `nextjs`, which extends `react` with the App Router rule a Vite React app does not get.
+
+In a monorepo the skill reads each folder holding a `package.json`, `pyproject.toml`, `go.mod`, `composer.json`, or `Cargo.toml` to depth two, skipping what git ignores. Each of those folders gets its own tooling stack and a `canon tooling sync <stack> <folder> --skip base` in the preview. Governance still installs once at the root, since a rule's `paths:` globs reach every subfolder, so a subfolder's language rules join the root install through `--add`.
 
 `node-server` is named rather than detected. It carries the server-side security and persistence rules for a project writing request handlers or a persistence layer in TypeScript, and the detect step matches a runtime or a framework against stack names, so nothing there marks a project as a backend. Pass it deliberately with `canon init --stack node-server` or `canon gov install node-server <target>`.
 
 Markdown-heavy projects, CLI tools, docs sites, research notebooks, and scripting repos stay on `base`. Escalation is a ceiling move, not a default.
 
-A project the toolkit ships no stack for lands on `base` the same way, and the skill marks that resolution as a fallback in its preview rather than reporting it as a match. Configs, seeds, and gitignore entries land either way, and the JavaScript development dependencies, scripts, and hook activation land only where a `package.json` exists to carry them. A project outside that ecosystem declines at the preview and takes `canon:target-setup gov` for the governance layer alone, which is language-neutral. Go and PHP are the exception: they ship language and testing rules but no stack, so a project in either lands on `base` and picks those rules up through `--add`, for example `canon gov install base --add 130-go,335-testing-go .`
+A project the toolkit ships no stack for lands on `base` the same way, and the skill marks that resolution as a fallback in its preview rather than reporting it as a match. Configs, seeds, and gitignore entries land either way, and the JavaScript development dependencies, scripts, and hook activation land only where a `package.json` exists to carry them. A project outside that ecosystem declines at the preview and takes `canon:target-setup gov` for the governance layer alone, which is language-neutral. Go and PHP ship tooling stacks but no governance stack, so a project in either takes the `go` or `php` tooling stack, lands on `base` for governance, and picks up its language and testing rules through `--add`, for example `canon gov install base --add 130-go,335-testing-go .`
 
 Run `canon tooling list --json` and `canon gov list --json` to see the current catalogs. Never hardcode stack names.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "4.114.0",
+  "version": "4.115.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/audits/catalog.ts

@@ -2,6 +2,7 @@ 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 { RestatedRefusal } from '@/gov/restated'
 import type { LabelAuditRefusal } from '@/labels/audit'
@@ -199,6 +200,45 @@ function architectureCounts(
   }
 }
 
+/**
+ * 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
@@ -502,6 +542,18 @@ 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/commands/context.ts

@@ -14,6 +14,8 @@ import {
   missingSections,
   PROVENANCE_FOLDER,
   REQUIRED_SECTIONS,
+  REQUIRED_SECTIONS_BY_FOLDER,
+  requiredSections,
   type SectionFinding,
 } from '@/context/audit'
 import {
@@ -129,8 +131,9 @@ export function register(program: Command): void {
         'it holds more decisions than the cap. A record stating neither is',
         'reported and never gated. --gate widens the gate to the other two',
         'findings that are facts rather than judgments: a missing required',
-        'section and index',
-        'drift. Entry length, reference form, table, provenance, narration,',
+        'section and index drift. A context entry requires Overview and',
+        'Layout, and a wireframe requires Regions, States, Copy, and Not on',
+        'this surface. Entry length, reference form, table, provenance, narration,',
         'and the record claim classification are judgments under both.',
         '',
         'Depth and bullet weight are stated over every markdown file rather',
@@ -740,6 +743,10 @@ async function runAudit(
           renderWidth: RENDER_WIDTH,
           provenanceFolder: PROVENANCE_FOLDER,
           requiredSections: REQUIRED_SECTIONS,
+          // Keyed on the audited folder name. The flat key above stays for a
+          // caller that read it before wireframes owed a section, since turning
+          // it into this map would break that caller without an error.
+          requiredSectionsByFolder: REQUIRED_SECTIONS_BY_FOLDER,
           // Three states rather than two, so a record showing no finding says
           // which terms were looked for. The key is absent when the run never
           // scanned, which is `--citations-only`, and null when it scanned and
@@ -946,7 +953,8 @@ function reportReferenceForm(
 
 /**
  * Names the path each finding belongs to, which is an entry in the folder named
- * under `.claude/` and the folder itself in a domain split across one. States
+ * under `.claude/`, the folder itself in a domain split across one, and the
+ * file in any wireframe folder. States
  * the reach on every run for the reason the provenance report does.
  *
  * This prints ahead of the four readability measures because a missing section
@@ -959,19 +967,31 @@ function reportSections(
 ): void {
   logStep('Sections')
 
-  const governed = folders.filter(governsContent)
-  if (governed.length === 0) {
+  const names = [
+    ...new Set(
+      folders
+        .filter((folder) => requiredSections(folder).length > 0)
+        .map((folder) => folder.name),
+    ),
+  ]
+  if (names.length === 0) {
     logInfo(
-      `Out of scope. The list is stated in the standard governing canon/${PROVENANCE_FOLDER}/, and no audited folder is that one.`,
+      `Out of scope. The lists are stated in the standards governing ${Object.keys(
+        REQUIRED_SECTIONS_BY_FOLDER,
+      )
+        .map((name) => `canon/${name}/`)
+        .join(' and ')}, and no audited folder is one of them.`,
     )
     return
   }
 
+  for (const name of names) {
+    logInfo(
+      `canon/${name}/ requires ${REQUIRED_SECTIONS_BY_FOLDER[name].join(', ')}.`,
+    )
+  }
   logInfo(
-    `Covers canon/${PROVENANCE_FOLDER}/ alone, whose standard requires ${REQUIRED_SECTIONS.join(' and ')}.`,
-  )
-  logInfo(
-    'A heading at any level counts. Each entry answers for itself, except in a domain split across a folder, where a sibling answers for the rest.',
+    'A heading at any level counts. Each entry answers for itself, except in a context domain split across a folder, where a sibling answers for the rest. A wireframe answers for itself in every folder.',
   )
 
   if (missing.length === 0) {

package/src/commands/teach.ts

@@ -797,6 +797,7 @@ function reportNav(
         root: outcome.root,
         contents: outcome.contents,
         lessons: outcome.lessons,
+        reference: outcome.reference,
         skipped: outcome.skipped,
       })}\n`,
     )
@@ -810,9 +811,11 @@ function reportNav(
   for (const path of outcome.contents) logInfo(path)
   logStep('Lessons rewritten')
   logInfo(String(outcome.lessons))
+  logStep('Reference pages rendered')
+  logInfo(String(outcome.reference))
 
   if (outcome.skipped.length > 0) {
-    logStep('Refused, missing a chrome marker')
+    logStep('Refused, missing a chrome marker or the markdown renderer')
     for (const skip of outcome.skipped) {
       logWarn(`${skip.file}: no ${skip.missing}`)
     }

package/src/context/audit.ts

@@ -45,19 +45,35 @@ export const CATALOG_ROW_CHECKPOINT = 6
 const CATALOG_NAMED_RATIO = 0.6
 
 /**
- * Sections `standards/context.md` marks required, in the order it states them.
+ * Required sections per audited folder name, each in the order its standard
+ * states them.
  *
- * The list is held here rather than read out of the standard, the way the four
- * checkpoints above quote their numbers. A parser over the standard's prose
+ * The lists are held here rather than read out of the standards, the way the
+ * four checkpoints above quote their numbers. A parser over a standard's prose
  * would decide which sections are required from the wording around them, so it
  * fails on a rewrite of that wording rather than on a defect in an entry.
  *
  * These names do not generalize the way a length threshold does, which is why
- * the measure is scoped to the folder `governsContent` names. A diagram entry
- * declares a heading per kind and a wireframe entry per screen, and neither
- * sibling standard states a required section at all.
+ * each list is keyed on the folder whose standard states it. `context.md`
+ * requires an overview and a layout. `wireframes.md` asks four questions of a
+ * surface and answers each in a section, so those four are required and
+ * `## Behavior` is not, since a static surface has no interaction to state. A
+ * diagram entry declares a heading per kind and its standard requires none.
  */
-export const REQUIRED_SECTIONS: readonly string[] = ['Overview', 'Layout']
+export const REQUIRED_SECTIONS_BY_FOLDER: Readonly<
+  Record<string, readonly string[]>
+> = {
+  context: ['Overview', 'Layout'],
+  wireframes: ['Regions', 'States', 'Copy', 'Not on this surface'],
+}
+
+/**
+ * The context standard's list, kept as its own export because the audit record
+ * has published it flat under `checkpoints.requiredSections` since before any
+ * other folder required a section.
+ */
+export const REQUIRED_SECTIONS: readonly string[] =
+  REQUIRED_SECTIONS_BY_FOLDER.context
 
 const HEADING_TEXT = /^#{1,6}\s+(.+?)\s*$/
 const TABLE_ROW = /^\s*\|/
@@ -226,7 +242,7 @@ export interface EntryReport {
   readonly bareReferences: readonly BareReferenceFinding[]
   /**
    * Required sections this entry declares, in the standard's order, and empty
-   * outside the folder whose standard names them. What the folder is short of
+   * outside a folder whose standard names them. What the folder is short of
    * is `missingSections`, since one entry answers for its siblings.
    */
   readonly sections: readonly string[]
@@ -550,17 +566,20 @@ function narration(
  * Fenced blocks are skipped for the reason the scans above skip them. A
  * standard quoted inside an example declares nothing about the entry quoting it.
  */
-function declaredSections(lines: readonly BodyLine[]): string[] {
+function declaredSections(
+  lines: readonly BodyLine[],
+  required: readonly string[],
+): string[] {
   const found = new Set<string>()
 
   for (const line of lines) {
     if (line.fenced) continue
 
     const match = line.text.match(HEADING_TEXT)
-    if (match && REQUIRED_SECTIONS.includes(match[1])) found.add(match[1])
+    if (match && required.includes(match[1])) found.add(match[1])
   }
 
-  return REQUIRED_SECTIONS.filter((section) => found.has(section))
+  return required.filter((section) => found.has(section))
 }
 
 /**
@@ -611,7 +630,9 @@ function bareReferences(
  * The caller passes jurisdiction rather than deriving it from `rel`, because a
  * path prefix hardcodes what `--folder` exists to override and misses a domain
  * split into `context/<sub-area>/`. Sibling names arrive the same way and for
- * the same reason, since the folder an entry sits in is what holds them.
+ * the same reason, since the folder an entry sits in is what holds them. The
+ * required sections arrive apart from jurisdiction, since a wireframe owes
+ * sections under a standard that states no provenance rule.
  */
 export function measureEntry(
   rel: string,
@@ -619,6 +640,7 @@ export function measureEntry(
   governsContent = true,
   terms?: NarrationTerms,
   siblings: readonly string[] = [],
+  required: readonly string[] = governsContent ? REQUIRED_SECTIONS : [],
 ): EntryReport {
   const lines = bodyLines(source)
 
@@ -632,7 +654,7 @@ export function measureEntry(
     provenance: governsContent ? provenance(lines) : [],
     narration: governsContent && terms ? narration(lines, terms) : [],
     bareReferences: bareReferences(lines, siblings),
-    sections: governsContent ? declaredSections(lines) : [],
+    sections: declaredSections(lines, required),
     stub: isStubSeed(source),
     governed: governsContent,
   }
@@ -713,6 +735,7 @@ export async function measureFolders(
           governsContent(folder),
           terms,
           names.filter((name) => name !== self),
+          requiredSections(folder),
         ),
       )
     }
@@ -726,6 +749,13 @@ export function governsContent(folder: AuditedFolder): boolean {
   return folder.name === PROVENANCE_FOLDER
 }
 
+/** Names the sections the folder's standard requires, empty where it states none. */
+export function requiredSections(folder: AuditedFolder): readonly string[] {
+  return Object.hasOwn(REQUIRED_SECTIONS_BY_FOLDER, folder.name)
+    ? REQUIRED_SECTIONS_BY_FOLDER[folder.name]
+    : []
+}
+
 /**
  * Reports whether a bare sibling name here is a reference by construction.
  *
@@ -765,6 +795,11 @@ export function matchesSiblings(folder: AuditedFolder): boolean {
  * The standard sanctions omitting `## Layout` from a domain owning no paths,
  * which no measure can tell from an entry that forgot it. An entry of that
  * shape therefore reports, which is a reason this is printed and never gated on.
+ *
+ * A wireframe folder answers per file whether nested or not, since its
+ * standard keeps one surface per file. A subfolder of wireframes groups
+ * surfaces the way the named context folder groups domains, so a conforming
+ * sibling there says nothing about the surface beside it.
  */
 export function missingSections(
   root: string,
@@ -774,11 +809,12 @@ export function missingSections(
   const byRel = new Map(entries.map((entry) => [entry.rel, entry]))
   const findings: SectionFinding[] = []
 
-  const shortOf = (declared: readonly string[]): string[] =>
-    REQUIRED_SECTIONS.filter((name) => !declared.includes(name))
-
   for (const folder of folders) {
-    if (!governsContent(folder) || folder.entries.length === 0) continue
+    const required = requiredSections(folder)
+    if (required.length === 0 || folder.entries.length === 0) continue
+
+    const shortOf = (declared: readonly string[]): string[] =>
+      required.filter((name) => !declared.includes(name))
 
     // A stub owes no sections, so it is dropped before either branch rather
     // than inside them. Leaving one in the split-folder aggregate would let a
@@ -790,7 +826,7 @@ export function missingSections(
 
     if (reports.length === 0) continue
 
-    if (folder.nested) {
+    if (folder.nested && governsContent(folder)) {
       const missing = shortOf(reports.flatMap((entry) => entry.sections))
       if (missing.length > 0) findings.push({ rel: folder.rel, missing })
       continue