opencastle 0.22.0 → 0.23.0

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

@@ -32,6 +32,7 @@ function makeConvoy(overrides: Partial<Parameters<ConvoyStore['insertConvoy']>[0
     branch: null,
     created_at: new Date().toISOString(),
     spec_yaml: 'name: test',
+    pipeline_id: null,
     ...overrides,
   }
 }
@@ -69,6 +70,19 @@ function makeWorker(overrides: Partial<Parameters<ConvoyStore['insertWorker']>[0
   }
 }
 
+function makePipeline(overrides: Partial<Parameters<ConvoyStore['insertPipeline']>[0]> = {}) {
+  return {
+    id: 'pipeline-1',
+    name: 'Test Pipeline',
+    status: 'pending' as const,
+    branch: null,
+    spec_yaml: 'name: test-pipeline\nversion: 2',
+    convoy_specs: JSON.stringify(['convoys/step1.yml', 'convoys/step2.yml']),
+    created_at: new Date().toISOString(),
+    ...overrides,
+  }
+}
+
 // ── DB creation and WAL mode ──────────────────────────────────────────────────
 
 describe('DB creation', () => {
@@ -84,11 +98,11 @@ describe('DB creation', () => {
     expect(row.journal_mode).toBe('wal')
   })
 
-  it('sets schema version to 3', () => {
+  it('sets schema version to 4', () => {
     const db = new DatabaseSync(dbPath)
     const row = db.prepare('PRAGMA user_version').get() as { user_version: number }
     db.close()
-    expect(row.user_version).toBe(3)
+    expect(row.user_version).toBe(4)
   })
 
   it('creates all required tables', () => {
@@ -102,6 +116,7 @@ describe('DB creation', () => {
     expect(names).toContain('task')
     expect(names).toContain('worker')
     expect(names).toContain('event')
+    expect(names).toContain('pipeline')
   })
 
   it('reopening an existing DB does not reset schema version', () => {
@@ -113,7 +128,7 @@ describe('DB creation', () => {
     store2.close()
     // Reassign so afterEach does not double-close
     store = createConvoyStore(dbPath)
-    expect(row.user_version).toBe(3)
+    expect(row.user_version).toBe(4)
   })
 })
 
@@ -192,8 +207,8 @@ describe('schema migration', () => {
     verifyDb.close()
 
     expect(cols.map(c => c.name)).toContain('adapter')
-    // v1 chains through v2→v3 in one init, so final version is 3
-    expect(version.user_version).toBe(3)
+    // v1 chains through v2→v3→v4 in one init, so final version is 4
+    expect(version.user_version).toBe(4)
   })
 
   it('schema migration v2 to v3 adds cost columns', () => {
@@ -279,7 +294,7 @@ describe('schema migration', () => {
     expect(convoyColNames).toContain('total_tokens')
     expect(convoyColNames).toContain('total_cost_usd')
 
-    expect(version.user_version).toBe(3)
+    expect(version.user_version).toBe(4)
   })
 
   it('schema migration v1 to v3 chains correctly in a single init', () => {
@@ -365,7 +380,90 @@ describe('schema migration', () => {
     expect(convoyColNames).toContain('total_tokens')
     expect(convoyColNames).toContain('total_cost_usd')
 
-    expect(version.user_version).toBe(3)
+    expect(version.user_version).toBe(4)
+  })
+
+  it('schema migration v3 to v4 creates pipeline table and adds pipeline_id to convoy', () => {
+    const v3DbPath = join(tmpDir, 'v3.db')
+    const rawDb = new DatabaseSync(v3DbPath)
+    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,
+        total_tokens INTEGER,
+        total_cost_usd TEXT
+      );
+      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',
+        adapter     TEXT,
+        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,
+        prompt_tokens INTEGER,
+        completion_tokens INTEGER,
+        total_tokens INTEGER,
+        cost_usd 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 = 3')
+    rawDb.close()
+
+    const v3Store = createConvoyStore(v3DbPath)
+    v3Store.close()
+
+    const verifyDb = new DatabaseSync(v3DbPath)
+    const convoyCols = verifyDb.prepare('PRAGMA table_info(convoy)').all() as Array<{ name: string }>
+    const tables = verifyDb
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+      .all() as Array<{ name: string }>
+    const version = verifyDb.prepare('PRAGMA user_version').get() as { user_version: number }
+    verifyDb.close()
+
+    expect(convoyCols.map(c => c.name)).toContain('pipeline_id')
+    expect(tables.map(t => t.name)).toContain('pipeline')
+    expect(version.user_version).toBe(4)
   })
 })
 
@@ -738,6 +836,140 @@ describe('withTransaction', () => {
   })
 })
 
+// ── pipeline CRUD ─────────────────────────────────────────────────────────────
+
+describe('pipeline CRUD', () => {
+  it('inserts and retrieves a pipeline record', () => {
+    store.insertPipeline(makePipeline())
+    const retrieved = store.getPipeline('pipeline-1')
+    expect(retrieved).toBeDefined()
+    expect(retrieved!.id).toBe('pipeline-1')
+    expect(retrieved!.name).toBe('Test Pipeline')
+    expect(retrieved!.status).toBe('pending')
+    expect(retrieved!.started_at).toBeNull()
+    expect(retrieved!.finished_at).toBeNull()
+    expect(retrieved!.total_tokens).toBeNull()
+    expect(retrieved!.total_cost_usd).toBeNull()
+  })
+
+  it('returns undefined for missing pipeline', () => {
+    expect(store.getPipeline('does-not-exist')).toBeUndefined()
+  })
+
+  it('getLatestPipeline returns most recent pipeline', () => {
+    store.insertPipeline(makePipeline({ id: 'pipeline-old', created_at: '2026-01-01T00:00:00.000Z' }))
+    store.insertPipeline(makePipeline({ id: 'pipeline-new', created_at: '2026-01-02T00:00:00.000Z' }))
+    const latest = store.getLatestPipeline()
+    expect(latest?.id).toBe('pipeline-new')
+  })
+
+  it('getLatestPipeline returns undefined when no pipelines exist', () => {
+    expect(store.getLatestPipeline()).toBeUndefined()
+  })
+
+  it('updatePipelineStatus updates status', () => {
+    store.insertPipeline(makePipeline())
+    store.updatePipelineStatus('pipeline-1', 'running')
+    expect(store.getPipeline('pipeline-1')!.status).toBe('running')
+  })
+
+  it('updatePipelineStatus sets started_at', () => {
+    const ts = '2026-01-01T00:00:00.000Z'
+    store.insertPipeline(makePipeline())
+    store.updatePipelineStatus('pipeline-1', 'running', { started_at: ts })
+    const p = store.getPipeline('pipeline-1')!
+    expect(p.status).toBe('running')
+    expect(p.started_at).toBe(ts)
+  })
+
+  it('updatePipelineStatus sets finished_at', () => {
+    const ts = '2026-01-01T01:00:00.000Z'
+    store.insertPipeline(makePipeline())
+    store.updatePipelineStatus('pipeline-1', 'done', { finished_at: ts })
+    const p = store.getPipeline('pipeline-1')!
+    expect(p.status).toBe('done')
+    expect(p.finished_at).toBe(ts)
+  })
+
+  it('updatePipelineStatus persists total_tokens and total_cost_usd', () => {
+    store.insertPipeline(makePipeline())
+    store.updatePipelineStatus('pipeline-1', 'done', {
+      finished_at: '2026-01-01T01:00:00.000Z',
+      total_tokens: 12000,
+      total_cost_usd: '0.036000',
+    })
+    const p = store.getPipeline('pipeline-1')!
+    expect(p.total_tokens).toBe(12000)
+    expect(p.total_cost_usd).toBe('0.036000')
+  })
+
+  it('pipeline status can transition through all states', () => {
+    store.insertPipeline(makePipeline())
+    const states = ['running', 'failed', 'done', 'pending'] as const
+    for (const s of states) {
+      store.updatePipelineStatus('pipeline-1', s)
+      expect(store.getPipeline('pipeline-1')!.status).toBe(s)
+    }
+  })
+
+  it('convoy_specs is stored and retrieved as a JSON string', () => {
+    const specs = ['convoys/build.yml', 'convoys/test.yml', 'convoys/deploy.yml']
+    store.insertPipeline(makePipeline({ convoy_specs: JSON.stringify(specs) }))
+    const p = store.getPipeline('pipeline-1')!
+    expect(JSON.parse(p.convoy_specs)).toEqual(specs)
+  })
+})
+
+// ── pipeline-convoy linking ───────────────────────────────────────────────────
+
+describe('pipeline-convoy linking', () => {
+  it('insertConvoy accepts pipeline_id', () => {
+    store.insertPipeline(makePipeline())
+    store.insertConvoy(makeConvoy({ pipeline_id: 'pipeline-1' }))
+    const c = store.getConvoy('convoy-1')!
+    expect(c.pipeline_id).toBe('pipeline-1')
+  })
+
+  it('insertConvoy with null pipeline_id creates a standalone convoy', () => {
+    store.insertConvoy(makeConvoy({ pipeline_id: null }))
+    const c = store.getConvoy('convoy-1')!
+    expect(c.pipeline_id).toBeNull()
+  })
+
+  it('getConvoysByPipeline returns all convoys for a pipeline', () => {
+    store.insertPipeline(makePipeline())
+    store.insertConvoy(makeConvoy({ id: 'convoy-1', pipeline_id: 'pipeline-1', created_at: '2026-01-01T00:00:00.000Z' }))
+    store.insertConvoy(makeConvoy({ id: 'convoy-2', pipeline_id: 'pipeline-1', created_at: '2026-01-01T01:00:00.000Z' }))
+    const convoys = store.getConvoysByPipeline('pipeline-1')
+    expect(convoys).toHaveLength(2)
+    expect(convoys.map(c => c.id)).toEqual(['convoy-1', 'convoy-2'])
+  })
+
+  it('getConvoysByPipeline returns convoys ordered by created_at', () => {
+    store.insertPipeline(makePipeline())
+    store.insertConvoy(makeConvoy({ id: 'convoy-b', pipeline_id: 'pipeline-1', created_at: '2026-01-01T02:00:00.000Z' }))
+    store.insertConvoy(makeConvoy({ id: 'convoy-a', pipeline_id: 'pipeline-1', created_at: '2026-01-01T01:00:00.000Z' }))
+    const convoys = store.getConvoysByPipeline('pipeline-1')
+    expect(convoys[0].id).toBe('convoy-a')
+    expect(convoys[1].id).toBe('convoy-b')
+  })
+
+  it('getConvoysByPipeline returns empty array when no convoys are linked', () => {
+    store.insertPipeline(makePipeline())
+    expect(store.getConvoysByPipeline('pipeline-1')).toHaveLength(0)
+  })
+
+  it('getConvoysByPipeline does not return convoys from other pipelines', () => {
+    store.insertPipeline(makePipeline({ id: 'pipeline-1' }))
+    store.insertPipeline(makePipeline({ id: 'pipeline-2' }))
+    store.insertConvoy(makeConvoy({ id: 'convoy-1', pipeline_id: 'pipeline-1' }))
+    store.insertConvoy(makeConvoy({ id: 'convoy-2', pipeline_id: 'pipeline-2' }))
+    const p1Convoys = store.getConvoysByPipeline('pipeline-1')
+    expect(p1Convoys).toHaveLength(1)
+    expect(p1Convoys[0].id).toBe('convoy-1')
+  })
+})
+
 // ── close ─────────────────────────────────────────────────────────────────────
 
 describe('close', () => {

package/src/cli/convoy/store.ts

@@ -7,12 +7,14 @@ import type {
   WorkerRecord,
   WorkerStatus,
   EventRecord,
+  PipelineRecord,
+  PipelineStatus,
 } from './types.js'
 
-const SCHEMA_VERSION = 3
+const SCHEMA_VERSION = 4
 
 export interface ConvoyStore {
-  insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at' | 'total_tokens' | 'total_cost_usd'>): void
+  insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at' | 'total_tokens' | 'total_cost_usd' | 'pipeline_id'> & { pipeline_id?: string | null }): void
   getConvoy(id: string): ConvoyRecord | undefined
   getLatestConvoy(): ConvoyRecord | undefined
   updateConvoyStatus(
@@ -46,6 +48,15 @@ export interface ConvoyStore {
   ): void
   insertEvent(record: Omit<EventRecord, 'id'>): void
   getEvents(convoyId: string): EventRecord[]
+  insertPipeline(record: Omit<PipelineRecord, 'started_at' | 'finished_at' | 'total_tokens' | 'total_cost_usd'>): void
+  getPipeline(id: string): PipelineRecord | undefined
+  getLatestPipeline(): PipelineRecord | undefined
+  updatePipelineStatus(
+    id: string,
+    status: PipelineStatus,
+    extra?: { started_at?: string; finished_at?: string; total_tokens?: number | null; total_cost_usd?: string | null },
+  ): void
+  getConvoysByPipeline(pipelineId: string): ConvoyRecord[]
   withTransaction<T>(fn: () => T): T
   close(): void
 }
@@ -75,7 +86,22 @@ class ConvoyStoreImpl implements ConvoyStore {
           finished_at    TEXT,
           spec_yaml      TEXT NOT NULL,
           total_tokens   INTEGER,
-          total_cost_usd TEXT
+          total_cost_usd TEXT,
+          pipeline_id    TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS pipeline (
+          id              TEXT PRIMARY KEY,
+          name            TEXT NOT NULL,
+          status          TEXT NOT NULL DEFAULT 'pending',
+          branch          TEXT,
+          spec_yaml       TEXT NOT NULL,
+          convoy_specs    TEXT NOT NULL,
+          created_at      TEXT NOT NULL,
+          started_at      TEXT,
+          finished_at     TEXT,
+          total_tokens    INTEGER,
+          total_cost_usd  TEXT
         );
 
         CREATE TABLE IF NOT EXISTS task (
@@ -145,15 +171,35 @@ class ConvoyStoreImpl implements ConvoyStore {
       this.db.exec('PRAGMA user_version = 3')
       version = 3
     }
+    if (version === 3) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS pipeline (
+          id              TEXT PRIMARY KEY,
+          name            TEXT NOT NULL,
+          status          TEXT NOT NULL DEFAULT 'pending',
+          branch          TEXT,
+          spec_yaml       TEXT NOT NULL,
+          convoy_specs    TEXT NOT NULL,
+          created_at      TEXT NOT NULL,
+          started_at      TEXT,
+          finished_at     TEXT,
+          total_tokens    INTEGER,
+          total_cost_usd  TEXT
+        )
+      `)
+      this.db.exec('ALTER TABLE convoy ADD COLUMN pipeline_id TEXT')
+      this.db.exec('PRAGMA user_version = 4')
+      version = 4
+    }
   }
 
-  insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at' | 'total_tokens' | 'total_cost_usd'>): void {
+  insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at' | 'total_tokens' | 'total_cost_usd' | 'pipeline_id'> & { pipeline_id?: string | null }): void {
     this.db
       .prepare(
-        `INSERT INTO convoy (id, name, spec_hash, status, branch, created_at, started_at, finished_at, spec_yaml)
-         VALUES (:id, :name, :spec_hash, :status, :branch, :created_at, NULL, NULL, :spec_yaml)`,
+        `INSERT INTO convoy (id, name, spec_hash, status, branch, created_at, started_at, finished_at, spec_yaml, pipeline_id)
+         VALUES (:id, :name, :spec_hash, :status, :branch, :created_at, NULL, NULL, :spec_yaml, :pipeline_id)`,
       )
-      .run(record)
+      .run({ ...record, pipeline_id: record.pipeline_id ?? null })
   }
 
   getConvoy(id: string): ConvoyRecord | undefined {
@@ -324,6 +370,63 @@ class ConvoyStoreImpl implements ConvoyStore {
       .all({ convoy_id: convoyId }) as unknown as EventRecord[]
   }
 
+  insertPipeline(record: Omit<PipelineRecord, 'started_at' | 'finished_at' | 'total_tokens' | 'total_cost_usd'>): void {
+    this.db
+      .prepare(
+        `INSERT INTO pipeline (id, name, status, branch, spec_yaml, convoy_specs, created_at,
+           started_at, finished_at, total_tokens, total_cost_usd)
+         VALUES (:id, :name, :status, :branch, :spec_yaml, :convoy_specs, :created_at,
+           NULL, NULL, NULL, NULL)`,
+      )
+      .run(record)
+  }
+
+  getPipeline(id: string): PipelineRecord | undefined {
+    return this.db
+      .prepare('SELECT * FROM pipeline WHERE id = :id')
+      .get({ id }) as PipelineRecord | undefined
+  }
+
+  getLatestPipeline(): PipelineRecord | undefined {
+    return this.db
+      .prepare('SELECT * FROM pipeline ORDER BY created_at DESC LIMIT 1')
+      .get() as PipelineRecord | undefined
+  }
+
+  updatePipelineStatus(
+    id: string,
+    status: PipelineStatus,
+    extra?: { started_at?: string; finished_at?: string; total_tokens?: number | null; total_cost_usd?: string | null },
+  ): void {
+    const sets = ['status = :status']
+    const params: Record<string, string | number | null> = { id, status }
+
+    if (extra?.started_at !== undefined) {
+      sets.push('started_at = :started_at')
+      params.started_at = extra.started_at
+    }
+    if (extra?.finished_at !== undefined) {
+      sets.push('finished_at = :finished_at')
+      params.finished_at = extra.finished_at
+    }
+    if (extra?.total_tokens !== undefined) {
+      sets.push('total_tokens = :total_tokens')
+      params.total_tokens = extra.total_tokens
+    }
+    if (extra?.total_cost_usd !== undefined) {
+      sets.push('total_cost_usd = :total_cost_usd')
+      params.total_cost_usd = extra.total_cost_usd
+    }
+
+    this.db.prepare(`UPDATE pipeline SET ${sets.join(', ')} WHERE id = :id`).run(params)
+  }
+
+  getConvoysByPipeline(pipelineId: string): ConvoyRecord[] {
+    return this.db
+      .prepare('SELECT * FROM convoy WHERE pipeline_id = :pipeline_id ORDER BY created_at')
+      .all({ pipeline_id: pipelineId }) as unknown as ConvoyRecord[]
+  }
+
   withTransaction<T>(fn: () => T): T {
     this.db.exec('BEGIN')
     try {

package/src/cli/convoy/types.ts

@@ -11,6 +11,8 @@ export type ConvoyTaskStatus =
 
 export type WorkerStatus = 'spawned' | 'running' | 'done' | 'failed' | 'killed'
 
+export type PipelineStatus = 'pending' | 'running' | 'done' | 'failed'
+
 export interface ConvoyRecord {
   id: string
   name: string
@@ -23,6 +25,7 @@ export interface ConvoyRecord {
   spec_yaml: string
   total_tokens: number | null
   total_cost_usd: string | null
+  pipeline_id: string | null
 }
 
 export interface TaskRecord {
@@ -73,3 +76,17 @@ export interface EventRecord {
   data: string | null
   created_at: string
 }
+
+export interface PipelineRecord {
+  id: string
+  name: string
+  status: PipelineStatus
+  branch: string | null
+  spec_yaml: string
+  convoy_specs: string
+  created_at: string
+  started_at: string | null
+  finished_at: string | null
+  total_tokens: number | null
+  total_cost_usd: string | null
+}

package/src/cli/dashboard.ts

@@ -21,6 +21,7 @@ const MIME_TYPES: Record<string, string> = {
 const DATA_FILES = [
   'events.ndjson',
   'convoys.ndjson',
+  'pipelines.ndjson',
   // Legacy individual files — kept for backwards compatibility
   'sessions.ndjson',
   'delegations.ndjson',