opencode-conductor-cdd-plugin 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/index.js

@@ -6,6 +6,7 @@ import RevertPromptJson from "./prompts/cdd/revert.json" with { type: "json" };
 import SetupPromptJson from "./prompts/cdd/setup.json" with { type: "json" };
 import StatusPromptJson from "./prompts/cdd/status.json" with { type: "json" };
 import { detectCDDConfig } from "./utils/configDetection.js";
+import { createCommandDefaults } from "./utils/commandDefaults.js";
 const asPrompt = (prompt) => (typeof prompt === "string" ? prompt : "");
 const asDescription = (description) => typeof description === "string" ? description : undefined;
 export const MyPlugin = async ({ directory, }) => {
@@ -44,9 +45,7 @@ export const MyPlugin = async ({ directory, }) => {
     const configDetection = detectCDDConfig();
     return {
         config: async (_config) => {
-            const commandDefaults = configDetection.cddModel
-                ? { agent: "cdd", model: configDetection.cddModel }
-                : { agent: "cdd" };
+            const commandDefaults = createCommandDefaults(configDetection.cddModel);
             _config.command = {
                 ..._config.command,
                 "cdd:implement": {

package/dist/index.test.js

@@ -120,3 +120,8 @@ describe("getFileTreeSummary behavior", () => {
         expect(sorted).not.toContain("conductor-cdd/docs");
     });
 });
+describe("Plugin Model Configuration Injection", () => {
+    it("should declare model injection test suite", () => {
+        expect(true).toBe(true);
+    });
+});

package/dist/test/integration/modelConfigIntegration.test.d.ts

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

package/dist/test/integration/modelConfigIntegration.test.js

@@ -0,0 +1,222 @@
+import { describe, it, expect } from "vitest";
+import { detectCDDConfig } from "../../utils/configDetection.js";
+import { createCommandDefaults } from "../../utils/commandDefaults.js";
+/**
+ * Phase 3: Integration Testing & End-to-End Verification
+ *
+ * Tests verify that all CDD commands respect the resolved model configuration
+ * in real-world scenarios with different synergy frameworks.
+ *
+ * Test Strategy:
+ * - Uses detectCDDConfig() to resolve the actual config on the test machine
+ * - Uses createCommandDefaults() factory to ensure consistent command configuration
+ * - Validates that commands receive proper agent and model settings
+ * - Covers all CDD commands: setup, newTrack, implement, status, revert
+ */
+describe("Phase 3: Integration Testing & End-to-End Verification", () => {
+    describe("End-to-end tests for all CDD commands with model config", () => {
+        it("should apply model config to /cdd:setup command defaults", () => {
+            const configDetection = detectCDDConfig();
+            const commandDefaults = createCommandDefaults(configDetection.cddModel);
+            expect(commandDefaults.agent).toBe("cdd");
+            if (configDetection.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+            }
+        });
+        it("should apply model config to /cdd:newTrack command defaults", () => {
+            const configDetection = detectCDDConfig();
+            const commandDefaults = createCommandDefaults(configDetection.cddModel);
+            expect(commandDefaults.agent).toBe("cdd");
+            if (configDetection.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+            }
+        });
+        it("should apply model config to /cdd:implement command defaults", () => {
+            const configDetection = detectCDDConfig();
+            const commandDefaults = createCommandDefaults(configDetection.cddModel);
+            expect(commandDefaults.agent).toBe("cdd");
+            if (configDetection.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+            }
+        });
+        it("should apply model config to /cdd:status command defaults", () => {
+            const configDetection = detectCDDConfig();
+            const commandDefaults = createCommandDefaults(configDetection.cddModel);
+            expect(commandDefaults.agent).toBe("cdd");
+            if (configDetection.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+            }
+        });
+        it("should apply model config to /cdd:revert command defaults", () => {
+            const configDetection = detectCDDConfig();
+            const commandDefaults = createCommandDefaults(configDetection.cddModel);
+            expect(commandDefaults.agent).toBe("cdd");
+            if (configDetection.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+            }
+        });
+    });
+    describe("Synergy framework scenarios", () => {
+        it("should resolve model when oh-my-opencode-slim is active", () => {
+            const config = detectCDDConfig();
+            if (config.synergyFramework === "oh-my-opencode-slim") {
+                expect(config.hasCDDInSlim).toBe(true);
+                if (config.cddModel) {
+                    expect(config.cddModel).toMatch(/^[a-z0-9\-]+\/[a-z0-9\-\.]+$/i);
+                }
+            }
+        });
+        it("should resolve model when oh-my-opencode is active", () => {
+            const config = detectCDDConfig();
+            if (config.synergyFramework === "oh-my-opencode") {
+                expect(config.hasCDDInOMO).toBe(true);
+                if (config.cddModel) {
+                    expect(config.cddModel).toMatch(/^[a-z0-9\-]+\/[a-z0-9\-\.]+$/i);
+                }
+            }
+        });
+        it("should resolve model with only opencode.json config", () => {
+            const config = detectCDDConfig();
+            if (config.hasCDDInOpenCode &&
+                !config.hasCDDInSlim &&
+                !config.hasCDDInOMO) {
+                if (config.cddModel) {
+                    expect(config.cddModel).toMatch(/^[a-z0-9\-]+\/[a-z0-9\-\.]+$/i);
+                }
+            }
+        });
+        it("should handle fallback behavior when no config files exist", () => {
+            const config = detectCDDConfig();
+            if (!config.hasCDDInSlim && !config.hasCDDInOMO && !config.hasCDDInOpenCode) {
+                expect(config.synergyFramework).toBe("none");
+                expect(config.cddModel).toBeUndefined();
+            }
+        });
+    });
+    describe("Backward compatibility tests", () => {
+        it("should continue to work with projects without model configuration", () => {
+            const config = detectCDDConfig();
+            if (!config.cddModel) {
+                const commandDefaults = { agent: "cdd" };
+                expect(commandDefaults.agent).toBe("cdd");
+                expect(commandDefaults).not.toHaveProperty("model");
+            }
+        });
+        it("should handle legacy oh-my-opencode config gracefully", () => {
+            const config = detectCDDConfig();
+            expect(config).toHaveProperty("hasCDDInOMO");
+            expect(typeof config.hasCDDInOMO).toBe("boolean");
+        });
+        it("should have no regression in existing CDD functionality", () => {
+            const config = detectCDDConfig();
+            expect(config).toHaveProperty("synergyActive");
+            expect(config).toHaveProperty("synergyFramework");
+            expect(config).toHaveProperty("hasCDDInSlim");
+            expect(config).toHaveProperty("hasCDDInOMO");
+            expect(config).toHaveProperty("hasCDDInOpenCode");
+        });
+    });
+    describe("Model priority resolution chain", () => {
+        it("should enforce slim > OMO > opencode priority", () => {
+            const config = detectCDDConfig();
+            if (config.hasCDDInSlim) {
+                expect(config.synergyFramework).toBe("oh-my-opencode-slim");
+            }
+            else if (config.hasCDDInOMO) {
+                expect(config.synergyFramework).toBe("oh-my-opencode");
+            }
+            else if (config.hasCDDInOpenCode) {
+                expect(config.synergyFramework).toBe("none");
+            }
+        });
+        it("should resolve model from highest priority framework available", () => {
+            const config = detectCDDConfig();
+            if (config.hasCDDInSlim && config.cddModel) {
+                expect(config.synergyFramework).toBe("oh-my-opencode-slim");
+            }
+            else if (config.hasCDDInOMO && config.cddModel) {
+                expect(config.synergyFramework).toBe("oh-my-opencode");
+            }
+            else if (config.hasCDDInOpenCode && config.cddModel) {
+                expect(config.synergyFramework).toBe("none");
+            }
+        });
+        it("should not override model from lower priority frameworks", () => {
+            const config = detectCDDConfig();
+            if (config.hasCDDInSlim && config.cddModel) {
+                expect(config.hasCDDInOMO || config.hasCDDInOpenCode).toBeDefined();
+            }
+            else if (config.hasCDDInOMO && config.cddModel) {
+                expect(config.hasCDDInSlim).toBe(false);
+            }
+        });
+    });
+    describe("Multi-framework coexistence", () => {
+        it("should detect when multiple synergy frameworks are present", () => {
+            const config = detectCDDConfig();
+            const frameworkCount = (config.hasCDDInSlim ? 1 : 0) +
+                (config.hasCDDInOMO ? 1 : 0) +
+                (config.hasCDDInOpenCode ? 1 : 0);
+            expect(frameworkCount).toBeGreaterThanOrEqual(0);
+        });
+        it("should select slim over OMO when both are available", () => {
+            const config = detectCDDConfig();
+            if (config.hasCDDInSlim && config.hasCDDInOMO) {
+                expect(config.synergyFramework).toBe("oh-my-opencode-slim");
+            }
+        });
+        it("should select OMO over opencode.json when both are available", () => {
+            const config = detectCDDConfig();
+            if (config.hasCDDInOMO && config.hasCDDInOpenCode && !config.hasCDDInSlim) {
+                expect(config.synergyFramework).toBe("oh-my-opencode");
+            }
+        });
+    });
+    describe("Configuration consistency across all CDD operations", () => {
+        it("should maintain consistent model throughout all command lifecycle", () => {
+            const config = detectCDDConfig();
+            const model = config.cddModel;
+            const commands = ["setup", "newTrack", "implement", "status", "revert"];
+            commands.forEach((cmd) => {
+                const commandDefaults = model
+                    ? { agent: "cdd", model }
+                    : { agent: "cdd" };
+                expect(commandDefaults.agent).toBe("cdd");
+                if (model) {
+                    expect(commandDefaults.model).toBe(model);
+                }
+            });
+        });
+        it("should apply model config consistently across all synergy scenarios", () => {
+            const config = detectCDDConfig();
+            const scenarios = [
+                config.hasCDDInSlim,
+                config.hasCDDInOMO,
+                config.hasCDDInOpenCode,
+            ];
+            scenarios.forEach(() => {
+                const commandDefaults = config.cddModel
+                    ? { agent: "cdd", model: config.cddModel }
+                    : { agent: "cdd" };
+                expect(commandDefaults).toBeDefined();
+            });
+        });
+    });
+    describe("Edge cases and error handling", () => {
+        it("should handle missing config directory gracefully", () => {
+            const config = detectCDDConfig();
+            expect(config).toBeDefined();
+            expect(config.synergyFramework).toBeDefined();
+        });
+        it("should handle malformed JSON configs gracefully", () => {
+            const config = detectCDDConfig();
+            expect(config).toBeDefined();
+            expect(() => JSON.stringify(config)).not.toThrow();
+        });
+        it("should provide sensible defaults when config detection fails", () => {
+            const config = detectCDDConfig();
+            expect(config.synergyFramework).toBeDefined();
+            expect(typeof config.synergyActive).toBe("boolean");
+        });
+    });
+});

package/dist/test/integration/omo3-delegation.test.js

@@ -6,6 +6,7 @@ vi.mock('../../utils/configDetection.js', () => ({
         synergyActive: true,
     })),
     getAvailableOMOAgents: vi.fn(() => ['sisyphus', 'explore', 'oracle', 'librarian']),
+    getAgentModel: vi.fn((agentName) => `anthropic/claude-3-5-sonnet`),
 }));
 vi.mock('../../utils/synergyDelegation.js', () => ({
     resolveAgentForDelegation: vi.fn((agent) => ({
@@ -103,6 +104,7 @@ describe('OMO 3.0 Delegation Integration Tests', () => {
                 path: { id: 'session-123' },
                 body: {
                     agent: 'sisyphus',
+                    model: 'anthropic/claude-3-5-sonnet',
                     tools: {
                         cdd_delegate: false,
                         cdd_bg_task: false,

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

@@ -74,7 +74,11 @@ describe('Rebrand Integration Tests', () => {
         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"');
+            expect(indexContent).toContain('createCommandDefaults');
+            expect(indexContent).toContain('...commandDefaults');
+            const commandDefaultsPath = path.join(process.cwd(), 'src/utils/commandDefaults.ts');
+            const commandDefaultsContent = fs.readFileSync(commandDefaultsPath, 'utf-8');
+            expect(commandDefaultsContent).toContain('agent: "cdd"');
         });
     });
     describe('Utility Files References', () => {

package/dist/tools/delegate.js

@@ -1,5 +1,5 @@
 import { tool } from "@opencode-ai/plugin/tool";
-import { detectCDDConfig, getAvailableOMOAgents } from "../utils/configDetection.js";
+import { detectCDDConfig, getAvailableOMOAgents, getAgentModel } from "../utils/configDetection.js";
 import { resolveAgentForDelegation } from "../utils/synergyDelegation.js";
 /**
  * Creates a delegation tool that follows the OMO 3.0 agent invocation pattern.
@@ -41,10 +41,12 @@ export function createDelegationTool(ctx) {
                     return `Error creating session: ${createResult.error}`;
                 }
                 const sessionID = createResult.data.id;
+                const agentModel = getAgentModel(resolvedAgentName);
                 await ctx.client.session.prompt({
                     path: { id: sessionID },
                     body: {
                         agent: resolvedAgentName,
+                        model: agentModel,
                         tools: {
                             cdd_delegate: false,
                             cdd_bg_task: false,

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

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

package/dist/utils/agentInitialization.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as configDetection from "./configDetection.js";
+/**
+ * Phase 2: Agent Initialization with Resolved Model
+ *
+ * Tests verify that the resolved model configuration is properly
+ * passed to @cdd agent initialization and delegated agents.
+ */
+describe("Phase 2: Agent Initialization with Resolved Model", () => {
+    let originalEnv;
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe("@cdd agent receives correct model from resolved config", () => {
+        it("should pass resolved model to agent initialization when oh-my-opencode-slim has model", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Simulate what the plugin does with the config
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert
+            if (configDetectionResult.cddModel) {
+                expect(commandDefaults).toHaveProperty("model");
+                expect(commandDefaults).toMatchObject({
+                    agent: "cdd",
+                    model: configDetectionResult.cddModel,
+                });
+            }
+        });
+        it("should use fallback defaults when no model is configured", () => {
+            // Arrange
+            const configDetectionResult = {
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                hasCDDInSlim: false,
+                synergyActive: false,
+                cddModel: undefined,
+                synergyFramework: "none",
+            };
+            // Act - simulate plugin behavior
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert
+            expect(commandDefaults).toEqual({
+                agent: "cdd",
+            });
+            expect(commandDefaults).not.toHaveProperty("model");
+        });
+        it("should maintain model throughout all CDD command defaults", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Simulate all CDD commands
+            const commands = {
+                "cdd:setup": { ...commandDefaults },
+                "cdd:newTrack": { ...commandDefaults },
+                "cdd:implement": { ...commandDefaults },
+                "cdd:status": { ...commandDefaults },
+                "cdd:revert": { ...commandDefaults },
+            };
+            // Assert: all commands should have consistent model config
+            Object.entries(commands).forEach(([name, config]) => {
+                expect(config).toMatchObject({
+                    agent: "cdd",
+                });
+                if (configDetectionResult.cddModel) {
+                    expect(config).toHaveProperty("model", configDetectionResult.cddModel);
+                }
+            });
+        });
+    });
+    describe("Agent initialization handles invalid model config gracefully", () => {
+        it("should handle undefined model gracefully", () => {
+            // Arrange
+            const configDetectionResult = {
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                hasCDDInSlim: false,
+                synergyActive: false,
+                cddModel: undefined,
+                synergyFramework: "none",
+            };
+            // Act
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert
+            expect(commandDefaults).toBeDefined();
+            expect(commandDefaults.agent).toBe("cdd");
+            expect(() => {
+                if (!commandDefaults.agent)
+                    throw new Error("Agent not set");
+            }).not.toThrow();
+        });
+        it("should handle empty model string gracefully", () => {
+            // Arrange
+            const configDetectionResult = {
+                hasCDDInOpenCode: false,
+                hasCDDInOMO: false,
+                hasCDDInSlim: false,
+                synergyActive: false,
+                cddModel: "",
+                synergyFramework: "none",
+            };
+            // Act
+            const commandDefaults = configDetectionResult.cddModel
+                ? { agent: "cdd", model: configDetectionResult.cddModel }
+                : { agent: "cdd" };
+            // Assert - empty string is falsy, should fall back
+            expect(commandDefaults).not.toHaveProperty("model");
+        });
+        it("should validate model string format before passing to agent", () => {
+            // Arrange
+            const validModel = "anthropic/claude-3-5-sonnet";
+            const configDefaults = {
+                agent: "cdd",
+                model: validModel,
+            };
+            // Assert - model should be a valid string identifier
+            if (configDefaults.model) {
+                expect(typeof configDefaults.model).toBe("string");
+                expect(configDefaults.model).toMatch(/^[a-z0-9\-]+\/[a-z0-9\-]+$/i);
+            }
+        });
+    });
+    describe("Delegated agent model propagation", () => {
+        it("should pass model to @explorer agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "explorer", model: parentModel }
+                : { agent: "explorer" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "explorer",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should pass model to @designer agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "designer", model: parentModel }
+                : { agent: "designer" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "designer",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should pass model to @librarian agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "librarian", model: parentModel }
+                : { agent: "librarian" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "librarian",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should pass model to @oracle agent when configured", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate delegation
+            const delegationConfig = parentModel
+                ? { agent: "oracle", model: parentModel }
+                : { agent: "oracle" };
+            // Assert
+            expect(delegationConfig).toMatchObject({
+                agent: "oracle",
+            });
+            if (parentModel) {
+                expect(delegationConfig).toHaveProperty("model", parentModel);
+            }
+        });
+        it("should maintain consistent model across delegation chain", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            const parentModel = configDetectionResult.cddModel;
+            // Act - simulate full delegation chain
+            const cddConfig = parentModel
+                ? { agent: "cdd", model: parentModel }
+                : { agent: "cdd" };
+            const delegatedAgents = ["explorer", "designer", "librarian", "oracle"];
+            const delegationConfigs = delegatedAgents.map((agent) => parentModel
+                ? { agent: agent, model: parentModel }
+                : { agent: agent });
+            // Assert - all delegates should have same model as parent
+            delegationConfigs.forEach((delegateConfig) => {
+                if (parentModel) {
+                    expect(delegateConfig).toHaveProperty("model", parentModel);
+                }
+                if (cddConfig && "model" in cddConfig) {
+                    expect(delegateConfig).toHaveProperty("model", cddConfig.model);
+                }
+            });
+        });
+    });
+    describe("Synergy framework agent model propagation", () => {
+        it("should detect and use slim framework model when active", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Act
+            const hasSlimModel = configDetectionResult.hasCDDInSlim && configDetectionResult.cddModel;
+            // Assert
+            if (hasSlimModel) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode-slim");
+                expect(configDetectionResult.cddModel).toBeDefined();
+            }
+        });
+        it("should detect and use OMO framework model when slim not active", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Act
+            const hasOmoModel = configDetectionResult.hasCDDInOMO &&
+                !configDetectionResult.hasCDDInSlim &&
+                configDetectionResult.cddModel;
+            // Assert
+            if (hasOmoModel) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode");
+                expect(configDetectionResult.cddModel).toBeDefined();
+            }
+        });
+        it("should respect synergy priority when resolving model", () => {
+            // Arrange
+            const configDetectionResult = configDetection.detectCDDConfig();
+            // Act & Assert - verify priority chain
+            if (configDetectionResult.hasCDDInSlim) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode-slim");
+            }
+            else if (configDetectionResult.hasCDDInOMO) {
+                expect(configDetectionResult.synergyFramework).toBe("oh-my-opencode");
+            }
+            else {
+                expect(configDetectionResult.synergyFramework).toBe("none");
+            }
+        });
+    });
+});

package/dist/utils/commandDefaults.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Factory for creating OpenCode command defaults with CDD agent configuration.
+ * Handles model resolution and provides type-safe command default objects.
+ */
+export interface CommandDefaults {
+    agent: "cdd";
+    model?: string;
+}
+/**
+ * Creates command defaults for CDD commands with optional model configuration.
+ *
+ * @param cddModel - The resolved model string from config detection (undefined = use OpenCode default)
+ * @returns Command defaults object with agent and optional model
+ *
+ * @example
+ * // With model configured
+ * const defaults = createCommandDefaults("anthropic/claude-3-5-sonnet");
+ * // { agent: "cdd", model: "anthropic/claude-3-5-sonnet" }
+ *
+ * @example
+ * // Without model (fallback to OpenCode default)
+ * const defaults = createCommandDefaults(undefined);
+ * // { agent: "cdd" }
+ */
+export declare function createCommandDefaults(cddModel: string | undefined): CommandDefaults;
+/**
+ * Validates that a model string is properly formatted.
+ *
+ * @param model - Model string to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * validateModelString("anthropic/claude-3-5-sonnet") // true
+ * validateModelString("google/gemini-flash-1.5") // true
+ * validateModelString("") // false
+ * validateModelString("  ") // false
+ */
+export declare function validateModelString(model: string | undefined): boolean;

package/dist/utils/commandDefaults.js

@@ -0,0 +1,54 @@
+/**
+ * Factory for creating OpenCode command defaults with CDD agent configuration.
+ * Handles model resolution and provides type-safe command default objects.
+ */
+/**
+ * Creates command defaults for CDD commands with optional model configuration.
+ *
+ * @param cddModel - The resolved model string from config detection (undefined = use OpenCode default)
+ * @returns Command defaults object with agent and optional model
+ *
+ * @example
+ * // With model configured
+ * const defaults = createCommandDefaults("anthropic/claude-3-5-sonnet");
+ * // { agent: "cdd", model: "anthropic/claude-3-5-sonnet" }
+ *
+ * @example
+ * // Without model (fallback to OpenCode default)
+ * const defaults = createCommandDefaults(undefined);
+ * // { agent: "cdd" }
+ */
+export function createCommandDefaults(cddModel) {
+    if (typeof cddModel === "string" && cddModel.trim() === "") {
+        console.warn("[CDD] Invalid model configuration detected. Model must be a non-empty string. Falling back to OpenCode default.");
+        return { agent: "cdd" };
+    }
+    if (!cddModel) {
+        return { agent: "cdd" };
+    }
+    return {
+        agent: "cdd",
+        model: cddModel,
+    };
+}
+/**
+ * Validates that a model string is properly formatted.
+ *
+ * @param model - Model string to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * validateModelString("anthropic/claude-3-5-sonnet") // true
+ * validateModelString("google/gemini-flash-1.5") // true
+ * validateModelString("") // false
+ * validateModelString("  ") // false
+ */
+export function validateModelString(model) {
+    if (!model)
+        return false;
+    if (typeof model !== "string")
+        return false;
+    if (model.trim() === "")
+        return false;
+    return true;
+}

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

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

package/dist/utils/commandDefaults.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createCommandDefaults, validateModelString } from './commandDefaults.js';
+describe('commandDefaults', () => {
+    describe('createCommandDefaults', () => {
+        it('should return defaults with model when valid model provided', () => {
+            const result = createCommandDefaults('anthropic/claude-3-5-sonnet');
+            expect(result).toEqual({
+                agent: 'cdd',
+                model: 'anthropic/claude-3-5-sonnet',
+            });
+        });
+        it('should return defaults without model when undefined provided', () => {
+            const result = createCommandDefaults(undefined);
+            expect(result).toEqual({
+                agent: 'cdd',
+            });
+        });
+        it('should return defaults without model when empty string provided', () => {
+            const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const result = createCommandDefaults('');
+            expect(result).toEqual({
+                agent: 'cdd',
+            });
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('[CDD] Invalid model configuration detected'));
+            consoleWarnSpy.mockRestore();
+        });
+        it('should return defaults without model when whitespace-only string provided', () => {
+            const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const result = createCommandDefaults('   ');
+            expect(result).toEqual({
+                agent: 'cdd',
+            });
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('[CDD] Invalid model configuration detected'));
+            consoleWarnSpy.mockRestore();
+        });
+        it('should handle various valid model formats', () => {
+            const testCases = [
+                'anthropic/claude-3-5-sonnet',
+                'google/gemini-flash-1.5',
+                'openai/gpt-4',
+                'anthropic/claude-3-opus-20240229',
+            ];
+            testCases.forEach(model => {
+                const result = createCommandDefaults(model);
+                expect(result.model).toBe(model);
+                expect(result.agent).toBe('cdd');
+            });
+        });
+        it('should return object with correct TypeScript type', () => {
+            const result = createCommandDefaults('anthropic/claude-3-5-sonnet');
+            expect(result.agent).toBe('cdd');
+            expect(typeof result.model).toBe('string');
+        });
+    });
+    describe('validateModelString', () => {
+        it('should return true for valid model strings', () => {
+            expect(validateModelString('anthropic/claude-3-5-sonnet')).toBe(true);
+            expect(validateModelString('google/gemini-flash-1.5')).toBe(true);
+            expect(validateModelString('openai/gpt-4')).toBe(true);
+        });
+        it('should return false for undefined', () => {
+            expect(validateModelString(undefined)).toBe(false);
+        });
+        it('should return false for empty string', () => {
+            expect(validateModelString('')).toBe(false);
+        });
+        it('should return false for whitespace-only string', () => {
+            expect(validateModelString('   ')).toBe(false);
+            expect(validateModelString('\t\n')).toBe(false);
+        });
+        it('should return false for non-string types', () => {
+            expect(validateModelString(null)).toBe(false);
+            expect(validateModelString(123)).toBe(false);
+            expect(validateModelString({})).toBe(false);
+            expect(validateModelString([])).toBe(false);
+        });
+    });
+    describe('integration with index.ts', () => {
+        it('should create command defaults compatible with OpenCode command config', () => {
+            const defaults = createCommandDefaults('anthropic/claude-3-5-sonnet');
+            const commandConfig = {
+                ...defaults,
+                template: 'Some prompt template',
+                description: 'Command description',
+            };
+            expect(commandConfig.agent).toBe('cdd');
+            expect(commandConfig.model).toBe('anthropic/claude-3-5-sonnet');
+            expect(commandConfig.template).toBe('Some prompt template');
+        });
+        it('should work with spread operator for command defaults', () => {
+            const defaults = createCommandDefaults('google/gemini-flash-1.5');
+            const command = {
+                ...defaults,
+                someOtherProperty: 'value',
+            };
+            expect(command.agent).toBe('cdd');
+            expect(command.model).toBe('google/gemini-flash-1.5');
+            expect(command.someOtherProperty).toBe('value');
+        });
+    });
+});

package/dist/utils/configDetection.d.ts

@@ -23,3 +23,16 @@ export interface ConfigDetectionResult {
 }
 export declare function detectCDDConfig(): ConfigDetectionResult;
 export declare function getAvailableOMOAgents(): string[];
+/**
+ * Get the configured model for a specific agent from synergy framework config.
+ *
+ * Priority Order:
+ * 1. oh-my-opencode-slim.json → agents.<agentName>.model
+ * 2. oh-my-opencode.json → agents.<agentName>.model
+ * 3. opencode.json → agent.<agentName>.model
+ * 4. undefined (no model configured)
+ *
+ * @param agentName - Name of the agent (e.g., 'explorer', 'designer', 'cdd')
+ * @returns Model string if configured, undefined otherwise
+ */
+export declare function getAgentModel(agentName: string): string | undefined;

package/dist/utils/configDetection.js

@@ -2,6 +2,38 @@ import { join } from "path";
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 export function detectCDDConfig() {
+    /**
+     * Detects and resolves CDD model configuration from synergy framework config files.
+     *
+     * Priority Order (highest to lowest):
+     * 1. oh-my-opencode-slim.json → agents.cdd.model
+     * 2. oh-my-opencode.json → agents.cdd.model
+     * 3. opencode.json → agent.cdd.model
+     * 4. No model (undefined)
+     *
+     * Synergy Framework Selection:
+     * - If oh-my-opencode-slim is present with cdd agent → use slim (highest priority)
+     * - Else if oh-my-opencode is present with cdd agent → use OMO
+     * - Else → no synergy (manual mode)
+     *
+     * Important: Synergy only activates if the selected framework explicitly
+     * has a "cdd" agent configured. File presence alone is insufficient.
+     *
+     * Example Config (oh-my-opencode-slim.json):
+     * {
+     *   "agents": {
+     *     "cdd": {
+     *       "model": "anthropic/claude-3-5-sonnet"
+     *     },
+     *     "explorer": {
+     *       "model": "google/gemini-flash-1.5"
+     *     }
+     *   },
+     *   "disabled_agents": ["librarian"]
+     * }
+     *
+     * @returns ConfigDetectionResult with framework info and model string
+     */
     const opencodeConfigDir = join(homedir(), ".config", "opencode");
     const opencodeJsonPath = join(opencodeConfigDir, "opencode.json");
     const omoJsonPath = join(opencodeConfigDir, "oh-my-opencode.json");
@@ -99,3 +131,58 @@ export function getAvailableOMOAgents() {
     }
     return [];
 }
+/**
+ * Get the configured model for a specific agent from synergy framework config.
+ *
+ * Priority Order:
+ * 1. oh-my-opencode-slim.json → agents.<agentName>.model
+ * 2. oh-my-opencode.json → agents.<agentName>.model
+ * 3. opencode.json → agent.<agentName>.model
+ * 4. undefined (no model configured)
+ *
+ * @param agentName - Name of the agent (e.g., 'explorer', 'designer', 'cdd')
+ * @returns Model string if configured, undefined otherwise
+ */
+export function getAgentModel(agentName) {
+    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");
+    // Check oh-my-opencode-slim.json first (highest priority)
+    if (existsSync(slimJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(slimJsonPath, "utf-8"));
+            if (config?.agents?.[agentName]?.model) {
+                return config.agents[agentName].model;
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check oh-my-opencode.json (second priority)
+    if (existsSync(omoJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
+            if (config?.agents?.[agentName]?.model) {
+                return config.agents[agentName].model;
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    // Check opencode.json (fallback)
+    if (existsSync(opencodeJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
+            if (config?.agent?.[agentName]?.model) {
+                return config.agent[agentName].model;
+            }
+        }
+        catch (e) {
+            // Silently fail on parse errors
+        }
+    }
+    return undefined;
+}

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

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

package/dist/utils/modelConfigInjection.test.js

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+vi.mock("fs");
+vi.mock("os");
+describe("Model Configuration Injection in Plugin Initialization", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.resetModules();
+    });
+    it("should inject model into command defaults when oh-my-opencode.json has model", async () => {
+        const { existsSync: mockExistsSync, readFileSync: mockReadFileSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockImplementation((path) => {
+            return String(path).includes("oh-my-opencode.json");
+        });
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        vi.mocked(mockReadFileSync).mockImplementation((path) => {
+            if (String(path).includes("oh-my-opencode.json")) {
+                return JSON.stringify({
+                    agents: {
+                        cdd: { model: "anthropic/claude-3-5-sonnet" },
+                    },
+                });
+            }
+            return "";
+        });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        const setupCmd = config.command["cdd:setup"];
+        expect(setupCmd.model).toBe("anthropic/claude-3-5-sonnet");
+        expect(setupCmd.agent).toBe("cdd");
+    });
+    it("should inject model into ALL CDD commands", async () => {
+        const { existsSync: mockExistsSync, readFileSync: mockReadFileSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockImplementation((path) => {
+            const pathStr = String(path);
+            return pathStr.includes("opencode.json") && !pathStr.includes("oh-my");
+        });
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        vi.mocked(mockReadFileSync).mockImplementation((path) => {
+            const pathStr = String(path);
+            if (pathStr.includes("opencode.json") && !pathStr.includes("oh-my")) {
+                return JSON.stringify({
+                    agent: {
+                        cdd: { model: "anthropic/claude-3-5-haiku" },
+                    },
+                });
+            }
+            return "";
+        });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        const cmdConfig = config.command;
+        ["cdd:setup", "cdd:newTrack", "cdd:implement", "cdd:status", "cdd:revert"].forEach((cmd) => {
+            expect(cmdConfig[cmd].model).toBe("anthropic/claude-3-5-haiku");
+            expect(cmdConfig[cmd].agent).toBe("cdd");
+        });
+    });
+    it("should prioritize oh-my-opencode-slim > oh-my-opencode > opencode.json", async () => {
+        const { existsSync: mockExistsSync, readFileSync: mockReadFileSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockReturnValue(true);
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        vi.mocked(mockReadFileSync).mockImplementation((path) => {
+            const pathStr = String(path);
+            if (pathStr.includes("oh-my-opencode-slim.json")) {
+                return JSON.stringify({ agents: { cdd: { model: "google/gemini-2-flash" } } });
+            }
+            if (pathStr.includes("oh-my-opencode.json")) {
+                return JSON.stringify({ agents: { cdd: { model: "anthropic/claude-3-5-sonnet" } } });
+            }
+            if (pathStr.includes("opencode.json")) {
+                return JSON.stringify({ agent: { cdd: { model: "anthropic/claude-3-5-haiku" } } });
+            }
+            return "";
+        });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        expect(config.command["cdd:setup"].model).toBe("google/gemini-2-flash");
+    });
+    it("should handle missing model config gracefully", async () => {
+        const { existsSync: mockExistsSync, readdirSync: mockReaddirSync, statSync: mockStatSync } = await import("fs");
+        const { homedir: mockHomedir } = await import("os");
+        vi.mocked(mockHomedir).mockReturnValue("/home/testuser");
+        vi.mocked(mockExistsSync).mockReturnValue(false);
+        vi.mocked(mockReaddirSync).mockReturnValue([]);
+        vi.mocked(mockStatSync).mockReturnValue({ isDirectory: () => false });
+        const { MyPlugin } = await import("../index.js");
+        const plugin = await MyPlugin({
+            directory: "/test/project",
+            client: {},
+            project: {},
+            worktree: {},
+            serverUrl: new URL("http://localhost"),
+            $: {},
+        });
+        const config = { command: {} };
+        await plugin.config?.(config);
+        expect(config.command["cdd:setup"].model).toBeUndefined();
+        expect(config.command["cdd:setup"].agent).toBe("cdd");
+    });
+});

package/package.json

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