@helmiq/crew 0.1.0

package/dist/engine/composite.test.js

@@ -0,0 +1,1947 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { mkdtemp } from 'node:fs/promises';
+import { executeCompositeTask } from './composite.js';
+const mockModel = {
+    alias: 'claude-sonnet',
+    provider: 'anthropic',
+    concreteModel: 'claude-sonnet-4-20250514',
+    apiKeyEnv: 'ANTHROPIC_API_KEY',
+};
+const emptyContext = {
+    blocks: [],
+    totalTokens: 0,
+    budgetLimit: 100_000,
+    gaps: [],
+};
+const emptyTools = {};
+function makePersona() {
+    return {
+        persona: {
+            name: 'engineer',
+            identity: { role: 'Senior Software Engineer' },
+            skills: ['feature-implementation', 'code-review'],
+            perception: { per_task: {} },
+            tasks: {},
+            tools: {
+                permitted: ['read-artifact', 'code', 'git', 'shell'],
+                denied: ['write-strategy-artifacts'],
+            },
+            cadence: {},
+            evaluation: { rubric: 'test.rubric.yaml' },
+        },
+    };
+}
+function makeTask(overrides) {
+    return {
+        mode: 'composite',
+        trigger: ['manual'],
+        sub_agents: [
+            { name: 'planner', skill: 'feature-implementation', reads: [], produces: 'plan' },
+            {
+                name: 'implementer',
+                skill: 'feature-implementation',
+                reads: ['plan'],
+                produces: 'code',
+                tools: ['code', 'git'],
+            },
+            { name: 'reviewer', skill: 'code-review', reads: ['code', 'plan'], produces: 'review' },
+        ],
+        published_artifact: 'review',
+        ...overrides,
+    };
+}
+let callCount = 0;
+function sequentialProvider(responses) {
+    callCount = 0;
+    return {
+        generateText: vi.fn().mockImplementation(() => {
+            const text = responses[callCount] ?? `response-${callCount}`;
+            callCount++;
+            return Promise.resolve({
+                text,
+                toolCalls: [],
+                tokensIn: 10,
+                tokensOut: 20,
+            });
+        }),
+    };
+}
+function failingProvider(failAtCall, responses) {
+    callCount = 0;
+    return {
+        generateText: vi.fn().mockImplementation(() => {
+            const idx = callCount;
+            callCount++;
+            if (idx === failAtCall) {
+                return Promise.reject(new Error('LLM call failed'));
+            }
+            const text = responses[idx] ?? `response-${idx}`;
+            return Promise.resolve({
+                text,
+                toolCalls: [],
+                tokensIn: 10,
+                tokensOut: 20,
+            });
+        }),
+    };
+}
+let tmpDir;
+beforeEach(async () => {
+    vi.restoreAllMocks();
+    callCount = 0;
+    tmpDir = await mkdtemp(join(tmpdir(), 'crew-composite-test-'));
+});
+describe('T-01-004a: sequential sub-agent execution', () => {
+    it('executes sub-agents in order and returns final output', async () => {
+        const provider = sequentialProvider(['The plan', 'The code', 'The review']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).toBe('The review');
+        expect(result.subAgentResults).toHaveLength(3);
+        expect(result.subAgentResults[0].name).toBe('planner');
+        expect(result.subAgentResults[1].name).toBe('implementer');
+        expect(result.subAgentResults[2].name).toBe('reviewer');
+        expect(provider.generateText).toHaveBeenCalledTimes(3);
+    });
+    it('passes working state between sub-agents', async () => {
+        const provider = sequentialProvider(['The plan', 'The code', 'The review']);
+        const task = makeTask();
+        await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        const calls = provider.generateText.mock.calls;
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain('The plan');
+        const reviewerPrompt = calls[2][0].messages[0]
+            .content;
+        expect(reviewerPrompt).toContain('The code');
+        expect(reviewerPrompt).toContain('The plan');
+    });
+    it('accumulates token counts across sub-agents', async () => {
+        const provider = sequentialProvider(['a', 'b', 'c']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.tokensIn).toBe(30);
+        expect(result.tokensOut).toBe(60);
+    });
+    it('applies sub-agent tool restrictions', async () => {
+        const noop = vi.fn().mockResolvedValue({});
+        const tools = {
+            'read-file': { name: 'read-file', description: 'read', parameters: {}, execute: noop },
+            'write-file': { name: 'write-file', description: 'write', parameters: {}, execute: noop },
+            'git-branch': { name: 'git-branch', description: 'git', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'git', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = sequentialProvider(['a', 'b', 'c']);
+        const task = makeTask();
+        await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, tools, tmpDir);
+        const calls = provider.generateText.mock.calls;
+        const plannerTools = calls[0][0].tools ?? {};
+        expect(Object.keys(plannerTools).sort()).toEqual(['git-branch', 'git-commit', 'read-file', 'run-command', 'write-file'].sort());
+        const implementerTools = calls[1][0].tools ?? {};
+        expect(Object.keys(implementerTools).sort()).toEqual(['git-branch', 'git-commit', 'read-file', 'write-file'].sort());
+    });
+});
+describe('T-01-004b: retry via max_iterations', () => {
+    it('retries a failing sub-agent up to max_iterations', async () => {
+        const task = makeTask({
+            sub_agents: [
+                {
+                    name: 'flaky',
+                    skill: 'feature-implementation',
+                    reads: [],
+                    produces: 'output',
+                    max_iterations: 3,
+                },
+            ],
+            published_artifact: 'output',
+        });
+        let attempt = 0;
+        const provider = {
+            generateText: vi.fn().mockImplementation(() => {
+                attempt++;
+                if (attempt < 3) {
+                    return Promise.reject(new Error(`Fail attempt ${attempt}`));
+                }
+                return Promise.resolve({
+                    text: 'Success on third try',
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).toBe('Success on third try');
+        expect(provider.generateText).toHaveBeenCalledTimes(3);
+    });
+    it('returns empty content when max_iterations exhausted', async () => {
+        const task = makeTask({
+            sub_agents: [
+                {
+                    name: 'always-fails',
+                    skill: 'feature-implementation',
+                    reads: [],
+                    produces: 'output',
+                    max_iterations: 2,
+                },
+            ],
+            published_artifact: 'output',
+        });
+        const provider = {
+            generateText: vi.fn().mockRejectedValue(new Error('Always fails')),
+        };
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).toBe('');
+        expect(provider.generateText).toHaveBeenCalledTimes(2);
+    });
+});
+describe('T-01-004c: jump-back via on_fail/gate/max_loops', () => {
+    it('jumps back when gate fails and retries from target', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    const pass = callIdx > 4;
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass, reason: pass ? 'ok' : 'issues found' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const task = makeTask({
+            sub_agents: [
+                { name: 'implementer', skill: 'feature-implementation', reads: [], produces: 'code' },
+                {
+                    name: 'reviewer',
+                    skill: 'code-review',
+                    reads: ['code'],
+                    produces: 'review',
+                    gate: 'no blocking issues',
+                    on_fail: 'implementer',
+                    max_loops: 2,
+                },
+            ],
+            published_artifact: 'review',
+        });
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).not.toBe('');
+        expect(result.subAgentResults.length).toBeGreaterThan(2);
+    });
+    it('fails when max_loops exhausted', async () => {
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: false, reason: 'always fails' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: 'some output',
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const task = makeTask({
+            sub_agents: [
+                { name: 'implementer', skill: 'feature-implementation', reads: [], produces: 'code' },
+                {
+                    name: 'reviewer',
+                    skill: 'code-review',
+                    reads: ['code'],
+                    produces: 'review',
+                    gate: 'no blocking issues',
+                    on_fail: 'implementer',
+                    max_loops: 1,
+                },
+            ],
+            published_artifact: 'review',
+        });
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).toBe('');
+    });
+});
+describe('T-01-004d: checkpoint work products', () => {
+    it('writes each sub-agent output to runs/{run_id}/work/', async () => {
+        const provider = sequentialProvider(['plan content', 'code content', 'review content']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.checkpoints).toHaveLength(3);
+        for (const cp of result.checkpoints) {
+            const content = await readFile(cp.path, 'utf-8');
+            expect(content).toBeTruthy();
+        }
+        const planContent = await readFile(result.checkpoints[0].path, 'utf-8');
+        expect(planContent).toBe('plan content');
+        const codeContent = await readFile(result.checkpoints[1].path, 'utf-8');
+        expect(codeContent).toBe('code content');
+    });
+    it('names checkpoint files with padded step numbers', async () => {
+        const provider = sequentialProvider(['a', 'b', 'c']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.checkpoints[0].path).toContain('01-planner.md');
+        expect(result.checkpoints[1].path).toContain('02-implementer.md');
+        expect(result.checkpoints[2].path).toContain('03-reviewer.md');
+    });
+});
+describe('T-01-004e: no partial publish on failure', () => {
+    it('returns empty content when a sub-agent fails', async () => {
+        const provider = failingProvider(1, ['plan OK']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.content).toBe('');
+        expect(result.subAgentResults).toHaveLength(1);
+        expect(result.checkpoints).toHaveLength(1);
+    });
+    it('checkpoints only the steps that succeeded before failure', async () => {
+        const provider = failingProvider(2, ['plan', 'code']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.checkpoints).toHaveLength(2);
+        expect(result.content).toBe('');
+    });
+    it('still records tokens consumed before failure', async () => {
+        const provider = failingProvider(1, ['plan']);
+        const task = makeTask();
+        const result = await executeCompositeTask(makePersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir);
+        expect(result.tokensIn).toBeGreaterThan(0);
+        expect(result.tokensOut).toBeGreaterThan(0);
+    });
+});
+describe('T-FR-04: test-writer sub-agent', () => {
+    function makeImplementStoryTask() {
+        return {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'implementer',
+                    skill: 'feature-implementation',
+                    reads: [],
+                    produces: 'code-changes',
+                    tools: ['code', 'git'],
+                },
+                {
+                    name: 'test-writer',
+                    skill: 'test-writing',
+                    reads: ['code-changes', 'requirements'],
+                    produces: 'test-files',
+                    tools: ['code', 'git', 'shell'],
+                },
+            ],
+            published_artifact: 'test-files',
+        };
+    }
+    it('receives the test-writing skill prompt in its user message', async () => {
+        const provider = sequentialProvider(['code output', 'test output']);
+        const skills = {
+            'feature-implementation': 'Feature implementation prompt content',
+            'test-writing': 'Test writing prompt for acceptance criteria coverage',
+        };
+        await executeCompositeTask(makePersona(), makeImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, skills);
+        const calls = provider.generateText.mock.calls;
+        const testWriterPrompt = calls[1][0].messages[0]
+            .content;
+        expect(testWriterPrompt).toContain('Test writing prompt for acceptance criteria coverage');
+        expect(testWriterPrompt).not.toContain('Feature implementation prompt content');
+    });
+    it('receives code-changes from working state', async () => {
+        const provider = sequentialProvider(['The implemented code changes', 'The tests']);
+        const skills = {
+            'feature-implementation': 'impl prompt',
+            'test-writing': 'test prompt',
+        };
+        await executeCompositeTask(makePersona(), makeImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, skills);
+        const calls = provider.generateText.mock.calls;
+        const testWriterPrompt = calls[1][0].messages[0]
+            .content;
+        expect(testWriterPrompt).toContain('The implemented code changes');
+    });
+    it('includes requirements from context when present in working state', async () => {
+        const contextWithRequirements = {
+            blocks: [],
+            totalTokens: 0,
+            budgetLimit: 100_000,
+            gaps: [],
+        };
+        const provider = sequentialProvider(['code output', 'test output']);
+        const skills = {
+            'feature-implementation': 'impl prompt',
+            'test-writing': 'test prompt',
+        };
+        const task = makeImplementStoryTask();
+        task.sub_agents[0].reads = ['requirements'];
+        task.sub_agents[0].produces = 'code-changes';
+        await executeCompositeTask(makePersona(), task, contextWithRequirements, mockModel, provider, emptyTools, tmpDir, skills);
+        const calls = provider.generateText.mock.calls;
+        const testWriterPrompt = calls[1][0].messages[0]
+            .content;
+        expect(testWriterPrompt).toContain('code-changes');
+    });
+    it('restricts tools to code, git, and shell groups', async () => {
+        const noop = async () => ({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read file', parameters: {}, execute: noop },
+            'write-file': {
+                name: 'write-file',
+                description: 'write file',
+                parameters: {},
+                execute: noop,
+            },
+            'git-branch': { name: 'git-branch', description: 'branch', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'commit', parameters: {}, execute: noop },
+            'git-diff': { name: 'git-diff', description: 'diff', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = sequentialProvider(['code', 'tests']);
+        const skills = {
+            'feature-implementation': 'impl prompt',
+            'test-writing': 'test prompt',
+        };
+        await executeCompositeTask(makePersona(), makeImplementStoryTask(), emptyContext, mockModel, provider, tools, tmpDir, skills);
+        const calls = provider.generateText.mock.calls;
+        const testWriterCall = calls[1][0];
+        const toolNames = Object.keys(testWriterCall.tools ?? {}).sort();
+        expect(toolNames).toEqual([
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'read-file',
+            'run-command',
+            'write-file',
+        ]);
+    });
+    it('produces test-files output and checkpoints it', async () => {
+        const provider = sequentialProvider(['code changes', 'test file content']);
+        const skills = {
+            'feature-implementation': 'impl prompt',
+            'test-writing': 'test prompt',
+        };
+        const result = await executeCompositeTask(makePersona(), makeImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, skills);
+        expect(result.content).toBe('test file content');
+        expect(result.checkpoints).toHaveLength(2);
+        expect(result.checkpoints[1].name).toBe('test-writer');
+        const checkpointContent = await readFile(result.checkpoints[1].path, 'utf-8');
+        expect(checkpointContent).toBe('test file content');
+    });
+    it('includes Sub-task: test-files in the prompt', async () => {
+        const provider = sequentialProvider(['code', 'tests']);
+        const skills = {
+            'feature-implementation': 'impl prompt',
+            'test-writing': 'test prompt',
+        };
+        await executeCompositeTask(makePersona(), makeImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, skills);
+        const calls = provider.generateText.mock.calls;
+        const testWriterPrompt = calls[1][0].messages[0]
+            .content;
+        expect(testWriterPrompt).toContain('Sub-task: test-files');
+    });
+});
+describe('T-FR-02: planner sub-agent', () => {
+    function makePlannerTask() {
+        return {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'planner',
+                    skill: 'implementation-planner',
+                    reads: ['requirements', 'design', 'codebase-structure'],
+                    produces: 'implementation-plan',
+                    tools: ['read-artifact'],
+                },
+                {
+                    name: 'implementer',
+                    skill: 'feature-implementation',
+                    reads: ['implementation-plan'],
+                    produces: 'code-changes',
+                    tools: ['code', 'git'],
+                },
+            ],
+            published_artifact: 'code-changes',
+        };
+    }
+    function makePlannerPersona() {
+        return {
+            persona: {
+                name: 'engineer',
+                identity: { role: 'Senior Software Engineer' },
+                skills: ['feature-implementation', 'implementation-planner', 'code-review'],
+                perception: { per_task: {} },
+                tasks: {},
+                tools: {
+                    permitted: ['read-artifact', 'code', 'git', 'shell'],
+                    denied: ['write-strategy-artifacts'],
+                },
+                cadence: {},
+                evaluation: { rubric: 'test.rubric.yaml' },
+            },
+        };
+    }
+    const plannerSkills = {
+        'implementation-planner': 'Analyze requirements and produce a structured implementation plan.',
+        'feature-implementation': 'Implement features following existing patterns.',
+    };
+    it('T-FR-02-1: planner produces a plan that is checkpointed', async () => {
+        const planOutput = '## Implementation Plan\n\n### Files to modify\n- src/engine/composite.ts';
+        const provider = sequentialProvider([planOutput, 'code changes']);
+        const task = makePlannerTask();
+        const result = await executeCompositeTask(makePlannerPersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir, plannerSkills);
+        expect(result.subAgentResults[0].name).toBe('planner');
+        expect(result.checkpoints[0].name).toBe('planner');
+        const checkpointContent = await readFile(result.checkpoints[0].path, 'utf-8');
+        expect(checkpointContent).toBe(planOutput);
+    });
+    it('T-FR-02-2: planner checkpoint is named 01-planner.md', async () => {
+        const provider = sequentialProvider(['the plan', 'the code']);
+        const task = makePlannerTask();
+        const result = await executeCompositeTask(makePlannerPersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir, plannerSkills);
+        expect(result.checkpoints[0].path).toContain('01-planner.md');
+    });
+    it('T-FR-02-3: planner prompt includes implementation-planner skill content', async () => {
+        const provider = sequentialProvider(['the plan', 'the code']);
+        const task = makePlannerTask();
+        await executeCompositeTask(makePlannerPersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir, plannerSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('structured implementation plan');
+    });
+    it('planner output flows to implementer via working state', async () => {
+        const planContent = 'Plan: modify src/engine.ts and add tests';
+        const provider = sequentialProvider([planContent, 'code written']);
+        const task = makePlannerTask();
+        await executeCompositeTask(makePlannerPersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir, plannerSkills);
+        const calls = provider.generateText.mock.calls;
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain(planContent);
+    });
+    it('planner receives only read-artifact tools when restricted', async () => {
+        const noop = vi.fn().mockResolvedValue({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read', parameters: {}, execute: noop },
+            'write-file': { name: 'write-file', description: 'write', parameters: {}, execute: noop },
+            'git-branch': { name: 'git-branch', description: 'git', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = sequentialProvider(['plan', 'code']);
+        const task = makePlannerTask();
+        await executeCompositeTask(makePlannerPersona(), task, emptyContext, mockModel, provider, tools, tmpDir, plannerSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerTools = calls[0][0].tools ?? {};
+        expect(Object.keys(plannerTools)).toEqual(['read-artifact']);
+        const implementerTools = calls[1][0].tools ?? {};
+        expect(Object.keys(implementerTools).sort()).toEqual(['git-branch', 'read-file', 'write-file'].sort());
+    });
+    it('planner uses different skill prompt than implementer', async () => {
+        const provider = sequentialProvider(['the plan', 'the code']);
+        const task = makePlannerTask();
+        await executeCompositeTask(makePlannerPersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir, plannerSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('structured implementation plan');
+        expect(plannerPrompt).not.toContain('Implement features');
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain('Implement features');
+        expect(implementerPrompt).not.toContain('structured implementation plan');
+    });
+    it('planner receives assembled context blocks', async () => {
+        const contextWithBlocks = {
+            blocks: [
+                {
+                    content: 'Epic requirements content',
+                    source: { type: 'requirements', path: 'work/CREW-03/requirements.md' },
+                    tokens: 250,
+                    priority: 'required',
+                },
+                {
+                    content: 'Design document content',
+                    source: { type: 'design', path: 'work/CREW-03/design.md' },
+                    tokens: 250,
+                    priority: 'required',
+                },
+            ],
+            totalTokens: 500,
+            budgetLimit: 100_000,
+            gaps: [],
+        };
+        const provider = sequentialProvider(['the plan', 'the code']);
+        const task = makePlannerTask();
+        await executeCompositeTask(makePlannerPersona(), task, contextWithBlocks, mockModel, provider, emptyTools, tmpDir, plannerSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('Epic requirements content');
+        expect(plannerPrompt).toContain('Design document content');
+    });
+});
+describe('T-FR-06: self-reviewer and PR author sub-agents', () => {
+    function makeSelfReviewTask() {
+        return {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'implementer',
+                    skill: 'feature-implementation',
+                    reads: [],
+                    produces: 'code-changes',
+                    tools: ['code', 'git'],
+                },
+                {
+                    name: 'self-reviewer',
+                    skill: 'self-review',
+                    reads: ['code-changes', 'design', 'standards'],
+                    produces: 'self-review',
+                    gate: 'no blocking issues',
+                    on_fail: 'implementer',
+                    max_loops: 2,
+                },
+                {
+                    name: 'pr-author',
+                    skill: 'pr-authoring',
+                    reads: ['code-changes', 'requirements', 'self-review'],
+                    produces: 'pull-request',
+                    tools: ['git'],
+                },
+            ],
+            published_artifact: 'pull-request',
+        };
+    }
+    const selfReviewSkills = {
+        'feature-implementation': 'Implement features following existing patterns.',
+        'self-review': 'Review code changes against design and standards. Produce a structured verdict.',
+        'pr-authoring': 'Create a GitHub PR with structured description linking to requirements.',
+    };
+    it('T-FR-06-1: self-reviewer receives the self-review skill prompt', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'no issues' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        const calls = provider.generateText.mock.calls;
+        const selfReviewerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(selfReviewerPrompt).toContain('Review code changes against design and standards');
+        expect(selfReviewerPrompt).not.toContain('Create a GitHub PR');
+    });
+    it('T-FR-06-1: self-review output is checkpointed', async () => {
+        const reviewOutput = '## Self-Review Verdict\n\n**Result:** PASS\n\n### Blocking Issues\n\nNone';
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'no blocking issues' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                if (callIdx === 2) {
+                    return Promise.resolve({
+                        text: reviewOutput,
+                        toolCalls: [],
+                        tokensIn: 10,
+                        tokensOut: 20,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        const selfReviewCheckpoint = result.checkpoints.find((cp) => cp.name === 'self-reviewer');
+        expect(selfReviewCheckpoint).toBeDefined();
+        const checkpointContent = await readFile(selfReviewCheckpoint.path, 'utf-8');
+        expect(checkpointContent).toContain('Self-Review Verdict');
+        expect(checkpointContent).toContain('PASS');
+    });
+    it('T-FR-06-2: gate failure loops back to implementer', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    const pass = callIdx > 5;
+                    return Promise.resolve({
+                        text: JSON.stringify({
+                            pass,
+                            reason: pass ? 'issues resolved' : 'blocking issues found',
+                        }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        const implementerResults = result.subAgentResults.filter((r) => r.name === 'implementer');
+        expect(implementerResults.length).toBeGreaterThan(1);
+        const selfReviewerResults = result.subAgentResults.filter((r) => r.name === 'self-reviewer');
+        expect(selfReviewerResults.length).toBeGreaterThan(1);
+    });
+    it('T-FR-06-2: max_loops exhaustion returns empty content', async () => {
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: false, reason: 'blocking issues persist' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: 'some output',
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        expect(result.content).toBe('');
+    });
+    it('self-reviewer reads code-changes from working state', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                if (callIdx === 1) {
+                    return Promise.resolve({
+                        text: 'Added src/engine/composite.ts with gate evaluation logic',
+                        toolCalls: [],
+                        tokensIn: 10,
+                        tokensOut: 20,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        const calls = provider.generateText.mock.calls;
+        const selfReviewerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(selfReviewerPrompt).toContain('Added src/engine/composite.ts with gate evaluation logic');
+    });
+    it('self-reviewer receives all permitted tools (no sub-agent restriction)', async () => {
+        const noop = async () => ({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read file', parameters: {}, execute: noop },
+            'write-file': {
+                name: 'write-file',
+                description: 'write file',
+                parameters: {},
+                execute: noop,
+            },
+            'git-branch': { name: 'git-branch', description: 'branch', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'commit', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, tools, tmpDir, selfReviewSkills);
+        const calls = provider.generateText.mock.calls;
+        const selfReviewerCall = calls[1][0];
+        const toolNames = Object.keys(selfReviewerCall.tools ?? {}).sort();
+        expect(toolNames).toEqual([
+            'git-branch',
+            'git-commit',
+            'read-artifact',
+            'read-file',
+            'run-command',
+            'write-file',
+        ].sort());
+    });
+    it('T-FR-06-3: PR author receives pr-authoring skill prompt', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        const calls = provider.generateText.mock.calls;
+        const prAuthorIdx = calls.findIndex((call) => {
+            const msgs = call[0].messages;
+            return msgs[0]?.content.includes('Sub-task: pull-request');
+        });
+        expect(prAuthorIdx).toBeGreaterThan(-1);
+        const prAuthorPrompt = calls[prAuthorIdx][0]
+            .messages[0].content;
+        expect(prAuthorPrompt).toContain('Create a GitHub PR with structured description');
+    });
+    it('T-FR-06-3: PR author reads self-review from working state', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                if (callIdx === 2) {
+                    return Promise.resolve({
+                        text: '## Self-Review Verdict\n\n**Result:** PASS\n\nNo blocking issues found.',
+                        toolCalls: [],
+                        tokensIn: 10,
+                        tokensOut: 20,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        const calls = provider.generateText.mock.calls;
+        const prAuthorIdx = calls.findIndex((call) => {
+            const msgs = call[0].messages;
+            return msgs[0]?.content.includes('Sub-task: pull-request');
+        });
+        const prAuthorPrompt = calls[prAuthorIdx][0]
+            .messages[0].content;
+        expect(prAuthorPrompt).toContain('Self-Review Verdict');
+        expect(prAuthorPrompt).toContain('PASS');
+    });
+    it('T-FR-06-4: PR author output is the final composite result', async () => {
+        const prOutput = 'Created PR #42: feat(CREW-03-010): implement self-reviewer and PR author';
+        let nonGateIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                nonGateIdx++;
+                if (nonGateIdx === 3) {
+                    return Promise.resolve({
+                        text: prOutput,
+                        toolCalls: [],
+                        tokensIn: 10,
+                        tokensOut: 20,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${nonGateIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        expect(result.content).toBe(prOutput);
+        expect(result.subAgentResults[result.subAgentResults.length - 1].name).toBe('pr-author');
+    });
+    it('PR author receives only git tools', async () => {
+        const noop = async () => ({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read file', parameters: {}, execute: noop },
+            'write-file': {
+                name: 'write-file',
+                description: 'write file',
+                parameters: {},
+                execute: noop,
+            },
+            'git-branch': { name: 'git-branch', description: 'branch', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'commit', parameters: {}, execute: noop },
+            'git-push': { name: 'git-push', description: 'push', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'ok' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, tools, tmpDir, selfReviewSkills);
+        const calls = provider.generateText.mock.calls;
+        const prAuthorIdx = calls.findIndex((call) => {
+            const msgs = call[0].messages;
+            return msgs[0]?.content.includes('Sub-task: pull-request');
+        });
+        const prAuthorCall = calls[prAuthorIdx][0];
+        const toolNames = Object.keys(prAuthorCall.tools ?? {}).sort();
+        expect(toolNames).toEqual(['git-branch', 'git-commit', 'git-push']);
+    });
+    it('full chain: implementer -> self-reviewer (pass) -> PR author', async () => {
+        let nonGateIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'no blocking issues' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                nonGateIdx++;
+                const responses = {
+                    1: 'Implemented code changes for CREW-03-010',
+                    2: '## Self-Review Verdict\n\n**Result:** PASS\n\nNo blocking issues.',
+                    3: 'Created PR #42 with structured description',
+                };
+                return Promise.resolve({
+                    text: responses[nonGateIdx] ?? `output-${nonGateIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makePersona(), makeSelfReviewTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, selfReviewSkills);
+        expect(result.subAgentResults).toHaveLength(3);
+        expect(result.subAgentResults[0].name).toBe('implementer');
+        expect(result.subAgentResults[1].name).toBe('self-reviewer');
+        expect(result.subAgentResults[2].name).toBe('pr-author');
+        expect(result.content).toBe('Created PR #42 with structured description');
+        expect(result.checkpoints).toHaveLength(3);
+        expect(result.checkpoints[0].name).toBe('implementer');
+        expect(result.checkpoints[1].name).toBe('self-reviewer');
+        expect(result.checkpoints[2].name).toBe('pr-author');
+    });
+});
+describe('T-CREW-05: Architect adr-workflow composite task', () => {
+    function makeAdrWorkflowTask(overrides) {
+        return {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'planner',
+                    skill: 'adr-plan',
+                    reads: ['requirements', 'architecture', 'adr-register', 'codebase-structure'],
+                    produces: 'decision-plan',
+                    tools: ['read-artifact', 'read-code'],
+                },
+                {
+                    name: 'writer',
+                    skill: 'adr-write',
+                    reads: ['decision-plan', 'requirements', 'architecture', 'adr-register'],
+                    produces: 'adr-drafts',
+                    tools: ['read-artifact', 'write-artifact', 'read-code'],
+                },
+                {
+                    name: 'reviewer',
+                    skill: 'adr-review',
+                    reads: ['adr-drafts', 'architecture', 'adr-register'],
+                    produces: 'adr-review',
+                    tools: ['read-artifact'],
+                    gate: 'all ADRs pass quality checks',
+                    on_fail: 'writer',
+                    max_loops: 2,
+                },
+            ],
+            published_artifact: 'adr-summary',
+            ...overrides,
+        };
+    }
+    function makeArchitectPersona() {
+        return {
+            persona: {
+                name: 'architect',
+                identity: { role: 'Senior Solution Architect' },
+                skills: ['adr-plan', 'adr-write', 'adr-review'],
+                perception: { per_task: {} },
+                tasks: {},
+                tools: {
+                    permitted: ['read-artifact', 'write-artifact', 'read-code'],
+                    denied: ['write-code', 'git-write', 'git-operations', 'shell'],
+                },
+                cadence: {},
+                evaluation: { rubric: 'rubrics/adr.rubric.yaml' },
+            },
+        };
+    }
+    const adrSkills = {
+        'adr-plan': 'Identify consequential architecture decisions for this epic.',
+        'adr-write': 'Write a draft ADR following the project template with balanced options analysis.',
+        'adr-review': 'Review ADRs for completeness, balance, and consistency with existing decisions.',
+    };
+    function gatePassingAdrProvider(responses) {
+        let subAgentIdx = 0;
+        const subAgentNames = ['planner', 'writer', 'reviewer'];
+        return {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'all ADRs pass quality checks' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                const name = subAgentNames[subAgentIdx] ?? 'unknown';
+                subAgentIdx++;
+                return Promise.resolve({
+                    text: responses[name] ?? `${name} output`,
+                    toolCalls: [],
+                    tokensIn: 80,
+                    tokensOut: 40,
+                });
+            }),
+        };
+    }
+    it('executes all 3 sub-agents in sequence: planner -> writer -> reviewer', async () => {
+        const provider = gatePassingAdrProvider({
+            planner: '## Decision Plan\n1. ADR-0017: Persona-spec-driven protected paths',
+            writer: '## ADR Drafts\n| ADR-0017 | Proposed |',
+            reviewer: '## ADR Review\nAll ADRs pass quality checks.',
+        });
+        const result = await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        expect(result.subAgentResults).toHaveLength(3);
+        expect(result.subAgentResults[0].name).toBe('planner');
+        expect(result.subAgentResults[1].name).toBe('writer');
+        expect(result.subAgentResults[2].name).toBe('reviewer');
+    });
+    it('planner output flows to writer via working state', async () => {
+        const planOutput = '## Decision Plan\n1. ADR-0017: Protected path configuration model';
+        const provider = gatePassingAdrProvider({
+            planner: planOutput,
+            writer: 'ADR drafts written',
+            reviewer: 'Review complete',
+        });
+        await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        const calls = provider.generateText.mock.calls;
+        const writerPrompt = calls[1][0].messages[0].content;
+        expect(writerPrompt).toContain(planOutput);
+    });
+    it('writer output flows to reviewer via working state', async () => {
+        const writerOutput = '## ADR Drafts\n| ADR-0017 | Protected paths | Proposed |';
+        const provider = gatePassingAdrProvider({
+            planner: 'Decision plan',
+            writer: writerOutput,
+            reviewer: 'Review pass',
+        });
+        await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        const calls = provider.generateText.mock.calls;
+        const reviewerPrompt = calls[2][0].messages[0]
+            .content;
+        expect(reviewerPrompt).toContain(writerOutput);
+    });
+    it('each sub-agent receives its own skill prompt', async () => {
+        const provider = gatePassingAdrProvider({});
+        await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('consequential architecture decisions');
+        expect(plannerPrompt).not.toContain('balanced options analysis');
+        const writerPrompt = calls[1][0].messages[0].content;
+        expect(writerPrompt).toContain('balanced options analysis');
+        expect(writerPrompt).not.toContain('completeness, balance, and consistency');
+        const reviewerPrompt = calls[2][0].messages[0]
+            .content;
+        expect(reviewerPrompt).toContain('completeness, balance, and consistency');
+    });
+    it('checkpoints are named correctly for all 3 sub-agents', async () => {
+        const provider = gatePassingAdrProvider({});
+        const result = await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        expect(result.checkpoints).toHaveLength(3);
+        expect(result.checkpoints[0].path).toContain('01-planner.md');
+        expect(result.checkpoints[0].name).toBe('planner');
+        expect(result.checkpoints[1].path).toContain('02-writer.md');
+        expect(result.checkpoints[1].name).toBe('writer');
+        expect(result.checkpoints[2].path).toContain('03-reviewer.md');
+        expect(result.checkpoints[2].name).toBe('reviewer');
+    });
+    it('final output is from the reviewer sub-agent', async () => {
+        const reviewOutput = '## ADR Review Summary\nAll 2 ADRs pass quality checks.';
+        const provider = gatePassingAdrProvider({ reviewer: reviewOutput });
+        const result = await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        expect(result.content).toBe(reviewOutput);
+    });
+    it('applies correct tool restrictions per sub-agent', async () => {
+        const noop = async () => ({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read artifact',
+                parameters: {},
+                execute: noop,
+            },
+            'write-artifact': {
+                name: 'write-artifact',
+                description: 'write artifact',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read', parameters: {}, execute: noop },
+            'list-directory': {
+                name: 'list-directory',
+                description: 'list',
+                parameters: {},
+                execute: noop,
+            },
+            'search-codebase': {
+                name: 'search-codebase',
+                description: 'search',
+                parameters: {},
+                execute: noop,
+            },
+            'write-file': { name: 'write-file', description: 'write', parameters: {}, execute: noop },
+            'git-branch': { name: 'git-branch', description: 'branch', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = gatePassingAdrProvider({});
+        await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, tools, tmpDir, adrSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerTools = Object.keys(calls[0][0].tools ?? {}).sort();
+        expect(plannerTools).toEqual(['read-artifact', 'read-file', 'list-directory', 'search-codebase'].sort());
+        const writerTools = Object.keys(calls[1][0].tools ?? {}).sort();
+        expect(writerTools).toEqual(['read-artifact', 'write-artifact', 'read-file', 'list-directory', 'search-codebase'].sort());
+        const reviewerIdx = calls.findIndex((call) => {
+            const msgs = call[0].messages;
+            return msgs[0]?.content.includes('Sub-task: adr-review');
+        });
+        const reviewerTools = Object.keys(calls[reviewerIdx][0].tools ?? {}).sort();
+        expect(reviewerTools).toEqual(['read-artifact']);
+    });
+    it('denied tools are never provided to any sub-agent', async () => {
+        const noop = async () => ({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'write-artifact': {
+                name: 'write-artifact',
+                description: 'write',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read', parameters: {}, execute: noop },
+            'write-file': { name: 'write-file', description: 'write', parameters: {}, execute: noop },
+            'git-branch': { name: 'git-branch', description: 'git', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'git', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = gatePassingAdrProvider({});
+        await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, tools, tmpDir, adrSkills);
+        const calls = provider.generateText.mock.calls;
+        for (const call of calls) {
+            const callTools = call[0].tools ?? {};
+            const toolNames = Object.keys(callTools);
+            expect(toolNames).not.toContain('write-file');
+            expect(toolNames).not.toContain('git-branch');
+            expect(toolNames).not.toContain('git-commit');
+            expect(toolNames).not.toContain('run-command');
+        }
+    });
+    it('reviewer gate failure loops back to writer', async () => {
+        let callIdx = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                callIdx++;
+                if (opts.system.includes('gate evaluator')) {
+                    const pass = callIdx > 5;
+                    return Promise.resolve({
+                        text: JSON.stringify({
+                            pass,
+                            reason: pass ? 'all ADRs pass' : 'ADR-0017 options analysis is one-sided',
+                        }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: `output-${callIdx}`,
+                    toolCalls: [],
+                    tokensIn: 80,
+                    tokensOut: 40,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        const writerResults = result.subAgentResults.filter((r) => r.name === 'writer');
+        expect(writerResults.length).toBeGreaterThan(1);
+        const reviewerResults = result.subAgentResults.filter((r) => r.name === 'reviewer');
+        expect(reviewerResults.length).toBeGreaterThan(1);
+        expect(result.content).not.toBe('');
+    });
+    it('max_loops exhaustion returns empty content', async () => {
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: false, reason: 'ADR quality insufficient' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                return Promise.resolve({
+                    text: 'some output',
+                    toolCalls: [],
+                    tokensIn: 80,
+                    tokensOut: 40,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        expect(result.content).toBe('');
+    });
+    it('assembled context blocks are available to planner', async () => {
+        const contextWithBlocks = {
+            blocks: [
+                {
+                    content: 'CREW-05 requirements: automate ADR workflow',
+                    source: { type: 'requirements', path: 'work/CREW-05/requirements.md' },
+                    tokens: 200,
+                    priority: 'required',
+                },
+                {
+                    content: 'Solution architecture: artifact-centric delivery system',
+                    source: { type: 'architecture', path: 'architecture/solution.md' },
+                    tokens: 300,
+                    priority: 'required',
+                },
+            ],
+            totalTokens: 500,
+            budgetLimit: 100_000,
+            gaps: [],
+        };
+        const provider = gatePassingAdrProvider({});
+        await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), contextWithBlocks, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('CREW-05 requirements: automate ADR workflow');
+        expect(plannerPrompt).toContain('artifact-centric delivery system');
+    });
+    it('accumulates tokens across all sub-agents', async () => {
+        const provider = gatePassingAdrProvider({});
+        const result = await executeCompositeTask(makeArchitectPersona(), makeAdrWorkflowTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, adrSkills);
+        expect(result.tokensIn).toBe(240);
+        expect(result.tokensOut).toBe(120);
+    });
+});
+describe('T-FR-03: implementer sub-agent', () => {
+    function makeImplementerTask() {
+        return {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'planner',
+                    skill: 'implementation-planner',
+                    reads: ['requirements', 'design'],
+                    produces: 'implementation-plan',
+                },
+                {
+                    name: 'implementer',
+                    skill: 'implement-code',
+                    reads: ['implementation-plan', 'codebase'],
+                    produces: 'code-changes',
+                    tools: ['code', 'git', 'shell'],
+                },
+            ],
+            published_artifact: 'code-changes',
+        };
+    }
+    function makeImplementerPersona() {
+        return {
+            persona: {
+                name: 'engineer',
+                identity: { role: 'Senior Software Engineer' },
+                skills: [
+                    'feature-implementation',
+                    'implement-code',
+                    'implementation-planner',
+                    'code-review',
+                ],
+                perception: { per_task: {} },
+                tasks: {},
+                tools: {
+                    permitted: ['read-artifact', 'code', 'git-operations', 'shell'],
+                    denied: ['write-strategy-artifacts'],
+                },
+                cadence: {},
+                evaluation: { rubric: 'test.rubric.yaml' },
+            },
+        };
+    }
+    const implementerSkills = {
+        'implementation-planner': 'Analyze requirements and produce an implementation plan.',
+        'implement-code': 'You are the Implementer sub-agent. Read the plan, write code, create branch, commit.',
+    };
+    it('T-FR-03-1: implementer receives implement-code skill prompt', async () => {
+        const provider = sequentialProvider(['the plan', 'code written']);
+        await executeCompositeTask(makeImplementerPersona(), makeImplementerTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, implementerSkills);
+        const calls = provider.generateText.mock.calls;
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain('Implementer sub-agent');
+        expect(implementerPrompt).not.toContain('Analyze requirements');
+    });
+    it('T-FR-03-2: implementer receives implementation-plan from working state', async () => {
+        const planText = '## Plan\n\n1. Create src/tools/registry.ts\n2. Create branch feat/CREW-03-007';
+        const provider = sequentialProvider([planText, 'code changes summary']);
+        await executeCompositeTask(makeImplementerPersona(), makeImplementerTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, implementerSkills);
+        const calls = provider.generateText.mock.calls;
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain(planText);
+        expect(implementerPrompt).toContain('Working State');
+    });
+    it('T-FR-03-3: implementer output is checkpointed as 02-implementer.md', async () => {
+        const provider = sequentialProvider(['the plan', 'code changes output']);
+        const result = await executeCompositeTask(makeImplementerPersona(), makeImplementerTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, implementerSkills);
+        expect(result.checkpoints[1].name).toBe('implementer');
+        expect(result.checkpoints[1].path).toContain('02-implementer.md');
+        const content = await readFile(result.checkpoints[1].path, 'utf-8');
+        expect(content).toBe('code changes output');
+    });
+    it('T-FR-03-4: implementer gets write-code, git, and shell tools', async () => {
+        const noop = vi.fn().mockResolvedValue({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read file', parameters: {}, execute: noop },
+            'write-file': {
+                name: 'write-file',
+                description: 'write file',
+                parameters: {},
+                execute: noop,
+            },
+            'list-directory': {
+                name: 'list-directory',
+                description: 'list dir',
+                parameters: {},
+                execute: noop,
+            },
+            'search-codebase': {
+                name: 'search-codebase',
+                description: 'search',
+                parameters: {},
+                execute: noop,
+            },
+            'git-branch': { name: 'git-branch', description: 'branch', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'commit', parameters: {}, execute: noop },
+            'git-push': { name: 'git-push', description: 'push', parameters: {}, execute: noop },
+            'git-diff': { name: 'git-diff', description: 'diff', parameters: {}, execute: noop },
+            'git-log': { name: 'git-log', description: 'log', parameters: {}, execute: noop },
+            'create-pr': { name: 'create-pr', description: 'pr', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = sequentialProvider(['plan', 'code']);
+        await executeCompositeTask(makeImplementerPersona(), makeImplementerTask(), emptyContext, mockModel, provider, tools, tmpDir, implementerSkills);
+        const calls = provider.generateText.mock.calls;
+        const implementerTools = calls[1][0].tools ?? {};
+        const toolNames = Object.keys(implementerTools).sort();
+        expect(toolNames).toEqual([
+            'create-pr',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+            'list-directory',
+            'read-file',
+            'run-command',
+            'search-codebase',
+            'write-file',
+        ]);
+    });
+    it('implementer includes Sub-task: code-changes in the prompt', async () => {
+        const provider = sequentialProvider(['plan', 'code']);
+        await executeCompositeTask(makeImplementerPersona(), makeImplementerTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, implementerSkills);
+        const calls = provider.generateText.mock.calls;
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain('Sub-task: code-changes');
+    });
+    it('implementer uses different skill than planner', async () => {
+        const provider = sequentialProvider(['plan', 'code']);
+        await executeCompositeTask(makeImplementerPersona(), makeImplementerTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, implementerSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('Analyze requirements');
+        expect(plannerPrompt).not.toContain('Implementer sub-agent');
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain('Implementer sub-agent');
+        expect(implementerPrompt).not.toContain('Analyze requirements');
+    });
+    it('implementer output flows to downstream sub-agents', async () => {
+        const codeOutput = 'Branch: feat/CREW-03-007\nFiles: registry.ts, tool-groups.ts\nCommits: 2';
+        const task = {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'planner',
+                    skill: 'implementation-planner',
+                    reads: [],
+                    produces: 'implementation-plan',
+                },
+                {
+                    name: 'implementer',
+                    skill: 'implement-code',
+                    reads: ['implementation-plan'],
+                    produces: 'code-changes',
+                    tools: ['code', 'git'],
+                },
+                { name: 'reviewer', skill: 'code-review', reads: ['code-changes'], produces: 'review' },
+            ],
+            published_artifact: 'review',
+        };
+        const skills = {
+            'implementation-planner': 'planner prompt',
+            'implement-code': 'implementer prompt',
+            'code-review': 'review prompt',
+        };
+        const provider = sequentialProvider(['the plan', codeOutput, 'review OK']);
+        await executeCompositeTask(makeImplementerPersona(), task, emptyContext, mockModel, provider, emptyTools, tmpDir, skills);
+        const calls = provider.generateText.mock.calls;
+        const reviewerPrompt = calls[2][0].messages[0]
+            .content;
+        expect(reviewerPrompt).toContain(codeOutput);
+    });
+});
+describe('T-FR-07: end-to-end implement-story composite task', () => {
+    /**
+     * Full 6-step sub-agent chain matching the engineer persona spec:
+     * planner -> implementer -> test-writer -> quality-checker -> self-reviewer -> pr-author
+     */
+    function makeFullImplementStoryTask() {
+        return {
+            mode: 'composite',
+            trigger: ['manual'],
+            sub_agents: [
+                {
+                    name: 'planner',
+                    skill: 'implementation-planner',
+                    reads: ['requirements', 'design', 'codebase-structure'],
+                    produces: 'implementation-plan',
+                    tools: ['read-artifact'],
+                },
+                {
+                    name: 'implementer',
+                    skill: 'implement-code',
+                    reads: ['implementation-plan', 'codebase'],
+                    produces: 'code-changes',
+                    tools: ['code', 'git', 'shell'],
+                },
+                {
+                    name: 'test-writer',
+                    skill: 'test-writing',
+                    reads: ['code-changes', 'requirements'],
+                    produces: 'test-files',
+                    tools: ['code', 'git', 'shell'],
+                },
+                {
+                    name: 'quality-checker',
+                    skill: 'quality-check',
+                    reads: ['code-changes', 'test-files'],
+                    produces: 'quality-report',
+                    tools: ['shell', 'code', 'git'],
+                    max_iterations: 3,
+                },
+                {
+                    name: 'self-reviewer',
+                    skill: 'self-review',
+                    reads: ['code-changes', 'design', 'standards'],
+                    produces: 'self-review',
+                    gate: 'no blocking issues',
+                    on_fail: 'implementer',
+                    max_loops: 2,
+                },
+                {
+                    name: 'pr-author',
+                    skill: 'pr-authoring',
+                    reads: ['code-changes', 'requirements', 'self-review'],
+                    produces: 'pull-request',
+                    tools: ['git'],
+                },
+            ],
+            published_artifact: 'pull-request',
+            quality_gate: 'human-review',
+        };
+    }
+    function makeEngineerPersona() {
+        return {
+            persona: {
+                name: 'engineer',
+                identity: { role: 'Senior Software Engineer' },
+                skills: [
+                    'feature-implementation',
+                    'implement-code',
+                    'implementation-planner',
+                    'code-review',
+                    'quality-check',
+                    'test-writing',
+                    'self-review',
+                    'pr-authoring',
+                ],
+                perception: { per_task: {} },
+                tasks: {},
+                tools: {
+                    permitted: ['read-artifact', 'write-artifact', 'code', 'git-operations', 'shell'],
+                    denied: ['write-strategy-artifacts', 'write-standards'],
+                },
+                cadence: {},
+                evaluation: { rubric: 'rubrics/pull-request.rubric.yaml' },
+            },
+        };
+    }
+    const allSkills = {
+        'implementation-planner': 'Analyze requirements and produce an implementation plan.',
+        'implement-code': 'Write code following the plan. Create branch, commit changes.',
+        'test-writing': 'Write tests covering acceptance criteria.',
+        'quality-check': 'Run lint, typecheck, tests. Fix failures iteratively.',
+        'self-review': 'Review changes against design. Report blocking issues.',
+        'pr-authoring': 'Create a GitHub PR with structured description.',
+        'feature-implementation': 'Feature implementation skill.',
+        'code-review': 'Code review skill.',
+    };
+    function gatePassingProvider(responses) {
+        let subAgentIdx = 0;
+        const subAgentNames = [
+            'planner',
+            'implementer',
+            'test-writer',
+            'quality-checker',
+            'self-reviewer',
+            'pr-author',
+        ];
+        return {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass: true, reason: 'no blocking issues' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                const name = subAgentNames[subAgentIdx] ?? 'unknown';
+                subAgentIdx++;
+                return Promise.resolve({
+                    text: responses[name] ?? `${name} output`,
+                    toolCalls: [],
+                    tokensIn: 100,
+                    tokensOut: 50,
+                });
+            }),
+        };
+    }
+    it('executes all 6 sub-agents in sequence', async () => {
+        const provider = gatePassingProvider({
+            planner: '## Plan\nModify engine/composite.ts',
+            implementer: 'Created branch, wrote code, committed',
+            'test-writer': 'Added 5 test cases for composite engine',
+            'quality-checker': 'Lint: pass, Typecheck: pass, Tests: 14/14 pass',
+            'self-reviewer': '## Verdict: PASS\nNo blocking issues.',
+            'pr-author': 'Created PR #47: feat(CREW-03-011): end-to-end composite task',
+        });
+        const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
+        expect(result.subAgentResults).toHaveLength(6);
+        expect(result.subAgentResults[0].name).toBe('planner');
+        expect(result.subAgentResults[1].name).toBe('implementer');
+        expect(result.subAgentResults[2].name).toBe('test-writer');
+        expect(result.subAgentResults[3].name).toBe('quality-checker');
+        expect(result.subAgentResults[4].name).toBe('self-reviewer');
+        expect(result.subAgentResults[5].name).toBe('pr-author');
+    });
+    it('shares working state between all sub-agents', async () => {
+        const planOutput = '## Plan\n1. Modify composite.ts\n2. Add tests';
+        const codeOutput = 'Branch: feat/CREW-03-011\nFiles: composite.ts\nCommits: 3';
+        const testOutput = 'Added test-files covering all 5 AC items';
+        const provider = gatePassingProvider({
+            planner: planOutput,
+            implementer: codeOutput,
+            'test-writer': testOutput,
+            'quality-checker': 'All checks pass',
+            'self-reviewer': 'PASS: no issues',
+            'pr-author': 'PR created',
+        });
+        await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
+        const calls = provider.generateText.mock.calls;
+        const implementerPrompt = calls[1][0].messages[0]
+            .content;
+        expect(implementerPrompt).toContain(planOutput);
+        const testWriterPrompt = calls[2][0].messages[0]
+            .content;
+        expect(testWriterPrompt).toContain(codeOutput);
+        const qualityPrompt = calls[3][0].messages[0]
+            .content;
+        expect(qualityPrompt).toContain(codeOutput);
+        expect(qualityPrompt).toContain(testOutput);
+    });
+    it('checkpoints all 6 intermediate work products', async () => {
+        const provider = gatePassingProvider({});
+        const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
+        expect(result.checkpoints).toHaveLength(6);
+        expect(result.checkpoints[0].path).toContain('01-planner.md');
+        expect(result.checkpoints[1].path).toContain('02-implementer.md');
+        expect(result.checkpoints[2].path).toContain('03-test-writer.md');
+        expect(result.checkpoints[3].path).toContain('04-quality-checker.md');
+        expect(result.checkpoints[4].path).toContain('05-self-reviewer.md');
+        expect(result.checkpoints[5].path).toContain('06-pr-author.md');
+        for (const cp of result.checkpoints) {
+            const content = await readFile(cp.path, 'utf-8');
+            expect(content).toBeTruthy();
+        }
+    });
+    it('final output is from the PR author sub-agent', async () => {
+        const prOutput = 'Created PR #47: feat(CREW-03-011): end-to-end composite task wiring';
+        const provider = gatePassingProvider({
+            'pr-author': prOutput,
+        });
+        const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
+        expect(result.content).toBe(prOutput);
+    });
+    it('accumulates tokens across all 6 sub-agents', async () => {
+        const provider = gatePassingProvider({});
+        const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
+        expect(result.tokensIn).toBe(600);
+        expect(result.tokensOut).toBe(300);
+    });
+    it('self-reviewer gate failure loops back to implementer', async () => {
+        let subAgentIdx = 0;
+        let gateCallCount = 0;
+        const provider = {
+            generateText: vi
+                .fn()
+                .mockImplementation((opts) => {
+                if (opts.system.includes('gate evaluator')) {
+                    gateCallCount++;
+                    const pass = gateCallCount > 1;
+                    return Promise.resolve({
+                        text: JSON.stringify({ pass, reason: pass ? 'resolved' : 'blocking issue found' }),
+                        toolCalls: [],
+                        tokensIn: 5,
+                        tokensOut: 5,
+                    });
+                }
+                subAgentIdx++;
+                return Promise.resolve({
+                    text: `step-${subAgentIdx}`,
+                    toolCalls: [],
+                    tokensIn: 10,
+                    tokensOut: 20,
+                });
+            }),
+        };
+        const result = await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, emptyTools, tmpDir, allSkills);
+        const names = result.subAgentResults.map((r) => r.name);
+        expect(names[0]).toBe('planner');
+        expect(names[1]).toBe('implementer');
+        expect(names[2]).toBe('test-writer');
+        expect(names[3]).toBe('quality-checker');
+        expect(names[4]).toBe('self-reviewer');
+        expect(names[5]).toBe('implementer');
+        expect(names[names.length - 1]).toBe('pr-author');
+        expect(result.content).not.toBe('');
+    });
+    it('provides assembled context to planner sub-agent', async () => {
+        const contextWithBlocks = {
+            blocks: [
+                {
+                    content: 'Story acceptance criteria: AC1, AC2, AC3',
+                    source: { type: 'requirements', path: 'work/CREW-03/requirements.md' },
+                    tokens: 100,
+                    priority: 'required',
+                },
+                {
+                    content: 'Technical design: component A, module B',
+                    source: { type: 'design', path: 'work/CREW-03/design.md' },
+                    tokens: 100,
+                    priority: 'required',
+                },
+            ],
+            totalTokens: 200,
+            budgetLimit: 200_000,
+            gaps: [],
+        };
+        const provider = gatePassingProvider({});
+        await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), contextWithBlocks, mockModel, provider, emptyTools, tmpDir, allSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerPrompt = calls[0][0].messages[0]
+            .content;
+        expect(plannerPrompt).toContain('Story acceptance criteria');
+        expect(plannerPrompt).toContain('Technical design');
+    });
+    it('applies correct tool restrictions per sub-agent', async () => {
+        const noop = async () => ({});
+        const tools = {
+            'read-artifact': {
+                name: 'read-artifact',
+                description: 'read',
+                parameters: {},
+                execute: noop,
+            },
+            'read-file': { name: 'read-file', description: 'read', parameters: {}, execute: noop },
+            'write-file': { name: 'write-file', description: 'write', parameters: {}, execute: noop },
+            'list-directory': {
+                name: 'list-directory',
+                description: 'list',
+                parameters: {},
+                execute: noop,
+            },
+            'search-codebase': {
+                name: 'search-codebase',
+                description: 'search',
+                parameters: {},
+                execute: noop,
+            },
+            'git-branch': { name: 'git-branch', description: 'branch', parameters: {}, execute: noop },
+            'git-commit': { name: 'git-commit', description: 'commit', parameters: {}, execute: noop },
+            'git-push': { name: 'git-push', description: 'push', parameters: {}, execute: noop },
+            'git-diff': { name: 'git-diff', description: 'diff', parameters: {}, execute: noop },
+            'git-log': { name: 'git-log', description: 'log', parameters: {}, execute: noop },
+            'create-pr': { name: 'create-pr', description: 'pr', parameters: {}, execute: noop },
+            'run-command': { name: 'run-command', description: 'shell', parameters: {}, execute: noop },
+        };
+        const provider = gatePassingProvider({});
+        await executeCompositeTask(makeEngineerPersona(), makeFullImplementStoryTask(), emptyContext, mockModel, provider, tools, tmpDir, allSkills);
+        const calls = provider.generateText.mock.calls;
+        const plannerTools = Object.keys(calls[0][0].tools ?? {}).sort();
+        expect(plannerTools).toEqual(['read-artifact']);
+        const implementerTools = Object.keys(calls[1][0].tools ?? {}).sort();
+        expect(implementerTools).toEqual([
+            'create-pr',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+            'list-directory',
+            'read-file',
+            'run-command',
+            'search-codebase',
+            'write-file',
+        ]);
+        const testWriterTools = Object.keys(calls[2][0].tools ?? {}).sort();
+        expect(testWriterTools).toEqual([
+            'create-pr',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+            'list-directory',
+            'read-file',
+            'run-command',
+            'search-codebase',
+            'write-file',
+        ]);
+        const qualityCheckerTools = Object.keys(calls[3][0].tools ?? {}).sort();
+        expect(qualityCheckerTools).toEqual([
+            'create-pr',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+            'list-directory',
+            'read-file',
+            'run-command',
+            'search-codebase',
+            'write-file',
+        ]);
+        const prAuthorIdx = calls.findIndex((call) => {
+            const msgs = call[0].messages;
+            return msgs[0]?.content.includes('Sub-task: pull-request');
+        });
+        const prAuthorTools = Object.keys(calls[prAuthorIdx][0].tools ?? {}).sort();
+        expect(prAuthorTools).toEqual([
+            'create-pr',
+            'git-branch',
+            'git-commit',
+            'git-diff',
+            'git-log',
+            'git-push',
+        ]);
+    });
+});