opencode-conductor-cdd-plugin 1.0.0-beta.13 → 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.
 
 ---
@@ -52,8 +52,8 @@ Add the plugin to your global OpenCode configuration file. OpenCode will automat
 
 ```json
 {
-  "plugin": [
-    "opencode-conductor-cdd-plugin"
+  "plugins": [
+    "opencode-conductor-cdd-plugin@beta"
   ]
 }
 ```
@@ -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/rebrand.test.d.ts

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

package/dist/test/integration/rebrand.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+describe('Rebrand Integration Tests', () => {
+    describe('Package Metadata', () => {
+        it('should have correct package name', () => {
+            const pkgPath = path.join(process.cwd(), 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            expect(pkg.name).toBe('opencode-conductor-cdd-plugin');
+        });
+        it('should have beta version', () => {
+            const pkgPath = path.join(process.cwd(), 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            expect(pkg.version).toMatch(/^1\.0\.0-beta\.\d+$/);
+        });
+        it('should reference new repository', () => {
+            const pkgPath = path.join(process.cwd(), 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            expect(pkg.repository.url).toContain('opencode-conductor-cdd');
+            expect(pkg.repository.url).not.toContain('opencode-orchestrator');
+        });
+    });
+    describe('Prompt Files Structure', () => {
+        it('should have cdd prompts directory', () => {
+            const cddPromptsPath = path.join(process.cwd(), 'src/prompts/cdd');
+            expect(fs.existsSync(cddPromptsPath)).toBe(true);
+        });
+        it('should NOT have orchestrator prompts directory', () => {
+            const orchestratorPromptsPath = path.join(process.cwd(), 'src/prompts/orchestrator');
+            expect(fs.existsSync(orchestratorPromptsPath)).toBe(false);
+        });
+        it('should have all required CDD prompt files', () => {
+            const cddPromptsPath = path.join(process.cwd(), 'src/prompts/cdd');
+            const requiredFiles = ['setup.json', 'newTrack.json', 'implement.json', 'status.json', 'revert.json'];
+            for (const file of requiredFiles) {
+                const filePath = path.join(cddPromptsPath, file);
+                expect(fs.existsSync(filePath), `${file} should exist`).toBe(true);
+            }
+        });
+        it('should have cdd agent prompt file', () => {
+            const cddAgentPath = path.join(process.cwd(), 'src/prompts/agent/cdd.md');
+            expect(fs.existsSync(cddAgentPath)).toBe(true);
+        });
+        it('should NOT have orchestrator agent prompt file', () => {
+            const orchestratorAgentPath = path.join(process.cwd(), 'src/prompts/agent/orchestrator.md');
+            expect(fs.existsSync(orchestratorAgentPath)).toBe(false);
+        });
+    });
+    describe('Source Code References', () => {
+        it('should import from cdd prompts in index.ts', () => {
+            const indexPath = path.join(process.cwd(), 'src/index.ts');
+            const indexContent = fs.readFileSync(indexPath, 'utf-8');
+            expect(indexContent).toContain('./prompts/cdd/implement.json');
+            expect(indexContent).toContain('./prompts/cdd/newTrack.json');
+            expect(indexContent).toContain('./prompts/cdd/setup.json');
+            expect(indexContent).not.toContain('./prompts/orchestrator/');
+        });
+        it('should register cdd: commands in index.ts', () => {
+            const indexPath = path.join(process.cwd(), 'src/index.ts');
+            const indexContent = fs.readFileSync(indexPath, 'utf-8');
+            expect(indexContent).toContain('"cdd:implement"');
+            expect(indexContent).toContain('"cdd:newTrack"');
+            expect(indexContent).toContain('"cdd:setup"');
+            expect(indexContent).toContain('"cdd:status"');
+            expect(indexContent).toContain('"cdd:revert"');
+            expect(indexContent).not.toContain('"orchestrator:');
+        });
+        it('should reference conductor-cdd directory in index.ts', () => {
+            const indexPath = path.join(process.cwd(), 'src/index.ts');
+            const indexContent = fs.readFileSync(indexPath, 'utf-8');
+            expect(indexContent).toContain('conductor-cdd');
+        });
+        it('should use cdd agent for commands', () => {
+            const indexPath = path.join(process.cwd(), 'src/index.ts');
+            const indexContent = fs.readFileSync(indexPath, 'utf-8');
+            expect(indexContent).toContain('agent: "cdd"');
+        });
+    });
+    describe('Utility Files References', () => {
+        it('should use conductor-cdd in stateManager', () => {
+            const stateManagerPath = path.join(process.cwd(), 'src/utils/stateManager.ts');
+            const content = fs.readFileSync(stateManagerPath, 'utf-8');
+            expect(content).toContain('conductor-cdd');
+            expect(content).not.toContain('orchestrator/');
+        });
+        it('should use detectCDDConfig function name', () => {
+            const configDetectionPath = path.join(process.cwd(), 'src/utils/configDetection.ts');
+            const content = fs.readFileSync(configDetectionPath, 'utf-8');
+            expect(content).toContain('detectCDDConfig');
+            expect(content).not.toContain('detectOrchestratorConfig');
+        });
+        it('should use cdd prefix in commit messages', () => {
+            const commitMessagesPath = path.join(process.cwd(), 'src/utils/commitMessages.ts');
+            const content = fs.readFileSync(commitMessagesPath, 'utf-8');
+            expect(content).toContain('cdd(');
+            expect(content).not.toContain('orchestrator(');
+        });
+    });
+    describe('README Documentation', () => {
+        it('should reference new package name in README', () => {
+            const readmePath = path.join(process.cwd(), 'README.md');
+            const content = fs.readFileSync(readmePath, 'utf-8');
+            expect(content).toContain('opencode-conductor-cdd-plugin');
+        });
+        it('should show /cdd: commands in README', () => {
+            const readmePath = path.join(process.cwd(), 'README.md');
+            const content = fs.readFileSync(readmePath, 'utf-8');
+            expect(content).toContain('/cdd:setup');
+            expect(content).toContain('/cdd:newTrack');
+            expect(content).toContain('/cdd:implement');
+        });
+        it('should NOT reference orchestrator commands in README', () => {
+            const readmePath = path.join(process.cwd(), 'README.md');
+            const content = fs.readFileSync(readmePath, 'utf-8');
+            expect(content).not.toContain('/orchestrator:');
+        });
+    });
+    describe('Build Scripts', () => {
+        it('should reference cdd prompts in convert-legacy script', () => {
+            const scriptPath = path.join(process.cwd(), 'scripts/convert-legacy.cjs');
+            const content = fs.readFileSync(scriptPath, 'utf-8');
+            expect(content).toContain('src/prompts/cdd');
+            expect(content).not.toContain('src/prompts/orchestrator');
+        });
+    });
+});

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 {};