@doingdev/opencode-claude-manager-plugin 0.1.55 → 0.1.57

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

@@ -35,7 +35,7 @@ describe('TeamOrchestrator', () => {
             outputTokens: 300,
             contextWindowSize: 200_000,
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const first = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -53,17 +53,22 @@ describe('TeamOrchestrator', () => {
         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: '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[1]?.[0]).toMatchObject({
-            systemPrompt: undefined,
             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');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         expect(team.engineers.find((engineer) => engineer.name === 'Tom')).toMatchObject({
             claudeSessionId: 'ses_tom',
@@ -74,7 +79,7 @@ describe('TeamOrchestrator', () => {
     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', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         await store.saveTeam({
             ...team,
@@ -112,7 +117,7 @@ describe('TeamOrchestrator', () => {
             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', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const result = await orchestrator.planWithTeam({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -125,6 +130,10 @@ describe('TeamOrchestrator', () => {
         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-'));
@@ -157,7 +166,7 @@ describe('TeamOrchestrator', () => {
                 };
             }
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
         const onLeadEvent = vi.fn();
         const onChallengerEvent = vi.fn();
         const onSynthesisEvent = vi.fn();
@@ -177,7 +186,7 @@ describe('TeamOrchestrator', () => {
     });
     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', 'Architect prompt');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis 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');
@@ -194,4 +203,115 @@ describe('TeamOrchestrator', () => {
             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');
+        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');
+        // 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 orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt');
+        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');
+    });
 });

package/dist/types/contracts.d.ts

@@ -2,7 +2,7 @@ export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
     engineerAgentPrompt: string;
     engineerSessionPrompt: string;
-    /** Prompt injected as the system prompt of the non-persistent synthesis runTask call inside plan_with_team. */
+    /** Prompt prepended to the user prompt of the synthesis runTask call inside plan_with_team. */
     planSynthesisPrompt: string;
     /** Visible subagent prompt for teamPlanner — thin bridge that calls plan_with_team. */
     teamPlannerPrompt: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",