opencode-conductor-plugin 1.15.0 → 1.17.0

package/dist/index.js

@@ -1,28 +1,24 @@
 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) => {
+    try {
+        if (existsSync(path))
+            return await readFile(path, "utf-8");
+    }
+    catch (e) { }
+    return null;
+};
 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 {
@@ -34,8 +30,7 @@ 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")
+                    templatesDir: join(dirname(__dirname), "templates"),
                 };
                 const finalReplacements = { ...defaults, ...replacements };
                 for (const [key, value] of Object.entries(finalReplacements)) {
@@ -45,10 +40,13 @@ const ConductorPlugin = async (ctx) => {
             }
             catch (error) {
                 console.error(`[Conductor] Error loading prompt ${filename}:`, error);
-                return { prompt: `SYSTEM ERROR: Failed to load prompt ${filename}`, description: "Error loading command" };
+                return {
+                    prompt: `SYSTEM ERROR: Failed to load prompt ${filename}`,
+                    description: "Error loading command",
+                };
             }
         };
-        // 3. Load Strategies
+        // 2. Load Strategies
         let strategySection = "";
         try {
             const strategyFile = "manual.md"; // Force manual strategy for now
@@ -58,74 +56,165 @@ const ConductorPlugin = async (ctx) => {
         catch (e) {
             strategySection = "SYSTEM ERROR: Could not load execution strategy.";
         }
-        // 4. Load all Command Prompts (Parallel)
-        const [setup, newTrack, implement, status, revert] = await Promise.all([
+        // 3. Load all Command Prompts (Parallel)
+        const [setup, newTrack, implement, status, revert, workflowMd] = await Promise.all([
             loadPrompt("setup.toml"),
             loadPrompt("newTrack.toml", { args: "$ARGUMENTS" }),
-            loadPrompt("implement.toml", { track_name: "$ARGUMENTS", strategy_section: strategySection }),
+            loadPrompt("implement.toml", {
+                track_name: "$ARGUMENTS",
+                strategy_section: strategySection,
+            }),
             loadPrompt("status.toml"),
-            loadPrompt("revert.toml", { target: "$ARGUMENTS" })
+            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": { template: setup.prompt, description: setup.description, agent: "conductor" },
-                    "conductor:newTrack": { template: newTrack.prompt, description: newTrack.description, agent: "conductor" },
-                    "conductor:implement": { template: implement.prompt, description: implement.description },
-                    "conductor:status": { template: status.prompt, description: status.description, agent: "conductor" },
-                    "conductor:revert": { template: revert.prompt, description: revert.description, agent: "conductor" }
+                    "conductor:setup": {
+                        template: setup.prompt,
+                        description: setup.description,
+                        agent: "conductor",
+                    },
+                    "conductor:newTrack": {
+                        template: newTrack.prompt,
+                        description: newTrack.description,
+                        agent: "conductor",
+                    },
+                    "conductor:implement": {
+                        template: implement.prompt,
+                        description: implement.description,
+                        agent: "conductor_implementer",
+                    },
+                    "conductor:status": {
+                        template: status.prompt,
+                        description: status.description,
+                        agent: "conductor",
+                    },
+                    "conductor:revert": {
+                        template: revert.prompt,
+                        description: revert.description,
+                        agent: "conductor",
+                    },
                 };
                 config.agent = {
                     ...(config.agent || {}),
-                    "conductor": {
-                        description: "Spec-Driven Development Architect.",
+                    conductor: {
+                        description: "Conductor Protocol Steward.",
                         mode: "primary",
-                        prompt: agentPrompt,
+                        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"
-                        }
-                    }
+                            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,
+                        },
+                    },
                 };
             },
             "tool.execute.before": async (input, output) => {
-                if (input.tool === "delegate_to_agent") {
-                    const agentName = (output.args.agent_name || output.args.agent || "");
-                    // Sisyphus must be capital S
-                    if (agentName.includes("Sisyphus")) {
-                        const conductorDir = join(ctx.directory, "conductor");
-                        const safeRead = async (path) => {
-                            try {
-                                if (existsSync(path))
-                                    return await readFile(path, "utf-8");
-                            }
-                            catch (e) { }
-                            return null;
-                        };
-                        const workflowMd = await safeRead(join(conductorDir, "workflow.md"));
+                const delegationTools = [
+                    "delegate_to_agent",
+                    "task",
+                    "background_task",
+                    "conductor:delegate",
+                    "conductor:background_task",
+                ];
+                if (delegationTools.includes(input.tool)) {
+                    const conductorDir = join(ctx.directory, "conductor");
+                    const workflowMd = await safeRead(join(conductorDir, "workflow.md"));
+                    if (workflowMd) {
                         let injection = "\n\n--- [SYSTEM INJECTION: CONDUCTOR CONTEXT PACKET] ---\n";
-                        injection += "You are receiving this task from the Conductor Architect.\n";
-                        if (workflowMd) {
-                            injection += "\n### DEVELOPMENT WORKFLOW\n" + workflowMd + "\n";
-                        }
+                        injection +=
+                            "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";
                         if (implement?.prompt) {
-                            injection += "\n### IMPLEMENTATION PROTOCOL\n" + implement.prompt + "\n";
+                            injection +=
+                                "\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";
+                        injection +=
+                            "\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";
-                        output.args.objective += injection;
+                        // Inject into the primary instruction field depending on the tool's schema
+                        if (typeof output.args.objective === "string") {
+                            output.args.objective += injection;
+                        }
+                        else if (typeof output.args.prompt === "string") {
+                            output.args.prompt += injection;
+                        }
+                        else if (typeof output.args.instruction === "string") {
+                            output.args.instruction += injection;
+                        }
                     }
                 }
-            }
+            },
         };
     }
     catch (err) {

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.
-
-## 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/agent.md

@@ -17,7 +17,7 @@ Your mission is to ensure that software development follows a rigorous, context-
 - **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.
+- **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."

package/dist/prompts/implement.toml

@@ -29,7 +29,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 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

@@ -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:

package/dist/prompts/revert.toml

@@ -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

@@ -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:

package/dist/prompts/status.toml

@@ -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.15.0",
+  "version": "1.17.0",
   "description": "Conductor plugin for OpenCode",
   "type": "module",
   "repository": "derekbar90/opencode-conductor",