@sabaiway/agent-workflow-kit 14.36.0 → 14.38.0

package/CHANGELOG.md

@@ -4,6 +4,59 @@ Semantically versioned ([semver](https://semver.org)), newest first. The `versio
 is the current release. `upgrade` mode reads a project's `docs/ai/.workflow-version` and applies
 every `migrations/<version>-<slug>.md` newer than it, in semver order.
 
+## 14.38.0 — the upgrade and bootstrap lay the project-layout rules into your project and keep the file agents read current; with your own local rules the agent does the merge (AD-190)
+
+**`/agent-workflow-kit upgrade` and bootstrap now write the project-layout rules into `docs/ai/rules/`, keep
+`docs/ai/rules/effective/project-layout.md` a copy of them, and record what it was built from, so
+`rules-cli.mjs --check` answers `current`.** Where you keep your own rules in `docs/ai/rules/local/`, no code merges
+them: the upgrade prints the merge the agent does and the command that records it.
+
+- **A ninth upgrade ensure, `rules`,** runs after the spec layer and before the navigator, so the navigator lists the
+  files it lays. Its outcome is one of `seeded`, `refreshed`, `regenerated`, `pending`, `customized-preserved` or
+  `already-current`, or `failed` with its cause; `--dry-run` answers the `would-` form and writes nothing. Bootstrap
+  runs it as `ensure-configs.mjs --reconcile --only rules` in step 10, before the navigator re-run.
+- **The kit file `docs/ai/rules/<theme>.md`** is created when absent, kept when it is the bundled template, refreshed
+  when it holds a body an earlier release shipped, and kept byte for byte when you edited it: the line then says your
+  own rules belong in `docs/ai/rules/local/<theme>.md`, where they win. The catalog of earlier bodies ships empty, so
+  nothing is refreshed yet.
+- **With no local file** the effective file is rebuilt as the kit file's copy and its record entry is written; an
+  edited kit file with no frontmatter is kept and nothing else is written for that theme.
+- **With a local file** nothing is written to the effective file or the record; until the merge is recorded, the line
+  starts `merge needed — `, states how to merge (by meaning, the local file winning a conflict, the frontmatter kept,
+  the user shown what changed) and prints the exact `rules-cli.mjs --record` command to run after it.
+- **A `docs/ai/rules/effective/sources.json` that reads as UTF-8 text but is not JSON of the record's schema** is now
+  replaced by the record writer instead of stopping it, in `--record` and in the upgrade alike; a directory or a
+  symlink on its path still stops it, writing nothing.
+
+**Upgrade note.** No step: the next upgrade lays the theme. If it prints `merge needed`, the agent merges, shows you
+what changed and runs the printed command.
+
+## 14.37.0 — the first project rules theme, project layout, ships with the writer of a record of what each effective rules file was built from and a read-only check; nothing is laid into a project yet (AD-189)
+
+**The kit now carries default project rules as thematic prose files, starting with project layout, and a command
+line that checks the file agents read still stands for its sources.** This release ships the files' shape, the theme
+registry, the record's writer and the check; the upgrade op that lays the theme into your project comes in a later release,
+so this one writes no rules file into your project.
+
+- **Four files per theme.** `docs/ai/rules/<theme>.md` is the kit's rules, `docs/ai/rules/local/<theme>.md` is
+  yours and wins, `docs/ai/rules/effective/<theme>.md` is what agents read, and
+  `docs/ai/rules/effective/sources.json` records, per theme, the sha256 of the kit, local (or `absent`) and effective
+  files. Rules are plain prose with no keys; with no local file the effective file equals the kit file, with one an
+  agent merges the two by meaning once. No code merges two texts.
+- **The project-layout template** (`references/rules/project-layout.md`): a module is a directory holding its code,
+  tests, mocks, fixtures and command-line entry; its index exports only what is used outside; no README repeats its
+  spec; modules nest by meaning, never by technical layer; a spec's path mirrors its module's; old code keeps its
+  place as a recorded exception.
+- **`node tools/project-rules/rules-cli.mjs --check [--cwd <project>]`** prints one line per theme — `absent`,
+  `current`, `drift` naming every moved file, or `record` with its state — and writes nothing. It exits 0 when every
+  theme is `current` or `absent`, 1 otherwise, every stop line saying `run /agent-workflow-kit upgrade`; 2 is usage.
+  It judges only against the record, never against the bundled template.
+- **`--record --theme <name> --kit <sha256> --local <sha256|absent> --effective <sha256>`** is the merging agent's
+  call: it writes the theme's entry only when the files still hash to the passed digests and the effective file fits
+  the merge, and otherwise exits 1 naming the failed condition, writing nothing.
+
+**Upgrade note.** No step: the module ships, and no rules file reaches a project until the later upgrade op.
+
 ## 14.36.0 — the review lens runs on opus/high by default and its model is a setting; the task tier offer proposes the executor, not codex (AD-188)
 
 **The bundled review lens now takes its model and effort from `docs/ai/vehicles.json`, opus and high unless you set

package/SKILL.md

@@ -3,7 +3,7 @@ name: agent-workflow-kit
 description: Deploy or upgrade a portable AI-agent memory-and-workflow system in any project. Use when the user wants to bootstrap `docs/ai/` + an entry-point `AGENTS.md` (+ `CLAUDE.md` alias) + cap/archive/index enforcement in a new or existing repo, set up the Memory Map and session protocols, install the docs-rotation pre-commit hook, or run `/agent-workflow-kit` / `/agent-workflow-kit upgrade`. Triggers on phrases like "set up the memory system", "deploy the AI workflow here", "bootstrap docs/ai", "upgrade the workflow". New to the epic, story and task tier? Run `/agent-workflow-kit tier`. A typed decision with a confidence from Jev? Run `/agent-workflow-kit jev`.
 disable-model-invocation: true
 metadata:
-  version: '14.36.0'
+  version: '14.38.0'
 ---
 
 # agent-workflow-kit

package/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "agent-workflow-kit",
   "kind": "composition-root",
-  "version": "14.36.0",
+  "version": "14.38.0",
   "provides": [],
   "roles": {},
   "detect": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "14.36.0",
+  "version": "14.38.0",
   "description": "Portable, cross-agent memory & workflow for AI coding agents — Claude Code, Codex, Cursor, Devin Desktop. One command deploys an AGENTS.md entry point + docs/ai context with cap/archive/index enforcement into any repo.",
   "keywords": [
     "ai-agents",

package/references/modes/bootstrap.md

@@ -34,8 +34,10 @@ Requires: ${CLAUDE_SKILL_DIR}/references/shared/report-footer.md · ${CLAUDE_SKI
      - A **leftover machine-wide ignore block** from an older deployment is kept and reported (harmless — the project-local rules win); the advisor's `footprint-global` item of step 11 removes it on the user's yes after its check, which prints each line it removes — another of the user's repos may rely on the same machine-wide rules.
      - Report the result plainly (what is now hidden). **Windows is supported.**
    - **Do not edit `package.json`** in hidden mode — a tracked change leaks the whole system.
-10. **Stamp the deployment lineage.** **First re-run the step-7 navigator finalizer**
-    (`--ensure-index`) whenever a later step touched `docs/ai` — the reconciles that follow the
+10. **Stamp the deployment lineage.** In both paths, delegated and fallback, **first lay down the
+    project rules** — `node ${CLAUDE_SKILL_DIR}/tools/ensure-configs.mjs --reconcile --only rules --cwd <project>`,
+    relaying its line — **then re-run the step-7 navigator finalizer**
+    (`--ensure-index`) whenever a later step touched `docs/ai` — the rules run and the reconciles that follow the
     template copy do (the agent-rules lens,
     `${CLAUDE_SKILL_DIR}/references/shared/composition-handoff.md`); it is idempotent, so an
     untouched tree simply reports `already-current`. Then write the **deployment-lineage head** into

package/references/modes/upgrade.md

@@ -33,21 +33,23 @@ Requires: ${CLAUDE_SKILL_DIR}/references/shared/report-footer.md · ${CLAUDE_SKI
 
    **`footprint` — hidden-mode footprint reconcile (D9 / AD-014).** A deployment does not record whether it chose `hidden`, so first **infer visibility** — the dry-run writes **zero bytes** and reports one of — **visible** (the entry point is tracked) → nothing to do; **ambiguous** (untracked but not ignored — could be a fresh uncommitted repo, or a hide that broke) → **ASK** the user which it is, never guess; **hidden** → re-run without `--dry-run` to migrate any older **machine-global** hide to the **project-local** `.git/info/exclude` (one managed block; folds in the legacy `.claude/skills/` line), idempotently (a clean re-run is zero-diff). Handle its surfaced paths exactly as bootstrap step 9 (`${CLAUDE_SKILL_DIR}/references/modes/bootstrap.md`) (already-committed → show `git rm --cached`, ask before `--include`; generic-name present file → ask; **a leftover machine-wide ignore block is kept + reported — the advisor's `footprint-global` item removes it**). This runs on **every** hidden upgrade, like the methodology slot — no lineage-head bump, no migration file.
 
-   **`configs` — the project-configuration ensures, ONE run.** The ONE command performs **all eight** ensures — orchestration config · gate declaration · autonomy declaration · vehicles declaration · executor check · enforcement scripts · spec layer · navigator index — in a fixed order, and prints **one outcome line per ensure**: paste those lines into the step 4 / step 8 success report. Every SEED is **create-only** (an existing file is preserved byte-for-byte); a refresh-class op rewrites only what it owns — the outcome tokens by ensure, below, name each arm. One ensure failing **never** skips the others: each reports its own outcome and the run exits non-zero when any of them `failed`. The outcome tokens, by ensure: orchestration → `seeded` / `note-refreshed` / `already-current` / `customized-preserved` / `malformed-preserved`; gates, autonomy and vehicles → `seeded` / `already-present`; executor → `not-placed` / `already-current` / `pending`; scripts → `seeded` / `already-present` / `old-adr-layout-migration-instructed` / `skipped-no-node-evidence`; specs → `seeded` / `refreshed` / `already-present` / `customized-preserved` / `skipped-no-node-evidence`; index → `regenerated` / `already-current` / `customized-preserved`; and any ensure may report `failed`, whose line OPENS with the cause (relay it with that cause — never soften it into a skip; an op that copies file by file also states when it stopped partway). The cause vocabulary is CLOSED — one of `race-unresolved`, `template-unreadable`, `bundle-unreadable`, `adr-layout-unverifiable`, `node-evidence-unverifiable`, `wrong-node-kind`, `vehicle-settings-unreadable`, `write-refused`, `unexpected-error`, `generator-unlaunchable`, `generator-failed`, `index-probe-failed`, `index-stale-after-write` — and every cause that can only arise AFTER the generator ran (`generator-failed`, and `index-probe-failed` / `index-stale-after-write` when they follow a reported regeneration) DISCLOSES in its own line that a write may already have landed. **A non-zero exit STOPs this upgrade — once row 3's replace ask is answered when a specs replace line printed, then as that ask says** — before the equal-head exit, the migrations and the re-stamp. Add `--dry-run` to preview without writing a byte. Like the pointer slots + the footprint reconcile, all eight reach an equal-head deployment **without a lineage-head bump or a migration file** (all inherently outside the docs cap-validator).
+   **`configs` — the project-configuration ensures, ONE run.** The ONE command performs **all nine** ensures — orchestration config · gate declaration · autonomy declaration · vehicles declaration · executor check · enforcement scripts · spec layer · project rules · navigator index — in a fixed order, and prints **one outcome line per ensure**: paste those lines into the step 4 / step 8 success report. Every SEED is **create-only** (an existing file is preserved byte-for-byte); a refresh-class op rewrites only what it owns — the outcome tokens by ensure, below, name each arm. One ensure failing **never** skips the others: each reports its own outcome and the run exits non-zero when any of them `failed`. The outcome tokens, by ensure: orchestration → `seeded` / `note-refreshed` / `already-current` / `customized-preserved` / `malformed-preserved`; gates, autonomy and vehicles → `seeded` / `already-present`; executor → `not-placed` / `already-current` / `pending`; scripts → `seeded` / `already-present` / `old-adr-layout-migration-instructed` / `skipped-no-node-evidence`; specs → `seeded` / `refreshed` / `already-present` / `customized-preserved` / `skipped-no-node-evidence`; rules → `seeded` / `refreshed` / `regenerated` / `pending` / `customized-preserved` / `already-current`; index → `regenerated` / `already-current` / `customized-preserved`; and any ensure may report `failed`, whose line OPENS with the cause (relay it with that cause — never soften it into a skip; an op that copies file by file also states when it stopped partway). The cause vocabulary is CLOSED — one of `race-unresolved`, `template-unreadable`, `bundle-unreadable`, `adr-layout-unverifiable`, `node-evidence-unverifiable`, `wrong-node-kind`, `vehicle-settings-unreadable`, `write-refused`, `unexpected-error`, `generator-unlaunchable`, `generator-failed`, `index-probe-failed`, `index-stale-after-write` — and every cause that can only arise AFTER the generator ran (`generator-failed`, and `index-probe-failed` / `index-stale-after-write` when they follow a reported regeneration) DISCLOSES in its own line that a write may already have landed. **A non-zero exit STOPs this upgrade — once row 3's replace ask is answered when a specs replace line printed, then as that ask says** — before the equal-head exit, the migrations and the re-stamp. Add `--dry-run` to preview without writing a byte. Like the pointer slots + the footprint reconcile, all nine reach an equal-head deployment **without a lineage-head bump or a migration file**.
 
-   **What the orchestration-config ensure does.** `docs/ai/orchestration.json` must exist **and its onboarding note must be current**: created from the canonical seed if missing; if it already exists, **every activity/slot the user set is preserved** and ONLY the `_README` note is refreshed, and only when the existing one still matches a known prior canonical — the tested `refreshIfCanonical` / `refreshReadme` in `tools/orchestration-config.mjs` is the source of truth for that decision (it normalizes CRLF/whitespace before comparing; a *customized* `_README` is preserved verbatim → `customized-preserved`; a *malformed* existing config is **preserved untouched + LOUD** → `malformed-preserved`, never clobbered and never silently skipped). The current note points at `/agent-workflow-kit set-recipe`. **Kit-owned:** in the **delegated** path memory only seeds/preserves the file (memory upgrade step 2) and this ensure applies the `_README` refresh; in the **fallback** path it does both. (Memory stays standalone.)
+   **What the orchestration-config ensure does.** `docs/ai/orchestration.json` must exist **and its onboarding note must be current**: created from the canonical seed if missing; if it already exists, **every activity/slot the user set is preserved** and ONLY the `_README` note is refreshed, and only when the existing one still matches a known prior canonical — `refreshIfCanonical` / `refreshReadme` in `tools/orchestration-config.mjs` decide it (CRLF/whitespace normalized first; a *customized* `_README` is preserved verbatim → `customized-preserved`; a *malformed* existing config is **preserved untouched + LOUD** → `malformed-preserved`, never clobbered and never silently skipped). The current note points at `/agent-workflow-kit set-recipe`. **Kit-owned:** in the **delegated** path memory only seeds/preserves the file (memory upgrade step 2) and this ensure applies the `_README` refresh; in the **fallback** path it does both. (Memory stays standalone.)
 
-   **What the gate-declaration ensure does.** `docs/ai/gates.json` must exist: created from `${CLAUDE_SKILL_DIR}/references/templates/gates.json` if missing — the kit's OWN template twin, so a memory substrate predating the gates feature never silently loses it; **an existing file is preserved byte-for-byte** (a project's declared gate matrix is authored content; unlike the orchestration `_README` there is no note-refresh here).
+   **What the gate-declaration ensure does.** `docs/ai/gates.json` must exist: created from `${CLAUDE_SKILL_DIR}/references/templates/gates.json` if missing — the kit's OWN template twin, so a memory substrate predating the gates feature never silently loses it; **an existing file is preserved byte-for-byte** (a declared gate matrix is authored content; no note-refresh here).
 
    **What the autonomy-declaration ensure does.** `docs/ai/autonomy.json` must exist: created from `${CLAUDE_SKILL_DIR}/references/templates/autonomy.json` if missing (the kit's own template twin — a stale memory never silently loses the seed); **an existing file is preserved byte-for-byte** (a declared policy is authored content). The seed is SPARSE (the onboarding note only) and **defaults-equivalent** — deploying it never changes behavior (the computed defaults stay the policy until the user declares levels with `/agent-workflow-kit set-autonomy` or by hand).
 
    **What the executor ensure does.** It never writes: a placed `.claude/agents/executor.md` whose bytes differ from the body derived from `docs/ai/vehicles.json` is `pending` — the advisor's `executor-vehicle.differing` item re-derives it on the user's yes — and an absent one is `not-placed` (the agents mode places it on consent).
 
-   **What the enforcement-script ensure does.** A deployment older than the ADR-cascade feature has no `scripts/archive-decisions.mjs`, and an equal-head exit would otherwise never deliver it. The pairs must exist in the project's `scripts/`: `archive-decisions.mjs` + `archive-decisions.test.mjs` and `markdown-blocks.mjs` + `markdown-blocks.test.mjs`, copied from `${CLAUDE_SKILL_DIR}/references/scripts/` if missing; **an existing file is preserved, never overwritten** (drift repair belongs to a lineage migration). Nothing else is seeded — the other tokenizer-era tests red beside OLD archivers. **OLD ADR-store layout — DETECTED FIRST, never auto-migrated (AD-051, Decision 13):** on a `docs/ai/history/decisions-archive*.md` monolith (`old`), or no monolith but a deployed rotator predating the store (`old-unrotated`), the project is on the RETIRED 3-tier cascade, so the ensure writes NOTHING and reports `old-adr-layout-migration-instructed` (the new `archive-decisions.mjs` beside un-migrated monoliths would red their ADR gate). Relay it as the LOUD instruct it is: the fix is the opt-in **`/agent-workflow-kit migrate-adr-store`** (consent-gated; previews first, never commits), and the seed lands on the next upgrade. A layout the ensure cannot READ is `failed`, not a seed — it never writes on an unverifiable tree. The seed applies ONLY to a clean layout (neither signal). **Whether Node runs here is PROVEN, never proxied:** the ensure seeds on a regular `package.json` at the root OR on any kit-seeded `scripts/*.mjs` already deployed (a bootstrap places them into projects that never carry a `package.json`); only when every probe answers absent does it report `skipped-no-node-evidence`, a line naming every probe it checked, while the config ensures still run; a probe that cannot be read is `failed` with the cause `node-evidence-unverifiable`, nothing written. **A `skipped-*` outcome whose stated reason this tool could itself disprove may not exist** — the retired `skipped-no-node` was exactly that, printed beside twenty deployed Node scripts. The deployed pre-commit hook gains the `archive-decisions.mjs --check` line only when the hook itself is next refreshed (the `enforcement` check line and apply, by the consent route, copy nothing and re-run the installer, which refuses a non-marker hook as always); an OLD hook without the line stays consistent-safe — the decisions gate is simply not enforced yet, never a broken hook.
+   **What the enforcement-script ensure does.** A deployment older than the ADR-cascade feature has no `scripts/archive-decisions.mjs`, and an equal-head exit would otherwise never deliver it. The pairs must exist in the project's `scripts/`: `archive-decisions.mjs` + `archive-decisions.test.mjs` and `markdown-blocks.mjs` + `markdown-blocks.test.mjs`, copied from `${CLAUDE_SKILL_DIR}/references/scripts/` if missing; **an existing file is preserved, never overwritten** (drift repair belongs to a lineage migration). Nothing else is seeded — the other tokenizer-era tests red beside OLD archivers. **OLD ADR-store layout — DETECTED FIRST, never auto-migrated (AD-051, Decision 13):** on a `docs/ai/history/decisions-archive*.md` monolith (`old`), or no monolith but a deployed rotator predating the store (`old-unrotated`), the project is on the RETIRED 3-tier cascade, so the ensure writes NOTHING and reports `old-adr-layout-migration-instructed` (the new `archive-decisions.mjs` beside un-migrated monoliths would red their ADR gate). Relay it as the LOUD instruct it is: the fix is the opt-in **`/agent-workflow-kit migrate-adr-store`** (consent-gated; previews first, never commits), and the seed lands on the next upgrade. A layout the ensure cannot READ is `failed`, writing nothing. The seed applies ONLY to a clean layout (neither signal). **Whether Node runs here is PROVEN, never proxied:** the ensure seeds on a regular `package.json` at the root OR on any kit-seeded `scripts/*.mjs` already deployed; only when every probe answers absent does it report `skipped-no-node-evidence`, a line naming every probe it checked, while the config ensures still run; a probe that cannot be read is `failed` with the cause `node-evidence-unverifiable`, nothing written. **A `skipped-*` outcome whose stated reason this tool could itself disprove may not exist**. The deployed pre-commit hook gains the `archive-decisions.mjs --check` line only when the hook is next refreshed (the `enforcement` check line and apply, by the consent route, copy nothing and re-run the installer, which refuses a non-marker hook as always); an OLD hook without the line is safe — the decisions gate is simply not enforced yet.
 
-   **What the navigator ensure does.** `docs/ai/index.md` is the always-loaded navigator the entry point declares, and it is GENERATED — no template ships it, so a deployment that never ran the generator boots from a broken entry point (and, on a Node project, carries a pre-commit hook that fails its own index check). The ensure runs the bundled generator's finalizer and reports `regenerated` (it was missing or stale — it was written) or `already-current` (nothing written); under a hook module that is not the bundled one, a write the project's own checker rejects is put back → `customized-preserved`. It never skips a No-Node project: the generator runs from `${CLAUDE_SKILL_DIR}/references/scripts/` on the agent host, not from the project's `scripts/`. **Its position in the run-list is EARLY and therefore NOT authoritative** — `lens` (and, on the migrated path, steps 6–7) still change `docs/ai` afterwards — so the authoritative run is the LATE `--only index` rung documented at both exits; the early one is idempotent: an untouched tree changes nothing.
+   **What the navigator ensure does.** `docs/ai/index.md` is the always-loaded navigator the entry point declares, and it is GENERATED — no template ships it, so a deployment that never ran the generator boots from a broken entry point (and a Node project's hook fails its index check). The ensure runs the bundled generator's finalizer and reports `regenerated` (it was missing or stale — it was written) or `already-current` (nothing written); under a hook module that is not the bundled one, a write the project's own checker rejects is put back → `customized-preserved`. It never skips a No-Node project: the generator runs from `${CLAUDE_SKILL_DIR}/references/scripts/` on the agent host, not from the project's `scripts/`. **Its position in the run-list is EARLY and therefore NOT authoritative** — `lens` (and, on the migrated path, steps 6–7) still change `docs/ai` afterwards — so the authoritative run is the LATE `--only index` rung documented at both exits; the early one is idempotent: an untouched tree changes nothing.
 
-   **What the spec-layer ensure does.** A deployment older than the feature-spec layer lacks `scripts/spec-schema.mjs` and `docs/ai/specs/index.md`, and its deployed `check-docs-size.mjs` predates the store collapse. In ONE order: the reader pair, then the checker pair — each seeded when absent and REFRESHED only while a file's bytes are a body a release shipped (an append-only digest catalog → `refreshed`; an edited body is preserved verbatim and withholds the writes that depend on it, the checker lane waiting on a byte-current reader pair); the store root is seeded from the bundled template, date rendered, ONLY behind a checker pair current after the run — an older or edited checker renders the store row by row and reds the hook's `--check-index`; edited files are replaced only on row 3's yes. One token by precedence: `seeded` > `refreshed` > `customized-preserved` (an edited pair, and this run wrote nothing) > `already-present`; `skipped-no-node-evidence` only when neither a root `package.json` nor any kit-seeded `scripts/*.mjs` is present (the same Node-evidence probe the enforcement-script ensure uses; an unreadable probe is `failed` / `node-evidence-unverifiable`); every line states what this run did, and a write that stops partway names what landed. The legacy-ADR instruct never withholds it. **The adoption state this seed leaves behind is reported, never assumed:** the Recommendations section (step 4 / 8) carries the `spec-adoption` item — `not adopted` (the store is absent: the seed offered, the decline the agent records), `adopting` (a store with no live contract: the decline offered), silenced by a recorded decline (`ack-write --lane spec-adoption`), and a store the probe cannot read is a stated skip — and `status` prints the same state on its own line.
+   **What the spec-layer ensure does.** A deployment older than the feature-spec layer lacks `scripts/spec-schema.mjs` and `docs/ai/specs/index.md`, and its deployed `check-docs-size.mjs` predates the store collapse. In ONE order: the reader pair, then the checker pair — each seeded when absent and REFRESHED only while a file's bytes are a body a release shipped (an append-only digest catalog → `refreshed`; an edited body is preserved verbatim and withholds the writes that depend on it, the checker lane waiting on a byte-current reader pair); the store root is seeded from the bundled template, date rendered, ONLY behind a checker pair current after the run — an older or edited checker renders the store row by row and reds the hook's `--check-index`; edited files are replaced only on row 3's yes. One token by precedence: `seeded` > `refreshed` > `customized-preserved` (an edited pair, and this run wrote nothing) > `already-present`; `skipped-no-node-evidence` only when neither a root `package.json` nor any kit-seeded `scripts/*.mjs` is present (the same Node-evidence probe the enforcement-script ensure uses; an unreadable probe is `failed` / `node-evidence-unverifiable`). The legacy-ADR instruct never withholds it. **The adoption state this seed leaves behind is reported, never assumed:** the Recommendations section (step 4 / 8) carries the `spec-adoption` item — `not adopted` (the store is absent: the seed offered, the decline the agent records), `adopting` (a store with no live contract: the decline offered), silenced by a recorded decline (`ack-write --lane spec-adoption`), and a store the probe cannot read is a stated skip — and `status` prints the same state on its own line.
+
+   **What the project-rules ensure does.** Each theme's kit file `docs/ai/rules/<theme>.md` is seeded, refreshed only from a body a release shipped (an edit is kept → `customized-preserved`), and with no local file its effective copy and record are rebuilt. With a local file it writes neither: `pending` prints the merge to do and its record command — do the merge, show the user what changed, then run that command.
 
    **`gates-migration` — legacy gates.json migration (consented preview — D8).** An EXISTING declaration may still carry the retired review-ledger / fold-completeness checks. Run the preview (dry-run — writes NOTHING), show the user the exact plan, and only on an explicit yes re-run it with `--apply`: canonical legacy entries (matched by their documented single-invocation cmd forms) are REMOVED, the canonical `unit-tests` cmd gains the built-in lcov reporters, and the coverage-check gate is ADDED last — atomic and COMPLETE, so the migrated declaration satisfies `run-gates --final`. **The checker rides a PRODUCER or is not declared at all** (`${CLAUDE_SKILL_DIR}/references/modes/gates.md`): with no gate producing the lcov it reads, the migration does NOT add it, an already-declared one is reported INERT, the result is not called final-run-capable, and the preview prints the paste-ready suite cmd to declare by hand — nothing is ever removed for you. CUSTOMIZED entries are NEVER auto-touched: the preview names each with a paste-ready recovery, and the commit guard must NOT be installed until they are resolved. Of step 3's run-list, only this migration and `tools/checker-gates.mjs` under the `tier` ask change an existing gates.json (the FILL preview runs at init).
 
@@ -111,7 +113,7 @@ Requires: ${CLAUDE_SKILL_DIR}/references/shared/report-footer.md · ${CLAUDE_SKI
    **The LATE navigator finalizer — the AUTHORITATIVE run, after the last `docs/ai` mutation.** `lens` above rewrites `docs/ai/agent_rules.md`, so the step-3 index ensure is already behind by the time the run-list ends. Re-run that ONE op here, before the step-4 report: `node ${CLAUDE_SKILL_DIR}/tools/ensure-configs.mjs --reconcile --only index --cwd <project>`. Relay **this** line in the report (it supersedes the early one; an untouched tree changes nothing, a failure STOPs the upgrade like any other ensure). On the migrated path the same rung runs again at the END of step 7 — after the migrations, before the step-8 re-stamp.
 4. **Equal-head exit — a real successful-exit report, not a bare stop.** If the stamp **equals** the head, the lineage is up to date — but step 3 (the stamp-independent reconciles) ran first and may have changed things, so this is a proper exit report, not a no-op:
    - **A skip line that contradicts the observed tree is a FINDING, never pasted as neutral.** Every ensure skip names the fact it proved (the probes that answered absent, the layout it read); if the tree you can see disproves that reason — a "no Node" skip beside deployed Node scripts, a "not deployed" skip beside a stamped `docs/ai` — do not relay the line as an outcome: raise it in the report as a defect of the tool, with the contradicting fact named, and stop short of any step that would build on the skip.
-   - **Report step 3's outcome in plain language** — for **each** `pointers` slot (workflow-methodology, orchestration-recipes and autonomy-policy) whether it was *added*, was *already present* (nothing changed), or was *skipped* (the soft-skip from step 3, with its reason — over the line limit / engine too old / the autonomy pointer's anchor absent); the **eight project-configuration ensure** (`configs`) lines exactly as the one ensure run composed them (the ensures and their outcome tokens are enumerated in step 3), each rendered in plain language: what was created, what was left exactly as the user wrote it, and — for a `failed` line — what stopped it; for the navigator, relay the **late** `--only index` line, not the early one; the **`gates-migration`** result — *nothing to migrate*, the shown plan *applied* on your explicit yes, or the plan *left unapplied* (consent not given), with any INERT checker or CUSTOMIZED entries named; the **placed-bridge refresh** (`bridges`) outcome — paste the tool's per-bridge lines verbatim (they are already plain: *refreshed* / *already current* / *skipped — not placed* / `skipped-readonly` with its re-scan verdict / *could not refresh* + recovery); the **agent-rules lens** (`lens`) outcome (*refreshed* / *already current* / *custom edit preserved + note* / *file absent* / *engine too old* / *over the line cap*) and the **Communication-section** outcome (its own set: refreshed / already current / custom preserved + note / section absent — noted / over the cap — refused) and the **story-sessions section** outcome (its own set: refreshed / already current / custom edit preserved + note / section absent — noted / over the file's line cap — refused); the **full-flow offer** (`tier`) lines; the **bridge-settings reconcile** (`bridge-settings`) outcome (paste the tool's line(s) verbatim); and, for a hidden deployment, whether the hidden-mode footprint (`footprint`) was *moved to project-local*, was *already project-local* (nothing changed), or needed a question (ambiguous visibility). Plain wording only — never the reconcile/slot/anchor/marker terms (the never-leak-kit-internals Gotcha — `${CLAUDE_SKILL_DIR}/references/shared/deploy-tail.md`).
+   - **Report step 3's outcome in plain language** — for **each** `pointers` slot (workflow-methodology, orchestration-recipes and autonomy-policy) whether it was *added*, was *already present* (nothing changed), or was *skipped* (the soft-skip from step 3, with its reason — over the line limit / engine too old / the autonomy pointer's anchor absent); the **nine project-configuration ensure** (`configs`) lines exactly as the one ensure run composed them (the ensures and their outcome tokens are enumerated in step 3), each rendered in plain language: what was created, what was left exactly as the user wrote it, and — for a `failed` line — what stopped it; for the navigator, relay the **late** `--only index` line, not the early one; the **`gates-migration`** result — *nothing to migrate*, the shown plan *applied* on your explicit yes, or the plan *left unapplied* (consent not given), with any INERT checker or CUSTOMIZED entries named; the **placed-bridge refresh** (`bridges`) outcome — paste the tool's per-bridge lines verbatim (they are already plain: *refreshed* / *already current* / *skipped — not placed* / `skipped-readonly` with its re-scan verdict / *could not refresh* + recovery); the **agent-rules lens** (`lens`) outcome (*refreshed* / *already current* / *custom edit preserved + note* / *file absent* / *engine too old* / *over the line cap*) and the **Communication-section** outcome (its own set: refreshed / already current / custom preserved + note / section absent — noted / over the cap — refused) and the **story-sessions section** outcome (its own set: refreshed / already current / custom edit preserved + note / section absent — noted / over the file's line cap — refused); the **full-flow offer** (`tier`) lines; the **bridge-settings reconcile** (`bridge-settings`) outcome (paste the tool's line(s) verbatim); and, for a hidden deployment, whether the hidden-mode footprint (`footprint`) was *moved to project-local*, was *already project-local* (nothing changed), or needed a question (ambiguous visibility). Plain wording only — never the reconcile/slot/anchor/marker terms (the never-leak-kit-internals Gotcha — `${CLAUDE_SKILL_DIR}/references/shared/deploy-tail.md`).
    - **Never surface the structure number on this exit.** Whatever step 3 did, do **not** recite the `docs/ai` structure version, the internal versioning vocabulary, or the two-axes note here — the number is inert on an equal-head exit; it belongs to *Version disclosure* in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md` (shown at the never-downgrade STOP, the explicit status view, or on an explicit ask). Frame the success itself per the final bullet: if step 3 changed anything, say **what changed** in plain human terms; only a pure zero-diff no-op is *settings already current — no update needed*.
    - **Render the mandatory Recommendations section — on this exit too, BEFORE the footer.** Run `node ${CLAUDE_SKILL_DIR}/tools/recommendations.mjs --cwd <project-root>` and PRESENT its output — from the `## Recommendations (agent-workflow)` header — in the user's conversational language: every fact, count and item from the tool, nothing added or dropped; commands, paths, hosts and rule strings byte-exact; show the raw tool block on request. The section is present-even-when-empty (with everything optimal the body is exactly `no recommendations — flow optimal.`) and VERDICT-FIRST — the composed verdict line renders from the frozen templates `{K} item(s) need attention` / `nothing is broken` / `{N} optional recommendation(s), apply any you want` / `optimality NOT attested — {M} probe check(s) skipped`. Then OFFER the consent route: the user picks items in plain language; surface each picked item's posture note and get the explicit confirm; run its lane's rendered lines — chat: the one-liner; harness: the check line, then on the yes to its result the apply line; user: the user's own step — per the full consent route in `${CLAUDE_SKILL_DIR}/references/modes/recommendations.md`. Pinned order on this exit: Recommendations block → optional applies → report footer → the commit ask (the advisor/apply lane never lands after the commit ask).
    - **Recommendations lanes — both exits.** The three lanes (`chat`, `harness`, `user`) and the consent route live in `${CLAUDE_SKILL_DIR}/references/modes/recommendations.md`; `init` stays a route the user may take.
@@ -121,4 +123,4 @@ Requires: ${CLAUDE_SKILL_DIR}/references/shared/report-footer.md · ${CLAUDE_SKI
 5. Show the relevant `${CLAUDE_SKILL_DIR}/CHANGELOG.md` diff (entries newer than the project's stamp).
 6. **Collect the migration answers FIRST, then apply.** Run `node ${CLAUDE_SKILL_DIR}/tools/migration-notes.mjs --cwd <project>` and relay its stdout lines verbatim, in order; a non-zero exit relays its one named line and STOPs, except `stamp-absent`, which routes back to step 1. Then run the preview `node ${CLAUDE_SKILL_DIR}/tools/migration-blocks.mjs --cwd <project>`. If its lines say both blocks are missing (pre-1.1.0), ask the two questions as ONE structured multi-question prompt; record each answer individually, write nothing until ALL are answered, and carry the answers into the migrations below: a migration whose answer was already collected never re-asks; a single missing block keeps its single ask (step 7). Then apply exactly the notes the tool listed, in its order ("only those newer than the project's stamp" is why, never a second selection). Migrations are **idempotent** — safe to re-run.
 7. Reconcile drift: add any kernel files/scripts the project is missing; never clobber project-authored content (their `decisions.md`, `known_issues.md`, page specs stay). Any user question a migration raises follows the same rule as bootstrap — **structured multiple-choice where supported** (`AskUserQuestion` in Claude Code), otherwise prose. For a block the preview names as needing its answer, **ask the user their conversational language** (`--language`) or **whether the agent may attribute work to itself / AI** (`--attribution`, defaulting to `off`), never re-asking a step-6 answer; then re-run the preview with `--apply` and the answers, relaying its lines. Exit 1 `answer-missing`: ask exactly what its lines name and re-run `--apply` once; a second one STOPs. Any other exit 1 is a named refusal: relay it with its recovery (`cap`: trim `AGENTS.md`, re-run) and STOP before the finalizer and the stamp. **Then, before the stamp, re-run the LATE navigator finalizer:** the migrations of steps 6–7 may have changed `docs/ai` files, so run the one op again — `node ${CLAUDE_SKILL_DIR}/tools/ensure-configs.mjs --reconcile --only index --cwd <project>` — and relay THAT line in the step-8 report (idempotent: an untouched tree changes nothing; a failure STOPs this upgrade like any other ensure).
-8. Re-stamp `docs/ai/.workflow-version` to the **deployment-lineage head** (`4.0.0`, not the package version — mechanics unchanged: the atomic write to the stamp file). In the report, **describe what the upgrade changed in plain human terms** — which parts of their `docs/ai` are now different (the migrations that ran), plus the step-3 run-list outcomes, each as step 4 words it: the `pointers` slots, the `footprint` visibility verdict (and what a consented re-run migrated), the **eight project-configuration ensure** (`configs`) lines (enumerated in step 3) — the navigator one being the late `--only index` run at the end of step 7, the **`gates-migration`** result, the **placed-bridge refresh** (`bridges`) lines (pasted verbatim), the **agent-rules lens** (`lens`) + **Communication-section** + **story-sessions section** outcomes (same outcome sets as step 4), the **full-flow offer** (`tier`) outcome, and the **bridge-settings reconcile** (`bridge-settings`) outcome (line(s) pasted verbatim) — rather than reciting a version number; **omit the raw structure number**, and do **not** print the two-axes note here (it belongs to *Version disclosure* in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`, on demand only). Then **render the mandatory Recommendations section**: run `node ${CLAUDE_SKILL_DIR}/tools/recommendations.mjs --cwd <project-root>` and PRESENT its output — from the `## Recommendations (agent-workflow)` header — in the user's conversational language (every fact, count and item, nothing added or dropped; commands, paths, hosts and rule strings byte-exact; raw tool block on request; present-even-when-empty: `no recommendations — flow optimal.`), then OFFER the consent route (per picked item: posture note → explicit confirm → chat: the one-liner; harness: the check line, then on the yes to its result the apply line; user: the user's own step — `${CLAUDE_SKILL_DIR}/references/modes/recommendations.md`). **Every current host/session claim in this report is tool-composed only** — prompts fired, sandbox scope, whether a bypass was needed, network reachability and approval counts must trace to **live tool output** from **this session**, a memory/handover snapshot is **context, never report facts**, and an unbacked claim is **omitted or explicitly marked unverified** (full clause: *Live host/session facts* in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`). Then **print the report footer** in the canonical order (version block → one-line backend-status line → welcome mat — the shared contracts in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`; rendered from the helpers, same host-can't-run skip-with-reason; the welcome mat closes on one caveat-aware next step). Then **ask before committing** — the pinned order on this exit is: Recommendations block → optional applies → report footer → the commit ask.
+8. Re-stamp `docs/ai/.workflow-version` to the **deployment-lineage head** (`4.0.0`, not the package version — mechanics unchanged: the atomic write to the stamp file). In the report, **describe what the upgrade changed in plain human terms** — which parts of their `docs/ai` are now different (the migrations that ran), plus the step-3 run-list outcomes, each as step 4 words it: the `pointers` slots, the `footprint` visibility verdict (and what a consented re-run migrated), the **nine project-configuration ensure** (`configs`) lines (enumerated in step 3) — the navigator one being the late `--only index` run at the end of step 7, the **`gates-migration`** result, the **placed-bridge refresh** (`bridges`) lines (pasted verbatim), the **agent-rules lens** (`lens`) + **Communication-section** + **story-sessions section** outcomes (same outcome sets as step 4), the **full-flow offer** (`tier`) outcome, and the **bridge-settings reconcile** (`bridge-settings`) outcome (line(s) pasted verbatim) — rather than reciting a version number; **omit the raw structure number**, and do **not** print the two-axes note here (it belongs to *Version disclosure* in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`, on demand only). Then **render the mandatory Recommendations section**: run `node ${CLAUDE_SKILL_DIR}/tools/recommendations.mjs --cwd <project-root>` and PRESENT its output — from the `## Recommendations (agent-workflow)` header — in the user's conversational language (every fact, count and item, nothing added or dropped; commands, paths, hosts and rule strings byte-exact; raw tool block on request; present-even-when-empty: `no recommendations — flow optimal.`), then OFFER the consent route (per picked item: posture note → explicit confirm → chat: the one-liner; harness: the check line, then on the yes to its result the apply line; user: the user's own step — `${CLAUDE_SKILL_DIR}/references/modes/recommendations.md`). **Every current host/session claim in this report is tool-composed only** — prompts fired, sandbox scope, whether a bypass was needed, network reachability and approval counts must trace to **live tool output** from **this session**, a memory/handover snapshot is **context, never report facts**, and an unbacked claim is **omitted or explicitly marked unverified** (full clause: *Live host/session facts* in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`). Then **print the report footer** in the canonical order (version block → one-line backend-status line → welcome mat — the shared contracts in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`; rendered from the helpers, same host-can't-run skip-with-reason; the welcome mat closes on one caveat-aware next step). Then **ask before committing** — the pinned order on this exit is: Recommendations block → optional applies → report footer → the commit ask.

package/references/rules/project-layout.md

@@ -0,0 +1,41 @@
+---
+type: rules
+lastUpdated: 2026-10-18
+scope: permanent
+staleAfter: never
+owner: kit
+maxLines: 80
+---
+
+# Project layout
+
+Where a file goes is decided by what it means, never by where there is room.
+
+## A module is a directory
+
+A module is a directory holding everything that belongs to it: its code, its tests, its mocks, its
+fixtures and its command-line entry. Tests live inside the module, next to the code they check, never
+in a separate tree.
+
+## The index is the one door
+
+The module's own index file, the one its language uses for that purpose, exports only what is used
+outside the module. Nothing outside reaches past the index into a file of the module.
+
+## The spec is the description
+
+No README repeats the module's spec. The spec describes the module; a README that restates it drifts
+from it.
+
+## Modules nest by meaning
+
+Modules nest by meaning: a slice holds its modules, and a shared layer holds what several slices use.
+Modules never nest by technical layer, so there is no directory of all controllers or all helpers.
+
+## The spec mirrors the module
+
+A spec's path mirrors its module's path, so the name of one gives the place of the other.
+
+## Old code
+
+Old code keeps its place as a recorded exception. New and touched code follows these rules.

package/tools/ensure-configs.mjs

@@ -10,6 +10,9 @@
 //   specs          scripts/<spec layer>        reader + checker pairs seeded when absent, refreshed only on
 //                  + docs/ai/specs/index.md    a shipped prior body, an edited one replaced only on the
 //                                              user's yes; store root seeded behind a current checker
+//   rules          docs/ai/rules/<theme>.md    the kit file seeded, or refreshed on a shipped prior body; with
+//                  + effective/ + sources.json no local file the effective copy and its record rebuilt; with
+//                                              one the merge an agent does is named, never done
 //   index          docs/ai/index.md            regenerate-if-missing-or-stale (a GENERATED artifact); under
 //                                              a project hook module that is not the bundled one, a write
 //                                              the project's own checker rejects is put back
@@ -40,12 +43,13 @@ import { isDirectRun } from './direct-run.mjs';
 import { ensureExecutor } from './ensure-executor.mjs';
 import { ENSURE_OPS, OWN_IMPLEMENTATIONS, failedOutcome } from './ensure-ops.mjs';
 import { ensureSpecs } from './ensure-specs.mjs';
+import { ensureRules } from './project-rules/index.mjs';
 
 const KIT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
 // The op table this CLI walks — name → implementation, in ENSURE_OPS order. Composed HERE (the one
-// consumer) because the executor and spec-layer ensures import ensure-ops.mjs for their outcome door and probes.
-export const ENSURE_IMPLEMENTATIONS = Object.freeze({ ...OWN_IMPLEMENTATIONS, executor: ensureExecutor, specs: ensureSpecs });
+// consumer) because the executor, spec-layer and rules ensures import ensure-ops.mjs for their outcome door and probes.
+export const ENSURE_IMPLEMENTATIONS = Object.freeze({ ...OWN_IMPLEMENTATIONS, executor: ensureExecutor, specs: ensureSpecs, rules: ensureRules });
 
 const EXIT_OK = 0;
 const EXIT_FAILED = 1;
@@ -63,13 +67,13 @@ const REPLACE_WITH_ONLY = '--replace-custom runs the spec layer and then the nav
 const REPLACE_WITH_DRY_RUN = "--replace-custom writes on the user's yes, so it cannot be combined with --dry-run — nothing was run";
 const INDEX_NOT_RUN = 'the navigator step did not run: a replace run runs it only after the spec layer succeeds';
 
-const HELP = `ensure-configs — the eight stamp-independent upgrade ensures, as ONE command.
+const HELP = `ensure-configs — the nine stamp-independent upgrade ensures, as ONE command.
 
 Usage:
   node ensure-configs.mjs --reconcile [--dry-run] [--only <op>] [--cwd <project>]
   node ensure-configs.mjs --reconcile --replace-custom <digest> [--cwd <project>]
 
-  --reconcile   required — run the eight ensures (${ENSURE_OPS.join(', ')})
+  --reconcile   required — run the nine ensures (${ENSURE_OPS.join(', ')})
   --dry-run     report what each ensure WOULD do; write nothing
   --only <op>   run EXACTLY ONE of them (an unknown, missing or repeated value is a usage error)
   --replace-custom <digest>
@@ -80,11 +84,13 @@ Usage:
   --help, -h    this help
 
 Every SEED is CREATE-ONLY: an existing file is preserved byte-for-byte, never clobbered and never
-refreshed in place. Three ops refresh instead: the orchestration onboarding note, only while it still
+refreshed in place. Four ops refresh instead: the orchestration onboarding note, only while it still
 matches a canonical the kit shipped (your own wording is preserved verbatim); the spec-layer reader
 and checker pairs, only while a file's bytes are a body a release shipped (an edited file is
 preserved, the writes that depend on it — the spec store root included — are withheld behind it,
-and ONE printed replace line replaces every edited file only on the user's yes); and the navigator index — a GENERATED artifact, regenerated
+and ONE printed replace line replaces every edited file only on the user's yes); the project rules
+kit file, only while its bytes are a body a release shipped (an edited one is kept), with the effective
+file rebuilt as its copy and recorded where no local file exists; and the navigator index — a GENERATED artifact, regenerated
 whenever it is missing or stale; where a module the project's hook loads is not the bundled one,
 the project's own checker judges the navigator and a write it rejects is put back byte for byte.
 The executor ensure writes nothing: a placed .claude/agents/executor.md whose bytes differ from the

package/tools/ensure-vocabulary.mjs

@@ -11,7 +11,8 @@
 // `specs` sits after `scripts` (its reader pair is a scripts/ seed too) and BEFORE `index`: the store
 // root it seeds is a docs/ai file the navigator must count.
 // `executor` follows `vehicles`: its body is derived from the settings file that op seeds.
-export const ENSURE_OPS = Object.freeze(['orchestration', 'gates', 'autonomy', 'vehicles', 'executor', 'scripts', 'specs', 'index']);
+// `rules` follows `specs` and precedes `index`: the rules files it lays are docs/ai files the navigator counts.
+export const ENSURE_OPS = Object.freeze(['orchestration', 'gates', 'autonomy', 'vehicles', 'executor', 'scripts', 'specs', 'rules', 'index']);
 
 // Tokens that assert a WRITE happened. --dry-run may never emit one of these (the CLI's contract test
 // walks this set), and each has exactly one `would-` counterpart below. `refreshed` is the spec-layer

package/tools/project-rules/index.mjs

@@ -0,0 +1,4 @@
+// The one door of the project-rules module. Contract: docs/ai/specs/kit/project-rules/index.md.
+export { THEMES } from './themes.mjs';
+export { checkRules } from './rules-check.mjs';
+export { ensureRules } from './rules-ensure.mjs';

package/tools/project-rules/rules-check.mjs

@@ -0,0 +1,115 @@
+// The read-only check: one verdict per registry theme, judged only against the record. It imports no
+// writer and reads every file through readUnder, so no symlink inside the root is followed. Contract:
+// docs/ai/specs/kit/project-rules/rules-check.md.
+
+import { createHash } from 'node:crypto';
+import { lstatSync } from 'node:fs';
+import { join } from 'node:path';
+import { readFileBytesNoFollow } from '../fs-read-nofollow.mjs';
+import { RECORD_PATH, THEMES, themePaths } from './themes.mjs';
+
+const UPGRADE = 'run /agent-workflow-kit upgrade';
+const EDIT_NOTE = 'move your edit to local/, a rebuild drops it';
+const DIGEST = /^[0-9a-f]{64}$/;
+const ROLES = ['kit', 'local', 'effective'];
+
+export const digestOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
+
+const isDigest = (value) => typeof value === 'string' && DIGEST.test(value);
+
+// readUnder(root, rel, deps?) → a readFileBytesNoFollow outcome for root/rel, or foreign or error
+// without a read when a directory on rel's path inside root is a symlink, not a directory, or cannot be
+// inspected; a missing directory ends the walk and the leaf then reads absent.
+export const readUnder = (root, rel, deps = {}) => {
+  const lstat = deps.lstat ?? lstatSync;
+  const parts = rel.split('/');
+  for (let i = 1; i < parts.length; i += 1) {
+    const prefix = parts.slice(0, i).join('/');
+    let st;
+    try {
+      st = lstat(join(root, prefix));
+    } catch (err) {
+      if (err && err.code === 'ENOENT') break;
+      return { outcome: 'error', code: `${prefix} cannot be inspected (${err?.code ?? err})` };
+    }
+    if (st.isSymbolicLink() || !st.isDirectory()) return { outcome: 'foreign', code: `${prefix} is a symlink or not a directory` };
+  }
+  return (deps.read ?? readFileBytesNoFollow)(join(root, rel));
+};
+
+const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const sameKeys = (value, keys) => JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
+
+// parseRecord(text, themes?) → { ok: true, record } | { ok: false, reason }: the record's one schema reader.
+export const parseRecord = (text, themes = THEMES) => {
+  const bad = (reason) => ({ ok: false, reason });
+  let record;
+  try {
+    record = JSON.parse(text);
+  } catch {
+    return bad('not JSON');
+  }
+  if (!isObject(record) || !sameKeys(record, ['schema', 'themes'])) return bad('the keys are not exactly schema and themes');
+  if (record.schema !== 1) return bad(`schema ${JSON.stringify(record.schema)} is not 1`);
+  if (!isObject(record.themes)) return bad('themes is not an object');
+  const names = new Set(themes.map((theme) => theme.name));
+  for (const [name, entry] of Object.entries(record.themes)) {
+    if (!names.has(name)) return bad(`theme ${name} is not in the registry`);
+    if (!isObject(entry) || !sameKeys(entry, ROLES)) return bad(`the entry of ${name} does not hold exactly kit, local and effective`);
+    if (!isDigest(entry.kit) || !isDigest(entry.effective)) return bad(`the entry of ${name} holds a value that is not a sha256`);
+    if (entry.local !== 'absent' && !isDigest(entry.local)) return bad(`the local of ${name} is neither a sha256 nor absent`);
+  }
+  return { ok: true, record };
+};
+
+// readRecord(outcome, themes) → { ok: true, themes } | { ok: false, reason }: an absent record holds no entry.
+export const readRecord = (outcome, themes = THEMES) => {
+  if (outcome.outcome === 'absent') return { ok: true, themes: {} };
+  if (outcome.outcome !== 'ok') return { ok: false, reason: 'it is not a regular file this check can read' };
+  const parsed = parseRecord(outcome.bytes.toString('utf8'), themes);
+  return parsed.ok ? { ok: true, themes: parsed.record.themes } : parsed;
+};
+
+const recordVerdict = (theme, state, detail) =>
+  ({ theme, verdict: 'record', state, line: `${theme}: record (${state}) — ${detail} — ${UPGRADE}` });
+
+const judgeTheme = (theme, paths, files, record) => {
+  if (!record.ok) return recordVerdict(theme, 'unreadable-record', `${paths.record} is unreadable: ${record.reason}`);
+  const unreadable = ROLES.find((role) => !['ok', 'absent'].includes(files[role].outcome));
+  if (unreadable) return recordVerdict(theme, 'unreadable-file', `${paths[unreadable]} is not a regular file this check can read`);
+  const present = (role) => files[role].outcome === 'ok';
+  const entry = record.themes[theme];
+  if (entry === undefined) {
+    const existing = ROLES.find(present);
+    if (existing === undefined) return { theme, verdict: 'absent', line: `${theme}: absent` };
+    return recordVerdict(theme, 'no-entry', `no record entry while ${paths[existing]} exists`);
+  }
+  const missing = ['kit', 'effective'].find((role) => !present(role));
+  if (missing) return recordVerdict(theme, 'missing-file', `${paths[missing]} is missing under its record entry`);
+  const differs = {
+    kit: digestOf(files.kit.bytes) !== entry.kit,
+    local: present('local') ? digestOf(files.local.bytes) !== entry.local : entry.local !== 'absent',
+    effective: digestOf(files.effective.bytes) !== entry.effective,
+  };
+  const moved = ROLES.filter((role) => differs[role])
+    .map((role) => (role === 'effective' ? { role, file: paths[role], note: EDIT_NOTE } : { role, file: paths[role] }));
+  if (moved.length > 0) {
+    const named = moved.map(({ file, note }) => (note ? `${file} (${note})` : file)).join('; ');
+    return { theme, verdict: 'drift', moved, line: `${theme}: drift — moved ${named} — ${UPGRADE}` };
+  }
+  if (!present('local') && !files.kit.bytes.equals(files.effective.bytes)) {
+    return recordVerdict(theme, 'kit-effective-differ', `no local file, yet ${paths.effective} differs from ${paths.kit}`);
+  }
+  return { theme, verdict: 'current', line: `${theme}: current` };
+};
+
+// checkRules(root, deps?) → [{ theme, verdict, line, moved?, state? }] in registry order; writes nothing.
+export const checkRules = (root, deps = {}) => {
+  const themes = deps.themes ?? THEMES;
+  const record = readRecord(readUnder(root, RECORD_PATH, deps), themes);
+  return themes.map(({ name }) => {
+    const paths = themePaths(name);
+    const files = Object.fromEntries(ROLES.map((role) => [role, readUnder(root, paths[role], deps)]));
+    return judgeTheme(name, paths, files, record);
+  });
+};

package/tools/project-rules/rules-cli.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// The command line over the read-only check and the record writer. Contract:
+// docs/ai/specs/kit/project-rules/rules-cli.md. Exit codes: 0 accept; 1 a stop or a refused record; 2 usage.
+
+import { resolve } from 'node:path';
+import { isDirectRun } from '../direct-run.mjs';
+import { checkRules } from './rules-check.mjs';
+import { writeRecord } from './rules-record.mjs';
+
+const USAGE = `project-rules — the effective rule files still stand for their sources.
+
+Usage:
+  node rules-cli.mjs --check [--cwd <project>]
+  node rules-cli.mjs --record --theme <name> --kit <sha256> --local <sha256|absent> --effective <sha256> [--cwd <project>]
+
+--check   one line per theme: current, absent, drift or record; writes nothing.
+--record  the merging agent's call: records the digests of the inputs it read and of the file it wrote.
+
+Exit codes: 0 accept; 1 a stop or a refused record; 2 usage.`;
+
+const MODES = { '--check': [], '--record': ['--theme', '--kit', '--local', '--effective'] };
+const VALUED = new Set(['--cwd', '--theme', '--kit', '--local', '--effective']);
+
+// parseArgs(argv) → { mode, options } | { help: true } | { error }; reads nothing.
+const parseArgs = (argv) => {
+  if (argv.length === 1 && (argv[0] === '--help' || argv[0] === '-h')) return { help: true };
+  let mode = null;
+  const options = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (Object.hasOwn(MODES, arg)) {
+      if (mode !== null) return { error: `${mode} and ${arg} are two modes; one run takes exactly one` };
+      mode = arg;
+    } else if (VALUED.has(arg)) {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('--')) return { error: `${arg} needs a value` };
+      if (arg in options) return { error: `${arg} is given twice` };
+      options[arg] = value;
+      i += 1;
+    } else {
+      return { error: `unknown argument: ${arg}` };
+    }
+  }
+  if (mode === null) return { error: 'no mode: give --check or --record' };
+  const allowed = new Set(['--cwd', ...MODES[mode]]);
+  const extra = Object.keys(options).find((name) => !allowed.has(name));
+  if (extra) return { error: `${mode} does not take ${extra}` };
+  const absent = MODES[mode].find((name) => !(name in options));
+  if (absent) return { error: `${mode} needs ${absent}` };
+  return { mode, options };
+};
+
+const lines = (list) => (list.length === 0 ? '' : `${list.join('\n')}\n`);
+
+// main(argv, ctx?) → { code, stdout, stderr }; never exits the process.
+export const main = (argv, ctx = {}) => {
+  const parsed = parseArgs(argv);
+  if (parsed.help) return { code: 0, stdout: `${USAGE}\n`, stderr: '' };
+  if (parsed.error) return { code: 2, stdout: '', stderr: `project-rules: ${parsed.error}\n\n${USAGE}\n` };
+  const root = resolve(ctx.cwd ?? process.cwd(), parsed.options['--cwd'] ?? '.');
+  const deps = ctx.deps ?? {};
+  if (parsed.mode === '--check') {
+    const verdicts = checkRules(root, deps);
+    const stops = verdicts.filter(({ verdict }) => verdict !== 'current' && verdict !== 'absent');
+    return { code: stops.length === 0 ? 0 : 1, stdout: lines(verdicts.map(({ line }) => line)), stderr: '' };
+  }
+  const { '--theme': theme, '--kit': kit, '--local': local, '--effective': effective } = parsed.options;
+  const result = writeRecord(root, theme, { kit, local, effective }, deps);
+  if (!result.ok) return { code: 1, stdout: '', stderr: `project-rules: --record refused (${result.condition}) — ${result.message}; nothing written\n` };
+  return { code: 0, stdout: `project-rules: recorded ${theme} in ${result.path}\n`, stderr: '' };
+};
+
+if (isDirectRun(import.meta.url)) {
+  const { code, stdout, stderr } = main(process.argv.slice(2));
+  process.stdout.write(stdout);
+  process.stderr.write(stderr);
+  process.exitCode = code;
+}

package/tools/project-rules/rules-ensure.mjs

@@ -0,0 +1,216 @@
+// The upgrade op `rules`: it lays every registry theme's kit file, keeps the effective file a copy of
+// the kit file where no local file exists, and names the merge an agent does where one does. It never
+// writes a local file and never merges two texts. Contract: docs/ai/specs/kit/project-rules/rules-ensure.md.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeDocsAiFileAtomic, writeProjectFileCreateOnly } from '../atomic-write.mjs';
+import { composeFailure, composeOutcome, tmpNote } from '../ensure-ops.mjs';
+import { shellQuoteArg } from '../repo-lex.mjs';
+import { parseFrontmatter } from '../../references/scripts/check-docs-size.mjs';
+import { digestOf, readRecord, readUnder } from './rules-check.mjs';
+import { writeRecord } from './rules-record.mjs';
+import { RULES_PRIORS, isKnownPrior } from './rules-priors.mjs';
+import { RECORD_PATH, THEMES, themePaths } from './themes.mjs';
+
+const OP = 'rules';
+const FILE_ROLES = ['kit', 'local', 'effective'];
+const causeOf = (err) => String((err && err.message) || err);
+
+// ── the survey: the template and every path read once, nothing written ───────────────────────────
+
+const readTemplate = (readFile, path) => {
+  try {
+    return { bytes: Buffer.from(readFile(path)) };
+  } catch (err) {
+    return { error: causeOf(err) };
+  }
+};
+
+const unreadable = (rel, read) => {
+  if (read.outcome === 'foreign') {
+    return composeFailure(OP, 'wrong-node-kind', `${rel}: ${read.code ?? `it is a ${read.className}, not a regular file`} — nothing was read or written; resolve it by hand, then re-run`);
+  }
+  if (read.outcome === 'ok' || read.outcome === 'absent') return null;
+  return composeFailure(OP, 'unexpected-error', `${rel}: could not be read (${read.code ?? read.outcome}) — nothing was written`);
+};
+
+const survey = ({ themes, cwd, kitRoot, readFile, deps }) => {
+  const surveyed = [];
+  for (const theme of themes) {
+    const paths = themePaths(theme.name);
+    const template = readTemplate(readFile, join(kitRoot, theme.template));
+    if (template.error !== undefined) {
+      return { failure: composeFailure(OP, 'template-unreadable', `${paths.kit}: the bundled template ${theme.template} could not be read, so nothing was written — reinstall the kit. ${template.error}`) };
+    }
+    const reads = Object.fromEntries(FILE_ROLES.map((role) => [role, readUnder(cwd, paths[role], deps)]));
+    const failure = FILE_ROLES.map((role) => unreadable(paths[role], reads[role])).find(Boolean);
+    if (failure) return { failure };
+    surveyed.push({ theme, paths, template: template.bytes, reads });
+  }
+  const recordRead = readUnder(cwd, RECORD_PATH, deps);
+  const failure = unreadable(RECORD_PATH, recordRead);
+  return failure ? { failure } : { surveyed, record: readRecord(recordRead, themes) };
+};
+
+// ── the decision per theme (pure over the survey) ────────────────────────────────────────────────
+
+const classifyKit = (name, kit, template, priors) => {
+  if (kit.outcome === 'absent') return 'absent';
+  if (kit.bytes.equals(template)) return 'current';
+  return isKnownPrior(name, kit.bytes, priors) ? 'prior' : 'custom';
+};
+
+const planTheme = ({ theme, paths, template, reads }, record, priors) => {
+  const { kit, local, effective } = reads;
+  const kitState = classifyKit(theme.name, kit, template, priors);
+  const kitBytes = kitState === 'absent' || kitState === 'prior' ? template : kit.bytes;
+  const kitWrite = { absent: 'seed', prior: 'refresh' }[kitState] ?? null;
+  const entry = record.ok ? record.themes[theme.name] : undefined;
+  const base = { name: theme.name, paths, kitState, kitBytes, kitWrite, effectiveWrite: null, recordWrite: false };
+  if (local.outcome === 'ok') {
+    const merged = entry !== undefined && effective.outcome === 'ok' && entry.kit === digestOf(kitBytes)
+      && entry.local === digestOf(local.bytes) && entry.effective === digestOf(effective.bytes);
+    return { ...base, mode: merged ? 'merged' : 'pending', localDigest: digestOf(local.bytes) };
+  }
+  if (kitState === 'custom' && parseFrontmatter(kitBytes.toString('utf8')) === null) return { ...base, mode: 'unvouched' };
+  const effectiveWrite = effective.outcome === 'absent' ? 'seed' : effective.bytes.equals(kitBytes) ? null : 'rebuild';
+  const passed = { kit: digestOf(kitBytes), local: 'absent', effective: digestOf(kitBytes) };
+  const recorded = entry !== undefined && entry.kit === passed.kit && entry.local === 'absent' && entry.effective === passed.effective;
+  const droppedEdit = effectiveWrite === 'rebuild' && entry !== undefined && entry.effective !== digestOf(effective.bytes);
+  return { ...base, mode: 'copy', effectiveWrite, recordWrite: effectiveWrite !== null || !recorded, passed, droppedEdit };
+};
+
+// ── the lines, composed from what happened ───────────────────────────────────────────────────────
+
+const KIT_LINES = {
+  absent: { written: 'created from the bundled template', stood: 'appeared while this run was creating it and holds the bundled template — it stands', would: 'absent — would be created from the bundled template' },
+  prior: { written: 'held the body an earlier release shipped — refreshed to the bundled template', would: 'holds the body an earlier release shipped — would be refreshed to the bundled template' },
+};
+const kitLine = (plan, fate) => {
+  const { kit, local } = plan.paths;
+  if (plan.kitState === 'current') return `${kit}: already the bundled template — nothing written`;
+  if (plan.mode === 'unvouched') return `${kit}: carries your edit with no frontmatter — kept byte for byte, and nothing else was written for this theme, because the record writer cannot vouch for a file without frontmatter; your own rules belong in ${local}, where they win`;
+  if (plan.kitState === 'custom') return `${kit}: carries your edit — kept byte for byte; your own rules belong in ${local}, where they win, and the kit's updates to this file wait while it carries the edit`;
+  return `${kit}: ${KIT_LINES[plan.kitState][fate]}`;
+};
+
+const effectiveLine = (plan, fate) => {
+  const { kit, local, effective } = plan.paths;
+  const dropped = plan.droppedEdit ? `, dropping an edit made to it; edits belong in ${local}` : '';
+  if (plan.effectiveWrite === null) return `${effective}: already the copy of ${kit} — nothing written`;
+  if (plan.effectiveWrite === 'seed') {
+    return `${effective}: ${{ written: `created as a copy of ${kit}`, stood: `appeared while this run was creating it and holds the copy of ${kit} — it stands`, would: `absent — would be created as a copy of ${kit}` }[fate]}`;
+  }
+  if (fate === 'would') return `${effective}: differs from ${kit} — would be rebuilt as its copy${dropped}`;
+  return `${effective}: ${plan.droppedEdit ? `rebuilt as a copy of ${kit}${dropped}` : `rebuilt from ${kit}`}`;
+};
+
+const recordLine = (plan, fate, replacing) => {
+  const { effective } = plan.paths;
+  if (!plan.recordWrite) return `${RECORD_PATH}: already records what ${effective} was built from — nothing written`;
+  const would = fate === 'would';
+  if (replacing !== null) {
+    return `${RECORD_PATH}: ${would ? 'is' : 'was'} unreadable (${replacing}) — ${would ? 'would be replaced' : 'replaced'} by a record of what ${effective} ${would ? 'is' : 'was'} built from`;
+  }
+  return `${RECORD_PATH}: ${would ? `would record what ${effective} is built from` : `records what ${effective} was built from`}`;
+};
+
+const mergeLine = ({ plan, kitRoot, cwd, dryRun }) => {
+  const { kit, local, effective } = plan.paths;
+  const cli = shellQuoteArg(join(kitRoot, 'tools', 'project-rules', 'rules-cli.mjs'));
+  const command = `node ${cli} --record --theme ${plan.name} --kit ${digestOf(plan.kitBytes)} --local ${plan.localDigest} --effective <the sha256 of the merged file> --cwd ${shellQuoteArg(cwd)}`;
+  const holds = dryRun && plan.kitWrite !== null ? ` — this command holds once the real run has written ${kit}` : '';
+  return `merge needed — merge ${kit} and ${local} into ${effective}: by meaning, the local file wins a conflict, each rule appears once, only the final meaning is written, with no mark of where a rule came from, the frontmatter is kept, and the user is shown what changed; then record it: ${command}${holds}`;
+};
+
+const themeLines = ({ plan, fateOf, kitRoot, cwd, dryRun, replacing }) => {
+  const lines = [kitLine(plan, fateOf(plan, 'kit'))];
+  if (plan.mode === 'pending') lines.push(mergeLine({ plan, kitRoot, cwd, dryRun }));
+  if (plan.mode === 'merged') lines.push(`${plan.paths.effective}: already the recorded merge of ${plan.paths.kit} and ${plan.paths.local} — nothing written`);
+  if (plan.mode === 'copy') lines.push(effectiveLine(plan, fateOf(plan, 'effective')), recordLine(plan, fateOf(plan, 'record'), replacing));
+  return lines;
+};
+
+// ── the token: one per run, the first that holds ─────────────────────────────────────────────────
+
+const DRY = { seeded: 'would-seed', refreshed: 'would-refresh', regenerated: 'would-regenerate' };
+const tokenOf = (plans, wrote, dryRun) => {
+  if (plans.some((plan) => plan.mode === 'pending')) return 'pending';
+  const token = (word) => (dryRun ? DRY[word] : word);
+  if (plans.some((plan) => plan.kitWrite === 'seed' && wrote(plan, 'kit'))) return token('seeded');
+  if (plans.some((plan) => plan.kitWrite === 'refresh' && wrote(plan, 'kit'))) return token('refreshed');
+  if (plans.some((plan) => wrote(plan, 'effective') || wrote(plan, 'record'))) return token('regenerated');
+  return plans.some((plan) => plan.kitState === 'custom') ? 'customized-preserved' : 'already-current';
+};
+
+// ── the writes, in order; the first that fails stops the run ─────────────────────────────────────
+
+const writtenNote = (written) => (written.length > 0 ? `already written by this run and not rolled back: ${written.join(', ')}` : 'nothing was written before it');
+const RACE = 'appeared while this run was creating it and does not hold the bytes this run carried — something is writing there underneath this run; nothing further written, re-run when the tree is settled';
+const NOUN = { noun: 'a project rules file' };
+
+const writeOne = ({ cwd, rel, body, kind, deps }) => (kind === 'seed'
+  ? writeProjectFileCreateOnly(cwd, rel, body, deps, NOUN)
+  : writeDocsAiFileAtomic(cwd, rel, body, deps, NOUN));
+
+const runWrites = ({ plans, cwd, deps, fates, notes }) => {
+  const written = [];
+  const stop = (cause, line) => ({ failure: composeFailure(OP, cause, `${line} — ${writtenNote(written)}`, ...notes) });
+  for (const plan of plans) {
+    const steps = [
+      plan.kitWrite && { role: 'kit', kind: plan.kitWrite },
+      plan.effectiveWrite && { role: 'effective', kind: plan.effectiveWrite },
+    ].filter(Boolean);
+    for (const { role, kind } of steps) {
+      const rel = plan.paths[role];
+      const result = (() => {
+        try {
+          return { ok: writeOne({ cwd, rel, body: plan.kitBytes, kind, deps }) };
+        } catch (err) {
+          return { error: causeOf(err) };
+        }
+      })();
+      if (result.error !== undefined) return stop('write-refused', `${rel}: ${result.error}`);
+      notes.push(...tmpNote(rel, result.ok.tmpLeftBehind));
+      if (!result.ok.created) {
+        const now = readUnder(cwd, rel, deps);
+        if (now.outcome !== 'ok' || !now.bytes.equals(plan.kitBytes)) return stop('race-unresolved', `${rel}: ${RACE}`);
+      }
+      if (result.ok.created) written.push(rel);
+      fates.set(`${plan.name}:${role}`, result.ok.created ? 'written' : 'stood');
+    }
+    if (plan.recordWrite) {
+      const recorded = writeRecord(cwd, plan.name, plan.passed, deps);
+      if (!recorded.ok && recorded.condition === 'write') return stop('write-refused', `${RECORD_PATH}: ${recorded.message}`);
+      if (!recorded.ok) {
+        return stop('race-unresolved', `${RECORD_PATH}: the record could not vouch for the files (${recorded.condition}: ${recorded.message}), so they changed underneath this run; nothing further written, re-run when the tree is settled`);
+      }
+      written.push(RECORD_PATH);
+      fates.set(`${plan.name}:record`, 'written');
+    }
+  }
+  return {};
+};
+
+// ensureRules({ cwd, kitRoot, dryRun?, deps? }) → one outcome of the closed vocabulary for every theme.
+export const ensureRules = ({ cwd, kitRoot, dryRun = false, deps = {} }) => {
+  const themes = deps.themes ?? THEMES;
+  const surveyed = survey({ themes, cwd, kitRoot, readFile: deps.readFile ?? readFileSync, deps });
+  if (surveyed.failure) return surveyed.failure;
+  const plans = surveyed.surveyed.map((one) => planTheme(one, surveyed.record, deps.priors ?? RULES_PRIORS));
+  const firstRecordWrite = plans.findIndex((plan) => plan.recordWrite);
+  const replacing = (index) => (index === firstRecordWrite && !surveyed.record.ok ? surveyed.record.reason : null);
+  const fates = new Map();
+  const notes = [];
+  const fateOf = (plan, role) => fates.get(`${plan.name}:${role}`) ?? 'would';
+  const lines = () => plans.flatMap((plan, index) => themeLines({ plan, fateOf, kitRoot, cwd, dryRun, replacing: replacing(index) }));
+  if (dryRun) {
+    const wouldWrite = (plan, role) => (role === 'kit' ? plan.kitWrite !== null : role === 'effective' ? plan.effectiveWrite !== null : plan.recordWrite);
+    return composeOutcome(OP, tokenOf(plans, wouldWrite, true), lines(), false);
+  }
+  const stopped = runWrites({ plans, cwd, deps, fates, notes });
+  if (stopped.failure) return stopped.failure;
+  const wrote = (plan, role) => fates.get(`${plan.name}:${role}`) === 'written';
+  return composeOutcome(OP, tokenOf(plans, wrote, false), [...lines(), ...notes], false);
+};

package/tools/project-rules/rules-priors.mjs

@@ -0,0 +1,12 @@
+// The append-only catalog of the kit-file bodies earlier releases shipped, and its one question.
+// Contract: docs/ai/specs/kit/project-rules/rules-priors.md.
+
+import { digestOf } from './rules-check.mjs';
+
+export const RULES_PRIORS = Object.freeze([]);
+
+// isKnownPrior(theme, bytes, catalog?) → true exactly when the bytes hash to an entry of that theme.
+export const isKnownPrior = (theme, bytes, catalog = RULES_PRIORS) => {
+  const digest = digestOf(bytes);
+  return catalog.some((entry) => entry.theme === theme && entry.sha256 === digest);
+};

package/tools/project-rules/rules-record.mjs

@@ -0,0 +1,78 @@
+// The record's one writer: docs/ai/rules/effective/sources.json states what every effective file was
+// built from, and a merge it cannot vouch for is refused. Contract:
+// docs/ai/specs/kit/project-rules/rules-record.md.
+
+import { lstatSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeDocsAiFileAtomic } from '../atomic-write.mjs';
+import { parseFrontmatter } from '../../references/scripts/check-docs-size.mjs';
+import { digestOf, readRecord, readUnder } from './rules-check.mjs';
+import { RECORD_PATH, THEMES, themePaths } from './themes.mjs';
+
+const ROLES = ['kit', 'local', 'effective'];
+
+// Why the first node on the record's path that lstat cannot inspect, is a symlink or is of the wrong
+// kind fails, or null when the path holds or ends in a missing node.
+const wrongNode = (root, lstat) => {
+  const parts = RECORD_PATH.split('/');
+  for (let i = 1; i <= parts.length; i += 1) {
+    const rel = parts.slice(0, i).join('/');
+    let st;
+    try {
+      st = lstat(join(root, rel));
+    } catch (err) {
+      if (err && err.code === 'ENOENT') return null;
+      return `${rel} cannot be inspected (${err?.code ?? err})`;
+    }
+    const isLeaf = i === parts.length;
+    if (st.isSymbolicLink() || (isLeaf ? !st.isFile() : !st.isDirectory())) return `${rel} is a symlink or not of its kind`;
+  }
+  return null;
+};
+
+// The conditions in the order they are judged; each returns null when it holds, else the refusal.
+const judge = (root, theme, passed, deps) => {
+  const themes = deps.themes ?? THEMES;
+  const fail = (condition, message) => ({ ok: false, condition, message });
+  if (!themes.some(({ name }) => name === theme)) return fail('theme', `${theme} is not a registry theme`);
+  const node = wrongNode(root, deps.lstat ?? lstatSync);
+  if (node !== null) return fail('record-path', node);
+  const recordRead = readUnder(root, RECORD_PATH, deps);
+  if (!['ok', 'absent'].includes(recordRead.outcome)) return fail('record-path', `${RECORD_PATH} is not a regular file`);
+  const record = readRecord(recordRead, themes);
+  const kept = record.ok ? record.themes : {};
+  const paths = themePaths(theme);
+  const files = Object.fromEntries(ROLES.map((role) => [role, readUnder(root, paths[role], deps)]));
+  const unreadable = ROLES.find((role) => !['ok', 'absent'].includes(files[role].outcome));
+  if (unreadable) return fail('unreadable-file', `${paths[unreadable]} is not a regular file this writer can read`);
+  const missing = ['kit', 'effective'].find((role) => files[role].outcome !== 'ok');
+  if (missing) return fail('missing-file', `${paths[missing]} is missing`);
+  const { kit, local, effective } = { kit: files.kit.bytes, local: files.local.bytes, effective: files.effective.bytes };
+  if (parseFrontmatter(effective.toString('utf8')) === null) return fail('frontmatter', `${paths.effective} carries no frontmatter`);
+  if (digestOf(kit) !== passed.kit) return fail('kit-moved', `${paths.kit} no longer hashes to the passed kit digest`);
+  if (digestOf(effective) !== passed.effective) return fail('effective-moved', `${paths.effective} no longer hashes to the passed effective digest`);
+  if ((local !== undefined) !== (passed.local !== 'absent')) {
+    return fail('local-presence', `${paths.local} ${local === undefined ? 'is absent' : 'exists'} while the passed local is ${passed.local}`);
+  }
+  if (local !== undefined) {
+    if (digestOf(local) !== passed.local) return fail('local-moved', `${paths.local} no longer hashes to the passed local digest`);
+    if (effective.equals(kit) || effective.equals(local)) return fail('effective-equals-input', `${paths.effective} equals one of its inputs, so no merge was written`);
+  } else if (!effective.equals(kit)) {
+    return fail('effective-differs-from-kit', `with no local file ${paths.effective} must equal ${paths.kit}`);
+  }
+  return { ok: true, themes: kept };
+};
+
+// writeRecord(root, theme, passed, deps?) → { ok: true, path, entry } | { ok: false, condition, message }.
+export const writeRecord = (root, theme, passed, deps = {}) => {
+  const judged = judge(root, theme, passed, deps);
+  if (!judged.ok) return judged;
+  const entry = { kit: passed.kit, local: passed.local, effective: passed.effective };
+  const body = `${JSON.stringify({ schema: 1, themes: { ...judged.themes, [theme]: entry } }, null, 2)}\n`;
+  try {
+    (deps.write ?? writeDocsAiFileAtomic)(root, RECORD_PATH, body);
+  } catch (err) {
+    return { ok: false, condition: 'write', message: String(err?.message ?? err) };
+  }
+  return { ok: true, path: RECORD_PATH, entry };
+};

package/tools/project-rules/themes.mjs

@@ -0,0 +1,19 @@
+// The theme registry: pure data and pure derivation. Every surface that names a theme or its files
+// reads this list, never a second copy. Contract: docs/ai/specs/kit/project-rules/themes.md.
+
+export const THEMES = Object.freeze([
+  Object.freeze({
+    name: 'project-layout',
+    template: 'references/rules/project-layout.md',
+    readWhen: 'Creating, moving or naming a file, a module or a spec',
+  }),
+]);
+
+export const RECORD_PATH = 'docs/ai/rules/effective/sources.json';
+
+export const themePaths = (name) => Object.freeze({
+  kit: `docs/ai/rules/${name}.md`,
+  local: `docs/ai/rules/local/${name}.md`,
+  effective: `docs/ai/rules/effective/${name}.md`,
+  record: RECORD_PATH,
+});

package/tools/spec-adoption.mjs

@@ -1,5 +1,5 @@
 // spec-adoption.mjs — which of the four adoption states the feature-spec store is in, and whether the layer
-// was declined. Contract: docs/ai/specs/kit/spec-adoption.md. The census and the per-document read are
+// was declined. Contract: docs/ai/specs/kit/spec-layer/spec-adoption.md. The census and the per-document read are
 // spec-check's own exported seam; this module walks nothing of its own. Read-only, Node >= 22.
 
 import { join } from 'node:path';

package/tools/spec-coverage.mjs

@@ -7,7 +7,7 @@
 // contract a REQUIREMENT with a ratchet — a shipped tool no contract governs is a REFUSAL, and the
 // debt of today's uncovered tools may only shrink.
 //
-// The contract this module is built to is `docs/ai/specs/kit/spec-coverage.md`, and it was written
+// The contract this module is built to is `docs/ai/specs/kit/spec-layer/spec-coverage.md`, and it was written
 // BEFORE this file. That order is the point: a contract amended after the code describes whatever
 // the last review happened to find, which makes review an open question with no bounded answer.
 //