@doingdev/opencode-claude-manager-plugin 0.1.44 → 0.1.47

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,54 @@
+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/types/contracts.d.ts

@@ -1,8 +1,6 @@
 export interface ManagerPromptRegistry {
     ctoSystemPrompt: string;
-    engineerExplorePrompt: string;
-    engineerImplementPrompt: string;
-    engineerVerifyPrompt: string;
+    engineerAgentPrompt: string;
     engineerSessionPrompt: string;
     modePrefixes: {
         plan: string;
@@ -15,6 +13,15 @@ export interface ManagerPromptRegistry {
     };
 }
 export type SessionMode = 'plan' | 'free';
+export declare const DEFAULT_ENGINEER_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
+export type EngineerName = (typeof DEFAULT_ENGINEER_NAMES)[number];
+export type EngineerWorkMode = 'explore' | 'implement' | 'verify';
+export interface WrapperHistoryEntry {
+    timestamp: string;
+    type: 'assignment' | 'result';
+    mode?: EngineerWorkMode;
+    text: string;
+}
 export interface ClaudeCommandMetadata {
     name: string;
     description: string;
@@ -98,29 +105,49 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
-export type AgentSlotType = 'implement' | 'verify' | 'explore';
-export interface RunningTask {
-    slotType: AgentSlotType;
-    task: string;
-    startedAt: string;
+export interface TeamEngineerRecord {
+    name: EngineerName;
+    wrapperSessionId: string | null;
+    claudeSessionId: string | null;
+    busy: boolean;
+    lastMode: EngineerWorkMode | null;
+    lastTaskSummary: string | null;
+    lastUsedAt: string | null;
+    wrapperHistory: WrapperHistoryEntry[];
+    context: SessionContextSnapshot;
 }
-export interface SlotStatus {
-    implement: {
-        used: number;
-        max: number;
-    };
-    verify: {
-        used: number;
-        max: number;
-    };
-    explore: {
-        used: number;
-    };
+export interface TeamRecord {
+    id: string;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    engineers: TeamEngineerRecord[];
 }
-export interface ManagerStatus {
+export interface EngineerTaskResult {
+    teamId: string;
+    engineer: EngineerName;
+    mode: EngineerWorkMode;
+    sessionId?: string;
+    finalText: string;
+    turns?: number;
+    totalCostUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    contextWindowSize?: number;
     context: SessionContextSnapshot;
-    slotStatus: SlotStatus;
-    runningTasks: RunningTask[];
+}
+export interface PlanDraft extends EngineerTaskResult {
+    request: string;
+}
+export interface SynthesizedPlanResult {
+    teamId: string;
+    request: string;
+    leadEngineer: EngineerName;
+    challengerEngineer: EngineerName;
+    drafts: [PlanDraft, PlanDraft];
+    synthesis: string;
+    recommendedQuestion: string | null;
+    recommendedAnswer: string | null;
 }
 export interface GitDiffResult {
     hasDiff: boolean;

package/dist/types/contracts.js

@@ -1 +1 @@
-export {};
+export const DEFAULT_ENGINEER_NAMES = ['Tom', 'John', 'Maya', 'Sara', 'Alex'];

package/package.json

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