@fission-ai/openspec 1.12.0 → 1.13.1

package/dist/core/parsers/change-parser.js

@@ -1,8 +1,14 @@
 import { MarkdownParser } from './markdown-parser.js';
 import { buildCodeFenceMask } from './requirement-text.js';
+import { parseDeltaSpec } from './requirement-blocks.js';
 import path from 'path';
 import { promises as fs } from 'fs';
 import { discoverSpecFiles } from '../../utils/spec-discovery.js';
+/** A header-only block for a REMOVED entry written in the bullet form. */
+function removedNameBlock(name) {
+    const headerLine = `### Requirement: ${name}`;
+    return { headerLine, name, raw: headerLine };
+}
 export class ChangeParser extends MarkdownParser {
     changeDir;
     constructor(content, changeDir) {
@@ -19,13 +25,16 @@ export class ChangeParser extends MarkdownParser {
         if (!whatChanges) {
             throw new Error('Change must have a What Changes section');
         }
-        // Parse deltas from the What Changes section (simple format)
-        const simpleDeltas = this.parseDeltas(whatChanges);
-        // Check if there are spec files with delta format
-        const specsDir = path.join(this.changeDir, 'specs');
-        const deltaDeltas = await this.parseDeltaSpecs(specsDir);
-        // Combine both types of deltas, preferring delta format if available
-        const deltas = deltaDeltas.length > 0 ? deltaDeltas : simpleDeltas;
+        // Delta spec files that carry a delta section are the only source of
+        // structured deltas, even when those sections hold no entry archive can
+        // apply. Falling back to the "What Changes" prose then reported operations
+        // that never happen: a bullet-form REMOVED showed up as an invented
+        // MODIFIED. The prose (simple format) is still read when no spec file
+        // carries a delta section at all: a change with no spec files, or a legacy
+        // change whose specs/ hold full future-state specs.
+        const specFiles = await discoverSpecFiles(path.join(this.changeDir, 'specs'));
+        const { deltas: specDeltas, hasDeltaSections } = await this.parseDeltaSpecs(specFiles);
+        const deltas = hasDeltaSections ? specDeltas : this.parseDeltas(whatChanges);
         return {
             name,
             why: why.trim(),
@@ -37,23 +46,25 @@ export class ChangeParser extends MarkdownParser {
             },
         };
     }
-    async parseDeltaSpecs(specsDir) {
+    // The spec files come from discoverSpecFiles, which walks specs/ recursively
+    // so nested layouts like specs/<area>/<capability>/spec.md are parsed too (#1353)
+    async parseDeltaSpecs(specFiles) {
         const deltas = [];
-        // Discover delta specs recursively so nested layouts like
-        // specs/<area>/<capability>/spec.md are parsed too (#1353)
-        const specFiles = await discoverSpecFiles(specsDir);
+        let hasDeltaSections = false;
         for (const { id, specFile } of specFiles) {
             try {
                 const content = await fs.readFile(specFile, 'utf-8');
-                const specDeltas = this.parseSpecDeltas(id, content);
-                deltas.push(...specDeltas);
+                const plan = parseDeltaSpec(content);
+                if (Object.values(plan.sectionPresence).some(Boolean))
+                    hasDeltaSections = true;
+                deltas.push(...this.parseSpecDeltas(id, plan));
             }
             catch (error) {
                 // Spec file might not be readable, which is okay
                 continue;
             }
         }
-        return deltas;
+        return { deltas, hasDeltaSections };
     }
     /**
      * Read requirements from a delta section, ignoring headers that are not
@@ -75,89 +86,76 @@ export class ChangeParser extends MarkdownParser {
             children: section.children.filter((child) => /^Requirement:\s*\S/i.test(child.title.trim())),
         });
     }
-    parseSpecDeltas(specName, content) {
+    /**
+     * The deltas in one spec file, read by parseDeltaSpec — the reader archive
+     * applies — so what `show` reports is what archive will do. This used to be a
+     * second reader that disagreed with it: a bullet-form REMOVED was invisible,
+     * a repeated section header was read only once, and a RENAMED line written
+     * with `*` or `+` was dropped.
+     */
+    parseSpecDeltas(specName, plan) {
         const deltas = [];
-        const sections = this.parseSectionsFromContent(content);
         // Parse ADDED requirements
-        const addedSection = this.findSection(sections, 'ADDED Requirements');
-        if (addedSection) {
-            const requirements = this.parseRequirements(addedSection);
-            requirements.forEach(req => {
-                deltas.push({
-                    spec: specName,
-                    operation: 'ADDED',
-                    description: `Add requirement: ${req.text}`,
-                    // Provide both single and plural forms for compatibility
-                    requirement: req,
-                    requirements: [req],
-                });
+        this.toRequirements(plan.added).forEach(req => {
+            deltas.push({
+                spec: specName,
+                operation: 'ADDED',
+                description: `Add requirement: ${req.text}`,
+                // Provide both single and plural forms for compatibility
+                requirement: req,
+                requirements: [req],
             });
-        }
+        });
         // Parse MODIFIED requirements
-        const modifiedSection = this.findSection(sections, 'MODIFIED Requirements');
-        if (modifiedSection) {
-            const requirements = this.parseRequirements(modifiedSection);
-            requirements.forEach(req => {
-                deltas.push({
-                    spec: specName,
-                    operation: 'MODIFIED',
-                    description: `Modify requirement: ${req.text}`,
-                    requirement: req,
-                    requirements: [req],
-                });
+        this.toRequirements(plan.modified).forEach(req => {
+            deltas.push({
+                spec: specName,
+                operation: 'MODIFIED',
+                description: `Modify requirement: ${req.text}`,
+                requirement: req,
+                requirements: [req],
             });
-        }
-        // Parse REMOVED requirements
-        const removedSection = this.findSection(sections, 'REMOVED Requirements');
-        if (removedSection) {
-            const requirements = this.parseRequirements(removedSection);
-            requirements.forEach(req => {
-                deltas.push({
-                    spec: specName,
-                    operation: 'REMOVED',
-                    description: `Remove requirement: ${req.text}`,
-                    requirement: req,
-                    requirements: [req],
-                });
+        });
+        // Parse REMOVED requirements, in document order. A bullet-form entry
+        // carries only a name, so it reads as a header-form removal with no body.
+        const removedBlocks = [...plan.removedBlocks];
+        const removed = plan.removed.map((name) => {
+            const index = removedBlocks.findIndex((block) => block.name === name);
+            return index === -1 ? removedNameBlock(name) : removedBlocks.splice(index, 1)[0];
+        });
+        this.toRequirements(removed).forEach(req => {
+            deltas.push({
+                spec: specName,
+                operation: 'REMOVED',
+                description: `Remove requirement: ${req.text}`,
+                requirement: req,
+                requirements: [req],
             });
-        }
+        });
         // Parse RENAMED requirements
-        const renamedSection = this.findSection(sections, 'RENAMED Requirements');
-        if (renamedSection) {
-            const renames = this.parseRenames(renamedSection.content);
-            renames.forEach(rename => {
-                deltas.push({
-                    spec: specName,
-                    operation: 'RENAMED',
-                    description: `Rename requirement from "${rename.from}" to "${rename.to}"`,
-                    rename,
-                });
+        plan.renamed.forEach(rename => {
+            deltas.push({
+                spec: specName,
+                operation: 'RENAMED',
+                description: `Rename requirement from "${rename.from}" to "${rename.to}"`,
+                rename,
             });
-        }
+        });
         return deltas;
     }
-    parseRenames(content) {
-        const renames = [];
-        const lines = ChangeParser.normalizeContent(content).split('\n');
-        let currentRename = {};
-        for (const line of lines) {
-            const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
-            const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
-            if (fromMatch) {
-                currentRename.from = fromMatch[1].trim();
-            }
-            else if (toMatch) {
-                currentRename.to = toMatch[1].trim();
-                if (currentRename.from && currentRename.to) {
-                    renames.push({
-                        from: currentRename.from,
-                        to: currentRename.to,
-                    });
-                    currentRename = {};
-                }
-            }
-        }
-        return renames;
+    /**
+     * One Requirement per block, read by the same section parser (and the
+     * header filter above) as before, so text and scenarios are unchanged.
+     */
+    toRequirements(blocks) {
+        return blocks.flatMap((block) => {
+            const [headerLine, ...body] = block.raw.split('\n');
+            // Canonical header: the delta reader also accepts `###Requirement:` with
+            // no space, which the section parser would not see as a header.
+            const title = headerLine.replace(/^###\s*/, '').trim();
+            const [section] = this.parseSectionsFromContent([`### ${title}`, ...body].join('\n'));
+            return this.parseRequirements({ level: 2, title: '', content: '', children: [section] });
+        });
     }
     parseSectionsFromContent(content) {
         const normalizedContent = ChangeParser.normalizeContent(content);

package/dist/core/parsers/markdown-parser.js

@@ -1,4 +1,4 @@
-import { buildCodeFenceMask, extractRequirementText } from './requirement-text.js';
+import { buildCodeFenceMask, extractRequirementText, hasScenarioBody } from './requirement-text.js';
 export class MarkdownParser {
     lines;
     codeFenceLineMask;
@@ -130,8 +130,9 @@ export class MarkdownParser {
     parseScenarios(requirementSection) {
         const scenarios = [];
         for (const scenarioSection of requirementSection.children) {
-            // Store the raw text content of the scenario section
-            if (scenarioSection.content.trim()) {
+            // Store the raw text content of the scenario section. A header with no
+            // body is not a scenario; the delta counter applies the same rule.
+            if (hasScenarioBody(scenarioSection.content)) {
                 scenarios.push({
                     rawText: scenarioSection.content
                 });

package/dist/core/parsers/requirement-blocks.d.ts

@@ -14,9 +14,10 @@ export declare function normalizeRequirementName(name: string): string;
 /**
  * Case- and whitespace-insensitive fold of a requirement name. Requirement
  * matching itself is case-sensitive (normalizeRequirementName); this fold
- * exists only for typo detection - near-miss REMOVED headers and the
- * RENAMED+REMOVED cross-section conflict - where two spellings that differ
- * only in case or interior whitespace mean a mistake, never two requirements.
+ * exists only for typo detection - near-miss REMOVED, ADDED and RENAMED
+ * headers and the RENAMED+REMOVED cross-section conflict - where two spellings
+ * that differ only in case or interior whitespace mean a mistake, never two
+ * requirements.
  */
 export declare function foldRequirementName(name: string): string;
 /**
@@ -33,6 +34,42 @@ export interface SkippedHeader {
     section: string;
     line: number;
 }
+/**
+ * A `FROM:` or `TO:` line in `## RENAMED Requirements` that never formed a pair,
+ * recorded at the moment the reader steps over it.
+ *
+ * The pair reader used to carry one mutable `{ from, to }` and drop whatever did
+ * not fit: a second `FROM:` overwrote an unpaired first, a `TO:` with no pending
+ * `FROM:` vanished, and a trailing `FROM:` was forgotten at the end of the
+ * section. Nothing counted any of it, so a rename the author asked for could
+ * silently not happen - or, when the lines interleaved, a DIFFERENT requirement
+ * could be renamed under a name meant for another one.
+ *
+ * Recording them is what lets `validate` report the problem and `buildUpdatedSpec`
+ * refuse, rather than guess a pairing and rewrite the spec from it.
+ */
+export interface UnpairedRename {
+    side: 'FROM' | 'TO';
+    name: string;
+    line: number;
+}
+/**
+ * A canonical `### Requirement:` block that sits outside every delta section -
+ * under `## Notes`, under a misspelled `## Add Requirements`, or above the
+ * first `## ` header entirely.
+ *
+ * The delta reader only ever looks inside the four delta sections, so a block
+ * written anywhere else was dropped with no error, no warning and no note -
+ * even though it is well formed and reads exactly like one that would apply.
+ * That was the inconsistency worth closing: the ADJACENT mistake, a
+ * non-canonical `###` header INSIDE a delta section, has been reported as INFO
+ * since #498 (`skippedHeaders`), while the costlier one said nothing at all.
+ */
+export interface OrphanedRequirement {
+    name: string;
+    section: string | null;
+    line: number;
+}
 export interface DeltaPlan {
     added: RequirementBlock[];
     modified: RequirementBlock[];
@@ -42,6 +79,10 @@ export interface DeltaPlan {
         from: string;
         to: string;
     }>;
+    /** FROM:/TO: lines in RENAMED that never formed a pair. */
+    unpairedRenames: UnpairedRename[];
+    /** Canonical requirement blocks written outside every delta section. */
+    orphanedRequirements: OrphanedRequirement[];
     skippedHeaders: SkippedHeader[];
     sectionPresence: {
         added: boolean;

package/dist/core/parsers/requirement-blocks.js

@@ -1,13 +1,18 @@
 import { buildCodeFenceMask, SCENARIO_HEADER } from './requirement-text.js';
 export function normalizeRequirementName(name) {
-    return name.trim();
+    // An ATX heading may end in a closing run of `#`s: `### Requirement: Foo ###`
+    // renders as `Foo`, so the run is not part of the name. As for scenario names,
+    // only a run preceded by a space or tab closes the heading, so `C#` keeps its
+    // `#`, and `[ \t]` rather than `\s` keeps an NBSP-separated run in the name.
+    return name.replace(/[ \t]+#+[ \t]*$/, '').trim();
 }
 /**
  * Case- and whitespace-insensitive fold of a requirement name. Requirement
  * matching itself is case-sensitive (normalizeRequirementName); this fold
- * exists only for typo detection - near-miss REMOVED headers and the
- * RENAMED+REMOVED cross-section conflict - where two spellings that differ
- * only in case or interior whitespace mean a mistake, never two requirements.
+ * exists only for typo detection - near-miss REMOVED, ADDED and RENAMED
+ * headers and the RENAMED+REMOVED cross-section conflict - where two spellings
+ * that differ only in case or interior whitespace mean a mistake, never two
+ * requirements.
  */
 export function foldRequirementName(name) {
     return normalizeRequirementName(name).toLowerCase().replace(/\s+/g, ' ');
@@ -99,24 +104,29 @@ export function parseDeltaSpec(content) {
     const lines = normalized.split('\n');
     const fenceMask = buildCodeFenceMask(lines);
     const sections = splitTopLevelSections(lines, fenceMask);
-    const addedLookup = getSectionCaseInsensitive(sections, 'ADDED Requirements');
-    const modifiedLookup = getSectionCaseInsensitive(sections, 'MODIFIED Requirements');
-    const removedLookup = getSectionCaseInsensitive(sections, 'REMOVED Requirements');
-    const renamedLookup = getSectionCaseInsensitive(sections, 'RENAMED Requirements');
+    const addedLookup = getSectionsCaseInsensitive(sections, 'ADDED Requirements');
+    const modifiedLookup = getSectionsCaseInsensitive(sections, 'MODIFIED Requirements');
+    const removedLookup = getSectionsCaseInsensitive(sections, 'REMOVED Requirements');
+    const renamedLookup = getSectionsCaseInsensitive(sections, 'RENAMED Requirements');
     const skippedHeaders = [];
-    const added = parseRequirementBlocksFromSection(addedLookup.body, {
+    const added = addedLookup.bodies.flatMap((body) => parseRequirementBlocksFromSection(body, {
         section: addedLookup.title,
-        bodyStartLine: addedLookup.bodyStartLine,
+        bodyStartLine: body.bodyStartLine,
         sink: skippedHeaders,
-    });
-    const modified = parseRequirementBlocksFromSection(modifiedLookup.body, {
+    }));
+    const modified = modifiedLookup.bodies.flatMap((body) => parseRequirementBlocksFromSection(body, {
         section: modifiedLookup.title,
-        bodyStartLine: modifiedLookup.bodyStartLine,
+        bodyStartLine: body.bodyStartLine,
         sink: skippedHeaders,
-    });
-    const removedNames = parseRemovedNames(removedLookup.body);
-    const removedBlocks = parseRequirementBlocksFromSection(removedLookup.body);
-    const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    }));
+    const removedNames = removedLookup.bodies.flatMap((body) => parseRemovedNames(body));
+    const removedBlocks = removedLookup.bodies.flatMap((body) => parseRequirementBlocksFromSection(body));
+    // Pairs are read per section, so a FROM in one copy of the header can never
+    // pair with a TO in another: a FROM left pending at the end of one copy is
+    // reported as unpaired rather than carried into the next.
+    const unpairedRenames = [];
+    const renamedPairs = renamedLookup.bodies.flatMap((body) => parseRenamedPairs(body, unpairedRenames));
+    unpairedRenames.sort((a, b) => a.line - b.line);
     skippedHeaders.sort((a, b) => a.line - b.line);
     return {
         added,
@@ -124,6 +134,8 @@ export function parseDeltaSpec(content) {
         removed: removedNames,
         removedBlocks,
         renamed: renamedPairs,
+        unpairedRenames,
+        orphanedRequirements: findOrphanedRequirements(lines, fenceMask),
         skippedHeaders,
         sectionPresence: {
             added: addedLookup.found,
@@ -133,8 +145,58 @@ export function parseDeltaSpec(content) {
         },
     };
 }
+/**
+ * The four section titles the delta reader acts on, folded the way
+ * `getSectionsCaseInsensitive` folds them. Matching the reader exactly matters:
+ * a looser test (say, any run of whitespace) would treat `## ADDED  Requirements`
+ * as a delta section here while the reader ignores it, and the requirements
+ * under it would be dropped without this warning.
+ */
+const DELTA_SECTION_TITLES = new Set(['ADDED Requirements', 'MODIFIED Requirements', 'REMOVED Requirements', 'RENAMED Requirements'].map((title) => title.toLowerCase()));
+/**
+ * Every canonical `### Requirement:` header that is not inside a delta section,
+ * in document order.
+ *
+ * Walks the whole file rather than the parsed sections so a requirement written
+ * ABOVE the first `## ` header is reported too - it is dropped just as silently
+ * as one under `## Notes`. Fenced lines are skipped, so a requirement shown
+ * inside a markdown example is not mistaken for an authored one.
+ */
+function findOrphanedRequirements(lines, fenceMask) {
+    const orphans = [];
+    let section = null;
+    for (let i = 0; i < lines.length; i++) {
+        if (fenceMask[i])
+            continue;
+        // The same `## ` test splitTopLevelSections uses, so both agree on sections.
+        const sectionMatch = lines[i].match(/^(##)\s+(.+)$/);
+        if (sectionMatch) {
+            section = sectionMatch[2].trim();
+            continue;
+        }
+        if (section !== null && DELTA_SECTION_TITLES.has(section.toLowerCase()))
+            continue;
+        const header = lines[i].match(REQUIREMENT_HEADER_REGEX);
+        if (header) {
+            orphans.push({
+                name: normalizeRequirementName(header[1]),
+                section,
+                line: i + 1,
+            });
+        }
+    }
+    return orphans;
+}
+/**
+ * Every `## ` section, as a LIST rather than a title-keyed record.
+ *
+ * Keying by title silently dropped a repeated header: a delta that wrote
+ * `## ADDED Requirements` twice kept only the last body, so every requirement
+ * under the first copy was discarded before any validation or merge rule could
+ * see it. A list keeps each occurrence, and the lookup below merges them.
+ */
 function splitTopLevelSections(lines, fenceMask) {
-    const result = {};
+    const sections = [];
     const indices = [];
     for (let i = 0; i < lines.length; i++) {
         if (fenceMask[i])
@@ -148,23 +210,39 @@ function splitTopLevelSections(lines, fenceMask) {
         const current = indices[i];
         const next = indices[i + 1];
         const end = next ? next.index : lines.length;
-        result[current.title] = {
-            lines: lines.slice(current.index + 1, end),
-            fenceMask: fenceMask.slice(current.index + 1, end),
-            bodyStartLine: current.index + 2,
-        };
+        sections.push({
+            title: current.title,
+            body: {
+                lines: lines.slice(current.index + 1, end),
+                fenceMask: fenceMask.slice(current.index + 1, end),
+                bodyStartLine: current.index + 2,
+            },
+        });
     }
-    return result;
+    return sections;
 }
-const EMPTY_SECTION_BODY = { lines: [], fenceMask: [], bodyStartLine: 0 };
-function getSectionCaseInsensitive(sections, desired) {
+/**
+ * Every section body whose title folds to `desired`, in document order.
+ *
+ * Returning all of them - rather than the first match - is what makes a
+ * repeated header (`## ADDED Requirements` twice) and a case variant
+ * (`## ADDED Requirements` + `## Added Requirements`) both apply in full. Each
+ * body keeps its own `bodyStartLine`, so reported line numbers stay correct for
+ * the copy the header actually came from.
+ *
+ * `title` is the first spelling the author used, which is what diagnostics quote.
+ */
+function getSectionsCaseInsensitive(sections, desired) {
     const target = desired.toLowerCase();
-    for (const [title, body] of Object.entries(sections)) {
-        if (title.toLowerCase() === target) {
-            return { title, body, bodyStartLine: body.bodyStartLine, found: true };
-        }
+    const matches = sections.filter((section) => section.title.toLowerCase() === target);
+    if (matches.length === 0) {
+        return { title: desired, bodies: [], found: false };
     }
-    return { title: desired, body: EMPTY_SECTION_BODY, bodyStartLine: 0, found: false };
+    return {
+        title: matches[0].title,
+        bodies: matches.map((section) => section.body),
+        found: true,
+    };
 }
 function parseRequirementBlocksFromSection(sectionBody, skipped) {
     const { lines, fenceMask } = sectionBody;
@@ -212,6 +290,13 @@ function parseRequirementBlocksFromSection(sectionBody, skipped) {
     }
     return blocks;
 }
+/**
+ * Requirement names listed in `## REMOVED Requirements`, in document order.
+ *
+ * Two spellings are accepted: a plain `### Requirement:` header, and a bullet
+ * carrying one. Every CommonMark bullet marker counts for the second form -
+ * see the pattern below for why that matters.
+ */
 function parseRemovedNames(sectionBody) {
     const { lines, fenceMask } = sectionBody;
     if (lines.length === 0)
@@ -226,37 +311,73 @@ function parseRemovedNames(sectionBody) {
             names.push(normalizeRequirementName(m[1]));
             continue;
         }
-        // Also support bullet list of headers
-        const bullet = line.match(/^\s*-\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        // Also support bullet list of headers. Every CommonMark bullet marker
+        // counts: `*` and `+` open a list exactly as `-` does, so accepting only
+        // `-` turned a removal written with either of them into a silent no-op -
+        // archive reported success while the requirement stayed in the spec.
+        const bullet = line.match(/^\s*[-*+]\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
         if (bullet) {
             names.push(normalizeRequirementName(bullet[1]));
         }
     }
     return names;
 }
-function parseRenamedPairs(sectionBody) {
-    const { lines, fenceMask } = sectionBody;
+/**
+ * Read `FROM:`/`TO:` entries into rename pairs, recording every line that never
+ * formed one.
+ *
+ * A pair is a `FROM:` followed by a `TO:` with no second `FROM:` in between -
+ * the shape the documented format uses. Anything else is reported through
+ * `unpaired` rather than absorbed:
+ *
+ *   - a `FROM:` displaced by another `FROM:` before its `TO:` arrived
+ *   - a `TO:` with no pending `FROM:`
+ *   - a `FROM:` still pending when the section ends
+ *
+ * Silently dropping these is what let a requested rename not happen, and what
+ * let interleaved lines (`FROM a`, `FROM b`, `TO x`, `TO y`) pair b with x -
+ * renaming a requirement the author never named, under a name meant for a
+ * different one. Callers refuse the delta instead of guessing.
+ *
+ * The bullet is optional, and every CommonMark bullet marker is accepted: a
+ * rename written with `*` or `+` used to match nothing at all, so the rename
+ * silently never happened while archive still reported success.
+ */
+function parseRenamedPairs(sectionBody, unpaired) {
+    const { lines, fenceMask, bodyStartLine } = sectionBody;
     if (lines.length === 0)
         return [];
     const pairs = [];
-    let current = {};
+    let pending;
+    const drop = (side, name, line) => {
+        unpaired?.push({ side, name, line });
+    };
     for (let i = 0; i < lines.length; i++) {
         if (fenceMask[i])
             continue;
         const line = lines[i];
-        const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
-        const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        // The bullet stays optional, and any CommonMark marker is accepted: a rename
+        // written with `*` or `+` used to match nothing at all, so the rename never
+        // happened while archive still reported success.
+        const fromMatch = line.match(/^\s*[-*+]?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        const toMatch = line.match(/^\s*[-*+]?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
         if (fromMatch) {
-            current.from = normalizeRequirementName(fromMatch[1]);
+            if (pending)
+                drop('FROM', pending.name, pending.line);
+            pending = { name: normalizeRequirementName(fromMatch[1]), line: bodyStartLine + i };
         }
         else if (toMatch) {
-            current.to = normalizeRequirementName(toMatch[1]);
-            if (current.from && current.to) {
-                pairs.push({ from: current.from, to: current.to });
-                current = {};
+            const to = normalizeRequirementName(toMatch[1]);
+            if (!pending) {
+                drop('TO', to, bodyStartLine + i);
+                continue;
             }
+            pairs.push({ from: pending.name, to });
+            pending = undefined;
         }
     }
+    if (pending)
+        drop('FROM', pending.name, pending.line);
     return pairs;
 }
 /**

package/dist/core/parsers/requirement-text.d.ts

@@ -15,8 +15,17 @@ export { buildCodeFenceMask } from './code-fence.js';
  * as a scenario, so the delta counter must too (parity). The delta/loss path
  * reuses this exact constant via `scenarioHeaderAt` in requirement-blocks.ts;
  * keep both paths on it rather than reintroducing a separate `Scenario:` regex.
+ * A header alone is not yet a scenario on either path: see hasScenarioBody.
  */
 export declare const SCENARIO_HEADER: RegExp;
+/**
+ * Whether a scenario's body has content. The spec path
+ * (`MarkdownParser.parseScenarios`) drops a scenario whose body is empty, so
+ * the delta counter must too (parity): otherwise `validate` accepts a
+ * requirement whose only scenario is a bare header, and archive rejects it when
+ * it validates the rebuilt spec.
+ */
+export declare function hasScenarioBody(body: string): boolean;
 /**
  * The one predicate for normative-keyword detection. Matches `SHALL` or `MUST`
  * as whole words so the change-delta reader and the schema-based reader accept
@@ -49,8 +58,10 @@ export declare function extractRequirementBody(bodyLines: string[]): string;
 export declare function extractRequirementText(headerTitle: string, bodyLines: string[]): string;
 /**
  * Count the real scenarios in a requirement block: `#### ` headers on non-fenced
- * lines. A `#### Scenario:` that lives inside a fenced example is not a real
- * scenario and is not counted.
+ * lines whose body has content. A `#### Scenario:` that lives inside a fenced
+ * example is not a real scenario and is not counted.
  */
 export declare function countScenarios(bodyLines: string[]): number;
+/** Count the `#### ` headers in a requirement block that have no body under them. */
+export declare function countEmptyScenarios(bodyLines: string[]): number;
 //# sourceMappingURL=requirement-text.d.ts.map