popeye-cli 1.10.0 → 2.0.0

package/tests/pipeline/command-resolver.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Command Resolver tests — Node/Python/mixed project detection and resolution.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { resolveCommands, detectProjectType } from '../../src/pipeline/command-resolver.js';
+import type { RepoSnapshot, ConfigFileEntry } from '../../src/pipeline/types.js';
+
+function makeSnapshot(overrides: Partial<RepoSnapshot> = {}): RepoSnapshot {
+  return {
+    snapshot_id: 'test-snap',
+    timestamp: new Date().toISOString(),
+    tree_summary: '',
+    config_files: [],
+    languages_detected: [],
+    package_manager: undefined,
+    scripts: {},
+    test_framework: undefined,
+    build_tool: undefined,
+    env_files: [],
+    migrations_present: false,
+    ports_entrypoints: [],
+    total_files: 0,
+    total_lines: 0,
+    ...overrides,
+  };
+}
+
+function makeConfig(type: string): ConfigFileEntry {
+  return { path: type, type, content_hash: 'abc', key_fields: {} };
+}
+
+describe('CommandResolver', () => {
+  describe('detectProjectType', () => {
+    it('should detect node project', () => {
+      const snap = makeSnapshot({ config_files: [makeConfig('package.json')] });
+      expect(detectProjectType(snap)).toBe('node');
+    });
+
+    it('should detect python project', () => {
+      const snap = makeSnapshot({ config_files: [makeConfig('pyproject.toml')] });
+      expect(detectProjectType(snap)).toBe('python');
+    });
+
+    it('should detect mixed project', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json'), makeConfig('pyproject.toml')],
+      });
+      expect(detectProjectType(snap)).toBe('mixed');
+    });
+
+    it('should return unknown for empty project', () => {
+      const snap = makeSnapshot();
+      expect(detectProjectType(snap)).toBe('unknown');
+    });
+
+    it('should detect python from requirements.txt', () => {
+      const snap = makeSnapshot({ config_files: [makeConfig('requirements.txt')] });
+      expect(detectProjectType(snap)).toBe('python');
+    });
+  });
+
+  describe('resolveCommands', () => {
+    it('should resolve node commands from package.json scripts', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json')],
+        package_manager: 'npm',
+        scripts: { build: 'tsc', test: 'vitest', lint: 'eslint .' },
+        languages_detected: ['typescript'],
+      });
+
+      const cmds = resolveCommands(snap);
+      expect(cmds.build).toBe('npm run build');
+      expect(cmds.test).toBe('npm run test');
+      expect(cmds.lint).toBe('npm run lint');
+      expect(cmds.resolved_from).toBe('package.json');
+    });
+
+    it('should use pnpm when detected', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json')],
+        package_manager: 'pnpm',
+        scripts: { build: 'tsc', test: 'vitest' },
+      });
+
+      const cmds = resolveCommands(snap);
+      expect(cmds.build).toBe('pnpm build');
+      expect(cmds.test).toBe('pnpm test');
+    });
+
+    it('should resolve typecheck for typescript projects', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json')],
+        package_manager: 'npm',
+        scripts: {},
+        languages_detected: ['typescript'],
+      });
+
+      const cmds = resolveCommands(snap);
+      expect(cmds.typecheck).toBe('npx tsc --noEmit');
+    });
+
+    it('should resolve python commands', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('pyproject.toml')],
+        languages_detected: ['python'],
+        test_framework: 'pytest',
+      });
+
+      const cmds = resolveCommands(snap);
+      expect(cmds.test).toBe('pytest tests/');
+      expect(cmds.lint).toBe('ruff check .');
+      expect(cmds.typecheck).toBe('mypy src/');
+      expect(cmds.build).toBe('python -m build');
+    });
+
+    it('should detect vitest framework fallback', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json')],
+        package_manager: 'npm',
+        scripts: {},
+        test_framework: 'vitest',
+      });
+
+      const cmds = resolveCommands(snap);
+      expect(cmds.test).toBe('npx vitest run');
+    });
+
+    it('should detect prisma migrations', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json'), makeConfig('prisma/schema.prisma')],
+        package_manager: 'npm',
+        scripts: {},
+      });
+
+      const cmds = resolveCommands(snap);
+      expect(cmds.migrations).toBe('npx prisma migrate deploy');
+    });
+
+    it('should apply overrides', () => {
+      const snap = makeSnapshot({
+        config_files: [makeConfig('package.json')],
+        package_manager: 'npm',
+        scripts: { test: 'jest' },
+      });
+
+      const cmds = resolveCommands(snap, { test: 'custom-test-cmd' });
+      expect(cmds.test).toBe('custom-test-cmd');
+    });
+
+    it('should return minimal commands for unknown project', () => {
+      const snap = makeSnapshot();
+      const cmds = resolveCommands(snap);
+      expect(cmds.resolved_from).toBe('none');
+      expect(cmds.build).toBeUndefined();
+      expect(cmds.test).toBeUndefined();
+    });
+  });
+});

package/tests/pipeline/consensus-runner.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Consensus Runner tests — vote aggregation, packet construction,
+ * prompt building. (LLM calls are not tested here.)
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  buildReviewPrompt,
+} from '../../src/pipeline/consensus/consensus-runner.js';
+import {
+  buildConsensusPacket,
+} from '../../src/pipeline/packets/consensus-packet-builder.js';
+import type {
+  PlanPacket,
+  ReviewerVote,
+  ArtifactRef,
+} from '../../src/pipeline/types.js';
+
+function makeRef(type: string = 'master_plan'): ArtifactRef {
+  return {
+    artifact_id: `ref-${type}`,
+    path: `docs/${type}.md`,
+    sha256: 'abc',
+    version: 1,
+    type: type as ArtifactRef['type'],
+  };
+}
+
+function makePlanPacket(overrides: Partial<PlanPacket> = {}): PlanPacket {
+  return {
+    metadata: {
+      packet_id: 'plan-1',
+      timestamp: new Date().toISOString(),
+      phase: 'INTAKE',
+      submitted_by: 'DISPATCHER',
+      version: 1,
+    },
+    references: {
+      master_plan: makeRef('master_plan'),
+      constitution: makeRef('constitution'),
+      repo_snapshot: makeRef('repo_snapshot'),
+    },
+    proposed_artifacts: [],
+    acceptance_criteria: ['All endpoints documented', 'Tests for all routes'],
+    artifact_dependencies: [],
+    constraints: [
+      { type: 'technical', description: 'Use TypeScript', source: makeRef() },
+    ],
+    ...overrides,
+  };
+}
+
+function makeVote(
+  reviewerId: string,
+  vote: 'APPROVE' | 'REJECT' | 'CONDITIONAL',
+  confidence: number = 0.9,
+): ReviewerVote {
+  return {
+    reviewer_id: reviewerId,
+    provider: 'openai',
+    model: 'gpt-4o',
+    temperature: 0.3,
+    prompt_hash: 'hash',
+    vote,
+    confidence,
+    blocking_issues: vote === 'REJECT' ? ['blocking issue'] : [],
+    suggestions: [],
+    evidence_refs: [],
+  };
+}
+
+describe('ConsensusRunner', () => {
+  describe('buildReviewPrompt', () => {
+    it('should include phase and submitter', () => {
+      const packet = makePlanPacket();
+      const prompt = buildReviewPrompt(packet);
+
+      expect(prompt).toContain('INTAKE');
+      expect(prompt).toContain('DISPATCHER');
+    });
+
+    it('should include acceptance criteria', () => {
+      const packet = makePlanPacket();
+      const prompt = buildReviewPrompt(packet);
+
+      expect(prompt).toContain('All endpoints documented');
+      expect(prompt).toContain('Tests for all routes');
+    });
+
+    it('should include constraints', () => {
+      const packet = makePlanPacket();
+      const prompt = buildReviewPrompt(packet);
+
+      expect(prompt).toContain('technical');
+      expect(prompt).toContain('Use TypeScript');
+    });
+
+    it('should include open questions when present', () => {
+      const packet = makePlanPacket({
+        open_questions: ['Which database?', 'Auth strategy?'],
+      });
+      const prompt = buildReviewPrompt(packet);
+
+      expect(prompt).toContain('Which database?');
+      expect(prompt).toContain('Auth strategy?');
+    });
+
+    it('should include review instructions', () => {
+      const packet = makePlanPacket();
+      const prompt = buildReviewPrompt(packet);
+
+      expect(prompt).toContain('APPROVE');
+      expect(prompt).toContain('REJECT');
+      expect(prompt).toContain('CONDITIONAL');
+      expect(prompt).toContain('Completeness');
+    });
+  });
+
+  describe('vote aggregation via buildConsensusPacket', () => {
+    it('should approve when all reviewers approve with sufficient quorum', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('r1', 'APPROVE'), makeVote('r2', 'APPROVE')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      expect(packet.final_status).toBe('APPROVED');
+      expect(packet.consensus_result.approved).toBe(true);
+      expect(packet.consensus_result.score).toBe(1.0);
+    });
+
+    it('should reject when below threshold', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('r1', 'APPROVE'), makeVote('r2', 'REJECT')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      expect(packet.final_status).toBe('REJECTED');
+      expect(packet.consensus_result.score).toBe(0.5);
+    });
+
+    it('should handle multi-provider votes', () => {
+      const votes: ReviewerVote[] = [
+        { ...makeVote('r1', 'APPROVE'), provider: 'openai', model: 'gpt-4o' },
+        { ...makeVote('r2', 'APPROVE'), provider: 'gemini', model: 'gemini-2.0-flash' },
+        { ...makeVote('r3', 'APPROVE'), provider: 'grok', model: 'grok-3' },
+      ];
+
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes,
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      expect(packet.consensus_result.participating_reviewers).toBe(3);
+      expect(packet.final_status).toBe('APPROVED');
+    });
+
+    it('should count CONDITIONAL as non-approve', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('r1', 'APPROVE'), makeVote('r2', 'CONDITIONAL')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+      });
+
+      // CONDITIONAL is not APPROVE, so score = 0.5
+      expect(packet.consensus_result.score).toBe(0.5);
+      expect(packet.final_status).toBe('REJECTED');
+    });
+
+    it('should use ARBITRATED status when arbitrator is present', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('r1', 'APPROVE'), makeVote('r2', 'REJECT')],
+        rules: { threshold: 0.95, quorum: 2, min_reviewers: 2 },
+        arbitratorResult: { decision: 'Approve with amendments' },
+      });
+
+      expect(packet.final_status).toBe('ARBITRATED');
+    });
+
+    it('should reject when quorum not met', () => {
+      const packet = buildConsensusPacket({
+        planPacketRef: makeRef(),
+        votes: [makeVote('r1', 'APPROVE')],
+        rules: { threshold: 0.5, quorum: 2, min_reviewers: 2 },
+      });
+
+      // 1 approver, score = 1.0, but quorum = 2, only 1 voter
+      expect(packet.consensus_result.approved).toBe(false);
+    });
+
+    it('should link plan packet reference', () => {
+      const planRef = makeRef();
+      const packet = buildConsensusPacket({
+        planPacketRef: planRef,
+        votes: [makeVote('r1', 'APPROVE')],
+        rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+      });
+
+      expect(packet.plan_packet_reference).toBe(planRef);
+      expect(packet.metadata.plan_packet_id).toBe(planRef.artifact_id);
+    });
+  });
+});

package/tests/pipeline/consensus-scoring.test.ts

@@ -0,0 +1,163 @@
+/**
+ * Consensus Scoring tests — weighted scoring, CONDITIONAL handling,
+ * blocking issues, confidence weights, backward compat.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { computeConsensusScore } from '../../src/pipeline/packets/consensus-packet-builder.js';
+import { buildConsensusPacket } from '../../src/pipeline/packets/consensus-packet-builder.js';
+import type { ReviewerVote, ArtifactRef } from '../../src/pipeline/types.js';
+
+function makeVote(overrides: Partial<ReviewerVote> = {}): ReviewerVote {
+  return {
+    reviewer_id: 'r1',
+    provider: 'openai',
+    model: 'gpt-4',
+    temperature: 0.2,
+    prompt_hash: 'abc',
+    vote: 'APPROVE',
+    confidence: 0.9,
+    blocking_issues: [],
+    suggestions: [],
+    evidence_refs: [],
+    ...overrides,
+  };
+}
+
+const mockRef: ArtifactRef = {
+  artifact_id: 'test-ref',
+  path: 'docs/test.md',
+  sha256: 'abc123',
+  version: 1,
+  type: 'master_plan',
+};
+
+describe('computeConsensusScore', () => {
+  it('should return 0 for empty votes', () => {
+    const result = computeConsensusScore([]);
+    expect(result.score).toBe(0);
+    expect(result.weighted_score).toBe(0);
+  });
+
+  it('should return 1.0 for all APPROVE votes', () => {
+    const votes = [
+      makeVote({ vote: 'APPROVE', confidence: 0.9 }),
+      makeVote({ vote: 'APPROVE', confidence: 0.8, reviewer_id: 'r2' }),
+    ];
+    const result = computeConsensusScore(votes);
+    expect(result.score).toBe(1.0);
+    expect(result.weighted_score).toBe(1.0);
+  });
+
+  it('should return 0 for all REJECT votes', () => {
+    const votes = [
+      makeVote({ vote: 'REJECT', confidence: 0.9, reviewer_id: 'r1' }),
+      makeVote({ vote: 'REJECT', confidence: 0.8, reviewer_id: 'r2' }),
+    ];
+    const result = computeConsensusScore(votes);
+    expect(result.score).toBe(0);
+    expect(result.weighted_score).toBe(0);
+  });
+
+  it('should treat CONDITIONAL as 0.5 weight', () => {
+    const votes = [
+      makeVote({ vote: 'CONDITIONAL', confidence: 1.0, reviewer_id: 'r1' }),
+    ];
+    const result = computeConsensusScore(votes);
+    expect(result.score).toBe(0); // Simple: 0 approves / 1 total
+    expect(result.weighted_score).toBe(0.5); // Weighted: 0.5 * 1.0 / 1.0
+  });
+
+  it('should weight by confidence', () => {
+    const votes = [
+      makeVote({ vote: 'APPROVE', confidence: 1.0, reviewer_id: 'r1' }),
+      makeVote({ vote: 'REJECT', confidence: 0.1, reviewer_id: 'r2' }),
+    ];
+    const result = computeConsensusScore(votes);
+    expect(result.score).toBe(0.5); // Simple: 1/2
+    // Weighted: (1.0*1.0 + 0.0*0.1) / (1.0+0.1) = 1.0/1.1 ≈ 0.909
+    expect(result.weighted_score).toBeCloseTo(1.0 / 1.1, 3);
+  });
+
+  it('should force weighted_score to 0 when blocking issues exist', () => {
+    const votes = [
+      makeVote({ vote: 'APPROVE', confidence: 1.0, reviewer_id: 'r1' }),
+      makeVote({
+        vote: 'CONDITIONAL',
+        confidence: 0.9,
+        blocking_issues: ['Critical bug found'],
+        reviewer_id: 'r2',
+      }),
+    ];
+    const result = computeConsensusScore(votes);
+    expect(result.score).toBe(0.5); // Simple score unaffected
+    expect(result.weighted_score).toBe(0); // Forced to 0 by blocking issues
+  });
+
+  it('should handle mixed votes with varied confidence', () => {
+    const votes = [
+      makeVote({ vote: 'APPROVE', confidence: 0.8, reviewer_id: 'r1' }),
+      makeVote({ vote: 'CONDITIONAL', confidence: 0.6, reviewer_id: 'r2' }),
+      makeVote({ vote: 'REJECT', confidence: 0.4, reviewer_id: 'r3' }),
+    ];
+    const result = computeConsensusScore(votes);
+    expect(result.score).toBeCloseTo(1 / 3, 3); // 1 approve / 3 total
+    // Weighted: (1.0*0.8 + 0.5*0.6 + 0.0*0.4) / (0.8+0.6+0.4) = 1.1/1.8 ≈ 0.611
+    expect(result.weighted_score).toBeCloseTo(1.1 / 1.8, 3);
+  });
+});
+
+describe('buildConsensusPacket', () => {
+  it('should include weighted_score in consensus_result', () => {
+    const packet = buildConsensusPacket({
+      planPacketRef: mockRef,
+      votes: [makeVote({ vote: 'APPROVE', confidence: 0.9 })],
+      rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+    });
+    expect(packet.consensus_result.weighted_score).toBeDefined();
+    expect(packet.consensus_result.weighted_score).toBe(1.0);
+  });
+
+  it('should maintain backward-compatible simple score', () => {
+    const packet = buildConsensusPacket({
+      planPacketRef: mockRef,
+      votes: [
+        makeVote({ vote: 'APPROVE', reviewer_id: 'r1' }),
+        makeVote({ vote: 'REJECT', reviewer_id: 'r2' }),
+      ],
+      rules: { threshold: 0.5, quorum: 1, min_reviewers: 1 },
+    });
+    expect(packet.consensus_result.score).toBe(0.5);
+  });
+
+  it('should APPROVE when score meets threshold', () => {
+    const packet = buildConsensusPacket({
+      planPacketRef: mockRef,
+      votes: [makeVote({ vote: 'APPROVE' })],
+      rules: { threshold: 0.95, quorum: 1, min_reviewers: 1 },
+    });
+    expect(packet.final_status).toBe('APPROVED');
+  });
+
+  it('should REJECT when score below threshold', () => {
+    const packet = buildConsensusPacket({
+      planPacketRef: mockRef,
+      votes: [
+        makeVote({ vote: 'APPROVE', reviewer_id: 'r1' }),
+        makeVote({ vote: 'REJECT', reviewer_id: 'r2' }),
+      ],
+      rules: { threshold: 0.95, quorum: 1, min_reviewers: 1 },
+    });
+    expect(packet.final_status).toBe('REJECTED');
+  });
+
+  it('should ARBITRATE when arbitrator result provided', () => {
+    const packet = buildConsensusPacket({
+      planPacketRef: mockRef,
+      votes: [makeVote({ vote: 'REJECT' })],
+      rules: { threshold: 0.95, quorum: 1, min_reviewers: 1 },
+      arbitratorResult: { decision: 'Override to approve' },
+    });
+    expect(packet.final_status).toBe('ARBITRATED');
+  });
+});

package/tests/pipeline/constitution.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Constitution tests — artifact creation, hash computation, verification.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import {
+  computeConstitutionHash,
+  createConstitutionArtifact,
+  verifyConstitution,
+} from '../../src/pipeline/constitution.js';
+import { createArtifactManager } from '../../src/pipeline/artifact-manager.js';
+import { createDefaultPipelineState } from '../../src/pipeline/types.js';
+
+const TEST_DIR = join(process.cwd(), 'tmp-constitution-test');
+
+beforeEach(() => {
+  mkdirSync(join(TEST_DIR, 'skills'), { recursive: true });
+  mkdirSync(join(TEST_DIR, 'docs'), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('computeConstitutionHash', () => {
+  it('should compute SHA-256 of constitution file', () => {
+    const content = '# POPEYE CONSTITUTION\nRule 1: Be deterministic';
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), content);
+
+    const hash = computeConstitutionHash(TEST_DIR);
+    const expected = createHash('sha256').update(content, 'utf-8').digest('hex');
+    expect(hash).toBe(expected);
+  });
+
+  it('should return empty string when file not found', () => {
+    const hash = computeConstitutionHash(TEST_DIR + '-nonexistent');
+    expect(hash).toBe('');
+  });
+
+  it('should produce different hashes for different content', () => {
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Version 1');
+    const hash1 = computeConstitutionHash(TEST_DIR);
+
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Version 2');
+    const hash2 = computeConstitutionHash(TEST_DIR);
+
+    expect(hash1).not.toBe(hash2);
+  });
+});
+
+describe('createConstitutionArtifact', () => {
+  it('should create an artifact from constitution file', () => {
+    writeFileSync(
+      join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'),
+      '# Constitution\nRule 1',
+    );
+    const am = createArtifactManager(TEST_DIR);
+    const entry = createConstitutionArtifact(TEST_DIR, am);
+
+    expect(entry).not.toBeNull();
+    expect(entry!.type).toBe('constitution');
+    expect(entry!.phase).toBe('INTAKE');
+  });
+
+  it('should return null when constitution file missing', () => {
+    const am = createArtifactManager(TEST_DIR);
+    const entry = createConstitutionArtifact(TEST_DIR + '-nope', am);
+    expect(entry).toBeNull();
+  });
+});
+
+describe('verifyConstitution', () => {
+  it('should pass when hash matches', () => {
+    const content = '# Constitution\nRule 1: Immutable';
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), content);
+
+    const pipeline = createDefaultPipelineState();
+    pipeline.constitutionHash = computeConstitutionHash(TEST_DIR);
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(true);
+  });
+
+  it('should fail when constitution has been modified', () => {
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Original');
+    const pipeline = createDefaultPipelineState();
+    pipeline.constitutionHash = computeConstitutionHash(TEST_DIR);
+
+    // Modify the file
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Modified!');
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(false);
+    expect(result.reason).toContain('modified');
+  });
+
+  it('should skip verification when no hash stored (pre-INTAKE)', () => {
+    const pipeline = createDefaultPipelineState();
+    // constitutionHash is '' by default
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(true);
+  });
+
+  it('should fail when constitution file deleted after hash stored', () => {
+    writeFileSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'), 'Content');
+    const pipeline = createDefaultPipelineState();
+    pipeline.constitutionHash = computeConstitutionHash(TEST_DIR);
+
+    // Delete the file
+    rmSync(join(TEST_DIR, 'skills', 'POPEYE_CONSTITUTION.md'));
+
+    const result = verifyConstitution(pipeline, TEST_DIR);
+    expect(result.valid).toBe(false);
+    expect(result.reason).toContain('not found');
+  });
+});