@doingdev/opencode-claude-manager-plugin 0.1.64 → 0.1.66

package/dist/test/team-orchestrator.test.js

@@ -1,583 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { TeamOrchestrator } from '../src/manager/team-orchestrator.js';
-import { TeamStateStore } from '../src/state/team-state-store.js';
-// Full BrowserQA capabilities used in all test orchestrator instances
-const BROWSER_QA_TEST_CAPS = {
-    sessionPrompt: 'Browser QA prompt',
-    restrictWriteTools: true,
-    skipModeInstructions: true,
-    plannerEligible: false,
-    isRuntimeUnavailableResponse: (text) => text.trimStart().startsWith('PLAYWRIGHT_UNAVAILABLE:'),
-    runtimeUnavailableTitle: '❌ Playwright unavailable',
-};
-describe('TeamOrchestrator', () => {
-    let tempRoot;
-    afterEach(async () => {
-        if (tempRoot) {
-            await rm(tempRoot, { recursive: true, force: true });
-        }
-    });
-    it('dispatches work to a named engineer and persists the Claude session', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const runTask = vi
-            .fn()
-            .mockResolvedValueOnce({
-            sessionId: 'ses_tom',
-            events: [{ type: 'result', text: 'done', turns: 1, totalCostUsd: 0.02 }],
-            finalText: 'Done.',
-            turns: 1,
-            totalCostUsd: 0.02,
-            inputTokens: 1000,
-            outputTokens: 200,
-            contextWindowSize: 200_000,
-        })
-            .mockResolvedValueOnce({
-            sessionId: 'ses_tom',
-            events: [{ type: 'result', text: 'done again', turns: 2, totalCostUsd: 0.03 }],
-            finalText: 'Done again.',
-            turns: 2,
-            totalCostUsd: 0.03,
-            inputTokens: 2000,
-            outputTokens: 300,
-            contextWindowSize: 200_000,
-        });
-        const store = new TeamStateStore('.state');
-        const orchestrator = new TeamOrchestrator({ runTask }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const first = await orchestrator.dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'Tom',
-            mode: 'explore',
-            message: 'Investigate the auth flow',
-        });
-        const second = await orchestrator.dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'Tom',
-            mode: 'implement',
-            message: 'Implement the chosen fix',
-        });
-        expect(first.sessionId).toBe('ses_tom');
-        expect(second.sessionId).toBe('ses_tom');
-        expect(runTask.mock.calls[0]?.[0]).toMatchObject({
-            resumeSessionId: undefined,
-            permissionMode: 'acceptEdits',
-            restrictWriteTools: true,
-        });
-        expect(runTask.mock.calls[0]?.[0].systemPrompt).toBeUndefined();
-        expect(runTask.mock.calls[0]?.[0].prompt).toContain('Base engineer prompt');
-        expect(runTask.mock.calls[0]?.[0].prompt).toContain('Assigned engineer: Tom.');
-        expect(runTask.mock.calls[0]?.[0].prompt).toContain('Investigate the auth flow');
-        expect(runTask.mock.calls[0]?.[0].prompt).toContain('The caller should specify the desired output');
-        expect(runTask.mock.calls[0]?.[0].prompt).not.toContain('Produce a concrete plan');
-        expect(runTask.mock.calls[1]?.[0]).toMatchObject({
-            resumeSessionId: 'ses_tom',
-            permissionMode: 'acceptEdits',
-            restrictWriteTools: false,
-        });
-        expect(runTask.mock.calls[1]?.[0].systemPrompt).toBeUndefined();
-        expect(runTask.mock.calls[1]?.[0].prompt).not.toContain('Assigned engineer: Tom.');
-        expect(runTask.mock.calls[1]?.[0].prompt).toContain('Implement the chosen fix');
-        // Hybrid workflow: implement mode must include a pre-implementation plan step
-        expect(runTask.mock.calls[1]?.[0].prompt).toContain('state a brief implementation plan');
-        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        expect(team.engineers.find((engineer) => engineer.name === 'Tom')).toMatchObject({
-            claudeSessionId: 'ses_tom',
-            busy: false,
-            lastMode: 'implement',
-        });
-    });
-    it('rejects work when the same engineer is already busy', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const store = new TeamStateStore('.state');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await store.saveTeam({
-            ...team,
-            engineers: team.engineers.map((engineer) => engineer.name === 'Tom'
-                ? {
-                    ...engineer,
-                    busy: true,
-                }
-                : engineer),
-        });
-        await expect(orchestrator.dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'Tom',
-            mode: 'explore',
-            message: 'Investigate again',
-        })).rejects.toThrow('Tom is already working on another assignment.');
-    });
-    it('creates two drafts and synthesizes them into one plan', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const runTask = vi
-            .fn()
-            .mockResolvedValueOnce({
-            sessionId: 'ses_tom',
-            events: [],
-            finalText: '## Objective\nLead plan',
-        })
-            .mockResolvedValueOnce({
-            sessionId: 'ses_maya',
-            events: [],
-            finalText: '## Objective\nChallenger plan',
-        })
-            .mockResolvedValueOnce({
-            sessionId: undefined,
-            events: [],
-            finalText: '## Synthesis\nCombined plan\n## Recommended Question\nShould we migrate now?\n## Recommended Answer\nNo, defer it.',
-        });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const result = await orchestrator.planWithTeam({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            request: 'Plan the billing refactor',
-            leadEngineer: 'Tom',
-            challengerEngineer: 'Maya',
-        });
-        expect(result.drafts).toHaveLength(2);
-        expect(result.synthesis).toBe('Combined plan');
-        expect(result.recommendedQuestion).toBe('Should we migrate now?');
-        expect(result.recommendedAnswer).toBe('No, defer it.');
-        expect(runTask).toHaveBeenCalledTimes(3);
-        const synthesisCall = runTask.mock.calls[2]?.[0];
-        expect(synthesisCall.systemPrompt).toBeUndefined();
-        expect(synthesisCall.prompt).toContain('Synthesis prompt');
-        expect(synthesisCall.prompt).toContain('Plan the billing refactor');
-    });
-    it('invokes lead, challenger, and synthesis event callbacks', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const runTask = vi.fn(async (input, onEvent) => {
-            // Simulate event callbacks being invoked by the session
-            if (onEvent) {
-                await Promise.resolve(onEvent({ type: 'init', text: 'initialized' }));
-            }
-            // Return appropriate result based on call count
-            const calls = runTask.mock.calls.length;
-            if (calls === 1) {
-                return {
-                    sessionId: 'ses_tom',
-                    events: [{ type: 'init', text: 'initialized', sessionId: 'ses_tom' }],
-                    finalText: 'Lead plan',
-                };
-            }
-            else if (calls === 2) {
-                return {
-                    sessionId: 'ses_maya',
-                    events: [{ type: 'init', text: 'initialized', sessionId: 'ses_maya' }],
-                    finalText: 'Challenger plan',
-                };
-            }
-            else {
-                return {
-                    sessionId: undefined,
-                    events: [{ type: 'init', text: 'initialized', sessionId: undefined }],
-                    finalText: '## Synthesis\nSynthesis\n## Recommended Question\nNONE\n## Recommended Answer\nNONE',
-                };
-            }
-        });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const onLeadEvent = vi.fn();
-        const onChallengerEvent = vi.fn();
-        const onSynthesisEvent = vi.fn();
-        await orchestrator.planWithTeam({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            request: 'Plan the refactor',
-            leadEngineer: 'Tom',
-            challengerEngineer: 'Maya',
-            onLeadEvent,
-            onChallengerEvent,
-            onSynthesisEvent,
-        });
-        expect(onLeadEvent).toHaveBeenCalled();
-        expect(onChallengerEvent).toHaveBeenCalled();
-        expect(onSynthesisEvent).toHaveBeenCalled();
-    });
-    it('persists wrapper session memory for an engineer', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.recordWrapperSession(tempRoot, 'team-1', 'Tom', 'wrapper-tom');
-        await orchestrator.recordWrapperExchange(tempRoot, 'team-1', 'Tom', 'wrapper-tom', 'explore', 'Investigate the auth flow and compare approaches', 'The auth flow uses one shared validator and the cookie refresh path is the main risk.');
-        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        expect(team.engineers.find((engineer) => engineer.name === 'Tom')).toMatchObject({
-            wrapperSessionId: 'wrapper-tom',
-            lastMode: 'explore',
-        });
-        const wrapperContext = await orchestrator.getWrapperSystemContext(tempRoot, 'team-1', 'Tom');
-        expect(wrapperContext).toContain('Persistent wrapper memory for Tom');
-        expect(wrapperContext).toContain('assignment [explore]');
-        expect(wrapperContext).toContain('result [explore]');
-        await expect(orchestrator.findTeamByWrapperSession(tempRoot, 'wrapper-tom')).resolves.toEqual({
-            teamId: 'team-1',
-            engineer: 'Tom',
-        });
-    });
-    it('planWithTeam auto-selects two distinct engineers when names are omitted', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const runTask = vi.fn(async (_input, _onEvent) => {
-            // Return different results for lead vs challenger
-            const calls = runTask.mock.calls.length;
-            if (calls === 1) {
-                return {
-                    sessionId: 'ses_lead',
-                    events: [],
-                    finalText: 'Lead plan',
-                    turns: 1,
-                    totalCostUsd: 0.01,
-                    inputTokens: 100,
-                    outputTokens: 50,
-                    contextWindowSize: 200_000,
-                };
-            }
-            else if (calls === 2) {
-                return {
-                    sessionId: 'ses_challenger',
-                    events: [],
-                    finalText: 'Challenger plan',
-                    turns: 1,
-                    totalCostUsd: 0.01,
-                    inputTokens: 100,
-                    outputTokens: 50,
-                    contextWindowSize: 200_000,
-                };
-            }
-            else {
-                return {
-                    sessionId: undefined,
-                    events: [],
-                    finalText: '## Synthesis\nBest plan\n## Recommended Question\nNONE\n## Recommended Answer\nNONE',
-                };
-            }
-        });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const result = await orchestrator.planWithTeam({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            request: 'Plan the refactor',
-            // NOTE: both leadEngineer and challengerEngineer are omitted
-        });
-        expect(result.leadEngineer).toBeDefined();
-        expect(result.challengerEngineer).toBeDefined();
-        expect(result.leadEngineer).not.toEqual(result.challengerEngineer);
-    });
-    it('throws error when fewer than 2 viable engineers exist for planning', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        // Mark all engineers as busy
-        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        for (const engineer of team.engineers) {
-            await orchestrator['updateEngineer'](tempRoot, 'team-1', engineer.name, (e) => ({
-                ...e,
-                busy: true,
-                busySince: new Date().toISOString(),
-            }));
-        }
-        await expect(orchestrator.planWithTeam({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            request: 'Plan something',
-        })).rejects.toThrow('Not enough available engineers for dual planning');
-    });
-    it('context exhaustion retries exactly once with same assignment message and fresh session', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        let callCount = 0;
-        let lastInputMessage = '';
-        const runTask = vi.fn(async (input) => {
-            callCount++;
-            lastInputMessage = input.prompt ?? '';
-            // First call throws context exhaustion, second succeeds
-            if (callCount === 1) {
-                const error = new Error('Token limit exceeded: context exhausted');
-                throw error;
-            }
-            return {
-                sessionId: 'ses_retry',
-                events: [],
-                finalText: 'Success after retry',
-                turns: 1,
-                totalCostUsd: 0.02,
-                inputTokens: 100,
-                outputTokens: 50,
-                contextWindowSize: 200_000,
-            };
-        });
-        const store = new TeamStateStore('.state');
-        const orchestrator = new TeamOrchestrator({ runTask }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const allEvents = [];
-        const result = await orchestrator.dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'Tom',
-            mode: 'implement',
-            message: 'Fix the bug',
-            onEvent: (event) => {
-                allEvents.push({ type: event.type, text: event.text });
-            },
-        });
-        // Verify retry happened exactly once (2 runTask calls total)
-        expect(callCount).toBe(2);
-        // Verify status event was emitted for context exhaustion
-        const statusEvent = allEvents.find((e) => e.type === 'status');
-        expect(statusEvent?.text).toContain('Context exhausted');
-        // Verify the retry message is the same (contains the original task)
-        expect(lastInputMessage).toContain('Fix the bug');
-        // Verify success result
-        expect(result.finalText).toBe('Success after retry');
-    });
-    it('rejects BrowserQA with implement mode', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'browserqa-implement-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const error = await orchestrator
-            .dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'BrowserQA',
-            mode: 'implement',
-            message: 'Write a feature',
-        })
-            .catch((e) => e);
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toContain('BrowserQA is a browser QA specialist');
-        expect(error.message).toContain('does not support implement mode');
-    });
-    it('forwards sessionAllowedTools to runTask when worker has them configured', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'browserqa-allowed-'));
-        const runTask = vi.fn().mockResolvedValueOnce({
-            sessionId: 'ses_qa',
-            events: [],
-            finalText: 'Done.',
-            turns: 1,
-            totalCostUsd: 0.01,
-            inputTokens: 500,
-            outputTokens: 100,
-            contextWindowSize: 200_000,
-        });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', {
-            BrowserQA: {
-                ...BROWSER_QA_TEST_CAPS,
-                sessionAllowedTools: ['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory'],
-            },
-        });
-        await orchestrator.dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'BrowserQA',
-            mode: 'explore',
-            message: 'Run Playwriter tests',
-        });
-        expect(runTask).toHaveBeenCalledOnce();
-        const taskInput = runTask.mock.calls[0]?.[0];
-        expect(taskInput.allowedTools).toEqual(expect.arrayContaining(['Skill', 'Bash', 'Read', 'Grep', 'Glob', 'LS', 'ListDirectory']));
-    });
-    it('passes undefined allowedTools for standard engineers without sessionAllowedTools', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'engineer-no-allowed-'));
-        const runTask = vi.fn().mockResolvedValueOnce({
-            sessionId: 'ses_tom',
-            events: [],
-            finalText: 'Done.',
-            turns: 1,
-            totalCostUsd: 0.01,
-            inputTokens: 500,
-            outputTokens: 100,
-            contextWindowSize: 200_000,
-        });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.dispatchEngineer({
-            teamId: 'team-1',
-            cwd: tempRoot,
-            engineer: 'Tom',
-            mode: 'explore',
-            message: 'Investigate something',
-        });
-        expect(runTask).toHaveBeenCalledOnce();
-        const taskInput = runTask.mock.calls[0]?.[0];
-        expect(taskInput.allowedTools).toBeUndefined();
-    });
-    it('classifyError returns modeNotSupported for implement-mode rejection', () => {
-        const result = TeamOrchestrator.classifyError(new Error('BrowserQA is a browser QA specialist and does not support implement mode. ' +
-            'It can only verify and explore.'));
-        expect(result.failureKind).toBe('modeNotSupported');
-    });
-    it('classifyError still returns sdkError for generic errors', () => {
-        const result = TeamOrchestrator.classifyError(new Error('Something unexpected happened'));
-        expect(result.failureKind).toBe('sdkError');
-    });
-    it('getFailureGuidanceText returns actionable guidance for modeNotSupported', async () => {
-        const { getFailureGuidanceText } = await import('../src/manager/team-orchestrator.js');
-        const guidance = getFailureGuidanceText('modeNotSupported');
-        expect(guidance).toContain('explore');
-        expect(guidance).toContain('verify');
-        expect(guidance).toContain('implement');
-    });
-    it('setActivePlan persists plan with slices on TeamRecord', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        const activePlan = await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Implement billing refactor in three slices',
-            taskSize: 'large',
-            slices: ['types + contracts', 'core logic', 'tests'],
-            preAuthorized: false,
-        });
-        expect(activePlan.id).toMatch(/^plan-/);
-        expect(activePlan.summary).toBe('Implement billing refactor in three slices');
-        expect(activePlan.taskSize).toBe('large');
-        expect(activePlan.preAuthorized).toBe(false);
-        expect(activePlan.slices).toHaveLength(3);
-        expect(activePlan.slices[0]).toMatchObject({
-            index: 0,
-            description: 'types + contracts',
-            status: 'pending',
-        });
-        expect(activePlan.slices[1]).toMatchObject({
-            index: 1,
-            description: 'core logic',
-            status: 'pending',
-        });
-        expect(activePlan.slices[2]).toMatchObject({
-            index: 2,
-            description: 'tests',
-            status: 'pending',
-        });
-        expect(activePlan.currentSliceIndex).toBe(0);
-        expect(activePlan.confirmedAt).not.toBeNull();
-        const retrieved = await orchestrator.getActivePlan(tempRoot, 'team-1');
-        expect(retrieved).toMatchObject({ id: activePlan.id, taskSize: 'large' });
-    });
-    it('clearActivePlan removes activePlan from TeamRecord', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Small task',
-            taskSize: 'simple',
-            slices: [],
-            preAuthorized: false,
-        });
-        const beforeClear = await orchestrator.getActivePlan(tempRoot, 'team-1');
-        expect(beforeClear).not.toBeNull();
-        await orchestrator.clearActivePlan(tempRoot, 'team-1');
-        const afterClear = await orchestrator.getActivePlan(tempRoot, 'team-1');
-        expect(afterClear).toBeNull();
-    });
-    it('updateActivePlanSlice marks a slice done and advances currentSliceIndex', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Two-slice task',
-            taskSize: 'large',
-            slices: ['slice A', 'slice B'],
-            preAuthorized: true,
-        });
-        await orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done');
-        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
-        expect(plan).not.toBeNull();
-        expect(plan.slices[0]).toMatchObject({ index: 0, status: 'done' });
-        expect(plan.slices[0].completedAt).toBeDefined();
-        expect(plan.slices[1]).toMatchObject({ index: 1, status: 'pending' });
-        expect(plan.currentSliceIndex).toBe(1);
-    });
-    it('updateActivePlanSlice sets currentSliceIndex to null when the final slice is completed', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Single-slice task',
-            taskSize: 'large',
-            slices: ['ship the feature'],
-            preAuthorized: true,
-        });
-        // Complete the only slice (index 0, which is also the last)
-        await orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done');
-        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
-        expect(plan).not.toBeNull();
-        expect(plan.slices[0]).toMatchObject({ index: 0, status: 'done' });
-        expect(plan.currentSliceIndex).toBeNull();
-    });
-    it('setActivePlan sets currentSliceIndex to null when no slices are provided', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        const plan = await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Simple no-slice task',
-            taskSize: 'simple',
-            slices: [],
-            preAuthorized: false,
-        });
-        expect(plan.currentSliceIndex).toBeNull();
-        expect(plan.slices).toHaveLength(0);
-    });
-    it('updateActivePlanSlice throws when team has no active plan', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done')).rejects.toThrow('has no active plan');
-    });
-    it('updateActivePlanSlice throws when slice index does not exist', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Two-slice task',
-            taskSize: 'large',
-            slices: ['slice A', 'slice B'],
-            preAuthorized: false,
-        });
-        // Index 5 does not exist (only 0 and 1 exist)
-        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 5, 'done')).rejects.toThrow('slice index 5 does not exist');
-    });
-    it('updateActivePlanSlice throws when active plan has no slices', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'No-slice plan',
-            taskSize: 'simple',
-            slices: [],
-            preAuthorized: false,
-        });
-        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done')).rejects.toThrow('plan has no slices');
-    });
-    it('getActivePlan returns null for a new team with no active plan', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
-        expect(plan).toBeNull();
-    });
-    it('normalizeTeamRecord preserves activePlan from persisted records', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
-        const store = new TeamStateStore('.state');
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        await orchestrator.setActivePlan(tempRoot, 'team-1', {
-            summary: 'Persist test',
-            taskSize: 'simple',
-            slices: [],
-            preAuthorized: false,
-        });
-        // Re-read via getOrCreateTeam (triggers normalizeTeamRecord)
-        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        expect(team.activePlan).toBeDefined();
-        expect(team.activePlan.summary).toBe('Persist test');
-    });
-    it('selectPlanEngineers excludes BrowserQA from planner selection', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'planner-exclude-browserqa-'));
-        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
-        // Create a team with all engineers
-        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
-        // Select plan engineers
-        const selection = await orchestrator.selectPlanEngineers(tempRoot, 'team-1');
-        // Both lead and challenger should be from general engineers only
-        const generalEngineers = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];
-        expect(generalEngineers).toContain(selection.lead);
-        expect(generalEngineers).toContain(selection.challenger);
-        expect(selection.lead).not.toBe('BrowserQA');
-        expect(selection.challenger).not.toBe('BrowserQA');
-    });
-});

package/dist/test/team-state-store.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/team-state-store.test.js

@@ -1,54 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { TeamStateStore } from '../src/state/team-state-store.js';
-import { createEmptyTeamRecord } from '../src/team/roster.js';
-describe('TeamStateStore', () => {
-    let tempRoot;
-    afterEach(async () => {
-        if (tempRoot) {
-            await rm(tempRoot, { recursive: true, force: true });
-        }
-    });
-    it('saves and reads a team record', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
-        const store = new TeamStateStore('.state');
-        const team = createEmptyTeamRecord('team-1', tempRoot);
-        await store.saveTeam(team);
-        await expect(store.getTeam(tempRoot, 'team-1')).resolves.toEqual(team);
-    });
-    it('updates one engineer inside a team record', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
-        const store = new TeamStateStore('.state');
-        const team = createEmptyTeamRecord('team-1', tempRoot);
-        await store.saveTeam(team);
-        const updated = await store.updateTeam(tempRoot, 'team-1', (existing) => ({
-            ...existing,
-            updatedAt: '2026-01-01T00:00:00.000Z',
-            engineers: existing.engineers.map((engineer) => engineer.name === 'Tom'
-                ? {
-                    ...engineer,
-                    claudeSessionId: 'ses_tom',
-                    lastTaskSummary: 'Plan the feature',
-                }
-                : engineer),
-        }));
-        expect(updated.engineers.find((engineer) => engineer.name === 'Tom')?.claudeSessionId).toBe('ses_tom');
-        expect(updated.engineers.find((engineer) => engineer.name === 'John')?.claudeSessionId).toBe(null);
-    });
-    it('lists teams newest first', async () => {
-        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
-        const store = new TeamStateStore('.state');
-        const older = createEmptyTeamRecord('older', tempRoot);
-        older.updatedAt = '2026-01-01T00:00:00.000Z';
-        const newer = createEmptyTeamRecord('newer', tempRoot);
-        newer.updatedAt = '2026-01-02T00:00:00.000Z';
-        await store.saveTeam(older);
-        await store.saveTeam(newer);
-        await expect(store.listTeams(tempRoot)).resolves.toMatchObject([
-            { id: 'newer' },
-            { id: 'older' },
-        ]);
-    });
-});

package/dist/test/tool-approval-manager.test.d.ts

@@ -1 +0,0 @@
-export {};