@productbrain/cli 0.1.0-beta.1431 → 0.1.0-beta.14316

package/dist/generators/portable-knowledge.test.js

@@ -1,927 +0,0 @@
-/**
- * portable-knowledge — unit tests.
- * BET-169: transport-aware skill dispatch, target filtering, and transport section stripping.
- */
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { join } from 'path';
-// vi.mock calls are hoisted — use vi.hoisted() for constants referenced inside factories.
-const { vfs } = vi.hoisted(() => ({
-    vfs: {},
-}));
-vi.mock('fs', () => ({
-    mkdirSync: vi.fn(),
-    writeFileSync: vi.fn((path, content) => {
-        vfs[path] = content;
-    }),
-    existsSync: vi.fn((path) => {
-        // Check if the path itself or any child key exists (for directory checks)
-        if (path in vfs)
-            return true;
-        // For directory checks: return true if any key starts with path + '/'
-        return Object.keys(vfs).some((k) => k.startsWith(path + '/'));
-    }),
-    readFileSync: vi.fn((path, _enc) => {
-        if (path in vfs)
-            return vfs[path];
-        throw Object.assign(new Error(`ENOENT: no such file '${path}'`), { code: 'ENOENT' });
-    }),
-    readdirSync: vi.fn((dir) => {
-        const prefix = dir.endsWith('/') ? dir : dir + '/';
-        const files = new Set();
-        for (const key of Object.keys(vfs)) {
-            if (key.startsWith(prefix)) {
-                const rest = key.slice(prefix.length);
-                const parts = rest.split('/');
-                if (parts.length === 1)
-                    files.add(parts[0]);
-            }
-        }
-        return [...files];
-    }),
-}));
-import { readCanonicalSkills, readCanonicalRules, shouldEmitToTarget, stripTransportSections, filterByLevel, evaluateConditions, generateCursorSkill, generateCursorRule, generateClaudeRule, generateCodexSkill, generateCodexSkillIndex, generateClaudeSkillRouter, } from './portable-knowledge.js';
-const PB_DIR = '/tmp/pb-test/.productbrain';
-describe('readCanonicalSkills', () => {
-    beforeEach(() => {
-        Object.keys(vfs).forEach((k) => delete vfs[k]);
-    });
-    it('parses targets from frontmatter', () => {
-        vfs[join(PB_DIR, 'skills', 'test-skill.md')] = `---
-name: test-skill
-description: A test skill
-triggers:
-  - test
-targets:
-  - claude
----
-
-# Test Skill Body
-`;
-        const skills = readCanonicalSkills(PB_DIR);
-        expect(skills).toHaveLength(1);
-        expect(skills[0].targets).toEqual(['claude']);
-    });
-    it('returns undefined targets when not specified in frontmatter', () => {
-        vfs[join(PB_DIR, 'skills', 'universal-skill.md')] = `---
-name: universal-skill
-description: A universal skill
-triggers:
-  - universal
----
-
-# Universal Skill Body
-`;
-        const skills = readCanonicalSkills(PB_DIR);
-        expect(skills).toHaveLength(1);
-        expect(skills[0].targets).toBeUndefined();
-    });
-    it('parses multiple targets', () => {
-        vfs[join(PB_DIR, 'skills', 'multi-target.md')] = `---
-name: multi-target
-description: Multi-target skill
-triggers:
-  - multi
-targets:
-  - claude
-  - cursor
----
-
-# Multi-Target Body
-`;
-        const skills = readCanonicalSkills(PB_DIR);
-        expect(skills).toHaveLength(1);
-        expect(skills[0].targets).toEqual(['claude', 'cursor']);
-    });
-    it('parses level from frontmatter', () => {
-        vfs[join(PB_DIR, 'skills', 'leveled-skill.md')] = `---
-name: leveled-skill
-description: A leveled skill
-level: core
-triggers:
-  - leveled
----
-
-# Leveled Skill Body
-`;
-        const skills = readCanonicalSkills(PB_DIR);
-        expect(skills).toHaveLength(1);
-        expect(skills[0].level).toBe('core');
-    });
-    it('returns undefined level when not specified in frontmatter', () => {
-        vfs[join(PB_DIR, 'skills', 'no-level-skill.md')] = `---
-name: no-level-skill
-description: A skill without level
-triggers:
-  - nolevel
----
-
-# No Level Skill Body
-`;
-        const skills = readCanonicalSkills(PB_DIR);
-        expect(skills).toHaveLength(1);
-        expect(skills[0].level).toBeUndefined();
-    });
-});
-describe('shouldEmitToTarget', () => {
-    it('returns true when targets is undefined (emit to all)', () => {
-        const skill = {
-            name: 'test',
-            description: '',
-            triggers: [],
-            body: '',
-            sourcePath: '',
-        };
-        expect(shouldEmitToTarget(skill, 'claude')).toBe(true);
-        expect(shouldEmitToTarget(skill, 'cursor')).toBe(true);
-        expect(shouldEmitToTarget(skill, 'copilot')).toBe(true);
-        expect(shouldEmitToTarget(skill, 'codex')).toBe(true);
-    });
-    it('returns true when target is in the list', () => {
-        const skill = {
-            name: 'test',
-            description: '',
-            triggers: [],
-            body: '',
-            sourcePath: '',
-            targets: ['claude'],
-        };
-        expect(shouldEmitToTarget(skill, 'claude')).toBe(true);
-    });
-    it('returns false when target is not in the list', () => {
-        const skill = {
-            name: 'test',
-            description: '',
-            triggers: [],
-            body: '',
-            sourcePath: '',
-            targets: ['claude'],
-        };
-        expect(shouldEmitToTarget(skill, 'cursor')).toBe(false);
-        expect(shouldEmitToTarget(skill, 'copilot')).toBe(false);
-    });
-    it('works for CanonicalRule as well', () => {
-        const rule = {
-            name: 'test-rule',
-            description: '',
-            autoApply: true,
-            body: '',
-            sourcePath: '',
-            targets: ['cursor'],
-        };
-        expect(shouldEmitToTarget(rule, 'cursor')).toBe(true);
-        expect(shouldEmitToTarget(rule, 'claude')).toBe(false);
-    });
-});
-describe('stripTransportSections', () => {
-    it('keeps content for the matching target and removes delimiters', () => {
-        const body = `Universal content above.
-
-<!-- transport:claude -->
-Claude-specific instructions here.
-<!-- /transport -->
-
-Universal content below.`;
-        const result = stripTransportSections(body, 'claude');
-        expect(result).toContain('Claude-specific instructions here.');
-        expect(result).toContain('Universal content above.');
-        expect(result).toContain('Universal content below.');
-        expect(result).not.toContain('<!-- transport:claude -->');
-        expect(result).not.toContain('<!-- /transport -->');
-    });
-    it('removes blocks for other targets entirely', () => {
-        const body = `Universal content.
-
-<!-- transport:cursor -->
-Cursor-only instructions.
-<!-- /transport -->
-
-More universal.`;
-        const result = stripTransportSections(body, 'claude');
-        expect(result).toContain('Universal content.');
-        expect(result).toContain('More universal.');
-        expect(result).not.toContain('Cursor-only instructions.');
-        expect(result).not.toContain('<!-- transport:cursor -->');
-    });
-    it('handles multiple transport blocks for different targets', () => {
-        const body = `# Heading
-
-<!-- transport:claude -->
-Claude dispatch: use Agent tool.
-<!-- /transport -->
-
-<!-- transport:cursor -->
-Cursor dispatch: use fresh conversation.
-<!-- /transport -->
-
-## Footer`;
-        const claudeResult = stripTransportSections(body, 'claude');
-        expect(claudeResult).toContain('Claude dispatch: use Agent tool.');
-        expect(claudeResult).not.toContain('Cursor dispatch: use fresh conversation.');
-        expect(claudeResult).toContain('# Heading');
-        expect(claudeResult).toContain('## Footer');
-        const cursorResult = stripTransportSections(body, 'cursor');
-        expect(cursorResult).toContain('Cursor dispatch: use fresh conversation.');
-        expect(cursorResult).not.toContain('Claude dispatch: use Agent tool.');
-        expect(cursorResult).toContain('# Heading');
-        expect(cursorResult).toContain('## Footer');
-    });
-    it('keeps universal content untouched when no transport blocks exist', () => {
-        const body = `# Just a normal skill
-
-No transport sections here.
-
-## Section 2
-
-More content.`;
-        const result = stripTransportSections(body, 'claude');
-        expect(result).toBe(body);
-    });
-    it('handles markdown and code blocks inside transport sections', () => {
-        const body = `Universal.
-
-<!-- transport:claude -->
-**Bold text** and \`inline code\`.
-
-\`\`\`bash
-git diff main..HEAD
-\`\`\`
-
-- List item 1
-- List item 2
-<!-- /transport -->
-
-End.`;
-        const result = stripTransportSections(body, 'claude');
-        expect(result).toContain('**Bold text** and `inline code`.');
-        expect(result).toContain('git diff main..HEAD');
-        expect(result).toContain('- List item 1');
-        expect(result).toContain('End.');
-    });
-    it('handles transport sections with no trailing newline after closing tag', () => {
-        const body = `Before.
-<!-- transport:claude -->
-Content.
-<!-- /transport -->After.`;
-        const result = stripTransportSections(body, 'claude');
-        expect(result).toContain('Content.');
-        expect(result).toContain('After.');
-    });
-});
-describe('generateCursorSkill (transport stripping)', () => {
-    it('strips non-cursor transport sections from generated output', () => {
-        const skill = {
-            name: 'test-skill',
-            description: 'Test skill',
-            triggers: ['test'],
-            body: `# Heading
-
-<!-- transport:claude -->
-Claude-only content.
-<!-- /transport -->
-
-<!-- transport:cursor -->
-Cursor-only content.
-<!-- /transport -->
-
-Universal content.`,
-            sourcePath: '/tmp/.productbrain/skills/test-skill.md',
-        };
-        const output = generateCursorSkill(skill);
-        expect(output).toContain('Cursor-only content.');
-        expect(output).not.toContain('Claude-only content.');
-        expect(output).toContain('Universal content.');
-        expect(output).not.toContain('<!-- transport:');
-    });
-});
-describe('generateCodexSkill / generateCodexSkillIndex', () => {
-    it('strips non-codex transport sections from generated Codex skill output', () => {
-        const skill = {
-            name: 'test-skill',
-            description: 'Test skill',
-            triggers: ['test'],
-            body: `# Heading
-
-<!-- transport:claude -->
-Claude-only content.
-<!-- /transport -->
-
-<!-- transport:codex -->
-Codex-only content.
-<!-- /transport -->
-
-Universal content.`,
-            sourcePath: '/tmp/.productbrain/skills/test-skill.md',
-        };
-        const output = generateCodexSkill(skill);
-        expect(output).toContain('Codex-only content.');
-        expect(output).not.toContain('Claude-only content.');
-        expect(output).toContain('Universal content.');
-    });
-    it('generates a Codex skill index with links to projected skills', () => {
-        const skills = [
-            {
-                name: 'preflight',
-                description: 'Ground the task before changing code.',
-                triggers: ['preflight', 'system check'],
-                body: '# Preflight',
-                sourcePath: '/tmp/.productbrain/skills/preflight.md',
-            },
-        ];
-        const output = generateCodexSkillIndex(skills);
-        expect(output).toContain('Product Brain Skills for Codex');
-        expect(output).toContain('## preflight');
-        expect(output).toContain('`preflight`');
-        expect(output).toContain('Read: `.codex/skills/preflight.md`');
-    });
-    it('hides learnings and template files from the Codex skill index', () => {
-        const skills = [
-            {
-                name: 'preflight',
-                description: 'Ground the task before changing code.',
-                triggers: ['preflight'],
-                body: '# Preflight',
-                sourcePath: '/tmp/.productbrain/skills/preflight.md',
-            },
-            {
-                name: 'retro-learnings',
-                description: 'Internal learnings companion.',
-                triggers: [],
-                body: '# Retro Learnings',
-                sourcePath: '/tmp/.productbrain/skills/retro-learnings.md',
-            },
-            {
-                name: 'LEARNINGS-TEMPLATE',
-                description: 'Template',
-                triggers: [],
-                body: '# Template',
-                sourcePath: '/tmp/.productbrain/skills/LEARNINGS-TEMPLATE.md',
-            },
-        ];
-        const output = generateCodexSkillIndex(skills);
-        expect(output).toContain('## preflight');
-        expect(output).not.toContain('## retro-learnings');
-        expect(output).not.toContain('## LEARNINGS-TEMPLATE');
-        expect(output).toContain('hidden from this index');
-    });
-});
-describe('generateClaudeSkillRouter (target filtering)', () => {
-    it('includes only skills with matching or no targets', () => {
-        const claudeOnly = {
-            name: 'claude-skill',
-            description: 'Claude only',
-            triggers: ['test-claude'],
-            body: '# Claude',
-            sourcePath: '/tmp/skills/claude-skill.md',
-            targets: ['claude'],
-        };
-        const cursorOnly = {
-            name: 'cursor-skill',
-            description: 'Cursor only',
-            triggers: ['test-cursor'],
-            body: '# Cursor',
-            sourcePath: '/tmp/skills/cursor-skill.md',
-            targets: ['cursor'],
-        };
-        const universal = {
-            name: 'universal-skill',
-            description: 'Universal',
-            triggers: ['test-universal'],
-            body: '# Universal',
-            sourcePath: '/tmp/skills/universal-skill.md',
-        };
-        // Filter skills for Claude (as handshake.ts would do)
-        const claudeSkills = [claudeOnly, cursorOnly, universal].filter((s) => shouldEmitToTarget(s, 'claude'));
-        const router = generateClaudeSkillRouter(claudeSkills);
-        expect(router).toContain('claude-skill');
-        expect(router).toContain('universal-skill');
-        expect(router).not.toContain('cursor-skill');
-    });
-    it('skill with targets: [claude] does not appear in Cursor output', () => {
-        const claudeOnly = {
-            name: 'claude-exclusive',
-            description: 'Claude exclusive skill',
-            triggers: ['claude-trigger'],
-            body: '# Claude Exclusive',
-            sourcePath: '/tmp/skills/claude-exclusive.md',
-            targets: ['claude'],
-        };
-        // Filter for Cursor (as handshake.ts would do)
-        const cursorSkills = [claudeOnly].filter((s) => shouldEmitToTarget(s, 'cursor'));
-        expect(cursorSkills).toHaveLength(0);
-    });
-    it('skill with no targets appears in both Claude and Cursor output', () => {
-        const universal = {
-            name: 'universal',
-            description: 'Universal skill',
-            triggers: ['uni'],
-            body: '# Universal',
-            sourcePath: '/tmp/skills/universal.md',
-        };
-        const claudeSkills = [universal].filter((s) => shouldEmitToTarget(s, 'claude'));
-        const cursorSkills = [universal].filter((s) => shouldEmitToTarget(s, 'cursor'));
-        expect(claudeSkills).toHaveLength(1);
-        expect(cursorSkills).toHaveLength(1);
-        const router = generateClaudeSkillRouter(claudeSkills);
-        expect(router).toContain('universal');
-        const cursorOutput = generateCursorSkill(cursorSkills[0]);
-        expect(cursorOutput).toContain('universal');
-    });
-});
-describe('generateCursorRule (scope propagation)', () => {
-    const baseRule = {
-        name: 'test-rule',
-        description: 'A test rule',
-        autoApply: true,
-        body: '# Rule body content',
-        sourcePath: '/tmp/.productbrain/rules/test-rule.md',
-    };
-    it('emits empty globs and alwaysApply: true when scope is empty string', () => {
-        const rule = { ...baseRule, scope: '' };
-        const output = generateCursorRule(rule);
-        expect(output).toContain('globs: ');
-        expect(output).toContain('alwaysApply: true');
-        expect(output).toContain('# Rule body content');
-    });
-    it('emits empty globs and alwaysApply: true when scope is undefined', () => {
-        const rule = { ...baseRule };
-        const output = generateCursorRule(rule);
-        expect(output).toContain('globs: ');
-        expect(output).toContain('alwaysApply: true');
-    });
-    it('emits glob pattern and alwaysApply: false when scope is set', () => {
-        const rule = { ...baseRule, scope: 'convex/**/*.ts' };
-        const output = generateCursorRule(rule);
-        expect(output).toContain('globs: convex/**/*.ts');
-        expect(output).toContain('alwaysApply: false');
-    });
-    it('respects autoApply: false with empty scope', () => {
-        const rule = { ...baseRule, autoApply: false, scope: '' };
-        const output = generateCursorRule(rule);
-        expect(output).toContain('alwaysApply: false');
-    });
-    it('replaces .productbrain paths with .cursor paths in body', () => {
-        const rule = {
-            ...baseRule,
-            body: 'Read `.productbrain/rules/foo.md` and `.productbrain/skills/bar.md`.',
-        };
-        const output = generateCursorRule(rule);
-        expect(output).toContain('.cursor/rules/foo.mdc');
-        expect(output).toContain('.cursor/skills/bar/SKILL.md');
-        expect(output).not.toContain('.productbrain/rules/foo.md');
-    });
-    it('includes source marker comment', () => {
-        const output = generateCursorRule(baseRule);
-        expect(output).toContain('source: .productbrain/rules/test-rule.md');
-    });
-});
-describe('generateClaudeRule (scope propagation)', () => {
-    const baseRule = {
-        name: 'test-rule',
-        description: 'A test rule',
-        autoApply: true,
-        body: '# Rule body content',
-        sourcePath: '/tmp/.productbrain/rules/test-rule.md',
-    };
-    it('omits paths when scope is empty string', () => {
-        const rule = { ...baseRule, scope: '' };
-        const output = generateClaudeRule(rule);
-        expect(output).not.toContain('paths:');
-        expect(output).toContain('description: "A test rule"');
-        expect(output).toContain('# Rule body content');
-    });
-    it('omits paths when scope is undefined', () => {
-        const rule = { ...baseRule };
-        const output = generateClaudeRule(rule);
-        expect(output).not.toContain('paths:');
-    });
-    it('emits paths array when scope is set', () => {
-        const rule = { ...baseRule, scope: 'convex/**/*.ts' };
-        const output = generateClaudeRule(rule);
-        expect(output).toContain('paths:');
-        expect(output).toContain('  - "convex/**/*.ts"');
-    });
-    it('escapes quotes in description', () => {
-        const rule = { ...baseRule, description: 'Rule with "quotes" inside' };
-        const output = generateClaudeRule(rule);
-        expect(output).toContain('description: "Rule with \\"quotes\\" inside"');
-    });
-    it('replaces .productbrain paths with .claude paths in body', () => {
-        const rule = {
-            ...baseRule,
-            body: 'Read `.productbrain/rules/foo.md` for details.',
-        };
-        const output = generateClaudeRule(rule);
-        expect(output).toContain('.claude/rules/foo.md');
-        expect(output).not.toContain('.productbrain/rules/foo.md');
-    });
-    it('includes source marker comment', () => {
-        const output = generateClaudeRule(baseRule);
-        expect(output).toContain('source: .productbrain/rules/test-rule.md');
-    });
-});
-describe('generateCodexSkillIndex (empty primary skills)', () => {
-    it('shows empty message when all skills are learnings/templates', () => {
-        const skills = [
-            {
-                name: 'retro-learnings',
-                description: 'Internal learnings companion.',
-                triggers: [],
-                body: '# Retro Learnings',
-                sourcePath: '/tmp/.productbrain/skills/retro-learnings.md',
-            },
-            {
-                name: 'LEARNINGS-TEMPLATE',
-                description: 'Template',
-                triggers: [],
-                body: '# Template',
-                sourcePath: '/tmp/.productbrain/skills/LEARNINGS-TEMPLATE.md',
-            },
-        ];
-        const output = generateCodexSkillIndex(skills);
-        expect(output).toContain('No Product Brain skills are currently projected');
-    });
-});
-describe('filterByLevel', () => {
-    const items = [
-        { name: 'core-item', level: 'core' },
-        { name: 'intermediate-item', level: 'intermediate' },
-        { name: 'expert-item', level: 'expert' },
-        { name: 'no-level-item' },
-    ];
-    it('filterByLevel("beginner") returns only level:core items + items with no level', () => {
-        const result = filterByLevel(items, 'beginner');
-        const names = result.map((i) => i.name);
-        expect(names).toContain('core-item');
-        expect(names).toContain('no-level-item');
-        expect(names).not.toContain('intermediate-item');
-        expect(names).not.toContain('expert-item');
-        expect(result).toHaveLength(2);
-    });
-    it('filterByLevel("intermediate") returns core + intermediate + no level', () => {
-        const result = filterByLevel(items, 'intermediate');
-        const names = result.map((i) => i.name);
-        expect(names).toContain('core-item');
-        expect(names).toContain('intermediate-item');
-        expect(names).toContain('no-level-item');
-        expect(names).not.toContain('expert-item');
-        expect(result).toHaveLength(3);
-    });
-    it('filterByLevel("expert") returns all items', () => {
-        const result = filterByLevel(items, 'expert');
-        expect(result).toHaveLength(4);
-    });
-    it('filterByLevel(undefined) returns all items (backward compat)', () => {
-        const result = filterByLevel(items, undefined);
-        expect(result).toHaveLength(4);
-    });
-    it('filterByLevel(null-ish) returns all items (backward compat)', () => {
-        const result = filterByLevel(items);
-        expect(result).toHaveLength(4);
-    });
-    it('unknown level throws an error', () => {
-        expect(() => filterByLevel(items, 'unknown')).toThrow('Unknown level "unknown"');
-    });
-});
-describe('filterByLevel — stage-gating (DEC-443)', () => {
-    const items = [
-        { name: 'core-item', level: 'core' },
-        { name: 'intermediate-item', level: 'intermediate' },
-        { name: 'expert-item', level: 'expert' },
-        { name: 'no-level-item' },
-    ];
-    it('stage=blank caps at core even if requestedLevel=expert', () => {
-        const result = filterByLevel(items, 'expert', 'blank');
-        const names = result.map((i) => i.name);
-        expect(names).toContain('core-item');
-        expect(names).toContain('no-level-item');
-        expect(names).not.toContain('intermediate-item');
-        expect(names).not.toContain('expert-item');
-        expect(result).toHaveLength(2);
-    });
-    it('stage=seed caps at intermediate (core + intermediate + no-level)', () => {
-        const result = filterByLevel(items, 'expert', 'seed');
-        const names = result.map((i) => i.name);
-        expect(names).toContain('core-item');
-        expect(names).toContain('intermediate-item');
-        expect(names).toContain('no-level-item');
-        expect(names).not.toContain('expert-item');
-        expect(result).toHaveLength(3);
-    });
-    it('stage=grounded applies no cap — all items returned', () => {
-        const result = filterByLevel(items, 'expert', 'grounded');
-        expect(result).toHaveLength(4);
-    });
-    it('stage=connected applies no cap — all items returned', () => {
-        const result = filterByLevel(items, 'expert', 'connected');
-        expect(result).toHaveLength(4);
-    });
-    it('stage=undefined (no profile) — no cap, backward compat', () => {
-        const result = filterByLevel(items, 'expert', undefined);
-        expect(result).toHaveLength(4);
-    });
-    it('unknown stage — fail-open, no cap applied', () => {
-        const result = filterByLevel(items, 'expert', 'unknown-stage');
-        expect(result).toHaveLength(4);
-    });
-    it('no requestedLevel + stage=blank still caps at beginner (core + no-level only)', () => {
-        const result = filterByLevel(items, undefined, 'blank');
-        const names = result.map((i) => i.name);
-        expect(names).toContain('core-item');
-        expect(names).toContain('no-level-item');
-        expect(names).not.toContain('intermediate-item');
-        expect(names).not.toContain('expert-item');
-        expect(result).toHaveLength(2);
-    });
-});
-describe('evaluateConditions', () => {
-    const noProfile = null;
-    const profile = {
-        stage: 'grounded',
-        totalRelations: 10,
-    };
-    const emptyRepo = { detectedStack: [] };
-    const sveltekitRepo = { detectedStack: ['sveltekit', 'typescript'] };
-    // 1. No conditions → included
-    it('no conditions → included', () => {
-        const result = evaluateConditions({}, profile, sveltekitRepo);
-        expect(result.included).toBe(true);
-        expect(result.reasons).toEqual(['no conditions']);
-    });
-    // 2. Matching when_stack → included
-    it('matching when_stack → included', () => {
-        const result = evaluateConditions({ when_stack: 'sveltekit' }, profile, sveltekitRepo);
-        expect(result.included).toBe(true);
-        expect(result.reasons.some((r) => r.includes('matched'))).toBe(true);
-    });
-    // 3. Non-matching when_stack → excluded with reason
-    it('non-matching when_stack → excluded with reason', () => {
-        const result = evaluateConditions({ when_stack: 'nextjs' }, profile, sveltekitRepo);
-        expect(result.included).toBe(false);
-        expect(result.reasons.some((r) => r.includes('when_stack=nextjs'))).toBe(true);
-    });
-    // 4. when_stack case-insensitive matching
-    it('when_stack is case-insensitive', () => {
-        const result = evaluateConditions({ when_stack: 'SvelteKit' }, profile, { detectedStack: ['sveltekit'] });
-        expect(result.included).toBe(true);
-    });
-    // 5. when_minStage ordering: blank < seed < grounded < connected < critical
-    it('when_minStage ordering: stage below threshold → excluded', () => {
-        const seedProfile = { stage: 'seed', totalRelations: 10 };
-        const result = evaluateConditions({ when_minStage: 'grounded' }, seedProfile, emptyRepo);
-        expect(result.included).toBe(false);
-        expect(result.reasons.some((r) => r.includes('when_minStage=grounded'))).toBe(true);
-    });
-    // 6. when_minStage with stage below threshold → excluded
-    it('when_minStage blank < connected threshold → excluded', () => {
-        const blankProfile = { stage: 'blank', totalRelations: 0 };
-        const result = evaluateConditions({ when_minStage: 'connected' }, blankProfile, emptyRepo);
-        expect(result.included).toBe(false);
-    });
-    // 7. when_minStage with stage at threshold → included
-    it('when_minStage with stage exactly at threshold → included', () => {
-        const result = evaluateConditions({ when_minStage: 'grounded' }, profile, emptyRepo);
-        expect(result.included).toBe(true);
-        expect(result.reasons.some((r) => r.includes('satisfied'))).toBe(true);
-    });
-    // Also verify stages above threshold pass
-    it('when_minStage with stage above threshold → included', () => {
-        const criticalProfile = { stage: 'critical', totalRelations: 10 };
-        const result = evaluateConditions({ when_minStage: 'grounded' }, criticalProfile, emptyRepo);
-        expect(result.included).toBe(true);
-    });
-    // 8. when_minGovernance with enough relations → included
-    it('when_minGovernance with enough relations → included', () => {
-        const result = evaluateConditions({ when_minGovernance: '5' }, profile, emptyRepo);
-        expect(result.included).toBe(true);
-        expect(result.reasons.some((r) => r.includes('satisfied'))).toBe(true);
-    });
-    // 9. when_minGovernance with too few → excluded
-    it('when_minGovernance with too few relations → excluded', () => {
-        const lowRelProfile = { stage: 'grounded', totalRelations: 3 };
-        const result = evaluateConditions({ when_minGovernance: '5' }, lowRelProfile, emptyRepo);
-        expect(result.included).toBe(false);
-        expect(result.reasons.some((r) => r.includes('when_minGovernance=5'))).toBe(true);
-    });
-    // 10. Multiple conditions: all pass → included
-    it('multiple conditions: all pass → included', () => {
-        const result = evaluateConditions({ when_stack: 'sveltekit', when_minStage: 'seed', when_minGovernance: '5' }, profile, sveltekitRepo);
-        expect(result.included).toBe(true);
-    });
-    // 11. Multiple conditions: one fails → excluded (AND semantics)
-    it('multiple conditions: one fails → excluded', () => {
-        const result = evaluateConditions({ when_stack: 'sveltekit', when_minStage: 'critical' }, profile, // stage=grounded, below critical
-        sveltekitRepo);
-        expect(result.included).toBe(false);
-        expect(result.reasons.some((r) => r.includes('when_minStage=critical'))).toBe(true);
-    });
-    // 12. Null profile + when_minStage → included (fail-open)
-    it('null profile with when_minStage → fail-open (included)', () => {
-        const result = evaluateConditions({ when_minStage: 'grounded' }, noProfile, emptyRepo);
-        expect(result.included).toBe(true);
-        expect(result.reasons.some((r) => r.includes('fail-open'))).toBe(true);
-    });
-    // 13. Null profile + when_stack only → still evaluated (stack comes from repoContext)
-    it('null profile with when_stack only → still evaluated from repoContext', () => {
-        const matchResult = evaluateConditions({ when_stack: 'sveltekit' }, noProfile, sveltekitRepo);
-        expect(matchResult.included).toBe(true);
-        const noMatchResult = evaluateConditions({ when_stack: 'nextjs' }, noProfile, sveltekitRepo);
-        expect(noMatchResult.included).toBe(false);
-    });
-});
-describe('BET-170 acceptance criteria — integration', () => {
-    /**
-     * Mock rules cover all combinations: stack condition, stage condition,
-     * governance condition, and unconditional at core/intermediate/expert levels.
-     */
-    const mockRules = [
-        { name: 'deployment', level: 'core', conditions: { when_stack: 'sveltekit' } },
-        { name: 'feature-flags', level: 'intermediate', conditions: { when_minStage: 'grounded' } },
-        { name: 'domain-boundaries', level: 'expert', conditions: { when_minGovernance: '5' } },
-        { name: 'code-integrity', level: 'core' }, // no conditions — always included
-        { name: 'review-gate', level: 'intermediate' }, // no conditions
-        { name: 'orchestrator-mode', level: 'expert' }, // no conditions
-    ];
-    function applyPipeline(rules, profile, repo) {
-        const profileStage = profile?.stage;
-        // stage-gated level filter: no requestedLevel (defaults to widest), stage caps it
-        const levelFiltered = filterByLevel(rules, undefined, profileStage);
-        // condition filter
-        return levelFiltered.filter((rule) => {
-            const result = evaluateConditions(rule.conditions ?? {}, profile, repo);
-            return result.included;
-        });
-    }
-    // AC1: Fresh Python workspace (stage=blank, 0 entries) — only core items with no conditions
-    it('AC1: stage=blank, python — only core unconditional items', () => {
-        const profile = { stage: 'blank', totalEntries: 0, totalRelations: 0 };
-        const repo = { detectedStack: ['python'] };
-        const result = applyPipeline(mockRules, profile, repo);
-        const names = result.map((r) => r.name);
-        // Only code-integrity: core level, no conditions
-        // deployment: core but when_stack=sveltekit fails (python != sveltekit)
-        expect(names).toContain('code-integrity');
-        expect(names).not.toContain('deployment'); // core but sveltekit condition fails
-        expect(names).not.toContain('feature-flags'); // intermediate — capped by blank stage
-        expect(names).not.toContain('domain-boundaries'); // expert — capped by blank stage
-        expect(names).not.toContain('review-gate'); // intermediate — capped by blank stage
-        expect(names).not.toContain('orchestrator-mode'); // expert — capped by blank stage
-        expect(result).toHaveLength(1);
-    });
-    // AC2: Node/TS workspace (stage=grounded, 30 entries) — stack-matched, all levels
-    it('AC2: stage=grounded, sveltekit/typescript, 30 entries — all rules included', () => {
-        const profile = { stage: 'grounded', totalEntries: 30, totalRelations: 15 };
-        const repo = { detectedStack: ['typescript', 'sveltekit'] };
-        const result = applyPipeline(mockRules, profile, repo);
-        const names = result.map((r) => r.name);
-        // All conditions pass: sveltekit matches, grounded >= grounded, 15 >= 5
-        expect(names).toContain('deployment');
-        expect(names).toContain('feature-flags');
-        expect(names).toContain('domain-boundaries');
-        expect(names).toContain('code-integrity');
-        expect(names).toContain('review-gate');
-        expect(names).toContain('orchestrator-mode');
-        expect(result).toHaveLength(6);
-    });
-    // AC3: Mature workspace (stage=connected, 100+ entries) — all rules and skills
-    it('AC3: stage=connected, 150 entries — all rules projected without filtering', () => {
-        const profile = { stage: 'connected', totalEntries: 150, totalRelations: 80 };
-        const repo = { detectedStack: ['typescript', 'sveltekit'] };
-        const result = applyPipeline(mockRules, profile, repo);
-        expect(result).toHaveLength(6);
-    });
-    // AC4: Unknown stack — general template set, no stack-specific rules
-    it('AC4: stage=grounded, unknown stack — only non-stack-conditional rules', () => {
-        const profile = { stage: 'grounded', totalEntries: 30, totalRelations: 15 };
-        const repo = { detectedStack: [] };
-        const result = applyPipeline(mockRules, profile, repo);
-        const names = result.map((r) => r.name);
-        // deployment requires sveltekit stack — excluded
-        // all others: feature-flags (grounded ok), domain-boundaries (15 >= 5), unconditionals all pass
-        expect(names).not.toContain('deployment');
-        expect(names).toContain('feature-flags');
-        expect(names).toContain('domain-boundaries');
-        expect(names).toContain('code-integrity');
-        expect(names).toContain('review-gate');
-        expect(names).toContain('orchestrator-mode');
-        expect(result).toHaveLength(5);
-    });
-    // AC5: workspaceReadiness failure (null profile) — fail-open, all rules/skills project
-    it('AC5: null profile (readiness failure) — fail-open, profile conditions pass', () => {
-        const profile = null;
-        const repo = { detectedStack: ['typescript'] };
-        const result = applyPipeline(mockRules, profile, repo);
-        const names = result.map((r) => r.name);
-        // Null profile:
-        // - filterByLevel: no stage cap → all levels pass
-        // - evaluateConditions: when_minStage + when_minGovernance → fail-open (included)
-        // - when_stack: still evaluated against repoContext; sveltekit not in [typescript] → excluded
-        expect(names).not.toContain('deployment'); // when_stack=sveltekit, typescript doesn't match
-        expect(names).toContain('feature-flags'); // fail-open (profile null)
-        expect(names).toContain('domain-boundaries'); // fail-open (profile null)
-        expect(names).toContain('code-integrity');
-        expect(names).toContain('review-gate');
-        expect(names).toContain('orchestrator-mode');
-        expect(result).toHaveLength(5);
-    });
-    // Scale test: 0/5/50/500 entries — filtering correctness at different entry counts
-    it('scale test: filtering correctness at 0/5/50/500 totalEntries', () => {
-        const repo = { detectedStack: ['sveltekit'] };
-        // 0 entries: blank stage, low relations
-        // deployment: core level (passes stage cap), sveltekit matches → included
-        // code-integrity: core level, no conditions → included
-        // everything else: capped by blank stage (intermediate/expert excluded)
-        const result0 = applyPipeline(mockRules, { stage: 'blank', totalEntries: 0, totalRelations: 0 }, repo);
-        const names0 = result0.map((r) => r.name);
-        expect(names0).toContain('deployment');
-        expect(names0).toContain('code-integrity');
-        expect(names0).not.toContain('feature-flags'); // intermediate — capped
-        expect(names0).not.toContain('domain-boundaries'); // expert — capped
-        expect(names0).not.toContain('review-gate'); // intermediate — capped
-        expect(names0).not.toContain('orchestrator-mode'); // expert — capped
-        expect(result0).toHaveLength(2);
-        // 5 entries: seed stage, 2 relations (below governance threshold)
-        const result5 = applyPipeline(mockRules, { stage: 'seed', totalEntries: 5, totalRelations: 2 }, repo);
-        const names5 = result5.map((r) => r.name);
-        // seed caps at intermediate; domain-boundaries (expert) + orchestrator-mode (expert) excluded
-        // domain-boundaries also fails governance (2 < 5)
-        // feature-flags: intermediate ok, but when_minStage=grounded fails for seed → excluded
-        // deployment: core ok, sveltekit matches → included
-        expect(names5).toContain('deployment');
-        expect(names5).toContain('code-integrity');
-        expect(names5).toContain('review-gate');
-        expect(names5).not.toContain('domain-boundaries');
-        expect(names5).not.toContain('orchestrator-mode');
-        expect(names5).not.toContain('feature-flags');
-        // 50 entries: grounded stage, 20 relations
-        const result50 = applyPipeline(mockRules, { stage: 'grounded', totalEntries: 50, totalRelations: 20 }, repo);
-        expect(result50).toHaveLength(6);
-        // 500 entries: connected stage, 200 relations
-        const result500 = applyPipeline(mockRules, { stage: 'connected', totalEntries: 500, totalRelations: 200 }, repo);
-        expect(result500).toHaveLength(6);
-    });
-});
-describe('readCanonicalRules — backward compat with when_* frontmatter', () => {
-    beforeEach(() => {
-        Object.keys(vfs).forEach((k) => delete vfs[k]);
-    });
-    it('parses when_stack from frontmatter into conditions', () => {
-        vfs[join(PB_DIR, 'rules', 'deploy.md')] = `---
-name: deploy
-description: Deploy rule
-scope: ""
-autoApply: true
-when_stack: sveltekit
----
-
-# Deploy body
-`;
-        const rules = readCanonicalRules(PB_DIR);
-        expect(rules).toHaveLength(1);
-        expect(rules[0].conditions?.when_stack).toBe('sveltekit');
-    });
-    it('parses when_minStage from frontmatter into conditions', () => {
-        vfs[join(PB_DIR, 'rules', 'flags.md')] = `---
-name: flags
-description: Feature flags rule
-scope: ""
-autoApply: false
-when_minStage: grounded
----
-
-# Flags body
-`;
-        const rules = readCanonicalRules(PB_DIR);
-        expect(rules).toHaveLength(1);
-        expect(rules[0].conditions?.when_minStage).toBe('grounded');
-    });
-    it('parses when_minGovernance from frontmatter into conditions', () => {
-        vfs[join(PB_DIR, 'rules', 'domains.md')] = `---
-name: domains
-description: Domain boundaries rule
-scope: ""
-autoApply: true
-when_minGovernance: 5
----
-
-# Domains body
-`;
-        const rules = readCanonicalRules(PB_DIR);
-        expect(rules).toHaveLength(1);
-        expect(rules[0].conditions?.when_minGovernance).toBe('5');
-    });
-    it('returns undefined conditions when no when_* keys are present (backward compat)', () => {
-        vfs[join(PB_DIR, 'rules', 'plain.md')] = `---
-name: plain
-description: Plain rule
-scope: ""
-autoApply: true
----
-
-# Plain body
-`;
-        const rules = readCanonicalRules(PB_DIR);
-        expect(rules).toHaveLength(1);
-        expect(rules[0].conditions).toBeUndefined();
-    });
-});
-//# sourceMappingURL=portable-knowledge.test.js.map