opencastle 0.22.0 → 0.23.1

package/src/cli/run/schema.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { parseYaml, parseTimeout, validateSpec, applyDefaults, isConvoySpec, parseTaskSpecText } from './schema.js'
+import { parseYaml, parseTimeout, validateSpec, applyDefaults, isConvoySpec, isPipelineSpec, parseTaskSpecText } from './schema.js'
 
 // ── parseYaml ──────────────────────────────────────────────────
 
@@ -365,12 +365,18 @@ describe('validateSpec — version field', () => {
     expect(result.errors).toHaveLength(0)
   })
 
-  it('rejects version 2', () => {
-    const result = validateSpec({ ...validSpec, version: 2 })
+  it('rejects version 3', () => {
+    const result = validateSpec({ ...validSpec, version: 3 })
     expect(result.valid).toBe(false)
     expect(result.errors).toContainEqual(expect.stringContaining('version'))
   })
 
+  it('accepts version 2', () => {
+    const result = validateSpec({ ...validSpec, version: 2 })
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
   it('rejects non-integer version', () => {
     const result = validateSpec({ ...validSpec, version: 1.5 })
     expect(result.valid).toBe(false)
@@ -614,14 +620,20 @@ describe('isConvoySpec', () => {
     ).toBe(true)
   })
 
+  it('returns true for version 2 spec', () => {
+    expect(
+      isConvoySpec({ name: 'test', version: 2, depends_on_convoy: ['other-convoy'] })
+    ).toBe(true)
+  })
+
   it('returns false for legacy spec without version', () => {
     expect(
       isConvoySpec({ name: 'test', tasks: [{ id: 'a', prompt: 'x' }] })
     ).toBe(false)
   })
 
-  it('returns false for version 2', () => {
-    expect(isConvoySpec({ name: 'test', version: 2 })).toBe(false)
+  it('returns false for version 3', () => {
+    expect(isConvoySpec({ name: 'test', version: 3 })).toBe(false)
   })
 
   it('returns false for null input', () => {
@@ -921,3 +933,230 @@ tasks:
     expect(isConvoySpec(spec)).toBe(true)
   })
 })
+
+// ── validateSpec — depends_on_convoy / pipeline specs ──────────
+
+describe('validateSpec — depends_on_convoy field', () => {
+  it('accepts depends_on_convoy as an array of strings', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1', 'phase-2'],
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('rejects depends_on_convoy as a string (not array)', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: 'phase-1',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('depends_on_convoy'))
+  })
+
+  it('rejects depends_on_convoy with non-string elements', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1', 42],
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('depends_on_convoy'))
+  })
+
+  it('rejects depends_on_convoy as a non-array object', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: { convoy: 'phase-1' },
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('depends_on_convoy'))
+  })
+
+  it('accepts omitting depends_on_convoy entirely (optional field)', () => {
+    const result = validateSpec({
+      name: 'convoy-run',
+      version: 1,
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(result.valid).toBe(true)
+  })
+})
+
+// ── validateSpec — pipeline spec (v2 tasks-optional) ──────────
+
+describe('validateSpec — pipeline spec (version:2, no tasks)', () => {
+  it('pipeline spec with no tasks is valid when depends_on_convoy is set', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1'],
+    })
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('pipeline spec with tasks AND depends_on_convoy is valid', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1'],
+      tasks: [{ id: 'a', prompt: 'do local work' }],
+    })
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('version:2 without depends_on_convoy still requires tasks', () => {
+    const result = validateSpec({
+      name: 'convoy-v2',
+      version: 2,
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('tasks'))
+  })
+
+  it('pipeline spec with empty depends_on_convoy still requires tasks', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: [],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('tasks'))
+  })
+
+  it('pipeline spec with explicitly empty tasks array is invalid', () => {
+    const result = validateSpec({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1'],
+      tasks: [],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('non-empty'))
+  })
+})
+
+// ── isPipelineSpec ─────────────────────────────────────────────
+
+describe('isPipelineSpec', () => {
+  it('returns true for version:2 spec with non-empty depends_on_convoy', () => {
+    expect(
+      isPipelineSpec({ name: 'pipeline', version: 2, depends_on_convoy: ['phase-1'] })
+    ).toBe(true)
+  })
+
+  it('returns true when depends_on_convoy has multiple entries', () => {
+    expect(
+      isPipelineSpec({ name: 'pipeline', version: 2, depends_on_convoy: ['a', 'b', 'c'] })
+    ).toBe(true)
+  })
+
+  it('returns false for v1 spec without depends_on_convoy', () => {
+    expect(
+      isPipelineSpec({ name: 'convoy', version: 1, tasks: [{ id: 'a', prompt: 'x' }] })
+    ).toBe(false)
+  })
+
+  it('returns false for v1 spec even with depends_on_convoy (wrong version)', () => {
+    expect(
+      isPipelineSpec({ name: 'convoy', version: 1, depends_on_convoy: ['phase-1'] })
+    ).toBe(false)
+  })
+
+  it('returns false for version:2 with empty depends_on_convoy', () => {
+    expect(
+      isPipelineSpec({ name: 'pipeline', version: 2, depends_on_convoy: [] })
+    ).toBe(false)
+  })
+
+  it('returns false for version:2 without depends_on_convoy', () => {
+    expect(
+      isPipelineSpec({ name: 'convoy', version: 2, tasks: [{ id: 'a', prompt: 'x' }] })
+    ).toBe(false)
+  })
+
+  it('returns false for legacy spec (no version)', () => {
+    expect(
+      isPipelineSpec({ name: 'legacy', tasks: [{ id: 'a', prompt: 'x' }] })
+    ).toBe(false)
+  })
+
+  it('returns false for null input', () => {
+    expect(isPipelineSpec(null)).toBe(false)
+  })
+
+  it('returns false for non-object input', () => {
+    expect(isPipelineSpec('string')).toBe(false)
+  })
+})
+
+// ── isConvoySpec — version 1 and 2 ────────────────────────────
+
+describe('isConvoySpec — version 1 and 2', () => {
+  it('returns true for version 1 spec', () => {
+    expect(isConvoySpec({ version: 1, tasks: [] })).toBe(true)
+  })
+
+  it('returns true for version 2 pipeline spec', () => {
+    expect(isConvoySpec({ version: 2, depends_on_convoy: ['phase-1'] })).toBe(true)
+  })
+
+  it('returns true for version 2 spec with tasks', () => {
+    expect(isConvoySpec({ version: 2, tasks: [{ id: 'a', prompt: 'x' }] })).toBe(true)
+  })
+
+  it('returns false for legacy spec (no version)', () => {
+    expect(isConvoySpec({ name: 'legacy', tasks: [] })).toBe(false)
+  })
+
+  it('returns false for version 3', () => {
+    expect(isConvoySpec({ version: 3 })).toBe(false)
+  })
+})
+
+// ── applyDefaults — pipeline spec (version:2, no tasks) ────────
+
+describe('applyDefaults — pipeline spec (version:2, no tasks)', () => {
+  it('pipeline spec with no tasks produces empty tasks array', () => {
+    const spec = applyDefaults({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1'],
+    })
+    expect(spec.tasks).toBeUndefined()
+    expect(spec.name).toBe('pipeline')
+    expect(spec.version).toBe(2)
+    expect(spec.depends_on_convoy).toEqual(['phase-1'])
+  })
+
+  it('pipeline spec with tasks applies defaults normally', () => {
+    const spec = applyDefaults({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1'],
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.tasks).toHaveLength(1)
+    expect(spec.tasks![0].agent).toBe('developer')
+    expect(spec.tasks![0].timeout).toBe('30m')
+  })
+
+  it('preserves depends_on_convoy through applyDefaults', () => {
+    const spec = applyDefaults({
+      name: 'pipeline',
+      version: 2,
+      depends_on_convoy: ['phase-1', 'phase-2'],
+    })
+    expect(spec.depends_on_convoy).toEqual(['phase-1', 'phase-2'])
+  })
+})

package/src/cli/run/schema.ts

@@ -43,6 +43,7 @@ interface RawSpec {
   defaults?: unknown
   gates?: unknown
   branch?: unknown
+  depends_on_convoy?: unknown
 }
 
 interface RawTask {
@@ -99,8 +100,18 @@ export function validateSpec(spec: unknown): ValidationResult {
 
   // version
   if (s.version !== undefined) {
-    if (typeof s.version !== 'number' || !Number.isInteger(s.version) || s.version !== 1) {
-      errors.push('`version` must be 1')
+    if (typeof s.version !== 'number' || !Number.isInteger(s.version) || (s.version !== 1 && s.version !== 2)) {
+      errors.push('`version` must be 1 or 2')
+    }
+  }
+
+  // depends_on_convoy
+  if (s.depends_on_convoy !== undefined) {
+    if (
+      !Array.isArray(s.depends_on_convoy) ||
+      !(s.depends_on_convoy as unknown[]).every((c) => typeof c === 'string')
+    ) {
+      errors.push('`depends_on_convoy` must be an array of strings')
     }
   }
 
@@ -148,12 +159,28 @@ export function validateSpec(spec: unknown): ValidationResult {
     errors.push('`branch` must be a string')
   }
 
-  // Tasks are always required
-  if (!s.tasks || !Array.isArray(s.tasks) || s.tasks.length === 0) {
-    errors.push('`tasks` is required and must be a non-empty array')
+  // Tasks: required unless this is a version:2 pipeline spec with depends_on_convoy
+  const isPipeline =
+    s.version === 2 &&
+    Array.isArray(s.depends_on_convoy) &&
+    (s.depends_on_convoy as unknown[]).length > 0
+
+  if (!isPipeline) {
+    if (!s.tasks || !Array.isArray(s.tasks) || s.tasks.length === 0) {
+      errors.push('`tasks` is required and must be a non-empty array')
+      return { valid: false, errors }
+    }
+  } else if (s.tasks !== undefined && (!Array.isArray(s.tasks) || s.tasks.length === 0)) {
+    // Pipeline spec may omit tasks entirely, but if present they must be non-empty
+    errors.push('`tasks`, when provided, must be a non-empty array')
     return { valid: false, errors }
   }
 
+  // Skip per-task validation when pipeline spec has no tasks
+  if (isPipeline && !s.tasks) {
+    return { valid: errors.length === 0, errors }
+  }
+
   const taskIds = new Set<string>()
   const tasks = s.tasks as RawTask[]
 
@@ -293,7 +320,7 @@ export function applyDefaults(spec: Record<string, unknown>): TaskSpec {
   // Leave adapter empty so run.ts can auto-detect the best available CLI
   s.adapter = (s.adapter as string) || ''
 
-  const tasks = s.tasks as Array<Record<string, unknown>>
+  const tasks = (s.tasks as Array<Record<string, unknown>> | undefined) ?? []
   const d =
     s.version === 1 && s.defaults
       ? (s.defaults as Record<string, unknown>)
@@ -327,11 +354,25 @@ export function applyDefaults(spec: Record<string, unknown>): TaskSpec {
 }
 
 /**
- * Returns true if the spec uses the Convoy Engine enhanced format (version: 1).
+ * Returns true if the spec uses the Convoy Engine enhanced format (version: 1 or 2).
  */
 export function isConvoySpec(spec: unknown): boolean {
   if (!spec || typeof spec !== 'object') return false
-  return (spec as Record<string, unknown>).version === 1
+  const v = (spec as Record<string, unknown>).version
+  return v === 1 || v === 2
+}
+
+/**
+ * Returns true if the spec is a pipeline spec (version: 2 + non-empty depends_on_convoy).
+ */
+export function isPipelineSpec(spec: unknown): boolean {
+  if (!spec || typeof spec !== 'object') return false
+  const s = spec as Record<string, unknown>
+  return (
+    s.version === 2 &&
+    Array.isArray(s.depends_on_convoy) &&
+    (s.depends_on_convoy as unknown[]).length > 0
+  )
 }
 
 /**

package/src/cli/run.ts

@@ -1,12 +1,13 @@
 import { readFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
-import { parseTaskSpecText, isConvoySpec } from './run/schema.js'
+import { parseTaskSpecText, isConvoySpec, isPipelineSpec } from './run/schema.js'
 import { createExecutor, buildPhases } from './run/executor.js'
 import { getAdapter, detectAdapter } from './run/adapters/index.js'
 import { createReporter, printExecutionPlan } from './run/reporter.js'
 import type { CliContext, RunOptions } from './types.js'
 import type { ConvoyResult } from './convoy/engine.js'
+import type { PipelineResult } from './convoy/pipeline.js'
 
 function formatTokens(n: number): string {
   if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M'
@@ -114,6 +115,7 @@ function printAdapterError(detectionFailed: boolean, adapterName: string): void
         `    • copilot    — https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli\n` +
         `    • claude     — npm install -g @anthropic-ai/claude-code\n` +
         `    • cursor     — https://cursor.com (Cursor > Install CLI)\n` +
+        `    • opencode   — https://opencode.ai\n` +
         `\n` +
         `    Or specify an adapter explicitly: opencastle run --adapter <name>`
     )
@@ -134,7 +136,7 @@ function printAdapterError(detectionFailed: boolean, adapterName: string): void
         '    Install OpenCode from https://opencode.ai\n' +
         '    Ensure the "opencode" command is on your PATH.',
     }
-    const cliName = adapterName === 'claude-code' ? 'claude' : adapterName
+    const cliName = adapterName === 'claude-code' ? 'claude' : adapterName === 'cursor' ? 'agent' : adapterName
     const hint = hints[adapterName] ?? ''
     console.error(
       `  ✗ Adapter "${adapterName}" is not available.\n` +
@@ -164,6 +166,26 @@ function printConvoyResult(result: ConvoyResult): void {
   }
 }
 
+/**
+ * Print a pipeline result summary.
+ */
+function printPipelineResult(result: PipelineResult): void {
+  console.log(`\n  ──────────────────────────────────────`)
+  console.log(`  Pipeline ${result.status}: ${result.duration}`)
+  console.log(
+    `  Convoys: ${result.summary.completed}/${result.summary.totalConvoys} completed` +
+    (result.summary.failed > 0 ? ` | ${result.summary.failed} failed` : '') +
+    (result.summary.skipped > 0 ? ` | ${result.summary.skipped} skipped` : '')
+  )
+  for (const cr of result.convoyResults) {
+    const icon = cr.status === 'done' ? '✓' : cr.status === 'failed' ? '✗' : '⊘'
+    console.log(`    ${icon} ${cr.convoyId}: ${cr.status} (${cr.duration})`)
+  }
+  if (result.cost) {
+    console.log(`  Tokens: ${formatTokens(result.cost.total_tokens)}`)
+  }
+}
+
 /**
  * CLI entry point for the `run` command.
  */
@@ -186,6 +208,38 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
     const { createConvoyStore } = await import('./convoy/store.js')
     const store = createConvoyStore(dbPath)
     try {
+      const pipeline = store.getLatestPipeline()
+      if (pipeline) {
+        const pipelineConvoys = store.getConvoysByPipeline(pipeline.id)
+        console.log(`\n  Pipeline: ${pipeline.name}`)
+        console.log(`  ID:       ${pipeline.id}`)
+        console.log(`  Status:   ${pipeline.status}`)
+        console.log(`  Branch:   ${pipeline.branch ?? '(none)'}`)
+        console.log(`  Created:  ${pipeline.created_at}`)
+        if (pipeline.started_at) console.log(`  Started:  ${pipeline.started_at}`)
+        if (pipeline.finished_at) console.log(`  Finished: ${pipeline.finished_at}`)
+        if (pipelineConvoys.length > 0) {
+          console.log(`\n  Convoys:`)
+          let totalTasks = 0
+          let totalDone = 0
+          let totalFailed = 0
+          let totalTokens = 0
+          for (const c of pipelineConvoys) {
+            const tasks = store.getTasksByConvoy(c.id)
+            const done = tasks.filter(t => t.status === 'done').length
+            const failed = tasks.filter(t => t.status === 'failed').length
+            totalTasks += tasks.length
+            totalDone += done
+            totalFailed += failed
+            totalTokens += tasks.reduce((sum, t) => sum + (t.total_tokens ?? 0), 0)
+            console.log(`    ${c.name} [${c.status}] — ${done}/${tasks.length} tasks done`)
+          }
+          console.log(`\n  Tasks: ${totalDone} done | ${totalFailed} failed | ${totalTasks} total`)
+          if (totalTokens > 0) console.log(`  Tokens: ${formatTokens(totalTokens)}`)
+        }
+        return
+      }
+
       const convoy = store.getLatestConvoy()
       if (!convoy) {
         console.log('  No convoy records found.')
@@ -237,6 +291,47 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
     }
     const { createConvoyStore } = await import('./convoy/store.js')
     const store = createConvoyStore(dbPath)
+    const latestPipeline = store.getLatestPipeline()
+    if (latestPipeline && (latestPipeline.status === 'pending' || latestPipeline.status === 'running')) {
+      store.close()
+      const resumePipelineSpec = parseTaskSpecText(latestPipeline.spec_yaml)
+      if (opts.concurrency !== null) resumePipelineSpec.concurrency = opts.concurrency
+      if (opts.adapter !== null) resumePipelineSpec.adapter = opts.adapter
+      if (opts.verbose) resumePipelineSpec._verbose = true
+
+      let resumePipelineDetectionFailed = false
+      if (!resumePipelineSpec.adapter) {
+        const detected = await detectAdapter()
+        if (detected) {
+          resumePipelineSpec.adapter = detected
+          console.log(`  ℹ Auto-detected adapter: ${detected}`)
+        } else {
+          resumePipelineDetectionFailed = true
+          resumePipelineSpec.adapter = 'claude-code'
+        }
+      }
+
+      const resumePipelineAdapter = await getAdapter(resumePipelineSpec.adapter)
+      const resumePipelineAvailable = await resumePipelineAdapter.isAvailable()
+      if (!resumePipelineAvailable) {
+        printAdapterError(resumePipelineDetectionFailed, resumePipelineSpec.adapter)
+        process.exit(1)
+      }
+
+      console.log(`\n  🏰 OpenCastle Pipeline (Resume): ${latestPipeline.name}`)
+      console.log(`  Pipeline ID: ${latestPipeline.id}`)
+      const { createPipelineOrchestrator } = await import('./convoy/pipeline.js')
+      const resumePipelineOrchestrator = createPipelineOrchestrator({
+        spec: resumePipelineSpec,
+        specYaml: latestPipeline.spec_yaml,
+        adapter: resumePipelineAdapter,
+        verbose: opts.verbose,
+      })
+      const resumePipelineResult = await resumePipelineOrchestrator.resume(latestPipeline.id)
+      printPipelineResult(resumePipelineResult)
+      process.exit(resumePipelineResult.status !== 'done' ? 1 : 0)
+    }
+
     const convoy = store.getLatestConvoy()
     store.close()
     if (!convoy) {
@@ -332,7 +427,16 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
 
   // ── Dry run ──────────────────────────────────────────────────
   if (opts.dryRun) {
-    if (isConvoySpec(spec)) {
+    if (isPipelineSpec(spec)) {
+      console.log(`\n  🏰 Pipeline Plan: ${spec.name}`)
+      console.log(`  Convoy chain: ${(spec.depends_on_convoy as string[]).join(' → ')}`)
+      if (spec.tasks?.length) {
+        console.log(`  Plus ${spec.tasks.length} local tasks after chain completes`)
+      }
+      if (spec.branch) console.log(`  Branch: ${spec.branch}`)
+      if (spec.gates?.length) console.log(`  Gates: ${spec.gates.length} validation commands`)
+      if (!spec.tasks?.length) return
+    } else if (isConvoySpec(spec)) {
       console.log(`\n  \uD83C\uDFF0 Convoy Plan: ${spec.name}`)
       console.log(
         `  Adapter: ${spec.adapter} | Concurrency: ${spec.concurrency} | Tasks: ${spec.tasks!.length}`
@@ -353,6 +457,41 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
     process.exit(1)
   }
 
+  // ── Pipeline orchestrator path (version: 2 specs with depends_on_convoy) ──
+  if (isPipelineSpec(spec)) {
+    const { createPipelineOrchestrator } = await import('./convoy/pipeline.js')
+    console.log(`\n  🏰 OpenCastle Pipeline: ${spec.name}`)
+    console.log(`  Convoy chain: ${(spec.depends_on_convoy as string[]).join(' → ')}`)
+    if (spec.branch) console.log(`  Branch: ${spec.branch}`)
+    if (spec.gates?.length) console.log(`  Gates: ${spec.gates.length} validation commands`)
+
+    const { startDashboardServer } = await import('./dashboard.js')
+    let pipelineDashboardResult: { server: import('node:http').Server } | null = null
+    try {
+      pipelineDashboardResult = await startDashboardServer({
+        pkgRoot,
+        openBrowser: true,
+        convoyId: 'active',
+      })
+    } catch {
+      // Dashboard failure must not block pipeline
+    }
+
+    const pipelineOrchestrator = createPipelineOrchestrator({
+      spec,
+      specYaml: specText,
+      adapter,
+      verbose: opts.verbose,
+    })
+
+    const pipelineResult = await pipelineOrchestrator.run()
+    printPipelineResult(pipelineResult)
+    if (pipelineDashboardResult) {
+      pipelineDashboardResult.server.close()
+    }
+    process.exit(pipelineResult.status !== 'done' ? 1 : 0)
+  }
+
   // ── Convoy engine path (version: 1 specs) ────────────────────
   if (isConvoySpec(spec)) {
     const { createConvoyEngine } = await import('./convoy/engine.js')

package/src/cli/types.ts

@@ -158,7 +158,7 @@ export interface TaskSpec {
   adapter: string;
   tasks?: Task[];
   _verbose?: boolean;
-  /** Spec schema version (1 for Convoy Engine format). */
+  /** Spec schema version (1 for Convoy Engine format, 2 for pipeline chaining). */
   version?: number;
   /** Worker defaults merged into each task (Convoy Engine). */
   defaults?: TaskDefaults;
@@ -166,6 +166,8 @@ export interface TaskSpec {
   gates?: string[];
   /** Git feature branch name. */
   branch?: string;
+  /** Other convoy spec names to run before this one (version: 2 pipeline specs). */
+  depends_on_convoy?: string[];
 }
 
 /** A single task in the spec. */