freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/requirement-blocks.d.ts

@@ -0,0 +1,65 @@
+export interface RequirementBlock {
+    headerLine: string;
+    name: string;
+    raw: string;
+}
+export interface RequirementsSectionParts {
+    before: string;
+    headerLine: string;
+    preamble: string;
+    bodyBlocks: RequirementBlock[];
+    after: string;
+}
+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.
+ */
+export declare function foldRequirementName(name: string): string;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export declare function extractRequirementsSection(content: string): RequirementsSectionParts;
+/**
+ * A level-3 header inside `## ADDED`/`## MODIFIED Requirements` that is not a
+ * canonical `### Requirement:` header, recorded at the moment the delta reader
+ * skips over it. Surfaced as an INFO note by `validate <change>` (#498).
+ */
+export interface SkippedHeader {
+    header: string;
+    section: string;
+    line: number;
+}
+export interface DeltaPlan {
+    added: RequirementBlock[];
+    modified: RequirementBlock[];
+    removed: string[];
+    renamed: Array<{
+        from: string;
+        to: string;
+    }>;
+    skippedHeaders: SkippedHeader[];
+    sectionPresence: {
+        added: boolean;
+        modified: boolean;
+        removed: boolean;
+        renamed: boolean;
+    };
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export declare function parseDeltaSpec(content: string): DeltaPlan;
+/**
+ * Scenario names the current requirement block has and the incoming
+ * (MODIFIED) block does not. A MODIFIED requirement replaces the whole block,
+ * so every name reported here would be dropped from the main spec.
+ *
+ * Shared by archive (which refuses to apply the block) and validate (which
+ * reports the same loss at authoring time, #1477), so the two cannot disagree
+ * about what counts as a dropped scenario.
+ */
+export declare function findMissingCurrentScenarios(current: RequirementBlock, incoming: RequirementBlock): string[];

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/requirement-blocks.js

@@ -0,0 +1,409 @@
+import { buildCodeFenceMask, SCENARIO_HEADER } from './requirement-text.js';
+export function normalizeRequirementName(name) {
+    return name.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.
+ */
+export function foldRequirementName(name) {
+    return normalizeRequirementName(name).toLowerCase().replace(/\s+/g, ' ');
+}
+/** The canonical requirement header the delta reader recognizes. */
+const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/i;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export function extractRequirementsSection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const fenceMask = buildCodeFenceMask(lines);
+    const reqHeaderIndex = lines.findIndex((l, i) => !fenceMask[i] && /^##\s+Requirements\s*$/i.test(l));
+    if (reqHeaderIndex === -1) {
+        // No requirements section; create an empty one at the end
+        const before = content.trimEnd();
+        const headerLine = '## Requirements';
+        return {
+            before: before ? before + '\n\n' : '',
+            headerLine,
+            preamble: '',
+            bodyBlocks: [],
+            after: '\n',
+        };
+    }
+    // Find end of this section: next line that starts with '## ' at same or higher level
+    let endIndex = lines.length;
+    for (let i = reqHeaderIndex + 1; i < lines.length; i++) {
+        if (!fenceMask[i] && /^##\s+/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, reqHeaderIndex).join('\n');
+    const headerLine = lines[reqHeaderIndex];
+    const sectionBodyLines = lines.slice(reqHeaderIndex + 1, endIndex);
+    const sectionBodyMask = fenceMask.slice(reqHeaderIndex + 1, endIndex);
+    const isRequirementHeader = (cursor) => !sectionBodyMask[cursor] && REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor]);
+    const isTopLevelHeader = (cursor) => !sectionBodyMask[cursor] && /^##\s+/.test(sectionBodyLines[cursor]);
+    // Parse requirement blocks within section body
+    const blocks = [];
+    let cursor = 0;
+    let preambleLines = [];
+    // Collect preamble lines until first requirement header
+    while (cursor < sectionBodyLines.length && !isRequirementHeader(cursor)) {
+        preambleLines.push(sectionBodyLines[cursor]);
+        cursor++;
+    }
+    while (cursor < sectionBodyLines.length) {
+        const headerLineCandidate = sectionBodyLines[cursor];
+        if (!isRequirementHeader(cursor)) {
+            // Not a requirement header; skip line defensively
+            cursor++;
+            continue;
+        }
+        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
+        const name = normalizeRequirementName(headerMatch[1]);
+        cursor++;
+        // Gather lines until next requirement header or end of section
+        const bodyLines = [headerLineCandidate];
+        while (cursor < sectionBodyLines.length && !isRequirementHeader(cursor) && !isTopLevelHeader(cursor)) {
+            bodyLines.push(sectionBodyLines[cursor]);
+            cursor++;
+        }
+        const raw = bodyLines.join('\n').trimEnd();
+        blocks.push({ headerLine: headerLineCandidate, name, raw });
+    }
+    const after = lines.slice(endIndex).join('\n');
+    const preamble = preambleLines.join('\n').trimEnd();
+    return {
+        before: before.trimEnd() ? before + '\n' : before,
+        headerLine,
+        preamble,
+        bodyBlocks: blocks,
+        after: after.startsWith('\n') ? after : '\n' + after,
+    };
+}
+function normalizeLineEndings(content) {
+    // Strip a UTF-8 BOM: Windows editors and PowerShell redirects prepend one,
+    // and it would keep the first line's `## ADDED Requirements` from matching.
+    return content.replace(/^/, '').replace(/\r\n?/g, '\n');
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export function parseDeltaSpec(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const fenceMask = buildCodeFenceMask(lines);
+    const sections = splitTopLevelSections(lines, fenceMask);
+    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 = addedLookup.bodies.flatMap((body) => parseRequirementBlocksFromSection(body, {
+        section: addedLookup.title,
+        bodyStartLine: body.bodyStartLine,
+        sink: skippedHeaders,
+    }));
+    const modified = modifiedLookup.bodies.flatMap((body) => parseRequirementBlocksFromSection(body, {
+        section: modifiedLookup.title,
+        bodyStartLine: body.bodyStartLine,
+        sink: skippedHeaders,
+    }));
+    const removedNames = removedLookup.bodies.flatMap((body) => parseRemovedNames(body));
+    // Pairs are read per section, so a FROM in one copy of the header can never
+    // pair with a TO written under a different copy.
+    const renamedPairs = renamedLookup.bodies.flatMap((body) => parseRenamedPairs(body, { section: renamedLookup.title, sink: skippedHeaders }));
+    skippedHeaders.sort((a, b) => a.line - b.line);
+    return {
+        added,
+        modified,
+        removed: removedNames,
+        renamed: renamedPairs,
+        skippedHeaders,
+        sectionPresence: {
+            added: addedLookup.found,
+            modified: modifiedLookup.found,
+            removed: removedLookup.found,
+            renamed: renamedLookup.found,
+        },
+    };
+}
+/**
+ * Every `## ` section of a delta file, as a list rather than a title-keyed
+ * record.
+ *
+ * A title-keyed record keeps only the last body under a repeated title, so a
+ * delta that writes `## ADDED Requirements` twice would silently drop every
+ * requirement under the first copy before any validation or merge rule sees
+ * it. A list keeps each occurrence in document order; `getSectionsCaseInsensitive`
+ * below merges the ones that share a title.
+ */
+function splitTopLevelSections(lines, fenceMask) {
+    const sections = [];
+    const indices = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (fenceMask[i])
+            continue;
+        const m = lines[i].match(/^(##)\s+(.+)$/);
+        if (m) {
+            indices.push({ title: m[2].trim(), index: i });
+        }
+    }
+    for (let i = 0; i < indices.length; i++) {
+        const current = indices[i];
+        const next = indices[i + 1];
+        const end = next ? next.index : lines.length;
+        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 sections;
+}
+/**
+ * Every section body whose title folds to `desired`, in document order.
+ *
+ * Returning all matches - not just the first - is what lets a repeated header
+ * (`## ADDED Requirements` twice) or a case variant (`## ADDED Requirements`
+ * next to `## Added Requirements`) apply in full: each body keeps its own
+ * `bodyStartLine`, so a diagnostic points at the copy the header actually came
+ * from. `title` is the first spelling the author used, which diagnostics quote.
+ */
+function getSectionsCaseInsensitive(sections, desired) {
+    const target = desired.toLowerCase();
+    const matches = sections.filter((section) => section.title.toLowerCase() === target);
+    if (matches.length === 0) {
+        return { title: desired, bodies: [], found: false };
+    }
+    return {
+        title: matches[0].title,
+        bodies: matches.map((section) => section.body),
+        found: true,
+    };
+}
+function parseRequirementBlocksFromSection(sectionBody, skipped) {
+    const { lines, fenceMask } = sectionBody;
+    if (lines.length === 0)
+        return [];
+    const isRequirementHeader = (i) => !fenceMask[i] && REQUIREMENT_HEADER_REGEX.test(lines[i]);
+    const isTopLevelHeader = (i) => !fenceMask[i] && /^##\s+/.test(lines[i]);
+    const recordIfSkippedHeader = (index) => {
+        if (!skipped || fenceMask[index])
+            return;
+        const h3 = lines[index].match(/^###\s+(.+?)\s*$/);
+        if (h3 && !REQUIREMENT_HEADER_REGEX.test(lines[index])) {
+            skipped.sink.push({
+                header: h3[1].trim(),
+                section: skipped.section,
+                line: skipped.bodyStartLine + index,
+            });
+        }
+    };
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        // Seek next requirement header
+        while (i < lines.length && !isRequirementHeader(i)) {
+            recordIfSkippedHeader(i);
+            i++;
+        }
+        if (i >= lines.length)
+            break;
+        const headerLine = lines[i];
+        const m = headerLine.match(REQUIREMENT_HEADER_REGEX);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const name = normalizeRequirementName(m[1]);
+        const buf = [headerLine];
+        i++;
+        while (i < lines.length && !isRequirementHeader(i) && !isTopLevelHeader(i)) {
+            recordIfSkippedHeader(i);
+            buf.push(lines[i]);
+            i++;
+        }
+        blocks.push({ headerLine, name, raw: buf.join('\n').trimEnd() });
+    }
+    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
+ * bullet form: accepting only `-` turns a removal written with `*` or `+`
+ * into a silent no-op - archive reports success while the requirement stays
+ * in the spec.
+ */
+function parseRemovedNames(sectionBody) {
+    const { lines, fenceMask } = sectionBody;
+    if (lines.length === 0)
+        return [];
+    const names = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (fenceMask[i])
+            continue;
+        const line = lines[i];
+        const m = line.match(REQUIREMENT_HEADER_REGEX);
+        if (m) {
+            names.push(normalizeRequirementName(m[1]));
+            continue;
+        }
+        // Also support bullet list of headers
+        const bullet = line.match(/^\s*[-*+]\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (bullet) {
+            names.push(normalizeRequirementName(bullet[1]));
+        }
+    }
+    return names;
+}
+/**
+ * `FROM:`/`TO:` rename pairs from `## RENAMED Requirements`, in document
+ * order.
+ *
+ * The leading bullet is optional, and every CommonMark bullet marker (`-`,
+ * `*`, `+`) is accepted: accepting only `-` turns a rename written with `*`
+ * or `+` into a silent no-op - archive reports success while the rename never
+ * happens.
+ */
+function parseRenamedPairs(sectionBody, skipped) {
+    const { lines, fenceMask, bodyStartLine } = sectionBody;
+    if (lines.length === 0)
+        return [];
+    const pairs = [];
+    let current = {};
+    const flushUnpairedFrom = () => {
+        if (current.from === undefined || !skipped)
+            return;
+        skipped.sink.push({
+            header: `${current.from} (FROM without a matching TO)`,
+            section: skipped.section,
+            line: bodyStartLine + current.fromLine,
+        });
+    };
+    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*$/);
+        if (fromMatch) {
+            // A prior FROM that never got its TO is about to be overwritten and
+            // discarded - the only chance to name it before it is gone.
+            flushUnpairedFrom();
+            current.from = normalizeRequirementName(fromMatch[1]);
+            current.fromLine = i;
+        }
+        else if (toMatch) {
+            current.to = normalizeRequirementName(toMatch[1]);
+            if (current.from && current.to) {
+                pairs.push({ from: current.from, to: current.to });
+                current = {};
+            }
+        }
+    }
+    flushUnpairedFrom();
+    return pairs;
+}
+/**
+ * Scenario names the current requirement block has and the incoming
+ * (MODIFIED) block does not. A MODIFIED requirement replaces the whole block,
+ * so every name reported here would be dropped from the main spec.
+ *
+ * Shared by archive (which refuses to apply the block) and validate (which
+ * reports the same loss at authoring time, #1477), so the two cannot disagree
+ * about what counts as a dropped scenario.
+ */
+export function findMissingCurrentScenarios(current, incoming) {
+    // Multiplicity-aware: a name present N times in current and M times in
+    // incoming means max(0, N - M) instances are missing. Set membership would
+    // treat N>M as fully covered and let archive silently drop duplicates
+    // (residual #1246 / duplicate-scenario-name blind spot).
+    const remainingIncoming = new Map();
+    for (const scenario of parseScenarioBlocks(incoming.raw)) {
+        const name = scenario.name;
+        remainingIncoming.set(name, (remainingIncoming.get(name) ?? 0) + 1);
+    }
+    const missing = [];
+    for (const scenario of parseScenarioBlocks(current.raw)) {
+        const name = scenario.name;
+        const remaining = remainingIncoming.get(name) ?? 0;
+        if (remaining > 0) {
+            remainingIncoming.set(name, remaining - 1);
+        }
+        else {
+            missing.push(name);
+        }
+    }
+    return missing;
+}
+/**
+ * Any non-fenced level-4 header on the given (masked) line. Reuses the spec
+ * path's SCENARIO_HEADER so the two counters cannot drift apart.
+ */
+function scenarioHeaderAt(lines, mask, index) {
+    return !mask[index] && SCENARIO_HEADER.test(lines[index]);
+}
+/**
+ * The scenario name for a `#### ` header, matching the label the author reads:
+ * the header text with the leading `####`, an optional CommonMark closing `#`
+ * run (`#### Foo ####` renders as `Foo`), and an optional `Scenario:` prefix
+ * stripped. Both the current and incoming blocks run through here, so the
+ * comparison in findMissingCurrentScenarios stays internally consistent
+ * regardless of label — and two headers that render to the same title (one
+ * ATX-closed, one not) are not mistaken for a dropped scenario.
+ */
+function scenarioNameAt(line) {
+    return line
+        .replace(SCENARIO_HEADER, '')
+        // Optional ATX closing sequence. CommonMark only treats a trailing `#` run
+        // as a close when it is preceded by a space or tab — not any Unicode space —
+        // so this uses `[ \t]`, not `\s`. A looser `\s` could strip a `#` run after
+        // an exotic space (e.g. NBSP) that CommonMark keeps, folding two distinct
+        // scenario names into one and masking a real loss. `[ \t]` keeps the fold
+        // faithful to how the header actually renders.
+        .replace(/[ \t]+#+[ \t]*$/, '')
+        .replace(/^Scenario:\s*/i, '')
+        .trim();
+}
+function parseScenarioBlocks(requirementRaw) {
+    const lines = requirementRaw.replace(/\r\n?/g, '\n').split('\n');
+    // A scenario is ANY non-fenced `#### ` header, matching the spec path's
+    // SCENARIO_HEADER / countScenarios (requirement-text.ts) exactly — not only
+    // `#### Scenario:`. The two MUST agree: a level-4 child whose header is not
+    // literally `Scenario:` (e.g. `#### Edge case`) is still a scenario the spec
+    // path counts, so a MODIFIED block that drops it would otherwise slip past
+    // this loss check and be deleted by archive with no error (the parity the
+    // SCENARIO_HEADER comment warns not to break). A `####` inside a fenced
+    // example is masked out, matching countScenarios.
+    const mask = buildCodeFenceMask(lines);
+    const scenarios = [];
+    let index = 0;
+    while (index < lines.length) {
+        if (!scenarioHeaderAt(lines, mask, index)) {
+            index++;
+            continue;
+        }
+        const start = index;
+        const name = scenarioNameAt(lines[index]);
+        index++;
+        while (index < lines.length && !scenarioHeaderAt(lines, mask, index)) {
+            index++;
+        }
+        scenarios.push({
+            name,
+            raw: lines.slice(start, index).join('\n').trimEnd(),
+        });
+    }
+    return scenarios;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/requirement-text.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared, fence-aware requirement-reading helpers.
+ *
+ * The requirement reader used to be implemented twice — once for main specs
+ * (`MarkdownParser.parseRequirements`) and once for change deltas
+ * (`Validator.extractRequirementText` / `countScenarios`) — and the two drifted
+ * apart. These helpers are the single source of truth for requirement-body
+ * extraction, scenario counting, and `SHALL`/`MUST` detection in
+ * `validate <change>`, `validate <spec>`, and `archive`.
+ */
+export { buildCodeFenceMask } from './code-fence.js';
+/**
+ * A level-4 header. Deliberately matches ANY `####` header, not only
+ * `#### Scenario:` — the spec path treats every level-4 child of a requirement
+ * 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.
+ */
+export declare const SCENARIO_HEADER: RegExp;
+/**
+ * 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
+ * and reject identical text.
+ */
+export declare function containsShallOrMust(text: string): boolean;
+/**
+ * Extract the full requirement body from the lines that follow a
+ * `### Requirement:` header (the lines may include scenarios and fenced code).
+ *
+ * Captures every body line from the start up to the first header found on a
+ * non-fenced line — usually the first `#### Scenario:`, but also a stray `###`
+ * divider the delta reader absorbed into the block — skipping blank lines and
+ * any line inside a fenced code block. `**metadata**:` lines are skipped only
+ * when other body text remains: a requirement written entirely as
+ * `**Constraint**: The system MUST ...` keeps that line as its body. Captured
+ * lines are trimmed and joined with newlines so a requirement whose text wraps
+ * across lines — or whose `SHALL`/`MUST` lands on a later line — is read in
+ * full.
+ */
+export declare function extractRequirementBody(bodyLines: string[]): string;
+/**
+ * Parser/display fallback for a requirement block with no body text. This is
+ * what lets a bare `### The system SHALL ...` header remain readable on the
+ * spec path (the title is the requirement). Validator body-keyword checks for
+ * canonical `### Requirement:` blocks use `extractRequirementBody` directly so
+ * a keyword that appears only in the header still receives the #1156/#1280
+ * body-keyword hint.
+ */
+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.
+ */
+export declare function countScenarios(bodyLines: string[]): number;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/requirement-text.js

@@ -0,0 +1,98 @@
+/**
+ * Shared, fence-aware requirement-reading helpers.
+ *
+ * The requirement reader used to be implemented twice — once for main specs
+ * (`MarkdownParser.parseRequirements`) and once for change deltas
+ * (`Validator.extractRequirementText` / `countScenarios`) — and the two drifted
+ * apart. These helpers are the single source of truth for requirement-body
+ * extraction, scenario counting, and `SHALL`/`MUST` detection in
+ * `validate <change>`, `validate <spec>`, and `archive`.
+ */
+// Re-exported so existing importers keep working; the single implementation
+// lives in code-fence.ts.
+export { buildCodeFenceMask } from './code-fence.js';
+import { buildCodeFenceMask } from './code-fence.js';
+/** Lines that look like `**ID**: ...` / `**Priority**: ...` metadata. */
+const METADATA_LINE = /^\*\*[^*]+\*\*:/;
+/** Any markdown header line — the boundary where a requirement body ends. */
+const HEADER_LINE = /^#{1,6}\s/;
+/**
+ * A level-4 header. Deliberately matches ANY `####` header, not only
+ * `#### Scenario:` — the spec path treats every level-4 child of a requirement
+ * 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.
+ */
+export const SCENARIO_HEADER = /^####\s+/;
+/**
+ * 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
+ * and reject identical text.
+ */
+export function containsShallOrMust(text) {
+    return /\b(SHALL|MUST)\b/.test(text);
+}
+/**
+ * Extract the full requirement body from the lines that follow a
+ * `### Requirement:` header (the lines may include scenarios and fenced code).
+ *
+ * Captures every body line from the start up to the first header found on a
+ * non-fenced line — usually the first `#### Scenario:`, but also a stray `###`
+ * divider the delta reader absorbed into the block — skipping blank lines and
+ * any line inside a fenced code block. `**metadata**:` lines are skipped only
+ * when other body text remains: a requirement written entirely as
+ * `**Constraint**: The system MUST ...` keeps that line as its body. Captured
+ * lines are trimmed and joined with newlines so a requirement whose text wraps
+ * across lines — or whose `SHALL`/`MUST` lands on a later line — is read in
+ * full.
+ */
+export function extractRequirementBody(bodyLines) {
+    const mask = buildCodeFenceMask(bodyLines);
+    const captured = [];
+    const metadata = [];
+    for (let i = 0; i < bodyLines.length; i++) {
+        if (mask[i])
+            continue; // inside a fenced code block
+        const line = bodyLines[i];
+        if (HEADER_LINE.test(line))
+            break; // first scenario or stray divider
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue; // blank
+        if (METADATA_LINE.test(trimmed)) {
+            metadata.push(trimmed); // **ID**: / **Priority**: ...
+            continue;
+        }
+        captured.push(trimmed);
+    }
+    if (captured.length > 0)
+        return captured.join('\n');
+    return metadata.join('\n'); // metadata-only body: the metadata IS the body
+}
+/**
+ * Parser/display fallback for a requirement block with no body text. This is
+ * what lets a bare `### The system SHALL ...` header remain readable on the
+ * spec path (the title is the requirement). Validator body-keyword checks for
+ * canonical `### Requirement:` blocks use `extractRequirementBody` directly so
+ * a keyword that appears only in the header still receives the #1156/#1280
+ * body-keyword hint.
+ */
+export function extractRequirementText(headerTitle, bodyLines) {
+    return extractRequirementBody(bodyLines) || headerTitle.trim();
+}
+/**
+ * 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.
+ */
+export function countScenarios(bodyLines) {
+    const mask = buildCodeFenceMask(bodyLines);
+    let count = 0;
+    for (let i = 0; i < bodyLines.length; i++) {
+        if (mask[i])
+            continue;
+        if (SCENARIO_HEADER.test(bodyLines[i]))
+            count++;
+    }
+    return count;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/spec-structure.d.ts

@@ -0,0 +1,8 @@
+export interface MainSpecStructureIssue {
+    kind: 'delta-header' | 'requirement-outside-requirements' | 'duplicate-requirement';
+    line: number;
+    header: string;
+    message: string;
+}
+export declare function findMainSpecStructureIssues(content: string): MainSpecStructureIssue[];
+export declare function stripFencedCodeBlocksPreservingLines(content: string): string;