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

package/dist/tools/delegate.js

@@ -1,45 +1,94 @@
 import { tool } from "@opencode-ai/plugin/tool";
+import { detectCDDConfig, getAvailableOMOAgents } from "../utils/configDetection.js";
+import { resolveAgentForDelegation } from "../utils/synergyDelegation.js";
+/**
+ * Creates a delegation tool that follows the OMO 3.0 agent invocation pattern.
+ *
+ * This implementation uses the synchronous prompt() API pattern:
+ * 1. Create a child session with parentID
+ * 2. Send prompt with agent specification and tool restrictions
+ * 3. Poll for completion by checking when session becomes idle
+ * 4. Extract and return the final response
+ *
+ * Based on OMO 3.0 call_omo_agent implementation:
+ * https://github.com/code-yeongyu/oh-my-opencode/blob/main/src/tools/call-omo-agent/tools.ts
+ */
 export function createDelegationTool(ctx) {
     return tool({
-        description: "Delegate a specific task to a specialized subagent",
+        description: "Delegate a specific task to a specialized subagent using OMO 3.0 invocation pattern",
         args: {
             task_description: tool.schema.string().describe("Summary of the work"),
-            subagent_type: tool.schema.string().describe("The name of the agent to call"),
+            subagent_type: tool.schema.string().describe("The name of the agent to call (e.g., explore, oracle, librarian)"),
             prompt: tool.schema.string().describe("Detailed instructions for the subagent"),
         },
         async execute(args, toolContext) {
-            // 1. Create a sub-session linked to the current one
-            const createResult = await ctx.client.session.create({
-                body: {
-                    parentID: toolContext.sessionID,
-                    title: `${args.task_description} (Delegated to ${args.subagent_type})`,
-                },
-            });
-            if (createResult.error)
-                return `Error: ${createResult.error}`;
-            const sessionID = createResult.data.id;
-            // 2. Send the prompt to the subagent
-            await ctx.client.session.prompt({
-                path: { id: sessionID },
-                body: {
-                    agent: args.subagent_type,
-                    tools: {
-                        "cdd_delegate": false,
+            try {
+                const config = detectCDDConfig();
+                const availableAgents = getAvailableOMOAgents();
+                const delegationResult = resolveAgentForDelegation(args.subagent_type, config.synergyFramework, availableAgents);
+                if (!delegationResult.success) {
+                    return `Cannot delegate to '${args.subagent_type}': ${delegationResult.reason}\n\nFalling back to @cdd for manual implementation.`;
+                }
+                const resolvedAgentName = delegationResult.resolvedAgent;
+                // 1. Create a sub-session linked to the current one
+                const createResult = await ctx.client.session.create({
+                    body: {
+                        parentID: toolContext.sessionID,
+                        title: `${args.task_description} (@${resolvedAgentName})`,
                     },
-                    parts: [{ type: "text", text: args.prompt }],
-                },
-            });
-            // 3. Fetch and return the assistant's response
-            const messagesResult = await ctx.client.session.messages({
-                path: { id: sessionID },
-            });
-            const lastMessage = messagesResult.data
-                ?.filter((m) => m.info.role === "assistant")
-                .pop();
-            const responseText = lastMessage?.parts
-                .filter((p) => p.type === "text")
-                .map((p) => p.text).join("\n") || "No response.";
-            return `${responseText}\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`;
+                });
+                if (createResult.error) {
+                    return `Error creating session: ${createResult.error}`;
+                }
+                const sessionID = createResult.data.id;
+                await ctx.client.session.prompt({
+                    path: { id: sessionID },
+                    body: {
+                        agent: resolvedAgentName,
+                        tools: {
+                            cdd_delegate: false,
+                            cdd_bg_task: false,
+                        },
+                        parts: [{ type: "text", text: args.prompt }],
+                    },
+                });
+                const MAX_POLL_TIME_MS = 5 * 60 * 1000;
+                const POLL_INTERVAL_MS = 2000;
+                const startTime = Date.now();
+                while (Date.now() - startTime < MAX_POLL_TIME_MS) {
+                    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+                    try {
+                        const statusResult = await ctx.client.session.status();
+                        const sessionStatus = statusResult.data?.[sessionID];
+                        if (sessionStatus?.type === "idle") {
+                            break;
+                        }
+                    }
+                    catch (statusError) {
+                        console.warn("[CDD Delegate] Status check failed:", statusError);
+                    }
+                }
+                const messagesResult = await ctx.client.session.messages({
+                    path: { id: sessionID },
+                });
+                if (messagesResult.error) {
+                    return `Error fetching messages: ${messagesResult.error}`;
+                }
+                const assistantMessages = (messagesResult.data || [])
+                    .filter((m) => m.info.role === "assistant");
+                if (assistantMessages.length === 0) {
+                    return `No response from agent ${resolvedAgentName}`;
+                }
+                const lastMessage = assistantMessages[assistantMessages.length - 1];
+                const responseText = lastMessage.parts
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text)
+                    .join("\n") || "No response.";
+                return `${responseText}\n\n<task_metadata>\nsession_id: ${sessionID}\nagent: ${resolvedAgentName}\nrequested: ${args.subagent_type}\n</task_metadata>`;
+            }
+            catch (error) {
+                return `Error during delegation: ${error.message || String(error)}`;
+            }
         },
     });
 }

package/dist/utils/configDetection.d.ts

@@ -1,10 +1,25 @@
 export type SynergyFramework = 'none' | 'oh-my-opencode' | 'oh-my-opencode-slim';
+/**
+ * Result of CDD configuration detection across multiple config files.
+ * Checks ~/.config/opencode/{opencode.json, oh-my-opencode.json, oh-my-opencode-slim.json}
+ */
 export interface ConfigDetectionResult {
+    /** Whether CDD agent is configured in opencode.json */
     hasCDDInOpenCode: boolean;
+    /** Whether CDD agent is configured in oh-my-opencode.json */
     hasCDDInOMO: boolean;
+    /** Whether CDD agent is configured in oh-my-opencode-slim.json */
+    hasCDDInSlim: boolean;
+    /** Whether synergy mode should be activated (true if any synergy framework detected) */
     synergyActive: boolean;
+    /** The CDD model string extracted from configs (priority: slim > OMO > opencode) */
     cddModel?: string;
+    /** Which synergy framework to use (priority: slim > OMO > none) */
     synergyFramework: SynergyFramework;
+    /** Available agents from slim config (filtered by disabled_agents) */
     slimAgents?: string[];
+    /** Available agents from OMO config (filtered by disabled_agents) */
+    omoAgents?: string[];
 }
 export declare function detectCDDConfig(): ConfigDetectionResult;
+export declare function getAvailableOMOAgents(): string[];

package/dist/utils/configDetection.js

@@ -8,17 +8,27 @@ export function detectCDDConfig() {
     const slimJsonPath = join(opencodeConfigDir, "oh-my-opencode-slim.json");
     let hasCDDInOpenCode = false;
     let hasCDDInOMO = false;
+    let hasCDDInSlim = false;
     let cddModel;
     let synergyFramework = 'none';
     let slimAgents;
+    let omoAgents;
     // Check oh-my-opencode-slim.json first (highest priority for synergy)
     if (existsSync(slimJsonPath)) {
         try {
             const config = JSON.parse(readFileSync(slimJsonPath, "utf-8"));
             // Check if config is not empty and has actual content
             if (config && Object.keys(config).length > 0) {
-                synergyFramework = 'oh-my-opencode-slim';
-                // Extract available agents (filter out disabled ones)
+                // Check for CDD agent in slim config (strict detection)
+                if (config.agents && config.agents.cdd) {
+                    hasCDDInSlim = true;
+                    synergyFramework = 'oh-my-opencode-slim';
+                    // Extract model from slim config (priority over OMO and opencode.json)
+                    if (config.agents.cdd.model) {
+                        cddModel = config.agents.cdd.model;
+                    }
+                }
+                // Extract available agents (filter out disabled ones) regardless of CDD presence
                 const coreAgents = ['explorer', 'librarian', 'oracle', 'designer'];
                 const disabledAgents = new Set(config.disabled_agents ?? []);
                 slimAgents = coreAgents.filter(agent => !disabledAgents.has(agent));
@@ -28,30 +38,37 @@ export function detectCDDConfig() {
             // Silently fail on parse errors
         }
     }
-    // Check oh-my-opencode.json (only if slim is not active)
-    if (synergyFramework === 'none' && existsSync(omoJsonPath)) {
+    // Check oh-my-opencode.json (only if slim doesn't have CDD)
+    if (existsSync(omoJsonPath)) {
         try {
             const config = JSON.parse(readFileSync(omoJsonPath, "utf-8"));
             if (config.agents && config.agents.cdd) {
                 hasCDDInOMO = true;
-                synergyFramework = 'oh-my-opencode';
-                // Extract model from oh-my-opencode.json
-                if (config.agents.cdd.model) {
+                // Only activate OMO synergy if slim doesn't have CDD (slim takes priority)
+                if (synergyFramework === 'none') {
+                    synergyFramework = 'oh-my-opencode';
+                }
+                // Extract model from oh-my-opencode.json (only if not already set by slim)
+                if (!cddModel && config.agents.cdd.model) {
                     cddModel = config.agents.cdd.model;
                 }
+                // Extract available OMO agents (filter out disabled ones)
+                const allConfiguredAgents = Object.keys(config.agents || {});
+                const disabledAgents = new Set(config.disabled_agents ?? []);
+                omoAgents = allConfiguredAgents.filter(agent => !disabledAgents.has(agent));
             }
         }
         catch (e) {
             // Silently fail on parse errors
         }
     }
-    // Check opencode.json (fallback if model not found in OMO)
+    // Check opencode.json (fallback if model not found in slim or OMO)
     if (existsSync(opencodeJsonPath)) {
         try {
             const config = JSON.parse(readFileSync(opencodeJsonPath, "utf-8"));
             if (config.agent && config.agent.cdd) {
                 hasCDDInOpenCode = true;
-                // Only use this model if we didn't find one in oh-my-opencode.json
+                // Only use this model if we didn't find one in slim or oh-my-opencode.json
                 if (!cddModel && config.agent.cdd.model) {
                     cddModel = config.agent.cdd.model;
                 }
@@ -64,9 +81,21 @@ export function detectCDDConfig() {
     return {
         hasCDDInOpenCode,
         hasCDDInOMO,
+        hasCDDInSlim,
         synergyActive: synergyFramework !== 'none',
         cddModel,
         synergyFramework,
         slimAgents,
+        omoAgents,
     };
 }
+export function getAvailableOMOAgents() {
+    const config = detectCDDConfig();
+    if (config.synergyFramework === 'oh-my-opencode-slim' && config.slimAgents) {
+        return config.slimAgents;
+    }
+    if (config.synergyFramework === 'oh-my-opencode' && config.omoAgents) {
+        return config.omoAgents;
+    }
+    return [];
+}

package/dist/utils/configDetection.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { existsSync, readFileSync } from "fs";
-import { detectCDDConfig } from "./configDetection.js";
+import { detectCDDConfig, getAvailableOMOAgents } from "./configDetection.js";
 vi.mock("fs", () => ({
     existsSync: vi.fn(),
     readFileSync: vi.fn(),
@@ -119,7 +119,7 @@ describe("configDetection", () => {
     });
     // 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", () => {
+        it("should NOT detect synergy when slim config has no cdd agent", () => {
             vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
             vi.mocked(readFileSync).mockImplementation((path) => {
                 if (path === slimJsonPath) {
@@ -130,11 +130,11 @@ describe("configDetection", () => {
                 return "";
             });
             const result = detectCDDConfig();
-            expect(result.synergyActive).toBe(true);
-            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyActive).toBe(false);
+            expect(result.synergyFramework).toBe('none');
             expect(result.slimAgents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
         });
-        it("should prioritize oh-my-opencode-slim over oh-my-opencode when both present", () => {
+        it("should prioritize oh-my-opencode over slim when slim has no cdd agent", () => {
             vi.mocked(existsSync).mockReturnValue(true);
             vi.mocked(readFileSync).mockImplementation((path) => {
                 if (path === slimJsonPath) {
@@ -146,10 +146,11 @@ describe("configDetection", () => {
                 return "";
             });
             const result = detectCDDConfig();
-            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyFramework).toBe('oh-my-opencode');
             expect(result.synergyActive).toBe(true);
+            expect(result.cddModel).toBe('model-from-omo');
         });
-        it("should filter out disabled agents from slim config", () => {
+        it("should filter out disabled agents from slim config (but require cdd for synergy)", () => {
             vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
             vi.mocked(readFileSync).mockImplementation((path) => {
                 if (path === slimJsonPath) {
@@ -160,7 +161,8 @@ describe("configDetection", () => {
                 return "";
             });
             const result = detectCDDConfig();
-            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
             expect(result.slimAgents).toEqual(['explorer', 'librarian']);
         });
         it("should handle empty oh-my-opencode-slim config", () => {
@@ -203,4 +205,314 @@ describe("configDetection", () => {
             expect(result.synergyActive).toBe(false);
         });
     });
+    // New tests for CDD agent detection in oh-my-opencode-slim
+    describe("CDD agent detection in oh-my-opencode-slim", () => {
+        it("should detect cdd agent in slim config and activate synergy", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyActive).toBe(true);
+            expect(result.cddModel).toBe("anthropic/claude-3-5-sonnet");
+        });
+        it("should not activate synergy when slim config exists but no cdd agent", () => {
+            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.hasCDDInSlim).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should not activate synergy when slim config has empty agents object", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({ agents: {} });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should handle malformed slim config gracefully with hasCDDInSlim false", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return "invalid json";
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should extract cdd model from slim config when present", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-haiku" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.cddModel).toBe("anthropic/claude-3-5-haiku");
+            expect(result.hasCDDInSlim).toBe(true);
+        });
+        it("should handle cdd agent without model field in slim", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: {}
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.cddModel).toBeUndefined();
+        });
+        it("should prioritize slim model over oh-my-opencode model when both have cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-slim" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-omo" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.cddModel).toBe("model-from-slim");
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.hasCDDInOMO).toBe(true);
+        });
+        it("should select oh-my-opencode when only OMO has cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-omo" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.hasCDDInOMO).toBe(true);
+            expect(result.synergyFramework).toBe('oh-my-opencode');
+        });
+        it("should select slim when only slim has cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-slim" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            sisyphus: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.hasCDDInOMO).toBe(false);
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+        });
+        it("should not activate synergy when neither framework has cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            sisyphus: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.hasCDDInOMO).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+    });
+    describe("OMO agent availability detection", () => {
+        it("should extract available agents from oh-my-opencode config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            sisyphus: { model: "anthropic/claude-3-5-sonnet" },
+                            explore: { model: "google/gemini-3-flash" },
+                            oracle: { model: "anthropic/claude-3-5-sonnet" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.omoAgents).toEqual(['cdd', 'sisyphus', 'explore', 'oracle']);
+        });
+        it("should filter out disabled agents from oh-my-opencode config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            sisyphus: { model: "anthropic/claude-3-5-sonnet" },
+                            explore: { model: "google/gemini-3-flash" },
+                            oracle: { model: "anthropic/claude-3-5-sonnet" }
+                        },
+                        disabled_agents: ['explore', 'oracle']
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.omoAgents).toEqual(['cdd', 'sisyphus']);
+        });
+        it("should handle empty agents object in oh-my-opencode config", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {}
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.omoAgents).toBeUndefined();
+        });
+    });
+    describe("getAvailableOMOAgents", () => {
+        it("should return slim agents when slim framework is active", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" }
+                        },
+                        disabled_agents: ['oracle']
+                    });
+                }
+                return "";
+            });
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual(['explorer', 'librarian', 'designer']);
+        });
+        it("should return omo agents when oh-my-opencode framework is active", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === omoJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            sisyphus: { model: "anthropic/claude-3-5-sonnet" },
+                            explore: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual(['cdd', 'sisyphus', 'explore']);
+        });
+        it("should return empty array when no synergy framework is active", () => {
+            vi.mocked(existsSync).mockReturnValue(false);
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual([]);
+        });
+        it("should prioritize slim agents over omo agents when both configs exist", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-slim" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-omo" },
+                            sisyphus: { model: "model" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const agents = getAvailableOMOAgents();
+            expect(agents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
+        });
+    });
 });

package/dist/utils/documentGeneration.d.ts

@@ -1,5 +1,6 @@
 import { Question, Section } from './questionGenerator.js';
 import { CodebaseAnalysis } from './codebaseAnalysis.js';
+import { Language } from './languageSupport.js';
 /**
  * Document Generation Module
  *
@@ -65,6 +66,7 @@ export interface DocumentGenerationOptions {
     outputPath: string;
     maxRevisions?: number;
     customInputPrompt?: (question: Question) => Promise<string>;
+    language?: Language;
 }
 export interface DocumentGenerationResult {
     success: boolean;
@@ -76,6 +78,7 @@ export interface DocumentGenerationResult {
 export interface PresentQuestionsOptions {
     maxQuestions?: number;
     customInputPrompt?: (question: Question) => Promise<string>;
+    language?: Language;
 }
 /**
  * Present questions sequentially to the user