@doingdev/opencode-claude-manager-plugin 0.1.58 → 0.1.60

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

@@ -44,7 +44,8 @@ describe('TeamOrchestrator', () => {
             outputTokens: 300,
             contextWindowSize: 200_000,
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        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,
@@ -78,6 +79,8 @@ describe('TeamOrchestrator', () => {
         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',
@@ -301,7 +304,8 @@ describe('TeamOrchestrator', () => {
                 contextWindowSize: 200_000,
             };
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        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',
@@ -339,6 +343,158 @@ describe('TeamOrchestrator', () => {
         expect(error.message).toContain('BrowserQA is a browser QA specialist');
         expect(error.message).toContain('does not support implement mode');
     });
+    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 });

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

@@ -51,22 +51,4 @@ describe('TeamStateStore', () => {
             { 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');
-    });
 });

package/dist/types/contracts.d.ts

@@ -116,6 +116,24 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export type TaskSize = 'trivial' | 'simple' | 'large';
+export interface PlanSlice {
+    index: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'done' | 'skipped';
+    completedAt?: string;
+}
+export interface ActivePlan {
+    id: string;
+    summary: string;
+    taskSize: TaskSize;
+    createdAt: string;
+    confirmedAt: string | null;
+    preAuthorized: boolean;
+    slices: PlanSlice[];
+    /** Null when the plan has no slices (trivial/simple tasks). */
+    currentSliceIndex: number | null;
+}
 export interface TeamEngineerRecord {
     name: EngineerName;
     wrapperSessionId: string | null;
@@ -142,6 +160,7 @@ export interface TeamRecord {
     createdAt: string;
     updatedAt: string;
     engineers: TeamEngineerRecord[];
+    activePlan?: ActivePlan;
 }
 export interface EngineerTaskResult {
     teamId: string;

package/package.json

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