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

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

@@ -203,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.56",
+  "version": "0.1.57",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",