opencastle 0.26.1 → 0.27.1

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

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync, readFileSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { EventEmitter } from 'node:events'
+import type { Task } from '../../types.js'
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTask(): Task {
+  return {
+    id: 'test-task',
+    agent: 'developer',
+    prompt: 'Do something',
+    files: [],
+    timeout: '5m',
+    depends_on: [],
+    description: 'test task',
+    max_retries: 0,
+  } as unknown as Task
+}
+
+function makeMockProc(exitCode = 0, stdoutData = '{"result":"ok"}') {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter
+    stderr: EventEmitter
+    killed: boolean
+    kill: ReturnType<typeof vi.fn>
+  }
+  proc.stdout = new EventEmitter()
+  proc.stderr = new EventEmitter()
+  proc.killed = false
+  proc.kill = vi.fn()
+  process.nextTick(() => {
+    if (stdoutData) proc.stdout.emit('data', Buffer.from(stdoutData))
+    proc.emit('close', exitCode)
+  })
+  return proc
+}
+
+// ── SDK mode ──────────────────────────────────────────────────────────────────
+
+describe('copilot adapter — SDK mode', () => {
+  let mockCreateSession: ReturnType<typeof vi.fn>
+  let mockSession: {
+    sendAndWait: ReturnType<typeof vi.fn>
+    on: ReturnType<typeof vi.fn>
+    destroy: ReturnType<typeof vi.fn>
+    abort: ReturnType<typeof vi.fn>
+  }
+
+  beforeEach(() => {
+    vi.resetModules()
+    mockSession = {
+      sendAndWait: vi.fn().mockResolvedValue({ data: { content: 'I did the task' } }),
+      on: vi.fn(),
+      destroy: vi.fn().mockResolvedValue(undefined),
+      abort: vi.fn().mockResolvedValue(undefined),
+    }
+    mockCreateSession = vi.fn().mockResolvedValue(mockSession)
+    vi.doMock('@github/copilot-sdk', () => {
+      // Must use a regular function (not arrow) so `new CopilotClient()` works
+      function MockCopilotClient(this: Record<string, unknown>) {
+        this.start = vi.fn().mockResolvedValue(undefined)
+        this.createSession = mockCreateSession
+      }
+      return {
+        CopilotClient: MockCopilotClient,
+        approveAll: vi.fn(),
+      }
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('passes mcpServers to createSession when provided', async () => {
+    const { execute } = await import('./copilot.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers })
+    expect(mockCreateSession).toHaveBeenCalledWith(
+      expect.objectContaining({ mcpServers }),
+    )
+  })
+
+  it('does NOT include mcpServers in createSession when not provided', async () => {
+    const { execute } = await import('./copilot.js')
+    await execute(makeTask(), {})
+    const callArg = mockCreateSession.mock.calls[0]?.[0] as Record<string, unknown>
+    expect(callArg).not.toHaveProperty('mcpServers')
+  })
+
+  it('does NOT include mcpServers when mcpServers is empty array', async () => {
+    const { execute } = await import('./copilot.js')
+    await execute(makeTask(), { mcpServers: [] })
+    const callArg = mockCreateSession.mock.calls[0]?.[0] as Record<string, unknown>
+    expect(callArg).not.toHaveProperty('mcpServers')
+  })
+})
+
+// ── CLI mode ──────────────────────────────────────────────────────────────────
+
+describe('copilot adapter — CLI mode', () => {
+  let tmpDir: string
+  let mockSpawn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.resetModules()
+    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'copilot-test-')))
+
+    // Make SDK unavailable so the adapter falls through to CLI
+    vi.doMock('@github/copilot-sdk', () => {
+      throw new Error('Module not found: @github/copilot-sdk')
+    })
+
+    mockSpawn = vi.fn().mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"ok"}')
+    })
+    vi.doMock('node:child_process', () => ({ spawn: mockSpawn }))
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+    vi.restoreAllMocks()
+  })
+
+  it('writes mcp.json to cwd with correct format when mcpServers provided', async () => {
+    let capturedContent: string | null = null
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      // mcp.json should exist at this point
+      const mcpPath = join(tmpDir, 'mcp.json')
+      if (existsSync(mcpPath)) {
+        capturedContent = readFileSync(mcpPath, 'utf8')
+      }
+      return makeMockProc(0, '{}')
+    })
+
+    const { execute } = await import('./copilot.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    expect(capturedContent).not.toBeNull()
+    expect(JSON.parse(capturedContent!)).toEqual({
+      mcpServers: { 'my-mcp': { command: 'node', args: ['server.js'] } },
+    })
+  })
+
+  it('cleans up mcp.json after successful execution', async () => {
+    const { execute } = await import('./copilot.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('cleans up mcp.json after failed execution (non-zero exit)', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(1, '') // non-zero exit
+    })
+    const { execute } = await import('./copilot.js')
+    const mcpServers = [{ name: 'err-mcp', type: 'local', command: 'node', args: [] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('includes --approve-mcps flag when mcp_approve_all is true', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./copilot.js')
+    await execute(makeTask(), { mcp_approve_all: true, cwd: tmpDir })
+    expect(capturedArgs).toContain('--approve-mcps')
+  })
+
+  it('does NOT write mcp.json when mcpServers not configured', async () => {
+    const { execute } = await import('./copilot.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT add --approve-mcps when mcp_approve_all is not set', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./copilot.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(capturedArgs).not.toContain('--approve-mcps')
+  })
+
+  it('maps mcpServers with url and config into mcp.json', async () => {
+    let capturedContent: string | null = null
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      const mcpPath = join(tmpDir, 'mcp.json')
+      if (existsSync(mcpPath)) capturedContent = readFileSync(mcpPath, 'utf8')
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./copilot.js')
+    const mcpServers = [
+      {
+        name: 'remote-mcp',
+        type: 'remote',
+        url: 'http://localhost:9000',
+        config: { token: 'abc' },
+      },
+    ]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(capturedContent).not.toBeNull()
+    const parsed = JSON.parse(capturedContent!) as { mcpServers: Record<string, Record<string, unknown>> }
+    expect(parsed.mcpServers['remote-mcp']).toMatchObject({
+      url: 'http://localhost:9000',
+      token: 'abc',
+    })
+  })
+})

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

@@ -1,12 +1,15 @@
 
 import { spawn } from 'node:child_process'
-import type { CopilotClient as CopilotClientType, CopilotSession, PermissionHandler } from '@github/copilot-sdk'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import type { CopilotClient as CopilotClientType, CopilotSession, PermissionHandler, SessionConfig } from '@github/copilot-sdk'
 import { parseTimeout } from '../schema.js'
 import type { Task, ExecuteOptions, ExecuteResult, TokenUsage } from '../../types.js'
 
 // Adapter name
 export const name = 'copilot'
 
+export function supportsSessionContinuity(): boolean { return true }
 // --- Unified adapter: SDK first, fallback to CLI ---
 let mode: 'sdk' | 'cli' | null = null
 
@@ -83,7 +86,9 @@ async function executeViaSdk(task: Task, options: ExecuteOptions = {}): Promise<
     },
     infiniteSessions: { enabled: false },
     ...(options.verbose ? { streaming: true } : {}),
-  })
+    // mcpServers is forward-compatible: field will be recognised by future SDK versions
+    ...(options.mcpServers?.length ? { mcpServers: options.mcpServers } : {}),
+  } as SessionConfig)
   activeSessions.set(task.id, session)
   if (options.verbose) {
     session.on('assistant.message_delta', (event: { data: { deltaContent: string } }) => {
@@ -143,11 +148,31 @@ async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<
     '--max-turns',
     '50',
   ]
-  return new Promise((resolve) => {
+  const cwd = options?.cwd ?? process.cwd()
+  const mcpJsonPath = join(cwd, 'mcp.json')
+  let wroteJson = false
+  if (options.mcpServers?.length) {
+    const mcpJson: Record<string, Record<string, unknown>> = {}
+    for (const server of options.mcpServers) {
+      const entry: Record<string, unknown> = {}
+      if (server.command) entry.command = server.command
+      if (server.args) entry.args = server.args
+      if (server.url) entry.url = server.url
+      if (server.config) Object.assign(entry, server.config)
+      mcpJson[server.name] = entry
+    }
+    writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: mcpJson }, null, 2), 'utf8')
+    wroteJson = true
+  }
+  if (options.mcp_approve_all) {
+    args.push('--approve-mcps')
+  }
+  try {
+  return await new Promise<ExecuteResult>((resolve) => {
     const proc = spawn('copilot', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: options?.cwd ?? process.cwd(),
+      cwd,
     })
     let stdout = ''
     let stderr = ''
@@ -192,6 +217,11 @@ async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<
     })
     task._process = proc
   })
+  } finally {
+    if (wroteJson) {
+      try { unlinkSync(mcpJsonPath) } catch { /* ignore */ }
+    }
+  }
 }
 
 function killCli(task: Task): void {

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

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync, readFileSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { EventEmitter } from 'node:events'
+import type { Task } from '../../types.js'
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTask(): Task {
+  return {
+    id: 'test-task',
+    agent: 'developer',
+    prompt: 'Do something',
+    files: [],
+    timeout: '5m',
+    depends_on: [],
+    description: 'test task',
+    max_retries: 0,
+  } as unknown as Task
+}
+
+function makeMockProc(exitCode = 0, stdoutData = '{"result":"ok"}') {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter
+    stderr: EventEmitter
+    killed: boolean
+    kill: ReturnType<typeof vi.fn>
+  }
+  proc.stdout = new EventEmitter()
+  proc.stderr = new EventEmitter()
+  proc.killed = false
+  proc.kill = vi.fn()
+  process.nextTick(() => {
+    if (stdoutData) proc.stdout.emit('data', Buffer.from(stdoutData))
+    proc.emit('close', exitCode)
+  })
+  return proc
+}
+
+// ── CLI mode ──────────────────────────────────────────────────────────────────
+
+describe('cursor adapter — MCP support', () => {
+  let tmpDir: string
+  let mockSpawn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.resetModules()
+    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cursor-test-')))
+
+    mockSpawn = vi.fn().mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"ok"}')
+    })
+    vi.doMock('node:child_process', () => ({ spawn: mockSpawn }))
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+    vi.restoreAllMocks()
+  })
+
+  it('writes mcp.json to cwd with correct format when mcpServers provided', async () => {
+    let capturedContent: string | null = null
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      const mcpPath = join(tmpDir, 'mcp.json')
+      if (existsSync(mcpPath)) {
+        capturedContent = readFileSync(mcpPath, 'utf8')
+      }
+      return makeMockProc(0, '{}')
+    })
+
+    const { execute } = await import('./cursor.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    expect(capturedContent).not.toBeNull()
+    expect(JSON.parse(capturedContent!)).toEqual({
+      mcpServers: { 'my-mcp': { command: 'node', args: ['server.js'] } },
+    })
+  })
+
+  it('passes --approve-mcps when mcp_approve_all is true', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { mcp_approve_all: true, cwd: tmpDir })
+    expect(capturedArgs).toContain('--approve-mcps')
+  })
+
+  it('cleans up mcp.json after successful execution', async () => {
+    const { execute } = await import('./cursor.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('cleans up mcp.json after failed execution (non-zero exit)', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(1, '')
+    })
+    const { execute } = await import('./cursor.js')
+    const mcpServers = [{ name: 'err-mcp', type: 'local', command: 'node', args: [] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT write mcp.json when mcpServers not configured', async () => {
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT add --approve-mcps when mcp_approve_all is not set', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(capturedArgs).not.toContain('--approve-mcps')
+  })
+
+  it('includes --approve-mcps when mcp_approve_all is true (no mcpServers)', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { mcp_approve_all: true, cwd: tmpDir })
+    expect(capturedArgs).toContain('--approve-mcps')
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+})

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

@@ -1,9 +1,12 @@
 import { spawn } from 'node:child_process'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
 import type { Task, ExecuteOptions, ExecuteResult, TokenUsage } from '../../types.js'
 
 /** Adapter name */
 export const name = 'cursor'
 
+export function supportsSessionContinuity(): boolean { return false }
 /**
  * Check if the Cursor CLI (`agent`) is available on the system PATH.
  */
@@ -33,11 +36,34 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     'json',
   ]
 
-  return new Promise((resolve) => {
+  const cwd = options?.cwd ?? process.cwd()
+  const mcpJsonPath = join(cwd, 'mcp.json')
+  let wroteJson = false
+
+  if (options.mcpServers?.length) {
+    const mcpJson: Record<string, Record<string, unknown>> = {}
+    for (const server of options.mcpServers) {
+      const entry: Record<string, unknown> = {}
+      if (server.command) entry.command = server.command
+      if (server.args) entry.args = server.args
+      if (server.url) entry.url = server.url
+      if (server.config) Object.assign(entry, server.config)
+      mcpJson[server.name] = entry
+    }
+    writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: mcpJson }, null, 2), 'utf8')
+    wroteJson = true
+  }
+
+  if (options.mcp_approve_all) {
+    args.push('--approve-mcps')
+  }
+
+  try {
+  return await new Promise<ExecuteResult>((resolve) => {
     const proc = spawn('agent', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: options?.cwd ?? process.cwd(),
+      cwd,
     })
 
     let stdout = ''
@@ -89,6 +115,11 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     // Store process ref for potential timeout kill
     task._process = proc
   })
+  } finally {
+    if (wroteJson) {
+      try { unlinkSync(mcpJsonPath) } catch { /* ignore */ }
+    }
+  }
 }
 
 /**

package/src/cli/run/adapters/opencode.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync, readFileSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { EventEmitter } from 'node:events'
+import type { Task } from '../../types.js'
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTask(): Task {
+  return {
+    id: 'test-task',
+    agent: 'developer',
+    prompt: 'Do something',
+    files: [],
+    timeout: '5m',
+    depends_on: [],
+    description: 'test task',
+    max_retries: 0,
+  } as unknown as Task
+}
+
+function makeMockProc(exitCode = 0, stdoutData = '{"result":"ok"}') {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter
+    stderr: EventEmitter
+    killed: boolean
+    kill: ReturnType<typeof vi.fn>
+  }
+  proc.stdout = new EventEmitter()
+  proc.stderr = new EventEmitter()
+  proc.killed = false
+  proc.kill = vi.fn()
+  process.nextTick(() => {
+    if (stdoutData) proc.stdout.emit('data', Buffer.from(stdoutData))
+    proc.emit('close', exitCode)
+  })
+  return proc
+}
+
+// ── CLI mode ──────────────────────────────────────────────────────────────────
+
+describe('opencode adapter — MCP support', () => {
+  let tmpDir: string
+  let mockSpawn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.resetModules()
+    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'opencode-test-')))
+
+    mockSpawn = vi.fn().mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"ok"}')
+    })
+    vi.doMock('node:child_process', () => ({ spawn: mockSpawn }))
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+    vi.restoreAllMocks()
+  })
+
+  it('writes mcp.json to cwd with correct format when mcpServers provided', async () => {
+    let capturedContent: string | null = null
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      const mcpPath = join(tmpDir, 'mcp.json')
+      if (existsSync(mcpPath)) {
+        capturedContent = readFileSync(mcpPath, 'utf8')
+      }
+      return makeMockProc(0, '{}')
+    })
+
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    expect(capturedContent).not.toBeNull()
+    expect(JSON.parse(capturedContent!)).toEqual({
+      mcpServers: { 'my-mcp': { command: 'node', args: ['server.js'] } },
+    })
+  })
+
+  it('passes --mcp-config flag pointing to mcp.json path', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    const idx = capturedArgs.indexOf('--mcp-config')
+    expect(idx).toBeGreaterThanOrEqual(0)
+    expect(capturedArgs[idx + 1]).toBe(join(tmpDir, 'mcp.json'))
+  })
+
+  it('cleans up mcp.json after successful execution', async () => {
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('cleans up mcp.json after failed execution (non-zero exit)', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(1, '')
+    })
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'err-mcp', type: 'local', command: 'node', args: [] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT write mcp.json when mcpServers not configured', async () => {
+    const { execute } = await import('./opencode.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT add --mcp-config when mcpServers not provided', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./opencode.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(capturedArgs).not.toContain('--mcp-config')
+  })
+})