@sabaiway/agent-workflow-kit 7.1.0 → 7.3.0

package/CHANGELOG.md

@@ -4,6 +4,79 @@ 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.
 
+## 7.3.0 — the spec layer's delivery half: hidden from day one, mirrored, bootstrapped (AD-112)
+
+The memory substrate ships the feature-spec layer in 4.6.0 and the engine its canon in 3.3.0; this
+release is what makes a FRESH kit bootstrap deliver it whole and hidden.
+
+- **Hidden mode, no new machinery.** `KIT_OWN_PATHS` gains `/scripts/spec-schema.mjs` and
+  `/scripts/spec-schema.test.mjs` (sentinel 28 -> 30) — the reader the navigator checker now imports
+  and its deployed test; `/docs/ai/` already subsumes the store. The integration suite proves it on a
+  bootstrapped layout with real `git check-ignore` on both files and on `docs/ai/specs/x.md`: nothing
+  of the layer is visible to git.
+- **Mirrors.** `references/scripts/` carries the reader pair and the GROUPS-collapse checker
+  byte-identical to the memory canon; `references/templates/` carries `specs/index.md` and
+  `SPEC_TEMPLATE.md` (the mirror manifest names both; template-parity reverse-pins them). The kit's
+  own fallback bootstrap excludes `SPEC_TEMPLATE.md` by NAME in its prose AND its E2E copy loop, and
+  the finalized navigator carries ONE counted `specs/` row.
+- **Templates.** `agent_rules.md` §1.2/§1.3 reworded (governing specs, adoption shim, the revision
+  lands with the code) and its lens region re-rendered with the engine's `Spec-first` bullet;
+  `AGENTS.md` routes `technical_specification.md` readers to the contracts under `docs/ai/specs/`.
+- Package-content pins: 241 -> 245 (the reader pair + the two templates), each by NAME.
+
+## 7.2.0 — `.mcp.json` joins the hidden-mode footprint, and a worktree never owns it (AD-111)
+
+7.0.0 taught the kit to register its MCP server. It did not teach hidden mode about the file that
+registration writes — so a hidden deployment that ran `/agent-workflow-kit mcp` left `.mcp.json`
+sitting in `git status`, one `git add -A` away from a commit. That is exactly the leak the footprint
+registry exists to prevent, and it shipped anyway.
+
+- **`/.mcp.json` is in `KIT_OWN_PATHS`.** It joins `/.claude/settings.json` as a SHARED container the
+  kit merges into rather than owns, on the same terms: the tracked→ASK arm means a project that
+  already commits its own registration is asked, never silently un-tracked. Candidacy is
+  unconditional on purpose — the path is CONSIDERED before a later `mcp --apply` writes the file
+  rather than only after it appears, and is then hidden, dropped as already covered by a tracked
+  `.gitignore`, or surfaced as an ASK. That is what removes the follow-up reconcile the bug depended
+  on. The `contracts.md` prose mirror names it.
+- **A worktree is never HANDED one, and never owns one.** The scope is the untracked lanes this tool
+  drives — the registry copy set and `--include`; a TRACKED `.mcp.json` still arrives with
+  `git worktree add`, because that is the checkout, not a copy. One frozen never-provisioned set,
+  read at three sites because each needs it for a different reason: the copy set would hand a
+  satellite a launcher pinned to a path consented for the MAIN checkout; the containment sweep would
+  STOP the whole provision on an escaping symlink at that path (a device-node mask realpaths inside
+  the repo and reaches the later special-file refusal instead); and `registryRoots` decides what
+  `cleanup` may REMOVE. That third one was measured — without the guard, `cleanup` on a landed
+  worktree carrying a satellite's own `.mcp.json` exited 0 and took the file with it. `--include` is
+  refused pre-mutation for the same paths: it is the one door that bypasses the copy set, and it
+  would have recorded the launcher as ours.
+- **A settings copy this tool wrote never enables a server the worktree cannot declare.** The
+  guarantee is exactly that narrow. `.claude/settings.json` rides `REBASE_TARGETS` into a worktree
+  carrying `enabledMcpjsonServers`, which `mcp.md` itself calls a client error on every startup. An
+  untracked copy still equal to MAIN loses our enable and our two derived allow rules — and ONLY
+  those; every foreign server, rule and key survives, as do the file's EOL and the order of its
+  non-index keys (`withoutRegistration`, the token-removal complement of `mergeSettings`, not its
+  exact inverse — a JSON round-trip still hoists integer-like keys, as JS object semantics require).
+  **Where a rewrite would LOSE something the kit does not own, it is refused whole and says why.**
+  Three ways, each detected before anything is written: a number past double precision comes back a
+  different value; a duplicate key at any depth collapses to the last one (both found on the source
+  TEXT, because after the parse the evidence is gone); and invalid UTF-8 would become U+FFFD, so both
+  rewriting lanes — the pin rebase and the token strip — decode with FATAL UTF-8 and refuse
+  separately. The MAIN-equality proof compares BYTES, with the BOM preserved through the decode, so
+  a BOM-carrying original and a BOM-less copy can never pass for the same file.
+  The rewrite is admitted by ONE positive conjunction — untracked, bytes still MAIN's or their
+  rebased form, and a launcher proven ABSENT — so a tracked or user-modified settings file keeps its
+  registration tokens on purpose, as does one standing beside a launcher that is present or that
+  cannot be read. Those states get a neutral line naming the tokens; orphanhood is only CLAIMED where
+  it is proven.
+- **All three output arms name the reconcile.** Applied, masked hand-off, and already-registered —
+  the last one matters most, because a deployment registered under 7.0.0 learns about the reconcile
+  on its next run. A settings write that fails after the entry landed carries the note too: that
+  path never reaches the report, and it strands a standing registration.
+
+**Known residual, stated:** a VISIBLE deployment still commits a launcher carrying an absolute
+machine path. The fix is not symmetric with hidden mode — a visible `.mcp.json` may legitimately hold
+a team's own committable servers — so it is its own queued decision, not a line in this release.
+
 ## 7.1.0 — `fold-scope`: the fold channel gets a checker that refuses a claim whose reference does not resolve (AD-110)
 
 The engine canon now asks every finding to NAME the invariant its fix enforces before the edit

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".
 disable-model-invocation: true
 metadata:
-  version: '7.1.0'
+  version: '7.3.0'
 ---
 
 # agent-workflow-kit

package/capability.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "7.1.0",
+  "version": "7.3.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/contracts.md

@@ -42,7 +42,7 @@ diverge:
 | `/.aider.input.history` | Aider | file | no | input history |
 | `/.continue/` | Continue | dir | no | project config dir |
 
-The kit's OWN footprint (`KIT_OWN_PATHS`) — `AGENTS.md`, `CLAUDE.md`, `docs/ai/` (subsumes the stamp), the added `scripts/*.mjs`, `docs/plans/`, `.claude/settings.local.json`, and `.claude/settings.json` (hidden-only — visible mode commits it) — is always a candidate in hidden mode.
+The kit's OWN footprint (`KIT_OWN_PATHS`) — `AGENTS.md`, `CLAUDE.md`, `docs/ai/` (subsumes the stamp), the added `scripts/*.mjs`, `docs/plans/`, `.claude/settings.local.json`, `.claude/settings.json` (hidden-only — visible mode commits it), and `.mcp.json` (the `mcp` mode's registration; hidden-only for the same reason, and it carries an absolute machine path) — is always a candidate in hidden mode.
 
 Not in this version: a fully-external hidden mode (artifacts relocated outside the repo tree).
 Deferred to a later release + migration.

package/references/modes/bootstrap.md

@@ -21,7 +21,7 @@ Requires: ${CLAUDE_SKILL_DIR}/references/shared/report-footer.md · ${CLAUDE_SKI
 3. **Choose conversational language — answered in the step-2 batch.** Which language should the agent *talk to them* in — questions, explanations, summaries, status updates? Offer the language they're already writing in as the default. Carry the answer into the `{{COMM_LANGUAGE}}` slot of the *Communication language* block when `AGENTS.md` is created (step 5). See [Communication contract](${CLAUDE_SKILL_DIR}/references/contracts.md#communication-contract). This sets the **dialogue** language only — never the files.
 4. **Choose agent attribution — answered in the step-2 batch.** May the agent attribute work to itself / to AI — `Co-Authored-By` trailers, "Generated with …" footers, "AI"/agent/model mentions in code, comments, commit messages, PR titles/bodies, or docs? **Default to `off`** (no agent/AI mention anywhere) unless they opt in — people are routinely surprised to find an AI listed as a repo contributor. Carry the answer into the `{{AGENT_ATTRIBUTION}}` slot of the *Attribution* block when `AGENTS.md` is created (step 5). **If `off` and the project uses Claude Code**, also set `"includeCoAuthoredBy": false` in the project's `.claude/settings.json` (create it if absent) — the trailer is added by the harness, so a doc directive alone won't stop it. See [Attribution contract](${CLAUDE_SKILL_DIR}/references/contracts.md#attribution-contract).
 5. **Entry-point doc.** If `AGENTS.md` / `CLAUDE.md` already exist (step-1 recon), do **not** overwrite — show the user and ask whether to merge or replace. Otherwise create `AGENTS.md` (the cross-agent standard — Codex / Cursor / Devin Desktop / Copilot read it natively) from `${CLAUDE_SKILL_DIR}/references/templates/AGENTS.md`, and symlink `CLAUDE.md -> AGENTS.md` (`ln -s AGENTS.md CLAUDE.md`) for Claude Code — single source, no duplication. For nested context, add a subdir `AGENTS.md` (+ a `CLAUDE.md` symlink beside it for Claude Code).
-6. **Deploy `docs/ai/`.** Create every `docs/ai/` file + `pages/` + the seed `adr/` store from `${CLAUDE_SKILL_DIR}/references/templates/` (the template loop deploys each non-`AGENTS.md`, non-`adr-record.md` template — `adr-record.md` is a skill-home ADR authoring reference, never deployed). This deploys the HOT ADR window **`docs/ai/decisions.md`** and the seed navigator **`docs/ai/adr/log.md`** (its `adr/` subdir copies in wholesale), the `.md` docs, **and** the three seeded, user-editable strict-JSON configs: **`docs/ai/orchestration.json`** (the per-project recipe defaults the `procedures` advisor reads), **`docs/ai/gates.json`** (the project's gate declaration — seeded as the no-consent EMPTY list; FILLING it is the consented `gates-init` preview, `${CLAUDE_SKILL_DIR}/references/modes/gates.md`), and **`docs/ai/autonomy.json`** (the per-project autonomy policy — seeded SPARSE with the onboarding note only, so it is exactly the computed defaults until the user declares levels via `/agent-workflow-kit set-autonomy` or by hand). Keep each `.md` file's frontmatter (`type / lastUpdated / scope / staleAfter / owner / maxLines`); the `.json` seeds carry no frontmatter (the docs cap-validator globs `*.md` only, so they are inherently skipped).
+6. **Deploy `docs/ai/`.** Create every `docs/ai/` file + `pages/` + the seed `adr/` store + the seed `specs/` store from `${CLAUDE_SKILL_DIR}/references/templates/` (the template loop deploys every template except `AGENTS.md`, `adr-record.md` and `SPEC_TEMPLATE.md` — the latter two are skill-home authoring references, never deployed). This deploys the HOT ADR window **`docs/ai/decisions.md`** and the seed navigator **`docs/ai/adr/log.md`** (its `adr/` subdir copies in wholesale), the spec store root **`docs/ai/specs/index.md`** (its `specs/` subdir copies in wholesale), the `.md` docs, **and** the three seeded, user-editable strict-JSON configs: **`docs/ai/orchestration.json`** (the per-project recipe defaults the `procedures` advisor reads), **`docs/ai/gates.json`** (the project's gate declaration — seeded as the no-consent EMPTY list; FILLING it is the consented `gates-init` preview, `${CLAUDE_SKILL_DIR}/references/modes/gates.md`), and **`docs/ai/autonomy.json`** (the per-project autonomy policy — seeded SPARSE with the onboarding note only, so it is exactly the computed defaults until the user declares levels via `/agent-workflow-kit set-autonomy` or by hand). Keep each `.md` file's frontmatter (`type / lastUpdated / scope / staleAfter / owner / maxLines`); the `.json` seeds carry no frontmatter (the docs cap-validator globs `*.md` only, so they are inherently skipped).
 7. **Fill templates** per the table below. **Then materialize the navigator, as the last `docs/ai` step:** the entry point declares `docs/ai/index.md` always-loaded and it is a GENERATED artifact with no template, so run `node ${CLAUDE_SKILL_DIR}/references/scripts/check-docs-size.mjs --ensure-index --root=<project>` and relay its one outcome line (`ensure-index: regenerated` / `already-current`, or a `write-refused` / `probe-failed` line naming the offending path — either is a STOP: resolve it before reporting the deploy, since the navigator the entry point declares does not exist yet). The generator runs from **this skill's own directory**, so a project with **no Node runtime** is covered too: the agent host runs it, and step 8's copy is not a precondition.
 8. **Install enforcement (Node projects).** Copy `${CLAUDE_SKILL_DIR}/references/scripts/*.mjs` (+ `*.test.mjs`) into the project's `scripts/`. They self-configure (project name from `package.json`, hierarchical/on-demand sections auto-discovered). **If the project has no Node runtime** (step-1 recon), skip this step and the hook in step 9 — follow the cap/archive/index policy manually, or port the scripts to the project's language.
 9. **Wire / hide** per visibility (see [Visibility contract](${CLAUDE_SKILL_DIR}/references/contracts.md#visibility-contract)). Install the pre-commit hook (Node projects): `node scripts/install-git-hooks.mjs`. If the installer reports a pre-existing non-marker hook, stop and ask the user to merge it manually rather than overwriting. Once the gate declaration is final-run-capable, the installer's optional consented `--commit-guard <kit commit-guard.mjs path>` arm binds commits to the green `run-gates --final` receipt (the Recommendations advisor surfaces the exact one-liner).

package/references/modes/mcp.md

@@ -17,6 +17,8 @@ Run `node ${CLAUDE_SKILL_DIR}/tools/mcp.mjs [--dry-run | --apply] [--cwd <dir>]`
 2. **Ask consent** via **`AskUserQuestion` where supported**, the no-change option first: keep the shell lanes, or register the typed channel — presenting the trust posture above in plain language.
 3. **Only on an explicit yes**, re-run with `--apply`. It writes **`.mcp.json` FIRST, then `.claude/settings.json`** — settings that enable a server whose entry is not yet there is a client error on every startup. Both writes are merge-don't-clobber (foreign servers, foreign keys and existing allow rules preserved; a re-apply adds nothing twice) and keep each file's existing EOL. New MCP servers are picked up when the client next starts — unlike the `hook` mode, this is not a hot reload.
 
+4. **Hidden-mode deployments:** after apply, run the hide-footprint reconcile (`node ${CLAUDE_SKILL_DIR}/tools/hide-footprint.mjs --dir <project> --reconcile`) so the registration stays invisible to `git status` — `/.mcp.json` is in the known-footprint registry; every output arm reminds you.
+
 **The two arms that are not a write:**
 
 - **DIFFERING** — `.mcp.json` already carries an `"agent-workflow"` entry that **structurally differs** from ours (another kit copy, a hand-edited path, an added `env`, a `null`). The comparison is deliberately key-order-independent, so a re-serialized identical entry is the SAME registration, while any real difference in what would be launched is a difference. The run **STOPs unwritten, on both lanes**: silently changing what an MCP server launches is exactly what consent must not slide past. The recovery is named — review that entry, then remove or rename it and re-run. The kit never resolves this for you.

package/references/modes/worktrees.md

@@ -14,10 +14,25 @@ The ONE stored-metadata exception is the PREPARED OID recorded in the handoff: l
 Git ≥ 2.36 is required for NUL-terminated worktree porcelain; an older Git fails closed with its
 own verbatim error through the existing Git-error surface.
 
+**The MCP registration is never HANDED to a worktree, and never owned by one.** The scope is the
+untracked lanes this tool drives — the registry copy set and `--include` (refused pre-mutation, and
+a recorded include from an older handoff is filtered out too); a TRACKED `.mcp.json` still arrives
+with `git worktree add`, because that is the checkout, not a copy. `/.mcp.json` names an absolute
+machine path and its consent is per checkout, so it is excluded from the copy set, from the provision
+containment sweep, and from what `cleanup` may remove — a satellite's own `.mcp.json` therefore stays
+classified as foreign work and blocks cleanup, rather than being deleted as ours. The settings half
+is rewritten only under ONE conjunction of proven facts: untracked, bytes still MAIN's (or their
+rebased form), and a launcher proven ABSENT — then the copy loses our `enabledMcpjsonServers`
+membership and our two derived allow rules and nothing else. Every other state keeps its registration
+TOKENS — not necessarily its bytes, since `rebasePins` may still rewrite absolute pins in that same
+file on its own lane — and, where the settings file is readable, well-formed and actually carries
+tokens, gets a neutral line naming them; orphanhood is claimed only where it is proven.
+
 - `provision <slug> --plan <path> [--as <name>.md] [--dir <path>] [--branch <name>] [--include <path>]... [--install] [--resume]`
   — create a feature worktree (default: the visible sibling `<repoParent>/<repoName>--<slug>`,
   branch `aw/<slug>`) and populate it: the registry-derived footprint copy-if-missing (a tracked
-  file is NEVER overwritten), EXACTLY ONE seeded feature plan, the `handoff-<slug>.md` stub
+  file is NEVER overwritten, and `/.mcp.json` is never copied or owned — see below), EXACTLY ONE seeded
+  feature plan, the `handoff-<slug>.md` stub
   (written at provision — the tool's own record; `list` and `cleanup` read it), a
   `node_modules` symlink when main has one and the link stays ignored — a SHARED MUTABLE cache:
   writes through it hit MAIN's node_modules; for isolation RUN the printed isolated-install

package/references/scripts/check-docs-size.mjs

@@ -29,6 +29,7 @@ import { existsSync, lstatSync, realpathSync } from 'node:fs';
 import { dirname, resolve, relative, join, basename, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomBytes } from 'node:crypto';
+import { readSpecDocument, SPECS_COLLAPSE } from './spec-schema.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -36,10 +37,8 @@ const ROOT = resolve(__dirname, '..');
 const DOCS_DIR = resolve(ROOT, 'docs/ai');
 const INDEX_PATH = resolve(DOCS_DIR, 'index.md');
 
-// Root-parameterized (BUGFREE-3 / AD-049, item (h)): the module ROOT constants are the CLI DEFAULT
-// (this deployment's own root); `--root=<dir>` and the exported `regenerateIndex(root, today)`
-// override them so the ADR-rotation hook (archive-decisions.mjs) and hermetic tests can regenerate
-// an arbitrary root's index without ever touching the real repo tree.
+// The module ROOT constants are the CLI DEFAULT (this deployment's own root); `--root=<dir>` and the
+// exported `regenerateIndex(root, today)` target an arbitrary root (the ADR-rotation hook, hermetic tests).
 const pathsFor = (root) => {
   const base = resolve(root);
   return { root: base, docsDir: resolve(base, 'docs/ai'), indexPath: resolve(base, 'docs/ai/index.md') };
@@ -58,12 +57,9 @@ const ENSURE_INDEX_PREFIX = 'ensure-index:';
 const DEFAULT_PROJECT_NAME = 'this project';
 const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'dist-ssr', 'coverage', 'build', '.next']);
 
-// `strict` is the finalizer's lens on the SAME walk: for a report, an unreadable subtree is fairly
-// skipped, but a run that WRITES the navigator may not silently treat "could not read" as "nothing
-// there" — it would publish an index missing whatever it could not see and call that success. Only
-// a genuine ENOENT stays an absence; every other fs error propagates.
-// Only a genuine ENOENT is an absence. A code-LESS throw (an injected reader, a wrapped client) is
-// not evidence of absence either, so it propagates too — "unknown" must never read as "empty".
+// `strict` is the finalizer's lens on the SAME walk: a run that WRITES the navigator may not treat
+// "could not read" as "nothing there". Only a genuine ENOENT is an absence — a code-LESS throw (an
+// injected reader, a wrapped client) propagates too: "unknown" must never read as "empty".
 const rethrowUnlessAbsent = (err, strict) => {
   if (strict && err?.code !== 'ENOENT') throw err;
 };
@@ -204,24 +200,25 @@ export const computeToday = (todayStr) =>
     ? new Date(`${todayStr}T00:00:00Z`)
     : new Date(new Date().toISOString().slice(0, 10) + 'T00:00:00Z');
 
+// A file under the spec store is ALSO read through the shared reader (already-read text, no second
+// read): its verdict rides the row as `spec` and decides collapse eligibility; a refusal is ADVISORY
+// here — surfaced as warnings, never a cap error — the structural checker owns the refusal.
+const readSpecVerdict = (rel, text) =>
+  rel.startsWith(SPECS_COLLAPSE.prefix) ? readSpecDocument(text, rel.slice(SPECS_COLLAPSE.prefix.length)) : null;
+
 export const inspectFile = async (filePath, today, root = ROOT) => {
   const text = await readFile(filePath, 'utf8');
   const lineCount = text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
   const fm = parseFrontmatter(text);
   const rel = relative(root, filePath);
+  const spec = readSpecVerdict(rel, text);
 
   if (!fm) {
-    return {
-      path: rel,
-      lineCount,
-      frontmatter: null,
-      errors: [`missing YAML frontmatter`],
-      warnings: [],
-    };
+    return { path: rel, lineCount, frontmatter: null, spec, errors: [`missing YAML frontmatter`], warnings: [] };
   }
 
   const errors = [];
-  const warnings = [];
+  const warnings = (spec === null ? [] : [...spec.errors, ...spec.warnings]).map((finding) => `spec ${finding.rule}: ${finding.message}`);
 
   const maxLines = fm.maxLines ? Number(fm.maxLines) : null;
   if (maxLines === null || Number.isNaN(maxLines)) {
@@ -241,7 +238,7 @@ export const inspectFile = async (filePath, today, root = ROOT) => {
     }
   }
 
-  return { path: rel, lineCount, frontmatter: fm, errors, warnings };
+  return { path: rel, lineCount, frontmatter: fm, spec, errors, warnings };
 };
 
 const formatRow = (row) => {
@@ -304,19 +301,16 @@ const formatIndexRow = (row) => {
   return `| ${link} | ${fm.type ?? '—'} | ${row.lineCount}/${fm.maxLines ?? '—'} | ${fm.lastUpdated ?? '—'} | ${fm.staleAfter ?? '—'} |`;
 };
 
-// The one-file-per-ADR store (docs/ai/adr/) grows O(n) forever, so its rows would blow the index's
-// own 80-line cap. It COLLAPSES to a single aggregate row (link → the navigator adr/log.md, record
-// count + numeric id range) — while walkMarkdownFiles still finds + cap-checks every individual body
-// (a body over its own cap still fails in the main flow; only the index RENDERING is collapsed).
+// Two stores grow O(n) forever and would blow the index's own 80-line cap: the one-file-per-ADR store
+// (docs/ai/adr/) and the spec store (docs/ai/specs/). Each is a GROUP that COLLAPSES to a single
+// counted row — while walkMarkdownFiles still finds + cap-checks every individual body (only the
+// index RENDERING is collapsed). Membership is by PROOF: a genuine ADR record / the adr navigator,
+// or a spec-store file the shared reader accepts. Anything else under either dir (a stray README.md,
+// a malformed spec) renders as its OWN visible row — never silently hidden by the collapse.
 const ADR_DIR_PREFIX = 'docs/ai/adr/';
 const ADR_RECORD_RE = /\/AD-(\d{3,})-[^/]*\.md$/;
 const ADR_NAV_PATH = 'docs/ai/adr/log.md';
 
-// Only genuine records + the navigator collapse into the aggregate row; an UNEXPECTED file under
-// adr/ (a stray README.md, AD-foo.md) renders as its OWN visible index row — never silently hidden
-// by the collapse (it also fails archive-decisions' own store-integrity check).
-const isCollapsibleAdr = (path) => path.startsWith(ADR_DIR_PREFIX) && (ADR_RECORD_RE.test(path) || path === ADR_NAV_PATH);
-
 const formatAdrCollapseRow = (adrRows) => {
   const recs = adrRows
     .map((r) => {
@@ -329,23 +323,37 @@ const formatAdrCollapseRow = (adrRows) => {
   return `| [\`adr/\`](./adr/log.md) | adr | ${recs.length} records | ${range} | — |`;
 };
 
-// Pure index renderer — given inspected rows + the date to stamp in the header,
-// returns the exact bytes `docs/ai/index.md` should contain. Shared by
-// `--write-index` (writes it) and `--check-index` (diffs against on-disk).
+// The live counts make the row change when a spec is added or removed, so --check-index sees it.
+const formatSpecsCollapseRow = (specRows) => {
+  const count = (kind) => specRows.filter((r) => r.spec.kind === kind).length;
+  const link = `[\`${SPECS_COLLAPSE.label}\`](./${SPECS_COLLAPSE.navPath.replace(/^docs\/ai\//, '')})`;
+  return `| ${link} | ${SPECS_COLLAPSE.type} | ${count('spec')} specs | ${count('part')} parts · ${count('index')} indexes | — |`;
+};
+
+const COLLAPSE_GROUPS = [
+  { sortPath: ADR_DIR_PREFIX, isMember: (r) => r.path.startsWith(ADR_DIR_PREFIX) && (ADR_RECORD_RE.test(r.path) || r.path === ADR_NAV_PATH), format: formatAdrCollapseRow },
+  { sortPath: SPECS_COLLAPSE.prefix, isMember: (r) => Boolean(r.spec) && r.spec.errors.length === 0, format: formatSpecsCollapseRow },
+];
+
+// Pure index renderer — inspected rows + the header date → the exact bytes `docs/ai/index.md` should
+// contain. Shared by `--write-index` (writes it) and `--check-index` (diffs against on-disk).
 export const buildIndex = (rows, todayStr, meta = {}) => {
   const projectName = meta.projectName ?? DEFAULT_PROJECT_NAME;
   const onDemandLinks = meta.onDemandLinks ?? [];
   const hierarchicalLinks = meta.hierarchicalLinks ?? [];
   const header = INDEX_HEADER.replace('__TODAY__', todayStr).replace('__PROJECT__', projectName);
   const tableHeader = `| File | Type | Lines/Max | Updated | Stale after |\n|------|------|-----------|---------|-------------|`;
-  const nonAdr = [];
-  const adrRows = [];
+  const singles = [];
+  const grouped = COLLAPSE_GROUPS.map(() => []);
   for (const r of rows) {
     if (r.path === 'docs/ai/index.md') continue;
-    (isCollapsibleAdr(r.path) ? adrRows : nonAdr).push(r);
+    const group = COLLAPSE_GROUPS.findIndex((g) => g.isMember(r));
+    (group === -1 ? singles : grouped[group]).push(r);
   }
-  const tableEntries = nonAdr.map((r) => ({ sortPath: r.path, md: formatIndexRow(r) }));
-  if (adrRows.length > 0) tableEntries.push({ sortPath: ADR_DIR_PREFIX, md: formatAdrCollapseRow(adrRows) });
+  const tableEntries = singles.map((r) => ({ sortPath: r.path, md: formatIndexRow(r) }));
+  COLLAPSE_GROUPS.forEach((g, i) => {
+    if (grouped[i].length > 0) tableEntries.push({ sortPath: g.sortPath, md: g.format(grouped[i]) });
+  });
   tableEntries.sort((a, b) => a.sortPath.localeCompare(b.sortPath));
   const tableRows = tableEntries.map((e) => e.md).join('\n');
   const onDemandSection =
@@ -359,11 +367,8 @@ export const buildIndex = (rows, todayStr, meta = {}) => {
   return `${header}${tableHeader}\n${tableRows}${onDemandSection}${hierarchicalSection}\n`;
 };
 
-// Decides whether an on-disk index is in sync with the source frontmatter.
-// The index is regenerated in memory using the on-disk index's OWN `lastUpdated`
-// for the header, so a mere day-rollover (no content change) is NOT flagged —
-// only genuine drift in the file table (added/removed files, changed
-// type/cap/lastUpdated/staleAfter, or a changed line count) makes it stale.
+// Freshness regenerates the index with the on-disk header's OWN `lastUpdated`, so a mere day-rollover
+// is NOT flagged — only genuine drift in the file table makes it stale.
 export const checkIndexFreshness = (rows, onDiskText, meta = {}) => {
   if (onDiskText === null || onDiskText === undefined || onDiskText === '') {
     return { fresh: false, expected: buildIndex(rows, 'unknown', meta) };
@@ -374,13 +379,11 @@ export const checkIndexFreshness = (rows, onDiskText, meta = {}) => {
   return { fresh: expected === onDiskText, expected };
 };
 
-// The navigator is a GENERATED artifact, so its write must land on the deployment's own file and
-// nowhere else: every component of <root>/docs/ai/index.md is lstat'ed no-follow (a symlinked root,
-// `docs`, `docs/ai` or leaf REFUSES — publishing through one would clobber whatever it points at),
-// the body goes out through a unique exclusive-create temp renamed into place with the chain
-// re-checked immediately before the rename, and the temp never survives a failure. The kit runs the
-// same discipline in atomic-write.mjs; this deployment script ships dependency-free, so the
-// semantics are REIMPLEMENTED here rather than imported.
+// The navigator write lands on the deployment's own file and nowhere else: every component of
+// <root>/docs/ai/index.md is lstat'ed no-follow (a symlink anywhere REFUSES — publishing through one
+// would clobber its target), the body goes out through an exclusive-create temp renamed into place
+// with the chain re-checked before the rename, and the temp never survives a failure. The kit's
+// atomic-write.mjs runs the same discipline; this script ships dependency-free, so it is REIMPLEMENTED.
 export const INDEX_WRITE_REFUSED = 'INDEX_WRITE_REFUSED';
 const refuse = (message) => Object.assign(new Error(message), { code: INDEX_WRITE_REFUSED });
 
@@ -444,11 +447,8 @@ const writeIndex = async (rows, today, meta, { root = ROOT, indexPath = INDEX_PA
   }
 };
 
-// regenerateIndex(root, todayStr) — the ONE reused generator, root-parameterized (item (h)). It runs
-// the SAME walk → inspect → discoverMeta → writeIndex pipeline as `--write-index`, against `root`
-// (default this deployment). The ADR-rotation hook reaches it via the CLI (`--write-index --root=…`);
-// hermetic tests call it directly. `todayStr` is 'YYYY-MM-DD' (null → today). Returns the written
-// index path + row count. No second index implementation exists.
+// regenerateIndex(root, todayStr) — the ONE reused generator: the SAME walk → inspect → discoverMeta →
+// writeIndex pipeline as `--write-index`, against `root`. `todayStr` is 'YYYY-MM-DD' (null → today).
 export const regenerateIndex = async (root, todayStr = null, deps = {}) => {
   const paths = pathsFor(root);
   const today = computeToday(todayStr);
@@ -460,12 +460,10 @@ export const regenerateIndex = async (root, todayStr = null, deps = {}) => {
   return { indexPath: paths.indexPath, files: rows.length };
 };
 
-// The finalizer promises its caller EXACTLY ONE outcome line, so every step it owns — the walk, the
-// metadata discovery, the freshness read and the write — runs inside one classified error path: an
-// unreadable docs/ai is a NAMED refusal, never a stack trace. The containment guard runs BEFORE the
-// freshness read for the same reason `already-present` needs a kind probe: a symlinked navigator
-// whose target happens to hold current bytes would otherwise report `already-current` over a file
-// this mode refuses to write through — an exit 0 proving nothing about the deployment's own file.
+// The finalizer promises EXACTLY ONE outcome line, so every step it owns runs inside one classified
+// error path: an unreadable docs/ai is a NAMED refusal, never a stack trace. The containment guard
+// runs BEFORE the freshness read: a symlinked navigator whose target holds current bytes would
+// otherwise report `already-current` over a file this mode refuses to write through.
 const runEnsureIndex = async ({ root, docsDir, indexPath, today, deps }) => {
   const lstat = deps.lstat ?? lstatSync;
   const read = deps.readFile ?? readFile;
@@ -571,9 +569,8 @@ export const runCli = async (argv, deps = {}) => {
   return result(errorCount > 0 && !flags.report ? 1 : 0);
 };
 
-// Run main() only when executed directly, never on import. Compare by REAL path: an entry point
-// reached through a symlink resolves to its target, so a raw string compare reads the two as
-// different and the CLI never runs. realpathSync collapses the link so both sides match.
+// Run main() only when executed directly, never on import — compared by REAL path, so an entry point
+// reached through a symlink still runs.
 const isDirectRun = (() => {
   const invoked = process.argv[1];
   if (!invoked) return false;

package/references/scripts/check-docs-size.test.mjs

@@ -178,11 +178,7 @@ describe('buildIndex — docs/ai/adr/ directory collapse (Decision 11)', () => {
   });
 
   it('a stray adr/ markdown file renders as its OWN visible row (never collapsed/hidden)', () => {
-    const rows = [
-      makeRow('docs/ai/adr/AD-001-a.md', { frontmatter: { type: 'adr', maxLines: '400' } }),
-      makeRow('docs/ai/adr/log.md', { frontmatter: { type: 'reference', maxLines: '200' } }),
-      makeRow('docs/ai/adr/notes.md', { frontmatter: { type: 'reference', maxLines: '100' } }),
-    ];
+    const rows = [makeRow('docs/ai/adr/AD-001-a.md', { frontmatter: { type: 'adr', maxLines: '400' } }), makeRow('docs/ai/adr/log.md', { frontmatter: { type: 'reference', maxLines: '200' } }), makeRow('docs/ai/adr/notes.md', { frontmatter: { type: 'reference', maxLines: '100' } })];
     const out = buildIndex(rows, '2026-07-09');
     expect(out).toMatch(/adr\/notes\.md/); // the stray is a visible row, not swallowed by the collapse
     const aggregateRows = out.split('\n').filter((l) => l.includes('](./adr/log.md)'));
@@ -190,11 +186,7 @@ describe('buildIndex — docs/ai/adr/ directory collapse (Decision 11)', () => {
   });
 
   it('the aggregate row shows the record count and a NUMERIC id range (AD-200 … AD-1000)', () => {
-    const rows = [
-      makeRow('docs/ai/adr/AD-200-a.md', { frontmatter: { type: 'adr', maxLines: '400' } }),
-      makeRow('docs/ai/adr/AD-1000-b.md', { frontmatter: { type: 'adr', maxLines: '400' } }),
-      makeRow('docs/ai/adr/log.md', { frontmatter: { type: 'reference', maxLines: '200' } }),
-    ];
+    const rows = [makeRow('docs/ai/adr/AD-200-a.md', { frontmatter: { type: 'adr', maxLines: '400' } }), makeRow('docs/ai/adr/AD-1000-b.md', { frontmatter: { type: 'adr', maxLines: '400' } }), makeRow('docs/ai/adr/log.md', { frontmatter: { type: 'reference', maxLines: '200' } })];
     const out = buildIndex(rows, '2026-07-09');
     expect(out).toMatch(/\[`adr\/`\]\(\.\/adr\/log\.md\) \| adr \| 2 records \| AD-200 … AD-1000/);
   });
@@ -219,13 +211,70 @@ describe('buildIndex — docs/ai/adr/ directory collapse (Decision 11)', () => {
   });
 });
 
+// The spec store (docs/ai/specs/**) joins the collapse as a second GROUP: every file whose reader
+// verdict is clean folds into ONE counted `specs/` row; a file the reader refuses keeps its own row.
+const SPEC_FRONT = (kind, maxLines, extra = '') =>
+  `---\ntype: spec\nlastUpdated: 2026-08-23\nscope: permanent\nstaleAfter: 90d\nowner: none\nmaxLines: ${maxLines}\nkind: ${kind}\n${extra}---\n`;
+const specBody = (slug) =>
+  `\n# Spec: ${slug}\n\n## Contract\n\nc\n\n## Scenarios\n\n- S1 a :: test/${slug}.test.mjs :: spec:${slug}/S1\n\n## Out of scope\n\n- b\n\n## Module\n\n- src/${slug}/\n`;
+const specRow = (path, kind, errors = []) => makeRow(path, { frontmatter: { type: 'spec', maxLines: '150' }, spec: { kind, status: 'draft', revision: 1, errors, warnings: [] } });
+const SPECS_ROW_RE = /\| \[`specs\/`\]\(\.\/specs\/index\.md\) \| spec \| (\d+) specs \| (\d+) parts · (\d+) indexes \| — \|/;
+
+describe('buildIndex — docs/ai/specs/ store collapse (spec layer 1a)', () => {
+  it('1000 valid specs + their indexes render ONE counted specs/ row; the index stays <= 80 lines', () => {
+    const specs = Array.from({ length: 1000 }, (_, i) => specRow(`docs/ai/specs/d${Math.floor(i / 30)}/s${i}.md`, 'spec'));
+    const indexes = Array.from({ length: 34 }, (_, i) => specRow(`docs/ai/specs/d${i}/index.md`, 'index'));
+    const rows = [makeRow('docs/ai/handover.md'), specRow('docs/ai/specs/index.md', 'index'), ...indexes, ...specs];
+    const out = buildIndex(rows, '2026-08-23');
+    const lines = out.split('\n');
+    expect(lines.filter((l) => l.includes('](./specs/index.md)')).length).toBe(1);
+    expect(out).not.toMatch(/s999\.md/);
+    expect(lines.length <= 80).toBe(true);
+    expect(out.match(SPECS_ROW_RE).slice(1)).toEqual(['1000', '0', '35']);
+  });
+
+  it('the counted row carries live counts per kind; a malformed file under specs/ keeps its OWN visible row beside it', () => {
+    const rows = [specRow('docs/ai/specs/index.md', 'index'), specRow('docs/ai/specs/a/index.md', 'spec'), specRow('docs/ai/specs/a/p.md', 'part'), specRow('docs/ai/specs/b.md', 'spec'), specRow('docs/ai/specs/broken.md', null, [{ rule: 'kind', message: 'x' }])];
+    const out = buildIndex(rows, '2026-08-23');
+    expect(out).toMatch(/specs\/broken\.md/);
+    expect(out.match(SPECS_ROW_RE).slice(1)).toEqual(['2', '1', '1']);
+  });
+
+  it('adding or removing one valid spec drifts the counted row -> the on-disk index is stale', () => {
+    const base = [specRow('docs/ai/specs/index.md', 'index'), specRow('docs/ai/specs/a.md', 'spec')];
+    const onDisk = buildIndex(base, '2026-08-23');
+    expect(checkIndexFreshness([...base, specRow('docs/ai/specs/b.md', 'spec')], onDisk).fresh).toBe(false);
+    expect(checkIndexFreshness(base.slice(0, 1), onDisk).fresh).toBe(false);
+    expect(checkIndexFreshness(base, onDisk).fresh).toBe(true);
+  });
+
+  it('inspectFile reads a file under docs/ai/specs/ through the reader: clean -> spec verdict, malformed -> advisory warnings only', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'specs-inspect-'));
+    try {
+      await mkdir(join(root, 'docs', 'ai', 'specs'), { recursive: true });
+      const clean = join(root, 'docs', 'ai', 'specs', 'login.md');
+      await writeFile(clean, `${SPEC_FRONT('spec', 150, 'status: draft\nrevision: 1\n')}${specBody('login')}`);
+      const ok = await inspectFile(clean, computeToday('2026-08-23'), root);
+      expect(ok.errors).toEqual([]);
+      expect(ok.spec.kind).toBe('spec');
+      expect(ok.spec.errors).toEqual([]);
+      const malformed = join(root, 'docs', 'ai', 'specs', 'broken.md');
+      await writeFile(malformed, `${SPEC_FRONT('spec', 150, 'status: draft\nrevision: 1\n')}${specBody('login')}`);
+      const bad = await inspectFile(malformed, computeToday('2026-08-23'), root);
+      expect(bad.errors).toEqual([]);
+      expect(bad.spec.errors.map((e) => e.rule)).toEqual(['scenario-marker']);
+      expect(bad.warnings.some((w) => /spec scenario-marker/.test(w))).toBe(true);
+      await writeFile(join(root, 'docs', 'ai', 'handover.md'), `${SPEC_FRONT('spec', 150)}\n# outside the store\n`);
+      expect((await inspectFile(join(root, 'docs', 'ai', 'handover.md'), computeToday('2026-08-23'), root)).spec).toBe(null);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('buildIndex', () => {
   it('is deterministic, sorts rows by path, and excludes index.md itself', () => {
-    const rows = [
-      makeRow('docs/ai/index.md'),
-      makeRow('docs/ai/b.md'),
-      makeRow('docs/ai/a.md'),
-    ];
+    const rows = [makeRow('docs/ai/index.md'), makeRow('docs/ai/b.md'), makeRow('docs/ai/a.md')];
     const out = buildIndex(rows, '2026-05-29');
     expect(out).toBe(buildIndex(rows, '2026-05-29')); // deterministic
     expect(out).not.toMatch(/\[`index\.md`\]/); // index.md row excluded
@@ -328,4 +377,19 @@ describe('root parameterization (item (h))', () => {
     expect(stale.status).toBe(1);
     expect(stale.stderr).toMatch(/stale/);
   });
+
+  it('the hook path over a real specs/ store: ONE counted row in the written index, a new spec makes --check-index exit 1', async () => {
+    const store = join(root, 'docs', 'ai', 'specs');
+    await mkdir(store, { recursive: true });
+    await writeFile(join(store, 'index.md'), `${SPEC_FRONT('index', 80)}\n# Specs\n\n> Up: [technical_specification.md](../technical_specification.md)\n\n## Children\n\n- [login](./login.md)\n`);
+    await writeFile(join(store, 'login.md'), `${SPEC_FRONT('spec', 150, 'status: draft\nrevision: 1\n')}${specBody('login')}`);
+    expect(runCli(['--write-index', `--root=${root}`]).status).toBe(0);
+    const index = await readFile(join(root, 'docs', 'ai', 'index.md'), 'utf8');
+    expect(index.match(SPECS_ROW_RE).slice(1)).toEqual(['1', '0', '1']);
+    expect(index).not.toMatch(/specs\/login\.md/);
+    expect(runCli(['--check-index', `--root=${root}`]).status).toBe(0);
+    await writeFile(join(store, 'signup.md'), `${SPEC_FRONT('spec', 150, 'status: draft\nrevision: 1\n')}${specBody('signup')}`);
+    expect(runCli(['--check-index', `--root=${root}`]).status).toBe(1);
+    expect(runCli([`--root=${root}`]).status).toBe(0);
+  });
 });