opencastle 0.12.0 → 0.14.0

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

@@ -0,0 +1,184 @@
+import { mkdtempSync, rmSync, realpathSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { execFile as execFileCb } from 'node:child_process'
+import { promisify } from 'node:util'
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { createMergeQueue } from './merge.js'
+import type { MergeQueue } from './merge.js'
+
+const execFile = promisify(execFileCb)
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+let repoPath: string
+let featureBranch: string
+let queue: MergeQueue
+
+async function setupTestRepo(): Promise<{ repoPath: string; featureBranch: string }> {
+  const path = realpathSync(mkdtempSync(join(tmpdir(), 'merge-test-')))
+  await execFile('git', ['init', path])
+  await execFile('git', ['-C', path, 'config', 'user.email', 'test@test.com'])
+  await execFile('git', ['-C', path, 'config', 'user.name', 'Test'])
+  writeFileSync(join(path, 'README.md'), '# Test')
+  await execFile('git', ['-C', path, 'add', '-A'])
+  await execFile('git', ['-C', path, 'commit', '-m', 'Initial commit'])
+  await execFile('git', ['-C', path, 'checkout', '-b', 'feat/test'])
+  return { repoPath: path, featureBranch: 'feat/test' }
+}
+
+async function addWorktree(repo: string, workerId: string, branch: string): Promise<string> {
+  const worktreesDir = join(repo, '.opencastle', 'worktrees')
+  mkdirSync(worktreesDir, { recursive: true })
+  const worktreePath = join(worktreesDir, workerId)
+  await execFile('git', ['-C', repo, 'worktree', 'add', worktreePath, '-b', `convoy-${workerId}`, branch])
+  return worktreePath
+}
+
+beforeEach(async () => {
+  const result = await setupTestRepo()
+  repoPath = result.repoPath
+  featureBranch = result.featureBranch
+  queue = createMergeQueue(repoPath)
+})
+
+afterEach(() => {
+  rmSync(repoPath, { recursive: true, force: true })
+})
+
+// ── successful merge ──────────────────────────────────────────────────────────
+
+describe('merge - successful merge', () => {
+  it('stages, commits, and merges worktree changes to the target branch', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+    writeFileSync(join(worktreePath, 'output.txt'), 'worker output')
+
+    const result = await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    expect(result).toEqual({ success: true, conflicted: false, message: 'Merged successfully' })
+  })
+
+  it('makes the merged file available in the target branch working tree', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+    writeFileSync(join(worktreePath, 'output.txt'), 'worker output')
+
+    await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    const { existsSync } = await import('node:fs')
+    expect(existsSync(join(repoPath, 'output.txt'))).toBe(true)
+  })
+
+  it('creates an auto-commit on the worktree branch with the convoy message', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+    writeFileSync(join(worktreePath, 'output.txt'), 'worker output')
+
+    await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    const { stdout } = await execFile('git', ['-C', repoPath, 'log', '--oneline', 'convoy-worker1'])
+    expect(stdout).toContain('convoy: convoy-worker1 completed')
+  })
+})
+
+// ── no changes ────────────────────────────────────────────────────────────────
+
+describe('merge - no changes', () => {
+  it('returns success with "No changes to merge" when the worker made no file changes', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+
+    const result = await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    expect(result).toEqual({ success: true, conflicted: false, message: 'No changes to merge' })
+  })
+
+  it('does not create a commit when there is nothing to stage', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+
+    await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    const { stdout } = await execFile('git', ['-C', repoPath, 'log', '--oneline', 'convoy-worker1'])
+    expect(stdout).not.toContain('convoy: convoy-worker1 completed')
+  })
+})
+
+// ── merge conflict ────────────────────────────────────────────────────────────
+
+describe('merge - conflict', () => {
+  it('returns conflicted: true and aborts when two worktrees edit the same file', async () => {
+    const worktree1 = await addWorktree(repoPath, 'worker1', featureBranch)
+    const worktree2 = await addWorktree(repoPath, 'worker2', featureBranch)
+
+    writeFileSync(join(worktree1, 'shared.txt'), 'content from worker 1')
+    writeFileSync(join(worktree2, 'shared.txt'), 'content from worker 2')
+
+    const first = await queue.merge(worktree1, 'convoy-worker1', featureBranch)
+    expect(first).toEqual({ success: true, conflicted: false, message: 'Merged successfully' })
+
+    const second = await queue.merge(worktree2, 'convoy-worker2', featureBranch)
+    expect(second.success).toBe(false)
+    expect(second.conflicted).toBe(true)
+    expect(second.message).toContain('conflict')
+  })
+
+  it('leaves the repo in a clean state (no pending merge) after aborting a conflict', async () => {
+    const worktree1 = await addWorktree(repoPath, 'worker1', featureBranch)
+    const worktree2 = await addWorktree(repoPath, 'worker2', featureBranch)
+
+    writeFileSync(join(worktree1, 'shared.txt'), 'content from worker 1')
+    writeFileSync(join(worktree2, 'shared.txt'), 'content from worker 2')
+
+    await queue.merge(worktree1, 'convoy-worker1', featureBranch)
+    await queue.merge(worktree2, 'convoy-worker2', featureBranch)
+
+    // --untracked-files=no excludes the .opencastle/worktrees/ dir from the check;
+    // we only want to verify there is no pending merge (no staged/modified tracked files).
+    const { stdout } = await execFile('git', ['-C', repoPath, 'status', '--porcelain', '--untracked-files=no'])
+    expect(stdout.trim()).toBe('')
+  })
+})
+
+// ── already committed changes ─────────────────────────────────────────────────
+
+describe('merge - already committed changes', () => {
+  it('merges pre-committed changes without auto-committing', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+
+    writeFileSync(join(worktreePath, 'output.txt'), 'pre-committed content')
+    await execFile('git', ['-C', worktreePath, 'add', '-A'])
+    await execFile('git', ['-C', worktreePath, 'commit', '-m', 'Worker manual commit'])
+
+    const result = await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    expect(result).toEqual({ success: true, conflicted: false, message: 'Merged successfully' })
+  })
+
+  it('makes pre-committed files available in the target branch after merge', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+
+    writeFileSync(join(worktreePath, 'output.txt'), 'pre-committed content')
+    await execFile('git', ['-C', worktreePath, 'add', '-A'])
+    await execFile('git', ['-C', worktreePath, 'commit', '-m', 'Worker manual commit'])
+
+    await queue.merge(worktreePath, 'convoy-worker1', featureBranch)
+
+    const { existsSync } = await import('node:fs')
+    expect(existsSync(join(repoPath, 'output.txt'))).toBe(true)
+  })
+})
+
+// ── error handling ────────────────────────────────────────────────────────────
+
+describe('merge - error handling', () => {
+  it('throws when the worktree branch does not exist in the repo', async () => {
+    const worktreePath = await addWorktree(repoPath, 'worker1', featureBranch)
+
+    await expect(
+      queue.merge(worktreePath, 'nonexistent-branch', featureBranch),
+    ).rejects.toThrow()
+  })
+
+  it('throws when path is outside the managed worktrees directory', async () => {
+    await expect(
+      queue.merge('/tmp/evil', 'some-branch', featureBranch),
+    ).rejects.toThrow(/outside the managed worktrees directory/)
+  })
+})

package/src/cli/convoy/merge.ts

@@ -0,0 +1,89 @@
+import { execFile as execFileCb } from 'node:child_process'
+import { resolve, join, sep } from 'node:path'
+import { promisify } from 'node:util'
+
+const execFile = promisify(execFileCb)
+
+export interface MergeResult {
+  success: boolean
+  conflicted: boolean
+  message: string
+}
+
+export interface MergeQueue {
+  /**
+   * Merge a single worktree's changes back onto the target branch.
+   * Stages all changes in the worktree, commits them if necessary, then merges
+   * the worktree branch into the target branch.
+   */
+  merge(worktreePath: string, worktreeBranch: string, targetBranch: string): Promise<MergeResult>
+}
+
+export function createMergeQueue(repoPath: string): MergeQueue {
+  const worktreesDir = resolve(join(repoPath, '.opencastle', 'worktrees'))
+
+  async function merge(
+    worktreePath: string,
+    worktreeBranch: string,
+    targetBranch: string,
+  ): Promise<MergeResult> {
+    const resolvedWorktree = resolve(worktreePath)
+    if (!resolvedWorktree.startsWith(worktreesDir + sep)) {
+      throw new Error(`Path "${worktreePath}" is outside the managed worktrees directory`)
+    }
+
+    // Stage all untracked/modified files in the worktree
+    await execFile('git', ['-C', resolvedWorktree, 'add', '-A'])
+
+    // List staged files — non-empty output means there are changes to commit.
+    // Uses --name-only (exits 0 regardless of diff size) rather than --quiet
+    // (exits 1 when changes exist) so the check is output-based, not exit-code-based.
+    const { stdout: staged } = await execFile('git', [
+      '-C',
+      resolvedWorktree,
+      'diff',
+      '--cached',
+      '--name-only',
+    ])
+    const hasUncommitted = staged.trim().length > 0
+
+    if (hasUncommitted) {
+      await execFile('git', [
+        '-C',
+        resolvedWorktree,
+        'commit',
+        '-m',
+        `convoy: ${worktreeBranch} completed`,
+      ])
+    }
+
+    // Merge the worktree branch into the target branch in the main repo
+    await execFile('git', ['-C', repoPath, 'checkout', targetBranch])
+
+    try {
+      const { stdout } = await execFile('git', [
+        '-C',
+        repoPath,
+        'merge',
+        worktreeBranch,
+        '--no-edit',
+      ])
+      if (stdout.includes('Already up to date')) {
+        return { success: true, conflicted: false, message: 'No changes to merge' }
+      }
+      return { success: true, conflicted: false, message: 'Merged successfully' }
+    } catch (err) {
+      const error = err as { code?: number | string; stderr?: string; stdout?: string }
+      const isConflict =
+        error.code === 1 &&
+        ((error.stderr ?? '').includes('CONFLICT') || (error.stdout ?? '').includes('CONFLICT'))
+      if (isConflict) {
+        await execFile('git', ['-C', repoPath, 'merge', '--abort'])
+        return { success: false, conflicted: true, message: 'Merge conflict detected; merge aborted' }
+      }
+      throw err
+    }
+  }
+
+  return { merge }
+}

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

@@ -0,0 +1,177 @@
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { execFile as execFileCb } from 'node:child_process'
+import { promisify } from 'node:util'
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { createWorktreeManager } from './worktree.js'
+import type { WorktreeManager } from './worktree.js'
+
+const execFile = promisify(execFileCb)
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+let tmpDir: string
+let manager: WorktreeManager
+
+async function initGitRepo(dir: string): Promise<void> {
+  await execFile('git', ['init'], { cwd: dir })
+  await execFile('git', ['config', 'user.email', 'test@test.com'], { cwd: dir })
+  await execFile('git', ['config', 'user.name', 'Test User'], { cwd: dir })
+  await execFile('git', ['commit', '--allow-empty', '-m', 'Initial commit'], { cwd: dir })
+}
+
+beforeEach(async () => {
+  tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'convoy-worktree-test-')))
+  await initGitRepo(tmpDir)
+  manager = createWorktreeManager(tmpDir)
+})
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+// ── create ────────────────────────────────────────────────────────────────────
+
+describe('create', () => {
+  it('creates a worktree and returns its absolute path', async () => {
+    const worktreePath = await manager.create('worker1', 'HEAD')
+    expect(worktreePath).toBe(join(tmpDir, '.opencastle', 'worktrees', 'worker1'))
+  })
+
+  it('creates the .opencastle/worktrees directory when it does not exist', async () => {
+    const { existsSync } = await import('node:fs')
+    const worktreePath = await manager.create('worker1', 'HEAD')
+    expect(existsSync(worktreePath)).toBe(true)
+  })
+
+  it('creates the new branch in the worktree', async () => {
+    await manager.create('worker1', 'HEAD')
+    const { stdout } = await execFile('git', ['branch', '--list', 'convoy-worker1'], { cwd: tmpDir })
+    // git prefixes branches checked out in a worktree with '+ '
+    expect(stdout.trim().replace(/^[*+]\s+/, '')).toBe('convoy-worker1')
+  })
+
+  it('throws when featureBranch does not exist', async () => {
+    await expect(manager.create('worker1', 'nonexistent-branch')).rejects.toThrow()
+  })
+
+  it('throws when workerId is already in use', async () => {
+    await manager.create('worker1', 'HEAD')
+    await expect(manager.create('worker1', 'HEAD')).rejects.toThrow()
+  })
+
+  it('throws for workerId with path traversal characters', async () => {
+    await expect(manager.create('../escape', 'HEAD')).rejects.toThrow(/Invalid workerId/)
+  })
+
+  it('throws for workerId with slashes', async () => {
+    await expect(manager.create('a/b', 'HEAD')).rejects.toThrow(/Invalid workerId/)
+  })
+})
+
+// ── remove ────────────────────────────────────────────────────────────────────
+
+describe('remove', () => {
+  it('removes the worktree so it no longer appears in list()', async () => {
+    const path = await manager.create('worker1', 'HEAD')
+    await manager.remove(path)
+    const worktrees = await manager.list()
+    expect(worktrees).toHaveLength(0)
+  })
+
+  it('deletes the convoy branch after removing the worktree', async () => {
+    const path = await manager.create('worker1', 'HEAD')
+    await manager.remove(path)
+    const { stdout } = await execFile('git', ['branch', '--list', 'convoy-worker1'], { cwd: tmpDir })
+    expect(stdout.trim()).toBe('')
+  })
+
+  it('is idempotent — does not throw for a non-existent worktree path', async () => {
+    const nonExistent = join(tmpDir, '.opencastle', 'worktrees', 'ghost')
+    await expect(manager.remove(nonExistent)).resolves.toBeUndefined()
+  })
+
+  it('re-throws git errors that are not "not a working tree"', async () => {
+    const path = await manager.create('worker1', 'HEAD')
+    // Lock the worktree so that single --force removal fails
+    await execFile('git', ['worktree', 'lock', path], { cwd: tmpDir })
+    await expect(manager.remove(path)).rejects.toThrow()
+    // Cleanup: unlock and remove manually
+    await execFile('git', ['worktree', 'unlock', path], { cwd: tmpDir })
+  })
+
+  it('throws when path is outside the managed worktrees directory', async () => {
+    await expect(manager.remove('/some/arbitrary/path')).rejects.toThrow(
+      /outside the managed worktrees directory/,
+    )
+  })
+})
+
+// ── list ──────────────────────────────────────────────────────────────────────
+
+describe('list', () => {
+  it('returns an empty array when no convoy worktrees exist', async () => {
+    const worktrees = await manager.list()
+    expect(worktrees).toHaveLength(0)
+  })
+
+  it('does not include the main worktree', async () => {
+    const worktrees = await manager.list()
+    for (const wt of worktrees) {
+      expect(wt.path).toContain('.opencastle/worktrees')
+    }
+  })
+
+  it('returns the correct WorktreeInfo for a created worktree', async () => {
+    await manager.create('worker1', 'HEAD')
+    const worktrees = await manager.list()
+    expect(worktrees).toHaveLength(1)
+    expect(worktrees[0].path).toBe(join(tmpDir, '.opencastle', 'worktrees', 'worker1'))
+    expect(worktrees[0].branch).toBe('refs/heads/convoy-worker1')
+    expect(worktrees[0].head).toMatch(/^[0-9a-f]{40}$/)
+  })
+
+  it('returns multiple worktrees when several have been created', async () => {
+    await manager.create('worker1', 'HEAD')
+    await manager.create('worker2', 'HEAD')
+    const worktrees = await manager.list()
+    expect(worktrees).toHaveLength(2)
+    const paths = worktrees.map(w => w.path)
+    expect(paths).toContain(join(tmpDir, '.opencastle', 'worktrees', 'worker1'))
+    expect(paths).toContain(join(tmpDir, '.opencastle', 'worktrees', 'worker2'))
+  })
+
+  it('handles detached HEAD worktrees by returning empty branch string', async () => {
+    // git worktree list --porcelain outputs 'detached' (not 'branch refs/...') for
+    // detached-HEAD worktrees — this exercises the else-if fallthrough in parseWorktreeList
+    const { existsSync, mkdirSync } = await import('node:fs')
+    const detachedPath = join(tmpDir, '.opencastle', 'worktrees', 'detached-test')
+    if (!existsSync(join(tmpDir, '.opencastle', 'worktrees'))) {
+      mkdirSync(join(tmpDir, '.opencastle', 'worktrees'), { recursive: true })
+    }
+    const { stdout: sha } = await execFile('git', ['rev-parse', 'HEAD'], { cwd: tmpDir })
+    await execFile('git', ['worktree', 'add', '--detach', detachedPath, sha.trim()], { cwd: tmpDir })
+    const worktrees = await manager.list()
+    const detached = worktrees.find(w => w.path === detachedPath)
+    expect(detached).toBeDefined()
+    expect(detached!.branch).toBe('')
+    expect(detached!.head).toMatch(/^[0-9a-f]{40}$/)
+  })
+})
+
+// ── removeAll ─────────────────────────────────────────────────────────────────
+
+describe('removeAll', () => {
+  it('removes all convoy worktrees', async () => {
+    await manager.create('worker1', 'HEAD')
+    await manager.create('worker2', 'HEAD')
+    await manager.removeAll()
+    const worktrees = await manager.list()
+    expect(worktrees).toHaveLength(0)
+  })
+
+  it('is a no-op when no convoy worktrees exist', async () => {
+    await expect(manager.removeAll()).resolves.toBeUndefined()
+  })
+})

package/src/cli/convoy/worktree.ts

@@ -0,0 +1,116 @@
+import { execFile as execFileCb } from 'node:child_process'
+import { mkdir } from 'node:fs/promises'
+import { realpathSync } from 'node:fs'
+import { join, basename, resolve, sep } from 'node:path'
+import { promisify } from 'node:util'
+
+const execFile = promisify(execFileCb)
+
+export interface WorktreeInfo {
+  path: string
+  branch: string
+  head: string
+}
+
+export interface WorktreeManager {
+  create(workerId: string, featureBranch: string): Promise<string>
+  remove(worktreePath: string): Promise<void>
+  list(): Promise<WorktreeInfo[]>
+  removeAll(): Promise<void>
+}
+
+export function createWorktreeManager(basePath: string): WorktreeManager {
+  const resolvedBase = realpathSync(resolve(basePath))
+  const worktreesDir = join(resolvedBase, '.opencastle', 'worktrees')
+
+  async function create(workerId: string, featureBranch: string): Promise<string> {
+    if (!/^[a-zA-Z0-9_-]+$/.test(workerId)) {
+      throw new Error(
+        `Invalid workerId "${workerId}": must only contain alphanumeric characters, hyphens, and underscores`,
+      )
+    }
+    const worktreePath = join(worktreesDir, workerId)
+    await mkdir(worktreesDir, { recursive: true })
+    await execFile(
+      'git',
+      ['worktree', 'add', worktreePath, '-b', `convoy-${workerId}`, featureBranch],
+      { cwd: resolvedBase },
+    )
+    return worktreePath
+  }
+
+  async function remove(worktreePath: string): Promise<void> {
+    let resolved: string
+    try {
+      resolved = realpathSync(worktreePath)
+    } catch {
+      resolved = resolve(worktreePath)
+    }
+    if (!resolved.startsWith(worktreesDir + sep)) {
+      throw new Error(`Path "${worktreePath}" is outside the managed worktrees directory`)
+    }
+    const workerId = basename(resolved)
+    try {
+      await execFile('git', ['worktree', 'remove', resolved, '--force'], {
+        cwd: resolvedBase,
+      })
+    } catch (err) {
+      const stderr = (err as { stderr?: string }).stderr ?? ''
+      if (stderr.includes('is not a working tree')) {
+        return
+      }
+      throw err
+    }
+    try {
+      await execFile('git', ['branch', '-D', `convoy-${workerId}`], { cwd: resolvedBase })
+    } catch {
+      // Branch may already be deleted — ignore
+    }
+  }
+
+
+  async function list(): Promise<WorktreeInfo[]> {
+    const { stdout } = await execFile('git', ['worktree', 'list', '--porcelain'], {
+      cwd: resolvedBase,
+    })
+    return parseWorktreeList(stdout, worktreesDir)
+  }
+
+  async function removeAll(): Promise<void> {
+    const worktrees = await list()
+    for (const wt of worktrees) {
+      await remove(wt.path)
+    }
+  }
+
+  return { create, remove, list, removeAll }
+}
+
+function parseWorktreeList(output: string, worktreesDir: string): WorktreeInfo[] {
+  const results: WorktreeInfo[] = []
+  const blocks = output.trim().split(/\n\n+/).filter(Boolean)
+
+  for (const block of blocks) {
+    const lines = block.split('\n')
+    let path = ''
+    let head = ''
+    let branch = ''
+
+    for (const line of lines) {
+      if (line.startsWith('worktree ')) {
+        path = line.slice('worktree '.length)
+      } else if (line.startsWith('HEAD ')) {
+        head = line.slice('HEAD '.length)
+      } else if (line.startsWith('branch ')) {
+        branch = line.slice('branch '.length)
+      }
+    }
+
+    // Only include worktrees that live under .opencastle/worktrees/
+    if (path.startsWith(worktreesDir + sep)) {
+      results.push({ path, branch, head })
+    }
+  }
+
+  return results
+}

package/src/cli/run/adapters/claude-code.ts

@@ -38,7 +38,7 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     const proc = spawn('claude', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: process.cwd(),
+      cwd: options?.cwd ?? process.cwd(),
     })
 
     let stdout = ''

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

@@ -61,6 +61,11 @@ async function getClient(): Promise<CopilotClientType> {
  *   - Streaming enabled in verbose mode for live output
  */
 export async function execute(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  // NOTE: The Copilot SDK CopilotClient is a shared singleton. Per-task cwd
+  // isolation requires SDK support for per-session workingDirectory, which is
+  // not yet available. When running in convoy mode with worktrees, prefer
+  // subprocess-based adapters (claude-code, cursor) that support options.cwd
+  // natively. Copilot SDK per-session cwd support is tracked for Phase 3.
   let prompt = `You are a ${task.agent}. ${task.prompt}`
 
   if (task.files && task.files.length > 0) {

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

@@ -37,7 +37,7 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     const proc = spawn('agent', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: process.cwd(),
+      cwd: options?.cwd ?? process.cwd(),
     })
 
     let stdout = ''

package/src/cli/types.ts

@@ -234,6 +234,8 @@ export interface AgentAdapter {
 /** Options for agent execution. */
 export interface ExecuteOptions {
   verbose?: boolean;
+  /** Working directory for the agent process (defaults to process.cwd()). */
+  cwd?: string;
 }
 
 /** Result from an agent adapter execution. */

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

@@ -1,25 +1,25 @@
 {
-  "hash": "7398c476",
+  "hash": "a6abe049",
   "configHash": "30f8ea04",
-  "lockfileHash": "35ec1b3d",
-  "browserHash": "6a8b9ff7",
+  "lockfileHash": "c72e777b",
+  "browserHash": "737e5c4c",
   "optimized": {
     "astro > cssesc": {
       "src": "../../../../../node_modules/cssesc/cssesc.js",
       "file": "astro___cssesc.js",
-      "fileHash": "ca3e0c44",
+      "fileHash": "3a9e4516",
       "needsInterop": true
     },
     "astro > aria-query": {
       "src": "../../../../../node_modules/aria-query/lib/index.js",
       "file": "astro___aria-query.js",
-      "fileHash": "9cd2129a",
+      "fileHash": "774ff115",
       "needsInterop": true
     },
     "astro > axobject-query": {
       "src": "../../../../../node_modules/axobject-query/lib/index.js",
       "file": "astro___axobject-query.js",
-      "fileHash": "cba29d71",
+      "fileHash": "bd1844a6",
       "needsInterop": true
     }
   },