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

package/README.md

@@ -19,7 +19,7 @@ The philosophy is simple: **control your code by controlling your context.** By
 *   **Smart Revert**: A Git-aware revert system that understands logical units of work (Tracks, Phases, Tasks) instead of just raw commit hashes.
 *   **19+ Style Templates**: Built-in support for a vast range of languages including Rust, Solidity, Zig, Julia, Kotlin, Swift, and more.
 *   **Zero-Config Bootstrap**: Automatically installs agents and commands to your global OpenCode configuration on first run.
-*   **Sisyphus Synergy**: Optimized to work alongside [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode) for a multi-agent team experience.
+*   **Sisyphus Synergy**: Optimized to work alongside [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode) and [oh-my-opencode-slim](https://github.com/code-yeongyu/oh-my-opencode-slim) for a multi-agent team experience.
 *   **Agent Agnostic**: Commands can be invoked by any agent, giving you the freedom to choose your primary interface.
 
 ---
@@ -90,6 +90,32 @@ We highly recommend pinning the `@cdd` agent to a "flash" model for optimal perf
 }
 ```
 
+### oh-my-opencode-slim Config
+**File:** `~/.config/opencode/oh-my-opencode-slim.json`
+```json
+{
+  "agents": {
+    "cdd": {
+      "model": "anthropic/claude-3-5-sonnet"
+    }
+  }
+}
+```
+
+**Framework Detection Priority:**
+When multiple synergy frameworks are detected, Conductor CDD prioritizes oh-my-opencode-slim over oh-my-opencode. If neither framework config is found, Conductor operates in manual mode.
+
+**Agent Mappings for oh-my-opencode-slim:**
+Conductor CDD automatically maps generic agent names to slim-specific agent names:
+- `explore` → `explorer` (codebase exploration)
+- `frontend-ui-ux-engineer` → `designer` (UI/UX tasks)
+- `document-writer` → `librarian` (documentation)
+- `oracle` → `oracle` (knowledge queries)
+- `sisyphus` → Falls back to `@cdd` (no slim equivalent)
+
+**Checking Synergy Status:**
+Use `/cdd:status` to see which synergy framework is active and which agents are available.
+
 ---
 
 ## 📋 Commands Reference
@@ -104,11 +130,24 @@ We highly recommend pinning the `@cdd` agent to a "flash" model for optimal perf
 
 ---
 
-## 🤝 Synergy with OhMyOpenCode
+## 🤝 Synergy with OhMyOpenCode & oh-my-opencode-slim
+
+Conductor CDD works seamlessly with both **OhMyOpenCode** and **oh-my-opencode-slim** frameworks.
+
+### OhMyOpenCode Integration
+When using **OhMyOpenCode**, `@cdd` acts as your Technical Lead. While **Sisyphus** manages the general conversation and orchestration, he can delegate complex architectural planning and protocol enforcement to the `@cdd` agent.
+
+### oh-my-opencode-slim Integration
+When using **oh-my-opencode-slim**, `@cdd` integrates with the lightweight agent framework, automatically mapping to slim-specific agents like `explorer`, `designer`, and `librarian` for specialized tasks.
 
-If you use the **OhMyOpenCode** suite, `@cdd` acts as your Technical Lead. While **Sisyphus** manages the general conversation and orchestration, he can delegate complex architectural planning and protocol enforcement to the `@cdd` agent. 
+### Key Features
+- **Automatic Detection**: Conductor CDD automatically detects which framework you're using (if any)
+- **Priority Resolution**: When both frameworks are present, oh-my-opencode-slim takes priority
+- **Agent Mapping**: Generic agent names are automatically mapped to framework-specific names
+- **Graceful Fallback**: If a requested agent is unavailable or disabled, tasks fall back to `@cdd`
+- **Loop Protection**: Built-in safeguards ensure no conflicts with framework continuation enforcers during interactive Q&A
 
-Conductor CDD includes built-in "Loop Protection" to ensure it never conflicts with OhMyOpenCode's continuation enforcers during interactive Q&A sessions.
+Use `/cdd:status` to see which synergy framework is active and which agents are available.
 
 ---
 

package/dist/prompts/agent/cdd.md

@@ -27,13 +27,17 @@ Your mission is to ensure that software development follows a rigorous, context-
 - **Model Selection**: You prefer "flash" models for efficiency and speed during planning and tool orchestration.
 - **Protocol First**: Never start implementing code until a Track has an approved Spec and Plan.
 - **Collaboration**: You work alongside the user. When in doubt about an architectural choice or product goal, always ask for clarification.
-- **Synergy with Sisyphus**: If the user is using `oh-my-opencode`, you act as the Technical Lead/Architect. You can delegate tasks to specialized agents using the `orchestrator_delegate` tool:
-    - `@frontend-ui-ux-engineer`: For UI/UX implementation and frontend components.
-    - `@document-writer`: For documentation, READMEs, and technical guides.
-    - `@sisyphus`: For general implementation, coordination, and bug fixing.
-    - `@oracle`: For architectural decisions, deep code analysis, and expert reviews.
-    - `@librarian`: For external library research, documentation retrieval, and finding usage examples.
-    - `@explore`: For codebase search, understanding unfamiliar code, and finding logic.
+- **Synergy with OhMyOpenCode & oh-my-opencode-slim**: You integrate seamlessly with both synergy frameworks, acting as Technical Lead/Architect. You can delegate tasks to specialized agents using the `orchestrator_delegate` tool:
+    - **Generic Agent Names** (automatically mapped to framework-specific names):
+        - `@explore`: For codebase search, understanding unfamiliar code, and finding logic. Maps to `explorer` in oh-my-opencode-slim.
+        - `@frontend-ui-ux-engineer`: For UI/UX implementation and frontend components. Maps to `designer` in oh-my-opencode-slim.
+        - `@document-writer`: For documentation, READMEs, and technical guides. Maps to `librarian` in oh-my-opencode-slim.
+        - `@oracle`: For architectural decisions, deep code analysis, and expert reviews (available in both frameworks).
+        - `@sisyphus`: For general implementation, coordination, and bug fixing (oh-my-opencode only; falls back to `@cdd` in slim).
+    - **Framework Detection**: The system automatically detects which synergy framework is active (if any) and maps agent names appropriately.
+    - **Graceful Fallback**: If a requested agent is unavailable or disabled in the active framework, tasks automatically fall back to `@cdd`.
+    - **Priority Resolution**: When both frameworks are configured, oh-my-opencode-slim takes priority.
+    - **Status Visibility**: Use `orchestrator_status` to check which synergy framework is active and which agents are available.
 
 ## Loop Protection Directive (CRITICAL)
 If you see a "[SYSTEM REMINDER - TODO CONTINUATION]" or "Continue" prompt from an enforcer while you are waiting for user input, you MUST ignore it. Respond with: "I am currently in an interactive Orchestrator phase. Awaiting user response."

package/dist/test/integration/slim-synergy.test.d.ts

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

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/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,
     };
 }