opencastle 0.33.6 → 0.33.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencastle",
-  "version": "0.33.6",
+  "version": "0.33.7",
   "type": "module",
   "description": "Multi-agent orchestration framework for AI coding assistants",
   "bin": {

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

@@ -103,6 +103,7 @@ function makeEngine(opts: ConvoyEngineOptions): ReturnType<typeof createConvoyEn
   return createConvoyEngine({
     logsDir: join(tmpDir, 'logs'),  // prevents test data in production logs
     _ensureBranch: vi.fn().mockResolvedValue(undefined),
+    _convoyWorktreeDir: null,
     ...opts,
   })
 }
@@ -3283,11 +3284,10 @@ describe('symlink security scan', () => {
   })
 })
 
-// ── Security: ensureBranch fallback (issue #3) ────────────────────────────────
+// ── Security: convoy-level worktree when branch is set ───────────────────────
 
-describe('ensureBranch fallback when _ensureBranch not provided', () => {
-  it('calls the injected _ensureBranch when branch is set in spec', async () => {
-    const branchFn = vi.fn().mockResolvedValue(undefined)
+describe('convoy-level worktree when branch is set', () => {
+  it('runs successfully when _convoyWorktreeDir is null and branch is set', async () => {
     const adapter = makeAdapter()
     const spec = makeSpec({ branch: 'feature-x' })
     const engine = createConvoyEngine({
@@ -3297,15 +3297,14 @@ describe('ensureBranch fallback when _ensureBranch not provided', () => {
       dbPath,
       _worktreeManager: makeWorktreeManager(),
       _mergeQueue: makeMergeQueue(),
-      _ensureBranch: branchFn,
+      _convoyWorktreeDir: null,
     })
 
-    await engine.run()
-    expect(branchFn).toHaveBeenCalledWith('feature-x', expect.any(String))
+    const result = await engine.run()
+    expect(result.status).toBe('done')
   })
 
-  it('does not call ensureBranch when spec has no branch', async () => {
-    const branchFn = vi.fn().mockResolvedValue(undefined)
+  it('does not attempt worktree creation when spec has no branch', async () => {
     const adapter = makeAdapter()
     const spec = makeSpec({ branch: undefined })
     const engine = makeEngine({
@@ -3315,11 +3314,10 @@ describe('ensureBranch fallback when _ensureBranch not provided', () => {
       dbPath,
       _worktreeManager: makeWorktreeManager(),
       _mergeQueue: makeMergeQueue(),
-      _ensureBranch: branchFn,
     })
 
-    await engine.run()
-    expect(branchFn).not.toHaveBeenCalled()
+    const result = await engine.run()
+    expect(result.status).toBe('done')
   })
 })
 

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/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/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"
+      "created_at": "2026-04-07T12:58:13.324Z"
     },
     {
       "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-07T12:58:13.324Z"
     },
     {
       "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-07T12:58:13.324Z"
     }
   ],
   "has_more_events": false,

package/src/dashboard/dist/data/convoys/demo-auth-revamp.json

@@ -42,28 +42,28 @@
       "name": "libs/auth/src/jwt-middleware.ts",
       "type": "file",
       "task_id": "auth-t2",
-      "created_at": "2026-04-06T12:18:29.968Z"
+      "created_at": "2026-04-07T12:58:13.323Z"
     },
     {
       "id": "artifact-demo-auth-revamp-libs-auth-src-rls-policies-sql",
       "name": "libs/auth/src/rls-policies.sql",
       "type": "file",
       "task_id": "auth-t3",
-      "created_at": "2026-04-06T12:18:29.968Z"
+      "created_at": "2026-04-07T12:58:13.323Z"
     },
     {
       "id": "artifact-demo-auth-revamp-tests-auth-integration-test-ts",
       "name": "tests/auth/integration.test.ts",
       "type": "file",
       "task_id": "auth-t4",
-      "created_at": "2026-04-06T12:18:29.968Z"
+      "created_at": "2026-04-07T12:58:13.323Z"
     },
     {
       "id": "artifact-demo-auth-revamp-reports-auth-review-summary-md",
       "name": "reports/auth-review-summary.md",
       "type": "summary",
       "task_id": "auth-t5",
-      "created_at": "2026-04-06T12:18:29.969Z"
+      "created_at": "2026-04-07T12:58:13.324Z"
     }
   ],
   "has_more_events": false,