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

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

package/dist/utils/synergyStatus.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+import { getSynergyStatus, formatSynergyStatus } from './synergyStatus.js';
+describe('Synergy Status', () => {
+    describe('getSynergyStatus', () => {
+        it('should return status with oh-my-opencode framework', () => {
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'oh-my-opencode',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+                availableAgents: [],
+                lastCheck: new Date('2026-01-19T14:00:00Z'),
+            });
+            expect(status.framework).toBe('oh-my-opencode');
+            expect(status.isActive).toBe(true);
+            expect(status.availableAgents).toEqual([]);
+            expect(status.detectedAt).toBeInstanceOf(Date);
+        });
+        it('should return status with oh-my-opencode-slim framework', () => {
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'oh-my-opencode-slim',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+                availableAgents: ['explorer', 'designer', 'librarian'],
+                lastCheck: new Date('2026-01-19T14:00:00Z'),
+            });
+            expect(status.framework).toBe('oh-my-opencode-slim');
+            expect(status.isActive).toBe(true);
+            expect(status.availableAgents).toHaveLength(3);
+            expect(status.availableAgents).toContain('explorer');
+        });
+        it('should return inactive status when no framework', () => {
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'none',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+                availableAgents: [],
+                lastCheck: new Date('2026-01-19T14:00:00Z'),
+            });
+            expect(status.framework).toBe('none');
+            expect(status.isActive).toBe(false);
+            expect(status.availableAgents).toEqual([]);
+        });
+        it('should include working directory in status', () => {
+            const workingDir = '/test/project';
+            const status = getSynergyStatus(workingDir, {
+                framework: 'oh-my-opencode-slim',
+                detectedAt: new Date(),
+                availableAgents: [],
+                lastCheck: new Date(),
+            });
+            expect(status.workingDir).toBe(workingDir);
+        });
+        it('should include detection timestamp', () => {
+            const detectedAt = new Date('2026-01-19T14:30:00Z');
+            const status = getSynergyStatus('/fake/dir', {
+                framework: 'oh-my-opencode',
+                detectedAt,
+                availableAgents: [],
+                lastCheck: new Date(),
+            });
+            expect(status.detectedAt).toBe(detectedAt);
+        });
+    });
+    describe('formatSynergyStatus', () => {
+        it('should format status for oh-my-opencode', () => {
+            const status = {
+                framework: 'oh-my-opencode',
+                isActive: true,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Synergy Framework: oh-my-opencode');
+            expect(formatted).toContain('Status: Active');
+            expect(formatted).toContain('Working Directory: /test/project');
+            expect(formatted).toContain('Detected At:');
+        });
+        it('should format status for oh-my-opencode-slim with agents', () => {
+            const status = {
+                framework: 'oh-my-opencode-slim',
+                isActive: true,
+                availableAgents: ['explorer', 'designer', 'librarian'],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Synergy Framework: oh-my-opencode-slim');
+            expect(formatted).toContain('Status: Active');
+            expect(formatted).toContain('Available Agents (3):');
+            expect(formatted).toContain('- explorer');
+            expect(formatted).toContain('- designer');
+            expect(formatted).toContain('- librarian');
+        });
+        it('should format inactive status', () => {
+            const status = {
+                framework: 'none',
+                isActive: false,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Synergy Framework: none');
+            expect(formatted).toContain('Status: Inactive');
+            expect(formatted).toContain('No synergy framework detected');
+        });
+        it('should handle empty agents list for active framework', () => {
+            const status = {
+                framework: 'oh-my-opencode',
+                isActive: true,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:00:00Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('oh-my-opencode');
+            expect(formatted).toContain('Active');
+            // Should not show agent list for oh-my-opencode (doesn't expose agents)
+            expect(formatted).not.toContain('Available Agents');
+        });
+        it('should format timestamps in readable format', () => {
+            const status = {
+                framework: 'oh-my-opencode-slim',
+                isActive: true,
+                availableAgents: [],
+                workingDir: '/test/project',
+                detectedAt: new Date('2026-01-19T14:30:45.123Z'),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Detected At:');
+            expect(formatted).toMatch(/\d{4}-\d{2}-\d{2}/); // Should contain date
+        });
+        it('should show agent count correctly', () => {
+            const status = {
+                framework: 'oh-my-opencode-slim',
+                isActive: true,
+                availableAgents: ['explorer'],
+                workingDir: '/test/project',
+                detectedAt: new Date(),
+            };
+            const formatted = formatSynergyStatus(status);
+            expect(formatted).toContain('Available Agents (1):');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-cdd-plugin",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "description": "Context-Driven Development (CDD) plugin for OpenCode - Transform your AI coding workflow with structured specifications, plans, and implementation tracking",
   "type": "module",
   "repository": {