opencode-conductor-plugin 1.1.3 → 1.2.0

package/README.md

@@ -1,63 +1,69 @@
 # Conductor Plugin for OpenCode
 
-**Measure twice, code once.**
+> **Measure twice, code once.**
 
-Conductor is an OpenCode plugin that enables **Context-Driven Development**. It turns OpenCode into a proactive project manager that follows a strict protocol to specify, plan, and implement software features and bug fixes.
+Conductor is a specialized OpenCode plugin designed to enforce a rigorous, **Context-Driven Development** lifecycle. It transforms OpenCode from a reactive coding tool into a proactive project architect that follows a strict protocol to specify, plan, and implement software features and bug fixes.
 
-Instead of just writing code, Conductor ensures a consistent, high-quality lifecycle for every task: **Context -> Spec & Plan -> Implement**.
-
-The philosophy behind Conductor is simple: **control your code**. By treating context as a managed artifact alongside your code, you transform your repository into a single source of truth that drives every agent interaction with deep, persistent project awareness.
+The philosophy is simple: **control your code by controlling your context.** By treating project requirements and plans as managed artifacts, Conductor ensures every agent interaction is grounded in deep, persistent project awareness.
 
 ---
 
 ## 🚀 Key Features
 
-- **Specialized `@conductor` Agent**: A dedicated subagent that acts as a Project Architect and Stewardship officer.
-- **Native Slash Commands**: Quick shortcuts like `/c-setup`, `/c-new`, and `/c-implement`.
-- **Plan Before You Build**: Automated generation of `spec.md` and `plan.md` based on your project's unique context.
-- **Maturity Aware**: Intelligent initialization for both new (Greenfield) and existing (Brownfield) projects.
-- **Smart Revert**: A Git-aware revert command that understands logical units of work (tracks, phases, tasks).
-- **Synergy with Sisyphus**: Seamlessly integrates with [oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode).
+*   **Specialized `@conductor` Agent**: A dedicated subagent that acts as your Project Architect and Technical Lead.
+*   **Native Slash Commands**: Integrated shortcuts like `/c-setup`, `/c-new`, and `/c-implement` for frictionless project management.
+*   **Protocol-Driven Workflow**: Automated enforcement of the **Context -> Spec -> Plan -> Implement** lifecycle.
+*   **Smart Revert**: A Git-aware revert system that understands logical units of work (Tracks, Phases, Tasks) instead of just raw commit hashes.
+*   **19+ Style Templates**: Built-in support for a vast range of languages including Rust, Solidity, Zig, Julia, Kotlin, Swift, and more.
+*   **Zero-Config Bootstrap**: Automatically installs agents and commands to your global OpenCode configuration on first run.
+*   **Sisyphus Synergy**: Optimized to work alongside [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode) for a multi-agent team experience.
 
-## 🛠️ Usage
+---
 
-Conductor manages the entire lifecycle of your development tasks via the `@conductor` agent.
+## 🛠️ The Conductor Lifecycle
 
-### 1. Set Up the Project (Run Once)
-Initializes the `conductor/` directory with your project's "Constitution" (Product vision, Tech Stack, and Workflow rules).
-```bash
-/c-setup
-```
+Conductor organizes your work into **Tracks** (features or bug fixes). Every Track follows three mandatory phases:
 
-### 2. Start a New Track (Feature or Bug)
-Initializes a **track** — a high-level unit of work. Conductor helps you generate a detailed specification and an actionable implementation plan.
-```bash
-/c-new "Add user authentication using OAuth"
-```
+### 1. Project Initialization (`/c-setup`)
+Run this once per project. The `@conductor` agent will interview you to define:
+*   **Product Vision**: Target users, core goals, and primary features.
+*   **Tech Stack**: Languages, frameworks, and databases.
+*   **Workflow Rules**: Testing standards (e.g., TDD), commit strategies, and documentation patterns.
 
-### 3. Implement the Track
-The agent works through the `plan.md` file, checking off tasks as it completes them, following your workflow strictly (e.g., TDD, commit strategy).
-```bash
-/c-implement
-```
+### 2. Track Planning (`/c-new`)
+When you're ready for a new task, tell Conductor what you want to build.
+*   **Specification (`spec.md`)**: Conductor asks 3-5 targeted questions to clarify the "What" and "Why".
+*   **Implementation Plan (`plan.md`)**: Once the spec is approved, Conductor generates a step-by-step checklist adhering to your project's workflow rules.
 
-### 4. Check Status & Revert
-Monitor progress or undo specific logical units of work.
-```bash
-/c-status
-/c-revert "last task"
-```
+### 3. Autonomous Implementation (`/c-implement`)
+The agent works through the `plan.md` checklist, executing tasks, running tests, and making semantic commits automatically until the Track is complete.
 
 ---
 
 ## 📦 Installation
 
-Please see [INSTALL.md](./INSTALL.md) for detailed instructions on building and installing the plugin globally.
+Add the plugin to your global OpenCode configuration file. OpenCode will automatically fetch and install it from NPM.
+
+**File:** `~/.config/opencode/opencode.json`
+
+```json
+{
+  "plugin": [
+    "opencode-conductor-plugin"
+  ]
+}
+```
+
+*Note: Please restart OpenCode after the first run to enable the global slash commands.*
+
+---
 
 ## ⚙️ Configuration
 
-You can customize the model used by the `@conductor` agent in your global `opencode.json` or `oh-my-opencode.json`:
+We highly recommend pinning the `@conductor` agent to a "flash" model for optimal performance during planning phases.
 
+### Standard OpenCode Config
+**File:** `~/.config/opencode/opencode.json`
 ```json
 {
   "agent": {
@@ -68,24 +74,49 @@ You can customize the model used by the `@conductor` agent in your global `openc
 }
 ```
 
+### OhMyOpenCode Config
+**File:** `~/.config/opencode/oh-my-opencode.json`
+```json
+{
+  "agents": {
+    "conductor": {
+      "model": "google/gemini-3-flash"
+    }
+  }
+}
+```
+
 ---
 
-## 🤝 Synergy with oh-my-opencode
+## 📋 Commands Reference
 
-If you are using the **OhMyOpenCode** suite, `@conductor` acts as your Technical Lead. While **Sisyphus** manages the overall conversation, he can delegate specialized planning and architectural enforcement tasks to the `@conductor` agent.
+| Command | Description |
+| :--- | :--- |
+| `/c-setup` | Initialize the `conductor/` directory and project "Constitution". |
+| `/c-new "desc"` | Start a new feature/bug Track with spec and plan generation. |
+| `/c-implement` | Start implementing the next pending task in the current track. |
+| `/c-status` | Get a high-level overview of project progress and active tracks. |
+| `/c-revert` | Interactively select a task, phase, or track to undo via Git. |
 
 ---
 
-## 📈 Automated Versioning & Release
+## 🤝 Synergy with OhMyOpenCode
+
+If you use the **OhMyOpenCode** suite, `@conductor` acts as your Technical Lead. While **Sisyphus** manages the general conversation and orchestration, he can delegate complex architectural planning and protocol enforcement to the `@conductor` agent. 
+
+Conductor includes built-in "Loop Protection" to ensure it never conflicts with OhMyOpenCode's continuation enforcers during interactive Q&A sessions.
+
+---
 
-This project uses **Semantic Release** to automate versioning and NPM publishing. Version numbers are automatically determined based on commit messages following the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+## 📈 Automated Versioning
 
-- `fix:` triggers a **patch** release (e.g., 0.1.0 -> 0.1.1)
-- `feat:` triggers a **minor** release (e.g., 0.1.0 -> 0.2.0)
-- `BREAKING CHANGE:` in footer triggers a **major** release (e.g., 0.1.0 -> 1.0.0)
+This project follows **Conventional Commits**. Releases are automated via Semantic Release:
+- `feat:` -> Minor version bump
+- `fix:` -> Patch version bump
+- `BREAKING CHANGE:` -> Major version bump
 
 ---
 
-## 📜 Legal
+## 📜 License
 
-- License: [Apache License 2.0](LICENSE)
+Distributed under the [Apache License 2.0](LICENSE).

package/dist/commands/implement.js

@@ -12,6 +12,8 @@ export const implementCommand = (ctx) => tool({
         if (!existsSync(join(conductorDir, "product.md"))) {
             return "Conductor is not set up. Please run `conductor_setup`.";
         }
-        return await loadPrompt("implement.toml");
+        return await loadPrompt("implement.toml", {
+            isOMOActive: ctx.isOMOActive ? "true" : "false"
+        });
     },
 });

package/dist/commands/newTrack.js

@@ -9,11 +9,13 @@ export const newTrackCommand = (ctx) => tool({
     },
     async execute(args) {
         const conductorDir = join(ctx.directory, "conductor");
-        if (!existsSync(join(conductorDir, "product.md")) ||
-            !existsSync(join(conductorDir, "workflow.md"))) {
+        if (!existsSync(join(conductorDir, "product.md"))) {
             return "Conductor is not set up. Please run `conductor_setup`.";
         }
         // Map the description to {{args}} in the legacy TOML
-        return await loadPrompt("newTrack.toml", { args: args.description || "" });
+        return await loadPrompt("newTrack.toml", {
+            args: args.description || "",
+            isOMOActive: ctx.isOMOActive ? "true" : "false"
+        });
     },
 });

package/dist/commands/setup.js

@@ -14,6 +14,9 @@ export const setupCommand = (ctx) => tool({
         const stateManager = new StateManager(ctx.directory);
         // Resolve the absolute path to the templates directory in the distribution
         const templatesDir = join(__dirname, "../templates");
-        return await loadPrompt("setup.toml", { templatesDir });
+        return await loadPrompt("setup.toml", {
+            templatesDir,
+            isOMOActive: ctx.isOMOActive ? "true" : "false"
+        });
     },
 });

package/dist/index.js

@@ -3,15 +3,22 @@ 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 { homedir } from "os";
+import { existsSync } from "fs";
 const ConductorPlugin = async (ctx) => {
-    console.log("[Conductor] Plugin tools loaded.");
+    // 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 extendedCtx = { ...ctx, isOMOActive };
     return {
         tool: {
-            conductor_setup: setupCommand(ctx),
-            conductor_new_track: newTrackCommand(ctx),
-            conductor_implement: implementCommand(ctx),
-            conductor_status: statusCommand(ctx),
-            conductor_revert: revertCommand(ctx),
+            conductor_setup: setupCommand(extendedCtx),
+            conductor_new_track: newTrackCommand(extendedCtx),
+            conductor_implement: implementCommand(extendedCtx),
+            conductor_status: statusCommand(extendedCtx),
+            conductor_revert: revertCommand(extendedCtx),
         },
     };
 };

package/dist/prompts/agent/conductor.md

@@ -1,6 +1,6 @@
 ---
 description: Spec-Driven Development Architect. Manages the project lifecycle using the Conductor protocol.
-mode: subagent
+mode: agent
 tools:
   conductor_setup: true
   conductor_new_track: true
@@ -30,4 +30,6 @@ Your mission is to ensure that software development follows a rigorous, context-
 - **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."
+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

@@ -67,10 +67,14 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
         - `conductor/workflow.md`
     c. **Error Handling:** If you fail to read any of these files, you MUST stop and inform the user of the error.
 
-4.  **Execute Tasks and Update Track Plan:**
+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. **Iterate Through Tasks:** You MUST now loop through each task in the track's `plan.md` one by one.
-    c. **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 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:**
         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/utils/bootstrap.js

@@ -17,23 +17,19 @@ export async function bootstrap(ctx) {
         mkdirSync(targetAgentDir, { recursive: true });
     if (!existsSync(targetCommandDir))
         mkdirSync(targetCommandDir, { recursive: true });
-    // 2. Install Agent if missing
+    // 2. Install/Update Agent
     const targetAgentFile = join(targetAgentDir, "conductor.md");
-    if (!existsSync(targetAgentFile)) {
-        if (existsSync(sourceAgentFile)) {
-            copyFileSync(sourceAgentFile, targetAgentFile);
-            installedAnything = true;
-        }
+    if (existsSync(sourceAgentFile)) {
+        copyFileSync(sourceAgentFile, targetAgentFile);
+        installedAnything = true;
     }
-    // 3. Install Commands if missing
+    // 3. Install/Update Commands
     if (existsSync(sourceCommandsDir)) {
         const commands = readdirSync(sourceCommandsDir);
         for (const cmdFile of commands) {
             const targetCmdFile = join(targetCommandDir, cmdFile);
-            if (!existsSync(targetCmdFile)) {
-                copyFileSync(join(sourceCommandsDir, cmdFile), targetCmdFile);
-                installedAnything = true;
-            }
+            copyFileSync(join(sourceCommandsDir, cmdFile), targetCmdFile);
+            installedAnything = true;
         }
     }
     if (installedAnything) {

package/package.json

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