opencode-conductor-plugin 1.3.0 → 1.5.0

package/dist/index.js

@@ -9,21 +9,94 @@ import { existsSync, readFileSync } from "fs";
 const ConductorPlugin = async (ctx) => {
     // Detect oh-my-opencode for synergy features
     const configPath = join(homedir(), ".config", "opencode", "opencode.json");
+    const omoFSPath = join(homedir(), ".config", "opencode", "node_modules", "oh-my-opencode");
     let isOMOActive = false;
+    let mainSessionID;
     try {
         if (existsSync(configPath)) {
             const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            isOMOActive = config.plugin?.some((p) => p.includes("oh-my-opencode"));
+            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) {
-        // Fallback to filesystem check if config read fails
-        const omoPath = join(homedir(), ".config", "opencode", "node_modules", "oh-my-opencode");
-        isOMOActive = existsSync(omoPath);
-    }
-    console.log(`[Conductor] Plugin tools loaded. (OMO Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
+    catch (e) { }
+    if (!isOMOActive)
+        isOMOActive = existsSync(omoFSPath);
+    console.log(`[Conductor] Plugin tools loaded. (Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
     const extendedCtx = { ...ctx, isOMOActive };
     return {
+        event: async (input) => {
+            const { event } = input;
+            const props = event.properties;
+            // 1. Track the main session ID
+            if (event.type === "session.created") {
+                const info = props?.info;
+                if (info && !info.parentID) {
+                    mainSessionID = info.id;
+                }
+            }
+            // 2. Monitor for telemetry tags in subagent messages
+            if (event.type === "message.part.updated" && mainSessionID) {
+                const text = props?.part?.text || "";
+                const syncMatch = text.match(/<conductor_sync\s+id="([^"]+)"\s+status="([^"]+)"\s*\/>/);
+                if (syncMatch) {
+                    const [_, todoId, status] = syncMatch;
+                    // Execute a hidden command in the main session to update the todo UI
+                    await ctx.client.session.command({
+                        path: { id: mainSessionID },
+                        body: {
+                            command: `/todowrite ${status} ${todoId}`
+                        }
+                    }).catch(() => { });
+                }
+            }
+        },
+        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,24 @@ 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 (Telemetry Sync):** Instead of coding yourself, use the `task` tool to delegate tasks to `@Sisyphus`. 
+    - You MUST pre-populate the main session's todo list with the tasks for the phase.
+    - Instruct Sisyphus to output the tag `<conductor_sync id="TASK_ID" status="completed" />` when he completes a task.
+    - This tag is a hidden signal that Conductor uses to update the main UI in real-time.
+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,16 @@ 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 & Live Telemetry (Synergy Mode):** If `isOMOActive` is "true", you MUST act as the Architect. Follow this sequence:
+               - **Step 1: Map Plan to Native Todos:** Read the current phase's tasks from `plan.md`. Use the `todowrite` tool to create a todo for EACH task in the **main session**. Use simple IDs like `task-1`, `task-2`, etc.
+               - **Step 2: Delegate the Phase:** Use the `task` tool with `subagent_type="Sisyphus"`. 
+               - **Step 3: The Delegation Prompt:** Your prompt to Sisyphus MUST include:
+                 > "You are implementing Phase [Name]. Here are the tasks: [List].
+                 > IMPORTANT: I have mirrored these tasks to the main UI with IDs task-1, task-2, etc.
+                 > When you complete a task, you **MUST** output the tag: `<conductor_sync id="task-N" status="completed" />`.
+                 > This allows the user to see your progress in real-time."
+               - **Step 4: Completion:** Once Sisyphus returns, verify the whole phase and proceed to the checkpoint.
+            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.3.0",
+  "version": "1.5.0",
   "description": "Conductor plugin for OpenCode",
   "type": "module",
   "repository": "derekbar90/opencode-conductor",