@fission-ai/openspec 1.6.0 → 1.8.0

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

@@ -11,6 +11,14 @@ export interface RequirementsSectionParts {
     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.
  */
@@ -45,4 +53,14 @@ export interface DeltaPlan {
  * 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[];
 //# sourceMappingURL=requirement-blocks.d.ts.map

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

@@ -2,6 +2,16 @@ 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;
 /**
@@ -10,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();
@@ -26,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;
         }
@@ -34,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++;
         }
@@ -74,14 +87,18 @@ 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');
@@ -114,43 +131,45 @@ 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');
-        // First body line, 1-based: the header is at 0-based current.index.
-        result[current.title] = { body, bodyStartLine: current.index + 2 };
+        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, bodyStartLine }] of Object.entries(sections)) {
-        if (title.toLowerCase() === target)
-            return { title, body, bodyStartLine, found: true };
+    for (const [title, body] of Object.entries(sections)) {
+        if (title.toLowerCase() === target) {
+            return { title, body, bodyStartLine: body.bodyStartLine, found: true };
+        }
     }
-    return { title: desired, body: '', bodyStartLine: 0, found: false };
+    return { title: desired, body: EMPTY_SECTION_BODY, bodyStartLine: 0, found: false };
 }
 function parseRequirementBlocksFromSection(sectionBody, skipped) {
-    if (!sectionBody)
+    const { lines, fenceMask } = sectionBody;
+    if (lines.length === 0)
         return [];
-    const lines = normalizeLineEndings(sectionBody).split('\n');
-    // Record the non-canonical level-3 headers this reader skips, at the moment
-    // it skips them, so the INFO note describes the reader's real boundaries.
-    // Fence-masked lines are excluded: the body reader treats them as fenced
-    // content, not as headers.
-    const fenceMask = skipped ? buildCodeFenceMask(lines) : undefined;
+    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;
@@ -167,7 +186,7 @@ function parseRequirementBlocksFromSection(sectionBody, skipped) {
     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++;
         }
@@ -182,7 +201,7 @@ function parseRequirementBlocksFromSection(sectionBody, skipped) {
         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++;
@@ -192,11 +211,14 @@ function parseRequirementBlocksFromSection(sectionBody, skipped) {
     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]));
@@ -211,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) {
@@ -232,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

@@ -8,14 +8,7 @@
  * extraction, scenario counting, and `SHALL`/`MUST` detection in
  * `validate <change>`, `validate <spec>`, and `archive`.
  */
-/**
- * Build a per-line mask marking lines that fall inside a fenced code block
- * (``` ``` ``` or ``` ~~~ ```), including the fence lines themselves. Mirrors the
- * fence rules markdown uses: a fence opens on the first ```` ```/~~~ ```` of
- * length >= 3 and closes on a line of the same marker whose length is >= the
- * opening length, with nothing but whitespace after it.
- */
-export declare function buildCodeFenceMask(lines: string[]): boolean[];
+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

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

@@ -8,48 +8,10 @@
  * extraction, scenario counting, and `SHALL`/`MUST` detection in
  * `validate <change>`, `validate <spec>`, and `archive`.
  */
-/**
- * Build a per-line mask marking lines that fall inside a fenced code block
- * (``` ``` ``` or ``` ~~~ ```), including the fence lines themselves. Mirrors the
- * fence rules markdown uses: a fence opens on the first ```` ```/~~~ ```` of
- * length >= 3 and closes on a line of the same marker whose length is >= the
- * opening length, with nothing but whitespace after it.
- */
-export function buildCodeFenceMask(lines) {
-    const mask = new Array(lines.length).fill(false);
-    let activeFence = null;
-    for (let i = 0; i < lines.length; i++) {
-        const fence = getFenceMarker(lines[i]);
-        if (!activeFence) {
-            if (fence) {
-                activeFence = fence;
-                mask[i] = true;
-            }
-            continue;
-        }
-        mask[i] = true;
-        if (isClosingFence(lines[i], activeFence)) {
-            activeFence = null;
-        }
-    }
-    return mask;
-}
-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);
-}
+// 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. */

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.
  */

package/dist/core/profile-sync-drift.js

@@ -3,7 +3,12 @@ import * as fs from 'fs';
 import { AI_TOOLS } from './config.js';
 import { ALL_WORKFLOWS } from './profiles.js';
 import { CommandAdapterRegistry } from './command-generation/index.js';
-import { COMMAND_IDS, getConfiguredTools } from './shared/index.js';
+import { getConfiguredTools } from './shared/index.js';
+import { shouldGenerateCommandsForTool, shouldGenerateSkillsForTool, shouldReconcileCommandFilesForTool, shouldRemoveSkillsForTool, } from './command-surface.js';
+import { readSharedSkillTarget } from './shared-skill-target.js';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { isLegacyCodexSkillEquivalentToCurrent } from './shared/skill-content-equivalence.js';
+import { hasGlobalSkillTarget, resolveToolSkillsDir, toolSupportsSkills, } from './shared/skill-paths.js';
 /**
  * Maps workflow IDs to their skill directory names.
  */
@@ -24,48 +29,11 @@ export const WORKFLOW_TO_SKILL_DIR = {
 function toKnownWorkflows(workflows) {
     return workflows.filter((workflow) => ALL_WORKFLOWS.includes(workflow));
 }
-/**
- * Checks whether a tool has at least one generated OpenSpec command file.
- */
-export function toolHasAnyConfiguredCommand(projectPath, toolId) {
-    const adapter = CommandAdapterRegistry.get(toolId);
-    if (!adapter)
-        return false;
-    for (const commandId of COMMAND_IDS) {
-        const cmdPath = adapter.getFilePath(commandId);
-        const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-        if (fs.existsSync(fullPath)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Returns tools with at least one generated command file on disk.
- */
-export function getCommandConfiguredTools(projectPath) {
-    return AI_TOOLS
-        .filter((tool) => {
-        if (!tool.skillsDir)
-            return false;
-        const toolDir = path.join(projectPath, tool.skillsDir);
-        try {
-            return fs.statSync(toolDir).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    })
-        .map((tool) => tool.value)
-        .filter((toolId) => toolHasAnyConfiguredCommand(projectPath, toolId));
-}
 /**
  * Returns tools that are configured via either skills or commands.
  */
 export function getConfiguredToolsForProfileSync(projectPath) {
-    const skillConfigured = getConfiguredTools(projectPath);
-    const commandConfigured = getCommandConfiguredTools(projectPath);
-    return [...new Set([...skillConfigured, ...commandConfigured])];
+    return getConfiguredTools(projectPath);
 }
 /**
  * Detects if a single tool has profile/delivery drift against the desired state.
@@ -77,14 +45,45 @@ export function getConfiguredToolsForProfileSync(projectPath) {
  */
 export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);
-    if (!tool?.skillsDir)
+    if (!tool || !toolSupportsSkills(tool))
         return false;
     const knownDesiredWorkflows = toKnownWorkflows(desiredWorkflows);
     const desiredWorkflowSet = new Set(knownDesiredWorkflows);
-    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+    const skillsDir = resolveToolSkillsDir(projectPath, tool);
     const adapter = CommandAdapterRegistry.get(toolId);
-    const shouldGenerateSkills = delivery !== 'commands';
-    const shouldGenerateCommands = delivery !== 'skills';
+    const shouldGenerateSkills = shouldGenerateSkillsForTool(toolId, delivery);
+    const shouldGenerateCommands = shouldGenerateCommandsForTool(toolId, delivery);
+    const sharedTarget = tool.skillsDir
+        ? readSharedSkillTarget(projectPath, tool.skillsDir)
+        : undefined;
+    for (const root of tool.legacySkillsDirs ?? []) {
+        for (const workflow of knownDesiredWorkflows) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const legacySkill = path.join(projectPath, root, 'skills', dirName, 'SKILL.md');
+            if (!fs.existsSync(legacySkill))
+                continue;
+            const currentSkill = path.join(skillsDir, dirName, 'SKILL.md');
+            if (!fs.existsSync(currentSkill) || sharedTarget !== toolId) {
+                return true;
+            }
+            try {
+                if (FileSystemUtils.canonicalizeExistingPath(legacySkill) ===
+                    FileSystemUtils.canonicalizeExistingPath(currentSkill)) {
+                    continue;
+                }
+                // Equivalent generated copies are actionable: migration can safely
+                // remove the redundant legacy file even when version, line endings,
+                // or supported invocation syntax changed. Materially divergent copies
+                // stay in place without forcing an update on every run.
+                if (isLegacyCodexSkillEquivalentToCurrent(fs.readFileSync(legacySkill, 'utf-8'), fs.readFileSync(currentSkill, 'utf-8'))) {
+                    return true;
+                }
+            }
+            catch {
+                return true;
+            }
+        }
+    }
     if (shouldGenerateSkills) {
         for (const workflow of knownDesiredWorkflows) {
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
@@ -104,7 +103,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
             }
         }
     }
-    else {
+    else if (shouldRemoveSkillsForTool(toolId, delivery) && !hasGlobalSkillTarget(tool)) {
         for (const workflow of ALL_WORKFLOWS) {
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
             const skillDir = path.join(skillsDir, dirName);
@@ -132,7 +131,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
             }
         }
     }
-    else if (!shouldGenerateCommands && adapter) {
+    else if (shouldReconcileCommandFilesForTool(toolId, delivery) && adapter) {
         for (const workflow of ALL_WORKFLOWS) {
             const cmdPath = adapter.getFilePath(workflow);
             const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
@@ -152,10 +151,10 @@ export function getToolsNeedingProfileSync(projectPath, desiredWorkflows, delive
 }
 function getInstalledWorkflowsForTool(projectPath, toolId, options) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);
-    if (!tool?.skillsDir)
+    if (!tool || !toolSupportsSkills(tool))
         return [];
     const installed = new Set();
-    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+    const skillsDir = resolveToolSkillsDir(projectPath, tool);
     if (options.includeSkills) {
         for (const workflow of ALL_WORKFLOWS) {
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
@@ -188,9 +187,9 @@ export function hasProjectConfigDrift(projectPath, desiredWorkflows, delivery) {
         return true;
     }
     const desiredSet = new Set(toKnownWorkflows(desiredWorkflows));
-    const includeSkills = delivery !== 'commands';
-    const includeCommands = delivery !== 'skills';
     for (const toolId of configuredTools) {
+        const includeSkills = shouldGenerateSkillsForTool(toolId, delivery);
+        const includeCommands = shouldGenerateCommandsForTool(toolId, delivery);
         const installed = getInstalledWorkflowsForTool(projectPath, toolId, { includeSkills, includeCommands });
         if (installed.some((workflow) => !desiredSet.has(workflow))) {
             return true;