@hyperdrive.bot/bmad-workflow 1.0.4 → 1.0.6

package/dist/models/provider.d.ts

@@ -4,7 +4,7 @@
 /**
  * Supported AI providers
  */
-export type AIProvider = 'claude' | 'gemini';
+export type AIProvider = 'claude' | 'gemini' | 'opencode';
 /**
  * Provider-specific configuration
  */

package/dist/models/provider.js

@@ -15,4 +15,9 @@ export const PROVIDER_CONFIGS = {
         flags: ['-p', '--yolo'],
         supportsFileReferences: false,
     },
+    opencode: {
+        command: 'opencode',
+        flags: ['run', '--format', 'json'],
+        supportsFileReferences: true,
+    },
 };

package/dist/services/agents/agent-runner-factory.js

@@ -5,6 +5,7 @@
  */
 import { ClaudeAgentRunner } from './claude-agent-runner.js';
 import { GeminiAgentRunner } from './gemini-agent-runner.js';
+import { OpenCodeAgentRunner } from './opencode-agent-runner.js';
 /**
  * Create an AI provider runner for the specified provider
  *
@@ -28,6 +29,9 @@ export function createAgentRunner(provider, logger) {
         case 'gemini': {
             return new GeminiAgentRunner(logger);
         }
+        case 'opencode': {
+            return new OpenCodeAgentRunner(logger);
+        }
         default: {
             throw new Error(`Unsupported AI provider: ${provider}`);
         }
@@ -40,5 +44,5 @@ export function createAgentRunner(provider, logger) {
  * @returns true if the provider is supported
  */
 export function isProviderSupported(provider) {
-    return provider === 'claude' || provider === 'gemini';
+    return provider === 'claude' || provider === 'gemini' || provider === 'opencode';
 }

package/dist/services/agents/index.d.ts

@@ -5,3 +5,4 @@ export * from './agent-runner-factory.js';
 export * from './agent-runner.js';
 export * from './claude-agent-runner.js';
 export * from './gemini-agent-runner.js';
+export * from './opencode-agent-runner.js';

package/dist/services/agents/index.js

@@ -5,3 +5,4 @@ export * from './agent-runner-factory.js';
 export * from './agent-runner.js';
 export * from './claude-agent-runner.js';
 export * from './gemini-agent-runner.js';
+export * from './opencode-agent-runner.js';

package/dist/services/agents/opencode-agent-runner.d.ts

@@ -0,0 +1,92 @@
+/**
+ * OpenCodeAgentRunner Service
+ *
+ * Encapsulates Open Code CLI process spawning with comprehensive error handling,
+ * logging, and timeout management for reliable AI agent execution.
+ */
+import type pino from 'pino';
+import type { AgentOptions, AgentResult } from '../../models/index.js';
+import type { AIProvider } from '../../models/provider.js';
+import type { AIProviderRunner } from './agent-runner.js';
+/**
+ * OpenCodeAgentRunner service for executing Open Code AI agents
+ *
+ * Spawns Open Code CLI processes to execute AI agents with specified prompts.
+ * Handles timeout, error collection, result formatting, and process cleanup.
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger({ namespace: 'agent-runner' })
+ * const runner = new OpenCodeAgentRunner(logger)
+ * const result = await runner.runAgent({
+ *   prompt: '@.bmad-core/agents/architect.md Create epic for user auth',
+ *   agentType: 'architect',
+ *   timeout: 300000
+ * })
+ * ```
+ */
+export declare class OpenCodeAgentRunner implements AIProviderRunner {
+    readonly provider: AIProvider;
+    private readonly config;
+    private readonly logger;
+    /**
+     * Create a new OpenCodeAgentRunner instance
+     *
+     * @param logger - Logger instance for structured logging
+     */
+    constructor(logger: pino.Logger);
+    /**
+     * Get the count of active processes
+     * (Useful for testing and monitoring purposes)
+     *
+     * @returns Number of currently active child processes
+     */
+    getActiveProcessCount(): number;
+    /**
+     * Execute an Open Code AI agent with the specified prompt and options
+     *
+     * This method spawns an Open Code CLI process, captures output, handles errors,
+     * and enforces timeouts. It never throws exceptions - all errors are returned
+     * as typed AgentResult objects.
+     *
+     * @param prompt - The prompt to execute with the agent
+     * @param options - Agent execution options (without prompt)
+     * @returns AgentResult with success status, output, errors, and metadata
+     *
+     * @example
+     * ```typescript
+     * const result = await runner.runAgent('@.bmad-core/agents/architect.md Create epic for user auth', {
+     *   agentType: 'architect',
+     *   timeout: 300000
+     * })
+     *
+     * if (result.success) {
+     *   console.log('Output:', result.output)
+     * } else {
+     *   console.error('Error:', result.errors)
+     * }
+     * ```
+     */
+    runAgent(prompt: string, options: Omit<AgentOptions, 'prompt'>): Promise<AgentResult>;
+    /**
+     * Parse JSON output from Open Code CLI
+     *
+     * Open Code's --format json outputs structured events.
+     * This method extracts the actual response content.
+     *
+     * @param stdoutData - Raw stdout from Open Code CLI
+     * @returns Extracted content string
+     * @private
+     */
+    private parseJsonOutput;
+    /**
+     * Build detailed error context for debugging process failures
+     * @private
+     */
+    private buildErrorContext;
+    /**
+     * Invoke onResponse callback and return result
+     * @private
+     */
+    private returnWithCallback;
+}

package/dist/services/agents/opencode-agent-runner.js

@@ -0,0 +1,392 @@
+/**
+ * OpenCodeAgentRunner Service
+ *
+ * Encapsulates Open Code CLI process spawning with comprehensive error handling,
+ * logging, and timeout management for reliable AI agent execution.
+ */
+import { exec } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+import { PROVIDER_CONFIGS } from '../../models/provider.js';
+/**
+ * Track active child processes for cleanup on SIGINT
+ */
+const activeProcesses = new Set();
+/**
+ * Track if SIGINT handler has been registered
+ */
+let sigintHandlerRegistered = false;
+/**
+ * Register SIGINT handler for graceful process cleanup
+ */
+const registerSigintHandler = (logger) => {
+    if (sigintHandlerRegistered)
+        return;
+    process.on('SIGINT', () => {
+        logger.info({
+            activeProcessCount: activeProcesses.size,
+        }, 'Received SIGINT, cleaning up active processes');
+        // Kill all active child processes
+        for (const childProcess of activeProcesses) {
+            try {
+                childProcess.kill('SIGTERM');
+            }
+            catch (error) {
+                logger.error({
+                    error: error.message,
+                }, 'Error killing child process');
+            }
+        }
+        // Clear the set
+        activeProcesses.clear();
+        // Exit the main process
+        process.exit(130); // 130 = 128 + SIGINT signal number (2)
+    });
+    sigintHandlerRegistered = true;
+};
+/**
+ * OpenCodeAgentRunner service for executing Open Code AI agents
+ *
+ * Spawns Open Code CLI processes to execute AI agents with specified prompts.
+ * Handles timeout, error collection, result formatting, and process cleanup.
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger({ namespace: 'agent-runner' })
+ * const runner = new OpenCodeAgentRunner(logger)
+ * const result = await runner.runAgent({
+ *   prompt: '@.bmad-core/agents/architect.md Create epic for user auth',
+ *   agentType: 'architect',
+ *   timeout: 300000
+ * })
+ * ```
+ */
+export class OpenCodeAgentRunner {
+    provider = 'opencode';
+    config = PROVIDER_CONFIGS.opencode;
+    logger;
+    /**
+     * Create a new OpenCodeAgentRunner instance
+     *
+     * @param logger - Logger instance for structured logging
+     */
+    constructor(logger) {
+        this.logger = logger;
+        registerSigintHandler(logger);
+    }
+    /**
+     * Get the count of active processes
+     * (Useful for testing and monitoring purposes)
+     *
+     * @returns Number of currently active child processes
+     */
+    getActiveProcessCount() {
+        return activeProcesses.size;
+    }
+    /**
+     * Execute an Open Code AI agent with the specified prompt and options
+     *
+     * This method spawns an Open Code CLI process, captures output, handles errors,
+     * and enforces timeouts. It never throws exceptions - all errors are returned
+     * as typed AgentResult objects.
+     *
+     * @param prompt - The prompt to execute with the agent
+     * @param options - Agent execution options (without prompt)
+     * @returns AgentResult with success status, output, errors, and metadata
+     *
+     * @example
+     * ```typescript
+     * const result = await runner.runAgent('@.bmad-core/agents/architect.md Create epic for user auth', {
+     *   agentType: 'architect',
+     *   timeout: 300000
+     * })
+     *
+     * if (result.success) {
+     *   console.log('Output:', result.output)
+     * } else {
+     *   console.error('Error:', result.errors)
+     * }
+     * ```
+     */
+    async runAgent(prompt, options) {
+        const startTime = Date.now();
+        const timeout = options.timeout ?? 1_800_000; // Default 30 minutes
+        // Input validation
+        if (!prompt || prompt.trim().length === 0) {
+            return this.returnWithCallback({
+                agentType: options.agentType,
+                duration: Date.now() - startTime,
+                errors: 'Prompt is required and cannot be empty',
+                exitCode: -1,
+                output: '',
+                success: false,
+            }, options.onResponse);
+        }
+        // Log execution start with metadata
+        this.logger.info({
+            agentType: options.agentType,
+            promptLength: prompt.length,
+            references: options.references?.length ?? 0,
+            timeout,
+        }, 'Executing Open Code agent');
+        // Invoke onPrompt callback if provided
+        if (options.onPrompt) {
+            try {
+                // Create options object without callbacks for the callback
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { onPrompt, onResponse, ...callbackOptions } = options;
+                await onPrompt(prompt, callbackOptions);
+            }
+            catch (error) {
+                this.logger.warn({ error: error.message }, 'Error in onPrompt callback');
+            }
+        }
+        // For large prompts or prompts with special characters, use a temp file
+        // This avoids shell escaping issues
+        let tempDir = null;
+        let tempFile = null;
+        let stdoutData = '';
+        let stderrData = '';
+        try {
+            // Create temp directory and file
+            tempDir = await mkdtemp(join(tmpdir(), 'opencode-prompt-'));
+            tempFile = join(tempDir, 'prompt.txt');
+            await writeFile(tempFile, prompt, 'utf8');
+            // Build command with --file flag (Open Code specific)
+            // Format: opencode run --format json --file "${tempFile}"
+            const flags = this.config.flags.join(' ');
+            const command = `${this.config.command} ${flags} --file "${tempFile}"`;
+            // Log the command being executed
+            this.logger.info({
+                command,
+                promptLength: prompt.length,
+                tempFile,
+            }, 'Executing command with temp file');
+            // Use exec for better shell compatibility
+            const { stderr, stdout } = await execAsync(command, {
+                env: process.env,
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                shell: process.env.SHELL || '/bin/bash',
+                timeout,
+            });
+            stdoutData = stdout;
+            stderrData = stderr;
+            const duration = Date.now() - startTime;
+            this.logger.info({
+                duration,
+                stderrLength: stderrData.length,
+                stdoutLength: stdoutData.length,
+            }, 'Open Code CLI process completed successfully');
+            // Parse JSON output from Open Code
+            const parsedOutput = this.parseJsonOutput(stdoutData);
+            const result = {
+                agentType: options.agentType,
+                duration,
+                errors: stderrData,
+                exitCode: 0,
+                output: parsedOutput,
+                success: true,
+            };
+            return this.returnWithCallback(result, options.onResponse);
+        }
+        catch (error) {
+            // Handle exec errors (includes timeout, non-zero exit, etc.)
+            const duration = Date.now() - startTime;
+            // Extract stdout/stderr from exec error if available
+            const execError = error;
+            if (execError.stdout)
+                stdoutData = execError.stdout;
+            if (execError.stderr)
+                stderrData = execError.stderr;
+            const exitCode = execError.code ?? -1;
+            const isTimeout = execError.killed === true && execError.signal === 'SIGTERM';
+            const wasKilled = execError.killed === true;
+            const signal = execError.signal ?? null;
+            // Build detailed error context for debugging
+            const errorContext = this.buildErrorContext({
+                cmd: execError.cmd,
+                duration,
+                exitCode,
+                isTimeout,
+                signal,
+                stderrData,
+                stdoutData,
+                wasKilled,
+            });
+            this.logger.error({
+                cmd: execError.cmd,
+                duration,
+                error: execError.message,
+                exitCode,
+                isTimeout,
+                signal,
+                stderrLength: stderrData.length,
+                stdoutLength: stdoutData.length,
+                wasKilled,
+            }, isTimeout ? 'Open Code CLI process timeout' : 'Open Code CLI process error');
+            return this.returnWithCallback({
+                agentType: options.agentType,
+                duration,
+                errors: errorContext,
+                exitCode: isTimeout ? 124 : exitCode,
+                output: stdoutData,
+                success: false,
+            }, options.onResponse);
+        }
+        finally {
+            // Clean up temp file and directory
+            if (tempDir) {
+                try {
+                    await rm(tempDir, { force: true, recursive: true });
+                    this.logger.debug({ tempDir }, 'Cleaned up temp directory');
+                }
+                catch (cleanupError) {
+                    this.logger.warn({ error: cleanupError.message, tempDir }, 'Failed to clean up temp directory');
+                }
+            }
+        }
+    }
+    /**
+     * Parse JSON output from Open Code CLI
+     *
+     * Open Code's --format json outputs structured events.
+     * This method extracts the actual response content.
+     *
+     * @param stdoutData - Raw stdout from Open Code CLI
+     * @returns Extracted content string
+     * @private
+     */
+    parseJsonOutput(stdoutData) {
+        if (!stdoutData || stdoutData.trim().length === 0) {
+            return '';
+        }
+        try {
+            const parsed = JSON.parse(stdoutData);
+            // Try common JSON response structures
+            // Open Code may output different structures depending on version
+            if (typeof parsed === 'string') {
+                return parsed;
+            }
+            if (parsed.content) {
+                return String(parsed.content);
+            }
+            if (parsed.message) {
+                return String(parsed.message);
+            }
+            if (parsed.response) {
+                return String(parsed.response);
+            }
+            if (parsed.output) {
+                return String(parsed.output);
+            }
+            if (parsed.text) {
+                return String(parsed.text);
+            }
+            // If we have a result array, try to extract content
+            if (Array.isArray(parsed)) {
+                const messages = parsed
+                    .filter((item) => item.type === 'message' || item.content || item.text)
+                    .map((item) => item.content || item.text || item.message || '')
+                    .filter(Boolean);
+                if (messages.length > 0) {
+                    return messages.join('\n');
+                }
+            }
+            // Fallback: stringify the parsed object
+            this.logger.debug({ parsedKeys: Object.keys(parsed) }, 'Unknown JSON structure, returning stringified');
+            return JSON.stringify(parsed, null, 2);
+        }
+        catch {
+            // JSON parsing failed, return raw output
+            this.logger.debug({ stdoutLength: stdoutData.length }, 'JSON parsing failed, returning raw output');
+            return stdoutData;
+        }
+    }
+    /**
+     * Build detailed error context for debugging process failures
+     * @private
+     */
+    buildErrorContext(info) {
+        const lines = [];
+        // Determine the type of failure
+        if (info.isTimeout) {
+            lines.push(`Process timeout after ${info.duration}ms`);
+        }
+        else if (info.wasKilled) {
+            lines.push('Process was killed externally');
+            // Explain common exit codes
+            switch (info.exitCode) {
+                case 130: {
+                    lines.push('Exit code 130 = SIGINT (user interrupt, Ctrl+C)');
+                    break;
+                }
+                case 137: {
+                    lines.push('Exit code 137 = SIGKILL (process forcefully killed)', 'Possible causes:', '  - System OOM killer', '  - Exceeded memory limits', '  - Docker/container killed the process');
+                    break;
+                }
+                case 143: {
+                    lines.push('Exit code 143 = SIGTERM (process terminated)', 'Possible causes:', '  - System OOM killer terminated the process', '  - Another process sent SIGTERM', '  - Parent process cleanup', '  - Docker/container resource limits');
+                    break;
+                }
+                // No default
+            }
+            if (info.signal) {
+                lines.push(`Signal received: ${info.signal}`);
+            }
+            else {
+                lines.push('No signal information available (signal: null)');
+            }
+        }
+        else {
+            lines.push(`Process exited with code ${info.exitCode}`);
+        }
+        // Add duration context
+        lines.push(`Duration: ${(info.duration / 1000).toFixed(2)}s`);
+        // Add output context
+        if (info.stdoutData.length > 0) {
+            lines.push(`Stdout (${info.stdoutData.length} chars):`);
+            // Truncate if too long, show last 500 chars which are often most relevant
+            const truncatedStdout = info.stdoutData.length > 500 ? `...[truncated]...\n${info.stdoutData.slice(-500)}` : info.stdoutData;
+            lines.push(truncatedStdout);
+        }
+        else {
+            lines.push('Stdout: (empty - no output captured)');
+        }
+        if (info.stderrData.length > 0) {
+            lines.push(`Stderr (${info.stderrData.length} chars):`);
+            const truncatedStderr = info.stderrData.length > 500 ? `...[truncated]...\n${info.stderrData.slice(-500)}` : info.stderrData;
+            lines.push(truncatedStderr);
+        }
+        else {
+            lines.push('Stderr: (empty - no error output)');
+        }
+        // Add command for reference (truncate if too long)
+        if (info.cmd) {
+            const truncatedCmd = info.cmd.length > 200 ? `${info.cmd.slice(0, 200)}...[truncated]` : info.cmd;
+            lines.push(`Command: ${truncatedCmd}`);
+        }
+        // Add troubleshooting suggestions for empty output
+        if (info.stdoutData.length === 0 && info.stderrData.length === 0) {
+            lines.push('', 'Troubleshooting (no output captured):', '  1. Check system resources (memory, CPU)', '  2. Verify Open Code CLI is properly installed: `opencode --version`', '  3. Check for Open Code API issues', '  4. Review system logs: `dmesg | tail -50` (for OOM killer)', '  5. Try running the command manually to see output');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Invoke onResponse callback and return result
+     * @private
+     */
+    async returnWithCallback(result, onResponse) {
+        if (onResponse) {
+            try {
+                await onResponse(result);
+            }
+            catch (error) {
+                this.logger.warn({ error: error.message }, 'Error in onResponse callback');
+            }
+        }
+        return result;
+    }
+}

package/dist/services/orchestration/task-decomposition-service.js

@@ -159,70 +159,38 @@ ${options.contextFiles.map((f) => `- ${f}`).join('\n')}
 `;
         }
         // Add output format instructions (varies based on story format mode)
-        prompt += options.storyFormat ? `## OUTPUT FORMAT - STORY MODE
-You MUST output tasks as BMAD-formatted STORIES with proper structure.
-Output ONLY valid YAML. DO NOT include markdown code fences or any other text.
-
-Each task will become a full story with:
-- Story ID: ${options.storyPrefix}-<number> (e.g., ${options.storyPrefix}-001, ${options.storyPrefix}-002)
-- User story format: "As a... I want... so that..."
-- Acceptance Criteria
-- Tasks/Subtasks breakdown
-- Dev Notes with testing info
-
-\`\`\`yaml
+        prompt += options.storyFormat ? `## OUTPUT FORMAT - STORY MODE - CRITICAL INSTRUCTIONS
+
+**YOUR RESPONSE MUST BE PURE YAML ONLY.**
+- Do NOT write any explanation, summary, or commentary
+- Do NOT use markdown code fences
+- Start your response DIRECTLY with "masterPrompt: |"
+
+Each task becomes a BMAD story with user story format, acceptance criteria, and tasks breakdown.
+
+The YAML structure MUST be:
+
 masterPrompt: |
-  A reusable prompt template that applies to all stories.
-  Include best practices, coding standards, and common guidelines for implementing these stories.
+  A reusable prompt template for all stories.
+  Include best practices and coding standards.
 
 tasks:
   - id: ${options.storyPrefix}-001
     title: "Clear, specific story title"
     description: "High-level description of what this story delivers"
     estimatedMinutes: 10
-    dependencies: []  # Array of story IDs that must complete first
+    dependencies: []
     parallelizable: true
     agentType: "dev"
-    targetFiles:  # Optional: specific files this story operates on
+    targetFiles:
       - "path/to/file.js"
     prompt: |
-      Create a story following BMAD story format:
-
-      # Story ${options.storyPrefix}-001: [Title]
-
-      ## Status
-      Draft
-
-      ## Story
-      **As a** [role/persona],
-      **I want** [capability/feature],
-      **so that** [benefit/value]
-
-      ## Acceptance Criteria
-      1. [Specific, testable criterion]
-      2. [Another criterion]
-      3. [Another criterion]
-
-      ## Tasks / Subtasks
-      - [ ] Task 1: [Description] (AC: #1)
-        - [ ] Subtask 1.1: [Specific action]
-        - [ ] Subtask 1.2: [Specific action]
-      - [ ] Task 2: [Description] (AC: #2)
-        - [ ] Subtask 2.1: [Specific action]
-
-      ## Dev Notes
-      [Relevant architecture info, integration points, file locations]
-
-      ### Testing
-      - Test file location: [path]
-      - Test standards: [requirements]
-      - Testing frameworks: [tools being used]
-      - Specific requirements: [any special test needs]
-
-      ## Change Log
-      | Date | Version | Description | Author |
-      |------|---------|-------------|--------|
-      | [Date] | 1.0 | Story created | AI Agent |
+      Create a story following BMAD story format with:
+      - Status: Draft
+      - User story (As a... I want... so that...)
+      - Acceptance Criteria (numbered, testable)
+      - Tasks/Subtasks with AC references
+      - Dev Notes with testing info
     outputFile: "${sessionDir}/stories/${options.storyPrefix}-001.md"
 
   - id: ${options.storyPrefix}-002
@@ -233,40 +201,25 @@ tasks:
     parallelizable: false
     agentType: "dev"
     prompt: |
-      [Story-formatted prompt as above]
+      Story-formatted prompt
     outputFile: "${sessionDir}/stories/${options.storyPrefix}-002.md"
 
-  # ... more tasks (as stories)
-\`\`\`
+## STORY MODE RULES
+- Task IDs: ${options.storyPrefix}-001, ${options.storyPrefix}-002, etc.
+- Output files: ${sessionDir}/stories/
+${options.perFile ? '- **CRITICAL**: Create one story per file (per-file mode is ON)' : ''}
 
-**CRITICAL FOR STORY MODE:**
-- Task IDs MUST be story IDs: ${options.storyPrefix}-001, ${options.storyPrefix}-002, etc.
-- Output files MUST go to stories/ directory
-- Prompts MUST generate full story structure (not simple task outputs)
-- Each story must have user story format, acceptance criteria, and tasks breakdown
+**REMEMBER: Your ENTIRE response must be valid YAML starting with "masterPrompt: |" - NO other text!**
+` : `## OUTPUT FORMAT - CRITICAL INSTRUCTIONS
 
-## IMPORTANT RULES
-1. Each story ID must be unique
-2. Dependencies must reference valid story IDs
-3. Circular dependencies are not allowed
-4. Stories with no dependencies can run immediately
-5. Stories with the same dependencies can run in parallel (if parallelizable: true)
-6. All file paths in outputFile should use the session directory: ${sessionDir}/stories/
-${options.perFile ? '7. **CRITICAL**: Create one story per file for the main work (per-file mode is ON)' : ''}
+**YOUR RESPONSE MUST BE PURE YAML ONLY.**
+- Do NOT write any explanation, summary, or commentary
+- Do NOT use markdown code fences (\`\`\`yaml or \`\`\`)
+- Do NOT write "Here's the task decomposition..." or similar
+- Start your response DIRECTLY with "masterPrompt: |"
 
-## EXAMPLE DEPENDENCY PATTERNS
+The YAML structure MUST be:
 
-Sequential:
-${options.storyPrefix}-001 (deps: []) → ${options.storyPrefix}-002 (deps: [${options.storyPrefix}-001])
-
-Parallel then join:
-${options.storyPrefix}-001 (deps: []) → [${options.storyPrefix}-002, ${options.storyPrefix}-003] → ${options.storyPrefix}-004
-
-Now, decompose the goal into stories. Output ONLY the YAML structure.
-` : `## OUTPUT FORMAT
-You MUST output ONLY valid YAML in the following structure. DO NOT include markdown code fences or any other text.
-
-\`\`\`yaml
 masterPrompt: |
   A reusable prompt template that applies to all tasks.
   Include best practices, coding standards, and common guidelines.
@@ -276,52 +229,39 @@ tasks:
     title: "Clear, specific task title"
     description: "Detailed description of what this task accomplishes"
     estimatedMinutes: 10
-    dependencies: []  # Array of task IDs that must complete first
-    parallelizable: true  # Can this run in parallel with other tasks?
-    agentType: "dev"  # Agent type: dev, architect, qa, etc.
-    targetFiles:  # Optional: specific files this task operates on
+    dependencies: []
+    parallelizable: true
+    agentType: "dev"
+    targetFiles:
       - "path/to/file.js"
     prompt: |
       Specific prompt for the agent to execute this task.
-      Include:
-      - What to do
-      - Where to do it (file paths)
-      - Expected outcome
-      - Any validation steps
+      Include what to do, where to do it, expected outcome, validation steps.
     outputFile: "${sessionDir}/outputs/task-001-output.md"
 
   - id: task-002
     title: "Next task"
     description: "Task description"
     estimatedMinutes: 5
-    dependencies: ["task-001"]  # Must wait for task-001
+    dependencies: ["task-001"]
     parallelizable: false
     agentType: "dev"
     prompt: |
       Task-specific prompt here
     outputFile: "${sessionDir}/outputs/task-002-output.md"
 
-  # ... more tasks
-\`\`\`
-
-## IMPORTANT RULES
-1. Each task ID must be unique
+## YAML RULES
+1. Each task ID must be unique (task-001, task-002, etc.)
 2. Dependencies must reference valid task IDs
-3. Circular dependencies are not allowed
-4. Tasks with no dependencies can run immediately
-5. Tasks with the same dependencies can run in parallel (if parallelizable: true)
-6. All file paths in outputFile should use the session directory: ${sessionDir}/outputs/
-${options.perFile ? '7. **CRITICAL**: Create one task per file for the main work (per-file mode is ON)' : ''}
-
-## EXAMPLE DEPENDENCY PATTERNS
-
-Sequential:
-task-001 (deps: []) → task-002 (deps: [task-001]) → task-003 (deps: [task-002])
+3. No circular dependencies
+4. Use outputFile path: ${sessionDir}/outputs/
+${options.perFile ? '5. **CRITICAL**: Create one task per file (per-file mode is ON)' : ''}
 
-Parallel then join:
-task-001 (deps: []) → [task-002, task-003] (deps: [task-001]) → task-004 (deps: [task-002, task-003])
+## DEPENDENCY PATTERNS
+- Sequential: task-001 → task-002 (deps: [task-001])
+- Parallel: task-002, task-003 both depend on task-001, then task-004 depends on both
 
-Now, decompose the goal into tasks. Output ONLY the YAML structure.
+**REMEMBER: Your ENTIRE response must be valid YAML starting with "masterPrompt: |" - NO other text!**
 `;
         return prompt;
     }
@@ -418,15 +358,25 @@ Now, decompose the goal into tasks. Output ONLY the YAML structure.
             startIndex = lines.findIndex((line) => line.trim().startsWith('tasks:'));
         }
         if (startIndex !== -1) {
-            // Find the end of YAML content (stop at empty lines or obvious non-YAML content)
+            // For YAML task graphs, we expect the content to continue until the end
+            // since ## headers inside multiline strings (prompt: |) are valid YAML content.
+            // Only stop if we see clear non-YAML markers at the start of a line (no indentation).
             let endIndex = lines.length;
             for (let i = startIndex + 1; i < lines.length; i++) {
-                const line = lines[i].trim();
-                // Stop if we hit obvious non-YAML content
-                if (line.startsWith('#') && !line.startsWith('# ') && i > startIndex + 5) {
-                    // Could be a comment, but if far from start, likely end of YAML
-                    endIndex = i;
-                    break;
+                const line = lines[i];
+                const trimmedLine = line.trim();
+                // Only stop at lines that are:
+                // 1. Not indented (start at column 0)
+                // 2. Look like markdown headers or prose (not YAML keys)
+                // 3. Are not empty lines (which are valid in YAML)
+                if (line.length > 0 && line[0] !== ' ' && line[0] !== '\t') {
+                    // Line is not indented - check if it's a YAML key or non-YAML content
+                    const isYamlKey = /^[a-zA-Z_][a-zA-Z0-9_]*:/.test(trimmedLine) || trimmedLine.startsWith('-');
+                    if (!isYamlKey && !trimmedLine.startsWith('#')) {
+                        // Non-indented, non-YAML content (like "Here's the summary...")
+                        endIndex = i;
+                        break;
+                    }
                 }
             }
             const yamlContent = lines.slice(startIndex, endIndex).join('\n');
@@ -535,21 +485,24 @@ Now, decompose the goal into tasks. Output ONLY the YAML structure.
         catch (error) {
             this.logger.warn({ error: error.message }, 'YAML validation failed, asking Claude to fix it');
             // YAML is invalid, ask Claude to fix it
-            const fixPrompt = `The following YAML has syntax errors. Please fix ALL syntax errors and return ONLY the corrected YAML (no explanations, no markdown code fences, just the raw YAML):
+            const fixPrompt = `FIX THIS YAML - OUTPUT ONLY THE FIXED YAML, NOTHING ELSE.
+
+**CRITICAL: Your response must be PURE YAML only. Start directly with "masterPrompt: |"**
+- Do NOT write any explanation
+- Do NOT use markdown code fences
+- Do NOT say "Here's the fixed YAML" or anything similar
 
-ERROR: ${error.message}
+ERROR TO FIX: ${error.message}
 
-INVALID YAML:
+YAML TO FIX:
 ${output}
 
-Please output the CORRECTED YAML only. Ensure:
-1. Proper indentation (2 spaces per level)
-2. All strings with special characters are quoted
-3. All lists and mappings are properly formatted
-4. No syntax errors remain
+RULES:
+- Use 2 spaces for indentation
+- Quote strings with special characters
+- Ensure valid YAML syntax
 
-Output ONLY the corrected YAML:
-`;
+YOUR RESPONSE MUST START WITH "masterPrompt: |" - NO OTHER TEXT ALLOWED!`;
             this.logger.info('Asking Claude to fix YAML errors');
             const fixResult = await this.agentRunner.runAgent(fixPrompt, {
                 agentType: 'architect',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hyperdrive.bot/bmad-workflow",
   "description": "AI-driven development workflow orchestration CLI for BMAD projects",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "author": {
     "name": "DevSquad",
     "email": "marcelo@devsquad.email",