opencode-conductor-cdd-plugin 1.0.0-beta.20 → 1.0.0-beta.21

package/dist/test/integration/omo3-delegation.test.js

@@ -0,0 +1,581 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createDelegationTool } from '../../tools/delegate.js';
+vi.mock('../../utils/configDetection.js', () => ({
+    detectCDDConfig: vi.fn(() => ({
+        synergyFramework: 'oh-my-opencode',
+        synergyActive: true,
+    })),
+    getAvailableOMOAgents: vi.fn(() => ['sisyphus', 'explore', 'oracle', 'librarian']),
+}));
+vi.mock('../../utils/synergyDelegation.js', () => ({
+    resolveAgentForDelegation: vi.fn((agent) => ({
+        success: true,
+        resolvedAgent: agent,
+        shouldFallback: false,
+    })),
+}));
+/**
+ * Integration tests for OMO 3.0 delegation flow
+ *
+ * These tests verify the complete delegation cycle:
+ * 1. Load plan and extract task
+ * 2. Create child session with parentID
+ * 3. Send prompt with agent specification and tool restrictions
+ * 4. Poll session.status() until idle
+ * 5. Extract assistant messages from session
+ * 6. Process response (detect PLAN_UPDATED, verify completion)
+ */
+function createMockToolContext(sessionID) {
+    return {
+        sessionID,
+        messageID: 'msg-mock-123',
+        agent: 'cdd',
+        abort: new AbortController().signal,
+        metadata: vi.fn(),
+        ask: vi.fn().mockResolvedValue(undefined),
+    };
+}
+describe('OMO 3.0 Delegation Integration Tests', () => {
+    describe('Full Delegation Cycle', () => {
+        it('should complete full delegation cycle: session create → prompt → poll → messages', async () => {
+            // Mock OpenCode SDK client
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-123' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({
+                        data: {},
+                        error: null,
+                    }),
+                    status: vi.fn()
+                        // First call: still working
+                        .mockResolvedValueOnce({
+                        data: {
+                            'session-123': { type: 'working' },
+                        },
+                    })
+                        // Second call: idle (complete)
+                        .mockResolvedValueOnce({
+                        data: {
+                            'session-123': { type: 'idle' },
+                        },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'user' },
+                                parts: [{ type: 'text', text: 'Task prompt' }],
+                            },
+                            {
+                                info: { role: 'assistant' },
+                                parts: [
+                                    {
+                                        type: 'text',
+                                        text: '✅ Task completed successfully.\n\nImplemented feature X with tests.\n\nCommit: abc123',
+                                    },
+                                ],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const toolContext = createMockToolContext('parent-session-456');
+            // Execute delegation tool
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Implement feature X',
+                subagent_type: 'sisyphus',
+                prompt: 'Execute this task from plan.md:\n\nTask: Implement feature X\n- Add unit tests\n- Update documentation',
+            }, toolContext);
+            // Verify session creation with correct parentID
+            expect(mockClient.session.create).toHaveBeenCalledWith({
+                body: {
+                    parentID: 'parent-session-456',
+                    title: 'Implement feature X (@sisyphus)',
+                },
+            });
+            // Verify prompt sent with agent and tool restrictions
+            expect(mockClient.session.prompt).toHaveBeenCalledWith({
+                path: { id: 'session-123' },
+                body: {
+                    agent: 'sisyphus',
+                    tools: {
+                        cdd_delegate: false,
+                        cdd_bg_task: false,
+                    },
+                    parts: [
+                        {
+                            type: 'text',
+                            text: 'Execute this task from plan.md:\n\nTask: Implement feature X\n- Add unit tests\n- Update documentation',
+                        },
+                    ],
+                },
+            });
+            // Verify status polling occurred (should be called twice)
+            expect(mockClient.session.status).toHaveBeenCalledTimes(2);
+            // Verify messages retrieved
+            expect(mockClient.session.messages).toHaveBeenCalledWith({
+                path: { id: 'session-123' },
+            });
+            // Verify response contains agent output and metadata
+            expect(result).toContain('✅ Task completed successfully');
+            expect(result).toContain('Commit: abc123');
+            expect(result).toContain('<task_metadata>');
+            expect(result).toContain('session_id: session-123');
+            expect(result).toContain('agent: sisyphus');
+        });
+        it('should detect PLAN_UPDATED marker in agent response', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-999' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-999': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [
+                                    {
+                                        type: 'text',
+                                        text: '✅ Task decomposed into 3 subtasks.\n\nPLAN_UPDATED: Added subtasks to plan.md\n\nCommit: def456',
+                                    },
+                                ],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Decompose large task',
+                subagent_type: 'sisyphus',
+                prompt: 'Break down this task into smaller subtasks',
+            }, createMockToolContext('parent-777'));
+            // Result should contain PLAN_UPDATED marker
+            expect(result).toContain('PLAN_UPDATED');
+            expect(result).toContain('Added subtasks to plan.md');
+            // In real usage, the CDD agent would detect this marker and reload plan.md
+            const hasPlanUpdate = result.includes('PLAN_UPDATED');
+            expect(hasPlanUpdate).toBe(true);
+        });
+    });
+    describe('Error Scenarios', () => {
+        it('should handle session creation failure', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: null,
+                        error: 'Failed to create session: insufficient permissions',
+                    }),
+                    prompt: vi.fn(),
+                    status: vi.fn(),
+                    messages: vi.fn(),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Test task',
+                subagent_type: 'explore',
+                prompt: 'Search for files',
+            }, createMockToolContext('parent-123'));
+            expect(result).toContain('Error creating session');
+            expect(result).toContain('insufficient permissions');
+            expect(mockClient.session.prompt).not.toHaveBeenCalled();
+        });
+        it('should handle agent timeout (exceeds 5 minutes)', async () => {
+            // Mock a session that never becomes idle
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-timeout' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-timeout': { type: 'working' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [{ type: 'text', text: 'Started working on task...' }],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            // Mock setTimeout to avoid actually waiting 5 minutes
+            vi.useFakeTimers();
+            const resultPromise = delegateTool.execute({
+                task_description: 'Long running task',
+                subagent_type: 'sisyphus',
+                prompt: 'This will take forever',
+            }, createMockToolContext('parent-999'));
+            // Fast-forward time to simulate timeout
+            await vi.advanceTimersByTimeAsync(5 * 60 * 1000 + 1000);
+            const result = await resultPromise;
+            // After timeout, should still retrieve messages (partial response)
+            expect(mockClient.session.messages).toHaveBeenCalled();
+            expect(result).toContain('Started working on task');
+            vi.useRealTimers();
+        });
+        it('should handle no assistant messages in response', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-empty' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-empty': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'user' },
+                                parts: [{ type: 'text', text: 'Prompt' }],
+                            },
+                            // No assistant messages
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Silent task',
+                subagent_type: 'explore',
+                prompt: 'Find something',
+            }, createMockToolContext('parent-000'));
+            expect(result).toContain('No response from agent explore');
+        });
+        it('should handle messages retrieval failure', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-456' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-456': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: null,
+                        error: 'Network error: connection timeout',
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Test task',
+                subagent_type: 'oracle',
+                prompt: 'Explain something',
+            }, createMockToolContext('parent-111'));
+            expect(result).toContain('Error fetching messages');
+            expect(result).toContain('connection timeout');
+        });
+        it('should handle status check failures gracefully', async () => {
+            let statusCallCount = 0;
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-robust' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockImplementation(() => {
+                        statusCallCount++;
+                        if (statusCallCount === 1) {
+                            // First call fails
+                            throw new Error('Status API temporarily unavailable');
+                        }
+                        // Second call succeeds with idle
+                        return Promise.resolve({
+                            data: { 'session-robust': { type: 'idle' } },
+                        });
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [{ type: 'text', text: 'Task completed despite status error' }],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Robust task',
+                subagent_type: 'librarian',
+                prompt: 'Research something',
+            }, createMockToolContext('parent-222'));
+            // Should still succeed despite status check failure
+            expect(result).toContain('Task completed despite status error');
+            expect(mockClient.session.status).toHaveBeenCalledTimes(2);
+        });
+        it('should handle unexpected exceptions during delegation', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockRejectedValue(new Error('Unexpected SDK error')),
+                    prompt: vi.fn(),
+                    status: vi.fn(),
+                    messages: vi.fn(),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Failing task',
+                subagent_type: 'explore',
+                prompt: 'This will fail',
+            }, createMockToolContext('parent-333'));
+            expect(result).toContain('Error during delegation');
+            expect(result).toContain('Unexpected SDK error');
+        });
+    });
+    describe('Task Verification', () => {
+        it('should include all required metadata in response', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-meta' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-meta': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [{ type: 'text', text: 'Task completed' }],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Metadata test',
+                subagent_type: 'oracle',
+                prompt: 'Test prompt',
+            }, createMockToolContext('parent-444'));
+            // Verify metadata section exists and contains required fields
+            expect(result).toContain('<task_metadata>');
+            expect(result).toContain('session_id: session-meta');
+            expect(result).toContain('agent: oracle');
+            expect(result).toContain('</task_metadata>');
+        });
+        it('should preserve multi-line assistant responses', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-multiline' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-multiline': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [
+                                    { type: 'text', text: 'Line 1: First step completed' },
+                                    { type: 'text', text: 'Line 2: Second step completed' },
+                                    { type: 'text', text: 'Line 3: Final verification passed' },
+                                ],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Multi-step task',
+                subagent_type: 'sisyphus',
+                prompt: 'Execute multiple steps',
+            }, createMockToolContext('parent-555'));
+            // All parts should be joined with newlines
+            expect(result).toContain('Line 1: First step completed');
+            expect(result).toContain('Line 2: Second step completed');
+            expect(result).toContain('Line 3: Final verification passed');
+        });
+        it('should filter out non-text parts in response', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-mixed' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-mixed': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [
+                                    { type: 'text', text: 'Text response' },
+                                    { type: 'tool_call', toolName: 'some_tool' }, // Should be filtered
+                                    { type: 'text', text: 'More text' },
+                                ],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Mixed content task',
+                subagent_type: 'explore',
+                prompt: 'Test mixed content',
+            }, createMockToolContext('parent-666'));
+            // Only text parts should be in result
+            expect(result).toContain('Text response');
+            expect(result).toContain('More text');
+            expect(result).not.toContain('tool_call');
+            expect(result).not.toContain('some_tool');
+        });
+    });
+    describe('Tool Restrictions', () => {
+        it('should restrict cdd_delegate and cdd_bg_task tools to prevent recursion', async () => {
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-restrict' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-restrict': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [{ type: 'text', text: 'Done' }],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            await delegateTool.execute({
+                task_description: 'Tool restriction test',
+                subagent_type: 'sisyphus',
+                prompt: 'Test prompt',
+            }, createMockToolContext('parent-777'));
+            const promptCall = mockClient.session.prompt.mock.calls[0][0];
+            expect(promptCall.body.tools).toEqual({
+                cdd_delegate: false,
+                cdd_bg_task: false,
+            });
+        });
+    });
+    describe('Agent Fallback', () => {
+        it('should return fallback message when agent is unavailable', async () => {
+            const resolveAgentForDelegation = await import('../../utils/synergyDelegation.js');
+            vi.spyOn(resolveAgentForDelegation, 'resolveAgentForDelegation').mockReturnValueOnce({
+                success: false,
+                resolvedAgent: null,
+                shouldFallback: true,
+                reason: 'Agent sisyphus is disabled or not available',
+            });
+            const mockClient = {
+                session: {
+                    create: vi.fn(),
+                    prompt: vi.fn(),
+                    status: vi.fn(),
+                    messages: vi.fn(),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Test with unavailable agent',
+                subagent_type: 'sisyphus',
+                prompt: 'Test prompt',
+            }, createMockToolContext('parent-888'));
+            expect(result).toContain('Cannot delegate to');
+            expect(result).toContain('sisyphus');
+            expect(result).toContain('Falling back to @cdd');
+            expect(mockClient.session.create).not.toHaveBeenCalled();
+        });
+        it('should use resolved agent name when mapping changes agent', async () => {
+            const resolveAgentForDelegation = await import('../../utils/synergyDelegation.js');
+            vi.spyOn(resolveAgentForDelegation, 'resolveAgentForDelegation').mockReturnValueOnce({
+                success: true,
+                resolvedAgent: 'explorer',
+                shouldFallback: false,
+            });
+            const mockClient = {
+                session: {
+                    create: vi.fn().mockResolvedValue({
+                        data: { id: 'session-mapped' },
+                        error: null,
+                    }),
+                    prompt: vi.fn().mockResolvedValue({ data: {}, error: null }),
+                    status: vi.fn().mockResolvedValue({
+                        data: { 'session-mapped': { type: 'idle' } },
+                    }),
+                    messages: vi.fn().mockResolvedValue({
+                        data: [
+                            {
+                                info: { role: 'assistant' },
+                                parts: [{ type: 'text', text: 'Search complete' }],
+                            },
+                        ],
+                        error: null,
+                    }),
+                },
+            };
+            const ctx = { client: mockClient };
+            const delegateTool = createDelegationTool(ctx);
+            const result = await delegateTool.execute({
+                task_description: 'Search codebase',
+                subagent_type: 'explore',
+                prompt: 'Find all TypeScript files',
+            }, createMockToolContext('parent-999'));
+            const createCall = mockClient.session.create.mock.calls[0][0];
+            expect(createCall.body.title).toContain('@explorer');
+            const promptCall = mockClient.session.prompt.mock.calls[0][0];
+            expect(promptCall.body.agent).toBe('explorer');
+            expect(result).toContain('agent: explorer');
+            expect(result).toContain('requested: explore');
+        });
+    });
+});

package/dist/tools/delegate.d.ts

@@ -1,3 +1,15 @@
 import { type PluginInput } from "@opencode-ai/plugin";
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+/**
+ * Creates a delegation tool that follows the OMO 3.0 agent invocation pattern.
+ *
+ * This implementation uses the synchronous prompt() API pattern:
+ * 1. Create a child session with parentID
+ * 2. Send prompt with agent specification and tool restrictions
+ * 3. Poll for completion by checking when session becomes idle
+ * 4. Extract and return the final response
+ *
+ * Based on OMO 3.0 call_omo_agent implementation:
+ * https://github.com/code-yeongyu/oh-my-opencode/blob/main/src/tools/call-omo-agent/tools.ts
+ */
 export declare function createDelegationTool(ctx: PluginInput): ToolDefinition;