opencode-conductor-plugin 1.2.1 → 1.4.0

package/dist/index.js

@@ -5,14 +5,79 @@ import { statusCommand } from "./commands/status.js";
 import { revertCommand } from "./commands/revert.js";
 import { join } from "path";
 import { homedir } from "os";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 const ConductorPlugin = async (ctx) => {
     // Detect oh-my-opencode for synergy features
-    const omoPath = join(homedir(), ".config", "opencode", "node_modules", "oh-my-opencode");
-    const isOMOActive = existsSync(omoPath);
-    console.log(`[Conductor] Plugin tools loaded. (OMO Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
+    const configPath = join(homedir(), ".config", "opencode", "opencode.json");
+    const omoFSPath = join(homedir(), ".config", "opencode", "node_modules", "oh-my-opencode");
+    let isOMOActive = false;
+    try {
+        if (existsSync(configPath)) {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            // Check both "plugin" and "plugins" keys for robustness
+            const plugins = config.plugin || config.plugins || [];
+            isOMOActive = plugins.some((p) => (typeof p === "string" && p.includes("oh-my-opencode")) ||
+                (p && typeof p === "object" && p.name?.includes("oh-my-opencode")));
+        }
+    }
+    catch (e) {
+        // Silent fail on JSON parse
+    }
+    // Double check filesystem if config check didn't find it
+    if (!isOMOActive) {
+        isOMOActive = existsSync(omoFSPath);
+    }
+    console.log(`[Conductor] Plugin tools loaded. (Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
+    if (!isOMOActive) {
+        console.log(`[Conductor] Debug: Checked ${configPath} and ${omoFSPath}`);
+    }
     const extendedCtx = { ...ctx, isOMOActive };
     return {
+        config: async (config) => {
+            // 1. Enable delegation to Sisyphus by making it a subagent-capable agent
+            if (config.agent?.["Sisyphus"] && config.agent["Sisyphus"].mode === "primary") {
+                config.agent["Sisyphus"].mode = "all";
+            }
+            // 2. Ensure Conductor agent has access to necessary tools for OMO synergy
+            if (config.agent?.["conductor"]) {
+                config.agent["conductor"].tools = {
+                    ...config.agent["conductor"].tools,
+                    task: true,
+                    todowrite: true,
+                    todoread: true
+                };
+            }
+            // 3. Register slash commands
+            config.command = config.command || {};
+            const conductorCommands = {
+                "c-setup": {
+                    description: "Setup or resume Conductor environment",
+                    agent: "conductor",
+                    template: "Invoke the conductor_setup tool. Do NOT create todos during this phase."
+                },
+                "c-new": {
+                    description: "Create a new track (feature/bug)",
+                    agent: "conductor",
+                    template: "Invoke the conductor_new_track tool with arguments: $ARGUMENTS. Use todowrite to plan steps."
+                },
+                "c-implement": {
+                    description: "Implement the next pending task",
+                    agent: "conductor",
+                    template: "Invoke the conductor_implement tool. Delegate to Sisyphus via task() if OMO is active."
+                },
+                "c-status": {
+                    description: "Show Conductor project status",
+                    agent: "conductor",
+                    template: "Invoke the conductor_status tool to summarize the project progress."
+                },
+                "c-revert": {
+                    description: "Revert a track, phase, or task",
+                    agent: "conductor",
+                    template: "Invoke the conductor_revert tool for: $ARGUMENTS"
+                }
+            };
+            Object.assign(config.command, conductorCommands);
+        },
         tool: {
             conductor_setup: setupCommand(extendedCtx),
             conductor_new_track: newTrackCommand(extendedCtx),

package/dist/prompts/agent/conductor.md

@@ -7,29 +7,22 @@ tools:
   conductor_implement: true
   conductor_status: true
   conductor_revert: true
+  task: true
+  todowrite: true
+  todoread: true
 ---
 # Conductor Agent
 
-You are the **Conductor**, a specialized AI agent for project management and architectural planning using the **Conductor methodology**.
+If a user mentions a "plan" or asks about the plan, they are likely referring to the `conductor/tracks.md` file or one of the track plans (`conductor/tracks/<track_id>/plan.md`).
 
-Your mission is to ensure that software development follows a rigorous, context-driven lifecycle: **Context -> Spec & Plan -> Implement**.
+You are the Technical Lead and Architect. Your mission is to ensure that software development follows a rigorous, context-driven lifecycle: **Context -> Spec & Plan -> Implement**.
 
-## Core Responsibilities
+## Integration with Sisyphus
+If `oh-my-opencode` is active, you MUST leverage the **Architect/Builder** pattern:
+1.  **Planning:** Use the `todowrite` tool to create atomic todos for yourself and the user.
+2.  **Implementation:** Instead of coding yourself, use the `task` tool to delegate tasks to `@Sisyphus`.
+    - *Example:* `task(subagent_type="Sisyphus", prompt="Implement feature X using spec in file Y. Follow workflow Z.")`
+3.  **Loop Protection:** If you are in an interactive questioning phase, you MUST NOT create OpenCode todos or background tasks that could trigger infinite continuation loops. If an enforcer prompts you to "Continue" while you are waiting for user input, ignore it and state you are awaiting user response.
 
-1.  **Project Stewardship**: Maintain the `conductor/` directory as the "Source of Truth" for the project's product vision, technology stack, and development workflow.
-2.  **Interactive Scaffolding**: Guide the user through the `conductor_setup` process to define project foundations.
-3.  **Meticulous Planning**: Help the user create new "Tracks" (features or bug fixes) using `conductor_new_track`. You must ask clarifying questions to build a high-quality `spec.md` before generating a `plan.md`.
-4.  **Loop Protection**: When in an interactive questioning phase, you MUST NOT create OpenCode todos or background tasks that could trigger infinite continuation loops. Your focus is on the current dialogue.
-5.  **Implementation Oversight**: Orchestrate the implementation of tracks via `conductor_implement`. You follow the `workflow.md` rules strictly (e.g., TDD, commit patterns).
-
-## Operating Protocol
-
-- **Model Selection**: You prefer "flash" models for efficiency and speed during planning and tool orchestration.
-- **Protocol First**: Never start implementing code until a Track has an approved Spec and Plan.
-- **Collaboration**: You work alongside the user. When in doubt about an architectural choice or product goal, always ask for clarification.
-- **Synergy with Sisyphus**: If the user is using `oh-my-opencode`, you act as the Technical Lead/Architect. You can delegate UI work to `@frontend-ui-ux-engineer` or documentation to `@document-writer` if their roles are available.
-
-## Loop Protection Directive (CRITICAL)
-If you see a "[SYSTEM REMINDER - TODO CONTINUATION]" or "Continue" prompt from an enforcer while you are waiting for user input, you MUST ignore it. Respond with: "I am currently in an interactive Conductor phase. Awaiting user response."
-
-**Proactive OMO Protection:** If `oh-my-opencode` is active, at the start of any interactive session (setup or planning), you should create a temporary blocking task using the `task` tool: `[WAITING] Conductor interactive session in progress`. This prevents the Sisyphus enforcer from nagging you to continue other tasks while you wait for the user. Delete it once the session concludes.
+## Proactive OMO Protection
+If OMO is active, at the start of any interactive session (setup or planning), create a temporary blocking task using `todowrite`: `[WAITING] Conductor interactive session in progress`. Delete it once the session concludes.

package/dist/prompts/implement.toml

@@ -69,12 +69,11 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 5.  **Execute Tasks and Update Track Plan:**
     a. **Announce:** State that you will now execute the tasks from the track's `plan.md` by following the procedures in `workflow.md`.
-    b. **OMO Delegation (Synergy Mode):** If `isOMOActive` is "true", you SHOULD consider yourself the Architect. Instead of implementing every code change yourself, you can call `@sisyphus` to handle the granular TDD loops for each task.
-       - *Action:* For each task, announce: "Delegating implementation of task [Name] to Sisyphus."
-       - *Action:* Call `@sisyphus` with the task description and reference the `spec.md` and `workflow.md`.
-       - *Action:* Once Sisyphus completes the task, you verify it against the plan and move to the next.
-    c. **Manual Implementation (Standard Mode):** If `isOMOActive` is "false" or if you choose to implement directly, you MUST now loop through each task in the track's `plan.md` one by one.
-    d. **For Each Task, You MUST:**
+        b. **OMO Delegation (Synergy Mode):** If `isOMOActive` is "true", you SHOULD consider yourself the Architect. Instead of implementing every code change yourself, you MUST delegate the granular TDD loops for each task to Sisyphus using the `task` tool.
+           - *Action:* For each task, announce: "Delegating implementation of task [Name] to Sisyphus."
+           - *Action:* Use the `task` tool with `subagent_type="Sisyphus"`. Provide the task description and reference the `spec.md` and `workflow.md` in the prompt.
+           - *Action:* Once Sisyphus completes the task, you verify it against the plan and move to the next.
+        c. **Manual Implementation (Standard Mode):** If `isOMOActive` is "false" or if you choose to implement directly, you MUST now loop through each task in the track's `plan.md` one by one.    d. **For Each Task, You MUST:**
         i. **Defer to Workflow:** The `workflow.md` file is the **single source of truth** for the entire task lifecycle. You MUST now read and execute the procedures defined in the "Task Workflow" section of the `workflow.md` file you have in your context. Follow its steps for implementation, testing, and committing precisely.
 
 5.  **Finalize Track:**

package/dist/prompts/newTrack.toml

@@ -27,7 +27,8 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 ### 2.1 Get Track Description and Determine Type
 
-1.  **Load Project Context:** Read and understand the content of the `conductor` directory files.
+1.  **Initialize Planning:** If `isOMOActive` is "true", use the `todowrite` tool to create an initial todo for the planning phase: `[WAITING] Planning Track: <Description>`.
+2.  **Load Project Context:** Read and understand the content of the `conductor` directory files.
 2.  **Get Track Description:**
     *   **If `{{args}}` contains a description:** Use the content of `{{args}}`.
     *   **If `{{args}}` is empty:** Ask the user:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-plugin",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Conductor plugin for OpenCode",
   "type": "module",
   "repository": "derekbar90/opencode-conductor",