opencode-conductor-cdd-plugin 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/test/integration/slim-synergy.test.js

@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest';
+import { resolveAgentName, isAgentAvailable, getAgentMapping } from '../../utils/agentMapping.js';
+import { shouldDelegateToSynergy, getDelegationStrategy, resolveAgentForDelegation } from '../../utils/synergyDelegation.js';
+/**
+ * Integration tests for oh-my-opencode-slim synergy support
+ *
+ * These tests verify that the various modules work together correctly
+ * for oh-my-opencode-slim integration, focusing on agent mapping, delegation,
+ * and the interaction between components.
+ */
+describe('oh-my-opencode-slim Integration Tests', () => {
+    describe('Complete Workflow: Mapping → Delegation', () => {
+        it('should complete full agent resolution workflow for slim framework', () => {
+            const framework = 'oh-my-opencode-slim';
+            const availableAgents = ['explorer', 'designer', 'librarian', 'oracle'];
+            // Step 1: Agent Mapping - Test that generic names map to slim-specific names
+            const explorerMapping = resolveAgentName('explore', framework);
+            expect(explorerMapping).toBe('explorer');
+            const designerMapping = resolveAgentName('frontend-ui-ux-engineer', framework);
+            expect(designerMapping).toBe('designer');
+            const librarianMapping = resolveAgentName('document-writer', framework);
+            expect(librarianMapping).toBe('librarian');
+            const oracleMapping = resolveAgentName('oracle', framework);
+            expect(oracleMapping).toBe('oracle');
+            // sisyphus has no slim equivalent
+            const sisyphusMapping = resolveAgentName('sisyphus', framework);
+            expect(sisyphusMapping).toBe(null);
+            // Step 2: Agent Availability - Test that mapped names are available
+            expect(isAgentAvailable(explorerMapping, availableAgents)).toBe(true);
+            expect(isAgentAvailable(designerMapping, availableAgents)).toBe(true);
+            expect(isAgentAvailable(librarianMapping, availableAgents)).toBe(true);
+            expect(isAgentAvailable(oracleMapping, availableAgents)).toBe(true);
+            expect(isAgentAvailable(sisyphusMapping, availableAgents)).toBe(false);
+            // Step 3: Delegation Strategy - Test that delegation is enabled for slim
+            expect(shouldDelegateToSynergy(framework)).toBe(true);
+            expect(getDelegationStrategy(framework)).toBe('delegate');
+            // Step 4: Complete Delegation Resolution - Test end-to-end resolution
+            const exploreResult = resolveAgentForDelegation('explore', framework, availableAgents);
+            expect(exploreResult.success).toBe(true);
+            expect(exploreResult.resolvedAgent).toBe('explorer');
+            expect(exploreResult.shouldFallback).toBe(false);
+            expect(exploreResult.reason).toBeUndefined();
+            const uiResult = resolveAgentForDelegation('frontend-ui-ux-engineer', framework, availableAgents);
+            expect(uiResult.success).toBe(true);
+            expect(uiResult.resolvedAgent).toBe('designer');
+            expect(uiResult.shouldFallback).toBe(false);
+            const docResult = resolveAgentForDelegation('document-writer', framework, availableAgents);
+            expect(docResult.success).toBe(true);
+            expect(docResult.resolvedAgent).toBe('librarian');
+            expect(docResult.shouldFallback).toBe(false);
+            const oracleResult = resolveAgentForDelegation('oracle', framework, availableAgents);
+            expect(oracleResult.success).toBe(true);
+            expect(oracleResult.resolvedAgent).toBe('oracle');
+            expect(oracleResult.shouldFallback).toBe(false);
+            // sisyphus should fallback since it has no slim equivalent
+            const sisyphusResult = resolveAgentForDelegation('sisyphus', framework, availableAgents);
+            expect(sisyphusResult.success).toBe(false);
+            expect(sisyphusResult.resolvedAgent).toBe(null);
+            expect(sisyphusResult.shouldFallback).toBe(true);
+            expect(sisyphusResult.reason).toContain('not available');
+            expect(sisyphusResult.reason).toContain('sisyphus');
+        });
+        it('should handle unavailable agents gracefully', () => {
+            const framework = 'oh-my-opencode-slim';
+            // Only explorer is available
+            const availableAgents = ['explorer'];
+            // explore maps to explorer and is available
+            const exploreResult = resolveAgentForDelegation('explore', framework, availableAgents);
+            expect(exploreResult.success).toBe(true);
+            expect(exploreResult.resolvedAgent).toBe('explorer');
+            // frontend-ui-ux-engineer maps to designer but designer is not available
+            const uiResult = resolveAgentForDelegation('frontend-ui-ux-engineer', framework, availableAgents);
+            expect(uiResult.success).toBe(false);
+            expect(uiResult.shouldFallback).toBe(true);
+            expect(uiResult.reason).toContain('not available');
+            // document-writer maps to librarian but librarian is not available
+            const docResult = resolveAgentForDelegation('document-writer', framework, availableAgents);
+            expect(docResult.success).toBe(false);
+            expect(docResult.shouldFallback).toBe(true);
+            expect(docResult.reason).toContain('not available');
+        });
+        it('should work with empty available agents list', () => {
+            const framework = 'oh-my-opencode-slim';
+            const availableAgents = [];
+            // All agents should fallback when none are available
+            const exploreResult = resolveAgentForDelegation('explore', framework, availableAgents);
+            expect(exploreResult.success).toBe(false);
+            expect(exploreResult.shouldFallback).toBe(true);
+            expect(exploreResult.reason).toContain('not available');
+            const sisyphusResult = resolveAgentForDelegation('sisyphus', framework, availableAgents);
+            expect(sisyphusResult.success).toBe(false);
+            expect(sisyphusResult.shouldFallback).toBe(true);
+            expect(sisyphusResult.reason).toContain('not available');
+        });
+    });
+    describe('Framework Priority and Switching', () => {
+        it('should handle oh-my-opencode framework (pass-through behavior)', () => {
+            const framework = 'oh-my-opencode';
+            const availableAgents = ['sisyphus', 'explore', 'oracle'];
+            // oh-my-opencode uses pass-through mapping (no transformation)
+            expect(resolveAgentName('explore', framework)).toBe('explore');
+            expect(resolveAgentName('sisyphus', framework)).toBe('sisyphus');
+            expect(resolveAgentName('oracle', framework)).toBe('oracle');
+            expect(resolveAgentName('frontend-ui-ux-engineer', framework)).toBe('frontend-ui-ux-engineer');
+            // Delegation should be enabled
+            expect(shouldDelegateToSynergy(framework)).toBe(true);
+            expect(getDelegationStrategy(framework)).toBe('delegate');
+            // Since oh-my-opencode doesn't have agent list detection,
+            // delegation with empty list means agent is assumed unavailable
+            const exploreResult = resolveAgentForDelegation('explore', framework, []);
+            expect(exploreResult.success).toBe(false);
+            expect(exploreResult.shouldFallback).toBe(true);
+            expect(exploreResult.reason).toContain('disabled or not available');
+        });
+        it('should handle manual mode (no synergy framework)', () => {
+            const framework = 'none';
+            const availableAgents = [];
+            // Manual mode means no delegation
+            expect(shouldDelegateToSynergy(framework)).toBe(false);
+            expect(getDelegationStrategy(framework)).toBe('manual');
+            // All agents should fallback in manual mode
+            const exploreResult = resolveAgentForDelegation('explore', framework, availableAgents);
+            expect(exploreResult.success).toBe(false);
+            expect(exploreResult.shouldFallback).toBe(true);
+            expect(exploreResult.reason).toContain('No synergy framework active');
+            const sisyphusResult = resolveAgentForDelegation('sisyphus', framework, availableAgents);
+            expect(sisyphusResult.success).toBe(false);
+            expect(sisyphusResult.shouldFallback).toBe(true);
+            expect(sisyphusResult.reason).toContain('No synergy framework active');
+        });
+    });
+    describe('Agent Mapping Completeness', () => {
+        it('should have mappings for all known generic agent names', () => {
+            const framework = 'oh-my-opencode-slim';
+            // Test all known mappings
+            const mappings = [
+                { generic: 'explore', slim: 'explorer' },
+                { generic: 'frontend-ui-ux-engineer', slim: 'designer' },
+                { generic: 'document-writer', slim: 'librarian' },
+                { generic: 'oracle', slim: 'oracle' }, // pass-through
+                { generic: 'sisyphus', slim: null }, // no equivalent
+            ];
+            for (const { generic, slim } of mappings) {
+                const resolved = resolveAgentName(generic, framework);
+                expect(resolved).toBe(slim);
+            }
+        });
+        it('should get complete agent mapping as object', () => {
+            const framework = 'oh-my-opencode-slim';
+            const mapping = getAgentMapping(framework);
+            // Check that known mappings exist
+            expect(mapping['explore']).toBe('explorer');
+            expect(mapping['frontend-ui-ux-engineer']).toBe('designer');
+            expect(mapping['document-writer']).toBe('librarian');
+            expect(mapping['oracle']).toBe('oracle');
+            expect(mapping['sisyphus']).toBe(null);
+        });
+        it('should have empty mapping for oh-my-opencode (pass-through)', () => {
+            const framework = 'oh-my-opencode';
+            const mapping = getAgentMapping(framework);
+            // oh-my-opencode has no special mappings
+            expect(mapping).toEqual({});
+        });
+        it('should pass through unknown agent names for oh-my-opencode only', () => {
+            // oh-my-opencode passes through unknown agents
+            expect(resolveAgentName('unknown-agent', 'oh-my-opencode')).toBe('unknown-agent');
+            expect(resolveAgentName('custom-agent', 'oh-my-opencode')).toBe('custom-agent');
+            expect(resolveAgentName('test-agent', 'oh-my-opencode')).toBe('test-agent');
+            // oh-my-opencode-slim returns null for unknown agents
+            expect(resolveAgentName('unknown-agent', 'oh-my-opencode-slim')).toBe(null);
+            expect(resolveAgentName('custom-agent', 'oh-my-opencode-slim')).toBe(null);
+        });
+    });
+    describe('Backward Compatibility', () => {
+        it('should not break oh-my-opencode agent resolution', () => {
+            const framework = 'oh-my-opencode';
+            // All agent names should pass through unchanged for oh-my-opencode
+            const agents = ['sisyphus', 'explore', 'oracle', 'frontend-ui-ux-engineer', 'document-writer'];
+            for (const agent of agents) {
+                expect(resolveAgentName(agent, framework)).toBe(agent);
+            }
+        });
+        it('should maintain delegation behavior for oh-my-opencode with available agents', () => {
+            const framework = 'oh-my-opencode';
+            const availableAgents = ['sisyphus']; // Provide available agents
+            // Delegation should be enabled
+            expect(shouldDelegateToSynergy(framework)).toBe(true);
+            expect(getDelegationStrategy(framework)).toBe('delegate');
+            // Resolution should work when agent is available
+            const result = resolveAgentForDelegation('sisyphus', framework, availableAgents);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('sisyphus');
+            expect(result.shouldFallback).toBe(false);
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('should handle null agent names gracefully', () => {
+            const availableAgents = ['explorer', 'designer'];
+            // null agent names should not be available
+            expect(isAgentAvailable(null, availableAgents)).toBe(false);
+        });
+        it('should handle empty agent name strings', () => {
+            const availableAgents = ['explorer', 'designer'];
+            // Empty string should not match
+            expect(isAgentAvailable('', availableAgents)).toBe(false);
+        });
+        it('should handle case-sensitive agent names', () => {
+            const framework = 'oh-my-opencode-slim';
+            const availableAgents = ['explorer', 'designer'];
+            // Agent names are case-sensitive
+            expect(isAgentAvailable('Explorer', availableAgents)).toBe(false);
+            expect(isAgentAvailable('EXPLORER', availableAgents)).toBe(false);
+            expect(isAgentAvailable('explorer', availableAgents)).toBe(true);
+        });
+        it('should handle whitespace in agent names', () => {
+            const availableAgents = ['explorer', 'designer'];
+            // Whitespace should matter
+            expect(isAgentAvailable(' explorer', availableAgents)).toBe(false);
+            expect(isAgentAvailable('explorer ', availableAgents)).toBe(false);
+            expect(isAgentAvailable('explorer', availableAgents)).toBe(true);
+        });
+    });
+    describe('Delegation Reason Messages', () => {
+        it('should provide clear reasons for fallback in manual mode', () => {
+            const result = resolveAgentForDelegation('explore', 'none', []);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toBe('No synergy framework active');
+        });
+        it('should provide clear reasons for missing agent mappings', () => {
+            const result = resolveAgentForDelegation('sisyphus', 'oh-my-opencode-slim', ['explorer']);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('not available');
+            expect(result.reason).toContain('sisyphus');
+            expect(result.reason).toContain('oh-my-opencode-slim');
+        });
+        it('should provide clear reasons for unavailable agents', () => {
+            const result = resolveAgentForDelegation('frontend-ui-ux-engineer', 'oh-my-opencode-slim', ['explorer']);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('not available');
+            expect(result.reason).toContain('designer');
+        });
+    });
+});

package/dist/utils/agentMapping.d.ts

@@ -0,0 +1,24 @@
+import type { SynergyFramework } from './configDetection.js';
+/**
+ * Resolve a requested agent name to the framework-specific agent name
+ *
+ * @param requestedAgent - The agent name requested by the user
+ * @param framework - The active synergy framework
+ * @returns The framework-specific agent name, or null if not available
+ */
+export declare function resolveAgentName(requestedAgent: string, framework: SynergyFramework): string | null;
+/**
+ * Get the complete agent mapping for a framework
+ *
+ * @param framework - The synergy framework
+ * @returns The agent mapping object
+ */
+export declare function getAgentMapping(framework: SynergyFramework): Record<string, string | null>;
+/**
+ * Check if an agent is available in the list of available agents
+ *
+ * @param agentName - The agent name to check (can be null)
+ * @param availableAgents - List of available agents
+ * @returns True if the agent is available
+ */
+export declare function isAgentAvailable(agentName: string | null, availableAgents: string[]): boolean;

package/dist/utils/agentMapping.js

@@ -0,0 +1,65 @@
+/**
+ * Mapping from generic agent names to framework-specific agent names
+ * for oh-my-opencode-slim
+ */
+const SLIM_AGENT_MAPPING = {
+    // Generic names → slim-specific names
+    'explore': 'explorer',
+    'frontend-ui-ux-engineer': 'designer',
+    'document-writer': 'librarian',
+    'oracle': 'oracle',
+    // Slim native names (pass through)
+    'explorer': 'explorer',
+    'designer': 'designer',
+    'librarian': 'librarian',
+    // Agents without slim equivalent
+    'sisyphus': null,
+    'orchestrator': null,
+};
+/**
+ * Resolve a requested agent name to the framework-specific agent name
+ *
+ * @param requestedAgent - The agent name requested by the user
+ * @param framework - The active synergy framework
+ * @returns The framework-specific agent name, or null if not available
+ */
+export function resolveAgentName(requestedAgent, framework) {
+    if (framework === 'none') {
+        return null;
+    }
+    if (framework === 'oh-my-opencode-slim') {
+        // Use the mapping, return null if not found
+        return SLIM_AGENT_MAPPING[requestedAgent] ?? null;
+    }
+    // For oh-my-opencode, pass through agent names unchanged
+    if (framework === 'oh-my-opencode') {
+        return requestedAgent;
+    }
+    return null;
+}
+/**
+ * Get the complete agent mapping for a framework
+ *
+ * @param framework - The synergy framework
+ * @returns The agent mapping object
+ */
+export function getAgentMapping(framework) {
+    if (framework === 'oh-my-opencode-slim') {
+        return { ...SLIM_AGENT_MAPPING };
+    }
+    // For oh-my-opencode and none, return empty mapping
+    return {};
+}
+/**
+ * Check if an agent is available in the list of available agents
+ *
+ * @param agentName - The agent name to check (can be null)
+ * @param availableAgents - List of available agents
+ * @returns True if the agent is available
+ */
+export function isAgentAvailable(agentName, availableAgents) {
+    if (agentName === null) {
+        return false;
+    }
+    return availableAgents.includes(agentName);
+}

package/dist/utils/agentMapping.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/agentMapping.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import { resolveAgentName, getAgentMapping, isAgentAvailable } from './agentMapping.js';
+describe('Agent Mapping', () => {
+    describe('resolveAgentName', () => {
+        it('should map generic agent names to oh-my-opencode-slim agents', () => {
+            expect(resolveAgentName('explore', 'oh-my-opencode-slim')).toBe('explorer');
+            expect(resolveAgentName('frontend-ui-ux-engineer', 'oh-my-opencode-slim')).toBe('designer');
+            expect(resolveAgentName('document-writer', 'oh-my-opencode-slim')).toBe('librarian');
+            expect(resolveAgentName('oracle', 'oh-my-opencode-slim')).toBe('oracle');
+        });
+        it('should pass through oh-my-opencode-slim native agent names', () => {
+            expect(resolveAgentName('explorer', 'oh-my-opencode-slim')).toBe('explorer');
+            expect(resolveAgentName('designer', 'oh-my-opencode-slim')).toBe('designer');
+            expect(resolveAgentName('librarian', 'oh-my-opencode-slim')).toBe('librarian');
+        });
+        it('should return null for agents without slim equivalent', () => {
+            expect(resolveAgentName('sisyphus', 'oh-my-opencode-slim')).toBe(null);
+        });
+        it('should return null for unknown agent names in slim framework', () => {
+            expect(resolveAgentName('unknown-agent', 'oh-my-opencode-slim')).toBe(null);
+        });
+        it('should pass through agent names for oh-my-opencode framework', () => {
+            expect(resolveAgentName('sisyphus', 'oh-my-opencode')).toBe('sisyphus');
+            expect(resolveAgentName('oracle', 'oh-my-opencode')).toBe('oracle');
+            expect(resolveAgentName('explore', 'oh-my-opencode')).toBe('explore');
+        });
+        it('should return null when framework is none', () => {
+            expect(resolveAgentName('explore', 'none')).toBe(null);
+            expect(resolveAgentName('oracle', 'none')).toBe(null);
+        });
+    });
+    describe('getAgentMapping', () => {
+        it('should return the complete mapping for oh-my-opencode-slim', () => {
+            const mapping = getAgentMapping('oh-my-opencode-slim');
+            expect(mapping).toHaveProperty('explore', 'explorer');
+            expect(mapping).toHaveProperty('explorer', 'explorer');
+            expect(mapping).toHaveProperty('frontend-ui-ux-engineer', 'designer');
+            expect(mapping).toHaveProperty('designer', 'designer');
+            expect(mapping).toHaveProperty('document-writer', 'librarian');
+            expect(mapping).toHaveProperty('librarian', 'librarian');
+            expect(mapping).toHaveProperty('oracle', 'oracle');
+            expect(mapping).toHaveProperty('sisyphus', null);
+        });
+        it('should return identity mapping for oh-my-opencode', () => {
+            const mapping = getAgentMapping('oh-my-opencode');
+            // For oh-my-opencode, agent names pass through unchanged
+            expect(mapping).toEqual({});
+        });
+        it('should return empty mapping when framework is none', () => {
+            const mapping = getAgentMapping('none');
+            expect(mapping).toEqual({});
+        });
+    });
+    describe('isAgentAvailable', () => {
+        it('should return true if agent is in available list', () => {
+            const availableAgents = ['explorer', 'designer', 'librarian'];
+            expect(isAgentAvailable('explorer', availableAgents)).toBe(true);
+            expect(isAgentAvailable('designer', availableAgents)).toBe(true);
+        });
+        it('should return false if agent is not in available list', () => {
+            const availableAgents = ['explorer', 'designer'];
+            expect(isAgentAvailable('librarian', availableAgents)).toBe(false);
+            expect(isAgentAvailable('oracle', availableAgents)).toBe(false);
+        });
+        it('should return false for null agent name', () => {
+            const availableAgents = ['explorer', 'designer'];
+            expect(isAgentAvailable(null, availableAgents)).toBe(false);
+        });
+        it('should return false when available agents list is empty', () => {
+            expect(isAgentAvailable('explorer', [])).toBe(false);
+        });
+        it('should handle case-sensitive matching', () => {
+            const availableAgents = ['explorer', 'Designer'];
+            expect(isAgentAvailable('explorer', availableAgents)).toBe(true);
+            expect(isAgentAvailable('Explorer', availableAgents)).toBe(false);
+            expect(isAgentAvailable('Designer', availableAgents)).toBe(true);
+            expect(isAgentAvailable('designer', availableAgents)).toBe(false);
+        });
+    });
+});

package/dist/utils/archive-tracks.d.ts

@@ -0,0 +1,25 @@
+export interface TrackMetadata {
+    track_id: string;
+    type: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    description: string;
+}
+export interface ArchiveResult {
+    archived: string[];
+    skipped: string[];
+    errors: {
+        trackId: string;
+        error: string;
+    }[];
+}
+/**
+ * Interface representing the structure of a track's plan file
+ */
+export interface TrackPlan {
+    tasks: {
+        name: string;
+        completed: boolean;
+    }[];
+}

package/dist/utils/archive-tracks.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/configDetection.d.ts

@@ -1,7 +1,10 @@
+export type SynergyFramework = 'none' | 'oh-my-opencode' | 'oh-my-opencode-slim';
 export interface ConfigDetectionResult {
     hasCDDInOpenCode: boolean;
     hasCDDInOMO: boolean;
     synergyActive: boolean;
     cddModel?: string;
+    synergyFramework: SynergyFramework;
+    slimAgents?: string[];
 }
 export declare function detectCDDConfig(): ConfigDetectionResult;

package/dist/utils/configDetection.js

@@ -5,15 +5,36 @@ export function detectCDDConfig() {
     const opencodeConfigDir = join(homedir(), ".config", "opencode");
     const opencodeJsonPath = join(opencodeConfigDir, "opencode.json");
     const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
+    const slimJsonPath = join(opencodeConfigDir, "oh-my-opencode-slim.json");
     let hasCDDInOpenCode = false;
     let hasCDDInOMO = false;
     let cddModel;
-    // Check oh-my-opencode.json first (higher priority)
-    if (existsSync(omoJsonPath)) {
+    let synergyFramework = 'none';
+    let slimAgents;
+    // Check oh-my-opencode-slim.json first (highest priority for synergy)
+    if (existsSync(slimJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(slimJsonPath, "utf-8"));
+            // Check if config is not empty and has actual content
+            if (config && Object.keys(config).length > 0) {
+                synergyFramework = 'oh-my-opencode-slim';
+                // Extract available agents (filter out disabled ones)
+                const coreAgents = ['explorer', 'librarian', 'oracle', 'designer'];
+                const disabledAgents = new Set(config.disabled_agents ?? []);
+                slimAgents = coreAgents.filter(agent => !disabledAgents.has(agent));
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check oh-my-opencode.json (only if slim is not active)
+    if (synergyFramework === 'none' && existsSync(omoJsonPath)) {
         try {
             const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
             if (config.agents && config.agents.cdd) {
                 hasCDDInOMO = true;
+                synergyFramework = 'oh-my-opencode';
                 // Extract model from oh-my-opencode.json
                 if (config.agents.cdd.model) {
                     cddModel = config.agents.cdd.model;
@@ -43,7 +64,9 @@ export function detectCDDConfig() {
     return {
         hasCDDInOpenCode,
         hasCDDInOMO,
-        synergyActive: hasCDDInOMO,
+        synergyActive: synergyFramework !== 'none',
         cddModel,
+        synergyFramework,
+        slimAgents,
     };
 }

package/dist/utils/configDetection.test.js

@@ -11,6 +11,7 @@ vi.mock("os", () => ({
 describe("configDetection", () => {
     const opencodeJsonPath = "/home/user/.config/opencode/opencode.json";
     const omoJsonPath = "/home/user/.config/opencode/oh-my-opencode.json";
+    const slimJsonPath = "/home/user/.config/opencode/oh-my-opencode-slim.json";
     beforeEach(() => {
         vi.clearAllMocks();
     });
@@ -116,4 +117,90 @@ describe("configDetection", () => {
         expect(result.hasCDDInOMO).toBe(true);
         expect(result.cddModel).toBeUndefined();
     });
+    // New tests for oh-my-opencode-slim detection
+    describe("oh-my-opencode-slim detection", () => {
+        it("should detect oh-my-opencode-slim when only slim config is present", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: { designer: { model: "google/gemini-3-flash" } }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyActive).toBe(true);
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.slimAgents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
+        });
+        it("should prioritize oh-my-opencode-slim over oh-my-opencode when both present", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({ agents: {} });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({ agents: { cdd: { model: "model-from-omo" } } });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyActive).toBe(true);
+        });
+        it("should filter out disabled agents from slim config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        disabled_agents: ['oracle', 'designer']
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.slimAgents).toEqual(['explorer', 'librarian']);
+        });
+        it("should handle empty oh-my-opencode-slim config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({});
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should fallback to oh-my-opencode when slim config is invalid", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return "invalid json";
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({ agents: { cdd: { model: "model-from-omo" } } });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('oh-my-opencode');
+            expect(result.hasCDDInOMO).toBe(true);
+        });
+        it("should handle malformed slim config gracefully", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    throw new Error("File read error");
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+    });
 });

package/dist/utils/synergyDelegation.d.ts

@@ -0,0 +1,33 @@
+import type { SynergyFramework } from './configDetection.js';
+/**
+ * Result of agent resolution for delegation
+ */
+export interface DelegationResult {
+    success: boolean;
+    resolvedAgent: string | null;
+    shouldFallback: boolean;
+    reason?: string;
+}
+/**
+ * Determine if delegation to synergy framework should occur
+ *
+ * @param framework - The active synergy framework
+ * @returns True if delegation should occur
+ */
+export declare function shouldDelegateToSynergy(framework: SynergyFramework): boolean;
+/**
+ * Get the delegation strategy file name based on active framework
+ *
+ * @param framework - The active synergy framework
+ * @returns Strategy file name ('delegate' or 'manual')
+ */
+export declare function getDelegationStrategy(framework: SynergyFramework): 'delegate' | 'manual';
+/**
+ * Resolve an agent name for delegation, handling mapping and availability
+ *
+ * @param requestedAgent - The agent name requested
+ * @param framework - The active synergy framework
+ * @param availableAgents - List of available agents in the framework
+ * @returns Delegation result with resolved agent or fallback info
+ */
+export declare function resolveAgentForDelegation(requestedAgent: string, framework: SynergyFramework, availableAgents: string[]): DelegationResult;