@productbrain/cli 0.1.0-beta.15 → 0.1.0-beta.20

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

@@ -39,7 +39,7 @@ vi.mock('fs', () => ({
         return [...files];
     }),
 }));
-import { readCanonicalSkills, shouldEmitToTarget, stripTransportSections, filterByLevel, generateCursorSkill, generateClaudeSkillRouter, } from './portable-knowledge.js';
+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(() => {
@@ -134,6 +134,7 @@ describe('shouldEmitToTarget', () => {
         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 = {
@@ -292,6 +293,77 @@ 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 = {
@@ -355,6 +427,120 @@ describe('generateClaudeSkillRouter (target filtering)', () => {
         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' },
@@ -396,4 +582,346 @@ describe('filterByLevel', () => {
         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