opencode-conductor-plugin 1.16.0 → 1.17.1

package/README.md

@@ -11,7 +11,7 @@ The philosophy is simple: **control your code by controlling your context.** By
 ## 🚀 Key Features
 
 *   **Specialized `@conductor` Agent**: A dedicated subagent that acts as your Project Architect and Technical Lead.
-*   **Native Slash Commands**: Integrated shortcuts like `/conductor:setup`, `/conductor:newTrack`, and `/conductor:implement` for frictionless project management.
+*   **Native Slash Commands**: Integrated shortcuts like `/conductor_setup`, `/conductor_newTrack`, and `/conductor_implement` for frictionless project management.
 *   **Modern Permissions**: Fully compatible with OpenCode v1.1.1 granular permission system.
 *   **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.
@@ -26,18 +26,18 @@ The philosophy is simple: **control your code by controlling your context.** By
 
 Conductor organizes your work into **Tracks** (features or bug fixes). Every Track follows three mandatory phases:
 
-### 1. Project Initialization (`/conductor:setup`)
+### 1. Project Initialization (`/conductor_setup`)
 Run this once per project. The 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.
 
-### 2. Track Planning (`/conductor:newTrack`)
+### 2. Track Planning (`/conductor_newTrack`)
 When you're ready for a new task, tell the agent 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.
 
-### 3. Autonomous Implementation (`/conductor:implement`)
+### 3. Autonomous Implementation (`/conductor_implement`)
 The agent works through the `plan.md` checklist, executing tasks, running tests, and making semantic commits automatically until the Track is complete.
 
 ---
@@ -94,11 +94,11 @@ We highly recommend pinning the `@conductor` agent to a "flash" model for optima
 
 | Command | Description |
 | :--- | :--- |
-| `/conductor:setup` | Initialize the `conductor/` directory and project "Constitution". |
-| `/conductor:newTrack "desc"` | Start a new feature/bug Track with spec and plan generation. |
-| `/conductor:implement` | Start implementing the next pending task in the current track. |
-| `/conductor:status` | Get a high-level overview of project progress and active tracks. |
-| `/conductor:revert` | Interactively select a task, phase, or track to undo via Git. |
+| `/conductor_setup` | Initialize the `conductor/` directory and project "Constitution". |
+| `/conductor_newTrack "desc"` | Start a new feature/bug Track with spec and plan generation. |
+| `/conductor_implement` | Start implementing the next pending task in the current track. |
+| `/conductor_status` | Get a high-level overview of project progress and active tracks. |
+| `/conductor_revert` | Interactively select a task, phase, or track to undo via Git. |
 
 ---
 

package/dist/index.js

@@ -1,8 +1,9 @@
 import { join, dirname } from "path";
-import { homedir } from "os";
-import { existsSync, readFileSync } from "fs";
+import { existsSync } from "fs";
 import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
+import { createDelegationTool } from "./tools/delegate.js";
+import { BackgroundManager, createBackgroundTask, createBackgroundOutput, createBackgroundCancel, } from "./tools/background.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const safeRead = async (path) => {
@@ -16,21 +17,8 @@ const safeRead = async (path) => {
 const ConductorPlugin = async (ctx) => {
     try {
         console.log("[Conductor] Initializing plugin...");
-        // 1. Detect oh-my-opencode for synergy features
-        const configPath = join(homedir(), ".config", "opencode", "opencode.json");
-        let isOMOActive = false;
-        try {
-            if (existsSync(configPath)) {
-                const config = JSON.parse(readFileSync(configPath, "utf-8"));
-                isOMOActive = config.plugin?.some((p) => p.includes("oh-my-opencode"));
-            }
-        }
-        catch (e) {
-            const omoPath = join(homedir(), ".config", "opencode", "node_modules", "oh-my-opencode");
-            isOMOActive = existsSync(omoPath);
-        }
-        console.log(`[Conductor] Plugin environment detected. (OMO Synergy: ${isOMOActive ? "Enabled" : "Disabled"})`);
-        // 2. Helper to load and process prompt templates (Manual TOML Parsing)
+        const backgroundManager = new BackgroundManager(ctx);
+        // 1. Helper to load and process prompt templates (Manual TOML Parsing)
         const loadPrompt = async (filename, replacements = {}) => {
             const promptPath = join(__dirname, "prompts", filename);
             try {
@@ -42,7 +30,6 @@ const ConductorPlugin = async (ctx) => {
                 if (!promptText)
                     throw new Error(`Could not parse prompt text from ${filename}`);
                 const defaults = {
-                    isOMOActive: isOMOActive ? "true" : "false",
                     templatesDir: join(dirname(__dirname), "templates"),
                 };
                 const finalReplacements = { ...defaults, ...replacements };
@@ -59,7 +46,7 @@ const ConductorPlugin = async (ctx) => {
                 };
             }
         };
-        // 3. Load Strategies
+        // 2. Load Strategies
         let strategySection = "";
         try {
             const strategyFile = "manual.md"; // Force manual strategy for now
@@ -69,7 +56,7 @@ const ConductorPlugin = async (ctx) => {
         catch (e) {
             strategySection = "SYSTEM ERROR: Could not load execution strategy.";
         }
-        // 4. Load all Command Prompts (Parallel)
+        // 3. Load all Command Prompts (Parallel)
         const [setup, newTrack, implement, status, revert, workflowMd] = await Promise.all([
             loadPrompt("setup.toml"),
             loadPrompt("newTrack.toml", { args: "$ARGUMENTS" }),
@@ -81,35 +68,48 @@ const ConductorPlugin = async (ctx) => {
             loadPrompt("revert.toml", { target: "$ARGUMENTS" }),
             safeRead(join(ctx.directory, "conductor", "workflow.md")),
         ]);
-        // 5. Extract Agent Prompt
-        const agentMd = await readFile(join(__dirname, "prompts", "agent", "conductor.md"), "utf-8");
-        const agentPrompt = agentMd.split("---").pop()?.trim() || "";
+        // 4. Extract Agent Prompts
+        const [conductorMd, implementerMd] = await Promise.all([
+            readFile(join(__dirname, "prompts", "agent", "conductor.md"), "utf-8"),
+            readFile(join(__dirname, "prompts", "agent", "implementer.md"), "utf-8"),
+        ]);
+        const conductorPrompt = conductorMd.split("---").pop()?.trim() || "";
+        const implementerPrompt = implementerMd.split("---").pop()?.trim() || "";
         console.log("[Conductor] All components ready. Injecting config...");
         return {
+            tool: {
+                "conductor_delegate": createDelegationTool(ctx),
+                "conductor_background_task": createBackgroundTask(backgroundManager),
+                "conductor_background_output": createBackgroundOutput(backgroundManager),
+                "conductor_background_cancel": createBackgroundCancel(backgroundManager),
+            },
             config: async (config) => {
-                console.log("[Conductor] config handler: Merging commands and agent...");
+                if (!config)
+                    return;
+                console.log("[Conductor] config handler: Merging commands and agents...");
                 config.command = {
                     ...(config.command || {}),
-                    "conductor:setup": {
+                    "conductor_setup": {
                         template: setup.prompt,
                         description: setup.description,
                         agent: "conductor",
                     },
-                    "conductor:newTrack": {
+                    "conductor_newTrack": {
                         template: newTrack.prompt,
                         description: newTrack.description,
                         agent: "conductor",
                     },
-                    "conductor:implement": {
+                    "conductor_implement": {
                         template: implement.prompt,
                         description: implement.description,
+                        agent: "conductor_implementer",
                     },
-                    "conductor:status": {
+                    "conductor_status": {
                         template: status.prompt,
                         description: status.description,
                         agent: "conductor",
                     },
-                    "conductor:revert": {
+                    "conductor_revert": {
                         template: revert.prompt,
                         description: revert.description,
                         agent: "conductor",
@@ -118,16 +118,62 @@ const ConductorPlugin = async (ctx) => {
                 config.agent = {
                     ...(config.agent || {}),
                     conductor: {
-                        description: "Spec-Driven Development Architect.",
+                        description: "Conductor Protocol Steward.",
                         mode: "primary",
-                        prompt: agentPrompt + workflowMd,
+                        prompt: conductorPrompt +
+                            (workflowMd ? "\n\n### PROJECT WORKFLOW\n" + workflowMd : ""),
                         permission: {
+                            bash: "allow",
                             edit: "allow",
+                            webfetch: "allow",
+                            external_directory: "deny",
+                        },
+                        tools: {
+                            bash: true,
+                            edit: true,
+                            write: true,
+                            read: true,
+                            grep: true,
+                            glob: true,
+                            list: true,
+                            lsp: true,
+                            patch: true,
+                            skill: true,
+                            todowrite: true,
+                            todoread: true,
+                            webfetch: true,
+                        },
+                    },
+                    conductor_implementer: {
+                        description: "Conductor Protocol Implementer.",
+                        mode: "primary",
+                        prompt: implementerPrompt +
+                            (workflowMd ? "\n\n### PROJECT WORKFLOW\n" + workflowMd : ""),
+                        permission: {
                             bash: "allow",
+                            edit: "allow",
                             webfetch: "allow",
-                            doom_loop: "allow",
                             external_directory: "deny",
                         },
+                        tools: {
+                            bash: true,
+                            edit: true,
+                            write: true,
+                            read: true,
+                            grep: true,
+                            glob: true,
+                            list: true,
+                            lsp: true,
+                            patch: true,
+                            skill: true,
+                            todowrite: true,
+                            todoread: true,
+                            webfetch: true,
+                            "conductor_delegate": true,
+                            "conductor_background_task": true,
+                            "conductor_background_output": true,
+                            "conductor_background_cancel": true,
+                        },
                     },
                 };
             },
@@ -136,7 +182,8 @@ const ConductorPlugin = async (ctx) => {
                     "delegate_to_agent",
                     "task",
                     "background_task",
-                    "call_omo_agent",
+                    "conductor_delegate",
+                    "conductor_background_task",
                 ];
                 if (delegationTools.includes(input.tool)) {
                     const conductorDir = join(ctx.directory, "conductor");
@@ -144,7 +191,7 @@ const ConductorPlugin = async (ctx) => {
                     if (workflowMd) {
                         let injection = "\n\n--- [SYSTEM INJECTION: CONDUCTOR CONTEXT PACKET] ---\n";
                         injection +=
-                            "You are receiving this task from the Conductor Architect.\n";
+                            "You are receiving this task from the Conductor.\n";
                         injection +=
                             "You MUST adhere to the following project workflow rules:\n";
                         injection += "\n### DEVELOPMENT WORKFLOW\n" + workflowMd + "\n";
@@ -153,7 +200,7 @@ const ConductorPlugin = async (ctx) => {
                                 "\n### IMPLEMENTATION PROTOCOL\n" + implement.prompt + "\n";
                         }
                         injection +=
-                            "\n### DELEGATED AUTHORITY\n- **EXECUTE:** Implement the requested task.\n- **REFINE:** You have authority to update `plan.md`.\n";
+                            "\n### DELEGATED AUTHORITY\n- **EXECUTE:** Implement the requested task.\n- **REFINE:** You have authority to update `plan.md` and `spec.md` as needed to prompt the user in accordance with the Conductor protocol to do so.\n";
                         injection += "--- [END INJECTION] ---\n";
                         // Inject into the primary instruction field depending on the tool's schema
                         if (typeof output.args.objective === "string") {

package/dist/prompts/agent/conductor.md

@@ -2,34 +2,37 @@
 description: Spec-Driven Development Architect. Manages the project lifecycle using the Conductor protocol.
 mode: primary
 permission:
-  conductor_setup: allow
-  conductor_new_track: allow
-  conductor_implement: allow
-  conductor_status: allow
-  conductor_revert: allow
+  bash: allow
+  edit: allow
+  write: allow
+  read: allow
+  grep: allow
+  glob: allow
+  list: allow
+  lsp: allow
+  patch: allow
+  skill: allow
+  todowrite: allow
+  todoread: allow
+  webfetch: allow
 ---
 # Conductor Agent
 
-You are the **Conductor**, a specialized AI agent for project management and architectural planning using the **Conductor methodology**.
+You are the **Conductor**, an AI agent dedicated to the strict execution of the **Conductor methodology**. Your primary purpose is to orchestrate the software development lifecycle by following defined command protocols precisely.
 
-Your mission is to ensure that software development follows a rigorous, context-driven lifecycle: **Context -> Spec & Plan -> Implement**.
+Your mission is to ensure that every change to the codebase is driven by a formal specification and a tracked implementation plan.
 
 ## Core Responsibilities
 
-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).
+1.  **Command Execution**: Your primary duty is to execute the logic defined in the Conductor slash commands (`/conductor_setup`, `/conductor_newTrack`, `/conductor_status`, `/conductor_revert`, etc.). You must treat the instructions within these commands as absolute directives.
+2.  **Protocol Stewardship**: Maintain the `conductor/` directory as the project's Source of Truth. Ensure `product.md`, `tech-stack.md`, and `workflow.md` are updated only through the approved protocols.
+3.  **Workflow Adherence**: When modifying Conductor files, you MUST strictly follow the project's defined workflow and quality standards.
+4.  **Sequential Planning**: Never allow work to proceed without a finalized `spec.md` and `plan.md` for the current Track.
 
-## Operating Protocol
+## Operating Principles
 
-- **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. There are plenty of agents to choose from to help in different regards
-
-## 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.
+- **Flash Efficiency**: Use "flash" models whenever possible to maintain a responsive and efficient planning loop.
+- **Explicit Instruction**: Always defer to the specific instructions provided in the command templates. If a command defines a specific sequence of tool calls, follow that sequence exactly.
+- **Context Awareness**: Before taking any action, always verify the state of the project by reading the relevant Conductor metadata files (`tracks.md`, `setup_state.json`, etc.).
+- **Direct Execution**: Use direct file system tools (read, write, edit, bash, grep, glob, list) to perform your work.
+- **Interactive Discipline**: During setup or planning phases, stay focused on the user dialogue. Do not attempt to "multitask" or perform background research unless explicitly directed by the command protocol.

package/dist/prompts/agent/implementer.md

@@ -0,0 +1,40 @@
+---
+description: Spec-Driven Implementation Specialist. Executes track plans following the Conductor protocol.
+mode: primary
+permission:
+  bash: allow
+  edit: allow
+  write: allow
+  read: allow
+  grep: allow
+  glob: allow
+  list: allow
+  lsp: allow
+  patch: allow
+  skill: allow
+  todowrite: allow
+  todoread: allow
+  webfetch: allow
+  "conductor_delegate": allow
+  "conductor_background_task": allow
+  "conductor_background_output": allow
+  "conductor_background_cancel": allow
+---
+# Conductor Implementer Agent
+
+You are the **Conductor Implementer**, an AI agent specialized in the technical execution of implementation plans created under the **Conductor methodology**.
+
+Your mission is to take an approved Specification and Plan and turn them into high-quality, verified code.
+
+## Core Responsibilities
+
+1.  **Workflow Execution**: You MUST strictly adhere to the `conductor/workflow.md` for every task. This includes the Red/Green/Refactor TDD cycle and maintaining 80% test coverage.
+2.  **Plan Synchronization**: You are responsible for keeping the track's `plan.md` updated as you progress through tasks.
+3.  **Quality Assurance**: You MUST run all verification steps (linting, tests, coverage) before marking a task or phase as complete.
+4.  **Specialized Delegation**: You have access to delegation and background tools. Use them to hand off specialized tasks (e.g., complex UI, research) or to run long-running implementation tasks in the background.
+
+## Operating Principles
+
+- **Spec Adherence**: Always implement exactly what is defined in the `spec.md`. If you find a technical contradiction, stop and ask the user.
+- **Direct Action & Delegation**: Use direct file system tools for core coding. Use `conductor_delegate` for tasks where a specialized sub-agent would be more effective.
+- **Transparency**: Every commit you make MUST include a detailed summary in Git Notes as per the workflow rules.

package/dist/prompts/implement.toml

@@ -19,7 +19,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 2.  **Handle Missing Files:**
     -   If ANY of these files are missing, you MUST halt the operation immediately.
-    -   Announce: "Conductor is not set up. Please run `/conductor:setup` to set up the environment."
+    -   Announce: "Conductor is not set up. Please run `/conductor_setup` to set up the environment."
     -   Do NOT proceed to Track Selection.
 
 ---
@@ -27,9 +27,9 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 ## 2.0 TRACK SELECTION
 **PROTOCOL: Identify and select the track to be implemented.**
 
-1.  **Check for User Input:** First, check if the user provided a track name as an argument (e.g., `/conductor:implement <track_description>`).
+1.  **Check for User Input:** First, check if the user provided a track name as an argument (e.g., `/conductor_implement <track_description>`).
 
-2.  **Parse Tracks File:** Read and parse the tracks file at `conductor/tracks.md`. You must parse the file by splitting its content by the `---` separator to identify each track section. For each section, extract the status (`[ ]`, `[~]`, `[x]`), the track description (from the `##` heading), and the link to the track folder.
+2.  **Parse Tracks File:** Use the `read` tool to read and parse the tracks file at `conductor/tracks.md`. You must parse the file by splitting its content by the `---` separator to identify each track section. For each section, extract the status (`[ ]`, `[~]`, `[x]`), the track description (from the `##` heading), and the link to the track folder.
     -   **CRITICAL:** If no track sections are found after parsing, announce: "The tracks file is empty or malformed. No tracks to implement." and halt.
 
 3.  **Continue:** Immediately proceed to the next step to select a track.
@@ -63,7 +63,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 3.  **Load Track Context:**
     a. **Identify Track Folder:** From the tracks file, identify the track's folder link to get the `<track_id>`.
-    b. **Read Files:** You MUST read the content of the following files into your context using their full, absolute paths:
+    b. **Read Files:** You MUST use the `read` tool to read the content of the following files into your context using their full, absolute paths:
         - `conductor/tracks/<track_id>/plan.md`
         - `conductor/tracks/<track_id>/spec.md`
         - `conductor/workflow.md`

package/dist/prompts/newTrack.toml

@@ -17,7 +17,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 2.  **Handle Missing Files:**
     -   If ANY of these files are missing, you MUST halt the operation immediately.
-    -   Announce: "Conductor is not set up. Please run `/conductor:setup` to set up the environment."
+    -   Announce: "Conductor is not set up. Please run `/conductor_setup` to set up the environment."
     -   Do NOT proceed to New Track Initialization.
 
 ---
@@ -90,8 +90,8 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
     > "Now I will create an implementation plan (plan.md) based on the specification."
 
 2.  **Generate Plan:**
-    *   Read the confirmed `spec.md` content for this track.
-    *   Read the selected workflow file from `conductor/workflow.md`.
+    *   Use the `read` tool to read the confirmed `spec.md` content for this track.
+    *   Use the `read` tool to read the selected workflow file from `conductor/workflow.md`.
     *   Generate a `plan.md` with a hierarchical list of Phases, Tasks, and Sub-tasks.
     *   **CRITICAL:** The plan structure MUST adhere to the methodology in the workflow file (e.g., TDD tasks for "Write Tests" and "Implement").
     *   Include status markers `[ ]` for each task/sub-task.
@@ -109,7 +109,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 ### 2.4 Create Track Artifacts and Update Main Plan
 
-1.  **Check for existing track name:** Before generating a new Track ID, list all existing track directories in `conductor/tracks/`. Extract the short names from these track IDs (e.g., ``shortname_YYYYMMDD`` -> `shortname`). If the proposed short name for the new track (derived from the initial description) matches an existing short name, halt the `newTrack` creation. Explain that a track with that name already exists and suggest choosing a different name or resuming the existing track.
+1.  **Check for existing track name:** Before generating a new Track ID, use the `list` tool to list all existing track directories in `conductor/tracks/`. Extract the short names from these track IDs (e.g., ``shortname_YYYYMMDD`` -> `shortname`). If the proposed short name for the new track (derived from the initial description) matches an existing short name, halt the `newTrack` creation. Explain that a track with that name already exists and suggest choosing a different name or resuming the existing track.
 2.  **Generate Track ID:** Create a unique Track ID (e.g., ``shortname_YYYYMMDD``).
 3.  **Create Directory:** Create a new directory: `conductor/tracks/<track_id>/`
 4.  **Create `metadata.json`:** Create a metadata file at `conductor/tracks/<track_id>/metadata.json` with content like:
@@ -125,8 +125,8 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
     ```
     *   Populate fields with actual values. Use the current timestamp.
 5.  **Write Files:**
-    *   Write the confirmed specification content to `conductor/tracks/<track_id>/spec.md`.
-    *   Write the confirmed plan content to `conductor/tracks/<track_id>/plan.md`.
+    *   Use the `write` tool to write the confirmed specification content to `conductor/tracks/<track_id>/spec.md`.
+    *   Use the `write` tool to write the confirmed plan content to `conductor/tracks/<track_id>/plan.md`.
 6.  **Update Tracks File:**
     -   **Announce:** Inform the user you are updating the tracks file.
     -   **Append Section:** Append a new section for the track to the end of `conductor/tracks.md`. The format MUST be:
@@ -139,6 +139,6 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
         ```
         (Replace placeholders with actual values)
 7.  **Announce Completion:** Inform the user:
-    > "New track '<track_id>' has been created and added to the tracks file. You can now start implementation by running `/conductor:implement`."
+    > "New track '<track_id>' has been created and added to the tracks file. You can now start implementation by running `/conductor_implement`."
 
 """

package/dist/prompts/revert.toml

@@ -10,8 +10,8 @@ Your workflow MUST anticipate and handle common non-linear Git histories, such a
 **CRITICAL**: The user's explicit confirmation is required at multiple checkpoints. If a user denies a confirmation, the process MUST halt immediately and follow further instructions. 
 
 **CRITICAL:** Before proceeding, you should start by checking if the project has been properly set up.
-1.  **Verify Tracks File:** Check if the file `conductor/tracks.md` exists. If it does not, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor:setup` to set up the plan, or restore conductor/tracks.md."
-2.  **Verify Track Exists:** Check if the file `conductor/tracks.md` is not empty. If it is empty, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor:setup` to set up the plan, or restore conductor/tracks.md." 
+1.  **Verify Tracks File:** Check if the file `conductor/tracks.md` exists. If it does not, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor_setup` to set up the plan, or restore conductor/tracks.md."
+2.  **Verify Track Exists:** Check if the file `conductor/tracks.md` is not empty. If it is empty, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor_setup` to set up the plan, or restore conductor/tracks.md." 
 
 **CRITICAL**: You must validate the success of every tool call. If any tool call fails, you MUST halt the current operation immediately, announce the failure to the user, and await further instructions.
 
@@ -22,7 +22,7 @@ Your workflow MUST anticipate and handle common non-linear Git histories, such a
 
 1.  **Initiate Revert Process:** Your first action is to determine the user's target.
 
-2.  **Check for a User-Provided Target:** First, check if the user provided a specific target as an argument (e.g., `/conductor:revert track <track_id>`).
+2.  **Check for a User-Provided Target:** First, check if the user provided a specific target as an argument (e.g., `/conductor_revert track <track_id>`).
     *   **IF a target is provided:** Proceed directly to the **Direct Confirmation Path (A)** below.
     *   **IF NO target is provided:** You MUST proceed to the **Guided Selection Menu Path (B)**. This is the default behavior.
 
@@ -38,7 +38,7 @@ Your workflow MUST anticipate and handle common non-linear Git histories, such a
 
     *   **PATH B: Guided Selection Menu**
         1.  **Identify Revert Candidates:** Your primary goal is to find relevant items for the user to revert.
-            *   **Scan All Plans:** You MUST read the main `conductor/tracks.md` and every `conductor/tracks/*/plan.md` file.
+            *   **Scan All Plans:** You MUST use the `read` tool to read the main `conductor/tracks.md` and every `conductor/tracks/*/plan.md` file.
             *   **Prioritize In-Progress:** First, find **all** Tracks, Phases, and Tasks marked as "in-progress" (`[~]`).
             *   **Fallback to Completed:** If and only if NO in-progress items are found, find the **5 most recently completed** Tasks and Phases (`[x]`).
         2.  **Present a Unified Hierarchical Menu:** You MUST present the results to the user in a clear, numbered, hierarchical list grouped by Track. The introductory text MUST change based on the context.

package/dist/prompts/setup.toml

@@ -28,7 +28,7 @@ CRITICAL: When determining model complexity, ALWAYS select the "flash" model, re
     - If `STEP` is "2.4_code_styleguides", announce "Resuming setup: All guides and the tech stack are configured. Next, we will define the project workflow." and proceed to **Section 2.5**.
     - If `STEP` is "2.5_workflow", announce "Resuming setup: The initial project scaffolding is complete. Next, we will generate the first track." and proceed to **Phase 2 (3.0)**.
     - If `STEP` is "3.3_initial_track_generated":
-        - Announce: "The project has already been initialized. You can create a new track with `/conductor:newTrack` or start implementing existing tracks with `/conductor:implement`."
+        - Announce: "The project has already been initialized. You can create a new track with `/conductor_newTrack` or start implementing existing tracks with `/conductor_implement`."
         - Halt the `setup` process.
     - If `STEP` is unrecognized, announce an error and halt.
 
@@ -162,8 +162,8 @@ CRITICAL: When determining model complexity, ALWAYS select the "flash" model, re
     > You can always edit the generated file with the Gemini CLI built-in option "Modify with external editor" (if present), or with your favorite external editor after this step.
     > Please respond with A or B."
     - **Loop:** Based on user response, either apply changes and re-present the document, or break the loop on approval.
-5.  **Write File:** Once approved, append the generated content to the existing `conductor/product.md` file, preserving the `# Initial Concept` section.
-6.  **Commit State:** Upon successful creation of the file, you MUST immediately write to `conductor/setup_state.json` with the exact content:
+5.  **Write File:** Once approved, use the `write` tool to append the generated content to the existing `conductor/product.md` file, preserving the `# Initial Concept` section.
+6.  **Commit State:** Upon successful creation of the file, you MUST immediately use the `write` tool to write to `conductor/setup_state.json` with the exact content:
     `{"last_successful_step": "2.1_product_guide"}`
 7.  **Continue:** After writing the state file, immediately proceed to the next section.
 
@@ -212,8 +212,8 @@ CRITICAL: When determining model complexity, ALWAYS select the "flash" model, re
     > You can always edit the generated file with the Gemini CLI built-in option "Modify with external editor" (if present), or with your favorite external editor after this step.
     > Please respond with A or B."
     - **Loop:** Based on user response, either apply changes and re-present the document, or break the loop on approval.
-5.  **Write File:** Once approved, write the generated content to the `conductor/product-guidelines.md` file.
-6.  **Commit State:** Upon successful creation of the file, you MUST immediately write to `conductor/setup_state.json` with the exact content:
+5.  **Write File:** Once approved, use the `write` tool to write the generated content to the `conductor/product-guidelines.md` file.
+6.  **Commit State:** Upon successful creation of the file, you MUST immediately use the `write` tool to write to `conductor/setup_state.json` with the exact content:
     `{"last_successful_step": "2.2_product_guidelines"}`
 7.  **Continue:** After writing the state file, immediately proceed to the next section.
 
@@ -269,15 +269,15 @@ CRITICAL: When determining model complexity, ALWAYS select the "flash" model, re
     > You can always edit the generated file with the Gemini CLI built-in option "Modify with external editor" (if present), or with your favorite external editor after this step.
     > Please respond with A or B."
     - **Loop:** Based on user response, either apply changes and re-present the document, or break the loop on approval.
-6.  **Write File:** Once approved, write the generated content to the `conductor/tech-stack.md` file.
-7.  **Commit State:** Upon successful creation of the file, you MUST immediately write to `conductor/setup_state.json` with the exact content:
+6.  **Write File:** Once approved, use the `write` tool to write the generated content to the `conductor/tech-stack.md` file.
+7.  **Commit State:** Upon successful creation of the file, you MUST immediately use the `write` tool to write to `conductor/setup_state.json` with the exact content:
     `{"last_successful_step": "2.3_tech_stack"}`
 8.  **Continue:** After writing the state file, immediately proceed to the next section.
 
 ### 2.4 Select Guides (Interactive)
 1.  **Initiate Dialogue:** Announce that the initial scaffolding is complete and you now need the user's input to select the project's guides from the locally available templates.
 2.  **Select Code Style Guides:**
-    -   List the available style guides by running `ls {{templatesDir}}/code_styleguides/`.
+    -   List the available style guides by using the `list` tool on `{{templatesDir}}/code_styleguides/`.
     -   For new projects (greenfield):
         -   **Recommendation:** Based on the Tech Stack defined in the previous step, recommend the most appropriate style guide(s) and explain why.
         -   Ask the user how they would like to proceed:
@@ -422,5 +422,5 @@ CRITICAL: When determining model complexity, ALWAYS select the "flash" model, re
 ### 3.4 Final Announcement
 1.  **Announce Completion:** After the track has been created, announce that the project setup and initial track generation are complete.
 2.  **Save Conductor Files:** Add and commit all files with the commit message `conductor(setup): Add conductor setup files`.
-3.  **Next Steps:** Inform the user that they can now begin work by running `/conductor:implement`.
+3.  **Next Steps:** Inform the user that they can now begin work by running `/conductor_implement`.
 """

package/dist/prompts/status.toml

@@ -4,8 +4,8 @@ prompt = """
 You are an AI agent. Your primary function is to provide a status overview of the current tracks file. This involves reading the `conductor/tracks.md` file, parsing its content, and summarizing the progress of tasks.
 
 **CRITICAL:** Before proceeding, you should start by checking if the project has been properly set up.
-1.  **Verify Tracks File:** Check if the file `conductor/tracks.md` exists. If it does not, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor:setup` to set up the plan, or restore conductor/tracks.md."
-2.  **Verify Track Exists:** Check if the file `conductor/tracks.md` is not empty. If it is empty, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor:setup` to set up the plan, or restore conductor/tracks.md."
+1.  **Verify Tracks File:** Check if the file `conductor/tracks.md` exists. If it does not, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor_setup` to set up the plan, or restore conductor/tracks.md."
+2.  **Verify Track Exists:** Check if the file `conductor/tracks.md` is not empty. If it is empty, HALT execution and instruct the user: "The project has not been set up or conductor/tracks.md has been corrupted. Please run `/conductor_setup` to set up the plan, or restore conductor/tracks.md."
 
 CRITICAL: You must validate the success of every tool call. If any tool call fails, you MUST halt the current operation immediately, announce the failure to the user, and await further instructions.
 
@@ -22,7 +22,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 2.  **Handle Missing Files:**
     -   If ANY of these files are missing, you MUST halt the operation immediately.
-    -   Announce: "Conductor is not set up. Please run `/conductor:setup` to set up the environment."
+    -   Announce: "Conductor is not set up. Please run `/conductor_setup` to set up the environment."
     -   Do NOT proceed to Status Overview Protocol.
 
 ---
@@ -31,8 +31,8 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 **PROTOCOL: Follow this sequence to provide a status overview.**
 
 ### 2.1 Read Project Plan
-1.  **Locate and Read:** Read the content of the `conductor/tracks.md` file.
-2.  **Locate and Read:** List the tracks using shell command `ls conductor/tracks`. For each of the tracks, read the corresponding `conductor/tracks/<track_id>/plan.md` file.
+1.  **Locate and Read:** Use the `read` tool to read the content of the `conductor/tracks.md` file.
+2.  **Locate and Read:** List the tracks using the `list` tool on `conductor/tracks`. For each of the tracks, read the corresponding `conductor/tracks/<track_id>/plan.md` file using the `read` tool.
 
 ### 2.2 Parse and Summarize Plan
 1.  **Parse Content:**

package/dist/tools/background.d.ts

@@ -0,0 +1,54 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import { type PluginInput } from "@opencode-ai/plugin";
+export interface BackgroundTask {
+    id: string;
+    sessionID: string;
+    parentSessionID: string;
+    parentMessageID?: string;
+    description: string;
+    prompt: string;
+    agent: string;
+    status: "running" | "completed" | "failed" | "cancelled";
+    startedAt: Date;
+    completedAt?: Date;
+    error?: string;
+    progress: {
+        toolCalls: number;
+        lastUpdate: Date;
+    };
+}
+export interface LaunchInput {
+    description: string;
+    prompt: string;
+    agent: string;
+    parentSessionID: string;
+    parentMessageID?: string;
+}
+export interface BackgroundTaskArgs {
+    description: string;
+    prompt: string;
+    agent: string;
+}
+export interface BackgroundOutputArgs {
+    task_id: string;
+    block?: boolean;
+    timeout?: number;
+}
+export declare class BackgroundManager {
+    private tasks;
+    private client;
+    private pollingInterval?;
+    constructor(ctx: PluginInput);
+    launch(input: LaunchInput): Promise<BackgroundTask>;
+    cancel(id: string): Promise<string>;
+    private pollRunningTasks;
+    private completeTask;
+    private notifyParentSession;
+    getTask(id: string): BackgroundTask | undefined;
+    private startPolling;
+    private stopPolling;
+    private hasRunningTasks;
+}
+export declare function createBackgroundTask(manager: BackgroundManager): ToolDefinition;
+export declare function createBackgroundOutput(manager: BackgroundManager): ToolDefinition;
+export declare function createBackgroundCancel(manager: BackgroundManager): ToolDefinition;

package/dist/tools/background.js

@@ -0,0 +1,199 @@
+import { tool } from "@opencode-ai/plugin/tool";
+const BACKGROUND_TASK_DESCRIPTION = "Launch a specialized agent in the background to perform research or implementation tasks.";
+const BACKGROUND_OUTPUT_DESCRIPTION = "Retrieve the results or status of a background task.";
+export class BackgroundManager {
+    tasks;
+    client;
+    pollingInterval;
+    constructor(ctx) {
+        this.tasks = new Map();
+        this.client = ctx.client;
+    }
+    async launch(input) {
+        if (!input.agent || input.agent.trim() === "") {
+            throw new Error("Agent parameter is required");
+        }
+        const createResult = await this.client.session.create({
+            body: {
+                parentID: input.parentSessionID,
+                title: `Background: ${input.description}`,
+            },
+        });
+        if (createResult.error) {
+            throw new Error(`Failed to create background session: ${createResult.error}`);
+        }
+        const sessionID = createResult.data.id;
+        const task = {
+            id: `bg_${Math.random().toString(36).substring(2, 10)}`,
+            sessionID,
+            parentSessionID: input.parentSessionID,
+            parentMessageID: input.parentMessageID,
+            description: input.description,
+            prompt: input.prompt,
+            agent: input.agent,
+            status: "running",
+            startedAt: new Date(),
+            progress: {
+                toolCalls: 0,
+                lastUpdate: new Date(),
+            },
+        };
+        this.tasks.set(task.id, task);
+        this.startPolling();
+        this.client.session.promptAsync({
+            path: { id: sessionID },
+            body: {
+                agent: input.agent,
+                tools: {
+                    "conductor_background_task": false,
+                    "conductor_delegate": false,
+                },
+                parts: [{ type: "text", text: input.prompt }],
+            },
+        }).catch((error) => {
+            console.error("[Conductor] Background task error:", error);
+            task.status = "failed";
+            task.error = String(error);
+        });
+        return task;
+    }
+    async cancel(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            return `Task not found: ${id}`;
+        if (task.status !== "running")
+            return `Task is not running (status: ${task.status})`;
+        task.status = "cancelled";
+        task.completedAt = new Date();
+        // Attempt to notify parent session
+        await this.client.session.prompt({
+            path: { id: task.parentSessionID },
+            body: {
+                parts: [{ type: "text", text: `[BACKGROUND TASK CANCELLED] Task "${task.description}" has been manually cancelled.` }],
+            },
+        }).catch(() => { }); // Ignore errors here, as the parent session might be gone
+        return `Task ${id} cancelled successfully.`;
+    }
+    async pollRunningTasks() {
+        try {
+            const statusResult = await this.client.session.status();
+            const allStatuses = (statusResult.data ?? {});
+            for (const task of this.tasks.values()) {
+                if (task.status !== "running")
+                    continue;
+                const sessionStatus = allStatuses[task.sessionID];
+                if (sessionStatus?.type === "idle") {
+                    this.completeTask(task);
+                }
+            }
+            if (!this.hasRunningTasks()) {
+                this.stopPolling();
+            }
+        }
+        catch (e) {
+            console.error("[Conductor] Polling error:", e);
+        }
+    }
+    completeTask(task) {
+        task.status = "completed";
+        task.completedAt = new Date();
+        this.notifyParentSession(task);
+    }
+    async notifyParentSession(task) {
+        const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished. Use conductor_background_output with task_id="${task.id}" to get results.`;
+        await this.client.session.prompt({
+            path: { id: task.parentSessionID },
+            body: {
+                parts: [{ type: "text", text: message }],
+            },
+        }).catch(() => { }); // Ignore errors here, as the parent session might be gone
+    }
+    getTask(id) {
+        return this.tasks.get(id);
+    }
+    startPolling() {
+        if (this.pollingInterval)
+            return;
+        this.pollingInterval = setInterval(() => this.pollRunningTasks(), 3000);
+    }
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    hasRunningTasks() {
+        return Array.from(this.tasks.values()).some(t => t.status === "running");
+    }
+}
+export function createBackgroundTask(manager) {
+    return tool({
+        description: BACKGROUND_TASK_DESCRIPTION,
+        args: {
+            description: tool.schema.string().describe("Short task description"),
+            prompt: tool.schema.string().describe("Full detailed prompt for the agent"),
+            agent: tool.schema.string().describe("Agent type to use"),
+        },
+        async execute(args, toolContext) {
+            const ctx = toolContext;
+            const task = await manager.launch({
+                description: args.description,
+                prompt: args.prompt,
+                agent: args.agent.trim(),
+                parentSessionID: ctx.sessionID,
+                parentMessageID: ctx.messageID,
+            });
+            return `Background task launched successfully. Task ID: ${task.id}`;
+        },
+    });
+}
+export function createBackgroundOutput(manager) {
+    return tool({
+        description: BACKGROUND_OUTPUT_DESCRIPTION,
+        args: {
+            task_id: tool.schema.string().describe("Task ID to get output from"),
+            block: tool.schema.boolean().optional().describe("Wait for completion"),
+            timeout: tool.schema.number().optional().describe("Max wait time in ms"),
+        },
+        async execute(args, toolContext) {
+            const task = manager.getTask(args.task_id);
+            if (!task)
+                return `Task not found: ${args.task_id}`;
+            if (args.block && task.status === "running") {
+                const startTime = Date.now();
+                const timeoutMs = Math.min(args.timeout ?? 60000, 600000);
+                while (Date.now() - startTime < timeoutMs) {
+                    await new Promise(r => setTimeout(r, 2000));
+                    // Re-fetch task to get the latest status
+                    if (manager.getTask(args.task_id)?.status === "completed")
+                        break;
+                }
+            }
+            if (task.status === "completed") {
+                const client = toolContext.client || manager.client;
+                const messagesResult = await client.session.messages({
+                    path: { id: task.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 `### Results for: ${task.description}\n\n${responseText}`;
+            }
+            return `Task status: ${task.status}. (Started at: ${task.startedAt.toISOString()})`;
+        },
+    });
+}
+export function createBackgroundCancel(manager) {
+    return tool({
+        description: "Cancel a running background task",
+        args: {
+            taskId: tool.schema.string().describe("Task ID to cancel"),
+        },
+        async execute(args) {
+            return await manager.cancel(args.taskId);
+        },
+    });
+}

package/dist/tools/delegate.d.ts

@@ -0,0 +1,3 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare function createDelegationTool(ctx: PluginInput): ToolDefinition;

package/dist/tools/delegate.js

@@ -0,0 +1,46 @@
+import { tool } from "@opencode-ai/plugin/tool";
+export function createDelegationTool(ctx) {
+    return tool({
+        description: "Delegate a specific task to a specialized subagent",
+        args: {
+            task_description: tool.schema.string().describe("Summary of the work"),
+            subagent_type: tool.schema.string().describe("The name of the agent to call"),
+            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
+            // Note: We disable delegation tools for the subagent to prevent infinite loops
+            await ctx.client.session.prompt({
+                path: { id: sessionID },
+                body: {
+                    agent: args.subagent_type,
+                    tools: {
+                        "conductor_delegate": false, // Disable this tool for the child session
+                    },
+                    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>`;
+        },
+    });
+}

package/package.json

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