@doingdev/opencode-claude-manager-plugin 0.1.46 → 0.1.49

package/dist/test/report-claude-event.test.js

@@ -0,0 +1,246 @@
+/**
+ * Tests for reportClaudeEvent via the real plugin onEvent chain,
+ * plus integration tests for second-invocation continuity across
+ * clearPluginServices() / new plugin instance.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
+import { clearPluginServices, getActiveTeamSession, getOrCreatePluginServices, } from '../src/plugin/service-factory.js';
+import { AGENT_CTO, ENGINEER_AGENT_IDS } from '../src/plugin/agent-hierarchy.js';
+import { TeamStateStore } from '../src/state/team-state-store.js';
+import { TeamOrchestrator } from '../src/manager/team-orchestrator.js';
+function makeContext(worktree, agentId, sessionID) {
+    const metadata = vi.fn();
+    const ctx = {
+        metadata,
+        worktree,
+        sessionID,
+        agent: agentId,
+        abort: new AbortController().signal,
+    };
+    return { metadata, ctx };
+}
+function makeDispatchResult(override = {}) {
+    const context = {
+        sessionId: 'ses-tom-1',
+        totalTurns: 1,
+        totalCostUsd: 0.01,
+        latestInputTokens: 500,
+        latestOutputTokens: 100,
+        contextWindowSize: 200_000,
+        estimatedContextPercent: 0.5,
+        warningLevel: 'ok',
+        compactionCount: 0,
+    };
+    return {
+        teamId: 'team-1',
+        engineer: 'Tom',
+        mode: 'explore',
+        sessionId: 'ses-tom-1',
+        finalText: 'done',
+        turns: 1,
+        totalCostUsd: 0.01,
+        inputTokens: 500,
+        outputTokens: 100,
+        contextWindowSize: 200_000,
+        context,
+        ...override,
+    };
+}
+async function executeClaude(plugin, ctx, args = { mode: 'explore', message: 'do work' }) {
+    const claudeTool = plugin.tool['claude'];
+    return claudeTool.execute(args, ctx);
+}
+// ── reportClaudeEvent via the plugin's onEvent chain ────────────────────────
+describe('reportClaudeEvent — via plugin onEvent chain', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'report-event-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    /**
+     * Helper: creates a plugin, sets the active CTO team, then stubs
+     * dispatchEngineer so it fires the given events before returning.
+     */
+    async function setupPlugin(events) {
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage = plugin['chat.message'];
+        await chatMessage({ agent: AGENT_CTO, sessionID: 'cto-1' });
+        const services = getOrCreatePluginServices(tempRoot);
+        vi.spyOn(services.orchestrator, 'dispatchEngineer').mockImplementation(async (input) => {
+            for (const event of events) {
+                await input.onEvent?.(event);
+            }
+            return makeDispatchResult();
+        });
+        vi.spyOn(services.orchestrator, 'recordWrapperExchange').mockResolvedValue(undefined);
+        return { plugin, services };
+    }
+    it('surfaces tool name, args, and toolId from a tool_call event', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-1',
+            text: JSON.stringify({ name: 'read', id: 'call-abc', input: { file_path: '/foo.ts' } }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-1');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('→'))?.[0];
+        expect(call).toBeDefined();
+        expect(call.title).toBe('⚡ Tom → read');
+        expect(call.metadata.toolName).toBe('read');
+        expect(call.metadata.toolId).toBe('call-abc');
+        expect(call.metadata.toolArgs).toEqual({ file_path: '/foo.ts' });
+        expect(call.metadata.sessionId).toBe('ses-1');
+        expect(call.metadata.engineer).toBe('Tom');
+    });
+    it('double-decodes a JSON-string input (tool input serialised twice)', async () => {
+        // The SDK adapter may serialize `input` as a JSON string inside the outer JSON on
+        // some tool calls. The handler should parse the inner string into an object.
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-2',
+            text: JSON.stringify({
+                name: 'bash',
+                id: 'call-def',
+                input: JSON.stringify({ command: 'ls -la' }),
+            }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-2');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('→'))?.[0];
+        expect(call.title).toBe('⚡ Tom → bash');
+        expect(call.metadata.toolArgs).toEqual({ command: 'ls -la' });
+    });
+    it('falls back to generic title and omits tool fields when event.text is not JSON', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-3',
+            text: 'not-json-at-all',
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-3');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('is using Claude Code tools'))?.[0];
+        expect(call).toBeDefined();
+        expect(call.title).toBe('⚡ Tom is using Claude Code tools');
+        expect(call.metadata).not.toHaveProperty('toolName');
+        expect(call.metadata).not.toHaveProperty('toolId');
+        expect(call.metadata).not.toHaveProperty('toolArgs');
+    });
+    it('falls back to generic title when parsed JSON has no name field', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-4',
+            text: JSON.stringify({ id: 'call-xyz', input: {} }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.John, 'wrapper-4');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('is using Claude Code tools'))?.[0];
+        expect(call).toBeDefined();
+        expect(call.metadata).not.toHaveProperty('toolName');
+    });
+    it('includes toolArgs when input is an empty object', async () => {
+        const event = {
+            type: 'tool_call',
+            sessionId: 'ses-5',
+            text: JSON.stringify({ name: 'git_status', id: 'call-ghi', input: {} }),
+        };
+        const { plugin } = await setupPlugin([event]);
+        const { metadata, ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Maya, 'wrapper-5');
+        await executeClaude(plugin, ctx);
+        const call = metadata.mock.calls.find(([c]) => c?.title?.includes('→'))?.[0];
+        expect(call.title).toBe('⚡ Maya → git_status');
+        expect(call.metadata.toolArgs).toEqual({});
+    });
+});
+// ── Second-invocation continuity ─────────────────────────────────────────────
+describe('second invocation continuity', () => {
+    let tempRoot;
+    beforeEach(async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'continuity-'));
+        clearPluginServices();
+    });
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot)
+            await rm(tempRoot, { recursive: true, force: true });
+    });
+    it('wrapper memory is injected after clearPluginServices and a new plugin instance', async () => {
+        // ── Phase 1: first task via orchestrator (no real SDK needed) ──────────
+        const store = new TeamStateStore();
+        await store.setActiveTeam(tempRoot, 'cto-1');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', []);
+        await orchestrator.recordWrapperSession(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1');
+        await orchestrator.recordWrapperExchange(tempRoot, 'cto-1', 'Tom', 'wrapper-tom-1', 'explore', 'Investigate the auth flow', 'Found two race conditions in the token refresh path.');
+        // ── Phase 2: process restart ───────────────────────────────────────────
+        clearPluginServices();
+        // ── Phase 3: new plugin instance, new CTO session ──────────────────────
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        const systemTransform2 = plugin2['experimental.chat.system.transform'];
+        // New CTO session must adopt the persisted team, not create a new one.
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        expect(getActiveTeamSession(tempRoot)).toBe('cto-1');
+        // Tom's new wrapper session must be registered under the persisted team.
+        await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
+        // Transform fires (after chat.message has registered the session mapping).
+        const output = { system: [] };
+        await systemTransform2({ sessionID: 'wrapper-tom-2', model: 'claude-sonnet-4-6' }, output);
+        expect(output.system).toHaveLength(1);
+        expect(output.system[0]).toContain('Persistent wrapper memory for Tom');
+        expect(output.system[0]).toContain('Investigate the auth flow');
+        expect(output.system[0]).toContain('Found two race conditions');
+    });
+    it('existing engineer Claude session is resumed on second invocation', async () => {
+        // ── Phase 1: pre-seed Tom with a claudeSessionId ───────────────────────
+        const store = new TeamStateStore();
+        await store.setActiveTeam(tempRoot, 'cto-1');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => undefined) }, 'Base prompt', []);
+        await orchestrator.getOrCreateTeam(tempRoot, 'cto-1');
+        await store.updateTeam(tempRoot, 'cto-1', (team) => ({
+            ...team,
+            engineers: team.engineers.map((e) => e.name === 'Tom' ? { ...e, claudeSessionId: 'ses-tom-persisted' } : e),
+        }));
+        // ── Phase 2: process restart ───────────────────────────────────────────
+        clearPluginServices();
+        // ── Phase 3: new plugin, new CTO, engineer runs second task ───────────
+        const plugin2 = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const chatMessage2 = plugin2['chat.message'];
+        await chatMessage2({ agent: AGENT_CTO, sessionID: 'cto-2' });
+        await chatMessage2({ agent: ENGINEER_AGENT_IDS.Tom, sessionID: 'wrapper-tom-2' });
+        const services2 = getOrCreatePluginServices(tempRoot);
+        // Mock at the session level so dispatchEngineer runs its real logic
+        // (reads claudeSessionId, passes resumeSessionId to runTask).
+        const runTask = vi.spyOn(services2.sessions, 'runTask').mockResolvedValue({
+            sessionId: 'ses-tom-persisted',
+            events: [],
+            finalText: 'resumed result',
+            turns: 2,
+            totalCostUsd: 0.02,
+            inputTokens: 1000,
+            outputTokens: 200,
+            contextWindowSize: 200_000,
+        });
+        vi.spyOn(services2.orchestrator, 'recordWrapperExchange').mockResolvedValue(undefined);
+        const { ctx } = makeContext(tempRoot, ENGINEER_AGENT_IDS.Tom, 'wrapper-tom-2');
+        await executeClaude(plugin2, ctx);
+        // dispatchEngineer should have read claudeSessionId='ses-tom-persisted' from
+        // the team store and forwarded it as resumeSessionId.
+        expect(runTask).toHaveBeenCalledOnce();
+        expect(runTask.mock.calls[0]?.[0]).toMatchObject({
+            resumeSessionId: 'ses-tom-persisted',
+            systemPrompt: undefined, // no new system prompt when resuming
+        });
+    });
+});

package/dist/test/session-controller.test.js

@@ -25,9 +25,9 @@ describe('SessionController', () => {
     it('creates a new session on first sendMessage', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test prompt');
+        const controller = new SessionController(adapter, tracker, 'test prompt', 'test', '/tmp');
         expect(controller.isActive).toBe(false);
-        const result = await controller.sendMessage('/tmp', 'hello');
+        const result = await controller.sendMessage('hello');
         expect(controller.isActive).toBe(true);
         expect(controller.sessionId).toBe('ses_test');
         expect(result.finalText).toBe('Done.');
@@ -39,17 +39,17 @@ describe('SessionController', () => {
     it('sends settingSources as user-only', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'hello');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('hello');
         const call = adapter.runSession.mock.calls[0][0];
         expect(call.settingSources).toEqual(['user']);
     });
     it('resumes session on subsequent sends', async () => {
         const adapter = createMockAdapter([{}, {}]);
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test prompt');
-        await controller.sendMessage('/tmp', 'first');
-        await controller.sendMessage('/tmp', 'second');
+        const controller = new SessionController(adapter, tracker, 'test prompt', 'test', '/tmp');
+        await controller.sendMessage('first');
+        await controller.sendMessage('second');
         const secondCall = adapter.runSession.mock.calls[1][0];
         expect(secondCall.resumeSessionId).toBe('ses_test');
         expect(secondCall.systemPrompt).toBeUndefined();
@@ -57,8 +57,8 @@ describe('SessionController', () => {
     it('updates context tracker on each message', async () => {
         const adapter = createMockAdapter([{ turns: 3, totalCostUsd: 0.05, inputTokens: 50_000 }]);
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'task');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('task');
         const snap = controller.getContextSnapshot();
         expect(snap.totalTurns).toBe(3);
         expect(snap.totalCostUsd).toBe(0.05);
@@ -68,10 +68,10 @@ describe('SessionController', () => {
     it('clears session and resets context', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'task');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('task');
         expect(controller.isActive).toBe(true);
-        const clearedId = await controller.clearSession('/tmp');
+        const clearedId = await controller.clearSession();
         expect(clearedId).toBe('ses_test');
         expect(controller.isActive).toBe(false);
         expect(controller.sessionId).toBeNull();
@@ -82,9 +82,9 @@ describe('SessionController', () => {
     it('sends /compact to current session', async () => {
         const adapter = createMockAdapter([{}, {}]);
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'task');
-        await controller.compactSession('/tmp');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('task');
+        await controller.compactSession();
         const compactCall = adapter.runSession.mock.calls[1][0];
         expect(compactCall.prompt).toBe('/compact');
         expect(compactCall.resumeSessionId).toBe('ses_test');
@@ -92,14 +92,14 @@ describe('SessionController', () => {
     it('throws when compacting without active session', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await expect(controller.compactSession('/tmp')).rejects.toThrow('No active session to compact');
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await expect(controller.compactSession()).rejects.toThrow('No active session to compact');
     });
     it('threads effort through to the SDK input', async () => {
         const adapter = createMockAdapter();
         const tracker = new ContextTracker();
-        const controller = new SessionController(adapter, tracker, 'test');
-        await controller.sendMessage('/tmp', 'hard task', { effort: 'max' });
+        const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+        await controller.sendMessage('hard task', { effort: 'max' });
         const call = adapter.runSession.mock.calls[0][0];
         expect(call.effort).toBe('max');
     });
@@ -111,8 +111,8 @@ describe('SessionController', () => {
         it('defaults to free mode with acceptEdits permissionMode', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
-            await controller.sendMessage('/tmp', 'do something');
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp', modePrefixes);
+            await controller.sendMessage('do something');
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('acceptEdits');
             expect(call.prompt).toBe('do something');
@@ -120,8 +120,8 @@ describe('SessionController', () => {
         it('sets permissionMode to plan and prepends prefix in plan mode', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
-            await controller.sendMessage('/tmp', 'analyze this', { mode: 'plan' });
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp', modePrefixes);
+            await controller.sendMessage('analyze this', { mode: 'plan' });
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('plan');
             expect(call.prompt).toBe('[PLAN MODE] Read-only planning.\n\nanalyze this');
@@ -129,8 +129,8 @@ describe('SessionController', () => {
         it('explicit free mode uses acceptEdits and no prefix', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
-            await controller.sendMessage('/tmp', 'build it', { mode: 'free' });
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp', modePrefixes);
+            await controller.sendMessage('build it', { mode: 'free' });
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('acceptEdits');
             expect(call.prompt).toBe('build it');
@@ -138,8 +138,8 @@ describe('SessionController', () => {
         it('works without modePrefixes constructor arg (backward compat)', async () => {
             const adapter = createMockAdapter();
             const tracker = new ContextTracker();
-            const controller = new SessionController(adapter, tracker, 'test');
-            await controller.sendMessage('/tmp', 'hello', { mode: 'plan' });
+            const controller = new SessionController(adapter, tracker, 'test', 'test', '/tmp');
+            await controller.sendMessage('hello', { mode: 'plan' });
             const call = adapter.runSession.mock.calls[0][0];
             expect(call.permissionMode).toBe('plan');
             // Empty prefix defaults — prompt should be unchanged

package/dist/test/team-orchestrator.test.d.ts

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

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

@@ -0,0 +1,146 @@
+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';
+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 orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', []);
+        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({
+            systemPrompt: expect.stringContaining('Assigned engineer: Tom.'),
+            resumeSessionId: undefined,
+            permissionMode: 'plan',
+        });
+        expect(runTask.mock.calls[1]?.[0]).toMatchObject({
+            systemPrompt: undefined,
+            resumeSessionId: 'ses_tom',
+            permissionMode: 'acceptEdits',
+        });
+        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', []);
+        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', []);
+        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);
+    });
+    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', []);
+        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',
+        });
+    });
+});

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

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

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

@@ -0,0 +1,72 @@
+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' },
+        ]);
+    });
+    it('returns null for active team when no active-team.json exists', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
+        const store = new TeamStateStore('.state');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBeNull();
+    });
+    it('persists and reads back the active team ID', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
+        const store = new TeamStateStore('.state');
+        await store.setActiveTeam(tempRoot, 'team-abc');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('team-abc');
+    });
+    it('overwrites the active team ID on subsequent writes', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-store-'));
+        const store = new TeamStateStore('.state');
+        await store.setActiveTeam(tempRoot, 'team-first');
+        await store.setActiveTeam(tempRoot, 'team-second');
+        await expect(store.getActiveTeam(tempRoot)).resolves.toBe('team-second');
+    });
+});