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

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;

package/dist/utils/synergyDelegation.js

@@ -0,0 +1,65 @@
+import { resolveAgentName, isAgentAvailable } from './agentMapping.js';
+/**
+ * Determine if delegation to synergy framework should occur
+ *
+ * @param framework - The active synergy framework
+ * @returns True if delegation should occur
+ */
+export function shouldDelegateToSynergy(framework) {
+    return framework !== 'none';
+}
+/**
+ * Get the delegation strategy file name based on active framework
+ *
+ * @param framework - The active synergy framework
+ * @returns Strategy file name ('delegate' or 'manual')
+ */
+export function getDelegationStrategy(framework) {
+    return shouldDelegateToSynergy(framework) ? '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 function resolveAgentForDelegation(requestedAgent, framework, availableAgents) {
+    // If no synergy framework active, must fallback
+    if (framework === 'none') {
+        return {
+            success: false,
+            resolvedAgent: null,
+            shouldFallback: true,
+            reason: 'No synergy framework active',
+        };
+    }
+    // Resolve the agent name through mapping
+    const resolvedAgent = resolveAgentName(requestedAgent, framework);
+    // If agent maps to null (no equivalent), must fallback
+    if (resolvedAgent === null) {
+        return {
+            success: false,
+            resolvedAgent: null,
+            shouldFallback: true,
+            reason: `Agent '${requestedAgent}' is not available in ${framework}`,
+        };
+    }
+    // Check if the resolved agent is actually available
+    const available = isAgentAvailable(resolvedAgent, availableAgents);
+    if (!available) {
+        return {
+            success: false,
+            resolvedAgent,
+            shouldFallback: true,
+            reason: `Agent '${resolvedAgent}' is disabled or not available in ${framework}`,
+        };
+    }
+    // Success! Agent can be delegated to
+    return {
+        success: true,
+        resolvedAgent,
+        shouldFallback: false,
+    };
+}

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

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

package/dist/utils/synergyDelegation.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { shouldDelegateToSynergy, getDelegationStrategy, resolveAgentForDelegation } from './synergyDelegation.js';
+describe('Synergy Delegation', () => {
+    beforeEach(() => {
+        // Clear any mocks
+        vi.clearAllMocks();
+    });
+    describe('shouldDelegateToSynergy', () => {
+        it('should return true when oh-my-opencode is active', () => {
+            const result = shouldDelegateToSynergy('oh-my-opencode');
+            expect(result).toBe(true);
+        });
+        it('should return true when oh-my-opencode-slim is active', () => {
+            const result = shouldDelegateToSynergy('oh-my-opencode-slim');
+            expect(result).toBe(true);
+        });
+        it('should return false when no synergy framework is active', () => {
+            const result = shouldDelegateToSynergy('none');
+            expect(result).toBe(false);
+        });
+    });
+    describe('getDelegationStrategy', () => {
+        it('should return delegate strategy for oh-my-opencode', () => {
+            const strategy = getDelegationStrategy('oh-my-opencode');
+            expect(strategy).toBe('delegate');
+        });
+        it('should return delegate strategy for oh-my-opencode-slim', () => {
+            const strategy = getDelegationStrategy('oh-my-opencode-slim');
+            expect(strategy).toBe('delegate');
+        });
+        it('should return manual strategy when no framework active', () => {
+            const strategy = getDelegationStrategy('none');
+            expect(strategy).toBe('manual');
+        });
+    });
+    describe('resolveAgentForDelegation', () => {
+        it('should resolve sisyphus to sisyphus for oh-my-opencode', () => {
+            const result = resolveAgentForDelegation('sisyphus', 'oh-my-opencode', ['sisyphus', 'oracle']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('sisyphus');
+            expect(result.shouldFallback).toBe(false);
+        });
+        it('should resolve explore to explorer for oh-my-opencode-slim', () => {
+            const result = resolveAgentForDelegation('explore', 'oh-my-opencode-slim', ['explorer', 'designer']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('explorer');
+            expect(result.shouldFallback).toBe(false);
+        });
+        it('should handle sisyphus mapping to null for slim (not available)', () => {
+            const result = resolveAgentForDelegation('sisyphus', 'oh-my-opencode-slim', ['explorer', 'designer']);
+            expect(result.success).toBe(false);
+            expect(result.resolvedAgent).toBe(null);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('not available');
+        });
+        it('should fallback when agent not in available list', () => {
+            const result = resolveAgentForDelegation('oracle', 'oh-my-opencode-slim', ['explorer', 'designer'] // oracle not in list
+            );
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('disabled or not available');
+        });
+        it('should handle unknown agent names', () => {
+            const result = resolveAgentForDelegation('unknown-agent', 'oh-my-opencode-slim', ['explorer']);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+        });
+        it('should return fallback when framework is none', () => {
+            const result = resolveAgentForDelegation('explore', 'none', []);
+            expect(result.success).toBe(false);
+            expect(result.shouldFallback).toBe(true);
+            expect(result.reason).toContain('No synergy framework');
+        });
+        it('should handle frontend-ui-ux-engineer mapping to designer', () => {
+            const result = resolveAgentForDelegation('frontend-ui-ux-engineer', 'oh-my-opencode-slim', ['designer', 'explorer']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('designer');
+            expect(result.shouldFallback).toBe(false);
+        });
+        it('should pass through agent names for oh-my-opencode', () => {
+            const result = resolveAgentForDelegation('explore', // not a standard omo agent, but should pass through
+            'oh-my-opencode', ['explore', 'sisyphus']);
+            expect(result.success).toBe(true);
+            expect(result.resolvedAgent).toBe('explore');
+            expect(result.shouldFallback).toBe(false);
+        });
+    });
+});

package/dist/utils/synergyState.d.ts

@@ -0,0 +1,18 @@
+import { type SynergyFramework } from "./configDetection.js";
+export interface SynergyState {
+    framework: SynergyFramework;
+    detectedAt: Date;
+    availableAgents: string[];
+    lastCheck: Date;
+}
+/**
+ * Get the current synergy state, with caching
+ * @param workingDir - Current working directory
+ * @param forceRefresh - Force re-detection even if cache is valid
+ * @returns Current synergy state
+ */
+export declare function getSynergyState(workingDir: string, forceRefresh?: boolean): SynergyState;
+/**
+ * Clear the synergy state cache, forcing re-detection on next call
+ */
+export declare function clearSynergyCache(): void;

package/dist/utils/synergyState.js

@@ -0,0 +1,52 @@
+import { detectCDDConfig } from "./configDetection.js";
+// In-memory cache
+let synergyStateCache = null;
+let lastWorkingDir = null;
+// Cache TTL: 60 seconds
+const CACHE_TTL_MS = 60000;
+/**
+ * Get the current synergy state, with caching
+ * @param workingDir - Current working directory
+ * @param forceRefresh - Force re-detection even if cache is valid
+ * @returns Current synergy state
+ */
+export function getSynergyState(workingDir, forceRefresh = false) {
+    const now = Date.now();
+    // Return cached state if:
+    // 1. Not forcing refresh
+    // 2. Cache exists
+    // 3. Same working directory
+    // 4. Cache is still fresh (within TTL)
+    if (!forceRefresh &&
+        synergyStateCache &&
+        lastWorkingDir === workingDir &&
+        now - synergyStateCache.lastCheck.getTime() < CACHE_TTL_MS) {
+        return synergyStateCache;
+    }
+    // Perform detection
+    const detection = detectCDDConfig();
+    // Extract available agents based on framework
+    let availableAgents = [];
+    if (detection.synergyFramework === 'oh-my-opencode-slim' && detection.slimAgents) {
+        availableAgents = detection.slimAgents;
+    }
+    // Note: oh-my-opencode doesn't expose agent list through config detection,
+    // so we leave availableAgents empty for that framework
+    const state = {
+        framework: detection.synergyFramework,
+        detectedAt: new Date(),
+        availableAgents,
+        lastCheck: new Date(),
+    };
+    // Update cache
+    synergyStateCache = state;
+    lastWorkingDir = workingDir;
+    return state;
+}
+/**
+ * Clear the synergy state cache, forcing re-detection on next call
+ */
+export function clearSynergyCache() {
+    synergyStateCache = null;
+    lastWorkingDir = null;
+}

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

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

package/dist/utils/synergyState.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { getSynergyState, clearSynergyCache } from "./synergyState.js";
+// Mock the configDetection module
+vi.mock("./configDetection.js", () => ({
+    detectCDDConfig: vi.fn(),
+}));
+import { detectCDDConfig } from "./configDetection.js";
+describe("synergyState", () => {
+    beforeEach(() => {
+        clearSynergyCache();
+        vi.clearAllMocks();
+    });
+    describe("getSynergyState", () => {
+        it("should detect and cache synergy state on first call", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer', 'librarian', 'oracle', 'designer'],
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.framework).toBe('oh-my-opencode-slim');
+            expect(state.availableAgents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
+            expect(detectCDDConfig).toHaveBeenCalledTimes(1);
+        });
+        it("should return cached state on subsequent calls with same directory", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer', 'librarian'],
+            });
+            const state1 = getSynergyState("/test/dir");
+            const state2 = getSynergyState("/test/dir");
+            expect(state1).toBe(state2); // Same object reference
+            expect(detectCDDConfig).toHaveBeenCalledTimes(1); // Only called once
+        });
+        it("should refresh state when working directory changes", () => {
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: true,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-1',
+            });
+            const state1 = getSynergyState("/dir1");
+            const state2 = getSynergyState("/dir2");
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+        });
+        it("should force refresh when forceRefresh is true", () => {
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-changed',
+            });
+            const state1 = getSynergyState("/test/dir");
+            const state2 = getSynergyState("/test/dir", true); // Force refresh
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+        });
+        it("should handle no synergy active", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: true,
+                hasCDDInOMO: false,
+                synergyActive: false,
+                synergyFramework: 'none',
+                cddModel: 'model-1',
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.framework).toBe('none');
+            expect(state.availableAgents).toEqual([]);
+        });
+        it("should refresh cache after TTL expires", () => {
+            vi.useFakeTimers();
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-1',
+            });
+            const state1 = getSynergyState("/test/dir");
+            // Advance time by 61 seconds (TTL is 60 seconds)
+            vi.advanceTimersByTime(61000);
+            const state2 = getSynergyState("/test/dir");
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+            vi.useRealTimers();
+        });
+        it("should include detection timestamp", () => {
+            const beforeTime = Date.now();
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: false,
+                synergyFramework: 'none',
+            });
+            const state = getSynergyState("/test/dir");
+            const afterTime = Date.now();
+            expect(state.detectedAt.getTime()).toBeGreaterThanOrEqual(beforeTime);
+            expect(state.detectedAt.getTime()).toBeLessThanOrEqual(afterTime);
+        });
+        it("should extract agents from oh-my-opencode-slim", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer', 'oracle'],
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.availableAgents).toEqual(['explorer', 'oracle']);
+        });
+        it("should handle oh-my-opencode framework", () => {
+            vi.mocked(detectCDDConfig).mockReturnValue({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: true,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'model-1',
+            });
+            const state = getSynergyState("/test/dir");
+            expect(state.framework).toBe('oh-my-opencode');
+            // oh-my-opencode doesn't expose agent list through config, so availableAgents should be empty
+            expect(state.availableAgents).toEqual([]);
+        });
+    });
+    describe("clearSynergyCache", () => {
+        it("should clear the cache and force re-detection", () => {
+            vi.mocked(detectCDDConfig)
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode-slim',
+                slimAgents: ['explorer'],
+            })
+                .mockReturnValueOnce({
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                synergyActive: true,
+                synergyFramework: 'oh-my-opencode',
+                cddModel: 'changed',
+            });
+            const state1 = getSynergyState("/test/dir");
+            clearSynergyCache();
+            const state2 = getSynergyState("/test/dir");
+            expect(state1.framework).toBe('oh-my-opencode-slim');
+            expect(state2.framework).toBe('oh-my-opencode');
+            expect(detectCDDConfig).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/utils/synergyStatus.d.ts

@@ -0,0 +1,27 @@
+import type { SynergyFramework } from './configDetection.js';
+import type { SynergyState } from './synergyState.js';
+/**
+ * Synergy status information for display
+ */
+export interface SynergyStatus {
+    framework: SynergyFramework;
+    isActive: boolean;
+    availableAgents: string[];
+    workingDir: string;
+    detectedAt: Date;
+}
+/**
+ * Get synergy status for display
+ *
+ * @param workingDir - Current working directory
+ * @param state - Current synergy state
+ * @returns Status information
+ */
+export declare function getSynergyStatus(workingDir: string, state: SynergyState): SynergyStatus;
+/**
+ * Format synergy status for display
+ *
+ * @param status - Synergy status to format
+ * @returns Formatted status string
+ */
+export declare function formatSynergyStatus(status: SynergyStatus): string;

package/dist/utils/synergyStatus.js

@@ -0,0 +1,54 @@
+/**
+ * Get synergy status for display
+ *
+ * @param workingDir - Current working directory
+ * @param state - Current synergy state
+ * @returns Status information
+ */
+export function getSynergyStatus(workingDir, state) {
+    return {
+        framework: state.framework,
+        isActive: state.framework !== 'none',
+        availableAgents: state.availableAgents,
+        workingDir,
+        detectedAt: state.detectedAt,
+    };
+}
+/**
+ * Format synergy status for display
+ *
+ * @param status - Synergy status to format
+ * @returns Formatted status string
+ */
+export function formatSynergyStatus(status) {
+    const lines = [];
+    lines.push('='.repeat(60));
+    lines.push('Synergy Framework Status');
+    lines.push('='.repeat(60));
+    lines.push('');
+    // Framework and status
+    lines.push(`Synergy Framework: ${status.framework}`);
+    lines.push(`Status: ${status.isActive ? 'Active' : 'Inactive'}`);
+    lines.push('');
+    // Working directory
+    lines.push(`Working Directory: ${status.workingDir}`);
+    lines.push('');
+    // Detection timestamp
+    lines.push(`Detected At: ${status.detectedAt.toISOString()}`);
+    lines.push('');
+    // Available agents (only if active and has agents)
+    if (status.isActive && status.availableAgents.length > 0) {
+        lines.push(`Available Agents (${status.availableAgents.length}):`);
+        status.availableAgents.forEach(agent => {
+            lines.push(`  - ${agent}`);
+        });
+        lines.push('');
+    }
+    else if (!status.isActive) {
+        lines.push('No synergy framework detected.');
+        lines.push('Configure oh-my-opencode or oh-my-opencode-slim to enable synergy.');
+        lines.push('');
+    }
+    lines.push('='.repeat(60));
+    return lines.join('\n');
+}

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

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