opencastle 0.32.8 → 0.32.10

package/src/cli/pipeline.ts

@@ -1,6 +1,6 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { readFile, writeFile, mkdir, unlink } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { resolve, dirname } from 'node:path'
+import { resolve } from 'node:path'
 import { stringify } from 'yaml'
 import { c, confirm, closePrompts } from './prompt.js'
 import { runPromptStep, readProjectMcpServers } from './plan.js'
@@ -8,7 +8,7 @@ import type { PromptStepOptions } from './plan.js'
 import { cleanupAdapters } from './run/adapters/index.js'
 import type { CliContext } from './types.js'
 import { parseYaml, validateSpec } from './run/schema.js'
-import { buildConvoyYaml, parseTaskPlan, parsePatches, applyPatches, deriveSpecEnrichment } from './convoy/spec-builder.js'
+import { buildConvoyYaml, parseTaskPlanWithReason, parsePatches, applyPatches, deriveSpecEnrichment, detectJsonTruncation } from './convoy/spec-builder.js'
 import type { TaskPlan, SpecEnrichment } from './convoy/spec-builder.js'
 
 export interface ConvoyGroup {
@@ -29,6 +29,104 @@ function appendTaskComplexity(base: string, taskComplexity: ComplexityAssessment
   return result
 }
 
+/**
+ * For chain mode, extract only the PRD sections relevant to the given phases.
+ * Keeps Overview, Technical Requirements, and the matching phase sections from
+ * Task Breakdown, while trimming the full User Stories, Implementation Scope,
+ * and non-matching phases to reduce context size and avoid output truncation.
+ */
+function extractRelevantPrdSections(prdContent: string, phases: number[]): string {
+  const phaseSet = new Set(phases)
+  const lines = prdContent.split('\n')
+  const result: string[] = []
+
+  // Sections to always include (key context)
+  const alwaysInclude = ['overview', 'goals', 'non-goals', 'technical requirements']
+  // Sections to include condensed
+  const condenseSection = ['user stories & acceptance criteria', 'implementation scope', 'success criteria', 'risks & open questions']
+
+  let currentSection = ''
+  let inTaskBreakdown = false
+  let inRelevantPhase = false
+  let skipSection = false
+
+  for (const line of lines) {
+    // Detect heading (## level)
+    const h2Match = line.match(/^## (.+)/)
+    if (h2Match) {
+      const heading = h2Match[1].trim().toLowerCase()
+      currentSection = heading
+      inTaskBreakdown = heading === 'task breakdown'
+      inRelevantPhase = false
+      skipSection = false
+
+      if (alwaysInclude.some(s => heading.startsWith(s))) {
+        result.push(line)
+        continue
+      }
+
+      if (inTaskBreakdown) {
+        result.push(line)
+        result.push('')
+        result.push(`*(Only phases ${phases.join(', ')} shown — other phases omitted for brevity)*`)
+        result.push('')
+        continue
+      }
+
+      if (condenseSection.some(s => heading.startsWith(s))) {
+        // Include the heading but mark as condensed
+        result.push(line)
+        result.push('')
+        result.push('*(Condensed — see full PRD for details)*')
+        result.push('')
+        skipSection = true
+        continue
+      }
+
+      // # title heading — always include
+      result.push(line)
+      continue
+    }
+
+    // H1 heading — always include
+    if (line.match(/^# /)) {
+      result.push(line)
+      continue
+    }
+
+    if (skipSection) continue
+
+    if (inTaskBreakdown) {
+      // Detect phase headers like "Phase 1 —" or "Phase 2 —"
+      const phaseMatch = line.match(/Phase\s+(\d+)/i)
+      if (phaseMatch) {
+        const phaseNum = parseInt(phaseMatch[1], 10)
+        inRelevantPhase = phaseSet.has(phaseNum)
+      }
+      if (inRelevantPhase) {
+        result.push(line)
+      }
+      continue
+    }
+
+    result.push(line)
+  }
+
+  return result.join('\n')
+}
+
+/**
+ * Filter task complexity entries to only those matching the given phases.
+ */
+function filterTaskComplexityByPhases(
+  taskComplexity: ComplexityAssessment['task_complexity'],
+  phases: number[],
+): ComplexityAssessment['task_complexity'] {
+  if (!taskComplexity?.length) return taskComplexity
+  const phaseSet = new Set(phases)
+  return taskComplexity.filter(tc => phaseSet.has(tc.phase))
+}
+
 export interface ComplexityAssessment {
   original_prompt: string
   total_tasks: number
@@ -310,6 +408,79 @@ function stepLabel(n: number, total: number, name: string): string {
   return c.bold(c.cyan(`  [${n}/${total}] ${name}`))
 }
 
+async function fixPrd(
+  sharedOpts: Omit<PromptStepOptions, 'template' | 'goalText'>,
+  prdPath: string,
+  prdContent: string,
+  initialErrors: string,
+  totalSteps: number,
+  adapterFlag: string | null,
+): Promise<void> {
+  const MAX_PRD_FIX_RETRIES = 2
+  let fixedPrdContent = prdContent
+  let prdValidationErrors = initialErrors
+  let prdFixed = false
+
+  for (let attempt = 1; attempt <= MAX_PRD_FIX_RETRIES; attempt++) {
+    const label = `Fix PRD attempt ${attempt}/${MAX_PRD_FIX_RETRIES}…`
+    console.log(stepLabel(3, totalSteps, label))
+
+    try {
+      await runPromptStep({
+        ...sharedOpts,
+        template: 'fix-prd',
+        goalText: fixedPrdContent,
+        contextText: prdValidationErrors,
+        outputPath: prdPath,
+      })
+    } catch (err) {
+      console.error(`\n  ✗ Step 3 (attempt ${attempt}) failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exit(1)
+    }
+
+    console.log(c.dim(`  Re-validating after fix…`))
+
+    fixedPrdContent = await readFile(prdPath, 'utf8')
+
+    let revalidation
+    try {
+      revalidation = await runPromptStep({
+        ...sharedOpts,
+        template: 'validate-prd',
+        goalText: `<!-- validation-pass: ${attempt + 1} -->\n${fixedPrdContent}`,
+      })
+    } catch (err) {
+      console.error(`\n  ✗ Re-validation failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exit(1)
+    }
+
+    if (revalidation.isValid) {
+      console.log(c.green(`  ✓ PRD fixed and validated\n`))
+      prdFixed = true
+      break
+    }
+
+    prdValidationErrors = revalidation.errors ?? revalidation.rawOutput
+
+    if (attempt < MAX_PRD_FIX_RETRIES) {
+      console.log(c.yellow(`  ⚠ Still has issues after fix attempt ${attempt} — retrying…\n`))
+      console.log(c.dim(prdValidationErrors))
+      console.log()
+    }
+  }
+
+  if (!prdFixed) {
+    console.log(c.yellow(`\n  ⚠ Could not fully auto-fix the PRD after ${MAX_PRD_FIX_RETRIES} attempts — continuing with best-effort PRD.\n`))
+    console.log(c.dim(`  Remaining issues:\n`))
+    console.log(c.dim(prdValidationErrors))
+    console.log(
+      c.dim(`\n  PRD saved to ${relPath(prdPath)} with best available fixes.`) +
+        c.dim(`\n  You can re-validate later with:\n`) +
+        `    opencastle start --prd ${relPath(prdPath)}${adapterFlag ? ` --adapter ${adapterFlag}` : ''}\n`
+    )
+  }
+}
+
 export default async function pipeline({ args, pkgRoot }: CliContext): Promise<void> {
   const opts = parseArgs(args)
 
@@ -386,98 +557,11 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     return
   }
 
-  // ── Step 2: Validate PRD ──────────────────────────────────────────────────
-  if (!opts.skipValidation) {
-    console.log(stepLabel(2, totalSteps, 'Validating PRD…'))
-
-    const prdContent = await readFile(prdPath, 'utf8')
-    let result
-    try {
-      result = await runPromptStep({
-        ...sharedOpts,
-        template: 'validate-prd',
-        goalText: `<!-- validation-pass: 1 -->\n${prdContent}`,
-      })
-    } catch (err) {
-      console.error(`\n  ✗ Step 2 failed: ${err instanceof Error ? err.message : String(err)}`)
-      process.exit(1)
-    }
-
-    if (!result.isValid) {
-      let prdValidationErrors = result.errors ?? result.rawOutput
-      console.log(c.yellow(`  ⚠ PRD has validation issues — attempting auto-fix…\n`))
-      console.log(c.dim(prdValidationErrors))
-      console.log()
-
-      // ── Step 3: Fix PRD (up to 2 retries) ──────────────────────────────────
-      const MAX_PRD_FIX_RETRIES = 2
-      let fixedPrdContent = prdContent
-      let prdFixed = false
-
-      for (let attempt = 1; attempt <= MAX_PRD_FIX_RETRIES; attempt++) {
-        const label = `Fix PRD attempt ${attempt}/${MAX_PRD_FIX_RETRIES}…`
-        console.log(stepLabel(3, totalSteps, label))
-
-        try {
-          await runPromptStep({
-            ...sharedOpts,
-            template: 'fix-prd',
-            goalText: fixedPrdContent,
-            contextText: prdValidationErrors,
-            outputPath: prdPath, // overwrite in place
-          })
-        } catch (err) {
-          console.error(`\n  ✗ Step 3 (attempt ${attempt}) failed: ${err instanceof Error ? err.message : String(err)}`)
-          process.exit(1)
-        }
-
-        console.log(c.dim(`  Re-validating after fix…`))
-
-        fixedPrdContent = await readFile(prdPath, 'utf8')
-
-        let revalidation
-        try {
-          revalidation = await runPromptStep({
-            ...sharedOpts,
-            template: 'validate-prd',
-            goalText: `<!-- validation-pass: ${attempt + 1} -->\n${fixedPrdContent}`,
-          })
-        } catch (err) {
-          console.error(`\n  ✗ Re-validation failed: ${err instanceof Error ? err.message : String(err)}`)
-          process.exit(1)
-        }
-
-        if (revalidation.isValid) {
-          console.log(c.green(`  ✓ PRD fixed and validated\n`))
-          prdFixed = true
-          break
-        }
-
-        prdValidationErrors = revalidation.errors ?? revalidation.rawOutput
-
-        if (attempt < MAX_PRD_FIX_RETRIES) {
-          console.log(c.yellow(`  ⚠ Still has issues after fix attempt ${attempt} — retrying…\n`))
-          console.log(c.dim(prdValidationErrors))
-          console.log()
-        }
-      }
-
-      if (!prdFixed) {
-        console.log(c.yellow(`\n  ⚠ Could not fully auto-fix the PRD after ${MAX_PRD_FIX_RETRIES} attempts — continuing with best-effort PRD.\n`))
-        console.log(c.dim(`  Remaining issues:\n`))
-        console.log(c.dim(prdValidationErrors))
-        console.log(
-          c.dim(`\n  PRD saved to ${relPath(prdPath)} with best available fixes.`) +
-            c.dim(`\n  You can re-validate later with:\n`) +
-            `    opencastle start --prd ${relPath(prdPath)}${opts.adapter ? ` --adapter ${opts.adapter}` : ''}\n`
-        )
-      }
-    } else {
-      console.log(c.green(`  ✓ PRD is valid\n`))
-    }
-  }
+  // ── Steps 2 + 4: Validate PRD & Assess complexity (in parallel) ────────
+  // Both only read the PRD — run them concurrently to save one LLM round-trip.
+  // If validation fails we still use the complexity result (fix-prd patches
+  // issues without changing the overall structure/phases).
 
-  // ── Complexity-aware strategy decision ────────────────────────────────────
   const complexityStep = opts.skipValidation ? 2 : 4
 
   let complexity: ComplexityAssessment | null = null
@@ -485,6 +569,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     ? resolve(process.cwd(), opts.complexity)
     : deriveComplexityPath(prdPath)
 
+  // Check for cached / provided complexity before launching LLM calls
   if (opts.complexity) {
     if (!existsSync(complexityFilePath)) {
       console.error(`  ✗ Complexity file not found: ${opts.complexity}`)
@@ -516,23 +601,107 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     }
   }
 
-  if (!complexity) {
-    console.log(stepLabel(complexityStep, totalSteps, 'Assessing complexity…'))
-    try {
-      const complexityResult = await runPromptStep({
-        ...sharedOpts,
-        template: 'assess-complexity',
-        filePath: prdPath,
-        contextText: opts.text ?? undefined,
-      })
-      complexity = parseComplexityAssessment(complexityResult.rawOutput)
-      if (complexity) {
-        await writeFile(complexityFilePath, JSON.stringify(complexity, null, 2), 'utf8')
-        console.log(c.green(`  ✓ Complexity assessment saved to ${relPath(complexityFilePath)}\n`))
+  const needsValidation = !opts.skipValidation
+  const needsComplexity = !complexity
+
+  if (needsValidation || needsComplexity) {
+    const prdContent = await readFile(prdPath, 'utf8')
+
+    // Launch validation and complexity in parallel when both are needed
+    if (needsValidation && needsComplexity) {
+      console.log(stepLabel(2, totalSteps, 'Validating PRD…'))
+      console.log(stepLabel(complexityStep, totalSteps, 'Assessing complexity…'))
+      console.log(c.dim(`  (running in parallel)\n`))
+
+      const [validationResult, complexityResult] = await Promise.all([
+        runPromptStep({
+          ...sharedOpts,
+          template: 'validate-prd',
+          goalText: `<!-- validation-pass: 1 -->\n${prdContent}`,
+        }).catch((err) => {
+          console.error(`\n  ✗ Validation failed: ${err instanceof Error ? err.message : String(err)}`)
+          return null
+        }),
+        runPromptStep({
+          ...sharedOpts,
+          template: 'assess-complexity',
+          filePath: prdPath,
+          contextText: opts.text ?? undefined,
+        }).catch((err) => {
+          console.warn(c.yellow(`  ⚠ Complexity assessment failed: ${err instanceof Error ? err.message : String(err)}`))
+          return null
+        }),
+      ])
+
+      // Process complexity result
+      if (complexityResult) {
+        complexity = parseComplexityAssessment(complexityResult.rawOutput)
+        if (complexity) {
+          await writeFile(complexityFilePath, JSON.stringify(complexity, null, 2), 'utf8')
+          console.log(c.green(`  ✓ Complexity assessment saved to ${relPath(complexityFilePath)}`))
+        }
+      }
+
+      // Process validation result
+      if (!validationResult) {
+        process.exit(1)
+      }
+
+      if (!validationResult.isValid) {
+        let prdValidationErrors = validationResult.errors ?? validationResult.rawOutput
+        console.log(c.yellow(`  ⚠ PRD has validation issues — attempting auto-fix…\n`))
+        console.log(c.dim(prdValidationErrors))
+        console.log()
+
+        await fixPrd(sharedOpts, prdPath, prdContent, prdValidationErrors, totalSteps, opts.adapter)
+      } else {
+        console.log(c.green(`  ✓ PRD is valid\n`))
+      }
+    } else if (needsValidation) {
+      // Only validation needed (complexity was cached)
+      console.log(stepLabel(2, totalSteps, 'Validating PRD…'))
+
+      let result
+      try {
+        result = await runPromptStep({
+          ...sharedOpts,
+          template: 'validate-prd',
+          goalText: `<!-- validation-pass: 1 -->\n${prdContent}`,
+        })
+      } catch (err) {
+        console.error(`\n  ✗ Step 2 failed: ${err instanceof Error ? err.message : String(err)}`)
+        process.exit(1)
+      }
+
+      if (!result.isValid) {
+        let prdValidationErrors = result.errors ?? result.rawOutput
+        console.log(c.yellow(`  ⚠ PRD has validation issues — attempting auto-fix…\n`))
+        console.log(c.dim(prdValidationErrors))
+        console.log()
+
+        await fixPrd(sharedOpts, prdPath, prdContent, prdValidationErrors, totalSteps, opts.adapter)
+      } else {
+        console.log(c.green(`  ✓ PRD is valid\n`))
+      }
+    } else {
+      // Only complexity needed (validation skipped)
+      console.log(stepLabel(complexityStep, totalSteps, 'Assessing complexity…'))
+      try {
+        const complexityResult = await runPromptStep({
+          ...sharedOpts,
+          template: 'assess-complexity',
+          filePath: prdPath,
+          contextText: opts.text ?? undefined,
+        })
+        complexity = parseComplexityAssessment(complexityResult.rawOutput)
+        if (complexity) {
+          await writeFile(complexityFilePath, JSON.stringify(complexity, null, 2), 'utf8')
+          console.log(c.green(`  ✓ Complexity assessment saved to ${relPath(complexityFilePath)}\n`))
+        }
+      } catch (err) {
+        console.warn(c.yellow(`  ⚠ Complexity assessment failed: ${err instanceof Error ? err.message : String(err)}`))
+        console.warn(c.dim(`    Falling back to single convoy strategy.\n`))
       }
-    } catch (err) {
-      console.warn(c.yellow(`  ⚠ Complexity assessment failed: ${err instanceof Error ? err.message : String(err)}`))
-      console.warn(c.dim(`    Falling back to single convoy strategy.\n`))
     }
   }
 
@@ -569,10 +738,18 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
         const convoyDir = resolve(process.cwd(), '.opencastle', 'convoys')
         await mkdir(convoyDir, { recursive: true })
 
+        // Extract feature name early for convoy naming
+        const chainPrdContent = await readFile(prdPath, 'utf8')
+        const featureNameMatch = chainPrdContent.match(/^# (.+?)\s*(?:—|-)?\s*PRD/m)
+        const featureName = featureNameMatch
+          ? featureNameMatch[1].trim().toLowerCase().replace(/[^a-z0-9]+/g, '-')
+          : 'feature'
+
         const groupSpecPaths: string[] = []
 
         for (let i = 0; i < complexity.convoy_groups.length; i++) {
           const group = complexity.convoy_groups[i]
+          console.log(c.cyan(`  [${i + 1}/${complexity.convoy_groups.length}] Generating convoy: ${group.name}`) + c.dim(` (phases: ${group.phases.join(', ')})`))
 
           const chainGoal = [
             complexity.original_prompt,
@@ -589,8 +766,10 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
           ].filter(Boolean).join('\n')
 
           const prdContent = await readFile(prdPath, 'utf8')
-          const contextForSpec = appendTaskComplexity(prdContent, complexity?.task_complexity)
-          const groupSpecPath = resolve(convoyDir, `${group.name}.convoy.yml`)
+          const relevantPrd = extractRelevantPrdSections(prdContent, group.phases)
+          const relevantComplexity = filterTaskComplexityByPhases(complexity?.task_complexity, group.phases)
+          const contextForSpec = appendTaskComplexity(relevantPrd, relevantComplexity)
+          const groupSpecPath = resolve(convoyDir, `${featureName}-${group.name}.convoy.yml`)
 
           const { specPath: resolvedGroupSpecPath } = await generateAndValidateSpec({
             sharedOpts,
@@ -599,18 +778,13 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
             specPath: groupSpecPath,
             skipValidation: opts.skipValidation,
             groupName: group.name,
+            featureName,
             enrichment: complexity ? deriveSpecEnrichment(complexity) : undefined,
           })
           groupSpecPaths.push(resolvedGroupSpecPath)
         }
 
         // Build master pipeline spec (version 2)
-        const chainPrdContent = await readFile(prdPath, 'utf8')
-        const featureNameMatch = chainPrdContent.match(/^# (.+?)\s*(?:—|-)?\s*PRD/m)
-        const featureName = featureNameMatch
-          ? featureNameMatch[1].trim().toLowerCase().replace(/[^a-z0-9]+/g, '-')
-          : 'feature'
-
         const branchMatch = chainPrdContent.match(/`feat\/([^`]+)`/)
         const branch = branchMatch ? `feat/${branchMatch[1]}` : `feat/${featureName}`
 
@@ -777,6 +951,7 @@ async function generateAndValidateSpec(params: {
   specPath?: string
   skipValidation: boolean
   groupName?: string
+  featureName?: string
   enrichment?: SpecEnrichment
 }): Promise<{ specPath: string; taskPlan: TaskPlan }> {
   const label = params.groupName
@@ -784,6 +959,14 @@ async function generateAndValidateSpec(params: {
     : 'Generating task plan…'
   console.log(c.cyan(`  ${label}`))
 
+  // Temp file for debugging — kept on failure, deleted on success
+  const convoyDir = resolve(process.cwd(), '.opencastle', 'convoys')
+  await mkdir(convoyDir, { recursive: true })
+  const tempJsonName = params.groupName
+    ? `${params.featureName ? `${params.featureName}-` : ''}${params.groupName}.task-plan.json`
+    : `${params.featureName ?? 'task-plan'}.task-plan.json`
+  const tempJsonPath = resolve(convoyDir, tempJsonName)
+
   let taskPlanResult
   try {
     taskPlanResult = await runPromptStep({
@@ -797,12 +980,15 @@ async function generateAndValidateSpec(params: {
     process.exit(1)
   }
 
-  let taskPlan = parseTaskPlan(taskPlanResult.rawOutput)
-  if (!taskPlan) {
-    console.log(c.yellow(`  ⚠ Failed to parse task plan JSON — retrying generation…\n`))
-    if (params.sharedOpts.verbose) {
-      console.log(c.dim(taskPlanResult.rawOutput.slice(0, 500)))
-    }
+  // Write raw JSON to temp file for debugging
+  await writeFile(tempJsonPath, taskPlanResult.rawOutput + '\n', 'utf8')
+
+  let result = parseTaskPlanWithReason(taskPlanResult.rawOutput)
+  if (!result.plan) {
+    console.log(c.yellow(`  ⚠ Failed to parse task plan JSON: ${result.reason}`))
+    console.log(c.dim(`    Output length: ${taskPlanResult.rawOutput.length} chars`))
+    console.log(c.dim(`    Temp file: ${relPath(tempJsonPath)}`))
+    console.log(c.yellow(`    Retrying generation…\n`))
 
     let retryResult
     try {
@@ -817,14 +1003,24 @@ async function generateAndValidateSpec(params: {
       process.exit(1)
     }
 
-    taskPlan = parseTaskPlan(retryResult.rawOutput)
-    if (!taskPlan) {
-      console.error('  ✗ Failed to parse task plan JSON after retry')
-      console.error(c.dim(retryResult.rawOutput.slice(0, 500)))
+    // Overwrite temp file with retry output
+    await writeFile(tempJsonPath, retryResult.rawOutput + '\n', 'utf8')
+
+    result = parseTaskPlanWithReason(retryResult.rawOutput)
+    if (!result.plan) {
+      console.error(`  ✗ Failed to parse task plan JSON after retry: ${result.reason}`)
+      console.error(c.dim(`    Output length: ${retryResult.rawOutput.length} chars`))
+      console.error(c.dim(`    Raw JSON saved to ${relPath(tempJsonPath)} for inspection.`))
+      console.error(c.dim(`\n${retryResult.rawOutput}`))
       process.exit(1)
     }
   }
 
+  let taskPlan = result.plan
+
+  // Success — clean up temp file
+  await unlink(tempJsonPath).catch(() => {})
+
   console.log(c.green(`  ✓ Task plan generated (${taskPlan.tasks.length} tasks)`))
 
   // Derive spec path from plan name if not provided

package/src/cli/plan.ts

@@ -152,8 +152,8 @@ function parseFrontmatter(text: string): Record<string, string> {
 
 /** Extract YAML content from a fenced ```yaml ... ``` block. */
 function extractYamlBlock(text: string): string | null {
-  // 1. Prefer explicit yaml/yml fence
-  const yamlFence = text.match(/```ya?ml\s*\n([\s\S]*?)```/)
+  // 1. Prefer explicit yaml/yml fence — greedy to skip backticks inside content
+  const yamlFence = text.match(/```ya?ml\s*\n([\s\S]*)```/)
   if (yamlFence) return yamlFence[1].trim()
 
   // 2. Fallback: any code fence whose content looks like a convoy spec
@@ -363,6 +363,10 @@ export async function runPromptStep(opts: PromptStepOptions): Promise<PromptStep
     max_retries: 1,
   }
 
+  if (opts.verbose) {
+    console.log(c.dim(`    Adapter: ${adapterName} | Template: ${templateName} | Agent: ${agentField}`))
+  }
+
   const stop = opts.verbose ? null : startProgress(templateName)
   let execResult
   try {
@@ -373,8 +377,20 @@ export async function runPromptStep(opts: PromptStepOptions): Promise<PromptStep
   } finally {
     stop?.()
   }
+
+  if (!execResult.success) {
+    throw new Error(
+      `Adapter "${adapterName}" returned failure (exit code ${execResult.exitCode}) for template "${templateName}".\n` +
+      `Output (${execResult.output.length} chars):\n${execResult.output.slice(0, 2000)}`
+    )
+  }
+
   const rawOutput = execResult.output
 
+  if (opts.verbose) {
+    console.log(c.dim(`    Output: ${rawOutput.length} chars | Exit code: ${execResult.exitCode}`))
+  }
+
   if (outputType === 'validation') {
     const { isValid, errors } = parseValidationResult(rawOutput)
     return { outputPath: null, rawOutput, outputType, isValid, errors }
@@ -382,13 +398,15 @@ export async function runPromptStep(opts: PromptStepOptions): Promise<PromptStep
 
   if (outputType === 'json') {
     // Extract JSON from a ```json fenced block — fail fast if missing
-    const jsonFenceMatch = rawOutput.match(/```json\s*\n([\s\S]*?)```/)
+    // Use greedy match (.*) to capture up to the LAST closing fence,
+    // since task prompts may contain triple backticks in code examples
+    const jsonFenceMatch = rawOutput.match(/```json\s*\n([\s\S]*)```/)
     if (!jsonFenceMatch) {
-      const preview = rawOutput.slice(0, 300)
       throw new Error(
         `Expected a fenced \`\`\`json block in the AI response but found none.\n\n` +
-        `Raw output (truncated):\n${preview}\n\n` +
-        `Tip: re-run with --verbose to see the full output.`
+        `Adapter: ${adapterName} | Output length: ${rawOutput.length} chars\n\n` +
+        `Raw output:\n${rawOutput}\n\n` +
+        `Tip: re-run with --verbose to see the full adapter output.`
       )
     }
     const jsonContent = jsonFenceMatch[1].trim()
@@ -417,7 +435,7 @@ export async function runPromptStep(opts: PromptStepOptions): Promise<PromptStep
   // convoy-spec (default)
   const yamlContent = extractYamlBlock(rawOutput)
   if (!yamlContent) {
-    const preview = rawOutput.slice(0, 500)
+    const preview = rawOutput.slice(0, 10_000)
     throw new Error(
       `No YAML code block found in the agent response.\n\nRaw output (truncated):\n${preview}`
     )

package/src/dashboard/dist/data/convoys/demo-api-v2.json

@@ -51,21 +51,21 @@
       "name": "docs/api-v2-contract.json",
       "type": "json",
       "task_id": "api-t1",
-      "created_at": "2026-03-18T01:38:47.256Z"
+      "created_at": "2026-03-18T16:27:21.682Z"
     },
     {
       "id": "artifact-demo-api-v2-reports-security-gate-failure-md",
       "name": "reports/security-gate-failure.md",
       "type": "summary",
       "task_id": "api-t3",
-      "created_at": "2026-03-18T01:38:47.256Z"
+      "created_at": "2026-03-18T16:27:21.682Z"
     },
     {
       "id": "artifact-demo-api-v2-src-api-rate-limiter-ts",
       "name": "src/api/rate-limiter.ts",
       "type": "file",
       "task_id": "api-t2",
-      "created_at": "2026-03-18T01:38:47.256Z"
+      "created_at": "2026-03-18T16:27:21.682Z"
     }
   ],
   "has_more_events": false,