opencode-conductor-plugin 1.6.0 → 1.8.0

package/dist/index.js

@@ -3,108 +3,31 @@ import { newTrackCommand } from "./commands/newTrack.js";
 import { implementCommand } from "./commands/implement.js";
 import { statusCommand } from "./commands/status.js";
 import { revertCommand } from "./commands/revert.js";
-import { join } from "path";
+import { join, dirname } from "path";
 import { homedir } from "os";
 import { existsSync, readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 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;
-    // Track ChildSessionID -> ParentSessionID mapping
-    const sessionMap = new Map();
     try {
         if (existsSync(configPath)) {
             const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            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")));
+            isOMOActive = config.plugin?.some((p) => p.includes("oh-my-opencode"));
         }
     }
-    catch (e) { }
-    if (!isOMOActive)
-        isOMOActive = existsSync(omoFSPath);
-    console.log(`[Conductor] Plugin tools loaded. (Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
+    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"})`);
     const extendedCtx = { ...ctx, isOMOActive };
     return {
-        event: async (input) => {
-            const { event } = input;
-            const props = event.properties;
-            // Track session hierarchy to know where to mirror tools
-            if (event.type === "session.created") {
-                const info = props?.info;
-                if (info && info.parentID) {
-                    sessionMap.set(info.id, info.parentID);
-                }
-            }
-            // Cleanup map on deletion
-            if (event.type === "session.deleted") {
-                const info = props?.info;
-                if (info)
-                    sessionMap.delete(info.id);
-            }
-        },
-        "tool.execute.before": async (input, output) => {
-            // Intercept 'todowrite' from any subagent and mirror it to their parent session
-            if (input.tool === "todowrite") {
-                const parentID = sessionMap.get(input.sessionID);
-                if (parentID) {
-                    // Re-post the todo update to the parent UI so the user can see it
-                    // We pass the exact arguments used by the subagent
-                    await ctx.client.session.command({
-                        path: { id: parentID },
-                        body: {
-                            command: `/todowrite ${JSON.stringify(output.args)}`
-                        }
-                    }).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),
@@ -112,6 +35,60 @@ const ConductorPlugin = async (ctx) => {
             conductor_status: statusCommand(extendedCtx),
             conductor_revert: revertCommand(extendedCtx),
         },
+        "tool.execute.before": async (input, output) => {
+            // INTERCEPT: Sisyphus Delegation Hook
+            // Purpose: Automatically inject the full Conductor context (Plan, Spec, Workflow, Protocol)
+            // whenever the Conductor delegates a task to Sisyphus. This ensures Sisyphus has "Engineering Authority"
+            // without needing the LLM to manually copy-paste huge context blocks.
+            if (input.tool === "delegate_to_agent") {
+                const agentName = (output.args.agent_name || output.args.agent || "").toLowerCase();
+                if (agentName.includes("sisyphus")) {
+                    console.log("[Conductor] Intercepting Sisyphus delegation. Injecting Context Packet...");
+                    const conductorDir = join(ctx.directory, "conductor");
+                    const promptsDir = join(__dirname, "prompts");
+                    // Helper to safely read file content
+                    const safeRead = async (path) => {
+                        try {
+                            if (existsSync(path))
+                                return await readFile(path, "utf-8");
+                        }
+                        catch (e) { /* ignore */ }
+                        return null;
+                    };
+                    // 1. Read Project Context Files
+                    // We need to find the active track to get the correct spec/plan.
+                    // Since we don't know the track ID easily here, we look for the 'plan.md' that might be in the args
+                    // OR we just rely on the Conductor having already done the setup. 
+                    // WAIT: We can't easily guess the track ID here. 
+                    // BETTER APPROACH: We rely on the generic 'conductor/workflow.md' and 'prompts/implement.toml'.
+                    // For 'spec.md' and 'plan.md', the Conductor usually puts the path in the message. 
+                    // However, to be robust, we will read the GLOBAL workflow and the IMPLEMENT prompt.
+                    // We will explicitly inject the IMPLEMENT PROMPT as requested.
+                    const implementToml = await safeRead(join(promptsDir, "implement.toml"));
+                    const workflowMd = await safeRead(join(conductorDir, "workflow.md"));
+                    // Construct the injection block
+                    let injection = "\n\n--- [SYSTEM INJECTION: CONDUCTOR CONTEXT PACKET] ---\n";
+                    injection += "You are receiving this task from the Conductor Architect.\n";
+                    if (implementToml) {
+                        injection += "\n### 1. ARCHITECTURAL PROTOCOL (Reference Only)\n";
+                        injection += "Use this protocol to understand the project's rigorous standards. DO NOT restart the project management lifecycle (e.g. track selection).\n";
+                        injection += "```toml\n" + implementToml + "\n```\n";
+                    }
+                    if (workflowMd) {
+                        injection += "\n### 2. DEVELOPMENT WORKFLOW\n";
+                        injection += "Follow these TDD and Commit rules precisely.\n";
+                        injection += "```markdown\n" + workflowMd + "\n```\n";
+                    }
+                    injection += "\n### 3. YOUR MANDATE (LEAD ENGINEER)\n";
+                    injection += "- **EXECUTE:** Implement the requested task using the Workflow.\n";
+                    injection += "- **REFINE:** You have authority to update `plan.md` if it is flawed.\n";
+                    injection += "- **ESCALATE:** If you modify the Plan or Spec, report 'PLAN_UPDATED' immediately.\n";
+                    injection += "--- [END INJECTION] ---\n";
+                    // Append to the objective
+                    output.args.objective += injection;
+                }
+            }
+        }
     };
 };
 export default ConductorPlugin;

package/dist/prompts/agent/conductor.md

@@ -7,21 +7,29 @@ tools:
   conductor_implement: true
   conductor_status: true
   conductor_revert: true
-  task: true
-  todowrite: true
-  todoread: true
 ---
 # Conductor Agent
 
-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`).
+You are the **Conductor**, a specialized AI agent for project management and architectural planning using the **Conductor methodology**.
 
-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**.
+Your mission is to ensure that software development follows a rigorous, context-driven lifecycle: **Context -> Spec & Plan -> Implement**.
 
-## 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`. Conductor will automatically mirror any todos Sisyphus creates to the main UI.
-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.
+## Core Responsibilities
 
-## 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.
+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.

package/dist/prompts/implement.toml

@@ -69,11 +69,19 @@ 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 MUST act as the Architect. 
-                   - *Action:* Use the `task` tool with `subagent_type="Sisyphus"`. Provide the phase name and reference the `plan.md` and `spec.md`.
-                   - *Action:* Instruct Sisyphus to implement the whole phase and update his internal todos as he works. Conductor will automatically mirror those updates to the main UI.
-                   - *Action:* 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:**
+    b. **OMO Delegation (Synergy Mode):** If `isOMOActive` is "true", you act as the **Architect**.
+       - *Role:* You delegate the execution of tasks to **Sisyphus**, who acts as the **Lead Engineer**.
+       - *System Note:* When you call `@sisyphus`, the system will automatically inject the full project context (Plan, Spec, Workflow, Protocol) for you.
+       - *Action:* For each task, call `@sisyphus` with this directive:
+         > "I am delegating the implementation of task: '[Task Name]' to you.
+         >
+         > **Goal:** Execute this task. You have Engineering Authority to update `plan.md` if needed.
+         > **Constraint:** If you modify the plan or spec, stop and report 'PLAN_UPDATED'."
+       - *Verification:*
+         - If Sisyphus reports 'PLAN_UPDATED', you MUST **reload** `plan.md` before proceeding.
+         - If Sisyphus reports success, verify the task 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,8 +27,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 ### 2.1 Get Track Description and Determine Type
 
-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.
+1.  **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.6.0",
+  "version": "1.8.0",
   "description": "Conductor plugin for OpenCode",
   "type": "module",
   "repository": "derekbar90/opencode-conductor",