@productbrain/cli 0.1.0-beta.5 → 0.1.0-beta.5060

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

@@ -0,0 +1,970 @@
+/**
+ * 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';
+import { generateCopilotInstructionFiles, MARKER } from './adapters.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();
+    });
+});
+describe('readCanonicalRules → generateCopilotInstructionFiles (DEC-1343 integration)', () => {
+    beforeEach(() => {
+        Object.keys(vfs).forEach((k) => delete vfs[k]);
+    });
+    it('parses applyTo and projects a path-scoped Copilot instruction file end to end', () => {
+        vfs[join(PB_DIR, 'rules', 'security-boundaries.md')] = `---
+name: security-boundaries
+description: Security boundaries
+applyTo: "convex/**/*.ts"
+level: core
+---
+
+# Security Boundaries
+
+Scope every workspace read by workspaceId at the index level. Fail closed.
+`;
+        const rules = readCanonicalRules(PB_DIR);
+        expect(rules).toHaveLength(1);
+        expect(rules[0].applyTo).toBe('convex/**/*.ts');
+        const files = generateCopilotInstructionFiles(rules.map((r) => ({ name: r.name, body: r.body, applyTo: r.applyTo, sourcePath: r.sourcePath })), '2026-06-22T00:00:00.000Z');
+        expect(files).toHaveLength(1);
+        expect(files[0].relativePath).toBe('.github/instructions/security-boundaries.instructions.md');
+        expect(files[0].content).toContain('applyTo: "convex/**/*.ts"');
+        expect(files[0].content).toContain('Scope every workspace read by workspaceId at the index level.');
+        expect(files[0].content).toContain(MARKER);
+    });
+    it('leaves a rule without applyTo out of the instruction-file set (repo-wide only)', () => {
+        vfs[join(PB_DIR, 'rules', 'git-workflow.md')] = `---
+name: git-workflow
+description: Git workflow
+level: core
+---
+
+# Git Workflow
+
+One logical change per PR.
+`;
+        const rules = readCanonicalRules(PB_DIR);
+        const files = generateCopilotInstructionFiles(rules.map((r) => ({ name: r.name, body: r.body, applyTo: r.applyTo, sourcePath: r.sourcePath })), '2026-06-22T00:00:00.000Z');
+        expect(files).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=portable-knowledge.test.js.map