@sabaiway/agent-workflow-kit 11.2.0 → 12.0.0

package/CHANGELOG.md

@@ -4,6 +4,23 @@ 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.
 
+## 12.0.0 — the reader mirror refuses an open-list clause, the outgoing reader becomes a prior, the consult line names the second case and the lens walks around every check (AD-133)
+
+**MAJOR by the AD-117 class.** `references/scripts/spec-schema.mjs` and its test are the memory 8.0.0 bodies
+byte-identically — `spec-check` relays the new `open-list` rule unchanged, so a consumer store valid under the old canon
+can refuse under this kit; the remedy is the closing clause, never a fourth case. `tools/script-priors.mjs` and
+`FROZEN_PRIORS` gain the outgoing reader pair as `5.0.0`..`7.2.1` with its fixture bodies under
+`test/fixtures/script-priors/5.0.0/`, so a deployed 5.0.0–7.2.1 reader classifies `prior`, never `custom`.
+
+**The consult clause and the lens bullet.** `tools/procedures.mjs` `CONSULT_LINE` — two source literals joined into
+ONE rendered line, each under the 1000-byte cap — renders inside the agy `--focus` payload "If this finding is the
+second case against the same check, reply with the replacement invariant, not an added case."; the codex consult-brief
+and the lens re-dispatch forms say "with the same payload"; `tools/procedures.test.mjs` pins the payload order for both
+activities. `references/agents/review-lens.md` gains the "How to review" bullet **When the artifact is a plan, walk
+around every check** (the S12 arm in `cheap-agents-derived.test.mjs`; the placed copy takes the same line on refresh).
+`tools/spec-coverage.test/cli.test.mjs` characterizes the S6 exit partition (`--help` / `-h` as the sole argument, an
+unreadable store, a stray `--reason` beside `--check`, the debt-write failure as an exception).
+
 ## 11.2.0 — a field report is triaged through a rendered procedure over a checked record (AD-132)
 
 Three consumer field reports were triaged ad hoc — verify each claim on HEAD, record the verdict,

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: '11.2.0'
+  version: '12.0.0'
 ---
 
 # agent-workflow-kit

package/capability.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "11.2.0",
+  "version": "12.0.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/agents/review-lens.md

@@ -29,6 +29,7 @@ How to review:
   restatement of design intent back to the orchestrator.
 - **Respect what is already decided.** The prompt will name findings already folded and decisions
   already locked. Re-raising them is churn; checking whether the FIX is correct is real work.
+- **When the artifact is a plan, walk around every check.** For every check bullet of each governing spec, name the invariant it proves and one state that walks around it; a named state is a finding with the replacement invariant, never an added case.
 - **Accuracy over volume.** A wrong finding costs the orchestrator more than a missed one — it
   spends a verification cycle and erodes trust in the whole list. If an angle turns up nothing, say
   so in one line and move on. Never pad.

package/references/scripts/spec-schema.mjs

@@ -1,13 +1,5 @@
 #!/usr/bin/env node
-// spec-schema.mjs — the ONE reader that DEFINES a well-formed spec document under docs/ai/specs/.
-//
-// Pure text in, verdict out: readSpecDocument(text, rel) never touches the filesystem and imports
-// nothing, so it seeds layout-free into any deployment. The navigator's collapse (check-docs-size.mjs)
-// and the future spec-check read through THIS module — "malformed" has one definition, never two.
-// `rel` is the path INSIDE docs/ai/specs/ (the store root navigator is `index.md`).
-//
-// SPEC_SCHEMA carries the frozen values; the engine canon (references/specs.md) is pinned against it.
-// A refusal names exactly one rule id per defect, so a fixture corpus can be read rule by rule.
+// Canon: the methodology engine's references/specs.md (frozen schema, refusals table).
 
 export const SPEC_SCHEMA = Object.freeze({
   storePrefix: 'docs/ai/specs/',
@@ -34,17 +26,25 @@ export const SPEC_SCHEMA = Object.freeze({
   rootOwnedKeys: Object.freeze(['status', 'revision']),
   rootOwnedSections: Object.freeze(['## Scenarios', '## Out of scope', '## Module', '## Parts']),
   scenarioGrammar: '- S<N> <name> :: <repo-relative test path> :: spec:<slug>/S<N>  |  - S<N> <name> :: unbound',
+  openList: Object.freeze({
+    checkVerbs: Object.freeze(['refuse', 'refusal', 'REFUSE', 'REFUSAL']),
+    enumerationForms: Object.freeze([Object.freeze([',', ' or ']), Object.freeze([' · '])]),
+    closureTokens: Object.freeze([
+      'only if', 'only when', 'the only', 'everything else', 'anything else', 'nothing else',
+      'every other', 'any other', 'otherwise', 'exactly', 'one of', 'closed',
+    ]),
+    emphaticToken: 'ONLY',
+  }),
   rules: Object.freeze([
     'frontmatter', 'frontmatter-key', 'substrate-key', 'type', 'kind', 'maxlines', 'status', 'revision',
     'root-owns', 'slug', 'kind-path', 'root-uplink', 'title', 'section-missing', 'section-order',
-    'section-forbidden', 'fence', 'children-link', 'children-duplicate', 'fan-out', 'scenario-line',
+    'section-forbidden', 'fence', 'open-list', 'children-link', 'children-duplicate', 'fan-out', 'scenario-line',
     'scenario-number', 'scenario-marker', 'scenario-path', 'scenarios-empty', 'out-of-scope', 'module-line', 'module-empty',
     'module-traversal', 'module-absolute', 'module-backslash', 'module-glob', 'module-mix', 'parts',
   ]),
 });
 
-// The descriptor check-docs-size.mjs joins to its ADR group: rows under `prefix` whose reader verdict
-// is clean collapse into ONE navigator row linking `navPath`; a row with reader errors stays visible.
+// Consumer contract: scripts/check-docs-size.mjs.
 export const SPECS_COLLAPSE = Object.freeze({
   prefix: SPEC_SCHEMA.storePrefix,
   navPath: `${SPEC_SCHEMA.storePrefix}${SPEC_SCHEMA.navigatorFile}`,
@@ -72,8 +72,6 @@ const FORBIDDEN_SECTIONS = Object.freeze({
 
 const KNOWN_KEYS = Object.freeze([...SPEC_SCHEMA.substrateKeys, 'kind', ...SPEC_SCHEMA.rootOwnedKeys]);
 
-// The frontmatter is a closed key set: an unknown key, a repeated key or a line that is not
-// `key: value` is a defect (`frontmatter-key`), never silently dropped or last-one-wins.
 const parseFrontmatter = (text) => {
   const match = text.match(FRONTMATTER_RE);
   if (!match) return null;
@@ -91,10 +89,6 @@ const parseFrontmatter = (text) => {
 
 const FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
 
-// The body as { title, sections: [{ heading, lines }], preamble, fenced } — the title is the FIRST
-// `# ` line, every `## ` line opens a section, the lines before the first section are the preamble.
-// The reader parses NO markdown code: a fence line is recorded (the `fence` refusal) rather than
-// modelled, so a spec carries no code sample and no line is ever ambiguous between code and structure.
 const parseBody = (body) => {
   const sections = [];
   const preamble = [];
@@ -116,8 +110,6 @@ const parseBody = (body) => {
   return { title: state.title, sections, preamble, fenced, sectionBeforeTitle: state.sectionBeforeTitle };
 };
 
-// Lexical classification of a repo-relative path field — the same vocabulary for module roots and
-// scenario bindings. Realpath/symlink containment needs the filesystem and is the checker's duty.
 export const classifyPath = (path) => {
   if (path.trim() === '') return 'empty';
   if (path.includes('\\')) return 'backslash';
@@ -139,8 +131,47 @@ const MODULE_PATH_RULES = Object.freeze({
 const isBullet = (line) => line === '-' || line.startsWith('- ');
 const bulletsOf = (lines) => lines.filter(isBullet).map((line) => line.slice(2));
 const contentOf = (lines) => lines.filter((line) => line.trim() !== '');
+const isAtxHeading = (line) => /^ {0,3}#{1,6}(?:[ \t]|$)/.test(line);
+const topLevelBulletsOf = (lines) => lines.reduce((state, raw) => {
+  const line = raw.replace(/\s+$/, '');
+  if (isBullet(line)) {
+    state.current = [line === '-' ? '' : line.slice(2)];
+    state.bullets.push(state.current);
+  } else if (line.trim() === '' || isAtxHeading(line)) state.current = null;
+  else if (state.current !== null) state.current.push(line.trim());
+  return state;
+}, { bullets: [], current: null }).bullets.map((parts) => parts.join(' ').replace(/\s+/g, ' ').trim());
+
+const CLAUSE_BREAK = String.fromCharCode(0);
+const MASKED_DOT = String.fromCharCode(1);
+const MASKED_SEMICOLON = String.fromCharCode(2);
+const maskClauseSpans = (text) => [...text].reduce((state, character) => {
+  if (character === '`') state.inSpan = !state.inSpan;
+  state.output.push(state.inSpan && character === '.' ? MASKED_DOT : state.inSpan && character === ';' ? MASKED_SEMICOLON : character);
+  return state;
+}, { inSpan: false, output: [] }).output.join('');
+const clausesOf = (bullet) => maskClauseSpans(bullet).replace(/([.;][*`\)\]]*) /g, `$1${CLAUSE_BREAK}`).split(CLAUSE_BREAK)
+  .map((clause) => clause.split(MASKED_DOT).join('.').split(MASKED_SEMICOLON).join(';').trim()).filter(Boolean);
+const containsInOrder = (text, tokens) => tokens.reduce((position, token) => {
+  const found = position === -1 ? -1 : text.indexOf(token, position);
+  return found === -1 ? -1 : found + token.length;
+}, 0) !== -1;
+const hasBoundedToken = (clause, token, flags) => new RegExp(`(^|[^A-Za-z0-9_-])${token}([^A-Za-z0-9_-]|$)`, flags).test(clause);
+const checkOpenLists = (parsed, kind, errors) => {
+  const groups = kind === 'spec' ? parsed.sections.filter((section) => section.heading === '## Contract').map((section) => section.lines)
+    : kind === 'part' ? [parsed.preamble, ...parsed.sections.map((section) => section.lines)] : [];
+  for (const clause of groups.flatMap(topLevelBulletsOf).flatMap(clausesOf)) {
+    const hasVerb = SPEC_SCHEMA.openList.checkVerbs.some((verb) => clause.includes(verb));
+    const hasEnumeration = SPEC_SCHEMA.openList.enumerationForms.some((form) => containsInOrder(clause, form));
+    const hasClosure = SPEC_SCHEMA.openList.closureTokens.some((token) => hasBoundedToken(clause, token, 'i'))
+      || hasBoundedToken(clause, SPEC_SCHEMA.openList.emphaticToken, '');
+    if (hasVerb && hasEnumeration && !hasClosure) {
+      const prefix = clause.split(/\s+/).slice(0, 6).join(' ');
+      errors.push({ rule: 'open-list', message: `the clause "${prefix}…" is an open list — add a closing form to it such as "only if …; everything else …"` });
+    }
+  }
+};
 
-// The slug a document owns: the file stem for a flat file, the folder name for an index.md.
 const describeRel = (rel) => {
   const segments = rel.split('/');
   const file = segments[segments.length - 1];
@@ -314,11 +345,7 @@ const checkParts = (parsed, at, errors) => {
   if (duplicate !== undefined) errors.push({ rule: 'parts', message: `part "${duplicate}" is listed twice` });
 };
 
-// The structure verdict (additive, slice 2a): the DETERMINISTIC extraction of what parsed, per
-// section, targets VERBATIM as written (`./x.md` and `./x/index.md` stay distinct strings). The
-// grammar is per line for scenarios/children/parts — a malformed line is simply absent — while the
-// module is a conjunction (ONE `dir/` root or an all-file list): prose, a refused path, a mix or
-// `*(empty)*` extracts null. `## Links` is free prose and is never extracted.
+// Structure verdict: the same canon, "The frozen schema".
 const scenarioEntry = (line) => {
   const scenario = parseScenario(line);
   if (scenario === null) return null;
@@ -345,10 +372,6 @@ const extractStructure = (parsed) => ({
   module: extractModule(parsed),
 });
 
-// The verdict: { kind, status, revision, structure, errors: [{ rule, message }], warnings: [{ rule,
-// message }] }. Errors are collected past the first defect wherever later checks stay meaningful; a
-// missing or defective frontmatter and an unknown kind each end the read (structure stays null),
-// because no shape can be judged without them.
 export const readSpecDocument = (text, rel) => {
   const errors = [];
   const warnings = [];
@@ -372,6 +395,7 @@ export const readSpecDocument = (text, rel) => {
   const at = checkPath(rel, kind, errors);
   const parsed = parseBody(body);
   if (parsed.fenced.length > 0) errors.push({ rule: 'fence', message: `"${parsed.fenced[0]}" — a spec document carries no code fence` });
+  checkOpenLists(parsed, kind, errors);
   checkSections(parsed, kind, errors);
   if (kind === 'index') {
     checkChildren(parsed, errors);

package/references/scripts/spec-schema.test.mjs

@@ -32,6 +32,8 @@ const refuses = (text, rel, rule) => {
   const verdict = readSpecDocument(text, rel);
   expect(rulesOf(verdict)).toEqual([rule]);
 };
+const withContract = (contract) => specDoc().replace('Accepts a credential pair.', contract);
+const openListErrors = (contract, rel = 'login.md') => readSpecDocument(withContract(contract), rel).errors;
 
 describe('readSpecDocument — accept', () => {
   it('a flat draft spec reads clean with kind/status/revision', () => {
@@ -269,6 +271,69 @@ describe('readSpecDocument — the structure verdict (additive, slice 2a)', () =
   });
 });
 
+describe('readSpecDocument — open-list clauses', () => {
+  const refusal = 'the clause "an anchor path reported modified, untracked…" is an open list — add a closing form to it such as "only if …; everything else …"';
+  const open = '- an anchor path reported modified, untracked or ignored is the named refusal `anchor-dirty`';
+  const closed = '- an anchor path is accepted only if `ls-files -v` lists it with tag `H` and `status` is silent — everything else, a path reported modified, untracked or ignored, is the named refusal `anchor-dirty`';
+
+  it('refuses the measured clause with the exact message; verb alone, form alone and an in-clause closure pass', () => {
+    expect(openListErrors(open)).toEqual([{ rule: 'open-list', message: refusal }]);
+    for (const text of [closed, '- refuse one case', '- alpha, beta or gamma']) expect(openListErrors(text)).toEqual([]);
+  });
+
+  it('joins continuation lines, collapses whitespace and keeps an indented bullet in its top-level bullet', () => {
+    for (const text of ['- refuse alpha,\n   beta   or ignored', '- refuse alpha,\n  - beta or ignored']) expect(rulesOf(readSpecDocument(withContract(text), 'login.md'))).toEqual(['open-list']);
+  });
+
+  it('ends a bullet at a blank, the next top-level bullet or every ATX heading; Contract prose is ignored', () => {
+    for (const tail of ['\n\nEverything else closes', '\n- Everything else closes', ...Array.from({ length: 6 }, (_, i) => `\n${'#'.repeat(i + 1)} Everything else closes`)]) {
+      expect(rulesOf(readSpecDocument(withContract('- refuse alpha, beta or gamma' + tail), 'login.md'))).toEqual(['open-list']);
+    }
+    expect(openListErrors('refuse alpha, beta or gamma')).toEqual([]);
+  });
+
+  it('ends a bullet at indented and tab-separated ATX headings', () => {
+    for (const tail of ['\n   ## Everything else closes', '\n#\tEverything else closes']) expect(rulesOf(readSpecDocument(withContract('- refuse alpha, beta or gamma' + tail), 'login.md'))).toEqual(['open-list']);
+  });
+
+  it('starts a new empty top-level bullet before following prose', () => {
+    for (const tail of ['\n- \nEverything else closes', '\n-\nonly if closes']) expect(rulesOf(readSpecDocument(withContract('- refuse alpha, beta or gamma' + tail), 'login.md'))).toEqual(['open-list']);
+  });
+
+  it('judges an open list in every Contract section', () => {
+    const duplicate = specDoc().replace('## Scenarios', '## Contract\n\n- refuse alpha, beta or gamma\n\n## Scenarios');
+    expect(rulesOf(readSpecDocument(duplicate, 'login.md')).includes('open-list')).toBe(true);
+  });
+
+  it('splits clauses at punctuation plus markdown tails, but not inside backtick spans', () => {
+    for (const tail of ['.** ', '.` ', '.) ', '.] ', '; ']) expect(rulesOf(readSpecDocument(withContract(`- refuse alpha, beta or gamma${tail}Everything else closes`), 'login.md'))).toEqual(['open-list']);
+    for (const text of ['- refuse `alpha. beta`, gamma or delta', '- refuse `alpha; beta`, gamma or delta', '- refuse `alpha. beta, gamma or delta']) expect(rulesOf(readSpecDocument(withContract(text), 'login.md'))).toEqual(['open-list']);
+    expect(openListErrors('- refuse alpha``. beta, gamma or delta')).toEqual([]);
+  });
+
+  it('keeps span content in judgement, and a closure in a neighbouring clause cannot lift a refusal', () => {
+    expect(rulesOf(readSpecDocument(withContract('- `refuse` alpha, beta or gamma'), 'login.md'))).toEqual(['open-list']);
+    expect(openListErrors('- refuse alpha, beta or gamma with `everything else`')).toEqual([]);
+    expect(rulesOf(readSpecDocument(withContract('- refuse alpha, beta or gamma. Everything else closes'), 'login.md'))).toEqual(['open-list']);
+  });
+
+  it('matches verbs, forms and closure tokens with the frozen case and boundary rules', () => {
+    for (const verb of ['refuse', 'refuses', 'refused', 'refusal', 'refusals', 'REFUSE', 'REFUSAL']) expect(rulesOf(readSpecDocument(withContract(`- ${verb} alpha, beta or gamma`), 'login.md'))).toEqual(['open-list']);
+    for (const text of ['- Refuse alpha, beta or gamma', '- refuse alpha, beta and gamma']) expect(openListErrors(text)).toEqual([]);
+    expect(rulesOf(readSpecDocument(withContract('- refuse alpha · beta'), 'login.md'))).toEqual(['open-list']);
+    for (const token of SPEC_SCHEMA.openList.closureTokens) expect(openListErrors(`- ${token.toUpperCase()}: refuse alpha, beta or gamma`)).toEqual([]);
+    for (const text of ['- refuse alpha, beta or gamma — none of these', '- refuse alpha, beta or gamma — closed-key', '- refuse alpha, beta or gamma — READ-ONLY', '- refuse alpha, beta or gamma — if only this', '- refuse alpha, beta or gamma — not only this']) expect(rulesOf(readSpecDocument(withContract(text), 'login.md'))).toEqual(['open-list']);
+    expect(openListErrors('- refuse alpha, beta or gamma — ONLY this')).toEqual([]);
+  });
+
+  it('judges every part bullet, never an index, and freezes every schema list and inner pair', () => {
+    expect(rulesOf(readSpecDocument(partDoc({ extra: `\n${open}\n` }), 'auth/login/sessions.md'))).toEqual(['open-list']);
+    expect(readSpecDocument(indexDoc({ children: [], preamble: `\n${open}\n` }), 'auth/index.md').errors).toEqual([]);
+    expect(SPEC_SCHEMA.openList).toEqual({ checkVerbs: ['refuse', 'refusal', 'REFUSE', 'REFUSAL'], enumerationForms: [[',', ' or '], [' · ']], closureTokens: ['only if', 'only when', 'the only', 'everything else', 'anything else', 'nothing else', 'every other', 'any other', 'otherwise', 'exactly', 'one of', 'closed'], emphaticToken: 'ONLY' });
+    expect([SPEC_SCHEMA.openList, SPEC_SCHEMA.openList.checkVerbs, SPEC_SCHEMA.openList.enumerationForms, ...SPEC_SCHEMA.openList.enumerationForms, SPEC_SCHEMA.openList.closureTokens].every(Object.isFrozen)).toBe(true);
+  });
+});
+
 describe('classifyPath + the frozen constants', () => {
   it('classifies the lexical path forms', () => {
     expect(['src/', 'src/a.mjs', '../x', '/x', 'C:/x', 'a\\b', 'src/*.mjs'].map(classifyPath)).toEqual([

package/tools/procedures.mjs

@@ -232,7 +232,8 @@ const backendSetLabel = (backends) =>
 // review slot can resolve or request reviewed|council (execute floors at solo|delegated), so the gate
 // reads the recipe, the requested recipe and the roster.
 const REVIEW_RECIPES = new Set(['reviewed', 'council']);
-const CONSULT_LINE = '  • Before every fold of a finding raised by a review member (a bridge backend or a placed lens): ASK that member whether the proposed fold solves it and adds no new problem; WAIT for its answer, READ it, then edit only as accepted or corrected — agy: agy-review --continue --decided @f --focus "Finding: <finding>. Proposed fold: <exact fold>. Does this proposed fold solve the finding and add no new problem? Reply accept, or correct with exact replacement text."; codex: fresh codex-review plan <consult-brief> written before the working tree changes; a placed lens: re-dispatch the same lens vehicle with the finding and the proposed fold. A self-review finding, or any finding when no review member ran, is folded directly — the exemption is the finding\'s ORIGIN, never the recipe word on the slot line.';
+const CONSULT_LINE = '  • Before every fold of a finding raised by a review member (a bridge backend or a placed lens): ASK that member whether the proposed fold solves it and adds no new problem; WAIT for its answer, READ it, then edit only as accepted or corrected — agy: agy-review --continue --decided @f --focus "Finding: <finding>. Proposed fold: <exact fold>. Does this proposed fold solve the finding and add no new problem? If this finding is the second case against the same check, reply with the replacement invariant, not an added case. ' +
+  'Reply accept, or correct with exact replacement text."; codex: fresh codex-review plan <consult-brief> with the same payload written before the working tree changes; a placed lens: re-dispatch the same lens vehicle with the same payload. A self-review finding, or any finding when no review member ran, is folded directly — the exemption is the finding\'s ORIGIN, never the recipe word on the slot line.';
 const ARMED_CONSULT_LINE = '  • ARMED pre-fold sequence for a bridge-raised finding: the round is open → dispatch that bridge\'s consult with a nonce → WAIT and READ → fold accepted or corrected → flow-writer consult-attestation <planId> --backend <id> --nonce <n> --proposed-fix-digest <the-sha256-of-the-fold-text> → then edit. A lens-raised finding re-dispatches the lens without a nonce, WAIT and READ, then edit as accepted or corrected — it mints no manifest and no attestation — only its per-round participation rides its internal-attestation.';
 // activity-aware (AD-046): the triage classification vocabulary rides EVERY review-backed activity;
 // the LEDGER pointer renders ONLY for plan-execution — the ledger is plan-execution-scoped (AD-045),

package/tools/script-priors.mjs

@@ -34,6 +34,8 @@ export const SCRIPT_PRIORS = Object.freeze([
   prior('spec-schema.mjs', '4.7.0', '4.7.0', '40b5b038d5ec5ed53c327c6d269d22fe5fa2bed99ae711fbf84306ad047be452'),
   prior('spec-schema.test.mjs', '4.7.0', '4.7.0', 'fde896419924223e54cfcabfdb1ef5807df5386fac700ed7c1463b6e7f81501b'),
   prior('check-docs-size.mjs', '4.6.0', '6.0.0', '22d020c3668cdbfb4cbc1f67a8a85b2baa2d0c4956808a50626d37409e81ab38'),
+  prior('spec-schema.mjs', '5.0.0', '7.2.1', '6a7d1e836c158baab5a412a1ad76d34891934dc28c88486c264a4b5d46f5892a'),
+  prior('spec-schema.test.mjs', '5.0.0', '7.2.1', '698564d7283281be1826019d214df475bb876687915de086818d8f5ece0e0336'),
 ]);
 
 export const digestOf = (bytes) => createHash('sha256').update(bytes).digest('hex');