@helmiq/crew 0.1.0

package/dist/config/config.test.js

@@ -0,0 +1,691 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig } from './resolver.js';
+import { loadYaml } from './loader.js';
+import { ProjectConfigSchema, PersonaSpecSchema, EvaluationRubricSchema } from './schemas.js';
+import { resolveModel, resolveExecutionModel, resolveEvalModel } from './model-resolver.js';
+import { ConfigNotFoundError, PersonaNotFoundError, RubricNotFoundError, SkillNotFoundError, SchemaValidationError, ModelNotFoundError, ModelNotAllowedError, } from '../common/errors.js';
+const testDir = join(fileURLToPath(import.meta.url), '..', '..', '..');
+const fixturesPath = join(testDir, 'test', 'fixtures');
+const defaultsPath = join(testDir, 'test', 'fixtures-defaults');
+const crewRepoPath = testDir;
+describe('T-01-001a: valid config load', () => {
+    it('loads and validates a well-formed project config', async () => {
+        const configPath = join(fixturesPath, '.crew', 'config');
+        const config = await loadYaml(configPath, ProjectConfigSchema, 'Project config');
+        expect(config.project.name).toBe('Test Project');
+        expect(config.project.key).toBe('TEST');
+        expect(config.llm.default_model).toBe('claude-sonnet');
+        expect(config.llm.providers['anthropic']?.api_key_env).toBe('ANTHROPIC_API_KEY');
+    });
+    it('loads and validates a well-formed persona spec', async () => {
+        const specPath = join(fixturesPath, '.crew', 'agents', 'engineer', 'persona.yaml');
+        const spec = await loadYaml(specPath, PersonaSpecSchema, 'Persona spec');
+        expect(spec.persona.name).toBe('engineer');
+        expect(spec.persona.identity.role).toBe('Senior Software Engineer');
+        expect(spec.persona.tasks['implement-story']?.mode).toBe('composite');
+    });
+    it('loads and validates a well-formed rubric', async () => {
+        const rubricPath = join(fixturesPath, '.crew', 'rubrics', 'rubrics', 'pull-request.rubric.yaml');
+        const rubric = await loadYaml(rubricPath, EvaluationRubricSchema, 'Rubric');
+        expect(rubric.rubric.artifact_type).toBe('pull-request');
+        expect(rubric.rubric.pass_threshold).toBe(7);
+        expect(rubric.rubric.criteria.length).toBe(3);
+        expect(rubric.rubric.criteria[0]?.weight).toBe('blocking');
+    });
+});
+describe('T-01-001b: override resolution', () => {
+    it('resolves persona from project override when present', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.persona.persona.name).toBe('engineer');
+        expect(result.persona.persona.identity.role).toBe('Senior Software Engineer');
+    });
+    it('falls back to defaults when no project override exists', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'reviewer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.persona.persona.name).toBe('reviewer');
+        expect(result.persona.persona.identity.role).toBe('Senior Code Reviewer');
+    });
+    it('resolves rubric from project override when present', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.rubric.rubric.artifact_type).toBe('pull-request');
+    });
+    it('falls back to default rubric when no project override exists', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'reviewer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.rubric.rubric.artifact_type).toBe('code-review');
+    });
+    it('returns typed ProjectConfig, PersonaSpec, and EvaluationRubric', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.project.project.name).toBe('Test Project');
+        expect(result.persona.persona.name).toBe('engineer');
+        expect(result.rubric.rubric.artifact_type).toBe('pull-request');
+    });
+});
+describe('T-01-001c: schema validation errors', () => {
+    it('throws ConfigNotFoundError for missing config file', async () => {
+        await expect(loadYaml('/nonexistent/path/config', ProjectConfigSchema, 'Project config')).rejects.toThrow(ConfigNotFoundError);
+    });
+    it('throws SchemaValidationError for invalid YAML syntax', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        const tmpDir = join(testDir, 'tmp-invalid-yaml');
+        await mkdir(tmpDir, { recursive: true });
+        const badPath = join(tmpDir, 'bad.yaml');
+        await writeFile(badPath, '  :\n  - invalid: [unclosed', 'utf-8');
+        try {
+            await expect(loadYaml(badPath, ProjectConfigSchema, 'Bad YAML')).rejects.toThrow(SchemaValidationError);
+        }
+        finally {
+            const { rm } = await import('node:fs/promises');
+            await rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('throws SchemaValidationError with details for schema violations', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        const tmpDir = join(testDir, 'tmp-invalid-schema');
+        await mkdir(tmpDir, { recursive: true });
+        const badPath = join(tmpDir, 'incomplete.yaml');
+        await writeFile(badPath, 'project:\n  name: "Missing fields"\n', 'utf-8');
+        try {
+            await expect(loadYaml(badPath, ProjectConfigSchema, 'Incomplete config')).rejects.toThrow(SchemaValidationError);
+            try {
+                await loadYaml(badPath, ProjectConfigSchema, 'Incomplete config');
+            }
+            catch (err) {
+                expect(err).toBeInstanceOf(SchemaValidationError);
+                expect(err.message).toContain('failed schema validation');
+                expect(err.details).toBeDefined();
+            }
+        }
+        finally {
+            const { rm } = await import('node:fs/promises');
+            await rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('throws PersonaNotFoundError when persona is missing everywhere', async () => {
+        await expect(loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'nonexistent-persona',
+            crewRepoPath: defaultsPath,
+        })).rejects.toThrow(PersonaNotFoundError);
+    });
+    it('throws RubricNotFoundError when rubric is missing everywhere', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        const tmpDir = join(testDir, 'tmp-missing-rubric');
+        const agentDir = join(tmpDir, '.crew', 'agents', 'badrubric');
+        await mkdir(agentDir, { recursive: true });
+        const crewDir = join(tmpDir, '.crew');
+        await writeFile(join(crewDir, 'config'), `project:
+  name: Test
+  key: T
+workspace:
+  path: .
+  work: work/
+  runs: runs/
+source:
+  repo: github:test/repo
+  path: ../t
+llm:
+  default_model: claude-sonnet
+  providers:
+    anthropic:
+      api_key_env: ANTHROPIC_API_KEY
+      models:
+        claude-sonnet: claude-sonnet-4-20250514
+`, 'utf-8');
+        const skillDir = join(tmpDir, '.crew', 'skills', 'test-skill');
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(join(skillDir, 'test-skill.prompt.md'), 'Test skill prompt', 'utf-8');
+        await writeFile(join(agentDir, 'persona.yaml'), `persona:
+  name: badrubric
+  identity:
+    role: Test
+  skills:
+    - test-skill
+  perception:
+    per_task:
+      do-thing:
+        - artifact: test
+  tasks:
+    do-thing:
+      mode: simple
+      trigger: [manual]
+      skill: test-skill
+      produces: output
+  tools:
+    permitted: [read-artifact]
+    denied: []
+  cadence: {}
+  evaluation:
+    rubric: nonexistent/rubric.yaml
+`, 'utf-8');
+        try {
+            await expect(loadConfig({
+                workspacePath: tmpDir,
+                personaName: 'badrubric',
+                crewRepoPath: defaultsPath,
+            })).rejects.toThrow(RubricNotFoundError);
+        }
+        finally {
+            const { rm } = await import('node:fs/promises');
+            await rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+describe('T-01-009a: model alias resolution', () => {
+    const llmConfig = {
+        default_model: 'claude-sonnet',
+        allowed_models: ['claude-sonnet', 'claude-haiku'],
+        providers: {
+            anthropic: {
+                api_key_env: 'ANTHROPIC_API_KEY',
+                models: {
+                    'claude-sonnet': 'claude-sonnet-4-20250514',
+                    'claude-haiku': 'claude-haiku-3-20250414',
+                },
+            },
+        },
+    };
+    it('resolves a valid alias to its concrete model', () => {
+        const result = resolveModel(llmConfig, 'claude-sonnet');
+        expect(result.alias).toBe('claude-sonnet');
+        expect(result.provider).toBe('anthropic');
+        expect(result.concreteModel).toBe('claude-sonnet-4-20250514');
+        expect(result.apiKeyEnv).toBe('ANTHROPIC_API_KEY');
+    });
+    it('resolves the execution model using project default', () => {
+        const result = resolveExecutionModel(llmConfig);
+        expect(result.alias).toBe('claude-sonnet');
+        expect(result.concreteModel).toBe('claude-sonnet-4-20250514');
+    });
+    it('resolves eval model with persona override', () => {
+        const result = resolveEvalModel(llmConfig, 'claude-haiku');
+        expect(result.alias).toBe('claude-haiku');
+        expect(result.concreteModel).toBe('claude-haiku-3-20250414');
+    });
+    it('resolves eval model falling back to project default', () => {
+        const result = resolveEvalModel(llmConfig, undefined);
+        expect(result.alias).toBe('claude-sonnet');
+    });
+});
+describe('T-01-009b: persona override within allowed set', () => {
+    it('allows a model that is in the allowed list', () => {
+        const llmConfig = {
+            default_model: 'claude-sonnet',
+            allowed_models: ['claude-sonnet', 'claude-haiku'],
+            providers: {
+                anthropic: {
+                    api_key_env: 'ANTHROPIC_API_KEY',
+                    models: {
+                        'claude-sonnet': 'claude-sonnet-4-20250514',
+                        'claude-haiku': 'claude-haiku-3-20250414',
+                    },
+                },
+            },
+        };
+        expect(() => resolveModel(llmConfig, 'claude-haiku')).not.toThrow();
+    });
+    it('allows any model when allowed_models is not set', () => {
+        const llmConfig = {
+            default_model: 'claude-sonnet',
+            providers: {
+                anthropic: {
+                    api_key_env: 'ANTHROPIC_API_KEY',
+                    models: {
+                        'claude-sonnet': 'claude-sonnet-4-20250514',
+                        'claude-haiku': 'claude-haiku-3-20250414',
+                    },
+                },
+            },
+        };
+        expect(() => resolveModel(llmConfig, 'claude-haiku')).not.toThrow();
+    });
+});
+describe('T-01-009c: rejection of disallowed model', () => {
+    it('throws ModelNotAllowedError for a model not in allowed_models', () => {
+        const llmConfig = {
+            default_model: 'claude-sonnet',
+            allowed_models: ['claude-sonnet'],
+            providers: {
+                anthropic: {
+                    api_key_env: 'ANTHROPIC_API_KEY',
+                    models: {
+                        'claude-sonnet': 'claude-sonnet-4-20250514',
+                        'claude-haiku': 'claude-haiku-3-20250414',
+                    },
+                },
+            },
+        };
+        expect(() => resolveModel(llmConfig, 'claude-haiku')).toThrow(ModelNotAllowedError);
+    });
+    it('throws ModelNotFoundError for a completely unknown alias', () => {
+        const llmConfig = {
+            default_model: 'claude-sonnet',
+            providers: {
+                anthropic: {
+                    api_key_env: 'ANTHROPIC_API_KEY',
+                    models: { 'claude-sonnet': 'claude-sonnet-4-20250514' },
+                },
+            },
+        };
+        expect(() => resolveModel(llmConfig, 'gpt-4o')).toThrow(ModelNotFoundError);
+    });
+});
+describe('T-FR-01-1: default Engineer persona spec schema validation', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'engineer.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Engineer persona spec');
+    });
+    it('loads and validates the default engineer persona spec', () => {
+        expect(spec.persona.name).toBe('engineer');
+    });
+    it('defines all persona dimensions: identity, skills, perception, tasks, tools, cadence, evaluation', () => {
+        expect(spec.persona.identity).toBeDefined();
+        expect(spec.persona.identity.role).toBe('Senior Software Engineer');
+        expect(spec.persona.skills).toBeDefined();
+        expect(spec.persona.skills.length).toBeGreaterThan(0);
+        expect(spec.persona.perception).toBeDefined();
+        expect(spec.persona.perception.per_task).toBeDefined();
+        expect(spec.persona.tasks).toBeDefined();
+        expect(Object.keys(spec.persona.tasks).length).toBeGreaterThan(0);
+        expect(spec.persona.tools).toBeDefined();
+        expect(spec.persona.tools.permitted).toBeDefined();
+        expect(spec.persona.tools.denied).toBeDefined();
+        expect(spec.persona.cadence).toBeDefined();
+        expect(spec.persona.evaluation).toBeDefined();
+        expect(spec.persona.evaluation.rubric).toBeTruthy();
+    });
+    it('declares all required skills', () => {
+        expect(spec.persona.skills).toContain('feature-implement');
+        expect(spec.persona.skills).toContain('code-implement');
+        expect(spec.persona.skills).toContain('implementation-plan');
+        expect(spec.persona.skills).toContain('code-review');
+        expect(spec.persona.skills).toContain('quality-check');
+        expect(spec.persona.skills).toContain('test-write');
+        expect(spec.persona.skills).toContain('self-review');
+        expect(spec.persona.skills).toContain('pr-author');
+    });
+    it('defines implement-story as a composite task with six sub-agents', () => {
+        const task = spec.persona.tasks['implement-story'];
+        expect(task).toBeDefined();
+        expect(task.mode).toBe('composite');
+        const composite = task;
+        expect(composite.sub_agents).toHaveLength(6);
+        const names = composite.sub_agents.map((a) => a.name);
+        expect(names).toEqual([
+            'planner',
+            'implementer',
+            'test-writer',
+            'quality-checker',
+            'self-reviewer',
+            'pr-author',
+        ]);
+    });
+    it('maps sub-agents to skills', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const byName = Object.fromEntries(task.sub_agents.map((a) => [a.name, a.skill]));
+        expect(byName['planner']).toBe('implementation-plan');
+        expect(byName['implementer']).toBe('code-implement');
+        expect(byName['test-writer']).toBe('test-write');
+        expect(byName['quality-checker']).toBe('quality-check');
+        expect(byName['self-reviewer']).toBe('self-review');
+        expect(byName['pr-author']).toBe('pr-author');
+    });
+});
+describe('T-FR-01-2: skill resolution', () => {
+    it('resolves skills to prompt content at load time', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.skills['feature-implementation']).toBeDefined();
+        expect(result.skills['feature-implementation']).toContain('Senior Software Engineer');
+    });
+    it('prefers workspace .crew/skills/ over default skills/', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.skills['feature-implementation']).toContain('workspace override');
+    });
+    it('falls back to default skills/ when workspace override absent', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'reviewer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.skills['code-review']).toContain('ANALYZING code changes');
+    });
+    it('resolves implementation-planner skill from defaults', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.skills['implementation-planner']).toBeDefined();
+        expect(result.skills['implementation-planner']).toContain('ANALYZING requirements');
+    });
+    it('resolves self-review skill from defaults', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.skills['self-review']).toBeDefined();
+        expect(result.skills['self-review']).toContain('self-reviewer');
+    });
+    it('resolves pr-authoring skill from defaults', async () => {
+        const result = await loadConfig({
+            workspacePath: fixturesPath,
+            personaName: 'engineer',
+            crewRepoPath: defaultsPath,
+        });
+        expect(result.skills['pr-authoring']).toBeDefined();
+        expect(result.skills['pr-authoring']).toContain('CREATING structured pull requests');
+    });
+});
+describe('T-FR-01-3: Engineer tool permissions', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'engineer.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Engineer persona spec');
+    });
+    it('permits required tools', () => {
+        const required = ['read-artifact', 'write-artifact', 'code', 'git-operations', 'shell'];
+        for (const tool of required) {
+            expect(spec.persona.tools.permitted).toContain(tool);
+        }
+    });
+    it('denies restricted tools', () => {
+        const denied = ['write-strategy-artifacts', 'write-standards'];
+        for (const tool of denied) {
+            expect(spec.persona.tools.denied).toContain(tool);
+        }
+    });
+    it('does not permit any denied tools', () => {
+        const overlap = spec.persona.tools.permitted.filter((t) => spec.persona.tools.denied.includes(t));
+        expect(overlap).toEqual([]);
+    });
+});
+describe('T-FR-01-4: missing skill error', () => {
+    it('throws SkillNotFoundError for a missing skill', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        const tmpDir = join(testDir, 'tmp-missing-skill');
+        const agentDir = join(tmpDir, '.crew', 'agents', 'badskill');
+        await mkdir(agentDir, { recursive: true });
+        const crewDir = join(tmpDir, '.crew');
+        await writeFile(join(crewDir, 'config'), `project:
+  name: Test
+  key: T
+workspace:
+  path: .
+  work: work/
+  runs: runs/
+source:
+  repo: github:test/repo
+  path: ../t
+llm:
+  default_model: claude-sonnet
+  providers:
+    anthropic:
+      api_key_env: ANTHROPIC_API_KEY
+      models:
+        claude-sonnet: claude-sonnet-4-20250514
+`, 'utf-8');
+        await writeFile(join(agentDir, 'persona.yaml'), `persona:
+  name: badskill
+  identity:
+    role: Test
+  skills:
+    - nonexistent-skill
+  perception:
+    per_task:
+      do-thing:
+        - artifact: test
+  tasks:
+    do-thing:
+      mode: simple
+      trigger: [manual]
+      skill: nonexistent-skill
+      produces: output
+  tools:
+    permitted: [read-artifact]
+    denied: []
+  cadence: {}
+  evaluation:
+    rubric: rubrics/pull-request.rubric.yaml
+`, 'utf-8');
+        try {
+            await expect(loadConfig({
+                workspacePath: tmpDir,
+                personaName: 'badskill',
+                crewRepoPath: defaultsPath,
+            })).rejects.toThrow(SkillNotFoundError);
+        }
+        finally {
+            const { rm } = await import('node:fs/promises');
+            await rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+describe('T-CREW-10-001: test-writer sub-agent has git tools', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'engineer.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Engineer persona spec');
+    });
+    it('test-writer has code, git, and shell tools', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const tw = task.sub_agents.find((a) => a.name === 'test-writer');
+        expect(tw).toBeDefined();
+        expect(tw.tools).toContain('code');
+        expect(tw.tools).toContain('git');
+        expect(tw.tools).toContain('shell');
+    });
+});
+describe('T-FR-05: quality-checker sub-agent configuration', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'engineer.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Engineer persona spec');
+    });
+    it('quality-checker references the quality-check skill', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const qc = task.sub_agents.find((a) => a.name === 'quality-checker');
+        expect(qc).toBeDefined();
+        expect(qc.skill).toBe('quality-check');
+    });
+    it('quality-checker has shell, code, and git tools for running checks, fixing failures, and committing', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const qc = task.sub_agents.find((a) => a.name === 'quality-checker');
+        expect(qc.tools).toContain('shell');
+        expect(qc.tools).toContain('code');
+        expect(qc.tools).toContain('git');
+    });
+    it('quality-checker has max_iterations of 3', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const qc = task.sub_agents.find((a) => a.name === 'quality-checker');
+        expect(qc.max_iterations).toBe(3);
+    });
+    it('quality-checker produces quality-report', () => {
+        const task = spec.persona.tasks['implement-story'];
+        const qc = task.sub_agents.find((a) => a.name === 'quality-checker');
+        expect(qc.produces).toBe('quality-report');
+    });
+    it('address-feedback task also uses quality-check skill for its quality-checker', () => {
+        const task = spec.persona.tasks['address-feedback'];
+        const qc = task.sub_agents.find((a) => a.name === 'quality-checker');
+        expect(qc).toBeDefined();
+        expect(qc.skill).toBe('quality-check');
+        expect(qc.tools).toContain('shell');
+        expect(qc.tools).toContain('code');
+        expect(qc.tools).toContain('git');
+        expect(qc.max_iterations).toBe(3);
+    });
+});
+describe('T-FR-01 (CREW-05): Architect persona spec and ADR rubric validation', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'architect.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Architect persona spec');
+    });
+    it('loads and validates the default architect persona spec', () => {
+        expect(spec.persona.name).toBe('architect');
+        expect(spec.persona.identity.role).toBe('Senior Solution Architect');
+    });
+    it('declares adr-plan, adr-write, adr-review skills', () => {
+        expect(spec.persona.skills).toContain('adr-plan');
+        expect(spec.persona.skills).toContain('adr-write');
+        expect(spec.persona.skills).toContain('adr-review');
+    });
+    it('defines adr-workflow as a composite task with three sub-agents', () => {
+        const task = spec.persona.tasks['adr-workflow'];
+        expect(task).toBeDefined();
+        expect(task.mode).toBe('composite');
+        const composite = task;
+        expect(composite.sub_agents).toHaveLength(3);
+        const names = composite.sub_agents.map((a) => a.name);
+        expect(names).toEqual(['planner', 'writer', 'reviewer']);
+    });
+    it('maps sub-agents to skills', () => {
+        const task = spec.persona.tasks['adr-workflow'];
+        const byName = Object.fromEntries(task.sub_agents.map((a) => [a.name, a.skill]));
+        expect(byName['planner']).toBe('adr-plan');
+        expect(byName['writer']).toBe('adr-write');
+        expect(byName['reviewer']).toBe('adr-review');
+    });
+    it('reviewer sub-agent has gate with on_fail targeting writer', () => {
+        const task = spec.persona.tasks['adr-workflow'];
+        const reviewer = task.sub_agents.find((a) => a.name === 'reviewer');
+        expect(reviewer.gate).toBeDefined();
+        expect(reviewer.on_fail).toBe('writer');
+        expect(reviewer.max_loops).toBe(2);
+    });
+    it('permits read-artifact, write-artifact, and read-code', () => {
+        expect(spec.persona.tools.permitted).toContain('read-artifact');
+        expect(spec.persona.tools.permitted).toContain('write-artifact');
+        expect(spec.persona.tools.permitted).toContain('read-code');
+    });
+    it('denies write-code, git-write, git-operations, and shell', () => {
+        expect(spec.persona.tools.denied).toContain('write-code');
+        expect(spec.persona.tools.denied).toContain('git-write');
+        expect(spec.persona.tools.denied).toContain('git-operations');
+        expect(spec.persona.tools.denied).toContain('shell');
+    });
+    it('does not permit any denied tools (no overlap after expansion)', async () => {
+        const { expandToolNames } = await import('../tools/tool-groups.js');
+        const permitted = expandToolNames(spec.persona.tools.permitted);
+        const denied = expandToolNames(spec.persona.tools.denied);
+        const overlap = [...permitted].filter((t) => denied.has(t));
+        expect(overlap).toEqual([]);
+    });
+    it('declares writable_paths for architecture/decisions/', () => {
+        expect(spec.persona.tools.writable_paths).toBeDefined();
+        expect(spec.persona.tools.writable_paths).toContain('architecture/decisions/');
+    });
+    it('references rubrics/adr.rubric.yaml', () => {
+        expect(spec.persona.evaluation.rubric).toBe('rubrics/adr.rubric.yaml');
+    });
+    it('loads and validates the ADR evaluation rubric', async () => {
+        const rubricPath = join(crewRepoPath, 'defaults', 'rubrics', 'adr.rubric.yaml');
+        const rubric = await loadYaml(rubricPath, EvaluationRubricSchema, 'ADR rubric');
+        expect(rubric.rubric.artifact_type).toBe('adr-summary');
+        expect(rubric.rubric.scoring_scale).toBe(10);
+        expect(rubric.rubric.pass_threshold).toBe(7);
+    });
+    it('ADR rubric has 3 blocking and 2 important criteria', async () => {
+        const rubricPath = join(crewRepoPath, 'defaults', 'rubrics', 'adr.rubric.yaml');
+        const rubric = await loadYaml(rubricPath, EvaluationRubricSchema, 'ADR rubric');
+        expect(rubric.rubric.criteria).toHaveLength(5);
+        const blocking = rubric.rubric.criteria.filter((c) => c.weight === 'blocking');
+        const important = rubric.rubric.criteria.filter((c) => c.weight === 'important');
+        expect(blocking).toHaveLength(3);
+        expect(important).toHaveLength(2);
+    });
+    it('ADR rubric criteria cover template, balance, rationale, consequences, and contradictions', async () => {
+        const rubricPath = join(crewRepoPath, 'defaults', 'rubrics', 'adr.rubric.yaml');
+        const rubric = await loadYaml(rubricPath, EvaluationRubricSchema, 'ADR rubric');
+        const names = rubric.rubric.criteria.map((c) => c.name);
+        expect(names).toContain('ADRs follow project template');
+        expect(names).toContain('Options analysis is balanced');
+        expect(names).toContain('Rationale is justified by analysis');
+        expect(names).toContain('Consequences are documented');
+        expect(names).toContain('No contradictions with existing ADRs');
+    });
+});
+describe('T-FR-01 (CREW-04): Reviewer persona spec validation', () => {
+    let spec;
+    beforeAll(async () => {
+        const specPath = join(crewRepoPath, 'defaults', 'personas', 'reviewer.persona.yaml');
+        spec = await loadYaml(specPath, PersonaSpecSchema, 'Reviewer persona spec');
+    });
+    it('loads and validates the default reviewer persona spec', () => {
+        expect(spec.persona.name).toBe('reviewer');
+        expect(spec.persona.identity.role).toBe('Senior Code Reviewer');
+    });
+    it('declares code-review skill', () => {
+        expect(spec.persona.skills).toContain('code-review');
+    });
+    it('defines review-pr as a simple task', () => {
+        const task = spec.persona.tasks['review-pr'];
+        expect(task).toBeDefined();
+        expect(task.mode).toBe('simple');
+    });
+    it('permits read-only code and git tools plus shell', () => {
+        expect(spec.persona.tools.permitted).toContain('read-artifact');
+        expect(spec.persona.tools.permitted).toContain('write-artifact');
+        expect(spec.persona.tools.permitted).toContain('read-code');
+        expect(spec.persona.tools.permitted).toContain('git-read');
+        expect(spec.persona.tools.permitted).toContain('shell');
+    });
+    it('denies write-code and git-write', () => {
+        expect(spec.persona.tools.denied).toContain('write-code');
+        expect(spec.persona.tools.denied).toContain('git-write');
+    });
+    it('does not permit any denied tools (no overlap after expansion)', async () => {
+        const { expandToolNames } = await import('../tools/tool-groups.js');
+        const permitted = expandToolNames(spec.persona.tools.permitted);
+        const denied = expandToolNames(spec.persona.tools.denied);
+        const overlap = [...permitted].filter((t) => denied.has(t));
+        expect(overlap).toEqual([]);
+    });
+    it('has perception for standards, pr-diff, design, requirements, and prior review', () => {
+        expect(spec.persona.perception.always_read).toBeDefined();
+        expect(spec.persona.perception.always_read.length).toBeGreaterThan(0);
+        expect(spec.persona.perception.always_read[0].artifact).toBe('standards');
+        const reviewPrRefs = spec.persona.perception.per_task['review-pr'];
+        expect(reviewPrRefs).toBeDefined();
+        const artifactTypes = reviewPrRefs.map((r) => r.artifact);
+        expect(artifactTypes).toContain('pr-diff');
+        expect(artifactTypes).toContain('design');
+        expect(artifactTypes).toContain('requirements');
+        expect(artifactTypes).toContain('review');
+    });
+    it('uses self-eval quality gate with code-review rubric', () => {
+        const task = spec.persona.tasks['review-pr'];
+        expect(task.quality_gate).toBe('self-eval');
+        expect(spec.persona.evaluation.rubric).toBe('rubrics/code-review.rubric.yaml');
+    });
+});