@erclx/aitk 1.7.1 → 2.1.0

package/README.md

@@ -67,7 +67,7 @@ Each domain has a canonical source in this repo and a thin install or sync CLI o
 
 - [Claude Code plugin](.claude/context/claude-plugin/index.md): skills for planning, review, docs sync, and the git ship chain
 - [Governance rules](.claude/context/governance/index.md): Claude rules and stacks, installable per project
-- [Standards](.claude/context/standards/index.md): shared authoring conventions, synced to projects
+- [Standards](.claude/context/standards/index.md): shared authoring conventions, read by name rather than installed
 - [Snippets](.claude/context/snippets.md): reusable prompts for Claude and Gemini chat
 - [Tooling stacks](.claude/context/tooling.md): golden configs, seeds, and references per framework
 - [Design system](.claude/context/design.md): `DESIGN.md` token shape, extract skill and its two paths, render command
@@ -116,7 +116,7 @@ git init
 aitk init
 ```
 
-`aitk init` installs base tooling configs, Claude seeds, governance rules, standards, and snippets in one pass, and scaffolds a `.claude/wiki/` stub for your project's own reference pages. Governance defaults to the `base` stack, so a bare init lands the coding and doc-authoring rules in `.claude/rules/` alongside the standards they route to. Pass `--stack <name>` for a framework stack, or `--skip governance` to leave rules out. Run `aitk tooling list --json` to see the catalog.
+`aitk init` installs base tooling configs, Claude seeds, governance rules, and snippets in one pass, and scaffolds a `.claude/wiki/` stub for your project's own reference pages. Governance defaults to the `base` stack, so a bare init lands the coding and doc-authoring rules in `.claude/rules/`. Each rule names the standard it answers to and reads it with `aitk standards <name>`, so no corpus is copied into your project. Pass `--stack <name>` for a framework stack, or `--skip governance` to leave rules out. Run `aitk tooling list --json` to see the catalog.
 
 For the full journey from scaffold through adding a domain later to syncing upstream drift, see [target projects](docs/target-projects.md).
 

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

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

package/claude/skills/claude-autoship/SKILL.md

@@ -75,11 +75,11 @@ The two causes want different responses. A plan that has yet to produce its outp
 
 The skip needs both tests to pass: every changed file matches `*.md` or `*.txt`, and no changed file sits under a behavior path. On a pass, skip review entirely and continue to Step 7. Otherwise invoke `aitk:claude-review`.
 
-Behavior paths carry two spellings, the one a surface authors at and the one it installs to, so the rule reads the same in a toolkit and in a project that consumed one:
+Behavior paths carry two spellings, the one a surface authors at and the one it reaches a session at, so the rule reads the same in a toolkit and in a project that consumed one:
 
 - `claude/skills/` and `.claude/skills/`
 - `governance/rules/` and `.claude/rules/`
-- `standards/` and `.claude/standards/`
+- `standards/` and `.claude/standards/`, which is the authoring root and this repository's generated mirror rather than an install destination, since the corpus installs into no project
 - `snippets/` and `.claude/snippets/`
 - `internal/` and `tooling/`, which hold the stack references and the seed documents a target is handed
 - `CLAUDE.md` at the repository root, named as a file because a path prefix reaches nothing that sits in no folder

package/claude/skills/claude-docs/SKILL.md

@@ -174,6 +174,17 @@ Reuse the diff from the baseline above, names and content both. For each existin
 - For each relevant entry, rewrite only the sections affected by the diff. Same pattern as `docs-sync`. Do not touch unrelated sections.
 - Write a reference to another entry as the path that entry sits at, rather than as its bare filename. `${CLAUDE_SKILL_DIR}/../../standards/context.md` states the form, and a bare name strands the reference once a domain splits into subfolders.
 
+### When the diff removes a capability
+
+The mapping above is scoped by file, and a removal invalidates claims that mapping cannot reach. Run this only when the diff deletes a command, a flag, a constant, or a folder. Ordinary feature work takes the narrow rule alone, since widening it on every ship churns prose nothing put in doubt.
+
+Grep the tree for the name that went, rather than for the paths the diff carries. A capability removed by name is cited by that name, which reaches a file the diff never touched.
+
+- An entry this run already rewrote is read whole before it is left. A refresh that updates the top and leaves a contradicting claim below reads worse than an untouched entry, because the current opening lends authority to the stale remainder. This is the one case that overrides "do not touch unrelated sections", and it overrides it only inside an entry the run edited anyway.
+- A claim comparing two surfaces is checked even where its file is outside the diff. Such a claim holds only while both surfaces do, so moving one inverts it with nobody editing the file it sits in.
+
+Report each hit as an ordinary rewrite.
+
 Do not create new entries automatically. New entries are a deliberate decision: the user invokes `claude-docs --new-context <domain>` (future flag) or hand-creates the file following `${CLAUDE_SKILL_DIR}/../../standards/context.md`. Auto-creation risks padding `.claude/context/` with low-signal entries.
 
 Write each updated entry immediately. Output one line per file:

package/claude/skills/claude-groundwork/SKILL.md

@@ -35,7 +35,7 @@ A track may run an experiment to settle an open question without stopping to ask
 - Writing a fixture this session reads or provisions itself: run it, under the fixtures path above. Provisioning is the usual blocker rather than spend, and it costs nothing.
 - Spawning a billed headless session: run up to three, then ask before spawning more. The bound is a run count rather than a budget, because a headless run reports its total cost only after it finishes, so a dollar ceiling is reportable and not enforceable while a run count is checkable before spawning.
 
-A fixture a headless run is pointed at goes outside the repository, under `mktemp -d`, and never under `.claude/.tmp/`. A session started anywhere beneath the project root loads that project's `CLAUDE.md`, `.claude/rules/`, and `.claude/standards/` through the ancestor chain, so an in-repo fixture measures the repository instead of the arm. Record the fixture as contaminated and re-run it outside if this is discovered after the fact, because the result reads as evidence either way.
+A fixture a headless run is pointed at goes outside the repository, under `mktemp -d`, and never under `.claude/.tmp/`. A session started anywhere beneath the project root loads that project's `CLAUDE.md` and `.claude/rules/` through the ancestor chain, so an in-repo fixture measures the repository instead of the arm. Record the fixture as contaminated and re-run it outside if this is discovered after the fact, because the result reads as evidence either way.
 
 Record method, result, measured cost, and caveats in `08-spikes.md`. Put whatever the run produced that the record cites in `evidence/` beside it, so a reader checking a claim opens the artifact rather than taking the prose for it. Reach for a test harness the project already carries before building one, and copy how it isolates its fixture rather than only what it asserts.
 

package/claude/skills/claude-seed-sync/REQUIREMENT.md

@@ -7,7 +7,7 @@ description: Scope boundary for section-granular seed reconciliation against the
 
 ## Gap
 
-Without this skill, a project that edited an installed seed or standard has two ways to take an upstream change and both lose something. `aitk standards install` overwrites every file, so the edits are gone with no record of what they were. `aitk standards sync` updates only files it already finds and adds none, so a standard written after the project installed never arrives at all. Neither can deliver one upstream section into a file the project has customized, which is the case a grown project is always in.
+Without this skill, a project that edited a seed has no way to take an upstream change without losing something. No `aitk` command touches a seed at all, so the only route is a hand copy that overwrites the file and takes the edits with it, unrecorded. Nothing can deliver one upstream section into a file the project has customized, which is the case a grown project is always in.
 
 A whole-file diff does not close it either. It cannot separate a section the user rewrote on purpose from a section the toolkit moved on without them, so the choice reaches the user as accept everything or lose everything, and the safe answer is always to skip.
 
@@ -17,7 +17,7 @@ Two failures belong to the audit rather than to the diff. A decision taken in ch
 
 ## Must
 
-- Read seed and standard content from the CLI rather than holding a copy, so the audit and the install cannot disagree
+- Read seed content from the CLI rather than holding a copy, so the audit and the install cannot disagree
 - Diff per section, treating the preamble as a section of its own
 - Separate a customized section from a stale one by reading the attribution the drift report records, not by how the section looks, and default the customized one to no action
 - Fall back to appearance only when attribution is unavailable, and mark every verdict reached that way as unverified

package/claude/skills/claude-seed-sync/SKILL.md

@@ -14,27 +14,24 @@ Surfaces drift between the toolkit's current seed docs and what was installed in
 
 ## Step 1: read toolkit sources and the drift report
 
-Run all three in parallel from the project root:
+Run both in parallel from the project root:
 
 ```bash
 aitk claude seeds list --json 2>/dev/null
-aitk standards list --json 2>/dev/null
 aitk sync --check . --json 2>/dev/null
 ```
 
-Seeds emit an array of `{name, source, target, content}`. Standards emit `{standards: [{name, description, target, content}]}`. In both cases `target` is the path relative to the project root where the file installs. Merge the two into one list of entries tagged by source (`seed` or `standard`).
+Seeds emit an array of `{name, source, target, content}`, where `target` is the path relative to the project root where the file installs.
 
-If the target project has no `.claude/standards/` directory, skip the standards stage silently.
+Seeds are the whole subject. No standard installs into a project, so there is no installed copy to audit and nothing to reconcile against the corpus. A standard a session needs is read with `aitk standards <name>`, which resolves against the copy inside the package.
 
 ### Narrow the set by attribution
 
-The report is what separates a file the project edited from one the toolkit moved on without it. Read `seeds.entries` for seed paths and `domains[].entries` for standards, then drop from the merged list every entry the report attributes as `stale`. A stale file matches a version the toolkit published, so it carries no edits to lose and `aitk standards sync` takes it whole. Section-merging it is work with no decision behind it.
+The report is what separates a file the project edited from one the toolkit moved on without it. Read `seeds.entries` for seed paths.
 
 Keep every seed regardless of state. `CLAUDE.md` is the file a project edits most, and its `drifted` verdict is the case this skill exists for.
 
-Record the dropped standards as one line in the scope table rather than as rows: `<n> standards stale, taken by aitk standards sync`.
-
-Read the `toolkit-cli` skill before naming that command in the output. It states which surfaces a sync overwrites, merges, or writes once, and this skill hands the user a command against files its own attribution pass cleared as carrying no edits.
+Read the `toolkit-cli` skill before naming a sync command in the output. It states which surfaces a sync overwrites, merges, or writes once.
 
 Fall back to the appearance heuristic in step 3 when the report cannot attribute, which is `historyUnavailable` set on the relevant section or the command failing outright. Say so in the summary block, because a fallback audit reports guesses rather than facts.
 
@@ -53,7 +50,8 @@ Note on `settings.json`: the seed now ships only the PostToolUse hook block. If
 For each seed file present in both sides, parse the body into a preamble (everything between H1 and the first H2) plus one part per `##` header, then compare part by part. Treat the preamble as a single unit with the same verdicts as a section. Use `(preamble)` as its label in the proposal.
 
 - **Identical:** ignore.
-- **Toolkit-only section** (present in source, absent in target): candidate to **Add**.
+- **Toolkit-only section** (present in source, absent in target): candidate to **Add**. Number it whatever the file's own verdict is. The verdict rules below govern a section present in both, and a section the project never had cannot be the customization a `drifted` file is being credited with. A pass that reads the file-level verdict first proposes nothing on a target missing eleven sections, which is the shape this bullet exists to catch.
+  - A deliberate removal reads the same as one that never arrived, and no decline is carried between runs, so a section the user skips is proposed again on the next branch. Say so beside the item rather than letting a reader meet it a third time wondering. The way to settle it for good is to keep the heading and write the project's own content under it, which moves the section onto the drifted path below, where the customization rule protects it and stops numbering it.
 - **Target-only section** (present in target, absent in source): preserve, never propose removal. These are user customizations.
 - **Drifted section** (present in both, content differs): candidate to **Update**.
   - Read the file's verdict from the report rather than judging it by eye. `drifted` means the content matches no version the toolkit ever published, so the project wrote it: call it **Customized**, default to skip, record in the scope table only, never numbered.
@@ -87,16 +85,15 @@ How to respond: fill in `Decision:` per item (`apply` or `skip`), then ping. Cha
 
 ## Scope
 
-Group rows by source. `Seeds` first, then `Standards`. Mark target-only files (present in target, absent in source) as `local-only` and leave them untouched.
+Mark target-only files (present in target, absent in source) as `local-only` and leave them untouched.
 
-| Source   | File       | Status     | Note                         |
-| -------- | ---------- | ---------- | ---------------------------- |
-| seed     | `<target>` | diffed     | <counts>                     |
-| seed     | `<target>` | in sync    |                              |
-| seed     | `<target>` | skipped    | non-text, compare manually   |
-| seed     | `<target>` | customized | <section> skipped by default |
-| standard | `<target>` | diffed     | <counts>                     |
-| standard | `<target>` | local-only | not in toolkit, preserved    |
+| Source | File       | Status     | Note                         |
+| ------ | ---------- | ---------- | ---------------------------- |
+| seed   | `<target>` | diffed     | <counts>                     |
+| seed   | `<target>` | in sync    |                              |
+| seed   | `<target>` | skipped    | non-text, compare manually   |
+| seed   | `<target>` | customized | <section> skipped by default |
+| seed   | `<target>` | local-only | not in toolkit, preserved    |
 
 ## 1. 📝 Update → `<target-path>` / <section>
 

package/claude/skills/create-standard/REQUIREMENT.md

@@ -1,6 +1,6 @@
 ---
 name: create-standard
-description: Why a standard needs its shape read from the meta-standard and its write surface resolved before anything is drafted
+description: Why a standard needs its shape read from the meta-standard before anything is drafted, and why the follow-up depends on who owns the folder it landed in
 ---
 
 # Create standard requirement
@@ -9,30 +9,27 @@ description: Why a standard needs its shape read from the meta-standard and its
 
 Without this skill, a standard is written from memory of what other standards look like. It arrives without the scope section that says what the file does not govern, so the next author cannot tell whether a rule belongs to it or to a sibling, and two standards end up claiming the same subject with no way to settle which one wins.
 
-The write surface is the second failure. The toolkit authors at `standards/` and a target project holds only the installed copy under `.claude/standards/`, so a session picks whichever folder it noticed first. A toolkit standard written into the consumed copy fails the drift assertion that regenerates that folder. A standard written there in a target project is correct and looks identical, which is why the surface has to be resolved from what the project has rather than guessed.
+The consumed copy is the second failure. This repository mirrors `standards/` into `.claude/standards/` and asserts the two match, so a toolkit standard written into the mirror fails that assertion while looking like a correct file. One write surface removes the choice: `standards/` is what the resolver reads first and what every author writes to, in the toolkit and in a project alike.
 
-A standard written at the root and left there is the third. The index entry and the context table are both generated or maintained downstream of the write, so a file that ships without them is catalogued nowhere and reached only by whoever already knew the path.
+A standard written and left there is the third. The index entry and the context table are both generated or maintained downstream of the write, so a file that ships without them is catalogued nowhere and reached only by whoever already knew the path.
 
 ## Must
 
 - Read the meta-standard before drafting, since the shape is what makes the file arguable against a sibling
-- Resolve the write surface from which standards folder the project has, rather than from whichever one the session noticed first
+- Write to `standards/`, creating it when absent, since it is the one root the resolver reads and the only surface either kind of author has
 - Confirm the slug and the full body with the user before writing
 - Emit the written path in full, so the terminal can resolve it
-- State what the resolved surface implies after writing, since a root file needs the consumed copy and the index regenerated and a project-local one needs copying to the toolkit to ship
+- State what the write implies for whoever owns the folder, since a toolkit standard needs the consumed copy and the index regenerated and a project-local one needs copying to the toolkit to ship
 
 ## Must not
 
 - Work the standard's shape or frontmatter from memory
 - Write a snippet, which carries no frontmatter and answers to a different authoring contract
-
-## Guards
-
-- Neither standards folder exists: stop, since there is nowhere for the standard to live
+- Write into `.claude/standards/`, which is this repository's generated mirror and reaches no resolver
 
 ## Out of scope
 
 - Editing a standard that already exists
 - A snippet, which `create-snippet` owns
 - A path-scoped coding rule, which `create-rule` owns
-- Installing and syncing the standards the toolkit ships, which the `aitk standards` commands own
+- Reading a standard the toolkit ships, which `aitk standards <name>` owns

package/claude/skills/create-standard/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: create-standard
-description: Creates a new standard file in `standards/` or `.claude/standards/`. Use when asked to create a standard, add a standard, or write a new authoring convention. Do NOT use to edit an existing standard.
+description: Creates a new standard file in `standards/`. Use when asked to create a standard, add a standard, or write a new authoring convention. Do NOT use to edit an existing standard.
 ---
 
 # Create standard
@@ -11,20 +11,19 @@ Creates one standard file. Read these files in parallel:
 - The `write-human` skill: voice, rhythm, and sentence construction for all generated text
 - `${CLAUDE_SKILL_DIR}/../../standards/standard.md`: the meta-standard for shape, frontmatter, and structure
 
-## Guards
-
-- If neither `standards/` nor `.claude/standards/` exists, stop: `❌ No standards/ or .claude/standards/ directory found.`
-
 ## Steps
 
-1. Resolve the write surface: `standards/` at the root if present, which is the toolkit's own authoring source. Otherwise `.claude/standards/`, a target project's installed copy.
-2. Draft the content from the user's description. The meta-standard governs frontmatter, headings, and structure.
-3. Confirm the slug and full content with the user before writing
-4. Write the file to `<surface>/<slug>.md`
+1. Draft the content from the user's description. The meta-standard governs frontmatter, headings, and structure.
+2. Confirm the slug and full content with the user before writing
+3. Write the file to `standards/<slug>.md`, creating the folder when it is absent
+
+`standards/` is the one write surface. It is the toolkit's authoring source in this repository and a project's own folder anywhere else, and both are the root `aitk standards <name>` resolves against first. No corpus installs into a project, so there is no second surface to pick between and no guard on a folder the skill can create itself.
 
 ## After writing
 
 Emit the full path on its own line.
 
-- Root surface: this is the toolkit's authoring source. Remind the user to run `bun run check` to regenerate the consumed copy under `.claude/`. That pass also regenerates the `standards/index.md` entry, and the user adds a row to the standards table in `.claude/context/standards/overview.md`.
-- `.claude/` surface: the file is project-local. `aitk standards sync` leaves it alone, since sync only updates filenames it recognizes from the toolkit. Remind the user to copy it to the toolkit repo, under `standards/<slug>.md`, if it should ship to every project.
+- In the toolkit: this is the authoring source. Remind the user to run `bun run check` to regenerate the consumed copy under `.claude/`. That pass also regenerates the `standards/index.md` entry, and the user adds a row to the standards table in `.claude/context/standards/overview.md`.
+- In a project: the file is project-local and no toolkit command touches it. Remind the user to copy it to the toolkit repo, under `standards/<slug>.md`, if it should ship to every project.
+
+Separate the two by whether the folder already held toolkit-authored standards before this write, since a project authoring its own uses the same path.

package/claude/skills/git-pr/references/labels.md

@@ -27,7 +27,13 @@ web = ["apps/web/", "packages/ui/"]
 
 A label takes more than one prefix when two folders read as one surface. Two labels may claim overlapping prefixes, and a path under both earns both.
 
-The map is authored by hand and nothing detects a directory it fails to cover, so a surface added after the map was written labels nothing until someone adds a row.
+Matching is prefix-anchored, so a row written for an authoring root reaches nothing under the copy a project consumes. A surface living only under a dotted folder carries its own prefix on the row that owns its subject, and a folder holding several subjects rather than one splits across the rows that own them.
+
+The map is authored by hand and nothing detects a directory it fails to cover, so a surface added after the map was written labels nothing until someone adds a row. A map that has been censused against its own history says in its comment where that check is owned, so a reader meeting the gap is sent somewhere rather than left with the prediction.
+
+## Paths a map declines to label
+
+A path that moves only when a release or a generator rewrites it earns no row. Release automation applies its own label, and a domain label on a generated file gives a mechanical edit a subject it does not have. Neither is covered, so both are recorded in the map's comment with the reason, which is what separates a path nobody has gotten to from one somebody decided against.
 
 ## Matching
 

package/claude/skills/migration-standards/REQUIREMENT.md

@@ -1,27 +1,30 @@
 ---
 name: migration-standards
-description: Why the root-to-.claude relocation ships as git mv commands the user runs, and which inbound references are worth fixing
+description: Why the root-to-.claude snippets relocation ships as git mv commands the user runs, which inbound references are worth fixing, and why standards no longer travel with it
 ---
 
 # Migration standards requirement
 
 ## Gap
 
-Without this skill, a project whose rules cite `.claude/standards/` while the files sit at the root gets fixed by hand, and the hand fix loses what version control was holding. A plain `mv` breaks the rename chain, so every relocated standard reads as a delete beside an unrelated add and its history stops at the move.
+Without this skill, a project whose rules cite `.claude/snippets/` while the files sit at the root gets fixed by hand, and the hand fix loses what version control was holding. A plain `mv` breaks the rename chain, so every relocated snippet reads as a delete beside an unrelated add and its history stops at the move.
 
-A fourth failure comes before those three, from deciding what is unmigrated by listing the folder. A root `standards/` can hold the project's own docs and nothing the toolkit ever installed, and a listing cannot tell the two apart, so the skill proposes moving project files under `.claude/` where a sync walks them. The drift report already answers this, counting only files whose basename the toolkit ships, and it is the same report `toolkit-operator` reads to route here.
+A fourth failure comes before those three, from deciding what is unmigrated by listing the folder. A root `snippets/` can hold the project's own prompts and nothing the toolkit ever installed, and a listing cannot tell the two apart, so the skill proposes moving project files under `.claude/` where a sync walks them. The drift report already answers this, counting only files whose basename the toolkit ships, and it is the same report `toolkit-operator` reads to route here.
+
+Standards left this skill when the corpus stopped installing into a project. The report no longer names the domain, so a body still describing the move would propose relocating a folder the project authored, which is the exact failure the paragraph above records in the other direction.
 
 Taking detection from a command opens a failure the listing never had. A CLI predating the field exits zero with a well-formed report that never mentions it, so a skill treating an absent key as an empty answer tells a project whose every domain sits at the root that it has nothing to relocate. That is the population this skill exists for, and a silent false negative there costs more than the unfiltered count reading the folder would have produced.
 
 The re-sync the skill names has the same gap in the other direction. The relocation is what makes those commands land on a path that held nothing before, so the run hands over a command whose overwrite behavior it never states, and the reference holding that answer is named in the boundary below where no session reads it. Claude Code loads the skill entry alone.
 
-Three failures follow from acting without looking first. A move onto an existing `.claude/standards/` copy overwrites the files already installed there, which is the case the relocation was supposed to be unnecessary for. A `git mv` on a dirty tree lands the relocation in the same commit as unrelated work, so neither can be reviewed or reverted alone. And a session that rewrites every inbound reference spends its effort on toolkit-owned rules and skills, which the next sync overwrites, while the author-owned lines that actually break go unmentioned.
+Three failures follow from acting without looking first. A move onto an existing `.claude/snippets/` copy overwrites the files already installed there, which is the case the relocation was supposed to be unnecessary for. A `git mv` on a dirty tree lands the relocation in the same commit as unrelated work, so neither can be reviewed or reverted alone. And a session that rewrites every inbound reference spends its effort on toolkit-owned rules and skills, which the next sync overwrites, while the author-owned lines that actually break go unmentioned.
 
 ## Must
 
-- Take the set of domains to relocate from `aitk sync --check --json`, and report its filtered count rather than a folder listing
+- Take what to relocate from `aitk sync --check --json`, and report its filtered count rather than a folder listing
+- Say in one line that a root `standards/` folder is left alone, since a user who came here expecting both domains reads silence as an oversight
 - Keep the listing as the fallback for a target where `aitk` is absent, the command fails, or the report carries no `unmigrated` key, and say that its counts are unfiltered
-- Detect an existing copy under `.claude/` and skip that folder's move rather than merging into it
+- Detect an existing copy under `.claude/` and skip the move rather than merging into it
 - Read the working tree state and require it clean before the moves, since the relocation has to be revertible on its own
 - Propose `git mv` so history follows each file
 - Report author-owned inbound references as TODO lines the user fixes, and leave the reference itself untouched
@@ -36,7 +39,7 @@ Three failures follow from acting without looking first. A move onto an existing
 
 ## Guards
 
-- Neither root `standards/` nor root `snippets/` present stops, since there is nothing to relocate
+- No root `snippets/` present stops, since there is nothing to relocate
 - A directory that is not a git work tree stops, since `git mv` needs version control and a plain move is the failure the skill exists to prevent
 
 ## Out of scope

package/claude/skills/migration-standards/SKILL.md

@@ -1,30 +1,29 @@
 ---
 name: migration-standards
-description: Proposes `git mv` commands to relocate a target project's root `standards/` and `snippets/` folders into `.claude/standards/` and `.claude/snippets/`, the install layout newer toolkit versions expect. Use when asked to "relocate standards", "move standards to .claude", "migrate snippets to .claude", or after a toolkit upgrade leaves rules pointing at `.claude/standards/` while the files sit at the root. Do NOT auto-execute moves or edit rule files. Proposal only.
+description: Proposes `git mv` commands to relocate a target project's root `snippets/` folder into `.claude/snippets/`, the install layout newer toolkit versions expect. Use when asked to "relocate snippets", "move snippets to .claude", "migrate snippets to .claude", or after a toolkit upgrade leaves a rule pointing at `.claude/snippets/` while the files sit at the root. Do NOT auto-execute moves or edit rule files. Proposal only.
 ---
 
 # Claude standards relocate
 
+Snippets is the one domain this skill relocates. Standards used to travel beside it and the toolkit corpus now installs into no project at all, so a root `standards/` folder in a target holds work the project authored and nothing proposes moving it. `aitk standards <name>` reads a toolkit standard wherever a session needs one.
+
 ## Guards
 
-- If neither `standards/` nor `snippets/` exists at `pwd`, stop: `❌ No root standards/ or snippets/ to relocate.`
+- If `snippets/` does not exist at `pwd`, stop: `❌ No root snippets/ to relocate.`
 - If `pwd` is not a git work tree, stop: `❌ Not a git repository. git mv needs version control.`
 
 ## Step 1: read the report
 
 Run `aitk sync --check . --json` from the project root. Its `unmigrated` array is the detection. Each entry carries `domain`, `rootPath`, `installPath`, and `files`, and a domain appears only when the root folder holds a file the toolkit ships and nothing sits at the install path. Report `files` as the count, since it excludes files the project wrote into the same folder.
 
-Run these beside it, in parallel. The report answers which domains to move and neither of these is derivable from it:
+Run these beside it, in parallel. The report answers whether to move and neither of these is derivable from it:
 
-- `ls .claude/standards/ 2>/dev/null`: separate a domain already relocated from one never installed, which the report cannot, since both are absent from `unmigrated`
-- `ls .claude/snippets/ 2>/dev/null`: the same, for the other domain
+- `ls .claude/snippets/ 2>/dev/null`: separate a domain already relocated from one never installed, which the report cannot, since both are absent from `unmigrated`
 - `git status --short 2>/dev/null`: confirm a clean tree before proposing moves
 
-Keep the two listings as separate commands. `ls` labels its output with a `dir:` header only when more than one operand succeeds, so a combined call with one directory present prints that directory's filenames bare while the redirect swallows the other's failure, and the result reads as whichever directory was expected.
-
 ### When the report is unavailable
 
-Fall back to `ls standards/*.md` and `ls snippets/` on any of three conditions. Say in the output that the counts are unfiltered, because a root folder can hold project-authored files the report would have excluded and the fallback counts every one of them.
+Fall back to `ls snippets/` on any of three conditions. Say in the output that the count is unfiltered, because a root folder can hold project-authored files the report would have excluded and the fallback counts every one of them.
 
 - `aitk` is not on `PATH`
 - The command exits non-zero
@@ -38,19 +37,20 @@ Do not fall back on `historyUnavailable`. That field reports failed attribution
 
 ## Step 2: check conflicts
 
-- If `.claude/standards/` already holds `.md` files, mark standards as "already relocated" and skip its move.
-- If `.claude/snippets/` already holds `.md` files, mark snippets as "already relocated" and skip its move.
+- If `.claude/snippets/` already holds `.md` files, mark snippets as "already relocated" and skip the move.
 - If `git status` is not clean, add a TODO line telling the user to commit or stash first. `git mv` on a dirty tree mixes the move with unrelated changes.
-- If a root folder holds files and no domain names it in a report that carried the key, propose nothing for it. The content is the project's own, and moving it under `.claude/` puts project files where a sync walks. This reads a present key alone. A report with no `unmigrated` key never reaches here, since Step 1 sends it to the fallback.
+- If the root folder holds files and no domain names it in a report that carried the key, propose nothing. The content is the project's own, and moving it under `.claude/` puts project files where a sync walks. This reads a present key alone. A report with no `unmigrated` key never reaches here, since Step 1 sends it to the fallback.
+- A root `standards/` folder is never a conflict and never a move. Say so in one line when one is present, since a user who came here expecting both domains reads silence as an oversight.
 
 ## Step 3: find author-owned inbound references
 
 Toolkit-owned rules and skills are re-synced, so do not rewrite them. Surface only references the user authored:
 
-- `git grep -n "standards/" -- 'CLAUDE.md' '.claude/rules/**' 'docs/**' 2>/dev/null`
-- `git grep -n "snippets/" -- 'CLAUDE.md' '.claude/rules/**' 'docs/**' 2>/dev/null`
+```bash
+git grep -n "snippets/" -- 'CLAUDE.md' '.claude/rules/**' 'docs/**' 2>/dev/null
+```
 
-Report each hit as a TODO line. Exclude paths already under `.claude/standards/` or `.claude/snippets/`.
+Report each hit as a TODO line. Exclude paths already under `.claude/snippets/`.
 
 ## Step 4: output
 
@@ -59,38 +59,40 @@ Print one grouped proposal block. Omit empty groups.
 ```markdown
 ## Relocate
 
-- standards/ → .claude/standards/ (<count> files)
 - snippets/ → .claude/snippets/ (<count> files)
 
 ## Already relocated
 
-- .claude/standards/ exists. Skipping.
+- .claude/snippets/ exists. Skipping.
+
+## Left alone
+
+- standards/ is the project's own. No toolkit standard installs into a project.
 
 ## Suggested git mv commands
 
 mkdir -p .claude
-git mv standards .claude/standards
 git mv snippets .claude/snippets
 
 ## Re-sync after moving
 
-aitk standards sync .
+aitk snippets sync .
 aitk gov sync .
 
 ## Inbound references to verify
 
-- CLAUDE.md:42 references standards/markdown.md
+- CLAUDE.md:42 references snippets/align.md
 - docs/contributing.md:8 references snippets/claude/feature
 
 ## Reminder
 
-Re-syncing reinstalls toolkit-owned rules and standards at the new path. Author-owned references above need a manual one-line fix.
+Re-syncing reinstalls toolkit-owned rules and snippets at the new path. Author-owned references above need a manual one-line fix.
 ```
 
 Two states produce no proposal at all, and each gets its own line rather than an empty block:
 
-- Both folders already live under `.claude/`: `✅ standards/ and snippets/ already live under .claude/. Nothing to relocate.`
-- A root folder exists and no domain names it in `unmigrated`: `✅ <folder>/ holds no file the toolkit installed. Nothing to relocate.` Name every such folder. The guard passed because the folder is there, so a session that printed nothing would leave the user reading silence as a failed run rather than as the answer.
+- The folder already lives under `.claude/`: `✅ snippets/ already lives under .claude/. Nothing to relocate.`
+- The root folder exists and no domain names it in `unmigrated`: `✅ snippets/ holds no file the toolkit installed. Nothing to relocate.` The guard passed because the folder is there, so a session that printed nothing would leave the user reading silence as a failed run rather than as the answer.
 
 Read the `toolkit-cli` skill before printing the re-sync block, and name in the reminder any surface it lists as overwritten. The user runs those commands against a tree the moves above relocated, and that relocation is what puts an overwrite onto files never installed at the new path.
 

package/claude/skills/migration-superseded/REQUIREMENT.md

@@ -19,7 +19,7 @@ The last is the two-speed release skew arriving as a confident wrong answer. `su
 
 - Take detection from the report's `superseded` array alone, and stop when the key is absent rather than treating it as empty
 - Resolve the governing standard by matching the replacement folder against the `appliesTo` the standards catalog declares, so a seed folder added later resolves without an edit to the body
-- Read the destination shape from the project's own installed standard, and propose nothing for a folder whose standard is absent or unshipped
+- Read the destination shape with `aitk standards <name>`, report the root it answered from, and propose nothing for a folder the catalog names no standard for
 - Separate a folder no standard governs from one whose governing standard could not be read, since the catalog derives `appliesTo` from prose and answers an unparsed scope statement with an empty array
 - Name the untrack command ahead of the ignore entry whenever a retired file is both tracked and ignored, and say when the check could not run
 - Report what the destination standard leaves open, such as a phase label the retired file never recorded, rather than supplying a value for it
@@ -38,7 +38,7 @@ The last is the two-speed release skew arriving as a confident wrong answer. `su
 
 ## Out of scope
 
-- Relocating root `standards/` and `snippets/` into `.claude/`: `migration-standards`
+- Relocating root `snippets/` into `.claude/`: `migration-standards`
 - Classifying `CLAUDE.md` sections into the three-tier model: `migration-claude-md`
 - Relocating `docs/` files by audience: `migration-context`
 - Reconciling a seed file against its source section by section, which diffs two files rather than splitting one into a folder: `claude-seed-sync`

package/claude/skills/migration-superseded/SKILL.md

@@ -37,13 +37,13 @@ Run `aitk standards list --json` and match each entry's `replacedBy` against the
 
 Compare on the folder rather than on the exact string. An `appliesTo` value matches when it equals `replacedBy` or begins with `replacedBy` followed by a slash. The report spells the folder `.claude/tasks` and the catalog spells it `.claude/tasks/`, and `memory` declares a filename pattern beneath its folder rather than the folder itself, so string equality matches nothing the catalog actually carries and sends every entry to a decline below.
 
-### Search both standards roots
+### Read the standard through the verb
 
-A match resolves to that standard's `name`. Then look for that standard in the target, reading `.claude/standards/<name>.md` first and `standards/<name>.md` when the first is absent. The catalog says which standard governs the folder and only the target says whether the project holds it.
+A match resolves to that standard's `name`. Read it with `aitk standards <name>`, which writes the document to stdout and the root it answered from to stderr.
 
-Search both roots in that order, which is the order the toolkit's own standards resolution already uses. A project that has not relocated its standards keeps them at the root, and testing the installed path alone hands exactly that target a refusal plus a command that installs a second copy beside the one it already holds.
+The verb is the one route. It resolves `standards/<name>.md` at the project root first, which is where a project that authors standards of its own keeps them, and falls back to the corpus inside the aitk package. No toolkit standard installs into a project, so there is no third path to test and no case where the shape is unreachable while the catalog names it.
 
-A standard found at the root rather than under `.claude/` is read the same way and produces a full proposal. Say where it was read from and name `migration-standards` as the skill that relocates it, since the split is answerable either way and the layout is a note beside the proposal rather than a reason to refuse.
+Report the root the frame named beside the proposal. A shape read from the project's own `standards/` is the project's stated agreement, and one read from the package is the toolkit's default, which is a difference the user weighs rather than a reason to refuse.
 
 ### The states that end an entry
 
@@ -51,10 +51,8 @@ Four states end an entry with no proposal. Name whichever one fired rather than
 
 - The catalog carries no `appliesTo` key: `⚠️ This aitk emits no appliesTo, so which standard governs <replacedBy> is unread.`
 - No value covers `replacedBy` and some entry carries an empty `appliesTo`: an empty array is a scope statement that did not parse, so a no-match verdict is unread rather than negative. Name the standards that did not parse.
-- No value covers `replacedBy` and every array is populated: `⚠️ The toolkit ships no standard for <replacedBy>. Nothing states the destination shape.` Installing cannot fix it, so name no command.
-- The standard resolved and neither root holds it: name it, then name `aitk standards install --only <name> .` as the command that lands it.
-
-Do not read the toolkit's own copy through `${CLAUDE_SKILL_DIR}` when the target lacks the file. Sibling skills cite that fallback for a standard they follow themselves, and this one is different: the standard here is the project's agreement about the shape of its own folder. A proposal drawn from the plugin copy hands back a shape the project never adopted, against content only the user can place.
+- No value covers `replacedBy` and every array is populated: `⚠️ The toolkit ships no standard for <replacedBy>. Nothing states the destination shape.` No command fixes it, so name none.
+- The standard resolved in the catalog and `aitk standards <name>` exits non-zero: name the standard and the exit, since the catalog and the read disagree and only one of them can be right.
 
 ## Step 3: read the shape and map the file onto it
 
@@ -90,7 +88,7 @@ Print one block per superseded entry, then the shared reminder. Omit empty group
 ```markdown
 ## Split
 
-`.claude/TASKS.md` → `.claude/tasks/`, shaped by `.claude/standards/tasks.md`
+`.claude/TASKS.md` → `.claude/tasks/`, shaped by `aitk standards tasks`
 
 ## Proposed files
 

package/claude/skills/setup-gov/REQUIREMENT.md

@@ -32,6 +32,6 @@ The last failure sits at a boundary rather than inside a run. `setup-init` turns
 
 ## Out of scope
 
-- The rest of the onboarding chain. This skill installs governance and nothing else, and `setup-init` is the one-shot path that installs governance beside tooling, standards, snippets, and the seeds.
-- Scaffolding the rule file an unmatched technology needs. `create-rule` writes one into a target project, and a rule the toolkit should ship is authored under `governance/rules/` against `.claude/standards/rule.md`.
+- The rest of the onboarding chain. This skill installs governance and nothing else, and `setup-init` is the one-shot path that installs governance beside tooling, snippets, and the seeds.
+- Scaffolding the rule file an unmatched technology needs. `create-rule` writes one into a target project, and a rule the toolkit should ship is authored under `governance/rules/` against `aitk standards rule`.
 - Updating rules a project already has, which `aitk gov sync` owns

package/claude/skills/toolkit-cli/SKILL.md

@@ -9,18 +9,17 @@ What each `aitk` sync or install command does to existing files in a target proj
 
 ## Overwrite contract
 
-| Surface                                                  | Command                  | Effect on existing files                                         |
-| -------------------------------------------------------- | ------------------------ | ---------------------------------------------------------------- |
-| Golden configs, listed in full below                     | `aitk tooling sync`      | Overwritten once `--write` is passed. Local edits are lost.      |
-| Dictionary seeds (`.cspell/*.txt`)                       | `aitk tooling sync`      | Merged and sorted. Existing terms preserved.                     |
-| Other seeds (`cspell.json`, `.lintstagedrc`, state docs) | `aitk tooling sync`      | Copy-once. Dropped on first install, untouched after.            |
-| Standards                                                | `aitk standards install` | All overwritten.                                                 |
-| Standards                                                | `aitk standards sync`    | Only files already present are updated. None are added.          |
-| Seed docs and `CLAUDE.md`                                | `aitk claude init`       | Skipped when present. Never overwritten.                         |
-| Seed docs                                                | `aitk claude sync`       | Never touched. Only `.gitignore` is written.                     |
-| References (`.claude/tooling/<stack>.md`)                | `aitk tooling ref`       | Overwritten.                                                     |
-| `.gitignore`, deps, scripts                              | any sync                 | Additive. Existing entries preserved. Deps re-pin on major skew. |
-| Generated `index.md`                                     | any sync or regen        | Rewritten from target state. Hand edits are lost.                |
+| Surface                                                  | Command             | Effect on existing files                                          |
+| -------------------------------------------------------- | ------------------- | ----------------------------------------------------------------- |
+| Golden configs, listed in full below                     | `aitk tooling sync` | Overwritten once `--write` is passed. Local edits are lost.       |
+| Dictionary seeds (`.cspell/*.txt`)                       | `aitk tooling sync` | Merged and sorted. Existing terms preserved.                      |
+| Other seeds (`cspell.json`, `.lintstagedrc`, state docs) | `aitk tooling sync` | Copy-once. Dropped on first install, untouched after.             |
+| Standards                                                | none                | Nothing installs. `aitk standards <name>` reads and never writes. |
+| Seed docs and `CLAUDE.md`                                | `aitk claude init`  | Skipped when present. Never overwritten.                          |
+| Seed docs                                                | `aitk claude sync`  | Never touched. Only `.gitignore` is written.                      |
+| References (`.claude/tooling/<stack>.md`)                | `aitk tooling ref`  | Overwritten.                                                      |
+| `.gitignore`, deps, scripts                              | any sync            | Additive. Existing entries preserved. Deps re-pin on major skew.  |
+| Generated `index.md`                                     | any sync or regen   | Rewritten from target state. Hand edits are lost.                 |
 
 ## What a tooling sync can overwrite
 
@@ -94,8 +93,8 @@ Run `aitk tooling sync <stack> <target> --check` for the list resolved against a
 - Run `--check` first when the project carries local edits to any path above. The report names each file it would replace, which is the warning the user needs before the write.
 - An interactive run still prompts. `--write` skips the prompt, and `--check` refuses to write even with a TTY.
 - Seeds are user-owned. Dictionary `.txt` files merge and sort. Other seeds are copy-once, so re-seeding a structured file means deleting it and syncing again.
-- Prefer `aitk standards sync` over `install` on an existing project. `install` overwrites every standard.
-- For section-level customizations of a standard or seed doc, use the `claude-seed-sync` skill, not `aitk ... sync`. It diffs per section and preserves edits.
+- No command writes a standard into a project. A `.claude/standards/` folder from an older toolkit is inert, and deleting it costs nothing.
+- For section-level customizations of a seed doc, use the `claude-seed-sync` skill, not `aitk ... sync`. It diffs per section and preserves edits.
 
 ## CLAUDE.md
 

package/docs/agents/commands.md

@@ -60,7 +60,7 @@ Each domain exposes a consistent shape where applicable: `list`, `install`, `syn
 | ----------- | ------------------------------------------------------------------------------------------- |
 | `tooling`   | `list`, `sync`, `ref`, `create`, `verify`, `inject`, `prune-gitignore`                      |
 | `snippets`  | `list`, `install`, `sync`, `create`                                                         |
-| `standards` | `list`, `install`, `sync`, `<name>`                                                         |
+| `standards` | `list`, `<name>`                                                                            |
 | `gov`       | `list`, `install`, `sync`, `build`, `regen`, `test-order`                                   |
 | `claude`    | `init`, `sync`, `seeds list`, `skills list`, `skills audit`, `skills drift`, `setup [dest]` |
 | `wiki`      | `init`                                                                                      |