@erclx/aitk 3.12.0 → 3.12.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.12.0",
+  "version": "3.12.1",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

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

@@ -14,6 +14,7 @@ Two failure modes cost more than the rest. A track that fans out to subagents re
 ## Must
 
 - Detect open, resume, and close from the folder itself, matching the topic against tracks already there before deriving a slug
+- Name a newly opened folder with a two-digit ordinal ahead of the slug, taken from the highest one already present across groundwork and intake
 - Apply the qualifying test in open mode alone, so a track already measured is not refused by the test that admitted it
 - Measure the current state now rather than carrying a figure from a previous session
 - Carry a lean and the finding that would overturn it on every open question, or admit that a measurement is missing

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

@@ -1,6 +1,6 @@
 ---
 name: claude-groundwork
-description: Opens and runs a numbered groundwork folder under `.claude/groundwork/<slug>/` for a topic that has to be measured before it can be planned. Detects open, resume, and close from the folder itself. Use when asked to "research X", "dig into X", "work out what we should do about X", "measure this before we commit", or "open a groundwork folder". Do NOT use to write a feature plan or to implement. That is `claude-feature`.
+description: Opens and runs a numbered groundwork folder under `.claude/groundwork/<nn>-<slug>/` for a topic that has to be measured before it can be planned. Detects open, resume, and close from the folder itself. Use when asked to "research X", "dig into X", "work out what we should do about X", "measure this before we commit", or "open a groundwork folder". Do NOT use to write a feature plan or to implement. That is `claude-feature`.
 ---
 
 # Claude groundwork
@@ -19,10 +19,10 @@ Read `${CLAUDE_SKILL_DIR}/../../standards/groundwork.md` before writing any file
 
 ## Write scope
 
-- Write only inside `.claude/groundwork/<slug>/`. A feature plan, source changes, a standard, a rule, and a reference doc all live outside that folder, so this one rule forbids every one of them.
+- Write only inside `.claude/groundwork/<nn>-<slug>/`. A feature plan, source changes, a standard, a rule, and a reference doc all live outside that folder, so this one rule forbids every one of them.
 - One exception, at close only: write one task file recording what the track concluded.
 - A second exception, for what a spike reads: write an input under `.claude/.tmp/groundwork-fixtures/<slug>/`. Keep it out of `.claude/groundwork/` so mode detection never matches a fixture as a track. A fixture a headless run is pointed at goes outside the repository instead, per the rule in `## Running a spike`.
-- What a spike produces stays inside the track rather than joining the two exceptions above: write evidence a spike file cites under `.claude/groundwork/<slug>/evidence/`, which the first rule already permits. Mode detection matches entries at the top level of the tracks directory, so the sibling the fixtures rule guards against cannot be a folder nested inside a track, and the scratch path holds only what can be deleted without loss, which a recording a finding rests on is not.
+- What a spike produces stays inside the track rather than joining the two exceptions above: write evidence a spike file cites under `.claude/groundwork/<nn>-<slug>/evidence/`, which the first rule already permits. Mode detection matches entries at the top level of the tracks directory, so the sibling the fixtures rule guards against cannot be a folder nested inside a track, and the scratch path holds only what can be deleted without loss, which a recording a finding rests on is not.
 - Reading is not restricted. External research is in scope, so read documentation, comparable projects, and papers whenever a live question needs them.
 - Every claim about a source outside the project carries a link to it. A source found and not read is listed as a lead and is never cited.
 - Treat the folder as gitignored and unbacked. It dies with the machine, so `07-next-session.md` repeats what it needs instead of pointing at its siblings.
@@ -41,11 +41,11 @@ Record method, result, measured cost, and caveats in `08-spikes.md`. Put whateve
 
 ## Step 1: detect the mode
 
-List `.claude/groundwork/` from the project root and match the topic against the tracks already there before deriving anything. A resume pass rarely phrases the topic the way the folder was named, so a fresh slug derived from the wording would miss a live track and restart it.
+List `.claude/groundwork/` from the project root and match the topic against the slug half of each `<nn>-<slug>` folder already there before deriving anything. A resume pass rarely phrases the topic the way the folder was named, so a fresh slug derived from the wording would miss a live track and restart it.
 
 Never match against `.claude/` itself. That directory holds every other workflow surface, so a topic matched there lands on a folder that was never a track.
 
-With no match, derive a kebab-case slug named for the subject rather than the activity. Prefer `ts-migration` over `migration-research`. Then route on `.claude/groundwork/<slug>/`:
+With no match, derive a kebab-case slug named for the subject rather than the activity. Prefer `ts-migration` over `migration-research`. Also list `.claude/intake/` and take `<nn>` as the highest ordinal present across both listings, incremented, per `${CLAUDE_SKILL_DIR}/../../standards/groundwork.md`. Then route on `.claude/groundwork/<nn>-<slug>/`:
 
 - Folder absent: open
 - Folder present without `06-decision.md`: resume
@@ -72,7 +72,7 @@ The standard sets the open question format and requires it inside a topic file a
 
 ## Open mode
 
-1. Create `.claude/groundwork/<slug>/`.
+1. Create `.claude/groundwork/<nn>-<slug>/`, with `<nn>` and `<slug>` as derived in Step 1.
 2. Write `README.md` first. Writing it first forces the question of what the track is for.
 3. Write `01-current-state.md` by measuring now. Never carry a figure from a previous session or from recall without re-measuring it. Measure only what an open question in the folder needs. A number with no question attached is how groundwork turns into the work.
 4. Write `00-scope.md` when the track is large enough to run away. Skip it on a small track.
@@ -103,12 +103,12 @@ Emit the full relative path from the project root for every file written or upda
 Open and resume:
 
 ```plaintext
-📂 Opened .claude/groundwork/<slug>/
+📂 Opened .claude/groundwork/<nn>-<slug>/
 
 **Written:**
 
-- `.claude/groundwork/<slug>/README.md`
-- `.claude/groundwork/<slug>/01-current-state.md`
+- `.claude/groundwork/<nn>-<slug>/README.md`
+- `.claude/groundwork/<nn>-<slug>/01-current-state.md`
 
 **Open questions:**
 
@@ -122,12 +122,12 @@ Use `📂 Resumed` in place of `📂 Opened` on a resume pass.
 Close:
 
 ```plaintext
-✅ Closed .claude/groundwork/<slug>/
+✅ Closed .claude/groundwork/<nn>-<slug>/
 
 **Written:**
 
-- `.claude/groundwork/<slug>/06-decision.md`
-- `.claude/groundwork/<slug>/07-next-session.md`
+- `.claude/groundwork/<nn>-<slug>/06-decision.md`
+- `.claude/groundwork/<nn>-<slug>/07-next-session.md`
 
 **Uncited external claims:** <count, or none>
 

package/claude/skills/claude-intake/REQUIREMENT.md

@@ -22,6 +22,7 @@ A session with no numbering convention re-decides the folder shape per dump, so
 - Close every item with a verdict, and pair every open question with a suggested pick
 - Treat an empty operator slot as unread rather than as agreement
 - Reserve the index number and carry the domain in every other filename, leaving the rest of the numbering as read order
+- Name a newly opened folder with a two-digit ordinal ahead of the slug, taken from the highest one already present across intake and groundwork
 - Keep answers on items alone, with the index pointing at them
 - Name the heading and the act beside every path the pass wrote
 - Confine writes to the intake folder

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

@@ -1,6 +1,6 @@
 ---
 name: claude-intake
-description: Files a raw brain dump into a numbered intake folder under `.claude/intake/<slug>/`, one item per finding carrying a measured problem, a proposed fix, and a verdict. Use when asked to "file this dump", "triage my notes", "work through this list", "sort out this brain dump", or "run an intake pass". Do NOT use for one question that has to be measured before anyone can plan it. That is `claude-groundwork`.
+description: Files a raw brain dump into a numbered intake folder under `.claude/intake/<nn>-<slug>/`, one item per finding carrying a measured problem, a proposed fix, and a verdict. Use when asked to "file this dump", "triage my notes", "work through this list", "sort out this brain dump", or "run an intake pass". Do NOT use for one question that has to be measured before anyone can plan it. That is `claude-groundwork`.
 ---
 
 # Claude intake
@@ -29,7 +29,7 @@ Using the wrong one fails in two shapes. Intake on a question that needs measuri
 
 ## Write scope
 
-- Write only inside `.claude/intake/<slug>/`. A plan file, a task file, a source change, a standard, and a rule all live outside that folder, so this one rule forbids every one of them.
+- Write only inside `.claude/intake/<nn>-<slug>/`. A plan file, a task file, a source change, a standard, and a rule all live outside that folder, so this one rule forbids every one of them.
 - There is no exception. Promoting an item onto the board runs through `claude-tasks` after the operator has answered, which is a separate invocation.
 - Reading is unrestricted inside the project. Measuring is the work.
 - Treat the folder as gitignored and unbacked. No check reaches its contents, so every rule stated here holds only while a session reads it.
@@ -38,11 +38,11 @@ Nothing outside this body carries the write-scope floor, and no path-scoped rule
 
 ## Step 1: detect open or resume
 
-List `.claude/intake/` from the project root and match the topic against the folders already there before deriving a slug. A second pass over the same subject rarely phrases the topic the way the folder was named, so a fresh slug would open a duplicate beside a live folder.
+List `.claude/intake/` from the project root and match the topic against the slug half of each `<nn>-<slug>` folder already there before deriving a slug. A second pass over the same subject rarely phrases the topic the way the folder was named, so a fresh slug would open a duplicate beside a live folder.
 
 Never match against `.claude/` itself. That directory holds every other workflow surface, so a topic matched there lands on a folder that was never an intake.
 
-With no match, derive a kebab-case slug named for the subject rather than the activity. Prefer `toolkit-overview` over `august-triage`. An absent folder opens, and a present one resumes by appending items and revising verdicts the tree has moved under.
+With no match, derive a kebab-case slug named for the subject rather than the activity. Prefer `toolkit-overview` over `august-triage`. Also list `.claude/groundwork/` and take `<nn>` as the highest ordinal present across both listings, incremented, per `${CLAUDE_SKILL_DIR}/../../standards/intake.md`. An absent folder opens, and a present one resumes by appending items and revising verdicts the tree has moved under.
 
 ## Step 2: orient
 
@@ -90,12 +90,12 @@ Emit the full relative path from the project root for every file written, and na
 A file the pass only read gets no line, which is what keeps the block short.
 
 ```plaintext
-📂 Opened .claude/intake/<slug>/
+📂 Opened .claude/intake/<nn>-<slug>/
 
 **Filed:**
 
-- `.claude/intake/<slug>/05-coverage.md` gains items 6 to 8 under a new `## What the merge gate covers`
-- `.claude/intake/<slug>/00-overview.md` cluster rows and verdict counts updated
+- `.claude/intake/<nn>-<slug>/05-coverage.md` gains items 6 to 8 under a new `## What the merge gate covers`
+- `.claude/intake/<nn>-<slug>/00-overview.md` cluster rows and verdict counts updated
 
 **Routing:** <N> plan-ready, <N> groundwork candidates, <N> already settled
 

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

@@ -16,6 +16,15 @@ is left alone regardless of its name, since that subfolder is project-authored
 by location. It also removes a stale `.claude/GOV.md`
 from the retired build. Use `aitk gov install` to add rules.
 
+When the target's install recorded a stack, `aitk gov sync` also reports a
+rule that stack lists and `.claude/rules/` does not hold, as a `missing` entry
+carrying no change. This is what makes a target whose recorded sync point
+postdates a rule joining its stack still see that rule: the report reads the
+target's current entitlement against its current tree rather than diffing
+from an anchor a later sync could advance past the rule's own commit. A
+target whose install predates the recorded chain falls back to the same
+band-inference `newRules` uses in `aitk sync --check`.
+
 There is no `aitk standards sync` and no `aitk standards install`. The corpus
 installs into no project, so the domain has nothing in a target to reconcile.
 `aitk standards <name>` prints one, resolving `standards/` at the working root
@@ -94,16 +103,23 @@ It also refuses a target whose working tree is dirty, so commit or stash first.
 and is safe to run at any time. Each file is classified as `stale` when it still
 matches what the toolkit installed, `customized` when the project edited it,
 `stranded` when it sits at a path the toolkit no longer installs to, `orphaned`
-when the project authored it, or `drifted` when no stamp covers it.
+when the project authored it, or `drifted` when no stamp covers it. Governance
+also reports `missing`, for a rule the target's recorded stack lists that its
+tree does not hold at all.
 
 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 reads `.claude/aitk/config.json`, which every install and
-sync writes.
-
-A target installed before stamping shipped has no such file, and neither does one
-stamped before the file moved into `.claude/aitk/`, which is read as absent
-rather than migrated. Both fall back to the toolkit's own git history.
+and missing files are both excluded from that exit code: a project-authored
+rule never converges, and a sync that added a missing one silently changes
+what the project is governed by, which stays a separate command an operator
+chooses to run. Attribution reads `.claude/aitk/config.json`, which every
+install and sync writes.
+
+A target installed before stamping shipped has no such file, and neither does
+that fallback do anything to migrate it. A target stamped before the file
+moved into `.claude/aitk/` still carries it at the retired
+`.claude/aitk.json`, and `aitk sync --check` reads that path when the current
+one is absent, reporting it rather than moving it. Only a target carrying
+neither path 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
@@ -207,10 +223,10 @@ file and proposes relocating the lot.
 
 #### Rules the target never received
 
-`newRules` names a rule the toolkit authored after this target last synced
-governance. A sync refreshes the files a target already holds and adds none, so
-without this section a project's rule set freezes at its install date while every
-file it does hold reports as current. That is the report's most confident wrong
+`newRules` names a rule the target could receive and its tree does not hold. A
+sync refreshes the files a target already holds and adds none, so without this
+section a project's rule set freezes at its install date while every file it
+does hold reports as current. That is the report's most confident wrong
 answer, since a clean result reads as a target holding everything the toolkit
 publishes.
 
@@ -225,11 +241,22 @@ installs, nothing counts toward `--exit-code`, and a target can read the list an
 act on none of it. The value stops at an operator reading it, which is the same
 contract the skills list already sets.
 
-The measurement anchors on governance's own stamp rather than on the oldest
-anchor across domains, since rules are domain-scoped and a shared anchor would
-let a snippets sync move the revision rules are measured from. A target carrying
-no governance anchor reports nothing at all: it has no date to measure against,
-and diffing from the start of history would read the whole catalog as new.
+Since `aitk gov install` records the stack it resolved, a target carrying that
+record answers this by comparing its current entitlement against its current
+tree, with no anchor and no git diff involved. That is what lets the section
+name a rule that shipped before the target's last sync: the anchor a sync
+advances plays no part in the read, where an anchor-bound diff can never see a
+rule on the far side of a window a later sync moved past it. The per-file
+`missing` state `aitk gov sync` reports comes from the same comparison, so a
+rule the chain lists reaches both surfaces the same way.
+
+A target stamped before governance recorded a chain falls back to the older
+band-inference read below. The measurement there anchors on governance's own
+stamp rather than on the oldest anchor across domains, since rules are
+domain-scoped and a shared anchor would let a snippets sync move the revision
+rules are measured from. A target carrying no chain and no governance anchor
+reports nothing at all: it has no date to measure against, and diffing from the
+start of history would read the whole catalog as new.
 
 An anchor this toolkit cannot resolve reports nothing by the same route, and that
 one is not visible. A stamp naming a revision the running clone has never seen,
@@ -238,22 +265,22 @@ fails the read and yields an empty list rather than a stated absence. It looks
 identical to a target holding every rule the toolkit publishes. `newSkills`
 behaves the same way, and neither carries the `historyUnavailable` flag the
 per-domain scan uses to separate the two. Treat an empty section on a toolkit
-that is not a full clone as unmeasured rather than clean.
+that is not a full clone as unmeasured rather than clean. This gap does not
+reach the chain-based read above, since it consults no anchor at all.
 
-Entitlement is filtered, because a stack does not receive every rule. The base
-stack takes the `core` and `claude` folders whole and every other stack extends
-it with individually named rules, so an unfiltered list would tell a base
-consumer about rules it can never receive and train the reader to skip the
-section.
+In the fallback, entitlement is filtered, because a stack does not receive
+every rule. The base stack takes the `core` and `claude` folders whole and
+every other stack extends it with individually named rules, so an unfiltered
+list would tell a base consumer about rules it can never receive and train the
+reader to skip the section.
 
 The filter accepts a band on either of two grounds. A folder the base stack takes
 whole is entitled to every target, read from the stack file so a folder added to
 base later needs no code change. Every other band is read off the folders the
-target already carries, since `aitk gov install` records file hashes and never
-the stack it resolved, which leaves the installed tree as the only evidence of
-what a chain reached. One band can be reached by more than one stack, so the test
-over-reports inside a folder the target holds, which costs a line where
-under-reporting would cost the section its point.
+target already carries, which is the fallback's only evidence of what a target
+was entitled to before it recorded a chain. One band can be reached by more than
+one stack, so the test over-reports inside a folder the target holds, which
+costs a line where under-reporting would cost the section its point.
 
 A rule the target already holds is dropped by name. That is what keeps a rule the
 toolkit moved between band folders out of the list, since a rename reaches this

package/docs/agents/intake.md

@@ -9,6 +9,8 @@ description: Reading intake folder counts and items, the three read states an it
 
 `aitk intake list` reports the intake folders under `.claude/intake/`, or the items one folder holds. It reads and never writes, because an answer belongs to the operator and a verb that filled one would decide what the folder exists to ask.
 
+A folder carries a two-digit ordinal ahead of its slug, as in `21-toolkit-overview`, so a listing sorts by when each opened. A bare slug still resolves: passing `toolkit-overview` matches the one folder whose name is an ordinal ahead of it, and the folder's real name is what every command reports back.
+
 ```bash
 aitk intake list
 aitk intake list toolkit-overview --unread --json
@@ -58,7 +60,7 @@ One call writes one cluster. A call per selection is the alternative, and severa
 
 An item already carrying an answer refuses rather than being overwritten, and one filled item refuses the whole batch, so a partly applied write never lands. Drop the named item and send the rest.
 
-Exit codes: `0` every named item now carries its answer, `1` refused. The `reason` field carries `no-intake`, `no-folder`, `no-cluster`, `no-item`, `answered`, or `bad-input`.
+Exit codes: `0` every named item now carries its answer, `1` refused. The `reason` field carries `no-intake`, `no-folder`, `ambiguous-slug`, `no-cluster`, `no-item`, `answered`, or `bad-input`. A bare slug matching more than one ordinal-prefixed folder refuses as `ambiguous-slug` rather than `no-folder`, naming every match in `detail`.
 
 An exit code says nothing about a call made from a session, since a shell profile may wrap the binary in a function taking its status from a later command. Read the record's `reason` rather than the exit when a skill consumes this, which matters most here because the verb writes.
 

package/docs/ai-workflow.md

@@ -44,8 +44,8 @@ One session works for most features. Prefer splitting across two sessions only w
 
 Work in Claude Code directly. It reads `CLAUDE.md` automatically and has full file access, no pasting needed.
 
-- When the input is a pile of findings rather than one feature, invoke `aitk:claude-intake` first. It files the dump into `.claude/intake/<slug>/`, one item per finding carrying a problem measured against the tree, a proposed fix, and a verdict, then names which items are plan-ready, which need measuring, and which are already settled.
-- When the current state is unmeasured and more than one approach is live, invoke `aitk:claude-groundwork` first. It opens a track folder under `.claude/groundwork/<slug>/` and ends in a decision, which may be to do nothing. Skip it when the approach is already settled.
+- When the input is a pile of findings rather than one feature, invoke `aitk:claude-intake` first. It files the dump into `.claude/intake/<nn>-<slug>/`, one item per finding carrying a problem measured against the tree, a proposed fix, and a verdict, then names which items are plan-ready, which need measuring, and which are already settled.
+- When the current state is unmeasured and more than one approach is live, invoke `aitk:claude-groundwork` first. It opens a track folder under `.claude/groundwork/<nn>-<slug>/` and ends in a decision, which may be to do nothing. Skip it when the approach is already settled.
 - Invoke `aitk:claude-feature` to scan for code-level conflicts and ambiguities, confirm approach before proceeding
 - Implement the feature, then Claude Code runs the commands defined in `CLAUDE.md`, fixes failures, and iterates until all pass
 - For UI changes, invoke `aitk:claude-ui-test` to generate and run Playwright e2e tests

package/docs/target-projects.md

@@ -124,7 +124,7 @@ The report opens by naming the binary running it. The installed version reads ag
 
 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/config.json`, a stamp every install and sync writes. Snippets and governance record a hash per installed file. Tooling records the stack chain it resolved instead, since its install runs no per-file walk to attribute.
+That attribution comes from `.claude/aitk/config.json`, a stamp every install and sync writes. A target stamped before that path shipped is read from the retired `.claude/aitk.json` instead, reported rather than migrated. Snippets and governance record a hash per installed file. Governance also records the stack `aitk gov install` was given, and tooling records the stack chain it resolved instead of any file hash, since its install runs no per-file walk to attribute.
 
 Each domain holds its own toolkit commit, so syncing governance today does not move the revision snippets 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.
 
@@ -136,13 +136,15 @@ That third one matters most on an older project. Before it existed, a target hol
 
 #### Rules you never received
 
-A sync refreshes the files you already hold and adds none, so your rule set is frozen at the date you installed governance while every file in it reports as current. `newRules` names the rules the toolkit has authored since then, which is the one section that reads your absence rather than your contents.
+A sync refreshes the files you already hold and adds none, so your rule set is frozen at the date you installed governance while every file in it reports as current. `newRules` names a rule you could receive that your tree does not hold, which is the one section that reads your absence rather than your contents. `aitk gov sync` reports the same rules per file, marked `missing`, so you see them either way you check.
 
 Take a clean section as reporting rather than as delivering. Nothing here installs, and it counts toward nothing, so pick the rules up with `aitk gov install <stack>` or take one with `--add <rule>`. That separation is deliberate: adopting a rule changes what your project is governed by, which is a choice a sync has no business making for you.
 
-The list is filtered to what your stack can receive, read off the rule folders you already carry plus the folders the base stack takes whole. A rule under `lang/` or `ui/` belongs to some stacks and not others, so an unfiltered list would name rules you can never install. A target that has never stamped governance reports nothing at all, since there is no date to measure against.
+Since `aitk gov install` records the stack you gave it, the list is read by comparing that stack's current rules against what you hold right now, with no date involved at all. That is what lets it name a rule the toolkit shipped before you last synced: nothing here depends on when you installed. A target stamped before this recording shipped falls back to the older read below.
 
-An empty section is not proof either way when the toolkit running the check is not a full git clone. The read needs history to reach your anchor, and an install from the registry ships none, so the section goes quiet rather than saying it could not measure. Run the check from a clone before reading a clean result as a complete one.
+The fallback filters to what your stack can receive, read off the rule folders you already carry plus the folders the base stack takes whole. A rule under `lang/` or `ui/` belongs to some stacks and not others, so an unfiltered list would name rules you can never install. A target with neither a recorded stack nor a governance anchor reports nothing at all, since there is no date to measure against either.
+
+In the fallback, an empty section is not proof either way when the toolkit running the check is not a full git clone. The read needs history to reach your anchor, and an install from the registry ships none, so the section goes quiet rather than saying it could not measure. Run the check from a clone before reading a clean result as a complete one. The stack-based read above is untouched by this, since it consults no history.
 
 This also closes the case where a rule arrives citing a sibling you do not have. A sync refreshing a rule can land a version pointing at a file it never installs, and the section names the missing sibling rather than the broken citation, which is enough to act on.
 
@@ -177,7 +179,7 @@ Standards take no part in that run. Nothing installed them, so there is no copy
 ### Targeted
 
 - Claude seed docs such as `CLAUDE.md` and `.claude/REQUIREMENTS.md`: invoke `aitk:claude-seed-sync`. The skill splits each file into a preamble (between the H1 and the first H2) plus one part per `##` section, then diffs part by part and proposes per-part edits. User customizations are preserved.
-- Governance rules already installed: `aitk gov sync <path>` diffs and applies, and never adds new rules
+- Governance rules already installed: `aitk gov sync <path>` diffs and applies, and never adds new rules. A rule your recorded stack lists reports as `missing` instead.
 - Tooling configs and seeds: `aitk tooling <stack> <path>` overwrites golden configs and merges seeds
 - Reference docs for a stack: `aitk tooling ref <stack> <path>`
 - Index regeneration after markdown edits: `aitk indexes regen`

package/governance/rules/claude/556-groundwork.md

@@ -1,11 +1,15 @@
 ---
-description: Route .claude/groundwork/ edits to the groundwork standard for numbering, frontmatter, and required file contents
+description: Route .claude/groundwork/ edits to the groundwork standard for ordinal naming, numbering, frontmatter, and required file contents
 paths:
   - '.claude/groundwork/**'
 ---
 
 # Groundwork standards
 
+## Folder name
+
+- Name a new track `.claude/groundwork/<nn>-<slug>/`, a two-digit zero-padded ordinal followed by a kebab-case slug. Take the ordinal from the highest one already present across both `.claude/groundwork/` and `.claude/intake/`, incremented, or `01` when neither folder holds an entry. Never renumber an existing folder.
+
 ## Measuring and closing
 
 - Never carry a figure from an earlier session without re-measuring it. Mark an inference as an inference.

package/governance/rules/claude/557-intake.md

@@ -1,11 +1,15 @@
 ---
-description: Route .claude/intake/ edits to the intake standard for the item format, the answer contract, and numbering
+description: Route .claude/intake/ edits to the intake standard for the item format, the answer contract, and ordinal naming
 paths:
   - '.claude/intake/**'
 ---
 
 # Intake standards
 
+## Folder name
+
+- Name a new dump `.claude/intake/<nn>-<slug>/`, a two-digit zero-padded ordinal followed by a kebab-case slug. Take the ordinal from the highest one already present across both `.claude/intake/` and `.claude/groundwork/`, incremented, or `01` when neither folder holds an entry. Never renumber an existing folder.
+
 ## The answer contract
 
 - Never fill a `You:` slot and never infer a disposition from an empty one. Empty means unread, never agreement.

package/package.json

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

package/src/commands/gov.ts

@@ -35,6 +35,7 @@ import {
   type TestOrderReport,
 } from '@/gov/test-order'
 import { recordStamp, runDomainSync } from '@/sync/engine'
+import { writeChainStamp } from '@/sync/stamp'
 import { resolveTarget } from '@/target'
 import {
   intro,
@@ -757,7 +758,15 @@ async function runInstall(
 
   logStep('Installing rules')
   for (const rel of await installRules(found, resolved)) logAdd(rel)
-  await recordStamp(createGovAdapter(PROJECT_ROOT), resolved, new Date())
+
+  const now = new Date()
+  await recordStamp(createGovAdapter(PROJECT_ROOT), resolved, now)
+  await writeChainStamp(
+    resolved,
+    { domain: 'governance', toolkitRoot: PROJECT_ROOT },
+    [selected],
+    now,
+  )
 
   const { GREEN, NC } = palette(process.stderr)
   outro()

package/src/commands/sync.ts

@@ -99,6 +99,12 @@ function renderCheck(report: CheckReport): void {
 
   renderSkew(report)
 
+  if (report.stampAtLegacyPath) {
+    logWarn(
+      'Stamp found at the retired .claude/aitk.json. Move it to .claude/aitk/config.json.',
+    )
+  }
+
   if (!report.managed) {
     logStep('Not a toolkit project')
     logWarn('No .claude/ directory and no CLAUDE.md at the target.')
@@ -124,13 +130,20 @@ function renderCheck(report: CheckReport): void {
 
     for (const entry of domain.entries) {
       if (entry.state === 'matching' || entry.state === 'orphaned') continue
-      logWarn(`${entry.rel} (${entry.state})`)
+      logWarn(entry.notice ?? `${entry.rel} (${entry.state})`)
     }
 
-    const { stale, customized, drifted, stranded, orphaned } = domain.counts
+    const { stale, customized, drifted, stranded, orphaned, missing } =
+      domain.counts
     if (stale + customized + drifted + stranded === 0) {
       logInfo(orphaned === 0 ? 'up to date' : `up to date (${orphaned} local)`)
     }
+    // A local file is not a deficiency and a missing rule is, so this never
+    // shares the up-to-date line's parenthetical. It prints on its own,
+    // regardless of whether anything above needs a sync.
+    if (missing > 0) {
+      logWarn(`${missing} listed by the stack, not installed`)
+    }
 
     for (const commit of domain.upstream) {
       logInfo(`${commit.sha} ${commit.subject}`)
@@ -168,10 +181,10 @@ function renderCheck(report: CheckReport): void {
   if (report.newRules.length > 0) {
     logStep('New rules, never installed')
     for (const name of report.newRules) logWarn(name)
-    // Names the stack as the reader's to supply, since no target records one
-    // and `--add` layers onto a resolved stack rather than standing in for it.
+    // `install` re-resolves the whole stack rather than adding one rule, so
+    // the remedy names both routes rather than assuming the reader wants all.
     logInfo(
-      'Run `aitk gov install <stack>`, naming the stack yourself since no target records it. Add `--add <rule>` to take one.',
+      'Run `aitk gov install <stack>` to take the whole stack again, or `--add <rule>` to take one.',
     )
   }
 

package/src/demo/compile.ts

@@ -5,7 +5,7 @@ import type { Beat, Draft } from '@/demo/beats'
  * separate artifacts on purpose: a beat carries no target, no wait condition,
  * and no timing, and putting those four fields on every beat would destroy the
  * property the draft was designed around. See
- * `.claude/groundwork/demo-recorder/06-decision.md`.
+ * `.claude/groundwork/38-demo-recorder/06-decision.md`.
  *
  * A compiled plan is committed rather than scratch, because the timing below is
  * a starting point the operator tunes and the draft cannot reproduce a tuned

package/src/gov/adapter.ts

@@ -1,6 +1,8 @@
 import { existsSync } from 'node:fs'
 import { basename, join, relative, resolve } from 'node:path'
+import { resolveMissingRules } from '@/gov/stacks'
 import type { InstalledFile, RetiredSurface, SyncAdapter } from '@/sync/engine'
+import { readStamp, stampedChain } from '@/sync/stamp'
 
 const RETIRED_GOV_FILE = join('.claude', 'GOV.md')
 
@@ -54,11 +56,38 @@ export function createGovAdapter(root: string): SyncAdapter {
     locateSource: (file: InstalledFile) =>
       index.get(basename(file.path, '.md')),
     collectRetired: (target: string) => collectRetiredGov(target),
+    collectMissing: (target: string) => collectMissingGov(root, target),
     projectSubdir: 'project',
     stamp: { domain: 'governance', toolkitRoot: root },
   }
 }
 
+/**
+ * Rules the target's recorded chain entitles it to and its tree does not
+ * hold. Reports as `notice` text through the same shape `collectRetired`
+ * already returns, since both are surfaces the file walk cannot see: one an
+ * absence to remove, this one an absence to add.
+ */
+function collectMissingGov(root: string, target: string): RetiredSurface[] {
+  const chain = stampedChain(readStamp(target), 'governance')
+
+  return resolveMissingRules(root, target, chain).map((source) => {
+    const dest = join(
+      target,
+      '.claude',
+      'rules',
+      source.subdir,
+      `${source.rule}.md`,
+    )
+    const rel = relative(target, dest)
+    return {
+      path: dest,
+      rel,
+      notice: `${rel} (listed by ${chain[0]}, not installed. Run aitk gov install ${chain[0]} to add it.)`,
+    }
+  })
+}
+
 function collectRetiredGov(target: string): RetiredSurface[] {
   const path = join(target, RETIRED_GOV_FILE)
   if (!existsSync(path)) return []

package/src/gov/install.ts

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs'
-import { dirname, join, relative } from 'node:path'
+import { basename, dirname, join, relative } from 'node:path'
 import { copyPreservingMode } from '@/copy'
 
 export interface RuleSource {
@@ -21,6 +21,27 @@ export function installedRulesDir(target: string): string {
   return join(target, '.claude', 'rules')
 }
 
+/**
+ * Rule names a target already holds, read off the installed tree by basename
+ * rather than off a recorded stack, since a target may hold rules `--add`
+ * layered on that no stack lists.
+ */
+export function installedRuleNames(target: string): Set<string> {
+  const dir = installedRulesDir(target)
+  const names = new Set<string>()
+  if (!existsSync(dir)) return names
+
+  for (const rel of new Bun.Glob('**/*.md').scanSync({
+    cwd: dir,
+    onlyFiles: true,
+    dot: true,
+  })) {
+    names.add(basename(rel, '.md'))
+  }
+
+  return names
+}
+
 /**
  * Mirrors `rule_subdir` in `scripts/lib/gov.sh`, which stays in bash for the
  * sandbox loops. A rule sitting directly under `governance/rules/` has no

package/src/gov/stacks.ts

@@ -1,6 +1,12 @@
 import { existsSync, readFileSync, statSync } from 'node:fs'
 import { basename, join } from 'node:path'
-import { listRuleSourcePaths, rulesSourceDir } from '@/gov/install'
+import {
+  installedRuleNames,
+  listRuleSourcePaths,
+  lookupRules,
+  type RuleSource,
+  rulesSourceDir,
+} from '@/gov/install'
 
 export interface GovStack {
   readonly name: string
@@ -151,6 +157,32 @@ export function unreferencedRules(root: string): string[] {
     .sort()
 }
 
+/**
+ * Rules the target's recorded chain entitles it to that its installed tree
+ * does not hold. `resolveRules` already walks a stack's `extends` ancestors,
+ * so reading its leaf entry is enough; no second walk resolves the chain
+ * itself. A stack the toolkit no longer ships resolves to nothing rather than
+ * throwing, the same way `readNewRules`'s band fallback already treats it.
+ */
+export function resolveMissingRules(
+  root: string,
+  target: string,
+  chain: readonly string[],
+): readonly RuleSource[] {
+  const stack = chain[0]
+  if (stack === undefined) return []
+
+  const resolution = resolveRules(root, stack)
+  if (!resolution.ok) return []
+
+  const { found } = lookupRules(root, resolution.rules)
+  const held = installedRuleNames(target)
+
+  return found
+    .filter((source) => !held.has(source.rule))
+    .sort((left, right) => left.rule.localeCompare(right.rule))
+}
+
 /**
  * Layers `--add` names on top of a resolved stack. The bash trimmed a single
  * leading and trailing space per entry; trimming fully is the same result for

package/src/intake/folder.ts

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs'
 import { readdir, readFile, writeFile } from 'node:fs/promises'
-import { join, relative } from 'node:path'
+import { basename, join, relative } from 'node:path'
 import {
   INDEX_FILE,
   type IntakeItem,
@@ -13,6 +13,7 @@ import {
 export const INTAKE_REFUSALS = [
   'no-intake',
   'no-folder',
+  'ambiguous-slug',
   'no-cluster',
   'no-item',
   'answered',
@@ -110,6 +111,36 @@ async function listSlugs(dir: string): Promise<string[]> {
     .sort()
 }
 
+type SlugMatch =
+  | { readonly kind: 'matched'; readonly name: string }
+  | { readonly kind: 'ambiguous'; readonly names: readonly string[] }
+  | { readonly kind: 'none' }
+
+/**
+ * A folder carries a `<nn>-<slug>` name, but a caller names the topic alone.
+ * An exact match wins first, since it is what a name with no ordinal, or one
+ * already copied in full from a listing, resolves against. Otherwise the one
+ * entry whose name is an ordinal ahead of the given slug wins, which is what
+ * lets a topic keep working as its folder's identity gains a prefix. Two or
+ * more such entries is a collision the caller needs told apart from a typo,
+ * not a folder silently picked or silently missing.
+ */
+function matchSlug(names: readonly string[], slug: string): SlugMatch {
+  if (names.includes(slug)) return { kind: 'matched', name: slug }
+
+  const suffixed = names.filter(
+    (name) => name === `${extractOrdinal(name)}-${slug}`,
+  )
+
+  if (suffixed.length === 1) return { kind: 'matched', name: suffixed[0] }
+  if (suffixed.length > 1) return { kind: 'ambiguous', names: suffixed }
+  return { kind: 'none' }
+}
+
+function extractOrdinal(name: string): string {
+  return /^\d{2,}-/.exec(name)?.[0].slice(0, -1) ?? ''
+}
+
 async function openFolder(
   root: string,
   slug: string,
@@ -120,17 +151,22 @@ async function openFolder(
     return refuse('no-intake', `No intake at ${relative(root, dir)}.`)
   }
 
-  const folder = join(dir, slug)
+  const names = await listSlugs(dir)
+  const match = matchSlug(names, slug)
+
+  if (match.kind === 'none') {
+    return refuse('no-folder', `No intake folder named ${slug}.`, names)
+  }
 
-  if (!existsSync(folder)) {
+  if (match.kind === 'ambiguous') {
     return refuse(
-      'no-folder',
-      `No intake folder named ${slug}.`,
-      await listSlugs(dir),
+      'ambiguous-slug',
+      `More than one intake folder matches ${slug}.`,
+      match.names,
     )
   }
 
-  return folder
+  return join(dir, match.name)
 }
 
 /** Counts per folder, which is what a session picks a folder to work from. */
@@ -180,7 +216,11 @@ export async function readFolder(
   const opened = await openFolder(root, slug)
   if (typeof opened !== 'string') return opened
 
-  return { ok: true, slug, clusters: await readClusters(opened) }
+  return {
+    ok: true,
+    slug: basename(opened),
+    clusters: await readClusters(opened),
+  }
 }
 
 /**
@@ -272,7 +312,7 @@ export async function answerItems(
 
   return {
     ok: true,
-    slug,
+    slug: basename(opened),
     cluster: name,
     path,
     answered: selections,

package/src/sync/check.ts

@@ -3,7 +3,7 @@ import { basename, join, sep } from 'node:path'
 import { execa } from 'execa'
 import { gitEnv } from '@/git-env'
 import { createGovAdapter, rulesSourceDir } from '@/gov/adapter'
-import { loadGovStack } from '@/gov/stacks'
+import { loadGovStack, resolveMissingRules, resolveRules } from '@/gov/stacks'
 import { createSnippetsAdapter } from '@/snippets/adapter'
 import { planSync, type ScanEntry, type SyncAdapter } from '@/sync/engine'
 import {
@@ -19,6 +19,7 @@ import {
 } from '@/sync/reverse'
 import { buildSeedsReport, type SeedsReport } from '@/sync/seeds-report'
 import {
+  isLegacyStamped,
   readStamp,
   type Stamp,
   stampedChain,
@@ -71,6 +72,7 @@ export interface StateCounts {
   readonly drifted: number
   readonly orphaned: number
   readonly stranded: number
+  readonly missing: number
 }
 
 export interface DomainReport {
@@ -139,6 +141,12 @@ const UNMEASURED_TOOLING: ToolingReport = {
 
 export interface CheckReport {
   readonly covers: readonly StampDomain[]
+  /**
+   * True when the stamp `readStamp` found sits at the retired
+   * `.claude/aitk.json` path rather than the current one. Read only: nothing
+   * in the check migrates a target's config as a side effect of reporting it.
+   */
+  readonly stampAtLegacyPath: boolean
   /** False when the target is not a toolkit project, so every section stays empty. */
   readonly managed: boolean
   readonly domains: readonly DomainReport[]
@@ -204,7 +212,7 @@ export function buildToolingReport(
   target: string,
   stamp: Stamp | undefined,
 ): ToolingReport {
-  const chain = stampedChain(stamp)
+  const chain = stampedChain(stamp, 'tooling')
   const manifests = chain
     .map((name) => loadManifest(toolkitRoot, name))
     .filter((manifest) => manifest !== undefined)
@@ -270,6 +278,7 @@ export function countStates(entries: readonly ScanEntry[]): StateCounts {
     drifted: count(entries, 'drifted'),
     orphaned: count(entries, 'orphaned'),
     stranded: count(entries, 'stranded'),
+    missing: count(entries, 'missing'),
   }
 }
 
@@ -293,6 +302,11 @@ export function countStates(entries: readonly ScanEntry[]): StateCounts {
  * a file the project may own. `detectUnmigrated` already shipped that exact
  * false positive once, failing a push with no action that cleared it, and a
  * walk that reports `unattributed` by design would repeat it.
+ *
+ * `missing` is excluded on the same grounds `newRules` already reports on: a
+ * sync that adds a rule silently changes what a project is governed by, and
+ * nobody chose that, so gating CI on the count would pressure a target into
+ * adopting a rule nobody picked.
  */
 export function hasDrift(report: CheckReport): boolean {
   if (report.unmigrated.length > 0) return true
@@ -338,6 +352,7 @@ export async function buildCheckReport(
   if (!managed) {
     return {
       covers: [],
+      stampAtLegacyPath: isLegacyStamped(target),
       managed,
       domains: [],
       tooling: UNMEASURED_TOOLING,
@@ -353,6 +368,7 @@ export async function buildCheckReport(
 
   return {
     covers: stamp?.covers ?? [],
+    stampAtLegacyPath: isLegacyStamped(target),
     managed,
     domains,
     tooling: buildToolingReport(toolkitRoot, target, stamp),
@@ -360,11 +376,7 @@ export async function buildCheckReport(
     superseded: collectSuperseded(target),
     unmigrated,
     newSkills: await readNewSkills(toolkitRoot, anchors),
-    newRules: await readNewRules(
-      toolkitRoot,
-      target,
-      stampedCommit(stamp, 'governance'),
-    ),
+    newRules: await readNewRules(toolkitRoot, target, stamp),
     reverse: buildReverseReport(toolkitRoot, target),
     skew: await skewRead,
   }
@@ -529,14 +541,23 @@ export function baseBands(root: string): Set<string> {
 }
 
 /**
- * Rules are domain-scoped, so this measures from governance's own anchor rather
- * than from the oldest anchor across domains the way `readNewSkills` does. A
- * shared anchor would let a snippets sync move the revision rules are measured
- * from and drop a rule out of the read.
+ * A recorded chain answers this without the anchor at all: `resolveMissingRules`
+ * compares the entitled set against what the target holds right now, so a rule
+ * that shipped before the target's anchor is not a permanent blind spot the
+ * way the diff below leaves it. This is the primary path, and it is also what
+ * `collectMissing` reports per file through the domain scan, so a rule the
+ * chain names and the target lacks reaches both surfaces the same way.
+ *
+ * The diff-and-bands path stays as the fallback for a target stamped before
+ * governance recorded a chain. Rules are domain-scoped there too, so it
+ * measures from governance's own anchor rather than from the oldest anchor
+ * across domains the way `readNewSkills` does. A shared anchor would let a
+ * snippets sync move the revision rules are measured from and drop a rule out
+ * of the read.
  *
- * A target carrying no governance anchor reports nothing. It has no date to
- * measure against, and diffing from the beginning of history would read every
- * rule the toolkit ships as new.
+ * A target carrying no chain and no governance anchor reports nothing. It has
+ * no date to measure against, and diffing from the beginning of history would
+ * read every rule the toolkit ships as new.
  *
  * An anchor this clone cannot resolve reports nothing by a different route and
  * says so nowhere. `read` yields an empty string on a non-zero exit, so a stamp
@@ -544,12 +565,29 @@ export function baseBands(root: string): Set<string> {
  * as a target holding everything. `readNewSkills` carries the same gap, and
  * neither has the `historyUnavailable` flag the per-domain scan uses to tell an
  * unmeasured result from a clean one.
+ *
+ * A recorded chain naming a stack the toolkit no longer ships falls through to
+ * the band-based path below rather than reporting the empty list an
+ * unresolved chain would otherwise produce. That empty list reads exactly
+ * like a target holding everything, which is the same failure this function
+ * exists to close, so a retired stack name is read the same as no chain at
+ * all instead of reintroducing it.
  */
 export async function readNewRules(
   root: string,
   target: string,
-  since: string | undefined,
+  stamp: Stamp | undefined,
 ): Promise<string[]> {
+  const chain = stampedChain(stamp, 'governance')
+  const stack = chain[0]
+
+  if (stack !== undefined && resolveRules(root, stack).ok) {
+    return resolveMissingRules(root, target, chain)
+      .map((source) => source.rule)
+      .sort()
+  }
+
+  const since = stampedCommit(stamp, 'governance')
   if (since === undefined) return []
 
   const paths = await read(root, [

package/src/sync/engine.ts

@@ -61,6 +61,10 @@ export type SyncChange =
  * separate because they need opposite treatment. A project-authored file is
  * orphaned and stays that way forever. A stamped file the toolkit no longer
  * installs to is stranded, which is a relocation waiting on a decision.
+ *
+ * `missing` is the one state the walk cannot produce on its own, since the
+ * walk only iterates files that exist. It comes from `collectMissing`
+ * instead, an adapter naming an entitled file the target does not hold.
  */
 export type EntryState =
   | 'matching'
@@ -69,12 +73,19 @@ export type EntryState =
   | 'drifted'
   | 'orphaned'
   | 'stranded'
+  | 'missing'
 
 export interface ScanEntry {
   readonly state: EntryState
   readonly rel: string
   /** Toolkit revision this file's content came from, when history proved it. */
   readonly since?: string
+  /**
+   * Overrides `report`'s generic text for this entry's state. `collectMissing`
+   * is the one producer: a stack name is only known to the adapter that
+   * resolved it, and the generic `missing` line cannot carry one.
+   */
+  readonly notice?: string
 }
 
 export interface SyncPlan {
@@ -119,6 +130,12 @@ export interface SyncAdapter {
   locateSource(file: InstalledFile): string | undefined
   /** Surfaces the file walk cannot see, such as a retired doc to delete. */
   collectRetired?(target: string): RetiredSurface[]
+  /**
+   * Entitled files the walk cannot see because they do not exist yet.
+   * Reported as `missing` and queued as no change, since installing one
+   * changes what the project is governed by and stays a separate command.
+   */
+  collectMissing?(target: string): RetiredSurface[]
   /** Dropped from the walk, so neither matching nor orphaned. */
   isExcluded?(file: InstalledFile): boolean
   /**
@@ -210,6 +227,10 @@ export function planSync(adapter: SyncAdapter, target: string): SyncPlan {
 
   entries.push(...strandedByRelocation(target, hashes, walked))
 
+  for (const surface of adapter.collectMissing?.(target) ?? []) {
+    entries.push({ state: 'missing', rel: surface.rel, notice: surface.notice })
+  }
+
   const retired = adapter.collectRetired?.(target) ?? []
   for (const surface of retired) {
     changes.push({ kind: 'delete', dest: surface.path, rel: surface.rel })
@@ -394,6 +415,10 @@ function report(adapter: SyncAdapter, plan: SyncPlan): void {
       logWarn(`${entry.rel} (locally customized)`)
     else if (entry.state === 'stranded')
       logWarn(`${entry.rel} (installed here by an older toolkit, now moved)`)
+    else if (entry.state === 'missing')
+      logWarn(
+        entry.notice ?? `${entry.rel} (listed by the stack, not installed)`,
+      )
     else logWarn(`${entry.rel} (not in toolkit source, skipping)`)
   }
 

package/src/sync/stamp.ts

@@ -38,10 +38,12 @@ export interface DomainStamp {
   readonly syncedAt: string
   readonly files: DomainHashes
   /**
-   * Stack names the install resolved, nearest stack first. Present only for
-   * tooling. An ordered chain rather than the leaf name, because a stack that
-   * extends another cannot be reinstalled from its leaf alone, and a `--skip`
-   * run installs fewer layers than the leaf's own chain would reproduce.
+   * Stack names the install resolved. Tooling records the full ancestor chain,
+   * nearest stack first, because a stack that extends another cannot be
+   * reinstalled from its leaf alone, and a `--skip` run installs fewer layers
+   * than the leaf's own chain would reproduce. Governance records the single
+   * stack `aitk gov install` was given, since `resolveRules` walks its
+   * ancestors internally and a reader needs only the leaf to ask it again.
    */
   readonly chain?: readonly string[]
 }
@@ -56,6 +58,24 @@ export function stampPath(target: string): string {
   return join(target, '.claude', 'aitk', 'config.json')
 }
 
+/**
+ * Where `106115ba` moved the stamp from. No migration shipped with that move,
+ * so a target stamped before it still carries its config here, and `readStamp`
+ * falls back to this path when the current one is absent.
+ */
+export function legacyStampPath(target: string): string {
+  return join(target, '.claude', 'aitk.json')
+}
+
+/**
+ * Whether `readStamp` would resolve to the retired path, so a caller can
+ * report that a target's config still sits there. False when neither path
+ * exists, since there is nothing to migrate off of.
+ */
+export function isLegacyStamped(target: string): boolean {
+  return !existsSync(stampPath(target)) && existsSync(legacyStampPath(target))
+}
+
 export function hashContent(content: Buffer | string): string {
   return `sha256:${createHash('sha256').update(content).digest('hex')}`
 }
@@ -75,9 +95,22 @@ export function toStampKey(rel: string): string {
 /**
  * A missing or corrupt stamp reads as absent rather than failing, which is what
  * keeps every unstamped target on the existing unattributed path.
+ *
+ * Falls back to the retired path only when the current one does not exist,
+ * read only: nothing here migrates a target's config as a side effect of a
+ * report. The check is existence rather than a successful parse, so a
+ * corrupt current stamp reads as absent rather than silently serving the
+ * retired one beside it. `isLegacyStamped` tests the same existence check,
+ * which is what keeps the two agreeing on which path a corrupt current file
+ * was read from.
  */
 export function readStamp(target: string): Stamp | undefined {
-  const path = stampPath(target)
+  return existsSync(stampPath(target))
+    ? readStampFile(stampPath(target))
+    : readStampFile(legacyStampPath(target))
+}
+
+function readStampFile(path: string): Stamp | undefined {
   if (!existsSync(path)) return undefined
 
   try {
@@ -105,17 +138,22 @@ export function stampedHashes(
 }
 
 /**
- * The stack chain tooling last installed. An empty result is the state every
- * target predating the tooling record sits in, and the report reads it as
- * unmeasured rather than as clean.
+ * The stack chain a domain's install last recorded. An empty result is the
+ * state every target predating that domain's chain recording sits in, and a
+ * reader treats it as unmeasured rather than as clean.
  */
-export function stampedChain(stamp: Stamp | undefined): readonly string[] {
-  return stamp?.domains.tooling?.chain ?? []
+export function stampedChain(
+  stamp: Stamp | undefined,
+  domain: StampDomain,
+): readonly string[] {
+  return stamp?.domains[domain]?.chain ?? []
 }
 
 /**
- * Replaces one domain's record and leaves the others untouched, because domains
- * install and sync independently but share the one file.
+ * Replaces one domain's file hashes and leaves the others, including that
+ * domain's own chain, untouched. Domains install and sync independently but
+ * share the one file, and a chain an install recorded is a separate fact a
+ * later file-only sync must not erase.
  */
 export async function writeStamp(
   target: string,
@@ -127,37 +165,35 @@ export async function writeStamp(
 }
 
 /**
- * Records what tooling installed. `files` stays empty because `src/tooling/`
- * never runs the sync engine, so there is no per-file attribution to store and
- * the chain is the whole record.
+ * Records the stack chain an install resolved and leaves that domain's file
+ * hashes untouched. Tooling calls this with no files ever recorded, since
+ * `src/tooling/` never runs the sync engine and the chain is its whole record.
+ * Governance calls it alongside `writeStamp`, since it records both.
  */
 export async function writeChainStamp(
   target: string,
-  toolkitRoot: string,
+  source: StampSource,
   chain: readonly string[],
   now: Date,
 ): Promise<void> {
-  await putDomain(
-    target,
-    { domain: 'tooling', toolkitRoot },
-    { files: {}, chain: [...chain] },
-    now,
-  )
+  await putDomain(target, source, { chain: [...chain] }, now)
 }
 
 async function putDomain(
   target: string,
   source: StampSource,
-  payload: Pick<DomainStamp, 'files' | 'chain'>,
+  payload: Partial<Pick<DomainStamp, 'files' | 'chain'>>,
   now: Date,
 ): Promise<void> {
   const previous = readStamp(target)
+  const previousRecord = previous?.domains[source.domain]
   const commit = await toolkitCommit(source.toolkitRoot)
 
   const record: DomainStamp = {
     ...(commit === undefined ? {} : { commit }),
     syncedAt: now.toISOString(),
-    ...payload,
+    files: payload.files ?? previousRecord?.files ?? {},
+    ...resolveChainField(payload.chain, previousRecord?.chain),
   }
 
   const domains = sortDomains({
@@ -203,6 +239,19 @@ async function readCommit(root: string): Promise<string | undefined> {
     : undefined
 }
 
+/**
+ * A write naming no chain keeps the domain's previous one rather than dropping
+ * it, since `writeStamp` and `writeChainStamp` each touch one half of a
+ * governance record and neither should erase what the other wrote.
+ */
+function resolveChainField(
+  chain: readonly string[] | undefined,
+  previous: readonly string[] | undefined,
+): Pick<DomainStamp, 'chain'> {
+  const resolved = chain ?? previous
+  return resolved === undefined ? {} : { chain: resolved }
+}
+
 /** Deterministic key order keeps a re-sync diff empty and a merge conflict local. */
 function sortKeys(hashes: DomainHashes): DomainHashes {
   return Object.fromEntries(

package/src/tooling/stamp.ts

@@ -32,7 +32,7 @@ export async function recordToolingChain(
 
   await writeChainStamp(
     target,
-    toolkitRoot,
+    { domain: 'tooling', toolkitRoot },
     chain.map((manifest) => manifest.name),
     now,
   )

package/standards/groundwork.md

@@ -1,17 +1,17 @@
 ---
 title: Groundwork reference
-description: Folder layout, reserved numbering, frontmatter and dating, required file contents, and conventions for a measurement track
+description: Folder layout, ordinal naming, reserved numbering, frontmatter and dating, required file contents, and conventions for a measurement track
 ---
 
 # Groundwork reference
 
-Applies to a groundwork track at `.claude/groundwork/<slug>/`. A track measures one question that has to be settled before anyone can plan against it. The numbering is the table of contents, so a reader opens the folder and knows where to start and what follows without an index maintained inside each file.
+Applies to a groundwork track at `.claude/groundwork/<nn>-<slug>/`. A track measures one question that has to be settled before anyone can plan against it. The numbering inside the folder is the table of contents, so a reader opens the folder and knows where to start and what follows without an index maintained inside each file.
 
 The folder is gitignored and unbacked. No check reaches its contents and no history recovers a deleted one, so every rule here holds only while a session reads it, and the handoff file has to be self-contained.
 
 ## Scope
 
-Governs a groundwork track under `.claude/groundwork/<slug>/`: folder layout, reserved numbering, frontmatter and dating, what each required file holds, and the conventions a track keeps.
+Governs a groundwork track under `.claude/groundwork/<nn>-<slug>/`: folder layout, ordinal naming, reserved numbering, frontmatter and dating, what each required file holds, and the conventions a track keeps.
 
 Does not govern:
 
@@ -22,6 +22,13 @@ Does not govern:
 - Headings, punctuation, word choice, and file references: `markdown.md`
 - When a project opens a track at all, and the procedure that runs one, which belong to the surface driving it
 
+## Folder name
+
+- Name the folder `<nn>-<slug>`, a two-digit zero-padded ordinal followed by a kebab-case slug.
+- Take the ordinal from the highest one already present across both `.claude/groundwork/` and `.claude/intake/`, incremented. A listing then sorts by when each folder opened rather than alphabetically, and the count includes both kinds because the two share one creation-order line.
+- With neither folder holding an entry, the first one opened takes `01`. Do not read this off the numbering inside a track, which starts at `00` on a large one and disagrees with intake's own first file.
+- Never renumber an existing folder. The ordinal is the order it opened, and a later reader cites it by that name.
+
 ## What a working track looks like
 
 A track works when a session that has never seen it re-enters from the folder alone and can answer each of these:

package/standards/index.md

@@ -14,8 +14,8 @@ 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
 - [Glossary reference](glossary.md): Frontmatter, entry shape, ordering, and the rules deciding which terms a glossary carries
-- [Groundwork reference](groundwork.md): Folder layout, reserved numbering, frontmatter and dating, required file contents, and conventions for a measurement track
-- [Intake reference](intake.md): Folder layout, reserved index number, frontmatter and dating, the item template, the answer contract, and retrieval
+- [Groundwork reference](groundwork.md): Folder layout, ordinal naming, reserved numbering, frontmatter and dating, required file contents, and conventions for a measurement track
+- [Intake reference](intake.md): Folder layout, ordinal naming, reserved index number, frontmatter and dating, the item template, the answer contract, and retrieval
 - [Issue reference](issue.md): GitHub issue title, labels, and body conventions
 - [Markdown reference](markdown.md): Headings, paragraph and list structure, code spans, the date form, punctuation, emphasis, file references, banned words, and frontmatter wording
 - [Memory reference](memory.md): Filename and type prefix, frontmatter, the body shape per type, links between entries, and the lifecycle from write to retire

package/standards/intake.md

@@ -1,17 +1,17 @@
 ---
 title: Intake reference
-description: Folder layout, reserved index number, frontmatter and dating, the item template, the answer contract, and retrieval
+description: Folder layout, ordinal naming, reserved index number, frontmatter and dating, the item template, the answer contract, and retrieval
 ---
 
 # Intake reference
 
-Applies to an intake folder at `.claude/intake/<slug>/`. One folder holds one dump, filed by domain, and every finding in it is an item carrying a measured problem, one proposed fix, and a verdict.
+Applies to an intake folder at `.claude/intake/<nn>-<slug>/`. One folder holds one dump, filed by domain, and every finding in it is an item carrying a measured problem, one proposed fix, and a verdict.
 
 The folder is gitignored and unbacked. No check reaches its contents, so the shape below survives only by being read.
 
 ## Scope
 
-Governs an intake folder under `.claude/intake/<slug>/`: folder layout, the reserved index number, frontmatter and dating, the item format, the answer contract, and retrieval.
+Governs an intake folder under `.claude/intake/<nn>-<slug>/`: folder layout, ordinal naming, the reserved index number, frontmatter and dating, the item format, the answer contract, and retrieval.
 
 Does not govern:
 
@@ -22,6 +22,13 @@ Does not govern:
 - Headings, punctuation, word choice, and file references: `markdown.md`
 - Which findings belong in a dump at all, and the procedure that files one, which belong to the surface driving it
 
+## Folder name
+
+- Name the folder `<nn>-<slug>`, a two-digit zero-padded ordinal followed by a kebab-case slug. This is the folder's own ordinal, distinct from the `NN-<domain>.md` numbering a cluster file carries inside it.
+- Take the ordinal from the highest one already present across both `.claude/intake/` and `.claude/groundwork/`, incremented. A listing then sorts by when each folder opened rather than alphabetically, and the count includes both kinds because the two share one creation-order line.
+- With neither folder holding an entry, the first one opened takes `01`. Do not read this off the numbering inside a dump, which starts at `00` and disagrees with groundwork's own first required file.
+- Never renumber an existing folder. The ordinal is the order it opened, and a later reader cites it by that name.
+
 ## What a working intake looks like
 
 An intake works when a reader returning weeks later can act on it from the folder alone: