@codewalla_india/openspec 1.3.1 → 1.3.3

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

@@ -1,6 +1,18 @@
+import { buildCodeFenceMask } 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.
@@ -8,7 +20,8 @@ const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/i;
 export function extractRequirementsSection(content) {
     const normalized = normalizeLineEndings(content);
     const lines = normalized.split('\n');
-    const reqHeaderIndex = lines.findIndex(l => /^##\s+Requirements\s*$/i.test(l));
+    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();
@@ -24,7 +37,7 @@ export function extractRequirementsSection(content) {
     // 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 (/^##\s+/.test(lines[i])) {
+        if (!fenceMask[i] && /^##\s+/.test(lines[i])) {
             endIndex = i;
             break;
         }
@@ -32,29 +45,31 @@ export function extractRequirementsSection(content) {
     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 && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor])) {
+    while (cursor < sectionBodyLines.length && !isRequirementHeader(cursor)) {
         preambleLines.push(sectionBodyLines[cursor]);
         cursor++;
     }
     while (cursor < sectionBodyLines.length) {
-        const headerStart = cursor;
         const headerLineCandidate = sectionBodyLines[cursor];
-        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
-        if (!headerMatch) {
+        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 && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
+        while (cursor < sectionBodyLines.length && !isRequirementHeader(cursor) && !isTopLevelHeader(cursor)) {
             bodyLines.push(sectionBodyLines[cursor]);
             cursor++;
         }
@@ -72,27 +87,42 @@ export function extractRequirementsSection(content) {
     };
 }
 function normalizeLineEndings(content) {
-    return content.replace(/\r\n?/g, '\n');
+    // 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 sections = splitTopLevelSections(normalized);
+    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 added = parseRequirementBlocksFromSection(addedLookup.body);
-    const modified = parseRequirementBlocksFromSection(modifiedLookup.body);
+    const skippedHeaders = [];
+    const added = parseRequirementBlocksFromSection(addedLookup.body, {
+        section: addedLookup.title,
+        bodyStartLine: addedLookup.bodyStartLine,
+        sink: skippedHeaders,
+    });
+    const modified = parseRequirementBlocksFromSection(modifiedLookup.body, {
+        section: modifiedLookup.title,
+        bodyStartLine: modifiedLookup.bodyStartLine,
+        sink: skippedHeaders,
+    });
     const removedNames = parseRemovedNames(removedLookup.body);
     const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    skippedHeaders.sort((a, b) => a.line - b.line);
     return {
         added,
         modified,
         removed: removedNames,
         renamed: renamedPairs,
+        skippedHeaders,
         sectionPresence: {
             added: addedLookup.found,
             modified: modifiedLookup.found,
@@ -101,43 +131,65 @@ export function parseDeltaSpec(content) {
         },
     };
 }
-function splitTopLevelSections(content) {
-    const lines = content.split('\n');
+function splitTopLevelSections(lines, fenceMask) {
     const result = {};
     const indices = [];
     for (let i = 0; i < lines.length; i++) {
+        if (fenceMask[i])
+            continue;
         const m = lines[i].match(/^(##)\s+(.+)$/);
         if (m) {
-            const level = m[1].length; // only care for '##'
-            indices.push({ title: m[2].trim(), index: i, level });
+            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 body = lines.slice(current.index + 1, next ? next.index : lines.length).join('\n');
-        result[current.title] = body;
+        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,
+        };
     }
     return result;
 }
+const EMPTY_SECTION_BODY = { lines: [], fenceMask: [], bodyStartLine: 0 };
 function getSectionCaseInsensitive(sections, desired) {
     const target = desired.toLowerCase();
     for (const [title, body] of Object.entries(sections)) {
-        if (title.toLowerCase() === target)
-            return { body, found: true };
+        if (title.toLowerCase() === target) {
+            return { title, body, bodyStartLine: body.bodyStartLine, found: true };
+        }
     }
-    return { body: '', found: false };
+    return { title: desired, body: EMPTY_SECTION_BODY, bodyStartLine: 0, found: false };
 }
-function parseRequirementBlocksFromSection(sectionBody) {
-    if (!sectionBody)
+function parseRequirementBlocksFromSection(sectionBody, skipped) {
+    const { lines, fenceMask } = sectionBody;
+    if (lines.length === 0)
         return [];
-    const lines = normalizeLineEndings(sectionBody).split('\n');
+    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 && !REQUIREMENT_HEADER_REGEX.test(lines[i]))
+        while (i < lines.length && !isRequirementHeader(i)) {
+            recordIfSkippedHeader(i);
             i++;
+        }
         if (i >= lines.length)
             break;
         const headerLine = lines[i];
@@ -149,7 +201,8 @@ function parseRequirementBlocksFromSection(sectionBody) {
         const name = normalizeRequirementName(m[1]);
         const buf = [headerLine];
         i++;
-        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]) && !/^##\s+/.test(lines[i])) {
+        while (i < lines.length && !isRequirementHeader(i) && !isTopLevelHeader(i)) {
+            recordIfSkippedHeader(i);
             buf.push(lines[i]);
             i++;
         }
@@ -158,11 +211,14 @@ function parseRequirementBlocksFromSection(sectionBody) {
     return blocks;
 }
 function parseRemovedNames(sectionBody) {
-    if (!sectionBody)
+    const { lines, fenceMask } = sectionBody;
+    if (lines.length === 0)
         return [];
     const names = [];
-    const lines = normalizeLineEndings(sectionBody).split('\n');
-    for (const line of lines) {
+    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]));
@@ -177,12 +233,15 @@ function parseRemovedNames(sectionBody) {
     return names;
 }
 function parseRenamedPairs(sectionBody) {
-    if (!sectionBody)
+    const { lines, fenceMask } = sectionBody;
+    if (lines.length === 0)
         return [];
     const pairs = [];
-    const lines = normalizeLineEndings(sectionBody).split('\n');
     let current = {};
-    for (const line of lines) {
+    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) {
@@ -198,4 +257,64 @@ function parseRenamedPairs(sectionBody) {
     }
     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;
+}
+function parseScenarioBlocks(requirementRaw) {
+    const lines = requirementRaw.replace(/\r\n?/g, '\n').split('\n');
+    // A `#### Scenario:` inside a fenced example is not a real scenario. The
+    // validator's countScenarios already ignores fenced lines; the drift check
+    // must agree with it, or a fenced sample can false-abort an archive (or
+    // mask a genuinely dropped scenario).
+    const mask = buildCodeFenceMask(lines);
+    const scenarios = [];
+    let index = 0;
+    while (index < lines.length) {
+        const headerMatch = mask[index] ? null : lines[index].match(/^####\s*Scenario:\s*(.+)\s*$/);
+        if (!headerMatch) {
+            index++;
+            continue;
+        }
+        const start = index;
+        const name = headerMatch[1].trim();
+        index++;
+        while (index < lines.length && (mask[index] || !/^####\s*Scenario:\s*(.+)\s*$/.test(lines[index]))) {
+            index++;
+        }
+        scenarios.push({
+            name,
+            raw: lines.slice(start, index).join('\n').trimEnd(),
+        });
+    }
+    return scenarios;
+}
 //# sourceMappingURL=requirement-blocks.js.map

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

@@ -0,0 +1,48 @@
+/**
+ * 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';
+/**
+ * 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;
+//# sourceMappingURL=requirement-text.d.ts.map

package/dist/core/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). Don't tighten this to
+ * `Scenario:` without changing both paths together.
+ */
+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;
+}
+//# sourceMappingURL=requirement-text.js.map

package/dist/core/parsers/spec-structure.d.ts

@@ -1,5 +1,5 @@
 export interface MainSpecStructureIssue {
-    kind: 'delta-header' | 'requirement-outside-requirements';
+    kind: 'delta-header' | 'requirement-outside-requirements' | 'duplicate-requirement';
     line: number;
     header: string;
     message: string;

package/dist/core/parsers/spec-structure.js

@@ -1,3 +1,4 @@
+import { buildCodeFenceMask } from './code-fence.js';
 const REQUIREMENTS_SECTION_HEADER = /^##\s+Requirements\s*$/i;
 const TOP_LEVEL_SECTION_HEADER = /^##\s+/;
 const DELTA_HEADER = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements\s*$/i;
@@ -7,6 +8,7 @@ export function findMainSpecStructureIssues(content) {
     const stripped = stripFencedCodeBlocksPreservingLines(normalized);
     const lines = stripped.split('\n');
     const issues = [];
+    const requirementLines = new Map();
     const requirementsHeaderIndex = lines.findIndex(line => REQUIREMENTS_SECTION_HEADER.test(line));
     let requirementsEndIndex = lines.length;
     if (requirementsHeaderIndex !== -1) {
@@ -29,7 +31,7 @@ export function findMainSpecStructureIssues(content) {
                 line: i + 1,
                 header: trimmed,
                 message: `Main spec contains delta header "${trimmed}". ` +
-                    'Delta headers are only valid inside openspec/changes/<name>/specs/<capability>/spec.md ' +
+                    'Delta headers are only valid inside openspec/changes/<name>/specs/<capability-path>/spec.md ' +
                     'and truncate the parsed ## Requirements section.',
             });
             continue;
@@ -49,40 +51,28 @@ export function findMainSpecStructureIssues(content) {
                 message: `Requirement header "${trimmed}" appears outside the main ## Requirements section. ` +
                     'Main specs only parse requirements inside that section, so this requirement is currently invisible to validate, list, and archive.',
             });
+            continue;
+        }
+        const requirementName = requirementMatch[1].trim();
+        const previousLine = requirementLines.get(requirementName);
+        if (previousLine !== undefined) {
+            issues.push({
+                kind: 'duplicate-requirement',
+                line: i + 1,
+                header: trimmed,
+                message: `Requirement header "${trimmed}" duplicates the requirement declared on line ${previousLine}. ` +
+                    'Requirement names must be unique so spec updates cannot discard one block while updating another.',
+            });
+        }
+        else {
+            requirementLines.set(requirementName, i + 1);
         }
     }
     return issues;
 }
 export function stripFencedCodeBlocksPreservingLines(content) {
     const lines = content.split('\n');
-    const output = [];
-    let activeFence = null;
-    for (const line of lines) {
-        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
-        if (!activeFence) {
-            if (fenceMatch) {
-                activeFence = {
-                    marker: fenceMatch[1][0],
-                    length: fenceMatch[1].length,
-                };
-                output.push('');
-            }
-            else {
-                output.push(line);
-            }
-            continue;
-        }
-        output.push('');
-        if (isClosingFence(line, activeFence)) {
-            activeFence = null;
-        }
-    }
-    return output.join('\n');
-}
-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);
+    const mask = buildCodeFenceMask(lines);
+    return lines.map((line, i) => (mask[i] ? '' : line)).join('\n');
 }
 //# sourceMappingURL=spec-structure.js.map

package/dist/core/profile-sync-drift.d.ts

@@ -5,14 +5,6 @@ type WorkflowId = (typeof ALL_WORKFLOWS)[number];
  * Maps workflow IDs to their skill directory names.
  */
 export declare const WORKFLOW_TO_SKILL_DIR: Record<WorkflowId, string>;
-/**
- * Checks whether a tool has at least one generated OpenSpec command file.
- */
-export declare function toolHasAnyConfiguredCommand(projectPath: string, toolId: string): boolean;
-/**
- * Returns tools with at least one generated command file on disk.
- */
-export declare function getCommandConfiguredTools(projectPath: string): string[];
 /**
  * Returns tools that are configured via either skills or commands.
  */