opencode-conductor-plugin 1.23.0 → 1.25.0

package/dist/prompts/newTrack.toml

@@ -3,6 +3,8 @@ prompt = """
 ## 1.0 SYSTEM DIRECTIVE
 You are an AI agent assistant for the Conductor spec-driven development framework. Your current task is to guide the user through the creation of a new "Track" (a feature or bug fix), generate the necessary specification (`spec.md`) and plan (`plan.md`) files, and organize them within a dedicated track directory.
 
+CRITICAL: If you are using the 'oh-my-opencode' plugin or any other 'todo-continuation-enforcer', you MUST ignore any prompts to "continue" or "finish tasks" while you are waiting for user input during this interactive track planning. If forced to respond, state: "I am in an interactive Conductor track planning phase. Awaiting user response."
+
 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.
 
 ## 1.1 SETUP CHECK
@@ -15,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.
 
 ---
@@ -107,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 the tracks using shell command `ls 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, 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:
@@ -137,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 use the `read` tool to read the main `conductor/tracks.md` and every `conductor/tracks/*/plan.md` file.
+            *   **Scan All Plans:** You MUST 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, 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:
+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:
     `{"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, 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:
+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:
     `{"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, 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:
+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:
     `{"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 using the `list` tool on `{{templatesDir}}/code_styleguides/`.
+    -   List the available style guides by running `ls {{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.
 
 ---
@@ -32,7 +32,7 @@ CRITICAL: You must validate the success of every tool call. If any tool call fai
 
 ### 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`. Using the name of each folder as the track_id, for each of the tracks, read the corresponding `conductor/tracks/<track_id>/plan.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.
 
 ### 2.2 Parse and Summarize Plan
 1.  **Parse Content:**

package/dist/prompts/strategies/delegate.md

@@ -2,10 +2,8 @@
 You are acting as the **Architect**. Your responsibility is to oversee the track while delegating execution to **Sisyphus**.
 
 **DIRECTIVE:**
-1.  **Execution Strategy:** You have the authority to decide between **direct implementation** and **delegation**.
-    *   **Direct Implementation:** Perform the task yourself if it is straightforward, involves minor changes, or if you are confident in the solution.
-    *   **Delegation:** Delegate to `@sisyphus` for complex, multi-file, or heavy-lifting implementation tasks.
-2.  **Delegation Protocol:** If you choose to delegate, call `@sisyphus`.
+1.  **Do NOT implement code yourself.**
+2.  **Delegate:** For each task in `plan.md`, call `@sisyphus`.
     *   *Note:* The system will automatically inject the full project context for you.
     *   *Instruction:* Tell Sisyphus: "Execute this task. You have authority to update `plan.md` if needed. Report 'PLAN_UPDATED' if you do."
 3.  **Verify:**

package/dist/tools/commands.d.ts

@@ -1,7 +1,11 @@
-import { type PluginInput } from "@opencode-ai/plugin";
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
-export declare function createSetupTool(ctx: PluginInput): ToolDefinition;
-export declare function createNewTrackTool(ctx: PluginInput): ToolDefinition;
-export declare function createImplementTool(ctx: PluginInput): ToolDefinition;
-export declare function createStatusTool(ctx: PluginInput): ToolDefinition;
-export declare function createRevertTool(ctx: PluginInput): ToolDefinition;
+export declare const setupCommand: (ctx: any) => ToolDefinition;
+export declare const newTrackCommand: (ctx: any) => ToolDefinition;
+export declare const implementCommand: (ctx: any) => ToolDefinition;
+export declare const statusCommand: (ctx: any) => ToolDefinition;
+export declare const revertCommand: (ctx: any) => ToolDefinition;
+export declare function createSetupTool(ctx: any): ToolDefinition;
+export declare function createNewTrackTool(ctx: any): ToolDefinition;
+export declare function createImplementTool(ctx: any): ToolDefinition;
+export declare function createStatusTool(ctx: any): ToolDefinition;
+export declare function createRevertTool(ctx: any): ToolDefinition;

package/dist/tools/commands.js

@@ -1,99 +1,82 @@
 import { tool } from "@opencode-ai/plugin/tool";
+import { createConductorCommand } from "../utils/commandFactory.js";
 import { join, dirname } from "path";
-import { readFile } from "fs/promises";
 import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Helper to load and process prompt templates
-async function loadPrompt(filename, replacements = {}) {
-    const promptPath = join(__dirname, "..", "prompts", filename);
-    try {
-        const content = await readFile(promptPath, "utf-8");
-        const descMatch = content.match(/description\s*=\s*"([^"]+)"/);
-        const description = descMatch ? descMatch[1] : "Conductor Command";
-        const promptMatch = content.match(/prompt\s*=\s*"""([\s\S]*?)"""/);
-        let promptText = promptMatch ? promptMatch[1] : "";
-        if (!promptText)
-            throw new Error(`Could not parse prompt text from ${filename}`);
-        const defaults = {
-            templatesDir: join(dirname(dirname(__dirname)), "templates"),
+export const setupCommand = createConductorCommand({
+    name: "setup.toml",
+    description: "Scaffolds the project and sets up the Conductor environment",
+    requiresSetup: false,
+    args: {},
+});
+export const newTrackCommand = createConductorCommand({
+    name: "newTrack.toml",
+    description: "Plans a track, generates track-specific spec documents and updates the tracks file",
+    args: {
+        description: tool.schema.string().optional().describe("Brief description of the track (feature, bug fix, chore, etc.)"),
+    },
+    additionalContext: async (ctx, args) => {
+        return {
+            args: args.description || "",
         };
-        const finalReplacements = { ...defaults, ...replacements };
-        for (const [key, value] of Object.entries(finalReplacements)) {
-            promptText = promptText.replaceAll(`{{${key}}}`, value || "");
+    },
+});
+export const implementCommand = createConductorCommand({
+    name: "implement.toml",
+    description: "Executes the tasks defined in the specified track's plan",
+    args: {
+        track_name: tool.schema.string().optional().describe("Name or description of the track to implement"),
+    },
+    additionalContext: async (ctx, args) => {
+        // 1. Choose strategy based on OMO activity
+        const strategyFile = ctx.isOMOActive ? "delegate.md" : "manual.md";
+        const strategyPath = join(__dirname, "../prompts/strategies", strategyFile);
+        let strategySection = "";
+        try {
+            strategySection = await readFile(strategyPath, "utf-8");
+        }
+        catch (e) {
+            console.warn(`[Conductor] Failed to load strategy ${strategyFile}:`, e);
+            strategySection = "Error: Could not load execution strategy.";
         }
-        return { prompt: promptText, description: description };
-    }
-    catch (error) {
-        console.error(`[Conductor] Error loading prompt ${filename}:`, error);
         return {
-            prompt: `SYSTEM ERROR: Failed to load prompt ${filename}`,
-            description: "Error loading command",
+            strategy_section: strategySection,
+            track_name: args.track_name || "",
         };
-    }
-}
+    },
+});
+export const statusCommand = createConductorCommand({
+    name: "status.toml",
+    description: "Displays the current progress of the project",
+    args: {},
+});
+export const revertCommand = createConductorCommand({
+    name: "revert.toml",
+    description: "Reverts previous work",
+    args: {
+        target: tool.schema.string().optional().describe("Target to revert (e.g., 'track <track_id>', 'phase <phase_name>', 'task <task_name>')"),
+    },
+    additionalContext: async (ctx, args) => {
+        return {
+            target: args.target || "",
+        };
+    },
+});
+// Export as functions for backward compatibility
 export function createSetupTool(ctx) {
-    return tool({
-        description: "Scaffolds the project and sets up the Conductor environment",
-        args: {},
-        async execute(args) {
-            const { prompt } = await loadPrompt("setup.toml");
-            return prompt;
-        },
-    });
+    return setupCommand(ctx);
 }
 export function createNewTrackTool(ctx) {
-    return tool({
-        description: "Plans a track, generates track-specific spec documents and updates the tracks file",
-        args: {
-            description: tool.schema.string().optional().describe("Brief description of the track (feature, bug fix, chore, etc.)"),
-        },
-        async execute(args) {
-            const trackDescription = args.description || "";
-            const { prompt } = await loadPrompt("newTrack.toml", {
-                args: trackDescription,
-            });
-            return prompt;
-        },
-    });
+    return newTrackCommand(ctx);
 }
 export function createImplementTool(ctx) {
-    return tool({
-        description: "Executes the tasks defined in the specified track's plan",
-        args: {
-            track_name: tool.schema.string().optional().describe("Name or description of the track to implement"),
-        },
-        async execute(args) {
-            const trackName = args.track_name || "";
-            const { prompt } = await loadPrompt("implement.toml", {
-                track_name: trackName,
-            });
-            return prompt;
-        },
-    });
+    return implementCommand(ctx);
 }
 export function createStatusTool(ctx) {
-    return tool({
-        description: "Displays the current progress of the project",
-        args: {},
-        async execute(args) {
-            const { prompt } = await loadPrompt("status.toml");
-            return prompt;
-        },
-    });
+    return statusCommand(ctx);
 }
 export function createRevertTool(ctx) {
-    return tool({
-        description: "Reverts previous work",
-        args: {
-            target: tool.schema.string().optional().describe("Target to revert (e.g., 'track <track_id>', 'phase <phase_name>', 'task <task_name>')"),
-        },
-        async execute(args) {
-            const target = args.target || "";
-            const { prompt } = await loadPrompt("revert.toml", {
-                target: target,
-            });
-            return prompt;
-        },
-    });
+    return revertCommand(ctx);
 }

package/dist/tools/commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/commands.test.js

@@ -0,0 +1,151 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createSetupTool, createNewTrackTool, createImplementTool, createStatusTool, createRevertTool, } from "./commands.js";
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+// Mock fs/promises
+vi.mock("fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+// Mock fs
+vi.mock("fs", () => ({
+    existsSync: vi.fn(),
+}));
+describe("Command Tools", () => {
+    let mockCtx;
+    let mockToolContext;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockCtx = {
+            directory: "/test/project",
+            isOMOActive: false,
+        };
+        mockToolContext = {
+            sessionID: "test-session-id",
+            messageID: "test-message-id",
+        };
+        // Default mocks
+        vi.mocked(readFile).mockResolvedValue(`
+description = "Test command"
+prompt = """
+Test prompt content
+"""
+`);
+        vi.mocked(existsSync).mockReturnValue(true); // Assume setup exists by default
+    });
+    describe("createSetupTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createSetupTool(mockCtx);
+            expect(tool.description).toBe("Scaffolds the project and sets up the Conductor environment");
+        });
+        it("should return prompt text when executed", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Setup"
+prompt = "Setup Prompt"
+`);
+            const tool = createSetupTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(result).toBe("Setup Prompt");
+        });
+        it("should NOT require setup to exist", async () => {
+            vi.mocked(existsSync).mockReturnValue(false);
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Setup"
+prompt = "Setup Prompt"
+`);
+            const tool = createSetupTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(result).toBe("Setup Prompt");
+        });
+    });
+    describe("createNewTrackTool", () => {
+        it("should have optional description argument", () => {
+            const tool = createNewTrackTool(mockCtx);
+            expect(tool.args).toHaveProperty("description");
+        });
+        it("should replace description in prompt", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "New Track"
+prompt = "Track description: {{args}}"
+`);
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({ description: "Login feature" }, mockToolContext);
+            expect(result).toBe("Track description: Login feature");
+        });
+        it("should return error if not set up", async () => {
+            vi.mocked(existsSync).mockReturnValue(false);
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(result).toContain("Conductor is not set up");
+        });
+    });
+    describe("createImplementTool", () => {
+        it("should have optional track_name argument", () => {
+            const tool = createImplementTool(mockCtx);
+            expect(tool.args).toHaveProperty("track_name");
+        });
+        it("should replace track_name in prompt", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Implement"
+prompt = "Track: {{track_name}}"
+`);
+            const tool = createImplementTool(mockCtx);
+            const result = await tool.execute({ track_name: "auth-track" }, mockToolContext);
+            expect(result).toBe("Track: auth-track");
+        });
+        it("should include strategy section", async () => {
+            vi.mocked(readFile).mockImplementation(async (path) => {
+                if (typeof path === 'string' && path.endsWith("manual.md")) {
+                    return "Manual Strategy";
+                }
+                return `
+description = "Implement"
+prompt = "Strategy: {{strategy_section}}"
+`;
+            });
+            const tool = createImplementTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(result).toBe("Strategy: Manual Strategy");
+        });
+    });
+    describe("createStatusTool", () => {
+        it("should execute and return prompt", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Status"
+prompt = "Status Prompt"
+`);
+            const tool = createStatusTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(result).toBe("Status Prompt");
+        });
+    });
+    describe("createRevertTool", () => {
+        it("should replace target in prompt", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Revert"
+prompt = "Target: {{target}}"
+`);
+            const tool = createRevertTool(mockCtx);
+            const result = await tool.execute({ target: "track 1" }, mockToolContext);
+            expect(result).toBe("Target: track 1");
+        });
+    });
+    describe("Error Handling", () => {
+        it("should throw error if readFile fails", async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error("File not found"));
+            const tool = createSetupTool(mockCtx);
+            await expect(tool.execute({}, mockToolContext)).rejects.toThrow("Failed to load prompt");
+        });
+    });
+    describe("Prompt Replacement", () => {
+        it("should replace standard variables", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Test"
+prompt = "Templates: {{templatesDir}}, OMO: {{isOMOActive}}"
+`);
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(result).toContain("Templates:");
+            expect(result).toContain("OMO: false");
+        });
+    });
+});

package/dist/utils/commandFactory.d.ts

@@ -0,0 +1,10 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+interface CommandOptions {
+    name: string;
+    description: string;
+    args?: any;
+    requiresSetup?: boolean;
+    additionalContext?: (ctx: any, args: any) => Promise<Record<string, string>>;
+}
+export declare const createConductorCommand: (options: CommandOptions) => (ctx: any) => ToolDefinition;
+export {};

package/dist/utils/commandFactory.js

@@ -0,0 +1,47 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { parse } from "smol-toml";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const createConductorCommand = (options) => (ctx) => tool({
+    description: options.description,
+    args: options.args || {},
+    async execute(args) {
+        // 1. Setup Check
+        if (options.requiresSetup !== false) {
+            const conductorDir = join(ctx.directory, "conductor");
+            if (!existsSync(join(conductorDir, "product.md"))) {
+                return "Conductor is not set up. Please run `conductor_setup`.";
+            }
+        }
+        // 2. Load Prompt from TOML
+        const promptPath = join(__dirname, "../prompts", options.name);
+        let promptText = "";
+        try {
+            const content = await readFile(promptPath, "utf-8");
+            const parsed = parse(content);
+            promptText = parsed.prompt;
+        }
+        catch (error) {
+            throw new Error(`Failed to load prompt from ${promptPath}: ${error}`);
+        }
+        // 3. Prepare Replacements
+        const replacements = {
+            isOMOActive: ctx.isOMOActive ? "true" : "false",
+            templatesDir: join(dirname(dirname(__dirname)), "dist/templates") // Fixing template path for setup
+        };
+        // 4. Inject Additional Context (e.g. from args)
+        if (options.additionalContext) {
+            const extra = await options.additionalContext(ctx, args);
+            Object.assign(replacements, extra);
+        }
+        // 5. Apply Replacements
+        for (const [key, value] of Object.entries(replacements)) {
+            promptText = promptText.replaceAll(`{{${key}}}`, value || "");
+        }
+        return promptText;
+    },
+});

package/dist/utils/stateManager.d.ts

@@ -0,0 +1,10 @@
+export interface SetupState {
+    last_successful_step: string;
+}
+export declare class StateManager {
+    private statePath;
+    constructor(workDir: string);
+    ensureConductorDir(): void;
+    readState(): SetupState;
+    writeState(step: string): void;
+}

package/dist/utils/stateManager.js

@@ -0,0 +1,30 @@
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+export class StateManager {
+    statePath;
+    constructor(workDir) {
+        this.statePath = join(workDir, "conductor", "setup_state.json");
+    }
+    ensureConductorDir() {
+        const dir = join(this.statePath, "..");
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    readState() {
+        if (!existsSync(this.statePath)) {
+            return { last_successful_step: "" };
+        }
+        try {
+            return JSON.parse(readFileSync(this.statePath, "utf-8"));
+        }
+        catch (e) {
+            return { last_successful_step: "" };
+        }
+    }
+    writeState(step) {
+        this.ensureConductorDir();
+        const state = { last_successful_step: step };
+        writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+    }
+}