opencastle 0.16.0 → 0.18.0

package/src/cli/convoy/engine.ts

@@ -9,9 +9,11 @@ import { createEventEmitter, type ConvoyEventEmitter } from './events.js'
 import { createWorktreeManager, type WorktreeManager } from './worktree.js'
 import { createMergeQueue, type MergeQueue } from './merge.js'
 import { createHealthMonitor } from './health.js'
+import { exportConvoyToNdjson } from './export.js'
 import type { TaskRecord, ConvoyStatus } from './types.js'
 import { buildPhases, formatDuration } from '../run/executor.js'
 import { parseTimeout } from '../run/schema.js'
+import { getAdapter, detectAdapter } from '../run/adapters/index.js'
 
 const execFile = promisify(execFileCb)
 
@@ -61,6 +63,7 @@ function taskRecordToTask(record: TaskRecord): Task {
     description: '',
     model: record.model ?? undefined,
     max_retries: record.max_retries,
+    adapter: record.adapter ?? undefined,
   }
 }
 
@@ -91,6 +94,7 @@ async function runConvoy(
   startTime: number,
 ): Promise<ConvoyResult> {
   const activeTaskMap = new Map<string, Task>()
+  const taskAdapterMap = new Map<string, AgentAdapter>()
 
   const healthMonitor = createHealthMonitor({
     store,
@@ -98,10 +102,12 @@ async function runConvoy(
     convoyId,
     onKill: (workerId, taskId) => {
       const task = activeTaskMap.get(taskId)
-      if (task && typeof adapter.kill === 'function') {
-        adapter.kill(task)
+      const taskAdpt = taskAdapterMap.get(taskId) ?? adapter
+      if (task && typeof taskAdpt.kill === 'function') {
+        taskAdpt.kill(task)
       }
       activeTaskMap.delete(taskId)
+      taskAdapterMap.delete(taskId)
     },
   })
   healthMonitor.start()
@@ -148,9 +154,23 @@ async function runConvoy(
     const workerId = `worker-${taskRecord.id}-${Date.now()}`
     const now = () => new Date().toISOString()
 
+    // Resolve per-task adapter (fallback to convoy-level adapter)
+    let taskAdapter: AgentAdapter = adapter
+    if (taskRecord.adapter && taskRecord.adapter !== adapter.name) {
+      if (taskRecord.adapter === 'auto') {
+        const detected = await detectAdapter()
+        if (detected) {
+          taskAdapter = await getAdapter(detected)
+        }
+      } else {
+        taskAdapter = await getAdapter(taskRecord.adapter)
+      }
+    }
+    taskAdapterMap.set(taskRecord.id, taskAdapter)
+
     // Create worktree (skip for copilot adapter)
     let worktreePath: string | null = null
-    if (adapter.name !== 'copilot') {
+    if (taskAdapter.name !== 'copilot') {
       try {
         worktreePath = await wtManager.create(workerId, baseBranch)
       } catch (err) {
@@ -165,7 +185,7 @@ async function runConvoy(
     store.insertWorker({
       id: workerId,
       task_id: taskRecord.id,
-      adapter: adapter.name,
+      adapter: taskAdapter.name,
       pid: null,
       session_id: null,
       status: 'spawned',
@@ -196,7 +216,7 @@ async function runConvoy(
     let result: ExecuteResult
     try {
       result = await Promise.race([
-        adapter.execute(task, { verbose, cwd: worktreePath ?? basePath }),
+        taskAdapter.execute(task, { verbose, cwd: worktreePath ?? basePath }),
         timeout.promise,
       ])
       timeout.clear()
@@ -217,7 +237,7 @@ async function runConvoy(
 
     // ── Timed out ───────────────────────────────────────────────────────────
     if (result._timedOut) {
-      if (typeof adapter.kill === 'function') adapter.kill(task)
+      if (typeof taskAdapter.kill === 'function') taskAdapter.kill(task)
       await removeWorktree()
 
       const freshRecord = store.getTask(taskRecord.id, convoyId)!
@@ -251,6 +271,7 @@ async function runConvoy(
         )
         cascadeFailure(taskRecord.id)
       }
+      taskAdapterMap.delete(taskRecord.id)
       return
     }
 
@@ -283,11 +304,12 @@ async function runConvoy(
         { exit_code: result.exitCode, worker_id: workerId },
         { convoy_id: convoyId, task_id: taskRecord.id, worker_id: workerId },
       )
+      taskAdapterMap.delete(taskRecord.id)
       return
     }
 
     // ── Failure ─────────────────────────────────────────────────────────────
-    if (typeof adapter.kill === 'function') adapter.kill(task)
+    if (typeof taskAdapter.kill === 'function') taskAdapter.kill(task)
     await removeWorktree()
 
     const freshRecord = store.getTask(taskRecord.id, convoyId)!
@@ -322,6 +344,7 @@ async function runConvoy(
       )
       cascadeFailure(taskRecord.id)
     }
+    taskAdapterMap.delete(taskRecord.id)
   }
 
   // ── Main execution loop ───────────────────────────────────────────────────
@@ -416,6 +439,7 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
     const wtManager = options._worktreeManager ?? createWorktreeManager(basePath)
     const mergeQueue = options._mergeQueue ?? createMergeQueue(basePath)
 
+    let result: ConvoyResult
     try {
       store.insertConvoy({
         id: convoyId,
@@ -437,6 +461,7 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
             phase: phaseIdx,
             prompt: task.prompt,
             agent: task.agent,
+            adapter: task.adapter ?? null,
             model: task.model ?? null,
             timeout_ms: parseTimeout(task.timeout),
             status: 'pending',
@@ -451,13 +476,15 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
       store.updateConvoyStatus(convoyId, 'running', { started_at: new Date().toISOString() })
       events.emit('convoy_started', { name: spec.name }, { convoy_id: convoyId })
 
-      return await runConvoy(
+      result = await runConvoy(
         convoyId, spec, adapter, store, events,
         wtManager, mergeQueue, basePath, baseBranch, verbose, startTime,
       )
     } finally {
+      try { await exportConvoyToNdjson(store, convoyId, options.logsDir) } catch { /* silent */ }
       store.close()
     }
+    return result
   }
 
   async function resume(convoyId: string): Promise<ConvoyResult> {
@@ -469,6 +496,7 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
     const wtManager = options._worktreeManager ?? createWorktreeManager(basePath)
     const mergeQueue = options._mergeQueue ?? createMergeQueue(basePath)
 
+    let result: ConvoyResult
     try {
       const convoy = store.getConvoy(convoyId)
       if (!convoy) {
@@ -508,13 +536,15 @@ export function createConvoyEngine(options: ConvoyEngineOptions): ConvoyEngine {
         { convoy_id: convoyId },
       )
 
-      return await runConvoy(
+      result = await runConvoy(
         convoyId, spec, adapter, store, events,
         wtManager, mergeQueue, basePath, baseBranch, verbose, startTime,
       )
     } finally {
+      try { await exportConvoyToNdjson(store, convoyId, options.logsDir) } catch { /* silent */ }
       store.close()
     }
+    return result
   }
 
   return { run, resume }

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

@@ -0,0 +1,190 @@
+import { mkdtempSync, rmSync, readFileSync, existsSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { exportConvoyToNdjson } from './export.js'
+import { createConvoyStore } from './store.js'
+import type { ConvoyStore } from './store.js'
+import type { ConvoyTaskStatus } from './types.js'
+
+vi.mock('../log.js', () => ({
+  appendEvent: vi.fn().mockResolvedValue(undefined),
+}))
+
+const NOW = '2026-03-08T10:00:00.000Z'
+
+let tmpDir: string
+let store: ConvoyStore
+
+function insertConvoy(id: string, name = 'Test Convoy') {
+  store.insertConvoy({
+    id,
+    name,
+    spec_hash: 'abc123',
+    status: 'done',
+    branch: 'main',
+    created_at: NOW,
+    spec_yaml: 'name: test',
+  })
+  store.updateConvoyStatus(id, 'done', { started_at: NOW, finished_at: NOW })
+}
+
+function insertTask(
+  taskId: string,
+  convoyId: string,
+  phase = 1,
+  status: ConvoyTaskStatus = 'done',
+) {
+  store.insertTask({
+    id: taskId,
+    convoy_id: convoyId,
+    phase,
+    prompt: 'Do something',
+    agent: 'developer',
+    adapter: 'claude-code',
+    model: null,
+    timeout_ms: 1_800_000,
+    status,
+    retries: 0,
+    max_retries: 1,
+    files: null,
+    depends_on: null,
+  })
+  if (status !== 'pending') {
+    store.updateTaskStatus(taskId, convoyId, status, {
+      started_at: NOW,
+      finished_at: NOW,
+      retries: 0,
+    })
+  }
+}
+
+function insertEvent(convoyId: string) {
+  store.insertEvent({
+    convoy_id: convoyId,
+    task_id: null,
+    worker_id: null,
+    type: 'convoy.started',
+    data: null,
+    created_at: NOW,
+  })
+}
+
+beforeEach(() => {
+  tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'convoy-export-test-')))
+  store = createConvoyStore(join(tmpDir, 'convoy.db'))
+})
+
+afterEach(() => {
+  store.close()
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe('exportConvoyToNdjson', () => {
+  it('creates convoys.ndjson with valid NDJSON', async () => {
+    insertConvoy('c1')
+    insertTask('t1', 'c1')
+    const logsDir = join(tmpDir, 'logs')
+
+    await exportConvoyToNdjson(store, 'c1', logsDir)
+
+    const outFile = join(logsDir, 'convoys.ndjson')
+    expect(existsSync(outFile)).toBe(true)
+    const line = readFileSync(outFile, 'utf8').trimEnd()
+    expect(() => JSON.parse(line)).not.toThrow()
+  })
+
+  it('appends on multiple exports (2 convoys -> 2 lines)', async () => {
+    insertConvoy('c1')
+    insertConvoy('c2', 'Second Convoy')
+    const logsDir = join(tmpDir, 'logs')
+
+    await exportConvoyToNdjson(store, 'c1', logsDir)
+    await exportConvoyToNdjson(store, 'c2', logsDir)
+
+    const content = readFileSync(join(logsDir, 'convoys.ndjson'), 'utf8')
+    const lines = content.trim().split('\n').filter(Boolean)
+    expect(lines).toHaveLength(2)
+    expect(JSON.parse(lines[0]).id).toBe('c1')
+    expect(JSON.parse(lines[1]).id).toBe('c2')
+  })
+
+  it('required fields present', async () => {
+    insertConvoy('c1')
+    insertTask('t1', 'c1', 1, 'done')
+    insertTask('t2', 'c1', 1, 'failed')
+    insertEvent('c1')
+    const logsDir = join(tmpDir, 'logs')
+
+    await exportConvoyToNdjson(store, 'c1', logsDir)
+
+    const record = JSON.parse(readFileSync(join(logsDir, 'convoys.ndjson'), 'utf8').trim())
+    expect(record.id).toBe('c1')
+    expect(record.name).toBe('Test Convoy')
+    expect(record.status).toBe('done')
+    expect(Array.isArray(record.tasks)).toBe(true)
+    expect(record.tasks).toHaveLength(2)
+    expect(record.tasks[0]).toMatchObject({
+      id: 't1',
+      phase: 1,
+      agent: 'developer',
+      adapter: 'claude-code',
+      status: 'done',
+      retries: 0,
+    })
+    expect(record.summary).toMatchObject({ total: 2, done: 1, failed: 1, skipped: 0, timedOut: 0 })
+    expect(record.events_count).toBe(1)
+  })
+
+  it('missing convoy -> no error, no file', async () => {
+    const logsDir = join(tmpDir, 'logs')
+    await expect(exportConvoyToNdjson(store, 'nonexistent', logsDir)).resolves.toBeUndefined()
+    expect(existsSync(join(logsDir, 'convoys.ndjson'))).toBe(false)
+  })
+
+  it('creates directory if missing', async () => {
+    insertConvoy('c1')
+    const logsDir = join(tmpDir, 'deep', 'nested', 'logs')
+
+    await exportConvoyToNdjson(store, 'c1', logsDir)
+
+    expect(existsSync(join(logsDir, 'convoys.ndjson'))).toBe(true)
+  })
+
+  it('respects custom logsDir', async () => {
+    insertConvoy('c1')
+    const customDir = join(tmpDir, 'custom-output')
+
+    await exportConvoyToNdjson(store, 'c1', customDir)
+
+    const outFile = join(customDir, 'convoys.ndjson')
+    expect(existsSync(outFile)).toBe(true)
+    const record = JSON.parse(readFileSync(outFile, 'utf8').trim())
+    expect(record.id).toBe('c1')
+  })
+
+  it('never throws on store error — writes warning to stderr', async () => {
+    const broken = {
+      getConvoy: () => { throw new Error('db exploded') },
+    } as unknown as ConvoyStore
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
+
+    await expect(exportConvoyToNdjson(broken, 'c1', join(tmpDir, 'logs'))).resolves.toBeUndefined()
+    expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('exportConvoyToNdjson warning'))
+
+    stderrSpy.mockRestore()
+  })
+
+  it('defaults to .opencastle/logs when logsDir is omitted', async () => {
+    insertConvoy('c1')
+    const originalCwd = process.cwd()
+    process.chdir(tmpDir)
+    try {
+      await exportConvoyToNdjson(store, 'c1')
+      const outFile = join(tmpDir, '.opencastle', 'logs', 'convoys.ndjson')
+      expect(existsSync(outFile)).toBe(true)
+    } finally {
+      process.chdir(originalCwd)
+    }
+  })
+})

package/src/cli/convoy/export.ts

@@ -0,0 +1,52 @@
+import { appendFileSync, mkdirSync } from 'node:fs'
+import { resolve } from 'node:path'
+import type { ConvoyStore } from './store.js'
+export async function exportConvoyToNdjson(
+  store: ConvoyStore,
+  convoyId: string,
+  logsDir?: string,
+): Promise<void> {
+  try {
+    const convoy = store.getConvoy(convoyId)
+    if (!convoy) return
+
+    const tasks = store.getTasksByConvoy(convoyId)
+    const eventsCount = store.getEvents(convoyId).length
+
+    const summary = {
+      total: tasks.length,
+      done: tasks.filter((t) => t.status === 'done').length,
+      failed: tasks.filter((t) => t.status === 'failed').length,
+      skipped: tasks.filter((t) => t.status === 'skipped').length,
+      timedOut: tasks.filter((t) => t.status === 'timed-out').length,
+    }
+
+    const record = {
+      id: convoy.id,
+      name: convoy.name,
+      status: convoy.status,
+      branch: convoy.branch,
+      created_at: convoy.created_at,
+      started_at: convoy.started_at,
+      finished_at: convoy.finished_at,
+      summary,
+      tasks: tasks.map((t) => ({
+        id: t.id,
+        phase: t.phase,
+        agent: t.agent,
+        adapter: t.adapter,
+        status: t.status,
+        started_at: t.started_at,
+        finished_at: t.finished_at,
+        retries: t.retries,
+      })),
+      events_count: eventsCount,
+    }
+
+    const dir = logsDir ?? resolve(process.cwd(), '.opencastle', 'logs')
+    mkdirSync(dir, { recursive: true })
+    appendFileSync(resolve(dir, 'convoys.ndjson'), JSON.stringify(record) + '\n', 'utf8')
+  } catch (err) {
+    process.stderr.write(`[opencastle] exportConvoyToNdjson warning: ${String(err)}\n`)
+  }
+}

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

@@ -63,6 +63,7 @@ function makeTask(
     phase: 0,
     prompt: 'Do something',
     agent: 'developer',
+    adapter: null,
     model: null,
     timeout_ms: 60_000,
     status: 'running' as const,

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

@@ -43,6 +43,7 @@ function makeTask(overrides: Partial<Parameters<ConvoyStore['insertTask']>[0]> =
     phase: 0,
     prompt: 'Do something',
     agent: 'developer',
+    adapter: null as string | null,
     model: null,
     timeout_ms: 1_800_000,
     status: 'pending' as const,
@@ -83,11 +84,11 @@ describe('DB creation', () => {
     expect(row.journal_mode).toBe('wal')
   })
 
-  it('sets schema version to 1', () => {
+  it('sets schema version to 2', () => {
     const db = new DatabaseSync(dbPath)
     const row = db.prepare('PRAGMA user_version').get() as { user_version: number }
     db.close()
-    expect(row.user_version).toBe(1)
+    expect(row.user_version).toBe(2)
   })
 
   it('creates all required tables', () => {
@@ -112,7 +113,86 @@ describe('DB creation', () => {
     store2.close()
     // Reassign so afterEach does not double-close
     store = createConvoyStore(dbPath)
-    expect(row.user_version).toBe(1)
+    expect(row.user_version).toBe(2)
+  })
+})
+
+// ── schema migration ─────────────────────────────────────────────────────────
+
+describe('schema migration', () => {
+  it('schema migration v1 to v2 adds adapter column', () => {
+    // Create a v1 database manually: task table without adapter column
+    const v1DbPath = join(tmpDir, 'v1.db')
+    const rawDb = new DatabaseSync(v1DbPath)
+    rawDb.exec(`
+      CREATE TABLE convoy (
+        id          TEXT PRIMARY KEY,
+        name        TEXT NOT NULL,
+        spec_hash   TEXT NOT NULL,
+        status      TEXT NOT NULL DEFAULT 'pending',
+        branch      TEXT,
+        created_at  TEXT NOT NULL,
+        started_at  TEXT,
+        finished_at TEXT,
+        spec_yaml   TEXT NOT NULL
+      );
+      CREATE TABLE task (
+        id          TEXT PRIMARY KEY,
+        convoy_id   TEXT NOT NULL REFERENCES convoy(id),
+        phase       INTEGER NOT NULL,
+        prompt      TEXT NOT NULL,
+        agent       TEXT NOT NULL DEFAULT 'developer',
+        model       TEXT,
+        timeout_ms  INTEGER NOT NULL DEFAULT 1800000,
+        status      TEXT NOT NULL DEFAULT 'pending',
+        worker_id   TEXT,
+        worktree    TEXT,
+        output      TEXT,
+        exit_code   INTEGER,
+        started_at  TEXT,
+        finished_at TEXT,
+        retries     INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 1,
+        files       TEXT,
+        depends_on  TEXT
+      );
+      CREATE TABLE worker (
+        id             TEXT PRIMARY KEY,
+        task_id        TEXT REFERENCES task(id),
+        adapter        TEXT NOT NULL,
+        pid            INTEGER,
+        session_id     TEXT,
+        status         TEXT NOT NULL DEFAULT 'spawned',
+        worktree       TEXT,
+        created_at     TEXT NOT NULL,
+        finished_at    TEXT,
+        last_heartbeat TEXT
+      );
+      CREATE TABLE event (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        convoy_id  TEXT REFERENCES convoy(id),
+        task_id    TEXT,
+        worker_id  TEXT,
+        type       TEXT NOT NULL,
+        data       TEXT,
+        created_at TEXT NOT NULL
+      );
+    `)
+    rawDb.exec('PRAGMA user_version = 1')
+    rawDb.close()
+
+    // Open with createConvoyStore — should apply the v1→v2 migration
+    const v1Store = createConvoyStore(v1DbPath)
+    v1Store.close()
+
+    // Verify adapter column was added to task table
+    const verifyDb = new DatabaseSync(v1DbPath)
+    const cols = verifyDb.prepare('PRAGMA table_info(task)').all() as Array<{ name: string }>
+    const version = verifyDb.prepare('PRAGMA user_version').get() as { user_version: number }
+    verifyDb.close()
+
+    expect(cols.map(c => c.name)).toContain('adapter')
+    expect(version.user_version).toBe(2)
   })
 })
 
@@ -182,6 +262,12 @@ describe('task CRUD', () => {
     expect(store.getTask('does-not-exist', 'convoy-1')).toBeUndefined()
   })
 
+  it('insertTask stores adapter field', () => {
+    store.insertTask(makeTask({ adapter: 'opencode' }))
+    const retrieved = store.getTask('task-1', 'convoy-1')!
+    expect(retrieved.adapter).toBe('opencode')
+  })
+
   it('stores JSON fields as strings', () => {
     const task = makeTask({
       id: 'task-json',

package/src/cli/convoy/store.ts

@@ -9,7 +9,7 @@ import type {
   EventRecord,
 } from './types.js'
 
-const SCHEMA_VERSION = 1
+const SCHEMA_VERSION = 2
 
 export interface ConvoyStore {
   insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at'>): void
@@ -82,6 +82,7 @@ class ConvoyStoreImpl implements ConvoyStore {
           phase       INTEGER NOT NULL,
           prompt      TEXT NOT NULL,
           agent       TEXT NOT NULL DEFAULT 'developer',
+          adapter     TEXT,
           model       TEXT,
           timeout_ms  INTEGER NOT NULL DEFAULT 1800000,
           status      TEXT NOT NULL DEFAULT 'pending',
@@ -122,6 +123,10 @@ class ConvoyStoreImpl implements ConvoyStore {
       `)
       this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`)
     }
+    if (row.user_version === 1) {
+      this.db.exec('ALTER TABLE task ADD COLUMN adapter TEXT')
+      this.db.exec('PRAGMA user_version = 2')
+    }
   }
 
   insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at'>): void {
@@ -174,11 +179,11 @@ class ConvoyStoreImpl implements ConvoyStore {
     this.db
       .prepare(
         `INSERT INTO task
-           (id, convoy_id, phase, prompt, agent, model, timeout_ms, status,
+           (id, convoy_id, phase, prompt, agent, adapter, model, timeout_ms, status,
             worker_id, worktree, output, exit_code, started_at, finished_at,
             retries, max_retries, files, depends_on)
          VALUES
-           (:id, :convoy_id, :phase, :prompt, :agent, :model, :timeout_ms, :status,
+           (:id, :convoy_id, :phase, :prompt, :agent, :adapter, :model, :timeout_ms, :status,
             NULL, NULL, NULL, NULL, NULL, NULL,
             :retries, :max_retries, :files, :depends_on)`,
       )

package/src/cli/convoy/types.ts

@@ -29,6 +29,7 @@ export interface TaskRecord {
   phase: number
   prompt: string
   agent: string
+  adapter: string | null
   model: string | null
   timeout_ms: number
   status: ConvoyTaskStatus