@erclx/aitk 0.24.0 → 0.26.0

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

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

package/claude/skills/claude-address-review/SKILL.md

@@ -73,9 +73,9 @@ bullet per finding, each opening with the bolded finding identifier.
 Close the body with `🤖 Addressed by Claude Code` on its own line so the reply
 reads as an independent machine pass, not a human sign-off.
 
-Before posting, run the pre-publish scan in `.claude/standards/prose.md`
-against the reply, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the
-project does not have it. The hook skips `.claude/.tmp/`, so this scan is the
+Before posting, run the scan in `.claude/standards/publish.md`
+against the reply, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when
+the project does not have it. The hook skips `.claude/.tmp/`, so this scan is the
 only gate on the published reply. Post it to the PR:
 
 ```bash

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

@@ -11,7 +11,7 @@ Chain the post-plan pipeline in a single run. Every step has a stop condition. S
 ## Guards
 
 - All `.claude/plans/` and `.claude/review/` reads resolve at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`.
-- Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. This skill takes the stop rather than the `latest` fallback, since it commits and opens a pull request. If empty, stop: `❌ Detached HEAD. Checkout the feature branch first.`
+- Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. This skill takes the stop rather than the `latest` fallback, since it commits and opens a pull request. If empty, stop: `❌ Detached HEAD. Checkout the feature branch first.`
 - If `.claude/plans/feature-<slug>.md` does not exist at the main worktree root, stop: `❌ No approved plan at .claude/plans/feature-<slug>.md. Run /claude-feature first.`
 - If the working tree has uncommitted changes unrelated to the plan, stop: `❌ Uncommitted changes outside the plan. Commit or stash before autoshipping.`
 

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

@@ -80,7 +80,7 @@ The code paths the explanation cites are what the `claude-docs` sweep watches fo
 
 Quote node labels containing spaces or special characters with double quotes (`A["Web shell"]`). Avoid parentheses inside labels, they break some renderers. Use `<br/>` for line breaks inside labels.
 
-Run the pre-publish scan in `.claude/standards/prose.md` against the whole file, including inside mermaid `subgraph` labels and node text, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the project does not have it. The file lands in the repository rather than on a remote, so the scan's destination scoping leaves the character checks and not the phase-label one. A colon also works as a replacement inside a label. The pedagogical voice the diagram standard asks for is a yield on voice alone and buys no exemption from these bans.
+Run the scan in `.claude/standards/publish.md` against the whole file, including inside mermaid `subgraph` labels and node text, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when the project does not have it. The file lands in the repository rather than on a remote, so the scan's destination scoping leaves the character checks and not the phase-label one. A colon also works as a replacement inside a label. The pedagogical voice the diagram standard asks for is a yield on voice alone and buys no exemption from these bans.
 
 Nothing enforces the ban inside the diagram. The standards-audit hook toggles on a fence and skips every line within it, so a label carrying an em dash passes silently while the same character in the explanation paragraph below is caught. Check the labels by reading them. This is the one place in the file where the author is the only gate.
 

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

@@ -237,7 +237,7 @@ A plan can serve more than one task, and archiving on the first task to close st
 
 Write the retarget as a markdown link, `Plan: [feature-<slug>](../.tmp/plans-archive/feature-<slug>.md)`, updating both halves so the text and the target stay in step. This branch is the only writer that produces a `Plan:` line nobody authored by hand, so a retarget that emits a bare path converts every task to the old form as it closes and drifts the board back to two shapes on its own.
 
-**Reviews.** Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. Fall back to `latest` on an empty result. If `.claude/review/review-<slug>.md` exists, delete it. `claude-review` writes with this convention. Do not sweep any other `review-*.md` file.
+**Reviews.** Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. Fall back to `latest` on an empty result. If `.claude/review/review-<slug>.md` exists, delete it. `claude-review` writes with this convention. Do not sweep any other `review-*.md` file.
 
 Do not sweep `ui-checklist-*.md` (pending human verification) or `ux-audit-*.md` (standalone deliverable).
 

package/claude/skills/claude-memory-review/SKILL.md

@@ -78,7 +78,7 @@ Rules that resist crisp one-line phrasing default to **Delete** over promote. Ne
 
 ### Step 4: write the proposal to the review file
 
-Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. Fall back to `latest` on an empty result.
+Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. Fall back to `latest` on an empty result.
 
 Write the full proposal to `.claude/review/memory-review-<slug>.md` at the main worktree root. Do not print it inline.
 

package/claude/skills/claude-pr-review/SKILL.md

@@ -131,7 +131,7 @@ The `What is right` section is optional, capped at three bullets, and included o
 
 Close the body with `🤖 Reviewed by Claude Code` on its own line so the review reads as an independent machine pass, not a human sign-off.
 
-Before posting, run the pre-publish scan in `.claude/standards/prose.md` against the body, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the project does not have it. The hook skips `.claude/.tmp/`, so this scan is the only gate on the published comment. A finding phrased against an internal phase label is what the label half of the scan catches here.
+Before posting, run the scan in `.claude/standards/publish.md` against the body, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when the project does not have it. The hook skips `.claude/.tmp/`, so this scan is the only gate on the published comment. A finding phrased against an internal phase label is what the label half of the scan catches here.
 
 ```bash
 gh pr review <number> --comment --body-file .claude/.tmp/pr-review/body-<number>-<short-sha>.md

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

@@ -118,7 +118,7 @@ If nothing is wrong, use: `✅ No findings.`
 
 ### Persist
 
-Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. Fall back to `latest` on an empty result.
+Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. Fall back to `latest` on an empty result.
 
 Write the full report directly to `.claude/review/review-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
 

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

@@ -52,7 +52,7 @@ Before proposing an Update, grep the target section for the seed text's keywords
 
 ## Step 4: write the proposal to the review file
 
-Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. Fall back to `latest` on an empty result.
+Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. Fall back to `latest` on an empty result.
 
 Write the full proposal to `.claude/review/seed-audit-<slug>.md` at the main worktree root. Do not print the proposal inline.
 

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

@@ -1,6 +1,6 @@
 ---
 name: claude-standards-audit
-description: Audits changed markdown files against applicable authoring standards (prose, skill, readme) and reports violations without fixing. Maps each file to its standards, greps for banned tokens, and groups findings by file. Use when asked to "audit prose", "audit standards", "check standards", "standards audit", or after editing markdown where standards compliance matters. Do NOT fix violations. Reporting only.
+description: Audits changed markdown files against every authoring standard that declares jurisdiction over their paths and reports violations without fixing. Reads the standards catalog to map each file, greps for banned tokens, and groups findings by file. Use when asked to "audit prose", "audit standards", "check standards", "standards audit", or after editing markdown where standards compliance matters. Do NOT fix violations. Reporting only.
 ---
 
 # Claude standards audit
@@ -35,17 +35,33 @@ Get the changed file list, substituting `git diff HEAD --name-only` when the bas
 git diff <base> HEAD --name-only
 ```
 
-Filter to markdown (`.md`). Drop generated files the project does not hand-author (`index.md` when `auto: false` is absent, any file in a gitignored directory).
+Filter to markdown (`.md`), then drop what the project does not hand-author:
+
+- `index.md`, unless its frontmatter carries `auto: false`
+- Any file in a gitignored directory
+- Any file sitting in a skill's bundled reference folder whose frontmatter names the consumers a generator copied it out to
+
+The last rule keeps a fan-out from multiplying one edit into a finding per copy. The source is the file to audit and the only one an author can fix, because the next regen overwrites every copy.
+
+It takes both halves. A generator copies frontmatter verbatim, so the field alone matches the source as well and drops the one file the rule means to keep. The location alone matches a reference the skill author wrote by hand, which carries no such field and is governed like the rest of the folder.
 
 ## Step 2: map files to standards
 
-For each changed markdown file, pick the applicable standards:
+Read the mapping rather than holding it here. Every standard declares the paths it governs, so a standard added later joins this audit with no edit to this body:
+
+```bash
+aitk standards list --json
+```
+
+Each entry carries `appliesTo`, the paths its `## Scope` statement declares. Match every changed file against every entry:
+
+- `*` matches every changed markdown file
+- An entry ending in `/` matches when the file path contains it at a path-segment boundary
+- Any other entry matches when the file path ends with it at a path-segment boundary
 
-- Any markdown with prose: `.claude/standards/prose.md`
-- `SKILL.md` under `.claude/skills/` or `claude/skills/`: also `.claude/standards/skill.md`
-- `README.md` at any level: also `.claude/standards/readme.md`
+Add any standard in `.claude/standards/` the catalog did not list, and derive every declaration the same way when `aitk` is unavailable: the backticked paths in the first sentence under `## Scope`, or `*` when that sentence says the standard governs an attribute. Skip `index.md`, which is generated from the others and declares nothing. Read a standard from `${CLAUDE_SKILL_DIR}/../../standards/` when the project does not have it.
 
-Read a standard from `${CLAUDE_SKILL_DIR}/../../standards/` instead when the project does not have it.
+An entry whose `appliesTo` is empty declared nothing this can read. Report it as a finding against that standard's own file in Step 4 and audit the rest. A standard dropped in silence is the same miss this mapping exists to remove, one level up.
 
 Every mapping names a changed markdown file, which is the only thing Step 1 produces. Text that never lands in the tree, such as a branch name or a pull request body, is checked by the skill that publishes it rather than here.
 
@@ -60,14 +76,14 @@ Every changed markdown file gets the prose pattern pass, since `.claude/standard
 
 ## Step 4: report
 
-Group findings by file with line references. Use this shape:
+Group findings by file with line references, naming the standard each one comes from. One file is one fix pass, and the standard is what the reader opens to settle a finding they disagree with. Use this shape:
 
 ```markdown
 path/to/file.md
 
-- L12: em dash in prose
-- L34: semicolon used to join clauses
-- L67: bullet ends with period but is a single fragment
+- L12: `prose.md`, em dash in prose
+- L34: `prose.md`, semicolon used to join clauses
+- L67: `context.md`, decision entry names no rejected alternative
 ```
 
 If clean, respond with `✅ No violations.`

package/claude/skills/claude-ui-test/SKILL.md

@@ -57,7 +57,7 @@ If all changes are automatable, skip the manual checklist:
 
 ### Persist the checklist
 
-Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. Fall back to `latest` on an empty result.
+Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. Fall back to `latest` on an empty result.
 
 When a manual checklist is produced, write it directly to `.claude/review/ui-checklist-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
 

package/claude/skills/claude-ux-audit/SKILL.md

@@ -58,7 +58,7 @@ If nothing is wrong, use: `✅ No observations.`
 
 ### Persist
 
-Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. Fall back to `latest` on an empty result.
+Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. Fall back to `latest` on an empty result.
 
 Write the full report directly to `.claude/review/ux-audit-<slug>.md` at the main worktree root, not the current worktree. See Worktrees in `CLAUDE.md`. Create the directory if it does not exist. Always overwrite.
 

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

@@ -34,7 +34,7 @@ The directory test separates the defect from a genuinely bare repository, which
 
 Try each source in order. Stop at the first match.
 
-1. **Plan matched to current branch.** Derive `<slug>` per Deriving the branch slug in `.claude/standards/skill.md`, or `${CLAUDE_SKILL_DIR}/../../standards/skill.md` when the project does not have it. An empty result falls through to the next source here rather than becoming `latest`, since the slug is one candidate among several. If `<main-root>/.claude/plans/feature-<slug>.md` exists, use `<slug>`.
+1. **Plan matched to current branch.** Derive `<slug>` per `.claude/standards/slug.md`, or `${CLAUDE_SKILL_DIR}/../../standards/slug.md` when the project does not have it. An empty result falls through to the next source here rather than becoming `latest`, since the slug is one candidate among several. If `<main-root>/.claude/plans/feature-<slug>.md` exists, use `<slug>`.
 2. **Single plan file.** List `<main-root>/.claude/plans/feature-*.md`. If exactly one match, derive `<slug>` from the filename.
 3. **Multiple plan files, no branch match.** Ask the user which plan. Show the candidate slugs as a numbered list. Do not pick.
 4. **Current branch.** When no plan exists, use the `<slug>` from step 1 if it is not `main` or `master`.

package/claude/skills/git-branch/references/branch.md

@@ -15,7 +15,7 @@ Does not govern:
 - Commit subject format, which shares the type vocabulary: `commit.md`
 - Pull request title and body: `pr.md`
 - Whether a phase label may appear in a branch name: `versioning.md`
-- Deriving an output filename from a branch name, which is a transform the skill running it owns
+- Deriving a slug from a branch name for use in an output filename: `slug.md`
 
 ## Format
 

package/claude/skills/git-followup/SKILL.md

@@ -24,7 +24,7 @@ its own reply, so skip the comment in step 6. The push and body sync still run.
 3. Invoke `aitk:git-commit` to generate one conventional commit from the staged diff
 4. Run `git push` to the tracking branch
 5. Check for existing review comments: `gh api 'repos/{owner}/{repo}/pulls/<number>/comments' --jq 'length'`, resolving `<number>` from `gh pr view --json number`.
-6. When invoked with `reply-owned`, skip this step's comment: the caller posts the reply. Otherwise, if the count is above zero, the followup addresses review feedback: post a one-line summary of the fix with `gh pr comment --body`, first running the pre-publish scan in `.claude/standards/prose.md` against it, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the project does not have it, since the hook does not see an inline comment body. If it is zero, run `gh pr view --json url,title,body` and update the body with `gh pr edit --body` when the new commit changes scope, and the title with `gh pr edit --title` when the scope shifted enough to make it inaccurate.
+6. When invoked with `reply-owned`, skip this step's comment: the caller posts the reply. Otherwise, if the count is above zero, the followup addresses review feedback: post a one-line summary of the fix with `gh pr comment --body`, first running the scan in `.claude/standards/publish.md` against it, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when the project does not have it, since the hook does not see an inline comment body. If it is zero, run `gh pr view --json url,title,body` and update the body with `gh pr edit --body` when the new commit changes scope, and the title with `gh pr edit --title` when the scope shifted enough to make it inaccurate.
 
 ## After completion
 

package/claude/skills/git-issue/SKILL.md

@@ -40,7 +40,7 @@ After outputting the preview, execute the final command immediately. Claude Code
 
 ### Pre-publish scan
 
-Before running the final command, run the pre-publish scan in `.claude/standards/prose.md` against the title and body, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the project does not have it. The title and body go straight to the remote with nothing checking them on the way, so this scan is the only gate. It covers the phase-label check as well as the characters, since both go to a reader who has no task board. It applies on top of the banned phrases in `${CLAUDE_SKILL_DIR}/references/issue.md`.
+Before running the final command, run the scan in `.claude/standards/publish.md` against the title and body, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when the project does not have it. The title and body go straight to the remote with nothing checking them on the way, so this scan is the only gate. It covers the phase-label check as well as the characters, since both go to a reader who has no task board. It applies on top of the banned phrases in `${CLAUDE_SKILL_DIR}/references/issue.md`.
 
 ### Final command
 

package/claude/skills/git-pr/SKILL.md

@@ -69,7 +69,7 @@ Leave a box unchecked only for the human-only cases the reference defines, and n
 
 ### Pre-publish scan
 
-Before running the final command, run the pre-publish scan in `.claude/standards/prose.md` against the PR title and body, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the project does not have it. The title and body go straight to the remote with nothing checking them on the way, so this scan is the only gate. It covers the phase-label check as well as the characters, since both go to a reader who has no task board. It applies on top of the banned phrases in `${CLAUDE_SKILL_DIR}/references/pr.md`.
+Before running the final command, run the scan in `.claude/standards/publish.md` against the PR title and body, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when the project does not have it. The title and body go straight to the remote with nothing checking them on the way, so this scan is the only gate. It covers the phase-label check as well as the characters, since both go to a reader who has no task board. It applies on top of the banned phrases in `${CLAUDE_SKILL_DIR}/references/pr.md`.
 
 ### Final command
 

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

@@ -15,7 +15,7 @@ Does not govern:
 - Commit subject format, which shares the type vocabulary: `commit.md`
 - Pull request title and body: `pr.md`
 - Whether a phase label may appear in a branch name: `versioning.md`
-- Deriving an output filename from a branch name, which is a transform the skill running it owns
+- Deriving a slug from a branch name for use in an output filename: `slug.md`
 
 ## Format
 

package/claude/skills/git-split/SKILL.md

@@ -69,7 +69,7 @@ If Mode is Independent, append this line to the preview:
 
 After outputting the preview, execute the final commands immediately. Claude Code's tool permission dialog is the confirmation gate. Do not wait for user input.
 
-Before running them, run the pre-publish scan in `.claude/standards/prose.md` against every title and body, or `${CLAUDE_SKILL_DIR}/../../standards/prose.md` when the project does not have it. Each body stages under `.claude/.tmp/` and leaves through `gh`, so the hook sees neither and this scan is the only gate.
+Before running them, run the scan in `.claude/standards/publish.md` against every title and body, or `${CLAUDE_SKILL_DIR}/../../standards/publish.md` when the project does not have it. Each body stages under `.claude/.tmp/` and leaves through `gh`, so the hook sees neither and this scan is the only gate.
 
 ### Final commands
 

package/claude/skills/git-split/references/branch.md

@@ -15,7 +15,7 @@ Does not govern:
 - Commit subject format, which shares the type vocabulary: `commit.md`
 - Pull request title and body: `pr.md`
 - Whether a phase label may appear in a branch name: `versioning.md`
-- Deriving an output filename from a branch name, which is a transform the skill running it owns
+- Deriving a slug from a branch name for use in an output filename: `slug.md`
 
 ## Format
 

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

@@ -63,7 +63,7 @@ Before executing, output:
 
 ## Execute
 
-Run the chain in order. Each step's permission dialog is the confirmation gate. Run from the target project's current directory.
+Run the chain in order, starting immediately after the preview. Each step's permission dialog is the confirmation gate. Do not pause for additional confirmation. Run from the target project's current directory.
 
 Step 1: `aitk init` installs base tooling, claude seeds, governance rules, standards, snippets, and wiki.
 

package/docs/agents.md

@@ -163,8 +163,16 @@ matches what the toolkit installed, `customized` when the project edited it,
 when the project authored it, or `drifted` when no stamp covers it. Use `--json`
 for the machine-readable report and `--exit-code` to fail a CI job. Orphaned
 files are excluded from that exit code, since a project-authored rule never
-converges. Attribution needs `.claude/aitk.json`, which every install and sync
-writes. Without it, every difference reports as `drifted`.
+converges. Attribution reads `.claude/aitk.json`, which every install and sync
+writes.
+
+A target installed before stamping shipped has no such file, and the report
+falls back to the toolkit's own git history. Installed content matching any
+version that history ever published proves the file is untouched, so it reports
+`stale` naming the commit it came from, and content matching no published
+version stays `drifted`. A toolkit reached outside a git clone, which is what a
+registry install is, cannot run that fallback and reports
+`historyUnavailable` alongside the unattributed files.
 
 Each domain carries its own toolkit anchor in that file, so syncing one domain
 never advances the revision another measures from, and each reports the upstream
@@ -238,7 +246,7 @@ The record carries every scenario with the arms that declare, plus `totalScenari
 
 `--skills` answers what the scenario count cannot, which is whether anything can fail a given skill. It adds `skills`, `totalSkills`, `asserted`, `shouldBeAsserted`, `exempt`, `staleExemptions`, and `supersededExemptions` to the record, and keeps the scenario view rather than replacing it. The two denominators disagree on purpose: an armed scenario under `infra/` or `tooling/` exercises a CLI domain and pairs with no skill at all.
 
-A skill pairs to a scenario by filename, `<category>-<command>` first and bare `<command>` second, so `claude/setup-init.sh` reaches the `setup-init` skill. `should-be-asserted` is the default and is the work queue for writing arms. `exempt` means no arm should be written and holds only with a reason, declared in `scripts/sandbox/exempt.toml` and limited to a harness limit the checker cannot reach past or a skill that writes no artifact. An armed arm outranks an exemption. An exemption naming no shipped skill, or naming one an arm now asserts, exits 1 without `--strict`. Each armed arm reports as `<category>:<command>/<arm>`, so two same-named arms under different scenarios stay distinct.
+A skill pairs to a scenario by filename, `<category>-<command>` first and bare `<command>` second, so `claude/setup-init.sh` reaches the `setup-init` skill. `should-be-asserted` is the default rather than a queue to drain, and which of those skills earns an arm is a project decision the census does not make. `exempt` means no arm should be written and holds only with a reason, declared in `scripts/sandbox/exempt.toml` and limited to a harness limit the checker cannot reach past or a skill that writes no artifact. An armed arm outranks an exemption. An exemption naming no shipped skill, or naming one an arm now asserts, exits 1 without `--strict`. Each armed arm reports as `<category>:<command>/<arm>`, so two same-named arms under different scenarios stay distinct.
 
 `scripts/sandbox/run.sh` calls this after a headless run and merges the verdict into the envelope it prints. It also writes that merged record to `.claude/.tmp/sandbox-runs/<target>-<arm>-<timestamp>.json` with a `writes` array appended, and logs the path on stderr. Both fields are what a later re-score needs, since `--envelope` and `--writes` read files the run deletes on exit. Stdout carries the same bytes it did before the record existed.
 
@@ -403,7 +411,7 @@ Use these to discover what's available instead of hardcoding names.
 | ------------------------------- | -------------------------------------------- |
 | `aitk tooling list --json`      | Stacks, extends chain, dep and script counts |
 | `aitk snippets list --json`     | Presets and categories with their slugs      |
-| `aitk standards list --json`    | Standards docs                               |
+| `aitk standards list --json`    | Standards docs and the paths each governs    |
 | `aitk gov list --json`          | Governance stacks and rule sets              |
 | `aitk claude seeds list --json` | Seed doc sources with content                |
 | `aitk docs list --json`         | Consumer docs plus per-domain context        |
@@ -412,6 +420,14 @@ Every catalog serializes through `JSON.stringify`, so a name carrying a quote
 emits valid JSON. `aitk tooling list` and `aitk snippets list` previously built
 their output with `printf` and no escaping.
 
+`aitk standards list` carries `appliesTo` per standard, the paths that standard's
+`## Scope` statement declares. It holds the backticked paths from the first
+sentence of the statement, the single entry `*` for a standard governing an
+attribute rather than a document type, and an empty array when the statement
+declares nothing a parser can read. A consumer mapping a file to its governing
+standards reads this rather than holding a table of its own, and reports an empty
+array rather than skipping the standard behind it.
+
 `aitk claude seeds list` reads the same plan `aitk claude init` applies, so the
 listing and the install cannot disagree. It now reports
 `.claude/context/index.md`, which `init` has always installed and the listing

package/docs/target-projects.md

@@ -77,7 +77,7 @@ Run `aitk tooling list --json` and `aitk gov list --json` to see the current cat
 `governance`, `standards`, and `wiki` are skippable:
 
 - `--skip governance`: leave `.claude/rules/` empty. Standards still install, so `.claude/standards/prose.md` lands with nothing pointing at it and no coding standard loads on a file match. The preview names any `--add` rules the skip drops, and the run prints the `aitk gov install <stack> <path>` command to add rules afterward, carrying those extras so one paste restores what the skip declined.
-- `--skip standards`: leave standards out. The governance rules still reference `.claude/standards/`, so their authority lines resolve to nothing. Toolkit skills are unaffected, since each falls back to the copy in its own plugin root. That fallback now carries runtime behavior rather than reference prose alone, because the pre-publish scan and the branch-slug transform are defined in the standards and cited by the skills that run them.
+- `--skip standards`: leave standards out. The governance rules still reference `.claude/standards/`, so their authority lines resolve to nothing. Toolkit skills are unaffected, since each falls back to the copy in its own plugin root. That fallback now carries runtime behavior rather than reference prose alone, because the pre-publish scan and the branch-slug transform each have a standard of their own, `publish.md` and `slug.md`, cited by the skills that run them.
 - `--skip wiki`: skip the `.claude/wiki/` scaffold. A target that already carries a root `wiki/` keeps it, since the verb reports that folder rather than migrating it.
 
 ## Add a domain later
@@ -100,7 +100,9 @@ When the toolkit updates, target projects pull changes per domain. There is one
 
 `aitk sync --check <path>` reports what has drifted without writing anything. It splits each difference by cause, which is the question that decides what to do next. A `stale` file still matches what the toolkit installed, so the update is mechanical. A `customized` file carries local edits, so taking the upstream version is a decision and `aitk:claude-seed-sync` is the tool for it. A `stranded` file sits where an older toolkit installed it and the toolkit has since moved, which is what `aitk:migration-standards` handles.
 
-That attribution comes from `.claude/aitk.json`, a stamp every install and sync writes recording a hash per installed file. Each domain holds its own toolkit commit, so syncing governance today does not move the revision standards measures against, and each domain reports the upstream commits touching its own source path. A project that has never synced under a toolkit new enough to write a stamp reports every difference as `drifted`, the unattributed verdict. Running any sync stamps that domain, and the report names the ones still unstamped.
+That attribution comes from `.claude/aitk.json`, a stamp every install and sync writes recording a hash per installed file. Each domain holds its own toolkit commit, so syncing governance today does not move the revision standards measures against, and each domain reports the upstream commits touching its own source path. Running any sync stamps that domain, and the report names the ones still unstamped.
+
+A project that has never synced under a toolkit new enough to write a stamp falls back to the toolkit's own git history. Installed content matching any version that history published proves the file untouched, so it reports `stale` naming the commit it came from, and content matching no published version stays `drifted`. That fallback needs the toolkit as a git checkout. Installed from the registry it ships source without history, and the report says attribution was unavailable rather than reading every file as a local edit.
 
 Add `--json` for the machine-readable report, and `--exit-code` to fail a CI job when a target falls behind. Files the project authored itself never count toward that exit code.
 
@@ -110,7 +112,7 @@ Tooling is not covered by the stamp. Reconcile those configs with `aitk tooling
 
 `aitk sync <path>` runs every installed domain's sync in sequence. Safe to run on a cadence. It never touches user-owned seed files. Governance rules in `.claude/rules/`, tooling configs, and reference docs refresh in place. Stale `.claude/GOV.md` from earlier installs is removed.
 
-Standards are the exception inside that run, and the stamp narrows it. A standard the project customized is reported and left alone rather than overwritten. A standard still matching what was installed carries no local edits to lose, so a headless run updates it. On an unstamped project the old blanket rule holds and every drifted standard is left alone. To take the upstream version of a customized file, run `aitk standards sync <path>` interactively, or use `aitk:claude-seed-sync` below to merge section by section.
+Standards are the exception inside that run, and the stamp narrows it. A standard the project customized is reported and left alone rather than overwritten. A standard still matching what was installed carries no local edits to lose, so a headless run updates it. An unstamped project reaches the same split through the history fallback, so a headless run updates every standard it can prove untouched and refuses while any file resists attribution. To take the upstream version of a customized file, run `aitk standards sync <path>` interactively, or use `aitk:claude-seed-sync` below to merge section by section.
 
 ### Targeted
 

package/package.json

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

package/scripts/standards/list.sh

@@ -28,6 +28,26 @@ json_escape() {
   printf '%s' "$s"
 }
 
+# Emits the paths a standard's `## Scope` statement declares, as a JSON array.
+# The declaration is prose, so the contract is narrow on purpose: backticked
+# paths in the first sentence of the statement, or `*` for an attribute standard,
+# which names no path and says so in the same statement. An empty array means the
+# statement did not parse, which consumers report rather than skip.
+read_applies_to() {
+  local file="$1"
+  local scope first paths
+
+  scope=$(awk '/^## Scope[[:space:]]*$/ {found = 1; next} found && NF {print; exit}' "$file")
+  first="${scope%%. *}"
+  paths=$(printf '%s' "$first" | grep -o '`[^`]*`' | tr -d '`' || true)
+
+  if [ -z "$paths" ] && [[ "$scope" == *"attribute standard"* ]]; then
+    paths="*"
+  fi
+
+  printf '%s\n' "$paths" | jq -Rnc '[inputs | select(length > 0)]'
+}
+
 list_text() {
   log_step "Standards"
   local file name title
@@ -41,13 +61,14 @@ list_text() {
 
 list_json() {
   local first=1
-  local file name title target
+  local file name title target applies_to
   printf '['
   while IFS= read -r file; do
     name=$(basename "$file" .md)
     [ "$name" = "index" ] && continue
     title=$(read_frontmatter_field "$file" "description")
     target=".claude/standards/$(basename "$file")"
+    applies_to=$(read_applies_to "$file")
     if [ "$first" -eq 0 ]; then
       printf ','
     fi
@@ -55,8 +76,9 @@ list_json() {
       --arg name "$name" \
       --arg description "$title" \
       --arg target "$target" \
+      --argjson appliesTo "$applies_to" \
       --rawfile content "$file" \
-      '{name: $name, description: $description, target: $target, content: $content}'
+      '{name: $name, description: $description, target: $target, appliesTo: $appliesTo, content: $content}'
     first=0
   done < <(find "$STANDARDS_DIR" -maxdepth 1 -type f -name "*.md" | sort)
   printf ']'

package/src/commands/sync.ts

@@ -99,7 +99,11 @@ function renderCheck(report: CheckReport): void {
     logStep(domain.domain)
 
     if (domain.commit === undefined) {
-      logWarn('Not stamped. Drift below is reported unattributed.')
+      logWarn(
+        domain.historyUnavailable
+          ? 'Not stamped, and this toolkit has no git history. Drift below is reported unattributed.'
+          : 'Not stamped. Drift below is attributed from toolkit history.',
+      )
     } else {
       logInfo(`Synced from ${domain.commit} on ${domain.syncedAt}`)
     }

package/src/sync/check.ts

@@ -54,6 +54,11 @@ export interface DomainReport {
   readonly counts: StateCounts
   readonly entries: readonly ScanEntry[]
   readonly upstream: readonly UpstreamCommit[]
+  /**
+   * Separates a toolkit that could not attribute from one that attributed and
+   * found a local edit. Only the first is a capability the install lacks.
+   */
+  readonly historyUnavailable: boolean
 }
 
 export interface UpstreamCommit {
@@ -145,6 +150,7 @@ async function buildDomainReport(
     syncedAt: record?.syncedAt,
     counts: countStates(plan.entries),
     entries: plan.entries,
+    historyUnavailable: plan.historyUnavailable,
     upstream:
       since === undefined
         ? []

package/src/sync/engine.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import { rm } from 'node:fs/promises'
 import { isAbsolute, relative, resolve } from 'node:path'
 import { copyPreservingMode } from '@/copy'
+import { findInstalledOrigin, readHistoryIndex } from '@/sync/history'
 import {
   type DomainHashes,
   hashFile,
@@ -74,12 +75,16 @@ export type EntryState =
 export interface ScanEntry {
   readonly state: EntryState
   readonly rel: string
+  /** Toolkit revision this file's content came from, when history proved it. */
+  readonly since?: string
 }
 
 export interface SyncPlan {
   readonly entries: readonly ScanEntry[]
   readonly retired: readonly RetiredSurface[]
   readonly changes: readonly SyncChange[]
+  /** Set when a file needed history to attribute it and this toolkit has none. */
+  readonly historyUnavailable: boolean
 }
 
 /**
@@ -156,6 +161,7 @@ export function listInstalled(root: string, target: string): InstalledFile[] {
 export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
   const entries: ScanEntry[] = []
   const changes: SyncChange[] = []
+  const unattributed: UnattributedFile[] = []
 
   const hashes = stampedHashes(readStamp(target), adapter.stamp?.domain)
   const walked = new Set<string>()
@@ -176,7 +182,12 @@ export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
       continue
     }
 
-    entries.push({ state: attribute(hashes, file), rel: file.rel })
+    const state = attribute(hashes, file)
+    if (state === 'drifted') {
+      unattributed.push({ index: entries.length, source, path: file.path })
+    }
+
+    entries.push({ state, rel: file.rel })
     changes.push({
       kind: 'copy',
       source,
@@ -185,6 +196,8 @@ export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
     })
   }
 
+  const historyUnavailable = recoverAttribution(adapter, entries, unattributed)
+
   entries.push(...strandedByRelocation(target, hashes, walked))
 
   const retired = adapter.collectRetired?.(target) ?? []
@@ -192,7 +205,53 @@ export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
     changes.push({ kind: 'delete', dest: surface.path, rel: surface.rel })
   }
 
-  return { entries, retired, changes }
+  return { entries, retired, changes, historyUnavailable }
+}
+
+interface UnattributedFile {
+  readonly index: number
+  readonly source: string
+  readonly path: string
+}
+
+/**
+ * Second pass over the files the stamp could not attribute, which is every file
+ * in a target installed before stamping shipped. Matching the installed content
+ * against the toolkit's own history recovers the fact a stamp would have held,
+ * and a file matching no published version stays unattributed.
+ *
+ * Runs as one git call for the whole domain rather than one per file, and only
+ * when the first pass left something to attribute. Reports whether history was
+ * readable at all, so a registry install can say why it fell short instead of
+ * reporting every file as a local edit.
+ */
+function recoverAttribution(
+  adapter: SyncAdapter,
+  entries: ScanEntry[],
+  unattributed: readonly UnattributedFile[],
+): boolean {
+  const toolkitRoot = adapter.stamp?.toolkitRoot
+  if (toolkitRoot === undefined || unattributed.length === 0) return false
+
+  const index = readHistoryIndex(
+    toolkitRoot,
+    unattributed.map((file) => relative(toolkitRoot, file.source)),
+  )
+
+  if (index === undefined) return true
+
+  for (const file of unattributed) {
+    const since = findInstalledOrigin(
+      index,
+      relative(toolkitRoot, file.source),
+      file.path,
+    )
+
+    if (since === undefined) continue
+    entries[file.index] = { ...entries[file.index], state: 'stale', since }
+  }
+
+  return false
 }
 
 export async function applyChanges(
@@ -314,7 +373,12 @@ function report(adapter: SyncAdapter, plan: SyncPlan): void {
   for (const entry of plan.entries) {
     if (entry.state === 'matching') logInfo(entry.rel)
     else if (entry.state === 'drifted') logWarn(entry.rel)
-    else if (entry.state === 'stale') logWarn(`${entry.rel} (toolkit updated)`)
+    else if (entry.state === 'stale')
+      logWarn(
+        entry.since === undefined
+          ? `${entry.rel} (toolkit updated)`
+          : `${entry.rel} (toolkit updated since ${entry.since.slice(0, 7)})`,
+      )
     else if (entry.state === 'customized')
       logWarn(`${entry.rel} (locally customized)`)
     else if (entry.state === 'stranded')
@@ -325,6 +389,12 @@ function report(adapter: SyncAdapter, plan: SyncPlan): void {
   for (const surface of plan.retired) {
     logWarn(surface.notice)
   }
+
+  if (plan.historyUnavailable) {
+    logWarn(
+      'Attribution unavailable: this toolkit has no git history to match against.',
+    )
+  }
 }
 
 function sameContent(left: string, right: string): boolean {

package/src/sync/history.ts

@@ -0,0 +1,123 @@
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { sep } from 'node:path'
+import { execaSync } from 'execa'
+import { gitEnv } from '@/git-env'
+
+/** Blob SHA to the newest commit whose post-image for that path held it. */
+export type PathHistory = ReadonlyMap<string, string>
+
+/** Source path relative to the toolkit root, to that path's known blobs. */
+export type HistoryIndex = ReadonlyMap<string, PathHistory>
+
+const EMPTY_BLOB = '0000000000000000000000000000000000000000'
+
+/**
+ * Git's own object name for a file's contents: sha1 over `blob <len>\0` and the
+ * bytes. Computed here rather than shelled out to `git hash-object`, which would
+ * cost a process per file inside the attribution pass.
+ *
+ * A repository normalizing line endings on checkout stores a blob the working
+ * tree never holds, so this returns a name that matches no historical version.
+ * The caller treats an unmatched file as unattributed, which is the safe label.
+ */
+export function gitBlobHash(content: Buffer): string {
+  const header = Buffer.from(`blob ${content.length}\0`, 'utf8')
+  return createHash('sha1').update(header).update(content).digest('hex')
+}
+
+/**
+ * Reads `--raw` log output into blob-to-commit maps, one per path.
+ *
+ * Reverse-chronological input means the first commit naming a blob is the
+ * newest that produced it, so an existing key is never overwritten. Content
+ * reverted and restored therefore reports the recent commit rather than the
+ * original, which is the one an operator can act on.
+ */
+export function parseRawLog(output: string): HistoryIndex {
+  const index = new Map<string, Map<string, string>>()
+  let commit = ''
+
+  for (const line of output.split('\n')) {
+    if (line === '') continue
+
+    if (!line.startsWith(':')) {
+      commit = line.trim()
+      continue
+    }
+
+    const [meta, path] = line.split('\t')
+    if (path === undefined || commit === '') continue
+
+    const blob = meta.trim().split(/\s+/)[3]
+    if (blob === undefined || blob === EMPTY_BLOB) continue
+
+    const blobs = index.get(path) ?? new Map<string, string>()
+    if (!blobs.has(blob)) blobs.set(blob, commit)
+    index.set(path, blobs)
+  }
+
+  return index
+}
+
+/**
+ * Every historical version of the given toolkit-relative paths, or `undefined`
+ * when this toolkit has no history to read. A package installed from the
+ * registry ships source without `.git`, so absence is an ordinary state rather
+ * than a failure, and the caller degrades to the unattributed path.
+ *
+ * Renames are disabled so a raw line always carries exactly one path. Detection
+ * would emit a two-path form that the parser would read as an unknown blob.
+ */
+export function readHistoryIndex(
+  toolkitRoot: string,
+  paths: readonly string[],
+): HistoryIndex | undefined {
+  if (paths.length === 0) return new Map()
+
+  const result = execaSync(
+    'git',
+    [
+      '-C',
+      toolkitRoot,
+      'log',
+      '--all',
+      '--raw',
+      '--no-renames',
+      '--no-abbrev',
+      '--relative',
+      '--format=%H',
+      '--',
+      ...paths.map(toRepoPath),
+    ],
+    { reject: false, env: gitEnv(), extendEnv: false },
+  )
+
+  return result.exitCode === 0 ? parseRawLog(result.stdout) : undefined
+}
+
+/**
+ * Git prints and accepts posix separators on every platform, so a Windows
+ * caller's `relative()` output has to be converted before it can match a path
+ * the log emitted.
+ */
+function toRepoPath(path: string): string {
+  return path.split(sep).join('/')
+}
+
+/**
+ * The commit whose version of `sourceRel` matches what sits at `installedPath`.
+ * A match proves the file is untouched since it was installed, so the toolkit is
+ * what moved. No match means the content matches nothing this toolkit ever
+ * published, which is a local edit and stays unattributed.
+ */
+export function findInstalledOrigin(
+  index: HistoryIndex,
+  sourceRel: string,
+  installedPath: string,
+): string | undefined {
+  const blobs = index.get(toRepoPath(sourceRel))
+  if (blobs === undefined) return undefined
+
+  return blobs.get(gitBlobHash(readFileSync(installedPath)))
+}

package/standards/bundled/branch.md

@@ -15,7 +15,7 @@ Does not govern:
 - Commit subject format, which shares the type vocabulary: `commit.md`
 - Pull request title and body: `pr.md`
 - Whether a phase label may appear in a branch name: `versioning.md`
-- Deriving an output filename from a branch name, which is a transform the skill running it owns
+- Deriving a slug from a branch name for use in an output filename: `slug.md`
 
 ## Format
 

package/standards/index.md

@@ -12,10 +12,12 @@ Reference docs for consistent authoring across the toolkit and target projects.
 - [Design reference](design.md): Shape and content rules for .claude/DESIGN.md
 - [Diagram reference](diagrams.md): Shape and content rules for .claude/diagrams/<kind>.md files
 - [Prose reference](prose.md): Voice, structure, formatting, and language rules for reference markdown
+- [Publish reference](publish.md): Scan run against finished text leaving through a channel no automated check covers
 - [Readme reference](readme.md): Readme voice, structure, and content conventions
 - [Requirements reference](requirements.md): Shape and content rules for .claude/REQUIREMENTS.md
 - [Governance rule reference](rule.md): Rule frontmatter, body shape, and voice for .claude/rules files
 - [Claude skill reference](skill.md): Claude skill structure and authoring rules
+- [Slug reference](slug.md): Transform from a git branch name to a slug, and the three responses to an empty result
 - [Standard reference](standard.md): Shape and content rules for authoring a standard
 - [Tasks reference](tasks.md): Folder layout, filename convention, and content rules for .claude/tasks/
 - [Versioning reference](versioning.md): Phase label vs semver discipline across tasks, PRs, reviews, issues, commits, and tags

package/standards/prose.md

@@ -5,7 +5,7 @@ description: Voice, structure, formatting, and language rules for reference mark
 
 # Prose reference
 
-Applies to markdown reference docs, READMEs, and inline documentation in repos. It is the default voice for `.md` files and yields to any surface with its own voice, such as blogs, emails, changelogs, or commit messages. It also yields wherever another standard states the voice for the surface it governs, which is how a surface claims the exemption without this file having to name it. The yield covers voice alone. Punctuation, formatting, and language rules below stay in force on every surface, including the surfaces no automated check reaches, which is what the scan below is for.
+Applies to markdown reference docs, READMEs, and inline documentation in repos. It is the default voice for `.md` files and yields to any surface with its own voice, such as blogs, emails, changelogs, or commit messages. It also yields wherever another standard states the voice for the surface it governs, which is how a surface claims the exemption without this file having to name it. The yield covers voice alone. Punctuation, formatting, and language rules below stay in force on every surface, including the surfaces no automated check reaches.
 
 ## Scope
 
@@ -16,6 +16,7 @@ Does not govern:
 - What sections a document has, or what belongs in each: the standard for that document type
 - Which frontmatter fields a document carries, which is that standard's own subject. This file governs the wording of a `title` and a `description` and nothing else about them.
 - Phase-label and semver discipline: `versioning.md`
+- The scan that applies these bans to finished text on its way out: `publish.md`
 - Code style and language conventions, which are governance rules rather than a standard
 
 ## Voice
@@ -85,33 +86,6 @@ Does not govern:
 - Do not address the reader as a participant (`Let's`, `Here's`, `Here are`). State the content directly.
 - Commit to a position. Do not hedge in clusters (`It might be worth considering`) or use false balance (`While X is true, Y is also important`). Recommend, or state the tradeoff.
 
-## Pre-publish scan
-
-Wherever text leaves through a channel no automated check covers, the author is the only gate and runs this scan. Text sent to another service, written to a path the project's checks exclude, and text inside a fenced block are the usual cases. The surface that publishes the text is what knows which gap applies, so it names its own rather than reading one here.
-
-Run the scan as an explicit step against the finished text. Having read this file before drafting does not cover it, because the check has to happen after the text exists.
-
-### Banned characters
-
-Scan the drafted text and rewrite each occurrence:
-
-- `—` (em dash): split into two sentences, or use a comma
-- `;` (semicolon): split into two sentences
-
-Restructure the sentence rather than substituting the character. A semicolon swapped for a period leaves both clauses in the order the semicolon chose, which is the shape the ban exists to remove.
-
-### Phase labels
-
-The versioning standard beside this file holds the label rule and the table of surfaces. Read it at scan time rather than working the format from memory.
-
-Scope this check by destination. Text published to a remote takes it. Text scanned on its way into the repository, where the reader has the task board, takes the character checks alone.
-
-### An unreadable source
-
-Stop and name the source when one this scan reaches for cannot be read. Do not scan what resolved and report the result.
-
-A run that covers half its sources and says nothing is worse than one that visibly did not happen, because the surfaces running this scan are the ones that describe themselves as the only gate. A clean result from a half-run scan is read as coverage.
-
 ## Frontmatter descriptions
 
 When frontmatter carries a short `title` or `description` used for catalog display:

package/standards/publish.md

@@ -0,0 +1,40 @@
+---
+title: Publish reference
+description: Scan run against finished text leaving through a channel no automated check covers
+---
+
+# Publish reference
+
+## Scope
+
+Governs the scan an author runs against finished text on its way out, and the responses available when a source it reaches for cannot be read. It is an attribute standard rather than a document-type one, so it applies to any text leaving through a channel no automated check covers.
+
+Does not govern:
+
+- Which characters are banned, and the voice and formatting the text is written in: `prose.md`
+- The phase-label rule and the table of surfaces each namespace may appear on: `versioning.md`
+- Which gap a given surface has, and what it publishes through, which that surface names for itself
+
+## When it runs
+
+Wherever text leaves through a channel no automated check covers, the author is the only gate and runs this scan. Text sent to another service, written to a path the project's checks exclude, and text inside a fenced block are the usual cases. The surface that publishes the text is what knows which gap applies, so it names its own rather than reading one here.
+
+Run the scan as an explicit step against the finished text. Having read the underlying rules before drafting does not cover it, because the check has to happen after the text exists.
+
+## Banned characters
+
+`prose.md` holds the character bans. Read it at scan time rather than working them from memory, then scan the drafted text and rewrite each occurrence.
+
+Restructure the sentence rather than substituting the character. A semicolon swapped for a period leaves both clauses in the order the semicolon chose, which is the shape the ban exists to remove.
+
+## Phase labels
+
+`versioning.md` holds the label rule and the table of surfaces. Read it at scan time rather than working the format from memory.
+
+Scope this check by destination. Text published to a remote takes it. Text scanned on its way into the repository, where the reader has the task board, takes the character checks alone.
+
+## An unreadable source
+
+Stop and name the source when one this scan reaches for cannot be read. Do not scan what resolved and report the result.
+
+A run that covers half its sources and says nothing is worse than one that visibly did not happen, because the surfaces running this scan are the ones that describe themselves as the only gate. A clean result from a half-run scan is read as coverage.

package/standards/skill.md

@@ -11,13 +11,14 @@ Skills give Claude Code domain-specific constraints and rules inline, so it can
 
 ## Scope
 
-Governs a skill folder as one artifact: `SKILL.md`, its optional sibling `REQUIREMENT.md`, and the bundled `references/`, `scripts/`, and `assets/` beside them.
+Governs a skill folder under `skills/` as one artifact: `SKILL.md`, its optional sibling `REQUIREMENT.md`, and the bundled reference, script, and asset folders beside them.
 
 Does not govern:
 
 - Path-scoped coding rules, which load on a file match rather than on a request match: `rule.md`
 - Single-purpose chat prompts carrying no frontmatter, references, or scripts: `snippets.md`
 - Voice, punctuation, and formatting in a skill body: `prose.md`
+- The transform from a branch name to a slug a skill carries in a filename: `slug.md`
 - The domain conventions a skill cites, each of which belongs to the standard that owns it
 
 ## Skill types
@@ -184,18 +185,6 @@ Without this skill, a session <observed failure>, <observed failure>.
 - When a skill gathers user input or pre-seeds a template, attach a concrete proposed default to every question, derived from project context. Accept "use defaults" as a bulk-confirm.
 - Separate correctness axes (routing, sourcing, escalation, decline) from shape axes (line count, formatting, variant sprawl) when tuning a skill. Tighten only on correctness regressions. Do not convert soft caps to hard caps for aesthetic drift when correctness passes.
 
-### Deriving the branch slug
-
-Run `git branch --show-current` and replace every `/` with `-`. The result is `<slug>`. Anything reading a branch-derived name uses this transform, so two skills cannot spell it differently.
-
-A skill that persists output under `.claude/` carries the slug in the filename, which is what keeps parallel worktrees from overwriting each other's output.
-
-The empty result is a detached HEAD, and the skill picks one of three responses rather than inheriting a default. State the choice in the body, since the transform is shared and this is not.
-
-- Fall back to `latest`, so a read-only pass still writes somewhere predictable
-- Stop, when the skill commits or opens a pull request. There is no branch to put the work on, so `latest` would bury the problem instead of reporting it. State the stop in the skill's guards.
-- Fall through to the next source, when the slug is one candidate among several rather than the name of an output file
-
 ## Scripts
 
 - Use `scripts/` for operations that must be deterministic or repetitive

package/standards/slug.md

@@ -0,0 +1,29 @@
+---
+title: Slug reference
+description: Transform from a git branch name to a slug, and the three responses to an empty result
+---
+
+# Slug reference
+
+## Scope
+
+Governs the transform from a git branch name to the slug a surface carries in a derived name, and the responses available when the transform returns empty. It is an attribute standard rather than a document-type one, so it applies wherever a branch-derived name is produced.
+
+Does not govern:
+
+- The format of the branch name the transform reads: `branch.md`
+- Where a surface writes what it names with the slug, and what goes in it, which is that surface's own subject
+
+## The transform
+
+Run `git branch --show-current` and replace every `/` with `-`. The result is `<slug>`. Anything reading a branch-derived name uses this transform, so two surfaces cannot spell it differently.
+
+A surface that persists output to a shared folder carries the slug in the filename, which is what keeps parallel worktrees from overwriting each other's output.
+
+## An empty result
+
+The empty result is a detached HEAD, and the surface picks one of three responses rather than inheriting a default. State the choice where the transform is cited, since the transform is shared and this is not.
+
+- Fall back to `latest`, so a read-only pass still writes somewhere predictable
+- Stop, when the surface commits or opens a pull request. There is no branch to put the work on, so `latest` would bury the problem instead of reporting it. State the stop in the surface's guards.
+- Fall through to the next source, when the slug is one candidate among several rather than the name of an output file

package/standards/standard.md

@@ -13,7 +13,7 @@ A standard is a target-facing authoring convention for one document type, or for
 
 ## Scope
 
-Governs what an authored standard contains: its stated jurisdiction, success criterion, frontmatter, structure, and rule phrasing.
+Governs each authored standard under `standards/`: its stated jurisdiction, success criterion, frontmatter, structure, and rule phrasing.
 
 Does not govern:
 
@@ -38,6 +38,8 @@ A standard failing these questions is non-conforming even when it satisfies ever
 - Govern one document type per standard, or one attribute across every document. Split unrelated conventions into separate files.
 - Open with a `## Scope` section stating what the standard governs and what it does not, placed above the shape rules. A standard that specifies shape exhaustively and jurisdiction nowhere cannot refuse a rule, so the rule with no obvious owner lands in whichever standard sits nearest.
 - Write it as one line naming the artifact or attribute and where it applies, then a `Does not govern:` list. Give each entry the excluded concern and the owner it goes to. Name a sibling standard by bare filename, since standards install as siblings, and name the surface instead where the owner is one, such as a coding rule, a project policy, or the code.
+- Put the governed path in backticks inside the first sentence of that line, anchored deep enough to resolve from a project root. A bare folder name matches a same-named folder elsewhere in the tree, and a path held back until a later sentence sits beside every other path the statement mentions, including the ones it excludes.
+- Say in that same sentence when the standard governs an attribute rather than a document type. An attribute is written across every document and has no path to name, so the silence reads as an omission unless the sentence claims it.
 - Cut an entry that names no owner at all. It is either excluding something nothing was going to claim, or it is a content exclusion, which the rule below sends to the shape rules instead.
 - Declare a boundary from both sides. A yield, an exemption, or a handoff stated in one standard alone is never checked against the standard on the other side of it, which is how two files come to claim the same rule or neither does.
 - Separate a jurisdiction exclusion from a content exclusion. The first names a concern another standard owns and belongs in `## Scope`. The second names what does not belong inside the document and stays with the shape rules. Merging them puts a boundary claim where no sibling will read it.