opencastle 0.26.1 → 0.27.1

package/src/cli/plan.ts

@@ -0,0 +1,316 @@
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { resolve, join, basename } from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { getAdapter, detectAdapter } from './run/adapters/index.js'
+import { parseTaskSpecText } from './run/schema.js'
+import { c } from './prompt.js'
+import type { CliContext, Task } from './types.js'
+
+const HELP = `
+  opencastle plan [options]
+
+  Generate a convoy spec from a task description file by running it through the
+  generate-convoy prompt via an AI adapter.
+
+  Options:
+    --file, -f <path>        Path to a text file with the task description (required)
+    --context <path>         Optional path to an additional context file
+    --output, -o <path>      Output path for the generated convoy spec
+    --adapter, -a <name>     Override agent runtime adapter
+    --verbose                Show full agent output
+    --dry-run                Print the prompt that would be sent without executing
+    --help, -h               Show this help
+`
+
+interface PlanOptions {
+  file: string | null
+  context: string | null
+  output: string | null
+  adapter: string | null
+  verbose: boolean
+  dryRun: boolean
+  help: boolean
+}
+
+function parseArgs(args: string[]): PlanOptions {
+  const opts: PlanOptions = {
+    file: null,
+    context: null,
+    output: null,
+    adapter: null,
+    verbose: false,
+    dryRun: false,
+    help: false,
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    switch (arg) {
+      case '--help':
+      case '-h':
+        opts.help = true
+        break
+      case '--file':
+      case '-f':
+        if (i + 1 >= args.length) { console.error('  ✗ --file requires a path'); process.exit(1) }
+        opts.file = args[++i]
+        break
+      case '--context':
+        if (i + 1 >= args.length) { console.error('  ✗ --context requires a path'); process.exit(1) }
+        opts.context = args[++i]
+        break
+      case '--output':
+      case '-o':
+        if (i + 1 >= args.length) { console.error('  ✗ --output requires a path'); process.exit(1) }
+        opts.output = args[++i]
+        break
+      case '--adapter':
+      case '-a':
+        if (i + 1 >= args.length) { console.error('  ✗ --adapter requires a name'); process.exit(1) }
+        opts.adapter = args[++i]
+        break
+      case '--verbose':
+        opts.verbose = true
+        break
+      case '--dry-run':
+      case '--dryRun':
+        opts.dryRun = true
+        break
+      default:
+        console.error(`  ✗ Unknown option: ${arg}`)
+        console.log(HELP)
+        process.exit(1)
+    }
+  }
+
+  return opts
+}
+
+function printAdapterError(detectionFailed: boolean, adapterName: string): void {
+  if (detectionFailed) {
+    console.error(
+      `  ✗ No agent CLI found on your PATH.\n` +
+        `    Install one of the following adapters:\n` +
+        `    • copilot    — https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli\n` +
+        `    • claude     — npm install -g @anthropic-ai/claude-code\n` +
+        `    • cursor     — https://cursor.com (Cursor > Install CLI)\n` +
+        `    • opencode   — https://opencode.ai\n` +
+        `\n` +
+        `    Or specify an adapter explicitly: opencastle plan --adapter <name>`
+    )
+  } else {
+    const hints: Record<string, string> = {
+      'claude':
+        '    Install: npm install -g @anthropic-ai/claude-code\n' +
+        '    Docs:    https://docs.anthropic.com/en/docs/claude-code',
+      copilot:
+        '    Requires the Copilot CLI installed and authenticated:\n' +
+        '    https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli\n' +
+        '    Docs:    https://docs.github.com/en/copilot',
+      cursor:
+        '    The Cursor agent CLI ships with the Cursor editor.\n' +
+        '    Install Cursor from https://cursor.com and ensure the\n' +
+        '    "agent" command is on your PATH (Cursor > Install CLI).',
+      opencode:
+        '    Install OpenCode from https://opencode.ai\n' +
+        '    Ensure the "opencode" command is on your PATH.',
+    }
+    const cliName = adapterName === 'cursor' ? 'agent' : adapterName
+    const hint = hints[adapterName] ?? ''
+    console.error(
+      `  ✗ Adapter "${adapterName}" is not available.\n` +
+        `    Make sure the "${cliName}" CLI is installed and on your PATH.\n` +
+        hint
+    )
+  }
+}
+
+/**
+ * Strip YAML frontmatter (everything between first and second --- lines).
+ */
+function stripFrontmatter(text: string): string {
+  const lines = text.split('\n')
+  if (lines[0]?.trim() !== '---') return text
+  const closingIdx = lines.findIndex((line, i) => i > 0 && line.trim() === '---')
+  if (closingIdx === -1) return text
+  return lines.slice(closingIdx + 1).join('\n').trimStart()
+}
+
+/**
+ * Extract YAML content from a fenced code block (```yaml or ```yml).
+ */
+function extractYamlBlock(text: string): string | null {
+  const match = text.match(/```ya?ml\s*\n([\s\S]*?)```/)
+  if (!match) return null
+  return match[1].trim()
+}
+
+/**
+ * Derive an output filename from YAML content.
+ * Checks for a comment on the first line, then falls back to the `name` field.
+ */
+function deriveOutputFilename(yaml: string): string {
+  // First line comment: # .opencastle/convoys/some-name.convoy.yml
+  const firstLine = yaml.split('\n')[0] ?? ''
+  const commentMatch = firstLine.match(/^#\s*(.+\.convoy\.ya?ml)\s*$/)
+  if (commentMatch) {
+    return basename(commentMatch[1])
+  }
+
+  // Fall back to `name:` field
+  const nameMatch = yaml.match(/^name:\s*['"]?([^'"\n]+)['"]?\s*$/m)
+  if (nameMatch) {
+    const kebab = nameMatch[1].trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+    if (kebab) return `${kebab}.convoy.yml`
+  }
+
+  return 'convoy-plan.convoy.yml'
+}
+
+export default async function plan({ args, pkgRoot }: CliContext): Promise<void> {
+  const opts = parseArgs(args)
+
+  if (opts.help) {
+    console.log(HELP)
+    return
+  }
+
+  // ── Validate required --file arg ──────────────────────────────
+  if (!opts.file) {
+    console.error(`  ✗ --file is required. Specify a text file with the task description.`)
+    console.log(HELP)
+    process.exit(1)
+  }
+
+  const filePath = resolve(process.cwd(), opts.file)
+  if (!existsSync(filePath)) {
+    console.error(`  ✗ File not found: ${opts.file}`)
+    process.exit(1)
+  }
+
+  // ── Read task description ──────────────────────────────────────
+  const taskDescription = await readFile(filePath, 'utf8')
+
+  // ── Read optional context file ─────────────────────────────────
+  let contextContent = ''
+  if (opts.context) {
+    const contextPath = resolve(process.cwd(), opts.context)
+    if (!existsSync(contextPath)) {
+      console.error(`  ✗ Context file not found: ${opts.context}`)
+      process.exit(1)
+    }
+    contextContent = await readFile(contextPath, 'utf8')
+  }
+
+  // ── Load and assemble the prompt template ─────────────────────
+  const promptTemplatePath = join(pkgRoot, 'src', 'orchestrator', 'prompts', 'generate-convoy.prompt.md')
+  if (!existsSync(promptTemplatePath)) {
+    console.error(`  ✗ Prompt template not found: ${promptTemplatePath}`)
+    process.exit(1)
+  }
+
+  const rawTemplate = await readFile(promptTemplatePath, 'utf8')
+  const template = stripFrontmatter(rawTemplate)
+  const assembledPrompt = template
+    .replace('{{goal}}', taskDescription.trim())
+    .replace('{{context}}', contextContent.trim())
+
+  // ── Dry-run: print prompt and exit ────────────────────────────
+  if (opts.dryRun) {
+    console.log(c.bold(c.cyan('  Assembled prompt (dry-run):\n')))
+    console.log(assembledPrompt)
+    return
+  }
+
+  // ── Resolve adapter ───────────────────────────────────────────
+  let adapterName: string
+  if (opts.adapter) {
+    adapterName = opts.adapter
+  } else {
+    const detected = await detectAdapter()
+    if (!detected) {
+      printAdapterError(true, '')
+      process.exit(1)
+    }
+    adapterName = detected
+  }
+
+  let adapter
+  try {
+    adapter = await getAdapter(adapterName)
+  } catch {
+    printAdapterError(false, adapterName)
+    process.exit(1)
+  }
+
+  const available = await adapter.isAvailable()
+  if (!available) {
+    printAdapterError(false, adapterName)
+    process.exit(1)
+  }
+
+  console.log(c.dim(`  Using adapter: ${adapterName}`))
+  console.log(c.dim(`  Generating convoy spec from: ${opts.file}\n`))
+
+  // ── Execute the prompt through the adapter ────────────────────
+  const task: Task = {
+    id: 'generate-convoy',
+    prompt: assembledPrompt,
+    agent: 'team-lead',
+    timeout: '10m',
+    depends_on: [],
+    files: [],
+    description: 'Generate convoy spec from task description',
+    max_retries: 1,
+  }
+
+  const result = await adapter.execute(task, { verbose: opts.verbose })
+
+  // ── Extract YAML from the response ────────────────────────────
+  const yamlContent = extractYamlBlock(result.output)
+  if (!yamlContent) {
+    const preview = result.output.slice(0, 500)
+    console.error(`  ✗ No YAML code block found in the agent response.\n`)
+    console.error(c.dim(`  Raw output (truncated):\n${preview}`))
+    process.exit(1)
+  }
+
+  // ── Validate YAML ─────────────────────────────────────────────
+  let validationWarning = false
+  try {
+    parseTaskSpecText(yamlContent)
+  } catch (err) {
+    validationWarning = true
+    const msg = err instanceof Error ? err.message : String(err)
+    console.warn(c.yellow(`  ⚠ YAML validation warning: ${msg}`))
+    console.warn(c.dim(`    The file will still be written — you may need to edit it before running.\n`))
+  }
+
+  // ── Determine output path ─────────────────────────────────────
+  let outputPath: string
+  if (opts.output) {
+    outputPath = resolve(process.cwd(), opts.output)
+  } else {
+    const convoyDir = resolve(process.cwd(), '.opencastle', 'convoys')
+    await mkdir(convoyDir, { recursive: true })
+    const filename = deriveOutputFilename(yamlContent)
+    outputPath = join(convoyDir, filename)
+  }
+
+  await mkdir(resolve(outputPath, '..'), { recursive: true })
+  await writeFile(outputPath, yamlContent + '\n', 'utf8')
+
+  const relPath = outputPath.startsWith(process.cwd())
+    ? outputPath.slice(process.cwd().length + 1)
+    : outputPath
+
+  console.log(c.green(`  ✓ Convoy spec written to ${relPath}`))
+  if (validationWarning) {
+    console.log(c.yellow(`    (contains validation warnings — review before running)`))
+  }
+  console.log(`
+  ${c.dim('Preview:')} npx opencastle run -f ${relPath} --dry-run
+  ${c.dim('Execute:')} npx opencastle run -f ${relPath}
+`)
+}

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

@@ -0,0 +1,234 @@
+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('claude 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('@anthropic-ai/agent-sdk', () => {
+      // Must use a regular function (not arrow) so `new AgentClient()` works
+      function MockAgentClient(this: Record<string, unknown>) {
+        this.start = vi.fn().mockResolvedValue(undefined)
+        this.createSession = mockCreateSession
+      }
+      return {
+        AgentClient: MockAgentClient,
+        approveAll: vi.fn(),
+      }
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('passes mcpServers to createSession when provided', async () => {
+    const { execute } = await import('./claude.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('./claude.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('./claude.js')
+    await execute(makeTask(), { mcpServers: [] })
+    const callArg = mockCreateSession.mock.calls[0]?.[0] as Record<string, unknown>
+    expect(callArg).not.toHaveProperty('mcpServers')
+  })
+})
+
+// ── CLI mode ──────────────────────────────────────────────────────────────────
+
+describe('claude adapter — CLI mode', () => {
+  let tmpDir: string
+  let mockSpawn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.resetModules()
+    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'claude-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 { executeViaCli } = await import('./claude.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await executeViaCli(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 { executeViaCli } = await import('./claude.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await executeViaCli(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 { executeViaCli } = await import('./claude.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await executeViaCli(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 { executeViaCli } = await import('./claude.js')
+    const mcpServers = [{ name: 'err-mcp', type: 'local', command: 'node', args: [] }]
+    await executeViaCli(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 { executeViaCli } = await import('./claude.js')
+    await executeViaCli(makeTask(), { mcp_approve_all: true, cwd: tmpDir })
+    expect(capturedArgs).toContain('--approve-mcps')
+  })
+
+  it('does NOT write mcp.json when mcpServers not configured', async () => {
+    const { executeViaCli } = await import('./claude.js')
+    await executeViaCli(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 { executeViaCli } = await import('./claude.js')
+    await executeViaCli(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 { executeViaCli } = await import('./claude.js')
+    const mcpServers = [
+      {
+        name: 'remote-mcp',
+        type: 'remote',
+        url: 'http://localhost:9000',
+        config: { token: 'abc' },
+      },
+    ]
+    await executeViaCli(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/claude.ts

@@ -1,10 +1,13 @@
 import { spawn } from 'node:child_process'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
 import { parseTimeout } from '../schema.js'
 import type { Task, ExecuteOptions, ExecuteResult, TokenUsage } from '../../types.js'
 
 // Adapter name
 export const name = 'claude'
 
+export function supportsSessionContinuity(): boolean { return false }
 // Module-level state for mode selection
 let mode: 'sdk' | 'cli' | null = null
 
@@ -100,6 +103,8 @@ 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 } : {}),
   })
   activeSessions.set(task.id, session)
   if (options.verbose) {
@@ -108,12 +113,21 @@ async function executeViaSdk(task: Task, options: ExecuteOptions = {}): Promise<
       process.stdout.write(event.data.deltaContent)
     })
   }
+  interface SdkResponse {
+    data?: {
+      content?: string
+      usage?: Record<string, number>
+    }
+    usage?: Record<string, number>
+  }
+
   try {
     const timeoutMs = parseTimeout(task.timeout)
     const response = await session.sendAndWait({ prompt }, timeoutMs)
-    const data = (response as any)?.data as Record<string, unknown> | undefined
+    const typed = response as SdkResponse
+    const data = typed?.data
     const output = (data?.content as string | undefined) ?? ''
-    const rawUsage = data?.usage ?? (response as any)?.usage
+    const rawUsage = data?.usage ?? typed?.usage
     const u = rawUsage as Record<string, number> | undefined
     const usageResult = u
       ? {
@@ -150,7 +164,7 @@ function killSdk(task: Task): void {
 }
 
 // --- CLI implementation (from claude-code.ts) ---
-async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+export async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
   let prompt = `You are a ${task.agent}. ${task.prompt}`
   if (task.files && task.files.length > 0) {
     prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
@@ -163,11 +177,32 @@ 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')
+    args.push('--mcp-config', mcpJsonPath)
+    wroteJson = true
+  }
+  if (options.mcp_approve_all) {
+    args.push('--approve-mcps')
+  }
+  try {
+  return await new Promise<ExecuteResult>((resolve) => {
     const proc = spawn('claude', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: options?.cwd ?? process.cwd(),
+      cwd,
     })
     let stdout = ''
     let stderr = ''
@@ -212,6 +247,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 {