@erclx/aitk 3.37.1 → 3.38.1

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

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

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

@@ -88,7 +88,7 @@ Behavior paths carry two spellings, the one a surface authors at and the one it
 
 - `claude/skills/` and `.claude/skills/`
 - `governance/rules/` and `.claude/rules/`
-- `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
+- `standards/`, which is the authoring root and reaches a reader by resolution rather than by an install, so it carries no `.claude/` spelling
 - `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-intake/SKILL.md

@@ -77,7 +77,7 @@ Where an item's call is the operator's, pair it with a suggestion rather than a
 
 ## Step 6: write the index
 
-Write `00-overview.md` last, once the clusters are filed and the counts are real. It carries the format block, the cluster table, the verdict counts, the ready list, and the open questions.
+Write `00-overview.md` last, once the clusters are filed and the counts are real. It carries the cluster table, the verdict counts, the ready list, and the open questions.
 
 Each open question in the index is a labeled markdown link to its owning item's heading anchor. The index points and the item owns, so no answer slot appears in the index. One question in two answerable places has no rule for which wins, and retrieval walks item headings, so an answer typed into the index is found by nothing and lost silently.
 

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

@@ -9,7 +9,7 @@ description: Why a standard needs its shape read from the meta-standard before a
 
 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 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.
+The second write surface is the second failure. A standard put under `.claude/standards/` looks like a correct file and reaches no resolver, since nothing installs the corpus into a project and no repository generates a copy there. 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 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.
 
@@ -19,13 +19,13 @@ A standard written and left there is the third. The index entry and the context
 - 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 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
+- State what the write implies for whoever owns the folder, since a toolkit standard needs 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
-- Write into `.claude/standards/`, which is this repository's generated mirror and reaches no resolver
+- Write into `.claude/standards/`, which no repository generates and no resolver reads
 
 ## Out of scope
 

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

@@ -9,7 +9,7 @@ What each finding from `aitk context audit` means. The command surface, its flag
 
 ## Required sections
 
-The required-section check reports what does not declare `## Overview` and `## Layout`, the two sections `.claude/standards/context.md` marks required. The list is held in code beside the numeric checkpoints rather than parsed out of the standard, so it fails on a defect rather than on a rewrite of the wording around it. A heading at any level counts, because a domain that split into a folder carries its overview in a sibling named `overview.md` where the section is the `#` title and an `##` beneath it would repeat the filename. Matching exactly is what keeps `## Layout catalog` from satisfying `Layout`.
+The required-section check reports what does not declare `## Overview` and `## Layout`, the two sections `standards/context.md` marks required. The list is held in code beside the numeric checkpoints rather than parsed out of the standard, so it fails on a defect rather than on a rewrite of the wording around it. A heading at any level counts, because a domain that split into a folder carries its overview in a sibling named `overview.md` where the section is the `#` title and an `##` beneath it would repeat the filename. Matching exactly is what keeps `## Layout catalog` from satisfying `Layout`.
 
 Which unit answers depends on the folder. Entries of the folder named under `.claude/` are one domain each, so each answers for itself and a finding names the entry. Entries of a folder a domain split into describe that one domain between them, so any sibling answers and a finding names the folder. Holding a split folder to the rule per file would report every child beside its `overview.md`, and rolling the named folder up would let one conforming entry stand in for every other domain sitting next to it.
 
@@ -19,7 +19,7 @@ It reports rather than gates by default, the closer call because a missing secti
 
 ## Reference form
 
-The reference-form check reports an entry naming a sibling entry by bare filename where `.claude/standards/context.md` asks for the path it sits at. A bare name resolves against whichever folder its reader is already in, so a domain that splits into subfolders strands every inbound reference and the break surfaces nowhere. A path is checkable, which is what makes the form rule worth measuring at all: once a reference spells its path, the citation gate resolves it and a split that moves the file fails the push.
+The reference-form check reports an entry naming a sibling entry by bare filename where `standards/context.md` asks for the path it sits at. A bare name resolves against whichever folder its reader is already in, so a domain that splits into subfolders strands every inbound reference and the break surfaces nowhere. A path is checkable, which is what makes the form rule worth measuring at all: once a reference spells its path, the citation gate resolves it and a split that moves the file fails the push.
 
 A finding is a backticked filename carrying no folder, matched against the entries beside the one that wrote it. The backticks are required, since a filename in running prose is not a reference a reader follows.
 
@@ -33,7 +33,7 @@ It reports and never gates, which is the split the citation check already draws.
 
 ## Length
 
-Length quotes its checkpoint from `.claude/standards/context.md`: roughly 150 rendered lines for an entry, applied to each of the 60 entries the audit measures, 51 of them under `.claude/context/` and 9 diagram files beside them. It counts rendered lines rather than source lines, wrapping each line at 80 columns and summing the heights.
+Length quotes its checkpoint from `standards/context.md`: roughly 150 rendered lines for an entry, applied to each of the 60 entries the audit measures, 51 of them under `.claude/context/` and 9 diagram files beside them. It counts rendered lines rather than source lines, wrapping each line at 80 columns and summing the heights.
 
 A line is wrapped at the width it renders at, so a link counts as its anchor text and a backticked path counts whole, which parts the rendered count from a source count wherever an entry cites a path in backticks rather than as a link. Entries here are authored one line per bullet, so a block of fifteen paragraph-bullets occupies fifteen source lines and renders past sixty, which source counting cannot see.
 
@@ -45,7 +45,7 @@ Only the third is mechanical, and it is the provenance check already reported be
 
 It reports and never gates, which the standard settles rather than the usual judgment-against-fact line: there is no hard cap, so an entry that answers all three and is still long is a correct outcome. The JSON record carries the joined findings as `length`, each with a `causes` array in the standard's order, and the jurisdiction the join reads as `entries[].governed`. That flag is what parts a provenance list measured and empty from one never scanned, which the count alone cannot say. The join is published rather than left to a consumer, since deriving it means restating which question the provenance count answers.
 
-Depth and bullet weight are quoted from `.claude/standards/markdown.md`, which states both over every markdown file rather than over a context entry, so `aitk markdown audit` measures them and this command no longer does. They share `renderedHeight` with the length measure, since the two checkpoints sit in one section of that standard and a reader compares them. What the split costs is that a session wanting both numbers for one entry runs two commands, and what it buys is that either number can be had for a file in a folder this audit refuses to resolve.
+Depth and bullet weight are quoted from `standards/markdown.md`, which states both over every markdown file rather than over a context entry, so `aitk markdown audit` measures them and this command no longer does. They share `renderedHeight` with the length measure, since the two checkpoints sit in one section of that standard and a reader compares them. What the split costs is that a session wanting both numbers for one entry runs two commands, and what it buys is that either number can be had for a file in a folder this audit refuses to resolve.
 
 ## Tables
 
@@ -63,7 +63,7 @@ Fenced blocks are excluded, which keeps a pinned version in an install command f
 
 ## Narration
 
-The narration check reports a bullet that states the design a sibling bullet replaced instead of rewriting it. `.claude/standards/context.md` asks for the rewrite because the subject is still live and two bullets on one subject leave a reader to work out which of them is current, and no other measure sees that shape.
+The narration check reports a bullet that states the design a sibling bullet replaced instead of rewriting it. `standards/context.md` asks for the rewrite because the subject is still live and two bullets on one subject leave a reader to work out which of them is current, and no other measure sees that shape.
 
 It reads structure rather than words, which the corpus decided. Measured across the 39 entries this toolkit held the day it shipped, the terms carrying clean signal for a supersession are too rare to catch anything: `superseded` appears twice, `previously` three times, and `formerly`, `originally`, and `at first` never. The one term that would have caught the case a review caught by hand is `now`, which appears 57 times across 24 entries in correct present-tense prose. A list including it reports 57 lines to catch one, and a list excluding it reports nothing.
 
@@ -101,13 +101,13 @@ The coverage report classifies each decision as carrying a countable claim, a st
 
 Three limits are stated on every run rather than hidden. The countable signal reads digits alone, so a measured claim written in words reads as uncounted. Entries are counted by heading, and one heading holding several decisions counts once. Nothing is stored, so an entry rewritten tomorrow is classified afresh the next time the verb runs and no verdict goes stale.
 
-The report gates nothing. Deciding whether a sentence states a claim is a judgment no parser settles, so the output names candidates for a reader. This answers a different question from the verification anchors `.claude/standards/architecture.md` describes, which record that one cited number was re-read. That mechanism says whether a marked figure held, and this one says how much of the record could be checked at all.
+The report gates nothing. Deciding whether a sentence states a claim is a judgment no parser settles, so the output names candidates for a reader. This answers a different question from the verification anchors `standards/architecture.md` describes, which record that one cited number was re-read. That mechanism says whether a marked figure held, and this one says how much of the record could be checked at all.
 
 ## Which folders each check reaches
 
 The provenance, required-section, and narration checks cover `.claude/context/` alone, the reference-form check covers the split folders inside it, and length and the table finding reach every audited folder.
 
-What narrows the three is stated in `.claude/standards/context.md`, which opens its scope by handing diagrams and wireframes to `diagrams.md` and `wireframes.md`, and the sibling standards do not restate it. A marker reported in a diagram entry would cite a rule that entry's own standard routes elsewhere, and a diagram entry carries a heading per kind rather than a run of bullets deciding anything. The split is between kinds of rule rather than kinds of folder, and what decides it is which tier states the rule rather than what the check measures.
+What narrows the three is stated in `standards/context.md`, which opens its scope by handing diagrams and wireframes to `diagrams.md` and `wireframes.md`, and the sibling standards do not restate it. A marker reported in a diagram entry would cite a rule that entry's own standard routes elsewhere, and a diagram entry carries a heading per kind rather than a run of bullets deciding anything. The split is between kinds of rule rather than kinds of folder, and what decides it is which tier states the rule rather than what the check measures.
 
 Length and the table finding generalize as judgments about how far a reader travels, so both reach wherever the audit is pointed. Required sections narrow for a plainer reason: the names are the context standard's own, and neither sibling standard states a required section at all.
 

package/docs/agents/counts.md

@@ -35,12 +35,18 @@ The set is closed rather than derived, so widening it is a deliberate change to
 
 ## How a match is decided
 
-A sentence has to carry an assertion verb (`loads`, `ships`, `carries`, `holds`, `counts`, `totals`, `documents`, `declares`, `installs`, `lists`, `contains`, `comprises`) or an article (`the`, `a`, `an`) immediately ahead of the number, which is immediately ahead of the catalog noun, with one optional qualifying word between the number and the noun (`sixty-one shipped skills`). The number reads either as digits or as a spelled-out cardinal through ninety-nine, since this corpus states a catalog size in words as often as in digits.
+A sentence has to carry an assertion verb (`loads`, `ships`, `carries`, `holds`, `counts`, `totals`, `documents`, `declares`, `installs`, `lists`, `contains`, `comprises`, `authors`), the quantifier `all`, or an article (`the`, `a`, `an`) immediately ahead of the number, which is immediately ahead of the catalog noun, with one optional qualifying word between the number and the noun (`sixty-one shipped skills`). The number reads either as digits or as a spelled-out cardinal through ninety-nine, since this corpus states a catalog size in words as often as in digits.
+
+Nothing stands between the trigger and the number, which is the rule an author writing a new count has to know. It separates `the toolkit authors 69 rules` and `took all 69 rules`, both read, from `a domain of 55 skills` and `denominator of sixty-one shipped skills`, neither of them read. A figure meant as a past state takes a date in the same sentence instead, which reads the sentence past whatever its shape.
+
+## How the trigger set grew
 
 The verb gate is not the first design tried. A bare number next to a catalog noun anywhere in the tracked corpus returned 290 findings against a repository whose actionable instance count was one. Reading that run showed why: `18 rules citing a standard`, `21 skill bodies`, and `eight internal skills` all pair a number with a catalog noun while naming a subset, an example, or a different catalog than the one matched, and that shape dominates ordinary prose. Every instance this sweep was written against reads the number as the direct object of a verb asserting the catalog's own total, and gating on that verb is what took the false-positive count from 290 to five on the same tree.
 
 The article half was added after a first review of the shipped design found a live miss: `.claude/context/development/gates.md` stated a stale audit total while the tree held 20, and the verb gate never reached it, since that sentence puts its verb after the noun rather than ahead of the number. Widening the trigger set to admit an article ahead of the number closed that gap.
 
+The quantifier `all` and the verb `authors` joined on the same evidence, two more live misses failing only the trigger test. Allowing words to stand between the trigger and the number was the other candidate, measured and declined: at widths of one, two, and three it reached 77, 104, and 132 sentences against a baseline of 65, missed `took all 69 rules` at every width, and reached `the toolkit authors 69 rules` only at a width admitting the indirect-noun shape below. The two words reach both at 75 sentences and no false positive.
+
 ## The plausibility filter
 
 The verb gate alone still left four false positives standing: `carries two rules about a standard's own lifecycle`, `holds one rule or one fact` (twice, once per mirrored copy), and `documents two similar commands`. Each pairs an assertion verb with a catalog noun used for something the `rules` or `commands` catalog does not mean, and what tells those apart from the one live finding is magnitude: a catalog this sweep tracks drifts by a few members between the day a sentence was written and the day it is read, so a genuine staleness claim sits near the true count. `2` beside a true count of `59` is not a catalog that shrank, it is a different `rules` entirely.
@@ -51,7 +57,9 @@ The article gate is looser than the verb list and carries a real cost. Re-runnin
 
 ## What it does not measure
 
-A delta phrased as a transition (`from fourteen to fifteen`), a fraction (`thirteen of sixteen`), and a total reached through an indirect noun (`denominator of sixty-one shipped skills`) are all catalog-size claims this corpus carries, and none matches the assertion-verb shape this reads. Each is a known gap rather than an oversight, left for a wider pass once this design's own false-positive rate is measured over more than one run.
+A delta phrased as a transition (`from fourteen to fifteen`), a fraction (`thirteen of sixteen`), and a total reached through an indirect noun (`denominator of sixty-one shipped skills`) are all catalog-size claims this corpus carries, and none matches the trigger shape this reads. Each stays a known gap. The false-positive rate that gated closing them has a measurement behind it now, and what it showed is that the widening these three need is the one that costs a false positive rather than the one that does not.
+
+A second figure in a sentence whose first figure already matched is a fourth gap and a structural one, since one match is taken per catalog per sentence. `authors 69 rules under governance/rules/ and consumes 54 into .claude/rules/` is read for its 69 alone, which is correct here because the two figures name different populations, and a sentence stating one catalog twice would go unread the same way.
 
 A calendar date (`2026-08-21`) or a backticked commit reference in the same sentence reads the whole sentence past, since that is how this corpus already marks a figure as a historical record rather than a live claim. `.claude/ARCHITECTURE.md` and the context entries carry a figure this way deliberately, and every one of them stays correct forever.
 

package/docs/agents/install-and-sync.md

@@ -76,7 +76,7 @@ standard exits 1 after listing the catalog on stderr.
 Two roots answer, in order: `standards/` at the working directory, then the
 corpus inside the package. A project that authors standards of its own uses the
 first, and this repository's own authoring root is the same path. `.claude/standards/`
-is not among them. It is this repository's generated mirror, and a copy an older
+is not among them, and no repository writes one any more. A copy an older
 toolkit installed into a target resolves nothing.
 
 There is no citation closure to compute, since nothing is copied. A standard

package/docs/agents/intake.md

@@ -78,4 +78,4 @@ Skills branch on the reason rather than on the exit code:
 aitk intake list toolkit-overview --unread --json | jq -r '.clusters[] | .cluster'
 ```
 
-For the folder layout, the item format, the answer contract, and retrieval, see `.claude/standards/intake.md`.
+For the folder layout, the item format, the answer contract, and retrieval, see `standards/intake.md`.

package/docs/agents/markdown-audit.md

@@ -41,7 +41,7 @@ Freezing the spellings gave up a property worth naming. They were derived by app
 
 A set shipped empty is reported rather than passed. It finds nothing and would exit clean, which reports a corpus nobody checked as a corpus carrying no violation, so the run names the empty set and exits `1`. The sets ship with the package, so a defect in the build is the only cause left.
 
-`aitk standards <name>` still resolves a standard under `.claude/standards/`, then the authoring root, then the package corpus, and prints it, so the human catalog reads without a project copy on disk.
+`aitk standards <name>` still resolves a standard at the authoring root, then the package corpus, and prints it, so the human catalog reads without a project copy on disk.
 
 ## What each check reports
 

package/docs/agents/records.md

@@ -23,7 +23,7 @@ aitk records validate intake --json
 
 It reads and never writes, and the reason splits by kind. A session record is per-machine scratch with no history behind it, so a repair that guessed wrong could not be undone. A standard installs into every target and is cited by bare filename, so a rename the verb performed would reach further than the file it moved, which is why a finding naming one says so.
 
-`standards` reads the authoring root at `standards/` where it exists and the installed copy at `.claude/standards/` otherwise. The authoring root wins because the installed tree is generated from it in the toolkit, where a fix written to the copy is discarded by the next regen. A project that consumed the corpus holds only the second, so one precedence serves both. The walk stays flat, matching install and the catalog.
+`standards` reads the authoring root at `standards/` where it exists and a copy at `.claude/standards/` otherwise. The authoring root wins because it is the only tree anyone authors in and the only one the resolver answers from, so a finding fixed anywhere else is fixed where nothing reads it. No repository generates the second candidate any more, which leaves it as a floor under a target holding a copy an older toolkit installed. The walk stays flat, matching the catalog.
 
 Nothing fires it automatically. The five record folders are gitignored, so the standards-audit hook exits early on them and any check reading changed files from git never lists one. The corpus is tracked and still unreached, since the markdown audit reads content across the files git lists and rules on no filename. The verb runs at the moment a session claims the record is finished, which is the same placement `aitk tasks validate` takes over the board.
 
@@ -70,7 +70,7 @@ Skills branch on the findings rather than on the exit code:
 aitk records validate plans --json | jq -r '.findings[] | "\(.kind): \(.subject)"'
 ```
 
-For the shapes each check enforces, see `.claude/standards/plan.md`, `.claude/standards/groundwork.md`, `.claude/standards/intake.md`, `.claude/standards/memory.md`, and `.claude/standards/standard.md`.
+For the shapes each check enforces, see `standards/plan.md`, `standards/groundwork.md`, `standards/intake.md`, `standards/memory.md`, and `standards/standard.md`.
 
 ## Migrate
 
@@ -132,7 +132,7 @@ aitk records push --json
 aitk records pull
 ```
 
-The backed folders are `diagrams`, `groundwork`, `intake`, `memory`, `plans`, `proposals`, `review`, `tasks`, and `teach`, all under `.claude/`. Seven of them are the Claude ignore group the claude manifest ships, minus three entries: `.claude/.tmp`, which is deletable without loss, `.claude/worktrees/`, whose contents belong to the project repository already, and `.claude/.records.git/`, which is the history the rest are pushed into. `diagrams` and `proposals` are the two that group does not carry at all, since a target still tracks its own copies of both, which is why the list is spelled out rather than derived. Each name is a top-level record folder and every archive sits inside the one it archives, so the list stays at one entry per surface however many archives appear. It is a constant rather than configuration, and it deliberately does not match the six record kinds `validate` hardcodes.
+The backed folders are `diagrams`, `groundwork`, `intake`, `memory`, `plans`, `proposals`, `review`, `tasks`, and `teach`, all under `.claude/`. Eight of them are the Claude ignore group the claude manifest ships, minus three entries: `.claude/.tmp`, which is deletable without loss, `.claude/worktrees/`, whose contents belong to the project repository already, and `.claude/.records.git/`, which is the history the rest are pushed into. `diagrams` is the one that group does not carry at all, since a target still tracks its own copies, which is why the list is spelled out rather than derived. Each name is a top-level record folder and every archive sits inside the one it archives, so the list stays at one entry per surface however many archives appear. It is a constant rather than configuration, and it deliberately does not match the six record kinds `validate` hardcodes.
 
 Records are gitignored by design, so the history lives in a second git directory at `.claude/.records.git` with `.claude/` as its work tree. Every path stays where it is, which is what a separate checkout could not do. The verbs stage the nine folders by explicit pathspec with `--force`, so nothing outside them can enter the index however the ignore rules read, and the project working tree and its index are never touched. Each pathspec is a bare folder name and git reads it against the current directory rather than against the work tree the same call names, so the invocation carries `-C` at the work tree beside the other two flags. That is what lets either verb run from a linked worktree under `.claude/worktrees/`, which sits inside the records work tree and would otherwise prefix every name with its own path.
 
@@ -146,7 +146,7 @@ git --git-dir=.claude/.records.git remote add origin <private-repo-url>
 printf '.claude/.records.git/\n' >> .gitignore
 ```
 
-The ignore line is part of the setup rather than part of the installed gitignore group, because the person running these commands is the one who creates the directory. Every path that group ships is written by a toolkit command without anyone asking, and this one is not, so a project that never sets up records would carry a rule for a directory it will never hold. Leaving it out and adding it here puts the rule where whoever creates the directory reads it.
+The ignore line is repeated here rather than left to the install, because the person running these commands is the one who creates the directory and the rule is worth reading beside the command that needs it. The claude manifest ships `.claude/.records.git/` as the first entry of its group, so a project that ran `aitk claude sync` already carries it and this line is a no-op there. What the group buys is the project that never sets records up: it holds a rule for a directory it will never create, which costs nothing, and the backed-folder derivation above subtracts that entry from the group rather than from a list it does not sit in.
 
 Point it at a private repository, and at one that is not a remote of the project. Records carry the memory pen, the review reports, and the groundwork trails, so a public project publishes all of it to anyone who fetches all refs. `push` compares the configured origin against every remote of the project and refuses on a match. A read of that list which fails refuses as well, since an empty list clears the comparison for every origin and a gate that passes on its own failure is no gate.
 

package/docs/agents/tasks.md

@@ -191,4 +191,4 @@ Skills branch on the findings rather than on the exit code:
 aitk tasks validate --json | jq -r '.findings[] | "\(.kind): \(.subject)"'
 ```
 
-For the board format, the `Pull request:` line, and the archive rules, see `.claude/standards/tasks.md`.
+For the board format, the `Pull request:` line, and the archive rules, see `standards/tasks.md`.

package/docs/ai-workflow.md

@@ -89,7 +89,7 @@ A constraint naming a track in flight carries the same problem past the handoff,
 
 `.claude/plans/`, `.claude/review/`, and `.claude/memory/` all resolve at the main worktree root, so artifacts created in any session are visible from any sibling worktree. A session inside a worktree reads them directly, since the file-editing tools refuse a main-root path but `Read` resolves normally. It writes a whole file through the shell and makes a change inside an existing file through an `aitk` verb, which resolves the main root in-process. See [Claude Code and git worktrees](../wiki/claude/claude-worktrees.md) for the full rule and the domain-level fan-out guidance.
 
-The plan's shape is fixed by `.claude/standards/plan.md`: the section list, the filename, the lifecycle, and the contract its questions keep. Every question carries a `- Suggested:` line and an empty `- Answer:` slot, and a blank answer accepts the suggestion at execution time. That default is what makes a plan decision-ready in one pass, and it is the opposite of the contract an intake folder keeps, where an empty slot means nobody reached the item.
+The plan's shape is fixed by `standards/plan.md`: the section list, the filename, the lifecycle, and the contract its questions keep. Every question carries a `- Suggested:` line and an empty `- Answer:` slot, and a blank answer accepts the suggestion at execution time. That default is what makes a plan decision-ready in one pass, and it is the opposite of the contract an intake folder keeps, where an empty slot means nobody reached the item.
 
 An execution that picks other than the suggestion rewrites the `- Suggested:` line as `overridden at execution to <pick>,` followed by the measurement that moved it, and leaves the slot blank. That fixed phrase is how a reader of the archived plan tells an override from a suggestion the execution accepted, since an authored suggestion often carries a number of its own. The same deviation takes one line in the open task's `## Findings`, which is the register that survives the plan being archived. A deviation from a question somebody already answered goes back to whoever answered it instead, since a filled slot is a decision already made.
 

package/docs/visual-design-workflow.md

@@ -20,7 +20,7 @@ Claude Code reads both and writes the implementation. Works for CLI tools, inter
 
 ### Seed shape
 
-The toolkit seed in `tooling/claude/seeds/.claude/DESIGN.md` ships a token-table template with a starting set of roles, and `.claude/standards/design.md` carries the same tables under `## Template` with placeholder rows. The column headers are what the renderer parses, so they stay verbatim in either, while the rows and values are the project's own.
+The toolkit seed in `tooling/claude/seeds/.claude/DESIGN.md` ships a token-table template with a starting set of roles, and `standards/design.md` carries the same tables under `## Template` with placeholder rows. The column headers are what the renderer parses, so they stay verbatim in either, while the rows and values are the project's own.
 
 The `aitk:claude-design-extract` skill drafts the file, sourcing tokens from a project's existing prose and CLI UI surfaces, or proposing them from `.claude/REQUIREMENTS.md` and a `## Personality` paragraph when no UI code exists yet. `aitk design render` writes an HTML plus CSS preview to `.claude/review/design/` for eyeballing the current system without leaving Claude Code. See `.claude/context/design.md`.
 

package/governance/rules/claude/591-standard-authoring.md

@@ -1,7 +1,6 @@
 ---
 description: Enforce shape, scope, and success criterion for authoring convention files
 paths:
-  - '.claude/standards/**/*.md'
   - 'standards/**/*.md'
 ---
 

package/package.json

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

package/scripts/core/check-ignore-parity.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+set -e
+set -o pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+
+GITIGNORE="$PROJECT_ROOT/.gitignore"
+MANIFEST="$PROJECT_ROOT/tooling/claude/manifest.toml"
+SECTION="# Claude"
+
+# Divergences this repository has decided to keep, one `<entry>|<reason>` per
+# line, matched after the trailing slash is stripped. Each names a path the
+# enclosing repository ignores and the claude manifest deliberately does not
+# ship, so a target keeps tracking it.
+#
+# This is the canonical list. `.gitignore` and the manifest carry a pointer
+# beside their own entries rather than a second copy of the reason, and
+# `.claude/context/tooling.md` carries the narrative behind both.
+#
+# A sanction that no longer describes a divergence fails the same as an
+# unsanctioned one. An exception outliving its reason is what teaches the next
+# reader to widen the list rather than to read it.
+SANCTIONED=(
+  ".claude/diagrams|a target that tracks its diagrams keeps the context audit's default coverage of them, which ignoring the folder for every target would take away. This repository backs the folder through its records remote instead."
+  ".claude/README.md|the landing page a records pull writes back into a repository that set up a records remote. A target has not, so it never receives the file."
+)
+
+if [ ! -f "$GITIGNORE" ]; then
+  echo "No .gitignore at ${GITIGNORE#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
+  exit 1
+fi
+
+if [ ! -f "$MANIFEST" ]; then
+  echo "No claude manifest at ${MANIFEST#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
+  exit 1
+fi
+
+# A gitignore pattern and a manifest entry describe the same folder whether or
+# not either spells the trailing slash, so presence is compared with it dropped.
+# `.claude/.tmp` and `.claude/.tmp/` are the live instance of that pair.
+normalize() {
+  printf '%s\n' "${1%/}"
+}
+
+# Every pattern the file carries, comments and blank lines dropped. The whole
+# file rather than one header, because `.claude/teach/` sits under a header of
+# its own and reading the `# Claude` header alone would report it missing from a
+# list that carries it.
+gitignore_patterns() {
+  awk '{ sub(/[[:space:]]+$/, "") } $0 ~ /^[[:space:]]*#/ || $0 == "" { next } { print }' "$GITIGNORE"
+}
+
+# Every entry of the named array in the manifest's `[gitignore]` table. The
+# array is accumulated to its closing bracket before the quoted strings are read
+# out, so a formatter wrapping it across lines does not silently empty this.
+manifest_entries() {
+  awk -v key="\"$SECTION\"" '
+    /^\[/ { table = $0 }
+    table != "[gitignore]" { next }
+    index($0, key) == 1 { collecting = 1; buf = "" }
+    collecting { buf = buf $0 }
+    collecting && index($0, "]") > 0 {
+      collecting = 0
+      buf = substr(buf, index(buf, "["))
+      count = split(buf, parts, "\"")
+      for (i = 2; i <= count; i += 2) print parts[i]
+    }
+  ' "$MANIFEST"
+}
+
+contains() {
+  local needle=$1
+  shift
+  local candidate
+  for candidate in "$@"; do
+    [ "$candidate" = "$needle" ] || continue
+    return 0
+  done
+  return 1
+}
+
+ignored=()
+while IFS= read -r pattern; do
+  [ -n "$pattern" ] || continue
+  ignored+=("$(normalize "$pattern")")
+done < <(gitignore_patterns)
+
+shipped=()
+while IFS= read -r entry; do
+  [ -n "$entry" ] || continue
+  shipped+=("$(normalize "$entry")")
+done < <(manifest_entries)
+
+# An empty read on either side is a parse that failed rather than a repository
+# ignoring nothing, and reporting parity off it would say the two lists agree
+# having compared none of their entries.
+if [ ${#ignored[@]} -eq 0 ]; then
+  echo "No patterns read from .gitignore, ignore parity unverifiable." >&2
+  exit 1
+fi
+
+if [ ${#shipped[@]} -eq 0 ]; then
+  echo "No entries read from the \"$SECTION\" array in ${MANIFEST#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
+  exit 1
+fi
+
+failures=""
+sanction_notes=""
+
+# Entries the manifest ships that this repository does not ignore. A target is
+# told to ignore a folder the toolkit itself tracks, which no decision sanctions,
+# so this direction carries no exception list.
+for entry in "${shipped[@]}"; do
+  contains "$entry" "${ignored[@]}" && continue
+  failures="$failures  $entry is shipped by the manifest and absent from .gitignore"$'\n'
+done
+
+# Claude-scoped patterns this repository ignores that the manifest does not
+# ship. Scoped to `.claude/` because the manifest is the claude stack and says
+# nothing about `node_modules/` or `.env`.
+for pattern in "${ignored[@]}"; do
+  case "$pattern" in
+  .claude/*) ;;
+  *) continue ;;
+  esac
+  contains "$pattern" "${shipped[@]}" && continue
+
+  matched=false
+  for sanction in "${SANCTIONED[@]}"; do
+    [ "${sanction%%|*}" = "$pattern" ] || continue
+    matched=true
+    sanction_notes="$sanction_notes  $pattern stays out of the manifest: ${sanction#*|}"$'\n'
+    break
+  done
+
+  if [ "$matched" = false ]; then
+    failures="$failures  $pattern is ignored here and absent from the manifest"$'\n'
+  fi
+done
+
+# A sanction naming a path that is no longer divergent, either because the
+# manifest took it or because .gitignore dropped it.
+for sanction in "${SANCTIONED[@]}"; do
+  entry="${sanction%%|*}"
+  if contains "$entry" "${ignored[@]}" && ! contains "$entry" "${shipped[@]}"; then
+    continue
+  fi
+  failures="$failures  $entry is sanctioned as a divergence and is no longer one"$'\n'
+done
+
+if [ -n "$failures" ]; then
+  echo "The ignore set a target receives disagrees with this repository's own:" >&2
+  printf '%s' "$failures" >&2
+  echo "Add the entry to the \"$SECTION\" array in ${MANIFEST#"$PROJECT_ROOT/"} and to .gitignore, or record it in SANCTIONED in scripts/core/check-ignore-parity.sh with the reason it stays apart." >&2
+  exit 1
+fi
+
+if [ -n "$sanction_notes" ]; then
+  echo "Sanctioned divergences from the ignore set a target receives:"
+  printf '%s' "$sanction_notes"
+fi

package/scripts/core/regen-claude-copies.sh

@@ -18,7 +18,6 @@ mirror_dir() {
   done < <(find "$src" -type f "${find_args[@]}" | sort)
 }
 
-mirror_dir "$PROJECT_ROOT/standards" "$PROJECT_ROOT/.claude/standards" -name "*.md" -not -path "*/bundled/*"
 mirror_dir "$PROJECT_ROOT/snippets" "$PROJECT_ROOT/.claude/snippets" -name "*.md"
 
 # `internal/` is the surface the plugin does not symlink. Mirrored on its own so

package/scripts/core/verify.sh

@@ -261,7 +261,7 @@ main() {
 
   log_step "Consumed copies"
   run_check "bash $PROJECT_ROOT/scripts/core/regen-claude-copies.sh" "Consumed-copy regen failed"
-  assert_no_drift ".claude/standards .claude/snippets .claude/internal .claude/rules" "Consumed copies drifted. Run bun run check and commit .claude/standards, .claude/snippets, .claude/internal, and .claude/rules."
+  assert_no_drift ".claude/snippets .claude/internal .claude/rules" "Consumed copies drifted. Run bun run check and commit .claude/snippets, .claude/internal, and .claude/rules."
   log_info "Consumed copies clean"
 
   # Only the HTML is asserted. The PNG beside it is a chromium render whose bytes
@@ -278,6 +278,16 @@ main() {
   assert_no_drift "claude/skills/toolkit-cli/SKILL.md" "The overwrite contract drifted from what the stacks hold. Run bun run check and commit claude/skills/toolkit-cli/SKILL.md."
   log_info "Tooling paths clean"
 
+  # The claude manifest is the only route a target's ignore set travels, and it
+  # is hand-maintained beside this repository's own `.gitignore` with nothing
+  # comparing the two. A drift between them reaches every target on the next
+  # `aitk tooling sync` and surfaces to nobody, which is why this gates rather
+  # than reports. It is not an `assert_no_drift`: no generator produces either
+  # list, so there is nothing to regenerate and diff.
+  log_step "Ignore parity"
+  run_check "bash $PROJECT_ROOT/scripts/core/check-ignore-parity.sh" "The ignore set a target receives disagrees with this repository's own."
+  log_info "Ignore parity clean"
+
   log_step "Skill paths"
   run_check "bash $PROJECT_ROOT/scripts/core/check-skill-paths.sh" "Shipped skills reference a repo-local path."
   log_info "Skill paths clean"

package/src/audits/catalog.ts

@@ -570,7 +570,7 @@ export const AUDITS: readonly AuditSpec[] = [
     // `standards` is the one tracked kind here, so it takes none of the
     // per-machine default the other five inherit from their corpus. A target
     // reads standards through `aitk standards` rather than a copy in its own
-    // tree, so carrying neither `standards/` nor `.claude/standards/` is the
+    // tree, so carrying no standards folder at all is the
     // ordinary state of every project but this repository.
     ...(kind === 'standards' && {
       absentReasons: ['no-folder'] satisfies RecordRefusal[],

package/src/context/folders.ts

@@ -5,11 +5,15 @@ import { INDEX_FILE, listIndexes } from '@/indexes/walk'
 /**
  * Folder names under `.claude/` audited by default.
  *
- * The index-plus-entry contract on its own over-collects. `.claude/standards/`
- * also carries a generated index beside entries with frontmatter, and auditing
- * it would measure the consumed copy of `standards/` against a rule written for
- * per-domain narrative. This list names the folders `standards/context.md`
- * governs, and `--folder` admits another without an edit here.
+ * A named list rather than the index-plus-entry contract read off disk, so a
+ * generated tree satisfying that contract is never measured against a rule
+ * written for per-domain narrative. This list names the folders
+ * `standards/context.md` governs, and `--folder` admits another without an edit
+ * here.
+ *
+ * It doubles as the citation check's scope, since `citationPattern` spells only
+ * these names. A `.claude/` folder left off the list is never resolved, so a
+ * path into one goes stale silently rather than failing a push.
  */
 export const DEFAULT_FOLDERS: readonly string[] = [
   'context',

package/src/counts/scan.ts

@@ -78,6 +78,16 @@ function sentencesOf(line: string): string[] {
  * asserting the catalog's own total, `the full entry loads 59 skills` being
  * the live one, and gating the match on that verb is what a full re-read of
  * the 290 showed removing all of them while keeping that one.
+ *
+ * `authors` joined the list on a corpus measurement rather than on the shape
+ * argument above. `.claude/context/development/regeneration.md` states `the
+ * toolkit authors 69 rules under governance/rules/`, which is the assertion
+ * shape this list was built for with a verb the list did not carry, and the
+ * word costs one further sentence across the whole corpus and no finding.
+ * Extending the vocabulary is the narrow half of this fix and it is taken
+ * knowingly: a list of thirteen verbs still grows by whatever the next author
+ * writes, and the measurement below is what ruled out the general axis that
+ * would have replaced it.
  */
 const ASSERTION_VERBS = [
   'loads',
@@ -92,8 +102,26 @@ const ASSERTION_VERBS = [
   'lists',
   'contains',
   'comprises',
+  'authors',
 ]
 
+/**
+ * A quantifier asserting the whole of a catalog immediately ahead of the
+ * number, which is the one trigger class that states a total outright rather
+ * than by implication.
+ *
+ * `all 69 rules` names the catalog entire, where `the 69 rules` leaves a
+ * reader to decide whether a qualifier narrows it. That makes this class
+ * tighter than the articles below rather than looser, and the corpus agrees:
+ * adding it reached 9 further sentences and produced 2 further findings, both
+ * of them real staleness this repository then repaired.
+ *
+ * `every` and `both` were measured beside `all` and reached nothing, so
+ * neither ships. A quantifier earns a place here by naming a sentence in the
+ * corpus, not by belonging to the same part of speech.
+ */
+const QUANTIFIERS = ['all']
+
 /**
  * An article immediately ahead of the number, admitting the shape a bare verb
  * gate cannot reach: `the twelve audits read gitignored folders` asserts the
@@ -120,8 +148,9 @@ const ASSERTION_VERBS = [
 const ARTICLES = ['the', 'a', 'an']
 
 /**
- * Matches a catalog's stated size: an assertion verb or an article, the
- * number, an optional single qualifying word, then the noun in either number.
+ * Matches a catalog's stated size: an assertion verb, a quantifier, or an
+ * article, the number, an optional single qualifying word, then the noun in
+ * either number.
  *
  * The optional word between the number and the noun is what reaches a form
  * like `installs 11 shipped snippets` without also reaching past an
@@ -130,16 +159,34 @@ const ARTICLES = ['the', 'a', 'an']
  * double as its match narrows the corpus this reads without hand-listing
  * every irregular plural, since none of these six is irregular.
  *
- * What this drops along with the false positives: `denominator of sixty-one
- * shipped skills` and `exposed all 59` both state a real catalog total and
- * neither puts a verb or an article directly ahead of the number, so both
- * read past. The gap between the trigger and the number is a second axis
- * this could widen once this design's own false-positive rate is measured
- * over more than the two runs behind it so far.
+ * The gap between the trigger and the number was the second axis this comment
+ * used to name as open to widening once the false-positive rate had been
+ * measured over more than two runs. It was measured over the whole corpus at
+ * 518 files and 31,836 sentences and it is not the axis to take. Widths of
+ * one, two, and three optional words reached 77, 104, and 132 sentences
+ * against a baseline of 65, and the two live misses that motivated the
+ * measurement came back missed at every width but one: no width reaches `took
+ * all 69 rules`, whose nearest verb or article is the `The` opening the
+ * sentence, with five words standing between it and the number, and the width
+ * that does reach `the toolkit authors 69 rules` is the same
+ * width that admits `a domain of 55 skills`, which is the indirect-noun shape
+ * this module already records as out of scope. Widening the gap buys one of
+ * two misses at 60 percent more reach and a false positive of a class already
+ * named.
+ *
+ * The trigger vocabulary carries both misses instead, at 75 sentences reached
+ * against 65 and no false positive: `all` reaches the first and `authors` the
+ * second. Two of the four findings that shape reports were new, and both were
+ * real. Measured at `ffe7e7c6` on 2026-08-28.
+ *
+ * What this still drops: `denominator of sixty-one shipped skills` states a
+ * real catalog total through an indirect noun and reads past, which the gap
+ * measurement above is the argument for leaving alone rather than an
+ * oversight.
  */
 function buildMatcher(catalog: Catalog): RegExp {
   const [singular, plural] = catalog.nouns
-  const triggers = [...ASSERTION_VERBS, ...ARTICLES].join('|')
+  const triggers = [...ASSERTION_VERBS, ...QUANTIFIERS, ...ARTICLES].join('|')
   return new RegExp(
     `\\b(?:${triggers})\\s+(${NUMBER_PATTERN})(?:\\s+[a-z]+)?\\s+(?:${singular}|${plural})\\b`,
     'gi',
@@ -187,10 +234,19 @@ function isPlausibleClaim(stated: number, actual: number): boolean {
  * What it does not measure: a delta phrased as a transition (`from fourteen
  * to fifteen`), a fraction (`thirteen of sixteen`), and a total reached
  * through an indirect noun (`denominator of sixty-one shipped skills`) are
- * all catalog-size claims this corpus carries, and none matches the
- * assertion-verb shape this reads. Each is a known gap rather than an
- * oversight, left for a wider pass once this one's false-positive rate is
- * measured.
+ * all catalog-size claims this corpus carries, and none matches the trigger
+ * shape this reads. Each stays a known gap. The rate that used to gate
+ * closing them is measured now, and what it showed is that the widening they
+ * would need is the one that costs a false positive rather than the one that
+ * does not, which `buildMatcher` records with its numbers.
+ *
+ * A second figure in a sentence whose first figure already matched is a
+ * fourth gap and a structural one: `regex.exec` takes one match per catalog
+ * per sentence, so `authors 69 rules under governance/rules/ and consumes 54
+ * into .claude/rules/` is read for its 69 alone. Reaching the 54 would be
+ * wrong here rather than better, since it counts the consumed mirror rather
+ * than the source catalog this sweep tracks, but a sentence stating one
+ * catalog twice would go unread the same way.
  */
 export async function scanCounts(root: string): Promise<CountsReport> {
   const scope = await resolveMarkdown(root, [])

package/src/records/backup.ts

@@ -12,10 +12,12 @@ import { gitEnv } from '@/git-env'
  * list is spelled out rather than read off that group so adding an ignore entry
  * cannot silently enlarge the payload.
  *
- * `diagrams` and `proposals` are the two names the manifest group does not
- * carry, so a target tracks both where this repository ignores them. That is
- * the second reason to spell the list out: the manifest bounds it rather than
- * producing it, and no count taken off that group matches this one.
+ * `diagrams` is the one name the manifest group does not carry, so a target
+ * tracks it where this repository ignores it. That is the second reason to
+ * spell the list out: the manifest bounds it rather than producing it, and no
+ * count taken off that group matches this one. `scripts/core/check-ignore-parity.sh`
+ * compares the two lists and holds the reason `diagrams` stays apart, so the
+ * one difference is enforced rather than assumed.
  *
  * The manifest group is the one this reads rather than the enclosing
  * repository's own `.gitignore`, which spreads the same entries across two

package/src/standards/read.ts

@@ -33,7 +33,8 @@ export interface ResolvedStandard {
 
 /**
  * The roots a standard resolves against. No toolkit standard installs into a
- * project any more, so `.claude/standards/` is gone from the list and a target
+ * project any more, so `.claude/standards/` is gone from the list, no repository
+ * generates one, and a target
  * carries neither entry below: the package corpus is the only root that
  * answers there, which is what leaves no precedence to reason about.
  *

package/src/sync/reverse.ts

@@ -13,7 +13,7 @@ const CLAUDE_DIR = '.claude'
 
 /**
  * A `CLAUDE.md` past this many lines has more in it than the always-load tier
- * is for. The figure is the checkpoint `.claude/standards/context.md` sets for
+ * is for. The figure is the checkpoint `standards/context.md` sets for
  * a context entry, raised because `CLAUDE.md` legitimately carries more than
  * one domain. It gates a proposal rather than a failure, so being approximate
  * costs a line an operator can ignore.

package/src/tasks/validate.ts

@@ -14,7 +14,7 @@ const ORDERING_FILE = 'priority.md'
 const BACKLOG_FILE = 'backlog.md'
 
 /**
- * The readiness headings `.claude/standards/tasks.md` fixes. The names are the
+ * The readiness headings `standards/tasks.md` fixes. The names are the
  * contract rather than a suggestion, so a board grouping under names of its own
  * reads as carrying no group at all and the run refuses instead of reporting a
  * clean board it never parsed.

package/standards/intake.md

@@ -42,11 +42,11 @@ An intake failing these is non-conforming even when it satisfies every shape rul
 
 ## Files
 
-| File                 | Holds                                                        | Required |
-| -------------------- | ------------------------------------------------------------ | -------- |
-| `00-overview.md`     | Index: format block, cluster table, verdicts, open questions | Always   |
-| `NN-<domain>.md`     | One cluster of items, filed by the domain their fixes touch  | Always   |
-| `99-next-session.md` | What a compaction destroys that no cluster file carries      | Optional |
+| File                 | Holds                                                       | Required |
+| -------------------- | ----------------------------------------------------------- | -------- |
+| `00-overview.md`     | Index: cluster table, verdicts, open questions              | Always   |
+| `NN-<domain>.md`     | One cluster of items, filed by the domain their fixes touch | Always   |
+| `99-next-session.md` | What a compaction destroys that no cluster file carries     | Optional |
 
 `00` is the only reserved number. Everything else is read order, and the domain rides in the filename so a reader knows what `07-tooling.md` holds without opening it.
 
@@ -70,7 +70,6 @@ Date the folder once rather than every file. Twelve dated files leave eleven sta
 
 The index. It points at items and answers nothing itself.
 
-- The item format block, copied so a returning session picks the shape up from the folder
 - The answer contract stated out loud, since it inverts the plan file's
 - A cluster table of file, what it holds, item count, and open count
 - The verdict counts across the folder
@@ -168,10 +167,6 @@ date: <YYYY-MM-DD>
 
 <One line on what the dump covers and the commit it was measured against.>
 
-## Item format
-
-<the item format block, copied so a returning session picks the shape up here>
-
 ## The answer contract
 
 `You:` ships empty and empty means unread. Accepting a verdict is typed as

package/standards/standard.md

@@ -9,7 +9,7 @@ Applies to each authored standard in the folder. Skip for `index.md`, which is g
 
 ## Overview
 
-A standard is a target-facing authoring convention for one document type, or for one attribute carried across every document. It installs into a project under `.claude/standards/` and is consumed by skills and developers alike. This file governs itself, so every rule below applies to it.
+A standard is a target-facing authoring convention for one document type, or for one attribute carried across every document. Nothing installs it into a project, so a reader resolves it with `aitk standards <name>` or reads it at `standards/<name>.md`, and skills and developers consume it alike. This file governs itself, so every rule below applies to it.
 
 ## Scope
 

package/tooling/claude/manifest.toml

@@ -7,5 +7,8 @@ extends = ""
 runtime = ""
 scaffold = ""
 
+# Checked against this repository's own `.gitignore` by
+# scripts/core/check-ignore-parity.sh, which also holds the two `.claude/` paths
+# this array deliberately omits and the reason each stays out.
 [gitignore]
-"# Claude" = [".claude/.records.git/", ".claude/.tmp/", ".claude/groundwork/", ".claude/intake/", ".claude/memory/", ".claude/plans/", ".claude/review/", ".claude/worktrees/", ".claude/tasks/", ".claude/teach/"]
+"# Claude" = [".claude/.records.git/", ".claude/.tmp/", ".claude/groundwork/", ".claude/intake/", ".claude/memory/", ".claude/plans/", ".claude/proposals/", ".claude/review/", ".claude/worktrees/", ".claude/tasks/", ".claude/teach/"]

package/tooling/claude/reference.md

@@ -29,7 +29,7 @@ A project installed before the board became a folder still holds `.claude/TASKS.
 
 Convert by hand, once per project:
 
-1. Split each `###` block into `.claude/tasks/vXX.Y-<slug>.md`, adding the `title` and `description` frontmatter that `.claude/standards/tasks.md` requires. Compare each new file against the block it came from rather than checking that every block landed somewhere.
+1. Split each `###` block into `.claude/tasks/vXX.Y-<slug>.md`, adding the `title` and `description` frontmatter the tasks standard requires, which `aitk standards tasks` prints. Compare each new file against the block it came from rather than checking that every block landed somewhere.
 2. Run `aitk indexes regen --no-stage --root . .claude/tasks/<any-task>.md` to build the catalog.
 3. Delete `.claude/TASKS.md`, and swap its `.gitignore` entry for `.claude/tasks/`.