opencastle 0.33.6 → 0.33.8

package/src/cli/convoy/engine.ts

@@ -82,6 +82,11 @@ export interface ConvoyEngineOptions {
   _mergeQueue?: MergeQueue
   /** Override for test injection. Pass `ensureBranch` for real behavior, or a mock. */
   _ensureBranch?: (branchName: string, basePath: string) => Promise<void>
+  /** Pass `null` to skip convoy-level worktree creation (test mode).
+   *  Pass a string path to inject a specific worktree directory.
+   *  Omit (undefined) for real worktree creation.
+   *  Also skipped when `_ensureBranch` is provided (backward-compat for tests). */
+  _convoyWorktreeDir?: string | null
   /** Injectable for test injection of the review pipeline. */
   _reviewRunner?: (task: TaskRecord, level: ReviewLevel, reviewerModel: string) => Promise<ReviewResult>
 }
@@ -2981,11 +2986,33 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
     const specHash = createHash('sha256').update(specYaml).digest('hex')
     const baseBranch = spec.branch ?? (await getCurrentBranch())
 
-    // Ensure target branch exists before acquiring any locks.
-    // Uses _ensureBranch injection so callers/tests can override.
+    // Create convoy-level worktree for branch isolation.
+    // Skipped when _convoyWorktreeDir is null or _ensureBranch is injected (test mode).
+    let effectiveBasePath = basePath
+    let convoyWorktreeDir: string | undefined
     if (spec.branch !== undefined) {
-      const branchFn = options._ensureBranch ?? ensureBranch
-      await branchFn(spec.branch, basePath)
+      const skipWorktree = options._convoyWorktreeDir === null || options._ensureBranch !== undefined
+      if (!skipWorktree) {
+        if (typeof options._convoyWorktreeDir === 'string') {
+          effectiveBasePath = options._convoyWorktreeDir
+          convoyWorktreeDir = options._convoyWorktreeDir
+        } else {
+          const worktreeId = `convoy-root-${Date.now()}`
+          convoyWorktreeDir = join(basePath, '.opencastle', 'worktrees', worktreeId)
+          mkdirSync(dirname(convoyWorktreeDir), { recursive: true })
+          let branchExists = false
+          try {
+            await execFile('git', ['rev-parse', '--verify', spec.branch], { cwd: basePath })
+            branchExists = true
+          } catch { /* branch doesn't exist */ }
+          if (branchExists) {
+            await execFile('git', ['worktree', 'add', convoyWorktreeDir, spec.branch], { cwd: basePath })
+          } else {
+            await execFile('git', ['worktree', 'add', '-b', spec.branch, convoyWorktreeDir], { cwd: basePath })
+          }
+          effectiveBasePath = convoyWorktreeDir
+        }
+      }
     }
 
     mkdirSync(dirname(dbPath), { recursive: true })
@@ -3022,10 +3049,10 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
     const store = createConvoyStore(dbPath)
     const ndjsonPath = options.logsDir
       ? join(options.logsDir, 'convoys', `${convoyId}.ndjson`)
-      : ndjsonPathForConvoy(convoyId, basePath)
+      : ndjsonPathForConvoy(convoyId, effectiveBasePath)
     const events = createEventEmitter(store, { ndjsonPath })
-    const wtManager = options._worktreeManager ?? createWorktreeManager(basePath)
-    const mergeQueue = options._mergeQueue ?? createMergeQueue(basePath)
+    const wtManager = options._worktreeManager ?? createWorktreeManager(effectiveBasePath)
+    const mergeQueue = options._mergeQueue ?? createMergeQueue(effectiveBasePath)
 
     let result: ConvoyResult
     try {
@@ -3088,7 +3115,7 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
 
       result = await runConvoy(
         convoyId, spec, adapter, store, events,
-        wtManager, mergeQueue, basePath, baseBranch, verbose, startTime, ndjsonPath,
+        wtManager, mergeQueue, effectiveBasePath, baseBranch, verbose, startTime, ndjsonPath,
         options._reviewRunner,
       )
     } finally {
@@ -3096,6 +3123,11 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
       store.close()
       lock.release()
       lockDb.close()
+      if (convoyWorktreeDir) {
+        try {
+          await execFile('git', ['worktree', 'remove', convoyWorktreeDir, '--force'], { cwd: basePath })
+        } catch { /* ignore cleanup errors */ }
+      }
     }
     return result
   }
@@ -3135,12 +3167,9 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
     lock.startHeartbeat()
 
     const store = createConvoyStore(dbPath)
-    const ndjsonPath = options.logsDir
-      ? join(options.logsDir, 'convoys', `${convoyId}.ndjson`)
-      : ndjsonPathForConvoy(convoyId, basePath)
-    const events = createEventEmitter(store, { ndjsonPath })
-    const wtManager = options._worktreeManager ?? createWorktreeManager(basePath)
-    const mergeQueue = options._mergeQueue ?? createMergeQueue(basePath)
+    let effectiveBasePath = basePath
+    let convoyWorktreeDir: string | undefined
+    let events: ConvoyEventEmitter | undefined
 
     let result: ConvoyResult
     try {
@@ -3150,6 +3179,40 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
       }
 
       const baseBranch = convoy.branch ?? spec.branch ?? (await getCurrentBranch())
+      const convoyBranch = convoy.branch ?? spec.branch
+
+      // Create convoy-level worktree for branch isolation.
+      if (convoyBranch !== undefined) {
+        const skipWorktree = options._convoyWorktreeDir === null || options._ensureBranch !== undefined
+        if (!skipWorktree) {
+          if (typeof options._convoyWorktreeDir === 'string') {
+            effectiveBasePath = options._convoyWorktreeDir
+            convoyWorktreeDir = options._convoyWorktreeDir
+          } else {
+            const worktreeId = `convoy-root-${Date.now()}`
+            convoyWorktreeDir = join(basePath, '.opencastle', 'worktrees', worktreeId)
+            mkdirSync(dirname(convoyWorktreeDir), { recursive: true })
+            let branchExists = false
+            try {
+              await execFile('git', ['rev-parse', '--verify', convoyBranch], { cwd: basePath })
+              branchExists = true
+            } catch { /* branch doesn't exist */ }
+            if (branchExists) {
+              await execFile('git', ['worktree', 'add', convoyWorktreeDir, convoyBranch], { cwd: basePath })
+            } else {
+              await execFile('git', ['worktree', 'add', '-b', convoyBranch, convoyWorktreeDir], { cwd: basePath })
+            }
+            effectiveBasePath = convoyWorktreeDir
+          }
+        }
+      }
+
+      const ndjsonPath = options.logsDir
+        ? join(options.logsDir, 'convoys', `${convoyId}.ndjson`)
+        : ndjsonPathForConvoy(convoyId, effectiveBasePath)
+      events = createEventEmitter(store, { ndjsonPath })
+      const wtManager = options._worktreeManager ?? createWorktreeManager(effectiveBasePath)
+      const mergeQueue = options._mergeQueue ?? createMergeQueue(effectiveBasePath)
 
       // Reset interrupted tasks and mark their workers as killed
       const allTasks = store.getTasksByConvoy(convoyId)
@@ -3187,14 +3250,19 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
 
       result = await runConvoy(
         convoyId, spec, adapter, store, events,
-        wtManager, mergeQueue, basePath, baseBranch, verbose, startTime, ndjsonPath,
+        wtManager, mergeQueue, effectiveBasePath, baseBranch, verbose, startTime, ndjsonPath,
         options._reviewRunner,
       )
     } finally {
-      events.close()
+      events?.close()
       store.close()
       lock.release()
       lockDb.close()
+      if (convoyWorktreeDir) {
+        try {
+          await execFile('git', ['worktree', 'remove', convoyWorktreeDir, '--force'], { cwd: basePath })
+        } catch { /* ignore cleanup errors */ }
+      }
     }
     return result
   }

package/src/cli/convoy/events.test.ts

@@ -63,7 +63,7 @@ describe('createEventEmitter', () => {
 
   it('stores null data when no data object is provided', () => {
     const emitter = createEventEmitter(store)
-    emitter.emit('heartbeat', undefined, { convoy_id: 'c1' })
+    emitter.emit('convoy_guard', undefined, { convoy_id: 'c1' })
     emitter.close()
     const events = store.getEvents('c1')
     expect(events[0].data).toBeNull()
@@ -92,7 +92,7 @@ describe('createEventEmitter', () => {
 
   it('defaults all ids to null when ids are not provided', () => {
     const emitter = createEventEmitter(store, { ndjsonPath })
-    emitter.emit('generic_event')
+    emitter.emit('convoy_guard')
     emitter.close()
     const events = store.getEvents('c1')
     expect(events).toHaveLength(0)
@@ -106,7 +106,7 @@ describe('createEventEmitter', () => {
 
   it('includes all provided ids in the NDJSON record', () => {
     const emitter = createEventEmitter(store, { ndjsonPath })
-    emitter.emit('worker_spawned', {}, { convoy_id: 'c1', task_id: 't1', worker_id: 'w1' })
+    emitter.emit('task_started', {}, { convoy_id: 'c1', task_id: 't1', worker_id: 'w1' })
     emitter.close()
     const line = JSON.parse(readFileSync(ndjsonPath, 'utf8').trim())
     expect(line.convoy_id).toBe('c1')
@@ -116,7 +116,7 @@ describe('createEventEmitter', () => {
 
   it('SQLite event stores correct ids', () => {
     const emitter = createEventEmitter(store)
-    emitter.emit('worker_done', {}, { convoy_id: 'c1', task_id: 'task-x', worker_id: 'wkr-y' })
+    emitter.emit('task_done', {}, { convoy_id: 'c1', task_id: 'task-x', worker_id: 'wkr-y' })
     emitter.close()
     const events = store.getEvents('c1')
     expect(events[0].task_id).toBe('task-x')
@@ -125,7 +125,7 @@ describe('createEventEmitter', () => {
 
   it('does not throw if NDJSON path is not provided', () => {
     const emitter = createEventEmitter(store)
-    expect(() => emitter.emit('test', {}, { convoy_id: 'c1' })).not.toThrow()
+    expect(() => emitter.emit('convoy_guard', {}, { convoy_id: 'c1' })).not.toThrow()
     emitter.close()
   })
 
@@ -266,7 +266,7 @@ describe('crash resilience', () => {
     const count = 1000
     const emitter = createEventEmitter(store, { ndjsonPath })
     for (let i = 0; i < count; i++) {
-      emitter.emit('bench_event', { index: i }, { convoy_id: 'c1', task_id: `t${i}` })
+      emitter.emit('task_retried', { previous_status: String(i) }, { convoy_id: 'c1', task_id: `t${i}` })
     }
     emitter.close()
 
@@ -280,7 +280,7 @@ describe('crash resilience', () => {
     // Each line is valid JSON with the right type
     for (const line of lines) {
       const parsed = JSON.parse(line)
-      expect(parsed.type).toBe('bench_event')
+      expect(parsed.type).toBe('task_retried')
       expect(parsed.convoy_id).toBe('c1')
     }
 
@@ -453,7 +453,9 @@ describe('emit-time data validation', () => {
 
   it('unknown event type bypasses data validation (only one warning)', () => {
     const emitter = createEventEmitter(store)
-    emitter.emit('unknown_type_xyz', { any: 'data' }, { convoy_id: 'c1' })
+    // Cast needed: TypeScript normally catches unknown types at compile time.
+    // This tests the runtime guard (e.g. JS callers / dynamic values / `as any` paths).
+    emitter.emit('unknown_type_xyz' as Parameters<typeof emitter.emit>[0], { any: 'data' }, { convoy_id: 'c1' })
     emitter.close()
     expect(warnSpy).toHaveBeenCalledTimes(1)
     expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown event type: "unknown_type_xyz"'))

package/src/cli/convoy/events.ts

@@ -2,6 +2,7 @@ import { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync, readFileSync
 import { dirname, join } from 'node:path'
 import type { ConvoyStore } from './store.js'
 import { KNOWN_EVENT_TYPES } from './types.js'
+import type { ConvoyEventType } from './types.js'
 import { validateEventData } from './event-schemas.js'
 
 const RESERVED_KEYS = new Set(['_event_id', 'convoy_id', 'task_id', 'worker_id', 'timestamp', 'type'])
@@ -16,11 +17,13 @@ export function ndjsonPathForConvoy(convoyId: string, basePath?: string): string
   return join(base, '.opencastle', 'logs', 'convoys', `${convoyId}.ndjson`)
 }
 
+type ConvoyEmitIds = { convoy_id?: string; task_id?: string; worker_id?: string }
+
 export interface ConvoyEventEmitter {
-  emit(
-    type: string,
-    data?: Record<string, unknown>,
-    ids?: { convoy_id?: string; task_id?: string; worker_id?: string },
+  emit<T extends ConvoyEventType>(
+    type: T['type'],
+    data?: T extends { data?: infer D } ? D : never,
+    ids?: ConvoyEmitIds,
   ): void
   close(): void
 }

package/src/cli/convoy/pipeline.ts

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises'
 import { mkdirSync } from 'node:fs'
-import { resolve, dirname, relative, isAbsolute, sep } from 'node:path'
+import { resolve, join, dirname, relative, isAbsolute, sep } from 'node:path'
 import { execFile as execFileCb } from 'node:child_process'
 import { promisify } from 'node:util'
 import type { TaskSpec, AgentAdapter } from '../types.js'
@@ -8,7 +8,6 @@ import { parseTaskSpecText } from '../run/schema.js'
 import { createConvoyStore } from './store.js'
 import {
   createConvoyEngine,
-  ensureBranch,
   type ConvoyEngine,
   type ConvoyResult,
   type ConvoyEngineOptions,
@@ -51,6 +50,9 @@ export interface PipelineOrchestratorOptions {
   _createConvoyEngine?: (opts: ConvoyEngineOptions) => ConvoyEngine
   /** Injectable branch handler (used in tests). */
   _ensureBranch?: (branchName: string, basePath: string) => Promise<void>
+  /** Pass `null` to skip pipeline-level worktree creation (test mode).
+   *  Also skipped when `_ensureBranch` is provided (backward-compat for tests). */
+  _convoyWorktreeDir?: string | null
 }
 
 // ── Internal helpers ──────────────────────────────────────────────────────────
@@ -87,7 +89,6 @@ export function createPipelineOrchestrator(
   const basePath = resolve(options.basePath ?? process.cwd())
   const dbPath = options.dbPath ?? resolve(basePath, '.opencastle', 'convoy.db')
   const engineFactory = options._createConvoyEngine ?? createConvoyEngine
-  const branchFn = options._ensureBranch ?? ensureBranch
 
   async function getCurrentBranch(): Promise<string> {
     try {
@@ -118,7 +119,7 @@ export function createPipelineOrchestrator(
     specPath: string,
     pipelineId: string,
     branch: string,
-    skipDirtyCheck = false,
+    effectiveBase: string = basePath,
   ): Promise<ConvoyResult> {
     const absPath = resolveSpecPath(specPath)
     const convoyYaml = await readFile(absPath, 'utf8')
@@ -129,16 +130,13 @@ export function createPipelineOrchestrator(
       spec: overriddenSpec,
       specYaml: convoyYaml,
       adapter,
-      basePath,
+      basePath: effectiveBase,
       dbPath,
       logsDir: options.logsDir,
       verbose,
       pipelineId,
+      _convoyWorktreeDir: null,
     }
-    if (skipDirtyCheck) {
-      engineOpts._ensureBranch = (b, base) => ensureBranch(b, base, true)
-    }
-
     const engine = engineFactory(engineOpts)
     return engine.run()
   }
@@ -149,10 +147,33 @@ export function createPipelineOrchestrator(
     const branch = spec.branch ?? (await getCurrentBranch())
     const convoySpecs = spec.depends_on_convoy ?? []
 
-    // Switch branch BEFORE any DB writes — otherwise the convoy.db modification
-    // from insertPipeline() causes ensureBranch's dirty check to fail.
+    // Create pipeline-level worktree for branch isolation.
+    // Skipped when _convoyWorktreeDir is null or _ensureBranch is injected (test mode).
+    let effectiveBasePath = basePath
+    let convoyWorktreeDir: string | undefined
     if (spec.branch !== undefined) {
-      await branchFn(spec.branch, basePath)
+      const skipWorktree = options._convoyWorktreeDir === null || options._ensureBranch !== undefined
+      if (!skipWorktree) {
+        if (typeof options._convoyWorktreeDir === 'string') {
+          effectiveBasePath = options._convoyWorktreeDir
+          convoyWorktreeDir = options._convoyWorktreeDir
+        } else {
+          const worktreeId = `convoy-root-${Date.now()}`
+          convoyWorktreeDir = join(basePath, '.opencastle', 'worktrees', worktreeId)
+          mkdirSync(dirname(convoyWorktreeDir), { recursive: true })
+          let branchExists = false
+          try {
+            await execFile('git', ['rev-parse', '--verify', spec.branch], { cwd: basePath })
+            branchExists = true
+          } catch { /* branch doesn't exist */ }
+          if (branchExists) {
+            await execFile('git', ['worktree', 'add', convoyWorktreeDir, spec.branch], { cwd: basePath })
+          } else {
+            await execFile('git', ['worktree', 'add', '-b', spec.branch, convoyWorktreeDir], { cwd: basePath })
+          }
+          effectiveBasePath = convoyWorktreeDir
+        }
+      }
     }
 
     mkdirSync(dirname(dbPath), { recursive: true })
@@ -187,10 +208,7 @@ export function createPipelineOrchestrator(
 
         let convoyResult: ConvoyResult
         try {
-          // Always skip dirty check inside pipeline — run.ts pre-flight already
-          // handled the stash prompt, and insertPipeline() writes to convoy.db
-          // before the first convoy runs (which would cause a false dirty-check failure).
-          convoyResult = await runConvoySpecFile(specPath, pipelineId, branch, true)
+          convoyResult = await runConvoySpecFile(specPath, pipelineId, branch, effectiveBasePath)
         } catch (err) {
           process.stderr.write(
             `  ✗ Convoy spec "${specPath}" failed to load: ${(err as Error).message}\n`,
@@ -218,11 +236,12 @@ export function createPipelineOrchestrator(
           spec: { ...spec, branch },
           specYaml,
           adapter,
-          basePath,
+          basePath: effectiveBasePath,
           dbPath,
           logsDir: options.logsDir,
           verbose,
           pipelineId,
+          _convoyWorktreeDir: null,
         })
         const hybridResult = await hybridEngine.run()
         convoyResults.push(hybridResult)
@@ -238,6 +257,12 @@ export function createPipelineOrchestrator(
         failStore.close()
       }
       throw err
+    } finally {
+      if (convoyWorktreeDir) {
+        try {
+          await execFile('git', ['worktree', 'remove', convoyWorktreeDir, '--force'], { cwd: basePath })
+        } catch { /* ignore cleanup errors */ }
+      }
     }
 
     const totalTokens = aggregateTokens(convoyResults)
@@ -283,6 +308,36 @@ export function createPipelineOrchestrator(
     const convoySpecs: string[] = JSON.parse(pipeline.convoy_specs) as string[]
     const branch = pipeline.branch ?? spec.branch ?? (await getCurrentBranch())
 
+    // Create pipeline-level worktree for branch isolation.
+    // Skipped when _convoyWorktreeDir is null or _ensureBranch is injected (test mode).
+    let effectiveBasePath = basePath
+    let convoyWorktreeDir: string | undefined
+    const pipelineBranch = pipeline.branch ?? spec.branch
+    if (pipelineBranch !== undefined) {
+      const skipWorktree = options._convoyWorktreeDir === null || options._ensureBranch !== undefined
+      if (!skipWorktree) {
+        if (typeof options._convoyWorktreeDir === 'string') {
+          effectiveBasePath = options._convoyWorktreeDir
+          convoyWorktreeDir = options._convoyWorktreeDir
+        } else {
+          const worktreeId = `convoy-root-${Date.now()}`
+          convoyWorktreeDir = join(basePath, '.opencastle', 'worktrees', worktreeId)
+          mkdirSync(dirname(convoyWorktreeDir), { recursive: true })
+          let branchExists = false
+          try {
+            await execFile('git', ['rev-parse', '--verify', pipelineBranch], { cwd: basePath })
+            branchExists = true
+          } catch { /* branch doesn't exist */ }
+          if (branchExists) {
+            await execFile('git', ['worktree', 'add', convoyWorktreeDir, pipelineBranch], { cwd: basePath })
+          } else {
+            await execFile('git', ['worktree', 'add', '-b', pipelineBranch, convoyWorktreeDir], { cwd: basePath })
+          }
+          effectiveBasePath = convoyWorktreeDir
+        }
+      }
+    }
+
     // Load all convoys linked to this pipeline, sorted by creation time
     const convoyStore = createConvoyStore(dbPath)
     let existingConvoys
@@ -350,11 +405,12 @@ export function createPipelineOrchestrator(
             spec: overriddenSpec,
             specYaml: convoyYaml,
             adapter,
-            basePath,
+            basePath: effectiveBasePath,
             dbPath,
             logsDir: options.logsDir,
             verbose,
             pipelineId,
+            _convoyWorktreeDir: null,
           })
 
           if (existing.status === 'failed') {
@@ -366,7 +422,7 @@ export function createPipelineOrchestrator(
         } else {
           // Run fresh
           try {
-            convoyResult = await runConvoySpecFile(specPath, pipelineId, branch, true)
+            convoyResult = await runConvoySpecFile(specPath, pipelineId, branch, effectiveBasePath)
           } catch (err) {
             process.stderr.write(
               `  ✗ Convoy spec "${specPath}" failed to load: ${(err as Error).message}\n`,
@@ -399,6 +455,12 @@ export function createPipelineOrchestrator(
         failStore.close()
       }
       throw err
+    } finally {
+      if (convoyWorktreeDir) {
+        try {
+          await execFile('git', ['worktree', 'remove', convoyWorktreeDir, '--force'], { cwd: basePath })
+        } catch { /* ignore cleanup errors */ }
+      }
     }
 
     const totalTokens = aggregateTokens(convoyResults)

package/src/cli/convoy/types.ts

@@ -364,6 +364,9 @@ export type ConvoyEventType =
   | { type: 'tdd_check_passed'; data?: { task_id?: string; new_source_files?: number; existing_test_files?: number } }
   | { type: 'tdd_check_failed'; data?: { task_id?: string; missing_test_files?: string[]; new_source_files?: number } }
   | { type: 'tdd_check_skipped'; data?: { task_id?: string; reason?: string; agent?: string } }
+  | { type: 'convoy_resumed'; data?: { original_created_at?: string } }
+  | { type: 'artifacts_extracted'; data?: { task_id?: string; count?: number; artifacts?: Array<{ filename: string; summary?: string }> } }
+  | { type: 'file_partition_conflict'; data?: { conflicts?: Array<{ phase: number; taskA: string; taskB: string; overlapping: string[] }> } }
 
 /** All canonical convoy event type strings. Used for runtime validation. */
 export const KNOWN_EVENT_TYPES: Set<string> = new Set<ConvoyEventType['type']>([
@@ -414,4 +417,7 @@ export const KNOWN_EVENT_TYPES: Set<string> = new Set<ConvoyEventType['type']>([
   'tdd_check_passed',
   'tdd_check_failed',
   'tdd_check_skipped',
+  'convoy_resumed',
+  'artifacts_extracted',
+  'file_partition_conflict',
 ])

package/src/cli/run.ts

@@ -871,54 +871,6 @@ 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)
-      let statusOut: string
-      try {
-        const result = await execFile('git', ['status', '--porcelain'], {
-          cwd: process.cwd(),
-        })
-        statusOut = result.stdout
-      } catch {
-        console.error(`  ✗ Git repository not found. A git repo is required when using the \`branch\` option.`)
-        console.error(`    Run \`git init\` to initialize a repository.`)
-        console.log(`\n  ${c.dim('Resume:')} npx opencastle run -f ${opts.file}`)
-        process.exit(1)
-      }
-      // Untracked files (??) don't block branch checkout — ignore them
-      const trackedChanges = statusOut
-        .split('\n')
-        .filter(line => line.trim() && !line.startsWith('??'))
-        .join('\n')
-      if (trackedChanges) {
-        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.')
-          console.log(`\n  ${c.dim('Resume:')} npx opencastle run -f ${opts.file}`)
-          closePrompts()
-          process.exit(1)
-        }
-        try {
-          await execFile('git', ['stash', 'push', '-m', 'opencastle: auto-stash before pipeline'], {
-            cwd: process.cwd(),
-          })
-          pipelineDidStash = true
-          console.log(`  ${c.green('✓')} Changes stashed.`)
-        } catch {
-          console.log(`  ${c.yellow('⚠')} Could not stash changes automatically.`)
-          console.log(`  Commit or stash your changes manually, then resume:\n`)
-          console.log(`  ${c.dim('Resume:')} npx opencastle run -f ${opts.file}`)
-          closePrompts()
-          process.exit(1)
-        }
-      }
-    }
-
     const { startDashboardServer } = await import('./dashboard.js')
     let pipelineDashboardResult: { server: import('node:http').Server; port: number; url: string } | null = null
     try {
@@ -953,17 +905,6 @@ 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('Dashboard:')} ${pipelineDashboardResult.url}`)
@@ -996,54 +937,6 @@ 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 didStash = false
-    if (spec.branch) {
-      const { execFile: execFileCb } = await import('node:child_process')
-      const { promisify } = await import('node:util')
-      const execFile = promisify(execFileCb)
-      let statusOut: string
-      try {
-        const result = await execFile('git', ['status', '--porcelain'], {
-          cwd: process.cwd(),
-        })
-        statusOut = result.stdout
-      } catch {
-        console.error(`  ✗ Git repository not found. A git repo is required when using the \`branch\` option.`)
-        console.error(`    Run \`git init\` to initialize a repository.`)
-        console.log(`\n  ${c.dim('Resume:')} npx opencastle run -f ${opts.file}`)
-        process.exit(1)
-      }
-      // Untracked files (??) don't block branch checkout — ignore them
-      const trackedChanges = statusOut
-        .split('\n')
-        .filter(line => line.trim() && !line.startsWith('??'))
-        .join('\n')
-      if (trackedChanges) {
-        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.')
-          console.log(`\n  ${c.dim('Resume:')} npx opencastle run -f ${opts.file}`)
-          closePrompts()
-          process.exit(1)
-        }
-        try {
-          await execFile('git', ['stash', 'push', '-m', 'opencastle: auto-stash before convoy'], {
-            cwd: process.cwd(),
-          })
-          didStash = true
-          console.log(`  ${c.green('✓')} Changes stashed.`)
-        } catch {
-          console.log(`  ${c.yellow('⚠')} Could not stash changes automatically.`)
-          console.log(`  Commit or stash your changes manually, then resume:\n`)
-          console.log(`  ${c.dim('Resume:')} npx opencastle run -f ${opts.file}`)
-          closePrompts()
-          process.exit(1)
-        }
-      }
-    }
-
     const { startDashboardServer } = await import('./dashboard.js')
     let dashboardResult: { server: import('node:http').Server; port: number; url: string } | null = null
     try {
@@ -1095,17 +988,6 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
       throw err
     }
     printConvoyResult(result)
-    if (didStash) {
-      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 (dashboardResult) {
       console.log(`\n  ${c.dim('Results saved to .opencastle/convoy.db')}`)
       console.log(`  ${c.dim('Dashboard:')} ${dashboardResult.url}`)

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-04-06T12:18:29.969Z"
-    },
-    {
-      "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-04-06T12:18:29.969Z"
+      "created_at": "2026-04-07T13:06:16.545Z"
     },
     {
       "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-04-06T12:18:29.969Z"
+      "created_at": "2026-04-07T13:06:16.545Z"
+    },
+    {
+      "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-04-07T13:06:16.546Z"
     }
   ],
   "has_more_events": false,