@gordon.gan/specflow 1.0.0

package/dist/integrations/cursor/adapter.js

@@ -0,0 +1,126 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { COMMAND_CATALOG } from '../shared/command-catalog.js';
+import { directoryExists, fileExists, hashDirectoryTree, hashFile } from '../shared/asset-hash.js';
+import { deriveCapabilityIds } from '../shared/capability-evidence.js';
+import { copyRuntimeAssets } from '../shared/runtime-assets.js';
+import { renderIdeContent } from '../shared/skill-renderer.js';
+function extractSkillDescription(content, fallback) {
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        return fallback;
+    }
+    const descMatch = frontmatterMatch[1].match(/description:\s*["']?(.+?)["']?\s*$/m);
+    return descMatch ? descMatch[1] : fallback;
+}
+function generateCursorCommandAlias(commandName, description) {
+    return [
+        '---',
+        `description: "${description}"`,
+        '---',
+        `Invoke the specflow:${commandName} skill.`,
+        '',
+    ].join('\n');
+}
+function renderCursorRule() {
+    return [
+        '# SpecFlow Cursor Context',
+        '',
+        '- Respect specflow phase gates: plan -> refined -> built -> archived',
+        '- Never bypass CLI validation and archive checks',
+        '- Use artifacts under specflow/changes/<change>/ before coding',
+        '',
+    ].join('\n');
+}
+async function generateCursor(ctx) {
+    const { projectRoot, packageRoot } = ctx;
+    const skillsSourceDir = join(packageRoot, 'skills');
+    const skillsDestDir = join(projectRoot, '.cursor', 'skills');
+    const commandsDestDir = join(projectRoot, '.cursor', 'commands', 'specflow');
+    const rulesDir = join(projectRoot, '.cursor', 'rules');
+    await fs.mkdir(commandsDestDir, { recursive: true });
+    await fs.mkdir(rulesDir, { recursive: true });
+    for (const command of COMMAND_CATALOG) {
+        const skillDirName = `specflow-${command.id}`;
+        const srcSkillMd = join(skillsSourceDir, skillDirName, 'SKILL.md');
+        const destSkillDir = join(skillsDestDir, skillDirName);
+        await fs.mkdir(destSkillDir, { recursive: true });
+        let description = command.description;
+        try {
+            const content = await fs.readFile(srcSkillMd, 'utf-8');
+            await fs.writeFile(join(destSkillDir, 'SKILL.md'), renderIdeContent(content, 'cursor'), 'utf-8');
+            description = extractSkillDescription(content, command.description);
+        }
+        catch {
+            const placeholder = [
+                '---',
+                `name: ${skillDirName}`,
+                `description: "${command.description}"`,
+                '---',
+                '',
+                `# SpecFlow: ${command.id}`,
+                '',
+                'Skill content pending.',
+                '',
+            ].join('\n');
+            await fs.writeFile(join(destSkillDir, 'SKILL.md'), renderIdeContent(placeholder, 'cursor'), 'utf-8');
+        }
+        await fs.writeFile(join(commandsDestDir, `${command.id}.md`), generateCursorCommandAlias(command.id, description), 'utf-8');
+    }
+    await fs.writeFile(join(rulesDir, 'specflow-context.mdc'), renderCursorRule(), 'utf-8');
+    const runtimePaths = await copyRuntimeAssets(packageRoot, projectRoot, 'cursor');
+    return {
+        ide: 'cursor',
+        generatedPaths: [
+            '.cursor/skills',
+            '.cursor/commands/specflow',
+            '.cursor/rules/specflow-context.mdc',
+            ...runtimePaths,
+        ],
+    };
+}
+async function inspectCursor(projectRoot) {
+    const commandDir = join(projectRoot, '.cursor', 'commands', 'specflow');
+    const skillDir = join(projectRoot, '.cursor', 'skills');
+    const ruleFile = join(projectRoot, '.cursor', 'rules', 'specflow-context.mdc');
+    const promptsDir = join(projectRoot, '.cursor', 'specflow', 'prompts');
+    const schemasDir = join(projectRoot, '.cursor', 'specflow', 'schemas');
+    const templatesDir = join(projectRoot, '.cursor', 'specflow', 'templates');
+    const supported = [];
+    const skillContentsByCommand = {};
+    for (const command of COMMAND_CATALOG) {
+        try {
+            const stat = await fs.stat(join(commandDir, `${command.id}.md`));
+            if (stat.isFile()) {
+                supported.push(command.id);
+            }
+        }
+        catch {
+            // ignore
+        }
+        try {
+            skillContentsByCommand[command.id] = await fs.readFile(join(skillDir, `specflow-${command.id}`, 'SKILL.md'), 'utf-8');
+        }
+        catch {
+            skillContentsByCommand[command.id] = '';
+        }
+    }
+    return {
+        ide: 'cursor',
+        supportedCommandIds: supported,
+        supportedCapabilityIds: deriveCapabilityIds(supported, skillContentsByCommand),
+        assets: {
+            commandsDir: { exists: await directoryExists(commandDir), hash: await hashDirectoryTree(commandDir) },
+            skillsDir: { exists: await directoryExists(skillDir), hash: await hashDirectoryTree(skillDir) },
+            rulesFile: { exists: await fileExists(ruleFile), hash: await hashFile(ruleFile) },
+            runtimePromptsDir: { exists: await directoryExists(promptsDir), hash: await hashDirectoryTree(promptsDir) },
+            runtimeSchemasDir: { exists: await directoryExists(schemasDir), hash: await hashDirectoryTree(schemasDir) },
+            runtimeTemplatesDir: { exists: await directoryExists(templatesDir), hash: await hashDirectoryTree(templatesDir) },
+        },
+    };
+}
+export const cursorAdapter = {
+    ide: 'cursor',
+    generate: generateCursor,
+    inspect: inspectCursor,
+};

package/dist/integrations/shared/adapter-registry.d.ts

@@ -0,0 +1,4 @@
+import type { Adapter, IdeTarget, InitIdeTarget } from './types.js';
+export declare const ALL_ADAPTERS: readonly Adapter[];
+export declare function getAdapter(ide: IdeTarget): Adapter;
+export declare function resolveAdapters(ide: InitIdeTarget): readonly Adapter[];

package/dist/integrations/shared/adapter-registry.js

@@ -0,0 +1,27 @@
+import { claudeAdapter } from '../claude/adapter.js';
+import { codexAdapter } from '../codex/adapter.js';
+import { cursorAdapter } from '../cursor/adapter.js';
+export const ALL_ADAPTERS = [claudeAdapter, cursorAdapter, codexAdapter];
+export function getAdapter(ide) {
+    const adapter = ALL_ADAPTERS.find((a) => a.ide === ide);
+    if (!adapter) {
+        throw new Error(`Unknown IDE target: ${ide}`);
+    }
+    return adapter;
+}
+export function resolveAdapters(ide) {
+    switch (ide) {
+        case 'claude':
+            return [claudeAdapter];
+        case 'cursor':
+            return [cursorAdapter];
+        case 'codex':
+            return [codexAdapter];
+        case 'both':
+            return [claudeAdapter, cursorAdapter];
+        case 'all':
+            return ALL_ADAPTERS;
+        default:
+            throw new Error(`Unknown init IDE target: ${ide}`);
+    }
+}

package/dist/integrations/shared/asset-copy.d.ts

@@ -0,0 +1,2 @@
+export declare function copyDirRecursive(src: string, dest: string): Promise<void>;
+export declare function copyDirRecursiveRendered(src: string, dest: string, render: (content: string, relativePath: string) => string): Promise<void>;

package/dist/integrations/shared/asset-copy.js

@@ -0,0 +1,44 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+const RENDERABLE_EXTENSIONS = new Set(['.md', '.yaml', '.yml', '.dot', '.txt']);
+function shouldRenderFile(fileName) {
+    const dot = fileName.lastIndexOf('.');
+    if (dot === -1) {
+        return false;
+    }
+    return RENDERABLE_EXTENSIONS.has(fileName.slice(dot));
+}
+export async function copyDirRecursive(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }));
+}
+export async function copyDirRecursiveRendered(src, dest, render) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursiveRendered(srcPath, destPath, render);
+        }
+        else if (entry.isFile()) {
+            if (shouldRenderFile(entry.name)) {
+                const content = await fs.readFile(srcPath, 'utf-8');
+                await fs.writeFile(destPath, render(content, entry.name), 'utf-8');
+            }
+            else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }));
+}

package/dist/integrations/shared/asset-hash.d.ts

@@ -0,0 +1,4 @@
+export declare function hashFile(path: string): Promise<string | undefined>;
+export declare function directoryExists(path: string): Promise<boolean>;
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function hashDirectoryTree(path: string): Promise<string | undefined>;

package/dist/integrations/shared/asset-hash.js

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+export async function hashFile(path) {
+    try {
+        const content = await fs.readFile(path);
+        return createHash('sha256').update(content).digest('hex');
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function directoryExists(path) {
+    try {
+        const stat = await fs.stat(path);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function fileExists(path) {
+    try {
+        const stat = await fs.stat(path);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export async function hashDirectoryTree(path) {
+    if (!(await directoryExists(path))) {
+        return undefined;
+    }
+    const hash = createHash('sha256');
+    await walkAndHash(path, hash, path);
+    return hash.digest('hex');
+}
+async function walkAndHash(dir, hash, root) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of sorted) {
+        const full = join(dir, entry.name);
+        const rel = full.slice(root.length);
+        hash.update(rel);
+        if (entry.isDirectory()) {
+            await walkAndHash(full, hash, root);
+        }
+        else if (entry.isFile()) {
+            const content = await fs.readFile(full);
+            hash.update(content);
+        }
+    }
+}

package/dist/integrations/shared/capability-evidence.d.ts

@@ -0,0 +1 @@
+export declare function deriveCapabilityIds(supportedCommandIds: readonly string[], skillContentsByCommand: Readonly<Record<string, string>>): string[];

package/dist/integrations/shared/capability-evidence.js

@@ -0,0 +1,42 @@
+import { COMMAND_IDS } from './command-catalog.js';
+const MARKER_RULES = [
+    { id: 'sub.scan.planned_v03_notice', skill: 'scan', includes: ['[PLANNED v0.3]', 'NOT YET FUNCTIONAL'] },
+    { id: 'sub.plan.first_iteration', skill: 'plan', includes: ['first-iteration deep-analysis pass'] },
+    { id: 'sub.refine.multi_round', skill: 'refine', includes: ['auto-multi-round loop', '## LOOP (Stages 2-4)'] },
+    { id: 'sub.refine.challenge_scope', skill: 'refine', includes: ['Challenge Behaviors #3 and #4', 'question scope'] },
+    { id: 'sub.build.phase_a', skill: 'build', includes: ['## Phase A: Task Rewrite'] },
+    { id: 'sub.build.phase_b', skill: 'build', includes: ['## Phase B: Subagent TDD Execution'] },
+    { id: 'sub.build.gap_detection', skill: 'build', includes: ['Gap Detection'] },
+    { id: 'sub.review.spec_regression', skill: 'review', includes: ['regression'] },
+    { id: 'sub.test.full_scope', skill: 'test', includes: ['unit, integration, e2e', 'verification report'] },
+    { id: 'sub.verify.dual_validation', skill: 'verify', includes: ['Dual validation', 'delta specs'] },
+    { id: 'sub.done.archive_merge', skill: 'done', includes: ['specflow change archive', 'delta specs into main specs'] },
+    { id: 'sub.fix.urgent_mode', skill: 'fix', includes: ['--urgent', 'skip'] },
+    { id: 'sub.snap.posthoc', skill: 'snap', includes: ['post-hoc', 'archive'] },
+    { id: 'failure.scan.not_implemented_guard', skill: 'scan', includes: ['do NOT attempt to run `specflow scan`'] },
+    { id: 'failure.build.phase_gate', skill: 'build', includes: ['HARD GATE (prerequisite)', 'phase is not `refined`, REFUSE'] },
+    { id: 'failure.verify.explicit_skip_marker', skill: 'verify', includes: ['Pass 2: skipped (no baseline'] },
+];
+export function deriveCapabilityIds(supportedCommandIds, skillContentsByCommand) {
+    const capabilityIds = new Set();
+    for (const commandId of supportedCommandIds) {
+        capabilityIds.add(`command.${commandId}`);
+    }
+    for (const rule of MARKER_RULES) {
+        const content = skillContentsByCommand[rule.skill] ?? '';
+        const ok = rule.includes.every((needle) => content.includes(needle));
+        if (ok) {
+            capabilityIds.add(rule.id);
+        }
+    }
+    // Safety: never emit capabilities for unknown commands.
+    for (const id of [...capabilityIds]) {
+        if (id.startsWith('command.')) {
+            const command = id.replace('command.', '');
+            if (!COMMAND_IDS.includes(command)) {
+                capabilityIds.delete(id);
+            }
+        }
+    }
+    return [...capabilityIds].sort();
+}

package/dist/integrations/shared/command-catalog.d.ts

@@ -0,0 +1,6 @@
+export interface CommandInfo {
+    readonly id: string;
+    readonly description: string;
+}
+export declare const COMMAND_CATALOG: readonly CommandInfo[];
+export declare const COMMAND_IDS: readonly string[];

package/dist/integrations/shared/command-catalog.js

@@ -0,0 +1,13 @@
+export const COMMAND_CATALOG = [
+    { id: 'scan', description: 'Brownfield project scanner via code-review-graph' },
+    { id: 'plan', description: 'Create proposal and spec artifacts for a change' },
+    { id: 'refine', description: 'Refine and iterate on spec artifacts' },
+    { id: 'build', description: 'Implement tasks from a change spec' },
+    { id: 'review', description: 'Review code changes against spec' },
+    { id: 'test', description: 'Run tests and verify coverage' },
+    { id: 'verify', description: 'Verify implementation matches spec' },
+    { id: 'done', description: 'Finalize and archive a completed change' },
+    { id: 'fix', description: 'Debug and fix failing tests or builds' },
+    { id: 'snap', description: 'Snapshot current project state' },
+];
+export const COMMAND_IDS = COMMAND_CATALOG.map((c) => c.id);

package/dist/integrations/shared/managed-assets.d.ts

@@ -0,0 +1,2 @@
+import type { IdeTarget } from './types.js';
+export declare function getRegeneratableIgnoreLines(ide: IdeTarget): readonly string[];

package/dist/integrations/shared/managed-assets.js

@@ -0,0 +1,21 @@
+export function getRegeneratableIgnoreLines(ide) {
+    if (ide === 'claude') {
+        return [
+            '.claude/specflow/prompts/',
+            '.claude/specflow/schemas/',
+            '.claude/specflow/templates/',
+        ];
+    }
+    if (ide === 'cursor') {
+        return [
+            '.cursor/specflow/prompts/',
+            '.cursor/specflow/schemas/',
+            '.cursor/specflow/templates/',
+        ];
+    }
+    return [
+        '.agents/specflow/prompts/',
+        '.agents/specflow/schemas/',
+        '.agents/specflow/templates/',
+    ];
+}

package/dist/integrations/shared/marker-write.d.ts

@@ -0,0 +1,3 @@
+export declare function appendManagedBlock(targetPath: string, markerStart: string, markerEnd: string, lines: readonly string[]): Promise<void>;
+export declare function upsertManagedBlock(targetPath: string, markerStart: string, markerEnd: string, lines: readonly string[]): Promise<void>;
+export declare function managedBlockPresent(content: string, markerStart: string, markerEnd: string): boolean;

package/dist/integrations/shared/marker-write.js

@@ -0,0 +1,48 @@
+import { promises as fs } from 'node:fs';
+function buildBlock(markerStart, lines, markerEnd) {
+    return [markerStart, ...lines, markerEnd].join('\n');
+}
+export async function appendManagedBlock(targetPath, markerStart, markerEnd, lines) {
+    const block = `${buildBlock(markerStart, lines, markerEnd)}\n`;
+    let existing = '';
+    try {
+        existing = await fs.readFile(targetPath, 'utf-8');
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+    if (existing.includes(markerStart)) {
+        return;
+    }
+    const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+    await fs.writeFile(targetPath, `${existing}${separator}\n${block}`, 'utf-8');
+}
+export async function upsertManagedBlock(targetPath, markerStart, markerEnd, lines) {
+    const block = buildBlock(markerStart, lines, markerEnd);
+    let existing = '';
+    try {
+        existing = await fs.readFile(targetPath, 'utf-8');
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+    if (existing.includes(markerStart) && existing.includes(markerEnd)) {
+        const startIdx = existing.indexOf(markerStart);
+        const endIdx = existing.indexOf(markerEnd, startIdx);
+        const afterEnd = endIdx + markerEnd.length;
+        const before = existing.slice(0, startIdx).replace(/\s+$/, '');
+        const after = existing.slice(afterEnd).replace(/^\s+/, '');
+        const parts = [before, block, after].filter((part) => part.length > 0);
+        await fs.writeFile(targetPath, `${parts.join('\n\n')}\n`, 'utf-8');
+        return;
+    }
+    const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+    await fs.writeFile(targetPath, `${existing}${separator}\n${block}\n`, 'utf-8');
+}
+export function managedBlockPresent(content, markerStart, markerEnd) {
+    return content.includes(markerStart) && content.includes(markerEnd);
+}

package/dist/integrations/shared/migration-state.d.ts

@@ -0,0 +1,2 @@
+export type MigrationState = 'fresh' | 'claude_only' | 'cursor_only' | 'codex_only' | 'both' | 'both_partial' | 'all_three' | 'all_partial' | 'customized';
+export declare function detectMigrationState(projectRoot: string): Promise<MigrationState>;

package/dist/integrations/shared/migration-state.js

@@ -0,0 +1,67 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { directoryExists } from './asset-hash.js';
+async function hasIdeRuntime(projectRoot, ide) {
+    if (ide === 'claude') {
+        return directoryExists(join(projectRoot, '.claude', 'specflow'));
+    }
+    if (ide === 'cursor') {
+        return directoryExists(join(projectRoot, '.cursor', 'specflow'));
+    }
+    return directoryExists(join(projectRoot, '.agents', 'specflow'));
+}
+export async function detectMigrationState(projectRoot) {
+    const hasClaude = await directoryExists(join(projectRoot, '.claude'));
+    const hasCursor = await directoryExists(join(projectRoot, '.cursor'));
+    const hasCodex = await directoryExists(join(projectRoot, '.agents'));
+    const hasSpecflow = await directoryExists(join(projectRoot, 'specflow'));
+    if (!hasClaude && !hasCursor && !hasCodex && !hasSpecflow) {
+        return 'fresh';
+    }
+    const ideCount = [hasClaude, hasCursor, hasCodex].filter(Boolean).length;
+    if (ideCount === 1) {
+        if (hasClaude) {
+            return 'claude_only';
+        }
+        if (hasCursor) {
+            return 'cursor_only';
+        }
+        return 'codex_only';
+    }
+    if (ideCount === 2 && hasClaude && hasCursor && !hasCodex) {
+        const hasClaudeCore = await hasIdeRuntime(projectRoot, 'claude');
+        const hasCursorCore = await hasIdeRuntime(projectRoot, 'cursor');
+        if (hasClaudeCore && hasCursorCore) {
+            const customized = await hasCursorCustomizations(projectRoot);
+            return customized ? 'customized' : 'both';
+        }
+        return 'both_partial';
+    }
+    if (ideCount === 3) {
+        const [hasClaudeCore, hasCursorCore, hasCodexCore] = await Promise.all([
+            hasIdeRuntime(projectRoot, 'claude'),
+            hasIdeRuntime(projectRoot, 'cursor'),
+            hasIdeRuntime(projectRoot, 'codex'),
+        ]);
+        if (hasClaudeCore && hasCursorCore && hasCodexCore) {
+            const customized = await hasCursorCustomizations(projectRoot);
+            return customized ? 'customized' : 'all_three';
+        }
+        return 'all_partial';
+    }
+    return 'all_partial';
+}
+async function hasCursorCustomizations(projectRoot) {
+    const cursorRoot = join(projectRoot, '.cursor');
+    if (!(await directoryExists(cursorRoot))) {
+        return false;
+    }
+    const managedNames = new Set(['commands', 'skills', 'rules', 'specflow']);
+    try {
+        const entries = await fs.readdir(cursorRoot, { withFileTypes: true });
+        return entries.some((entry) => !managedNames.has(entry.name));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/integrations/shared/parity-comparator.d.ts

@@ -0,0 +1,6 @@
+import type { CapabilityReport, ParityStatus } from './types.js';
+export declare function validateReportAgainstManifest(report: CapabilityReport): ParityStatus;
+export declare function compareReports(left: CapabilityReport, right: CapabilityReport): ParityStatus;
+export declare function compareIdeParity(claude: CapabilityReport, cursor: CapabilityReport): ParityStatus;
+export declare function compareTriIdeParity(claude: CapabilityReport, cursor: CapabilityReport, codex: CapabilityReport): ParityStatus;
+export declare function compareHealthyReports(reports: readonly CapabilityReport[]): ParityStatus;

package/dist/integrations/shared/parity-comparator.js

@@ -0,0 +1,97 @@
+import { CAPABILITY_MANIFEST, IDE_ASSET_MANIFEST } from './parity-manifest.js';
+// Prompts are rendered per IDE (paths and invocation syntax differ), so only
+// compare runtime assets that are copied verbatim across adapters.
+const PARITY_COMPARABLE_ASSET_KEYS = [
+    'runtimeSchemasDir',
+    'runtimeTemplatesDir',
+];
+export function validateReportAgainstManifest(report) {
+    const deltas = [];
+    const supportedCapabilities = new Set(report.supportedCapabilityIds);
+    for (const capability of CAPABILITY_MANIFEST) {
+        if (!capability.required) {
+            continue;
+        }
+        if (!supportedCapabilities.has(capability.id)) {
+            deltas.push({
+                id: `missing-capability:${report.ide}:${capability.id}`,
+                severity: 'P0',
+                message: `${report.ide} missing required capability ${capability.id}`,
+            });
+        }
+    }
+    const assetSpec = IDE_ASSET_MANIFEST.find((s) => s.ide === report.ide);
+    if (assetSpec) {
+        for (const key of assetSpec.requiredAssetKeys) {
+            if (!report.assets[key]?.exists) {
+                deltas.push({
+                    id: `missing-asset:${report.ide}:${key}`,
+                    severity: 'P0',
+                    message: `${report.ide} missing required asset ${key}`,
+                });
+            }
+        }
+    }
+    return { ok: deltas.length === 0, deltas };
+}
+function compareCapabilitySets(baseline, target) {
+    const deltas = [];
+    const baselineSupported = new Set(baseline.supportedCapabilityIds);
+    const targetSupported = new Set(target.supportedCapabilityIds);
+    for (const capability of baselineSupported) {
+        if (!targetSupported.has(capability)) {
+            deltas.push({
+                id: `${target.ide}-missing-capability:${capability}`,
+                severity: 'P0',
+                message: `${target.ide} missing capability present in ${baseline.ide}: ${capability}`,
+            });
+        }
+    }
+    for (const capability of targetSupported) {
+        if (!baselineSupported.has(capability)) {
+            deltas.push({
+                id: `${baseline.ide}-missing-capability:${capability}`,
+                severity: 'P0',
+                message: `${baseline.ide} missing capability present in ${target.ide}: ${capability}`,
+            });
+        }
+    }
+    return deltas;
+}
+function compareAssetHashes(left, right) {
+    const deltas = [];
+    for (const key of PARITY_COMPARABLE_ASSET_KEYS) {
+        const l = left.assets[key];
+        const r = right.assets[key];
+        if (!l?.exists || !r?.exists) {
+            continue;
+        }
+        if (l.hash !== undefined && r.hash !== undefined && l.hash !== r.hash) {
+            deltas.push({
+                id: `asset-drift:${left.ide}-${right.ide}:${key}`,
+                severity: 'P1',
+                message: `Asset content drift for ${key} between ${left.ide} and ${right.ide}`,
+            });
+        }
+    }
+    return deltas;
+}
+export function compareReports(left, right) {
+    const deltas = [...compareCapabilitySets(left, right), ...compareAssetHashes(left, right)];
+    return { ok: deltas.length === 0, deltas };
+}
+export function compareIdeParity(claude, cursor) {
+    return compareReports(claude, cursor);
+}
+export function compareTriIdeParity(claude, cursor, codex) {
+    return compareHealthyReports([claude, cursor, codex]);
+}
+export function compareHealthyReports(reports) {
+    const deltas = [];
+    for (let i = 0; i < reports.length; i += 1) {
+        for (let j = i + 1; j < reports.length; j += 1) {
+            deltas.push(...compareReports(reports[i], reports[j]).deltas);
+        }
+    }
+    return { ok: deltas.length === 0, deltas };
+}

package/dist/integrations/shared/parity-manifest.d.ts

@@ -0,0 +1,13 @@
+import type { IdeTarget } from './types.js';
+export interface CapabilitySpec {
+    readonly id: string;
+    readonly commandId: string;
+    readonly level: 'command' | 'sub-capability' | 'failure-path';
+    readonly required: boolean;
+}
+export interface IdeAssetSpec {
+    readonly ide: IdeTarget;
+    readonly requiredAssetKeys: readonly string[];
+}
+export declare const CAPABILITY_MANIFEST: readonly CapabilitySpec[];
+export declare const IDE_ASSET_MANIFEST: readonly IdeAssetSpec[];