popeye-cli 2.0.0 → 2.2.0

package/tests/pipeline/bridges/review-bridge.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Review Bridge tests — severity mapping, category mapping, CR routing,
+ * pipeline detection, finding conversion.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  mapSeverity,
+  mapCategory,
+  categoryToChangeType,
+  convertFinding,
+  isPipelineManaged,
+  extractPipelineState,
+} from '../../../src/pipeline/bridges/review-bridge.js';
+import { createDefaultPipelineState } from '../../../src/pipeline/types.js';
+import type { AuditFinding as WorkflowFinding } from '../../../src/types/audit.js';
+import type { ArtifactRef } from '../../../src/pipeline/types.js';
+import type { ProjectState } from '../../../src/types/workflow.js';
+
+// ─── Test Data ───────────────────────────────────────────
+
+function makeSnapshotRef(): ArtifactRef {
+  return {
+    artifact_id: 'snap-001',
+    path: 'docs/snapshots/repo_snapshot_001.json',
+    sha256: 'abc123',
+    version: 1,
+    type: 'repo_snapshot',
+  };
+}
+
+function makeWorkflowFinding(overrides: Partial<WorkflowFinding> = {}): WorkflowFinding {
+  return {
+    id: 'finding-1',
+    category: 'integration-wiring',
+    severity: 'critical',
+    title: 'API endpoint mismatch',
+    description: 'Frontend calls /api/users but backend serves /api/v1/users',
+    evidence: [{ file: 'src/api.ts', line: 42, snippet: 'fetch("/api/users")' }],
+    recommendation: 'Update frontend API base URL',
+    autoFixable: true,
+    ...overrides,
+  };
+}
+
+function makeProjectState(withPipeline = false): ProjectState {
+  const base: ProjectState = {
+    id: 'test-id',
+    name: 'test-project',
+    idea: 'Build something',
+    language: 'python',
+    phase: 'execution',
+    status: 'in-progress',
+    milestones: [],
+    currentMilestone: null,
+    currentTask: null,
+    consensusHistory: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as ProjectState;
+
+  if (withPipeline) {
+    (base as unknown as { pipeline: unknown }).pipeline = createDefaultPipelineState();
+  }
+
+  return base;
+}
+
+// ─── Tests ───────────────────────────────────────────────
+
+describe('Review Bridge', () => {
+  describe('severity mapping', () => {
+    it('should map critical to P0', () => {
+      expect(mapSeverity('critical')).toBe('P0');
+    });
+
+    it('should map major to P1', () => {
+      expect(mapSeverity('major')).toBe('P1');
+    });
+
+    it('should map minor to P2', () => {
+      expect(mapSeverity('minor')).toBe('P2');
+    });
+
+    it('should map info to P3', () => {
+      expect(mapSeverity('info')).toBe('P3');
+    });
+  });
+
+  describe('category mapping', () => {
+    it('should map integration-wiring to integration', () => {
+      expect(mapCategory('integration-wiring')).toBe('integration');
+    });
+
+    it('should map feature-completeness to integration', () => {
+      expect(mapCategory('feature-completeness')).toBe('integration');
+    });
+
+    it('should map test-coverage to tests', () => {
+      expect(mapCategory('test-coverage')).toBe('tests');
+    });
+
+    it('should map config-deployment to config', () => {
+      expect(mapCategory('config-deployment')).toBe('config');
+    });
+
+    it('should map security to security', () => {
+      expect(mapCategory('security')).toBe('security');
+    });
+
+    it('should map dependency-sanity to deployment', () => {
+      expect(mapCategory('dependency-sanity')).toBe('deployment');
+    });
+
+    it('should map consistency to schema', () => {
+      expect(mapCategory('consistency')).toBe('schema');
+    });
+
+    it('should map documentation to deployment', () => {
+      expect(mapCategory('documentation')).toBe('deployment');
+    });
+  });
+
+  describe('CR change type routing', () => {
+    it('should route integration to architecture CR', () => {
+      expect(categoryToChangeType('integration')).toBe('architecture');
+    });
+
+    it('should route schema to architecture CR', () => {
+      expect(categoryToChangeType('schema')).toBe('architecture');
+    });
+
+    it('should route security to requirement CR', () => {
+      expect(categoryToChangeType('security')).toBe('requirement');
+    });
+
+    it('should route tests to config CR', () => {
+      expect(categoryToChangeType('tests')).toBe('config');
+    });
+
+    it('should route config to config CR', () => {
+      expect(categoryToChangeType('config')).toBe('config');
+    });
+
+    it('should route deployment to config CR', () => {
+      expect(categoryToChangeType('deployment')).toBe('config');
+    });
+  });
+
+  describe('finding conversion', () => {
+    it('should convert a critical workflow finding to P0 pipeline finding', () => {
+      const wf = makeWorkflowFinding({ severity: 'critical', category: 'integration-wiring' });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.id).toBe('finding-1');
+      expect(pf.severity).toBe('P0');
+      expect(pf.category).toBe('integration');
+      expect(pf.blocking).toBe(true);
+      expect(pf.description).toContain('API endpoint mismatch');
+      expect(pf.file_path).toBe('src/api.ts');
+      expect(pf.line_number).toBe(42);
+      expect(pf.evidence).toEqual([ref]);
+      expect(pf.suggested_owner).toBe('AUDITOR');
+    });
+
+    it('should convert an info finding to P3 non-blocking', () => {
+      const wf = makeWorkflowFinding({ severity: 'info', category: 'documentation' });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.severity).toBe('P3');
+      expect(pf.blocking).toBe(false);
+    });
+
+    it('should mark P0 and P1 as blocking, P2 and P3 as non-blocking', () => {
+      const ref = makeSnapshotRef();
+
+      expect(convertFinding(makeWorkflowFinding({ severity: 'critical' }), ref).blocking).toBe(true);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'major' }), ref).blocking).toBe(true);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'minor' }), ref).blocking).toBe(false);
+      expect(convertFinding(makeWorkflowFinding({ severity: 'info' }), ref).blocking).toBe(false);
+    });
+
+    it('should handle finding with no evidence', () => {
+      const wf = makeWorkflowFinding({ evidence: [] });
+      const ref = makeSnapshotRef();
+
+      const pf = convertFinding(wf, ref);
+
+      expect(pf.file_path).toBeUndefined();
+      expect(pf.line_number).toBeUndefined();
+    });
+  });
+
+  describe('pipeline detection', () => {
+    it('should detect pipeline-managed state', () => {
+      const state = makeProjectState(true);
+      expect(isPipelineManaged(state)).toBe(true);
+    });
+
+    it('should detect non-pipeline state', () => {
+      const state = makeProjectState(false);
+      expect(isPipelineManaged(state)).toBe(false);
+    });
+
+    it('should extract pipeline state when present', () => {
+      const state = makeProjectState(true);
+      const pipeline = extractPipelineState(state);
+
+      expect(pipeline).toBeDefined();
+      expect(pipeline!.pipelinePhase).toBe('INTAKE');
+    });
+
+    it('should return undefined when no pipeline state', () => {
+      const state = makeProjectState(false);
+      expect(extractPipelineState(state)).toBeUndefined();
+    });
+  });
+
+  describe('CR routing determinism', () => {
+    it('should route integration findings to CONSENSUS_ARCHITECTURE', () => {
+      // Integration → architecture CR → CONSENSUS_ARCHITECTURE (via change-request.ts routing)
+      const changeType = categoryToChangeType('integration');
+      expect(changeType).toBe('architecture');
+      // architecture routes to CONSENSUS_ARCHITECTURE per CHANGE_TYPE_ROUTING
+    });
+
+    it('should route security findings to CONSENSUS_MASTER_PLAN', () => {
+      const changeType = categoryToChangeType('security');
+      expect(changeType).toBe('requirement');
+      // requirement routes to CONSENSUS_MASTER_PLAN per CHANGE_TYPE_ROUTING
+    });
+
+    it('should route test findings to QA_VALIDATION', () => {
+      const changeType = categoryToChangeType('tests');
+      expect(changeType).toBe('config');
+      // config routes to QA_VALIDATION per CHANGE_TYPE_ROUTING
+    });
+  });
+});

package/tests/pipeline/migration.test.ts

@@ -95,8 +95,9 @@ describe('Migration', () => {
 
       expect(pipeline.activeRoles).toContain('DISPATCHER');
       expect(pipeline.activeRoles).toContain('ARCHITECT');
-      expect(pipeline.activeRoles).toContain('BACKEND_PROGRAMMER');
-      expect(pipeline.activeRoles).not.toContain('FRONTEND_PROGRAMMER');
+      expect(pipeline.activeRoles).toContain('FRONTEND_PROGRAMMER');
+      expect(pipeline.activeRoles).toContain('UI_UX_SPECIALIST');
+      expect(pipeline.activeRoles).not.toContain('BACKEND_PROGRAMMER');
     });
 
     it('should derive roles for fullstack project', () => {
@@ -106,8 +107,8 @@ describe('Migration', () => {
       expect(pipeline.activeRoles).toContain('DB_EXPERT');
       expect(pipeline.activeRoles).toContain('BACKEND_PROGRAMMER');
       expect(pipeline.activeRoles).toContain('FRONTEND_PROGRAMMER');
-      expect(pipeline.activeRoles).toContain('WEBSITE_PROGRAMMER');
       expect(pipeline.activeRoles).toContain('UI_UX_SPECIALIST');
+      expect(pipeline.activeRoles).not.toContain('WEBSITE_PROGRAMMER');
     });
 
     it('should derive roles for website project', () => {

package/tests/pipeline/session-guidance.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Fix A tests — sessionGuidance threading through pipeline.
+ * Verifies additionalContext persists in PipelineState and reaches phases.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  createDefaultPipelineState,
+  PipelineStateSchema,
+  ArtifactTypeSchema,
+} from '../../src/pipeline/types.js';
+
+describe('Fix A: sessionGuidance threading', () => {
+  describe('PipelineState.sessionGuidance', () => {
+    it('should accept sessionGuidance in pipeline state', () => {
+      const state = createDefaultPipelineState();
+      state.sessionGuidance = 'Upgrade from v1 to v2: preserve API backwards compat';
+
+      const result = PipelineStateSchema.safeParse(state);
+      expect(result.success).toBe(true);
+      expect(result.data?.sessionGuidance).toBe(
+        'Upgrade from v1 to v2: preserve API backwards compat',
+      );
+    });
+
+    it('should allow omitting sessionGuidance (backward compat)', () => {
+      const state = createDefaultPipelineState();
+      // No sessionGuidance set
+
+      const result = PipelineStateSchema.safeParse(state);
+      expect(result.success).toBe(true);
+      expect(result.data?.sessionGuidance).toBeUndefined();
+    });
+
+    it('should allow empty string for sessionGuidance', () => {
+      const state = createDefaultPipelineState();
+      state.sessionGuidance = '';
+
+      const result = PipelineStateSchema.safeParse(state);
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('additional_context artifact type', () => {
+    it('should accept additional_context as valid artifact type', () => {
+      const result = ArtifactTypeSchema.safeParse('additional_context');
+      expect(result.success).toBe(true);
+    });
+
+    it('should still accept all existing artifact types', () => {
+      const existingTypes = [
+        'master_plan', 'architecture', 'role_plan', 'consensus',
+        'arbitration', 'audit_report', 'rca_report', 'production_readiness',
+        'change_request',
+      ];
+
+      for (const type of existingTypes) {
+        expect(ArtifactTypeSchema.safeParse(type).success).toBe(true);
+      }
+    });
+  });
+
+  describe('PipelineOptions additionalContext -> sessionGuidance', () => {
+    it('should store additionalContext in pipeline state when not already set', () => {
+      const pipeline = createDefaultPipelineState();
+      const additionalContext = 'Focus on mobile-first responsive design';
+
+      // Simulates orchestrator logic
+      if (additionalContext && !pipeline.sessionGuidance) {
+        pipeline.sessionGuidance = additionalContext;
+      }
+
+      expect(pipeline.sessionGuidance).toBe('Focus on mobile-first responsive design');
+    });
+
+    it('should not overwrite existing sessionGuidance on resume', () => {
+      const pipeline = createDefaultPipelineState();
+      pipeline.sessionGuidance = 'Original guidance from first run';
+      const additionalContext = 'New guidance on resume';
+
+      // Simulates orchestrator logic
+      if (additionalContext && !pipeline.sessionGuidance) {
+        pipeline.sessionGuidance = additionalContext;
+      }
+
+      expect(pipeline.sessionGuidance).toBe('Original guidance from first run');
+    });
+
+    it('should leave sessionGuidance undefined when no additionalContext', () => {
+      const pipeline = createDefaultPipelineState();
+      const additionalContext: string | undefined = undefined;
+
+      if (additionalContext && !pipeline.sessionGuidance) {
+        pipeline.sessionGuidance = additionalContext;
+      }
+
+      expect(pipeline.sessionGuidance).toBeUndefined();
+    });
+  });
+
+  describe('INTAKE phase guidance injection', () => {
+    it('should prepend guidance to plan input when provided', () => {
+      const guidance = 'Upgrade context: migrate from Express to Fastify';
+      const expandedIdea = 'Build a REST API with user authentication';
+
+      const planInput = guidance
+        ? `${guidance}\n\n---\n\n${expandedIdea}`
+        : expandedIdea;
+
+      expect(planInput).toContain(guidance);
+      expect(planInput).toContain('---');
+      expect(planInput).toContain(expandedIdea);
+      expect(planInput.indexOf(guidance)).toBeLessThan(planInput.indexOf(expandedIdea));
+    });
+
+    it('should pass through expandedIdea unchanged when no guidance', () => {
+      const guidance = '';
+      const expandedIdea = 'Build a REST API with user authentication';
+
+      const planInput = guidance
+        ? `${guidance}\n\n---\n\n${expandedIdea}`
+        : expandedIdea;
+
+      expect(planInput).toBe(expandedIdea);
+    });
+  });
+
+  describe('IMPLEMENTATION phase guidance injection', () => {
+    it('should merge role prompt with guidance', () => {
+      const combinedRolePrompt = '## BACKEND_PROGRAMMER\nScope: API endpoints';
+      const guidance = 'Preserve backwards compatibility with v1 API';
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toContain(combinedRolePrompt);
+      expect(systemPrompt).toContain(guidance);
+    });
+
+    it('should use only role prompt when no guidance', () => {
+      const combinedRolePrompt = '## BACKEND_PROGRAMMER\nScope: API endpoints';
+      const guidance: string | undefined = undefined;
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toBe(combinedRolePrompt);
+    });
+
+    it('should use only guidance when no role prompt', () => {
+      const combinedRolePrompt = '';
+      const guidance = 'Focus on performance';
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toBe(guidance);
+    });
+
+    it('should return undefined when neither role prompt nor guidance', () => {
+      const combinedRolePrompt = '';
+      const guidance: string | undefined = undefined;
+
+      const systemPrompt = [combinedRolePrompt, guidance].filter(Boolean).join('\n\n') || undefined;
+
+      expect(systemPrompt).toBeUndefined();
+    });
+  });
+
+  describe('RECOVERY_LOOP guidance in RCA prompt', () => {
+    it('should include user guidance in RCA prompt when available', () => {
+      const debuggerPrompt = 'You are a debugger agent...';
+      const guidance = 'User wants API backwards compat preserved';
+      const failureEvidence = 'Failed phase: QA_VALIDATION';
+
+      const rcaPrompt = [
+        debuggerPrompt,
+        '',
+        ...(guidance ? ['## User Guidance', guidance, ''] : []),
+        '## Failure Evidence',
+        failureEvidence,
+      ].join('\n');
+
+      expect(rcaPrompt).toContain('## User Guidance');
+      expect(rcaPrompt).toContain(guidance);
+      expect(rcaPrompt.indexOf('User Guidance')).toBeLessThan(
+        rcaPrompt.indexOf('Failure Evidence'),
+      );
+    });
+
+    it('should omit User Guidance section when no guidance', () => {
+      const debuggerPrompt = 'You are a debugger agent...';
+      const guidance: string | undefined = undefined;
+      const failureEvidence = 'Failed phase: QA_VALIDATION';
+
+      const rcaPrompt = [
+        debuggerPrompt,
+        '',
+        ...(guidance ? ['## User Guidance', guidance, ''] : []),
+        '## Failure Evidence',
+        failureEvidence,
+      ].join('\n');
+
+      expect(rcaPrompt).not.toContain('## User Guidance');
+      expect(rcaPrompt).toContain('## Failure Evidence');
+    });
+  });
+});

package/tests/pipeline/skills/constitution-generator.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Constitution generator tests — deterministic template generation, skip logic.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  generateConstitution,
+  shouldSkipConstitution,
+  getTechStackSection,
+  getArchitectureRules,
+  getCodeQualityRules,
+  getConstraintsSection,
+} from '../../../src/pipeline/skills/constitution-generator.js';
+import type { ConstitutionContext } from '../../../src/pipeline/skills/types.js';
+
+const TEST_DIR = join(process.cwd(), '.test-constitution-gen');
+const SKILLS_DIR = join(TEST_DIR, 'skills');
+
+function makeContext(overrides: Partial<ConstitutionContext> = {}): ConstitutionContext {
+  return {
+    language: 'python',
+    projectName: 'TestProject',
+    techStack: {
+      language: 'Python 3.11+',
+      backend: 'FastAPI',
+      database: 'PostgreSQL',
+      orm: 'SQLAlchemy',
+      testing: 'Pytest',
+    },
+    expandedSpec: 'Build a REST API',
+    skillsDir: SKILLS_DIR,
+    ...overrides,
+  };
+}
+
+describe('constitution-generator', () => {
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(SKILLS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  describe('shouldSkipConstitution', () => {
+    it('should return false when constitution does not exist', () => {
+      expect(shouldSkipConstitution(SKILLS_DIR)).toBe(false);
+    });
+
+    it('should return true when constitution already exists', () => {
+      writeFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'existing');
+      expect(shouldSkipConstitution(SKILLS_DIR)).toBe(true);
+    });
+  });
+
+  describe('generateConstitution', () => {
+    it('should create POPEYE_CONSTITUTION.md', () => {
+      generateConstitution(makeContext());
+      const path = join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md');
+      expect(existsSync(path)).toBe(true);
+    });
+
+    it('should include project name in header', () => {
+      generateConstitution(makeContext());
+      const content = readFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'utf-8');
+      expect(content).toContain('# Project Constitution: TestProject');
+    });
+
+    it('should include tech stack section', () => {
+      generateConstitution(makeContext());
+      const content = readFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'utf-8');
+      expect(content).toContain('## Tech Stack');
+      expect(content).toContain('FastAPI');
+      expect(content).toContain('PostgreSQL');
+      expect(content).toContain('SQLAlchemy');
+    });
+
+    it('should include governance rules', () => {
+      generateConstitution(makeContext());
+      const content = readFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'utf-8');
+      expect(content).toContain('## Governance Rules');
+      expect(content).toContain('Consensus threshold: 0.95');
+      expect(content).toContain('immutable once stored');
+      expect(content).toContain('No placeholder content');
+    });
+
+    it('should include immutability notice', () => {
+      generateConstitution(makeContext());
+      const content = readFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'utf-8');
+      expect(content).toContain('## Immutability');
+      expect(content).toContain('MUST NOT be modified during pipeline execution');
+    });
+
+    it('should not overwrite existing constitution', () => {
+      writeFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'hand-written content');
+      generateConstitution(makeContext());
+      const content = readFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'utf-8');
+      expect(content).toBe('hand-written content');
+    });
+
+    it('should include session guidance when provided', () => {
+      generateConstitution(makeContext({ sessionGuidance: 'Focus on security' }));
+      const content = readFileSync(join(SKILLS_DIR, 'POPEYE_CONSTITUTION.md'), 'utf-8');
+      expect(content).toContain('Focus on security');
+    });
+
+    it('should create skills dir if it does not exist', () => {
+      rmSync(SKILLS_DIR, { recursive: true });
+      expect(existsSync(SKILLS_DIR)).toBe(false);
+      generateConstitution(makeContext());
+      expect(existsSync(SKILLS_DIR)).toBe(true);
+    });
+  });
+
+  describe('getTechStackSection', () => {
+    it('should list all available tech stack fields', () => {
+      const section = getTechStackSection({
+        language: 'Python 3.11+',
+        backend: 'FastAPI',
+        database: 'PostgreSQL',
+        orm: 'SQLAlchemy',
+        testing: 'Pytest',
+      });
+      expect(section).toContain('- Language: Python 3.11+');
+      expect(section).toContain('- Framework: FastAPI');
+      expect(section).toContain('- Database: PostgreSQL');
+      expect(section).toContain('- ORM: SQLAlchemy');
+      expect(section).toContain('- Testing: Pytest');
+    });
+
+    it('should skip undefined fields', () => {
+      const section = getTechStackSection({ language: 'Python 3.11+' });
+      expect(section).toContain('- Language: Python 3.11+');
+      expect(section).not.toContain('Framework');
+      expect(section).not.toContain('Database');
+    });
+  });
+
+  describe('getArchitectureRules', () => {
+    it('should include FastAPI async rule for FastAPI projects', () => {
+      const rules = getArchitectureRules({ backend: 'FastAPI' });
+      expect(rules).toContain('async/await');
+    });
+
+    it('should include SQLAlchemy rule for SQLAlchemy projects', () => {
+      const rules = getArchitectureRules({ orm: 'SQLAlchemy' });
+      expect(rules).toContain('SQLAlchemy ORM');
+    });
+
+    it('should include Python-specific rules', () => {
+      const rules = getArchitectureRules({ language: 'Python 3.11+' });
+      expect(rules).toContain('PEP8');
+      expect(rules).toContain('python-dotenv');
+    });
+
+    it('should include TypeScript-specific rules', () => {
+      const rules = getArchitectureRules({ language: 'TypeScript 5.x' });
+      expect(rules).toContain('strict mode');
+    });
+
+    it('should provide generic rules when no tech matches', () => {
+      const rules = getArchitectureRules({});
+      expect(rules).toContain('Environment variables');
+    });
+  });
+
+  describe('getCodeQualityRules', () => {
+    it('should include file size limit', () => {
+      const rules = getCodeQualityRules();
+      expect(rules).toContain('500 lines');
+    });
+
+    it('should include test requirements', () => {
+      const rules = getCodeQualityRules();
+      expect(rules).toContain('Unit tests');
+    });
+  });
+
+  describe('getConstraintsSection', () => {
+    it('should include Python constraints for python language', () => {
+      const section = getConstraintsSection('python');
+      expect(section).toContain('Python 3.11+');
+      expect(section).toContain('venv');
+    });
+
+    it('should include TypeScript constraints for typescript', () => {
+      const section = getConstraintsSection('typescript');
+      expect(section).toContain('Node.js 18+');
+      expect(section).toContain('ESM');
+    });
+
+    it('should include session guidance when provided', () => {
+      const section = getConstraintsSection('python', 'Focus on security');
+      expect(section).toContain('Session-Specific Guidance');
+      expect(section).toContain('Focus on security');
+    });
+  });
+});