opencastle 0.30.1 → 0.31.0

package/src/cli/pipeline.ts

@@ -4,6 +4,7 @@ import { resolve, dirname } from 'node:path'
 import { stringify } from 'yaml'
 import { c, confirm, closePrompts } from './prompt.js'
 import { runPromptStep, readProjectMcpServers } from './plan.js'
+import { cleanupAdapters } from './run/adapters/index.js'
 import type { CliContext } from './types.js'
 
 export interface ConvoyGroup {
@@ -14,6 +15,7 @@ export interface ConvoyGroup {
 }
 
 export interface ComplexityAssessment {
+  original_prompt: string
   total_tasks: number
   total_phases: number
   domains: string[]
@@ -24,18 +26,12 @@ export interface ComplexityAssessment {
   convoy_groups: ConvoyGroup[]
 }
 
-export function parseComplexityAssessment(prdContent: string): ComplexityAssessment | null {
-  const sectionMatch = prdContent.match(/## Complexity Assessment\s+([\s\S]*?)(?=\n## |\n# |$)/)
-  if (!sectionMatch) return null
-
-  const sectionContent = sectionMatch[1]
-  const jsonMatch = sectionContent.match(/```json\s*([\s\S]*?)```/)
-  if (!jsonMatch) return null
-
+export function parseComplexityAssessment(jsonText: string): ComplexityAssessment | null {
   try {
-    const parsed = JSON.parse(jsonMatch[1].trim()) as ComplexityAssessment
+    const parsed = JSON.parse(jsonText.trim()) as ComplexityAssessment
     // Validate required fields
     if (
+      typeof parsed.original_prompt !== 'string' ||
       typeof parsed.total_tasks !== 'number' ||
       typeof parsed.total_phases !== 'number' ||
       !Array.isArray(parsed.domains) ||
@@ -59,9 +55,10 @@ const HELP = `
     Step 1 — Generate PRD        (generate-prd)
     Step 2 — Validate PRD        (validate-prd)
     Step 3 — Fix PRD             (fix-prd, up to 2 retries if invalid)
-    Step 4 — Generate convoy spec (generate-convoy, using PRD as BDO)
-    Step 5 — Validate convoy spec (validate-convoy)
-    Step 6 — Fix convoy spec      (fix-convoy, up to 2 retries if invalid)
+    Step 4 — Assess complexity    (assess-complexity, determines single vs chain)
+    Step 5 — Generate convoy spec (generate-convoy, using PRD as input)
+    Step 6 — Validate convoy spec (validate-convoy)
+    Step 7 — Fix convoy spec      (fix-convoy, up to 2 retries if invalid)
 
   Options:
     --text, -t <text>        Feature prompt text (required, unless --prd is set)
@@ -71,7 +68,7 @@ const HELP = `
     --adapter, -a <name>     Override agent runtime adapter
     --verbose                Show full agent output for each step
     --dry-run                Generate and print the PRD prompt only, then stop
-    --skip-validation        Skip steps 2 and 4 (PRD and convoy validation)
+    --skip-validation        Skip PRD and convoy validation (steps 2, 3, 6, 7)
     --help, -h               Show this help
 `
 
@@ -149,6 +146,8 @@ function parseArgs(args: string[]): PipelineOptions {
   return opts
 }
 
+const MAX_FIX_RETRIES = 2
+
 function relPath(abs: string): string {
   return abs.startsWith(process.cwd()) ? abs.slice(process.cwd().length + 1) : abs
 }
@@ -184,7 +183,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     }
   }
 
-  const totalSteps = opts.skipValidation ? 3 : 6
+  const totalSteps = opts.skipValidation ? 4 : 7
   const mcpServers = await readProjectMcpServers(process.cwd())
   const sharedOpts = {
     adapterName: opts.adapter ?? undefined,
@@ -320,8 +319,26 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
   }
 
   // ── Complexity-aware strategy decision ────────────────────────────────────
-  const prdContentForComplexity = await readFile(prdPath, 'utf8')
-  const complexity = parseComplexityAssessment(prdContentForComplexity)
+  const complexityStep = opts.skipValidation ? 2 : 4
+  console.log(stepLabel(complexityStep, totalSteps, 'Assessing complexity…'))
+
+  let complexity: ComplexityAssessment | null = null
+  try {
+    const complexityResult = await runPromptStep({
+      ...sharedOpts,
+      template: 'assess-complexity',
+      filePath: prdPath,
+      contextText: opts.text ?? undefined,
+    })
+    complexity = parseComplexityAssessment(complexityResult.rawOutput)
+  } 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`))
+  }
+
+  if (!complexity) {
+    console.log(c.dim(`  Could not determine complexity — using single convoy strategy.\n`))
+  }
 
   if (complexity) {
     if (complexity.recommended_strategy === 'chain' && complexity.convoy_groups.length > 1) {
@@ -360,16 +377,21 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
           )
         )
 
-        const chainContext = JSON.stringify({
-          mode: 'chain_subset',
-          group_name: group.name,
-          group_description: group.description,
-          group_phases: group.phases,
-          depends_on_groups: group.depends_on,
-          total_groups: complexity.convoy_groups.length,
-          group_index: i + 1,
-        })
-
+        const chainGoal = [
+          complexity.original_prompt,
+          '',
+          '## Convoy Group Scope',
+          '',
+          `This is group **${i + 1} of ${complexity.convoy_groups.length}** in a convoy chain.`,
+          `Generate a convoy spec covering ONLY the phases listed below.`,
+          '',
+          `- **Group name:** ${group.name}`,
+          `- **Description:** ${group.description}`,
+          `- **Phases to include:** ${group.phases.join(', ')}`,
+          group.depends_on.length ? `- **Depends on groups:** ${group.depends_on.join(', ')}` : '',
+        ].filter(Boolean).join('\n')
+
+        const prdContent = await readFile(prdPath, 'utf8')
         const groupSpecPath = resolve(convoyDir, `${group.name}.convoy.yml`)
 
         let groupResult
@@ -377,8 +399,8 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
           groupResult = await runPromptStep({
             ...sharedOpts,
             template: 'generate-convoy',
-            filePath: prdPath,
-            contextText: chainContext,
+            goalText: chainGoal,
+            contextText: prdContent,
             outputPath: groupSpecPath,
           })
         } catch (err) {
@@ -397,13 +419,13 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
           const valStep = groupStep + 1
           console.log(stepLabel(valStep, totalGroupSteps, `Validating spec: ${group.name}…`))
 
-          const groupSpecContent = await readFile(resolvedGroupSpecPath, 'utf8')
+          let currentSpecContent = await readFile(resolvedGroupSpecPath, 'utf8')
           let groupValidation
           try {
             groupValidation = await runPromptStep({
               ...sharedOpts,
               template: 'validate-convoy',
-              goalText: groupSpecContent,
+              goalText: currentSpecContent,
             })
           } catch (err) {
             console.error(
@@ -412,40 +434,92 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
             process.exit(1)
           }
 
-          if (!groupValidation.isValid) {
-            console.log(c.yellow(`  ⚠ Spec has issues — attempting one auto-fix…\n`))
-            console.log(c.dim(groupValidation.errors ?? groupValidation.rawOutput))
-            console.log()
-
-            try {
-              await runPromptStep({
-                ...sharedOpts,
-                template: 'fix-convoy',
-                goalText: groupSpecContent,
-                contextText: groupValidation.errors ?? groupValidation.rawOutput,
-                outputPath: resolvedGroupSpecPath,
-              })
-            } catch (err) {
-              console.error(
-                `\n  ✗ Fix failed for group ${group.name}: ${err instanceof Error ? err.message : String(err)}`
+          if (groupValidation.isValid) {
+            console.log(c.green(`  ✓ Spec valid\n`))
+          } else {
+            let groupErrors = groupValidation.errors ?? groupValidation.rawOutput
+            let groupFixed = false
+
+            for (let attempt = 1; attempt <= MAX_FIX_RETRIES; attempt++) {
+              console.log(
+                c.yellow(`  ⚠ Spec has issues — fix attempt ${attempt}/${MAX_FIX_RETRIES} for ${group.name}…\n`)
               )
-              process.exit(1)
+              console.log(c.dim(groupErrors))
+              console.log()
+
+              try {
+                await runPromptStep({
+                  ...sharedOpts,
+                  template: 'fix-convoy',
+                  goalText: currentSpecContent,
+                  contextText: groupErrors,
+                  outputPath: resolvedGroupSpecPath,
+                })
+              } catch (err) {
+                console.error(
+                  `\n  ✗ Fix failed for group ${group.name} (attempt ${attempt}): ${err instanceof Error ? err.message : String(err)}`
+                )
+                process.exit(1)
+              }
+
+              console.log(c.dim(`  Re-validating ${group.name} after fix…`))
+
+              currentSpecContent = await readFile(resolvedGroupSpecPath, 'utf8')
+
+              let revalidation
+              try {
+                revalidation = await runPromptStep({
+                  ...sharedOpts,
+                  template: 'validate-convoy',
+                  goalText: currentSpecContent,
+                })
+              } catch (err) {
+                console.error(
+                  `\n  ✗ Re-validation failed for group ${group.name}: ${err instanceof Error ? err.message : String(err)}`
+                )
+                process.exit(1)
+              }
+
+              if (revalidation.isValid) {
+                console.log(c.green(`  ✓ ${group.name} fixed and validated\n`))
+                groupFixed = true
+                break
+              }
+
+              groupErrors = revalidation.errors ?? revalidation.rawOutput
+
+              if (attempt < MAX_FIX_RETRIES) {
+                console.log(
+                  c.yellow(`  ⚠ Still has issues after fix attempt ${attempt} — retrying…\n`)
+                )
+              }
             }
 
-            console.log(c.dim(`  Applied fix for ${group.name}\n`))
-          } else {
-            console.log(c.green(`  ✓ Spec valid\n`))
+            if (!groupFixed) {
+              console.log(
+                c.red(`\n  ✗ Could not auto-fix convoy spec for group ${group.name} after ${MAX_FIX_RETRIES} attempts.\n`)
+              )
+              console.log(`  Remaining issues:\n`)
+              console.log(groupErrors)
+              console.log(
+                c.dim(`\n  The spec has been saved to ${relPath(resolvedGroupSpecPath)} with best available fixes.\n`) +
+                  c.dim(`  Review the issues above and edit manually, then re-validate with:\n`) +
+                  `    opencastle plan --file ${relPath(resolvedGroupSpecPath)} --template validate-convoy\n`
+              )
+              process.exit(1)
+            }
           }
         }
       }
 
       // Build master pipeline spec (version 2)
-      const featureNameMatch = prdContentForComplexity.match(/^# (.+?)\s*(?:—|-)?\s*PRD/m)
+      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 = prdContentForComplexity.match(/`feat\/([^`]+)`/)
+      const branchMatch = chainPrdContent.match(/`feat\/([^`]+)`/)
       const branch = branchMatch ? `feat/${branchMatch[1]}` : `feat/${featureName}`
 
       const masterSpec = {
@@ -482,6 +556,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
         }
       } finally {
         closePrompts()
+        await cleanupAdapters()
       }
       return
     } else {
@@ -491,16 +566,20 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     }
   }
 
-  // ── Step 4: Generate convoy spec ──────────────────────────────────────────
-  const genStep = opts.skipValidation ? 2 : 4
+  // ── Generate convoy spec ──────────────────────────────────────────────────
+  const genStep = opts.skipValidation ? 3 : 5
   console.log(stepLabel(genStep, totalSteps, 'Generating convoy spec…'))
 
+  const singlePrdContent = await readFile(prdPath, 'utf8')
+  const singleGoal = complexity?.original_prompt ?? opts.text ?? ''
+
   let specPath: string
   try {
     const result = await runPromptStep({
       ...sharedOpts,
       template: 'generate-convoy',
-      filePath: prdPath,
+      goalText: singleGoal,
+      contextText: singlePrdContent,
       outputPath: opts.outputSpec ? resolve(process.cwd(), opts.outputSpec) : undefined,
     })
     specPath = result.outputPath!
@@ -516,8 +595,9 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     return
   }
 
-  // ── Step 5: Validate convoy spec ──────────────────────────────────────────
-  console.log(stepLabel(5, totalSteps, 'Validating convoy spec…'))
+  // ── Validate convoy spec ──────────────────────────────────────────────
+  const valStep = opts.skipValidation ? 4 : 6
+  console.log(stepLabel(valStep, totalSteps, 'Validating convoy spec…'))
 
   const specContent = await readFile(specPath, 'utf8')
   let validationErrors: string
@@ -531,7 +611,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
         goalText: specContent,
       })
     } catch (err) {
-      console.error(`\n  ✗ Step 5 failed: ${err instanceof Error ? err.message : String(err)}`)
+      console.error(`\n  ✗ Step ${valStep} failed: ${err instanceof Error ? err.message : String(err)}`)
       process.exit(1)
     }
 
@@ -547,13 +627,13 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     console.log()
   }
 
-  // ── Step 6: Fix convoy spec (up to 2 retries) ─────────────────────────────
-  const MAX_FIX_RETRIES = 2
+  // ── Fix convoy spec (up to 2 retries) ─────────────────────────────────
+  const fixStep = opts.skipValidation ? 4 : 7
   let fixedSpecContent = specContent
 
   for (let attempt = 1; attempt <= MAX_FIX_RETRIES; attempt++) {
     const label = `Fix attempt ${attempt}/${MAX_FIX_RETRIES}…`
-    console.log(stepLabel(6, totalSteps, label))
+    console.log(stepLabel(fixStep, totalSteps, label))
 
     let fixResult
     try {
@@ -641,5 +721,6 @@ async function printFinalSummary(
     }
   } finally {
     closePrompts()
+    await cleanupAdapters()
   }
 }

package/src/cli/plan.ts

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { resolve, join, basename } from 'node:path'
 import { mkdir, writeFile } from 'node:fs/promises'
-import { getAdapter, detectAdapter } from './run/adapters/index.js'
+import { getAdapter, detectAdapter, cleanupAdapters } from './run/adapters/index.js'
 import { parseTaskSpecText } from './run/schema.js'
 import { c } from './prompt.js'
 import type { CliContext, Task } from './types.js'
@@ -19,11 +19,13 @@ const HELP = `
     --text, -t <text>        Inline text to use as {{goal}} (alternative to --file)
     --template <name>        Prompt template name (default: generate-convoy)
                              Built-in templates:
-                               generate-prd      — Write a PRD from a feature prompt
-                               validate-prd      — Check a PRD for completeness
-                               generate-convoy   — Generate a convoy spec from a PRD (default)
-                               validate-convoy   — Check a convoy spec for correctness
-                               fix-convoy        — Fix validation errors in a convoy spec
+                               generate-prd        — Write a PRD from a feature prompt
+                               validate-prd        — Check a PRD for completeness
+                               fix-prd             — Fix validation errors in a PRD
+                               assess-complexity   — Assess PRD complexity (returns JSON)
+                               generate-convoy     — Generate a convoy spec from a PRD (default)
+                               validate-convoy     — Check a convoy spec for correctness
+                               fix-convoy          — Fix validation errors in a convoy spec
     --context <path>         Optional path to an additional context file (fills {{context}})
     --context-text <text>    Inline text to fill {{context}} (alternative to --context)
     --output, -o <path>      Output path override (skipped for validation output)
@@ -77,7 +79,7 @@ export interface PromptStepResult {
   /** Raw text returned by the AI adapter (or assembled prompt on dry-run) */
   rawOutput: string
   /** How the output was interpreted */
-  outputType: 'convoy-spec' | 'prd' | 'validation'
+  outputType: 'convoy-spec' | 'prd' | 'validation' | 'json'
   /** Set when outputType === 'validation' */
   isValid?: boolean
   /** Set when outputType === 'validation' and isValid === false */
@@ -150,9 +152,19 @@ function parseFrontmatter(text: string): Record<string, string> {
 
 /** Extract YAML content from a fenced ```yaml ... ``` block. */
 function extractYamlBlock(text: string): string | null {
-  const match = text.match(/```ya?ml\s*\n([\s\S]*?)```/)
-  if (!match) return null
-  return match[1].trim()
+  // 1. Prefer explicit yaml/yml fence
+  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
+  //    Must contain at least `name:` AND `tasks:` to avoid false positives
+  const genericFences = [...text.matchAll(/```\s*\n([\s\S]*?)```/g)]
+  for (const m of genericFences) {
+    const content = m[1].trim()
+    if (/^name:/m.test(content) && /^tasks:/m.test(content)) return content
+  }
+
+  return null
 }
 
 /**
@@ -274,7 +286,7 @@ export async function runPromptStep(opts: PromptStepOptions): Promise<PromptStep
 
   const rawTemplate = await readFile(templatePath, 'utf8')
   const frontmatter = parseFrontmatter(rawTemplate)
-  const outputType = (frontmatter['output'] ?? 'convoy-spec') as 'convoy-spec' | 'prd' | 'validation'
+  const outputType = (frontmatter['output'] ?? 'convoy-spec') as 'convoy-spec' | 'prd' | 'validation' | 'json'
   const template = stripFrontmatter(rawTemplate)
 
   let goalContent = opts.goalText ?? ''
@@ -351,6 +363,18 @@ export async function runPromptStep(opts: PromptStepOptions): Promise<PromptStep
     return { outputPath: null, rawOutput, outputType, isValid, errors }
   }
 
+  if (outputType === 'json') {
+    // Extract JSON from fenced block or raw output
+    const jsonMatch = rawOutput.match(/```(?:json)?\s*\n([\s\S]*?)```/)
+    const jsonContent = jsonMatch ? jsonMatch[1].trim() : rawOutput.trim()
+    const outputPath = opts.outputPath ?? null
+    if (outputPath) {
+      await mkdir(resolve(outputPath, '..'), { recursive: true })
+      await writeFile(outputPath, jsonContent + '\n', 'utf8')
+    }
+    return { outputPath, rawOutput: jsonContent, outputType }
+  }
+
   if (outputType === 'prd') {
     const content = extractMarkdownBody(rawOutput)
     let outputPath = opts.outputPath ?? null
@@ -585,6 +609,16 @@ export default async function plan({ args, pkgRoot }: CliContext): Promise<void>
       console.log(`\n  ${c.dim('Next step:')} opencastle plan --file ${relPath} --template validate-prd`)
       break
     }
+    case 'json': {
+      if (result.outputPath) {
+        const relP = result.outputPath.startsWith(process.cwd())
+          ? result.outputPath.slice(process.cwd().length + 1)
+          : result.outputPath
+        console.log(c.green(`  ✓ JSON written to ${relP}`))
+      }
+      console.log(result.rawOutput)
+      break
+    }
     default: {
       const relPath = result.outputPath!.startsWith(process.cwd())
         ? result.outputPath!.slice(process.cwd().length + 1)
@@ -599,4 +633,6 @@ export default async function plan({ args, pkgRoot }: CliContext): Promise<void>
 `)
     }
   }
+
+  await cleanupAdapters()
 }

package/src/cli/run/adapters/copilot.ts

@@ -108,7 +108,7 @@ async function executeViaSdk(task: Task, options: ExecuteOptions = {}): Promise<
     } : undefined
     return {
       success: true,
-      output: output.slice(0, 10_000),
+      output: output.slice(0, 100_000),
       exitCode: 0,
       usage: usageResult,
     }
@@ -246,3 +246,13 @@ export function kill(task: Task): void {
   if (mode === 'sdk') killSdk(task)
   else killCli(task)
 }
+
+export async function cleanup(): Promise<void> {
+  if (clientPromise) {
+    try {
+      const client = await clientPromise
+      await client.stop()
+    } catch { /* ignore */ }
+    clientPromise = null
+  }
+}

package/src/cli/run/adapters/index.ts

@@ -45,6 +45,19 @@ export async function detectAdapter(): Promise<string | null> {
   return null
 }
 
+/**
+ * Clean up all loaded adapters (stop SDK clients, close connections).
+ * Call this before process exit to avoid hanging.
+ */
+export async function cleanupAdapters(): Promise<void> {
+  for (const loader of Object.values(ADAPTERS)) {
+    try {
+      const mod = await loader()
+      await mod.cleanup?.()
+    } catch { /* ignore */ }
+  }
+}
+
 /**
  * List all registered adapters with their availability status.
  */

package/src/cli/run.ts

@@ -756,6 +756,31 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
     if (spec.branch) console.log(`  Branch: ${spec.branch}`)
     if (spec.gates?.length) console.log(`  Gates: ${spec.gates.length} validation commands`)
 
+    // ── Pre-flight: handle uncommitted changes before branch switch ──
+    let pipelineDidStash = false
+    if (spec.branch) {
+      const { execFile: execFileCb } = await import('node:child_process')
+      const { promisify } = await import('node:util')
+      const execFile = promisify(execFileCb)
+      const { stdout: statusOut } = await execFile('git', ['status', '--porcelain'], {
+        cwd: process.cwd(),
+      })
+      if (statusOut.trim()) {
+        console.log(`\n  ${c.yellow('⚠')} Uncommitted changes detected.`)
+        const shouldStash = await confirm('Stash changes and continue?', true)
+        if (!shouldStash) {
+          console.log('  Aborted. Commit or stash your changes manually, then retry.')
+          closePrompts()
+          process.exit(1)
+        }
+        await execFile('git', ['stash', 'push', '-m', 'opencastle: auto-stash before pipeline'], {
+          cwd: process.cwd(),
+        })
+        pipelineDidStash = true
+        console.log(`  ${c.green('✓')} Changes stashed.`)
+      }
+    }
+
     const { startDashboardServer } = await import('./dashboard.js')
     let pipelineDashboardResult: { server: import('node:http').Server; port: number; url: string } | null = null
     try {
@@ -789,12 +814,31 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
       throw err
     }
     printPipelineResult(pipelineResult)
+    if (pipelineDidStash) {
+      const { execFile: execFileCb } = await import('node:child_process')
+      const { promisify } = await import('node:util')
+      const execFile = promisify(execFileCb)
+      try {
+        await execFile('git', ['stash', 'pop'], { cwd: process.cwd() })
+        console.log(`  ${c.green('✓')} Stashed changes restored.`)
+      } catch {
+        console.log(`  ${c.yellow('⚠')} Could not restore stash automatically. Run \`git stash pop\` manually.`)
+      }
+    }
     if (pipelineDashboardResult) {
       console.log(`\n  ${c.dim('Results saved to .opencastle/convoy.db')}`)
-      console.log(`  ${c.dim('View again:')} opencastle dashboard`)
-      pipelineDashboardResult.server.close()
+      console.log(`  ${c.dim('Dashboard:')} ${pipelineDashboardResult.url}`)
+      console.log(`\n  Press Ctrl+C to stop`)
+      const exitCode = pipelineResult.status !== 'done' ? 1 : 0
+      process.on('SIGINT', () => {
+        console.log('\n  Dashboard stopped.\n')
+        pipelineDashboardResult!.server.close()
+        process.exit(exitCode)
+      })
+    } else {
+      process.exit(pipelineResult.status !== 'done' ? 1 : 0)
     }
-    process.exit(pipelineResult.status !== 'done' ? 1 : 0)
+    return
   }
 
   // ── Convoy engine path (version: 1 specs) ────────────────────
@@ -882,11 +926,6 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
       throw err
     }
     printConvoyResult(result)
-    if (dashboardResult) {
-      console.log(`\n  ${c.dim('Results saved to .opencastle/convoy.db')}`)
-      console.log(`  ${c.dim('View again:')} opencastle dashboard`)
-      dashboardResult.server.close()
-    }
     if (didStash) {
       const { execFile: execFileCb } = await import('node:child_process')
       const { promisify } = await import('node:util')
@@ -898,7 +937,19 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
         console.log(`  ${c.yellow('⚠')} Could not restore stash automatically. Run \`git stash pop\` manually.`)
       }
     }
-    process.exit(result.status !== 'done' ? 1 : 0)
+    if (dashboardResult) {
+      console.log(`\n  ${c.dim('Results saved to .opencastle/convoy.db')}`)
+      console.log(`  ${c.dim('Dashboard:')} ${dashboardResult.url}`)
+      console.log(`\n  Press Ctrl+C to stop`)
+      const exitCode = result.status !== 'done' ? 1 : 0
+      process.on('SIGINT', () => {
+        console.log('\n  Dashboard stopped.\n')
+        dashboardResult!.server.close()
+        process.exit(exitCode)
+      })
+    } else {
+      process.exit(result.status !== 'done' ? 1 : 0)
+    }
   }
 
   // ── Legacy executor path ──────────────────────────────────────

package/src/cli/types.ts

@@ -300,6 +300,8 @@ export interface AgentAdapter {
   kill?(_task: Task): void;
   /** Whether the adapter supports reusing sessions across multi-step task steps. Defaults to false. */
   supportsSessionContinuity?(): boolean;
+  /** Clean up any long-lived resources (SDK clients, open connections) so the process can exit. */
+  cleanup?(): Promise<void>;
 }
 
 /** Options for agent execution. */

package/src/dashboard/node_modules/.vite/deps/_metadata.json

@@ -1,25 +1,25 @@
 {
-  "hash": "019f3d08",
+  "hash": "92391349",
   "configHash": "30f8ea04",
-  "lockfileHash": "d116e77a",
-  "browserHash": "68231191",
+  "lockfileHash": "f32f6327",
+  "browserHash": "a3143d98",
   "optimized": {
     "astro > cssesc": {
       "src": "../../../../../node_modules/cssesc/cssesc.js",
       "file": "astro___cssesc.js",
-      "fileHash": "f4a93516",
+      "fileHash": "4da4d2a1",
       "needsInterop": true
     },
     "astro > aria-query": {
       "src": "../../../../../node_modules/aria-query/lib/index.js",
       "file": "astro___aria-query.js",
-      "fileHash": "3b18a33f",
+      "fileHash": "65e6b113",
       "needsInterop": true
     },
     "astro > axobject-query": {
       "src": "../../../../../node_modules/axobject-query/lib/index.js",
       "file": "astro___axobject-query.js",
-      "fileHash": "dc8d5b49",
+      "fileHash": "bd7268ed",
       "needsInterop": true
     }
   },