freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/delta-resolution.js

@@ -0,0 +1,171 @@
+// FreeHarness addition (not upstream OpenSpec): resolution of MODIFIED / REMOVED /
+// RENAMED delta headers against the current main spec.
+//
+// A MODIFIED or REMOVED block whose header is not in openspec/specs/<cap>/spec.md
+// has nothing to act on at archive time: the fold either aborts (MODIFIED,
+// RENAMED) or treats the removal as already synced (REMOVED) and the old
+// requirement survives in the published spec. The validator reports every such
+// header (ERROR under --strict, WARNING otherwise) and `openspec archive` refuses
+// on them unless --force. When the header exists only in another in-flight
+// change's ADDED block, the finding names that change: the fix is to archive it
+// first.
+import { promises as fs } from 'fs';
+import path from 'path';
+import { parseDeltaSpec, extractRequirementsSection, normalizeRequirementName, } from './parsers/requirement-blocks.js';
+import { discoverSpecFiles } from './spec-discovery.js';
+import { FileSystemUtils } from '../engine/file-system.js';
+/**
+ * Builds the printed message for one unresolved header.
+ * @param operation Delta operation.
+ * @param header Requirement header.
+ * @param specId Capability id.
+ * @param addedBy In-flight change that ADDs the header, when known.
+ * @returns Message text.
+ */
+export function unresolvedHeaderMessage(operation, header, specId, addedBy) {
+    const where = `openspec/specs/${specId}/spec.md${addedBy ? ` (ADDED by ${addedBy}, not archived yet)` : ''}`;
+    return (`${operation} "${header}" does not resolve in ${where} — archive would silently skip it and ` +
+        'the old requirement would survive; fix the header or archive the change that ADDs it first');
+}
+/**
+ * Reads the requirement names of a main spec; empty when the spec is absent.
+ * @param mainSpecFile Absolute spec.md path.
+ * @returns Normalized requirement names.
+ */
+async function currentRequirementNames(mainSpecFile) {
+    let content;
+    try {
+        content = await fs.readFile(mainSpecFile, 'utf-8');
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return new Set();
+        throw error;
+    }
+    const names = new Set();
+    for (const block of extractRequirementsSection(content).bodyBlocks) {
+        names.add(normalizeRequirementName(block.name));
+    }
+    return names;
+}
+/**
+ * Indexes the ADDED headers of every other in-flight change: `specId` ->
+ * normalized header -> change id (first change wins).
+ * @param changesDir The openspec/changes directory (may be absent).
+ * @param selfChange Change id to exclude.
+ * @returns Index.
+ */
+async function addedElsewhere(changesDir, selfChange) {
+    const index = new Map();
+    if (!changesDir)
+        return index;
+    let entries;
+    try {
+        entries = await fs.readdir(changesDir, { withFileTypes: true });
+    }
+    catch {
+        return index;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === 'archive' || entry.name.startsWith('.') || entry.name === selfChange)
+            continue;
+        let specs;
+        try {
+            specs = await discoverSpecFiles(path.join(changesDir, entry.name, 'specs'));
+        }
+        catch {
+            continue;
+        }
+        for (const { id, specFile } of specs) {
+            let content;
+            try {
+                content = await fs.readFile(specFile, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const bySpec = index.get(id) ?? new Map();
+            for (const block of parseDeltaSpec(content).added) {
+                const key = normalizeRequirementName(block.name);
+                if (!bySpec.has(key))
+                    bySpec.set(key, entry.name);
+            }
+            index.set(id, bySpec);
+        }
+    }
+    return index;
+}
+/**
+ * Lists the MODIFIED / REMOVED / RENAMED headers of a change that do not exist
+ * in the current main specs. A RENAMED whose FROM is gone but whose TO exists is
+ * an already-synced rename and resolves.
+ * @param changeDir Absolute change directory.
+ * @param mainSpecsDir Absolute openspec/specs directory.
+ * @param changesDir Absolute openspec/changes directory, for the ADDED-elsewhere
+ *   attribution; omitted = no attribution.
+ * @returns Unresolved headers in delta-file order.
+ */
+export async function findUnresolvedDeltaHeaders(changeDir, mainSpecsDir, changesDir) {
+    const specsDir = path.join(changeDir, 'specs');
+    let discovered;
+    try {
+        discovered = await discoverSpecFiles(specsDir);
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return [];
+        throw error;
+    }
+    const out = [];
+    let elsewhere;
+    const changeName = path.basename(changeDir);
+    for (const { id: specId, specFile } of discovered) {
+        let content;
+        try {
+            content = await fs.readFile(specFile, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const plan = parseDeltaSpec(content);
+        if (plan.modified.length + plan.removed.length + plan.renamed.length === 0)
+            continue;
+        const mainSpecFile = path.join(mainSpecsDir, ...specId.split('/'), 'spec.md');
+        FileSystemUtils.assertPathWithin(path.dirname(mainSpecFile), mainSpecFile);
+        const current = await currentRequirementNames(mainSpecFile);
+        const entryPath = FileSystemUtils.toPosixPath(path.relative(specsDir, specFile));
+        const report = async (operation, header) => {
+            elsewhere ??= await addedElsewhere(changesDir, changeName);
+            const addedBy = elsewhere.get(specId)?.get(normalizeRequirementName(header));
+            out.push({
+                operation,
+                header,
+                specId,
+                entryPath,
+                ...(addedBy ? { addedBy } : {}),
+                message: unresolvedHeaderMessage(operation, header, specId, addedBy),
+            });
+        };
+        const renamedTo = new Set(plan.renamed.map((r) => normalizeRequirementName(r.to)));
+        for (const block of plan.modified) {
+            const key = normalizeRequirementName(block.name);
+            // Archive applies RENAMED first, so a MODIFIED naming a rename target resolves.
+            if (current.has(key) || renamedTo.has(key))
+                continue;
+            await report('MODIFIED', block.name);
+        }
+        for (const name of plan.removed) {
+            if (current.has(normalizeRequirementName(name)))
+                continue;
+            await report('REMOVED', name);
+        }
+        for (const { from, to } of plan.renamed) {
+            if (current.has(normalizeRequirementName(from)) || current.has(normalizeRequirementName(to)))
+                continue;
+            await report('RENAMED', from);
+        }
+    }
+    return out;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/change-parser.d.ts

@@ -0,0 +1,27 @@
+import { MarkdownParser, Section } from './markdown-parser.js';
+import { Change, Requirement } from '../schemas/index.js';
+export declare class ChangeParser extends MarkdownParser {
+    private changeDir;
+    constructor(content: string, changeDir: string);
+    parseChangeWithDeltas(name: string): Promise<Change>;
+    private parseDeltaSpecs;
+    /**
+     * Read requirements from a delta section, ignoring headers that are not
+     * `### Requirement: <name>`.
+     *
+     * A delta section often carries divider headers such as
+     * `### Documentation Requirements`. The base parser treats every child header
+     * as a requirement, which invented a scenario-less requirement that does not
+     * exist (#498): archive warned about a missing scenario, and `show --json`
+     * reported an extra delta. The delta reader already skips these headers and
+     * notes them, so this keeps the two readers in agreement.
+     *
+     * Overriding here rather than in MarkdownParser keeps main spec parsing —
+     * `view`, `list`, `spec --json`, spec validation — untouched.
+     */
+    protected parseRequirements(section: Section): Requirement[];
+    private parseSpecDeltas;
+    private parseRenames;
+    private parseSectionsFromContent;
+    private getContentUntilNextHeaderFromLines;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/change-parser.js

@@ -0,0 +1,210 @@
+import { MarkdownParser } from './markdown-parser.js';
+import { buildCodeFenceMask } from './requirement-text.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { discoverSpecFiles } from '../spec-discovery.js';
+export class ChangeParser extends MarkdownParser {
+    changeDir;
+    constructor(content, changeDir) {
+        super(content);
+        this.changeDir = changeDir;
+    }
+    async parseChangeWithDeltas(name) {
+        const sections = this.parseSections();
+        const why = this.findSection(sections, 'Why')?.content || '';
+        const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
+        if (!why) {
+            throw new Error('Change must have a Why section');
+        }
+        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;
+        return {
+            name,
+            why: why.trim(),
+            whatChanges: whatChanges.trim(),
+            deltas,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec-change',
+            },
+        };
+    }
+    async parseDeltaSpecs(specsDir) {
+        const deltas = [];
+        // Discover delta specs recursively so nested layouts like
+        // specs/<area>/<capability>/spec.md are parsed too (#1353)
+        const specFiles = await discoverSpecFiles(specsDir);
+        for (const { id, specFile } of specFiles) {
+            try {
+                const content = await fs.readFile(specFile, 'utf-8');
+                const specDeltas = this.parseSpecDeltas(id, content);
+                deltas.push(...specDeltas);
+            }
+            catch (error) {
+                // Spec file might not be readable, which is okay
+                continue;
+            }
+        }
+        return deltas;
+    }
+    /**
+     * Read requirements from a delta section, ignoring headers that are not
+     * `### Requirement: <name>`.
+     *
+     * A delta section often carries divider headers such as
+     * `### Documentation Requirements`. The base parser treats every child header
+     * as a requirement, which invented a scenario-less requirement that does not
+     * exist (#498): archive warned about a missing scenario, and `show --json`
+     * reported an extra delta. The delta reader already skips these headers and
+     * notes them, so this keeps the two readers in agreement.
+     *
+     * Overriding here rather than in MarkdownParser keeps main spec parsing —
+     * `view`, `list`, `spec --json`, spec validation — untouched.
+     */
+    parseRequirements(section) {
+        return super.parseRequirements({
+            ...section,
+            children: section.children.filter((child) => /^Requirement:\s*\S/i.test(child.title.trim())),
+        });
+    }
+    parseSpecDeltas(specName, content) {
+        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],
+                });
+            });
+        }
+        // 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],
+                });
+            });
+        }
+        // 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 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,
+                });
+            });
+        }
+        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;
+    }
+    parseSectionsFromContent(content) {
+        const normalizedContent = ChangeParser.normalizeContent(content);
+        const lines = normalizedContent.split('\n');
+        const codeFenceLineMask = buildCodeFenceMask(lines);
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (codeFenceLineMask[i]) {
+                continue;
+            }
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const contentLines = this.getContentUntilNextHeaderFromLines(lines, codeFenceLineMask, i + 1, level);
+                const section = {
+                    level,
+                    title,
+                    content: contentLines.join('\n').trim(),
+                    children: [],
+                };
+                while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+                    stack.pop();
+                }
+                if (stack.length === 0) {
+                    sections.push(section);
+                }
+                else {
+                    stack[stack.length - 1].children.push(section);
+                }
+                stack.push(section);
+            }
+        }
+        return sections;
+    }
+    getContentUntilNextHeaderFromLines(lines, codeFenceLineMask, startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = codeFenceLineMask[i] ? null : line.match(/^(#{1,6})\s+/);
+            if (headerMatch && headerMatch[1].length <= currentLevel) {
+                break;
+            }
+            contentLines.push(line);
+        }
+        return contentLines;
+    }
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/code-fence.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared fenced-code-block detection for the Markdown parsers.
+ *
+ * Several parsers need to ignore Markdown structure (headers, requirement
+ * blocks, scenarios, delta sections) that appears inside fenced code blocks.
+ * Keeping this logic in one place avoids the drift that previously left
+ * `requirement-blocks.ts` treating fenced `### Requirement:` lines as real
+ * requirements during validation and archiving.
+ */
+/**
+ * Builds a per-line mask where `true` marks a line that is part of a fenced
+ * code block (including the opening and closing fence lines themselves).
+ */
+export declare function buildCodeFenceMask(lines: string[]): boolean[];

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/code-fence.js

@@ -0,0 +1,48 @@
+/**
+ * Shared fenced-code-block detection for the Markdown parsers.
+ *
+ * Several parsers need to ignore Markdown structure (headers, requirement
+ * blocks, scenarios, delta sections) that appears inside fenced code blocks.
+ * Keeping this logic in one place avoids the drift that previously left
+ * `requirement-blocks.ts` treating fenced `### Requirement:` lines as real
+ * requirements during validation and archiving.
+ */
+function getFenceMarker(line) {
+    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
+    if (!fenceMatch) {
+        return null;
+    }
+    return {
+        marker: fenceMatch[1][0],
+        length: fenceMatch[1].length,
+    };
+}
+function isClosingFence(line, activeFence) {
+    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+    return Boolean(fenceMatch &&
+        fenceMatch[1][0] === activeFence.marker &&
+        fenceMatch[1].length >= activeFence.length);
+}
+/**
+ * Builds a per-line mask where `true` marks a line that is part of a fenced
+ * code block (including the opening and closing fence lines themselves).
+ */
+export function buildCodeFenceMask(lines) {
+    const mask = new Array(lines.length).fill(false);
+    let activeFence = null;
+    for (let i = 0; i < lines.length; i++) {
+        if (!activeFence) {
+            const fence = getFenceMarker(lines[i]);
+            if (fence) {
+                activeFence = fence;
+                mask[i] = true;
+            }
+            continue;
+        }
+        mask[i] = true;
+        if (isClosingFence(lines[i], activeFence)) {
+            activeFence = null;
+        }
+    }
+    return mask;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/markdown-parser.d.ts

@@ -0,0 +1,22 @@
+import { Spec, Change, Requirement, Scenario, Delta } from '../schemas/index.js';
+export interface Section {
+    level: number;
+    title: string;
+    content: string;
+    children: Section[];
+}
+export declare class MarkdownParser {
+    private lines;
+    private codeFenceLineMask;
+    private currentLine;
+    constructor(content: string);
+    protected static normalizeContent(content: string): string;
+    parseSpec(name: string): Spec;
+    parseChange(name: string): Change;
+    protected parseSections(): Section[];
+    protected getContentUntilNextHeader(startLine: number, currentLevel: number): string;
+    protected findSection(sections: Section[], title: string): Section | undefined;
+    protected parseRequirements(section: Section): Requirement[];
+    protected parseScenarios(requirementSection: Section): Scenario[];
+    protected parseDeltas(content: string): Delta[];
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/validation/parsers/markdown-parser.js

@@ -0,0 +1,186 @@
+import { buildCodeFenceMask, extractRequirementText } from './requirement-text.js';
+/**
+ * EARS scenario title: `Scenario: WHEN <event> THE SYSTEM SHALL <behavior>`
+ * (also WHILE/WHERE/IF ... SHALL). Case-insensitive; the title is the text
+ * after `#### ` so it still starts with `Scenario:`.
+ */
+const EARS_SCENARIO_TITLE = /^Scenario:\s*(?:WHEN|WHILE|WHERE|IF)\b[\s\S]*\b(?:SHALL|MUST)\b/i;
+export class MarkdownParser {
+    lines;
+    codeFenceLineMask;
+    currentLine;
+    constructor(content) {
+        const normalized = MarkdownParser.normalizeContent(content);
+        this.lines = normalized.split('\n');
+        this.codeFenceLineMask = buildCodeFenceMask(this.lines);
+        this.currentLine = 0;
+    }
+    static normalizeContent(content) {
+        // Strip a UTF-8 BOM so a header on the first line still matches.
+        return content.replace(/^/, '').replace(/\r\n?/g, '\n');
+    }
+    parseSpec(name) {
+        const sections = this.parseSections();
+        const purpose = this.findSection(sections, 'Purpose')?.content || '';
+        const requirementsSection = this.findSection(sections, 'Requirements');
+        if (!purpose) {
+            throw new Error('Spec must have a Purpose section');
+        }
+        if (!requirementsSection) {
+            throw new Error('Spec must have a Requirements section');
+        }
+        const requirements = this.parseRequirements(requirementsSection);
+        return {
+            name,
+            overview: purpose.trim(),
+            requirements,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec',
+            },
+        };
+    }
+    parseChange(name) {
+        const sections = this.parseSections();
+        const why = this.findSection(sections, 'Why')?.content || '';
+        const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
+        if (!why) {
+            throw new Error('Change must have a Why section');
+        }
+        if (!whatChanges) {
+            throw new Error('Change must have a What Changes section');
+        }
+        const deltas = this.parseDeltas(whatChanges);
+        return {
+            name,
+            why: why.trim(),
+            whatChanges: whatChanges.trim(),
+            deltas,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec-change',
+            },
+        };
+    }
+    parseSections() {
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            if (this.codeFenceLineMask[i]) {
+                continue;
+            }
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const content = this.getContentUntilNextHeader(i + 1, level);
+                const section = {
+                    level,
+                    title,
+                    content,
+                    children: [],
+                };
+                while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+                    stack.pop();
+                }
+                if (stack.length === 0) {
+                    sections.push(section);
+                }
+                else {
+                    stack[stack.length - 1].children.push(section);
+                }
+                stack.push(section);
+            }
+        }
+        return sections;
+    }
+    getContentUntilNextHeader(startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            const headerMatch = this.codeFenceLineMask[i] ? null : line.match(/^(#{1,6})\s+/);
+            if (headerMatch && headerMatch[1].length <= currentLevel) {
+                break;
+            }
+            contentLines.push(line);
+        }
+        return contentLines.join('\n').trim();
+    }
+    findSection(sections, title) {
+        for (const section of sections) {
+            if (section.title.toLowerCase() === title.toLowerCase()) {
+                return section;
+            }
+            const child = this.findSection(section.children, title);
+            if (child) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    parseRequirements(section) {
+        const requirements = [];
+        for (const child of section.children) {
+            // Read the requirement text via the shared reader (multi-line, fence- and
+            // metadata-aware, with the shared header-title fallback for empty bodies).
+            const text = extractRequirementText(child.title, child.content.split('\n'));
+            const scenarios = this.parseScenarios(child);
+            requirements.push({
+                text,
+                scenarios,
+            });
+        }
+        return requirements;
+    }
+    parseScenarios(requirementSection) {
+        const scenarios = [];
+        for (const scenarioSection of requirementSection.children) {
+            // Store the raw text content of the scenario section
+            if (scenarioSection.content.trim()) {
+                scenarios.push({
+                    rawText: scenarioSection.content
+                });
+            }
+            else if (EARS_SCENARIO_TITLE.test(scenarioSection.title)) {
+                // FreeHarness V4-P4 (4.5): an EARS scenario carries its whole behavior
+                // in the header (`#### Scenario: WHEN <event> THE SYSTEM SHALL <behavior>`)
+                // and may have no body. Upstream drops body-less scenarios, which would
+                // leave the requirement without one; the header text is the scenario.
+                scenarios.push({ rawText: scenarioSection.title });
+            }
+        }
+        return scenarios;
+    }
+    parseDeltas(content) {
+        const deltas = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            // Match both formats: **spec:** and **spec**:
+            const deltaMatch = line.match(/^\s*-\s*\*\*([^*:]+)(?::\*\*|\*\*:)\s*(.+)$/);
+            if (deltaMatch) {
+                const specName = deltaMatch[1].trim();
+                const description = deltaMatch[2].trim();
+                let operation = 'MODIFIED';
+                const lowerDesc = description.toLowerCase();
+                // Use word boundaries to avoid false matches (e.g., "address" matching "add")
+                // Check RENAMED first since it's more specific than patterns containing "new"
+                if (/\brename(s|d|ing)?\b/.test(lowerDesc) || /\brenamed\s+(to|from)\b/.test(lowerDesc)) {
+                    operation = 'RENAMED';
+                }
+                else if (/\badd(s|ed|ing)?\b/.test(lowerDesc) || /\bcreate(s|d|ing)?\b/.test(lowerDesc) || /\bnew\b/.test(lowerDesc)) {
+                    operation = 'ADDED';
+                }
+                else if (/\bremove(s|d|ing)?\b/.test(lowerDesc) || /\bdelete(s|d|ing)?\b/.test(lowerDesc)) {
+                    operation = 'REMOVED';
+                }
+                deltas.push({
+                    spec: specName,
+                    operation,
+                    description,
+                });
+            }
+        }
+        return deltas;
+    }
+}