@mndrk/agx 2.0.38 → 2.0.40

package/cloud-runtime/standalone/docs/superpowers/plans/2026-04-01-prompt-scheduler.md

@@ -0,0 +1,1907 @@
+# Prompt Scheduler Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace agx-cloud's graph-based automations with a simple prompt+schedule+CLI scheduler, where users create PromptJobs that run on cron schedules via any CLI (claude, codex, gemini, etc.).
+
+**Architecture:** The existing graph engine becomes internal plumbing — a PromptJob maps to a single-node execution graph. New `prompt_runs` table tracks every execution. The runner polls for queued runs, shells out to the target CLI, streams output, and checks a cancel flag every 5s. The existing AutomationsBoard UI is replaced with a PromptJob-focused board.
+
+**Tech Stack:** Next.js 16 (app router), SQLite (better-sqlite3), React 19, TailwindCSS 4, cron-parser, existing graph engine internals.
+
+---
+
+## File Structure
+
+### New Files
+| File | Responsibility |
+|------|---------------|
+| `src/prompt-scheduler/types.ts` | PromptJob and PromptRun types |
+| `src/prompt-scheduler/cron.ts` | Cron parsing, next-run computation (wraps cron-parser + nl-schedule) |
+| `src/prompt-scheduler/engine.ts` | Core scheduling logic: find due jobs, create runs, compute next tick |
+| `src/prompt-scheduler/runner.ts` | CLI execution: spawn child process, capture output, cancel check |
+| `src/prompt-scheduler/store.ts` | Database operations for prompt_jobs and prompt_runs tables |
+| `db/sqlite/002_prompt_scheduler_schema.sql` | Migration: prompt_jobs + prompt_runs tables |
+| `app/api/prompt-jobs/route.ts` | GET (list) + POST (create) prompt jobs |
+| `app/api/prompt-jobs/[id]/route.ts` | GET (detail) + PATCH (update) + DELETE prompt job |
+| `app/api/prompt-jobs/[id]/runs/route.ts` | GET runs for a job |
+| `app/api/prompt-jobs/[id]/cancel/route.ts` | POST cancel current run |
+| `app/api/prompt-jobs/poll/route.ts` | POST poll for due jobs and execute |
+| `components/PromptJobBoard.tsx` | Main UI: job list, create form, run log, controls |
+| `hooks/usePromptJobs.ts` | Data fetching hook for prompt jobs + runs |
+| `__tests__/prompt-scheduler/cron.test.ts` | Cron parsing tests |
+| `__tests__/prompt-scheduler/engine.test.ts` | Scheduling engine tests |
+| `__tests__/prompt-scheduler/runner.test.ts` | Runner execution tests |
+| `__tests__/prompt-scheduler/store.test.ts` | Store CRUD tests |
+| `__tests__/prompt-scheduler/api.test.ts` | API route integration tests |
+
+### Modified Files
+| File | Change |
+|------|--------|
+| `app/automations/page.tsx` | Replace `AutomationsBoard` with `PromptJobBoard` |
+| `db/sqlite/001_agx_board_schema.sql` | Reference only — no changes, new migration file instead |
+
+### Preserved (internal plumbing, untouched)
+| File | Why |
+|------|-----|
+| `src/graph/schedule.ts` | Still used internally by graph engine for existing tasks |
+| `src/graph/schedule-runner.ts` | Prompt scheduler calls into this for graph-level execution |
+| `src/graph/nl-schedule.ts` | Reused by `src/prompt-scheduler/cron.ts` |
+
+---
+
+## Task 1: Database Schema — prompt_jobs and prompt_runs tables
+
+**Files:**
+- Create: `db/sqlite/002_prompt_scheduler_schema.sql`
+- Create: `src/prompt-scheduler/types.ts`
+
+- [ ] **Step 1: Define TypeScript types**
+
+Create `src/prompt-scheduler/types.ts`:
+
+```typescript
+export type PromptJobState = 'active' | 'paused' | 'stopped';
+export type OverlapPolicy = 'skip' | 'queue' | 'allow';
+export type RunStatus = 'queued' | 'running' | 'success' | 'failed' | 'cancelled';
+
+export interface PromptJob {
+  id: string;
+  name: string;
+  prompt: string;
+  cli: string;
+  cronExpr: string;
+  cadence: string;
+  state: PromptJobState;
+  overlapPolicy: OverlapPolicy;
+  cancelCheckSec: number;
+  nextRunAt: number | null;
+  lastRunAt: number | null;
+  lastOutcome: RunStatus | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface PromptRun {
+  id: string;
+  jobId: string;
+  status: RunStatus;
+  output: string | null;
+  error: string | null;
+  durationMs: number | null;
+  startedAt: string | null;
+  finishedAt: string | null;
+  cancelledAt: string | null;
+  createdAt: string;
+}
+
+export interface CreatePromptJobInput {
+  name: string;
+  prompt: string;
+  cli: string;
+  cadence: string;
+  overlapPolicy?: OverlapPolicy;
+  cancelCheckSec?: number;
+}
+
+export interface UpdatePromptJobInput {
+  name?: string;
+  prompt?: string;
+  cli?: string;
+  cadence?: string;
+  state?: PromptJobState;
+  overlapPolicy?: OverlapPolicy;
+  cancelCheckSec?: number;
+}
+```
+
+- [ ] **Step 2: Write the SQL migration**
+
+Create `db/sqlite/002_prompt_scheduler_schema.sql`:
+
+```sql
+-- Prompt Scheduler tables
+CREATE TABLE IF NOT EXISTS prompt_jobs (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    cli TEXT NOT NULL DEFAULT 'claude',
+    cron_expr TEXT NOT NULL,
+    cadence TEXT NOT NULL DEFAULT '',
+    state TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'paused', 'stopped')),
+    overlap_policy TEXT NOT NULL DEFAULT 'skip' CHECK (overlap_policy IN ('skip', 'queue', 'allow')),
+    cancel_check_sec INTEGER NOT NULL DEFAULT 5,
+    next_run_at INTEGER,
+    last_run_at INTEGER,
+    last_outcome TEXT CHECK (last_outcome IS NULL OR last_outcome IN ('queued', 'running', 'success', 'failed', 'cancelled')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_prompt_jobs_state ON prompt_jobs(state);
+CREATE INDEX IF NOT EXISTS idx_prompt_jobs_next_run_at ON prompt_jobs(next_run_at);
+
+CREATE TABLE IF NOT EXISTS prompt_runs (
+    id TEXT PRIMARY KEY,
+    job_id TEXT NOT NULL REFERENCES prompt_jobs(id) ON DELETE CASCADE,
+    status TEXT NOT NULL DEFAULT 'queued' CHECK (status IN ('queued', 'running', 'success', 'failed', 'cancelled')),
+    output TEXT,
+    error TEXT,
+    duration_ms INTEGER,
+    started_at TEXT,
+    finished_at TEXT,
+    cancelled_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_prompt_runs_job_id ON prompt_runs(job_id);
+CREATE INDEX IF NOT EXISTS idx_prompt_runs_status ON prompt_runs(status);
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/prompt-scheduler/types.ts db/sqlite/002_prompt_scheduler_schema.sql
+git commit -m "feat: add prompt_jobs and prompt_runs schema + types"
+```
+
+---
+
+## Task 2: Store — CRUD operations for prompt_jobs and prompt_runs
+
+**Files:**
+- Create: `src/prompt-scheduler/store.ts`
+- Create: `__tests__/prompt-scheduler/store.test.ts`
+
+- [ ] **Step 1: Write failing tests for store operations**
+
+Create `__tests__/prompt-scheduler/store.test.ts`:
+
+```typescript
+import Database from 'better-sqlite3';
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PromptJobStore } from '@/src/prompt-scheduler/store';
+import { readFileSync } from 'fs';
+import path from 'path';
+
+function createTestDb(): Database.Database {
+  const db = new Database(':memory:');
+  const boardSchema = readFileSync(
+    path.join(__dirname, '../../db/sqlite/001_agx_board_schema.sql'),
+    'utf-8'
+  );
+  const promptSchema = readFileSync(
+    path.join(__dirname, '../../db/sqlite/002_prompt_scheduler_schema.sql'),
+    'utf-8'
+  );
+  db.exec(boardSchema);
+  db.exec(promptSchema);
+  return db;
+}
+
+describe('PromptJobStore', () => {
+  let db: Database.Database;
+  let store: PromptJobStore;
+
+  beforeEach(() => {
+    db = createTestDb();
+    store = new PromptJobStore(db);
+  });
+
+  describe('createJob', () => {
+    it('creates a job and returns it with computed fields', () => {
+      const job = store.createJob({
+        name: 'Test Job',
+        prompt: 'Summarize my inbox',
+        cli: 'claude',
+        cronExpr: '0 9 * * *',
+        cadence: 'Daily at 9am',
+      });
+      expect(job.id).toBeTruthy();
+      expect(job.name).toBe('Test Job');
+      expect(job.prompt).toBe('Summarize my inbox');
+      expect(job.cli).toBe('claude');
+      expect(job.cronExpr).toBe('0 9 * * *');
+      expect(job.state).toBe('active');
+      expect(job.nextRunAt).toBeGreaterThan(Date.now() - 60000);
+    });
+  });
+
+  describe('listJobs', () => {
+    it('returns all non-stopped jobs by default', () => {
+      store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: 'Hourly' });
+      store.createJob({ name: 'B', prompt: 'b', cli: 'codex', cronExpr: '0 9 * * *', cadence: 'Daily' });
+      const jobs = store.listJobs();
+      expect(jobs).toHaveLength(2);
+    });
+
+    it('filters by state', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      store.updateJob(job.id, { state: 'paused' });
+      expect(store.listJobs({ state: 'active' })).toHaveLength(0);
+      expect(store.listJobs({ state: 'paused' })).toHaveLength(1);
+    });
+  });
+
+  describe('updateJob', () => {
+    it('updates fields and bumps updatedAt', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      const updated = store.updateJob(job.id, { name: 'B', state: 'paused' });
+      expect(updated.name).toBe('B');
+      expect(updated.state).toBe('paused');
+    });
+  });
+
+  describe('deleteJob', () => {
+    it('deletes job and its runs', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      store.createRun(job.id);
+      store.deleteJob(job.id);
+      expect(store.listJobs()).toHaveLength(0);
+      expect(store.listRuns(job.id)).toHaveLength(0);
+    });
+  });
+
+  describe('runs', () => {
+    it('creates a run in queued status', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      const run = store.createRun(job.id);
+      expect(run.status).toBe('queued');
+      expect(run.jobId).toBe(job.id);
+    });
+
+    it('updates run status and output', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      const run = store.createRun(job.id);
+      const updated = store.updateRun(run.id, {
+        status: 'success',
+        output: 'Done!',
+        durationMs: 1500,
+        finishedAt: new Date().toISOString(),
+      });
+      expect(updated.status).toBe('success');
+      expect(updated.output).toBe('Done!');
+    });
+
+    it('lists runs for a job ordered by created_at desc', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      store.createRun(job.id);
+      store.createRun(job.id);
+      const runs = store.listRuns(job.id);
+      expect(runs).toHaveLength(2);
+    });
+  });
+
+  describe('getDueJobs', () => {
+    it('returns active jobs where nextRunAt <= now', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      // Force nextRunAt to the past
+      db.prepare('UPDATE prompt_jobs SET next_run_at = ? WHERE id = ?').run(Date.now() - 60000, job.id);
+      const due = store.getDueJobs();
+      expect(due).toHaveLength(1);
+      expect(due[0].id).toBe(job.id);
+    });
+
+    it('skips paused jobs', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      db.prepare('UPDATE prompt_jobs SET next_run_at = ?, state = ? WHERE id = ?').run(Date.now() - 60000, 'paused', job.id);
+      expect(store.getDueJobs()).toHaveLength(0);
+    });
+  });
+
+  describe('hasRunningRun', () => {
+    it('returns true if job has a running run', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      const run = store.createRun(job.id);
+      store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+      expect(store.hasRunningRun(job.id)).toBe(true);
+    });
+
+    it('returns false if no running runs', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      expect(store.hasRunningRun(job.id)).toBe(false);
+    });
+  });
+
+  describe('isRunCancelled', () => {
+    it('returns false for non-cancelled run', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      const run = store.createRun(job.id);
+      expect(store.isRunCancelled(run.id)).toBe(false);
+    });
+
+    it('returns true for cancelled run', () => {
+      const job = store.createJob({ name: 'A', prompt: 'a', cli: 'claude', cronExpr: '0 * * * *', cadence: '' });
+      const run = store.createRun(job.id);
+      store.updateRun(run.id, { status: 'cancelled', cancelledAt: new Date().toISOString() });
+      expect(store.isRunCancelled(run.id)).toBe(true);
+    });
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/store.test.ts
+```
+
+Expected: FAIL — `Cannot find module '@/src/prompt-scheduler/store'`
+
+- [ ] **Step 3: Implement the store**
+
+Create `src/prompt-scheduler/store.ts`:
+
+```typescript
+import Database from 'better-sqlite3';
+import { randomUUID } from 'crypto';
+import type { PromptJob, PromptRun, RunStatus } from './types';
+import { computeNextTickFromCron } from '../graph/scheduler';
+
+interface CreateJobInput {
+  name: string;
+  prompt: string;
+  cli: string;
+  cronExpr: string;
+  cadence: string;
+  overlapPolicy?: string;
+  cancelCheckSec?: number;
+}
+
+interface ListJobsFilter {
+  state?: string;
+}
+
+interface UpdateRunInput {
+  status?: RunStatus;
+  output?: string;
+  error?: string;
+  durationMs?: number;
+  startedAt?: string;
+  finishedAt?: string;
+  cancelledAt?: string;
+}
+
+function rowToJob(row: Record<string, unknown>): PromptJob {
+  return {
+    id: row.id as string,
+    name: row.name as string,
+    prompt: row.prompt as string,
+    cli: row.cli as string,
+    cronExpr: row.cron_expr as string,
+    cadence: row.cadence as string,
+    state: row.state as PromptJob['state'],
+    overlapPolicy: row.overlap_policy as PromptJob['overlapPolicy'],
+    cancelCheckSec: row.cancel_check_sec as number,
+    nextRunAt: row.next_run_at as number | null,
+    lastRunAt: row.last_run_at as number | null,
+    lastOutcome: row.last_outcome as RunStatus | null,
+    createdAt: row.created_at as string,
+    updatedAt: row.updated_at as string,
+  };
+}
+
+function rowToRun(row: Record<string, unknown>): PromptRun {
+  return {
+    id: row.id as string,
+    jobId: row.job_id as string,
+    status: row.status as RunStatus,
+    output: row.output as string | null,
+    error: row.error as string | null,
+    durationMs: row.duration_ms as number | null,
+    startedAt: row.started_at as string | null,
+    finishedAt: row.finished_at as string | null,
+    cancelledAt: row.cancelled_at as string | null,
+    createdAt: row.created_at as string,
+  };
+}
+
+export class PromptJobStore {
+  constructor(private db: Database.Database) {}
+
+  createJob(input: CreateJobInput): PromptJob {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const nextRunAt = computeNextTickFromCron(input.cronExpr);
+
+    this.db.prepare(`
+      INSERT INTO prompt_jobs (id, name, prompt, cli, cron_expr, cadence, state, overlap_policy, cancel_check_sec, next_run_at, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?)
+    `).run(
+      id,
+      input.name,
+      input.prompt,
+      input.cli,
+      input.cronExpr,
+      input.cadence,
+      input.overlapPolicy ?? 'skip',
+      input.cancelCheckSec ?? 5,
+      nextRunAt,
+      now,
+      now,
+    );
+
+    return this.getJob(id)!;
+  }
+
+  getJob(id: string): PromptJob | null {
+    const row = this.db.prepare('SELECT * FROM prompt_jobs WHERE id = ?').get(id) as Record<string, unknown> | undefined;
+    return row ? rowToJob(row) : null;
+  }
+
+  listJobs(filter?: ListJobsFilter): PromptJob[] {
+    if (filter?.state) {
+      return (this.db.prepare('SELECT * FROM prompt_jobs WHERE state = ? ORDER BY created_at DESC').all(filter.state) as Record<string, unknown>[]).map(rowToJob);
+    }
+    return (this.db.prepare('SELECT * FROM prompt_jobs ORDER BY created_at DESC').all() as Record<string, unknown>[]).map(rowToJob);
+  }
+
+  updateJob(id: string, updates: Record<string, unknown>): PromptJob {
+    const sets: string[] = [];
+    const values: unknown[] = [];
+
+    const fieldMap: Record<string, string> = {
+      name: 'name',
+      prompt: 'prompt',
+      cli: 'cli',
+      cronExpr: 'cron_expr',
+      cadence: 'cadence',
+      state: 'state',
+      overlapPolicy: 'overlap_policy',
+      cancelCheckSec: 'cancel_check_sec',
+      nextRunAt: 'next_run_at',
+      lastRunAt: 'last_run_at',
+      lastOutcome: 'last_outcome',
+    };
+
+    for (const [key, val] of Object.entries(updates)) {
+      const col = fieldMap[key];
+      if (col) {
+        sets.push(`${col} = ?`);
+        values.push(val);
+      }
+    }
+
+    if (sets.length === 0) return this.getJob(id)!;
+
+    sets.push("updated_at = datetime('now')");
+    values.push(id);
+
+    this.db.prepare(`UPDATE prompt_jobs SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+    return this.getJob(id)!;
+  }
+
+  deleteJob(id: string): void {
+    this.db.prepare('DELETE FROM prompt_jobs WHERE id = ?').run(id);
+  }
+
+  getDueJobs(now: number = Date.now()): PromptJob[] {
+    return (this.db.prepare(
+      "SELECT * FROM prompt_jobs WHERE state = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?"
+    ).all(now) as Record<string, unknown>[]).map(rowToJob);
+  }
+
+  createRun(jobId: string): PromptRun {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT INTO prompt_runs (id, job_id, status, created_at)
+      VALUES (?, ?, 'queued', ?)
+    `).run(id, jobId, now);
+    return this.getRun(id)!;
+  }
+
+  getRun(id: string): PromptRun | null {
+    const row = this.db.prepare('SELECT * FROM prompt_runs WHERE id = ?').get(id) as Record<string, unknown> | undefined;
+    return row ? rowToRun(row) : null;
+  }
+
+  listRuns(jobId: string, limit: number = 50): PromptRun[] {
+    return (this.db.prepare(
+      'SELECT * FROM prompt_runs WHERE job_id = ? ORDER BY created_at DESC LIMIT ?'
+    ).all(jobId, limit) as Record<string, unknown>[]).map(rowToRun);
+  }
+
+  updateRun(id: string, updates: UpdateRunInput): PromptRun {
+    const sets: string[] = [];
+    const values: unknown[] = [];
+
+    const fieldMap: Record<string, string> = {
+      status: 'status',
+      output: 'output',
+      error: 'error',
+      durationMs: 'duration_ms',
+      startedAt: 'started_at',
+      finishedAt: 'finished_at',
+      cancelledAt: 'cancelled_at',
+    };
+
+    for (const [key, val] of Object.entries(updates)) {
+      const col = fieldMap[key];
+      if (col) {
+        sets.push(`${col} = ?`);
+        values.push(val);
+      }
+    }
+
+    if (sets.length === 0) return this.getRun(id)!;
+    values.push(id);
+
+    this.db.prepare(`UPDATE prompt_runs SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+    return this.getRun(id)!;
+  }
+
+  hasRunningRun(jobId: string): boolean {
+    const row = this.db.prepare(
+      "SELECT 1 FROM prompt_runs WHERE job_id = ? AND status IN ('queued', 'running') LIMIT 1"
+    ).get(jobId);
+    return !!row;
+  }
+
+  isRunCancelled(runId: string): boolean {
+    const row = this.db.prepare(
+      "SELECT 1 FROM prompt_runs WHERE id = ? AND status = 'cancelled'"
+    ).get(runId);
+    return !!row;
+  }
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/store.test.ts
+```
+
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/prompt-scheduler/store.ts __tests__/prompt-scheduler/store.test.ts
+git commit -m "feat: add PromptJobStore with CRUD for jobs and runs"
+```
+
+---
+
+## Task 3: Cron Module — parsing and next-run computation
+
+**Files:**
+- Create: `src/prompt-scheduler/cron.ts`
+- Create: `__tests__/prompt-scheduler/cron.test.ts`
+
+- [ ] **Step 1: Write failing tests**
+
+Create `__tests__/prompt-scheduler/cron.test.ts`:
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { parseCadence, computeNextRun } from '@/src/prompt-scheduler/cron';
+
+describe('parseCadence', () => {
+  it('parses natural language to cron', () => {
+    const result = parseCadence('daily at 9am');
+    expect(result).not.toBeNull();
+    expect(result!.cronExpr).toBe('0 9 * * *');
+    expect(result!.cadence).toBe('Daily at 9:00 AM');
+  });
+
+  it('passes through valid cron expressions', () => {
+    const result = parseCadence('*/15 * * * *');
+    expect(result).not.toBeNull();
+    expect(result!.cronExpr).toBe('*/15 * * * *');
+  });
+
+  it('parses "every 2 hours"', () => {
+    const result = parseCadence('every 2 hours');
+    expect(result).not.toBeNull();
+    expect(result!.cronExpr).toBe('0 */2 * * *');
+  });
+
+  it('parses "weekdays at 3pm"', () => {
+    const result = parseCadence('weekdays at 3pm');
+    expect(result).not.toBeNull();
+    expect(result!.cronExpr).toBe('0 15 * * 1-5');
+  });
+
+  it('returns null for unparseable input', () => {
+    expect(parseCadence('whenever the moon is full')).toBeNull();
+  });
+});
+
+describe('computeNextRun', () => {
+  it('returns a future timestamp for a valid cron expression', () => {
+    const next = computeNextRun('* * * * *');
+    expect(next).toBeGreaterThan(Date.now());
+  });
+
+  it('returns a future timestamp for daily at 9am', () => {
+    const next = computeNextRun('0 9 * * *');
+    expect(next).toBeGreaterThan(Date.now() - 86400000);
+  });
+
+  it('returns null for invalid cron', () => {
+    expect(computeNextRun('not a cron')).toBeNull();
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/cron.test.ts
+```
+
+Expected: FAIL — `Cannot find module '@/src/prompt-scheduler/cron'`
+
+- [ ] **Step 3: Implement the cron module**
+
+Create `src/prompt-scheduler/cron.ts`:
+
+```typescript
+import { toCronExpr } from '../graph/nl-schedule';
+
+export interface ParsedCadence {
+  cronExpr: string;
+  cadence: string;
+}
+
+export function parseCadence(input: string): ParsedCadence | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  const nlResult = toCronExpr(trimmed);
+  if (nlResult) {
+    return { cronExpr: nlResult.cronExpr, cadence: nlResult.cadence };
+  }
+
+  // Try parsing as raw cron (5 fields)
+  if (isValidCron(trimmed)) {
+    return { cronExpr: trimmed, cadence: trimmed };
+  }
+
+  return null;
+}
+
+export function computeNextRun(cronExpr: string, fromMs?: number): number | null {
+  try {
+    const { parseExpression } = require('cron-parser');
+    const interval = parseExpression(cronExpr, {
+      currentDate: fromMs ? new Date(fromMs) : new Date(),
+    });
+    return interval.next().getTime();
+  } catch {
+    return null;
+  }
+}
+
+function isValidCron(expr: string): boolean {
+  const parts = expr.split(/\s+/);
+  if (parts.length !== 5) return false;
+  try {
+    const { parseExpression } = require('cron-parser');
+    parseExpression(expr);
+    return true;
+  } catch {
+    return false;
+  }
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/cron.test.ts
+```
+
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/prompt-scheduler/cron.ts __tests__/prompt-scheduler/cron.test.ts
+git commit -m "feat: add cron parsing module wrapping nl-schedule + cron-parser"
+```
+
+---
+
+## Task 4: Engine — find due jobs, create runs, advance schedule
+
+**Files:**
+- Create: `src/prompt-scheduler/engine.ts`
+- Create: `__tests__/prompt-scheduler/engine.test.ts`
+
+- [ ] **Step 1: Write failing tests**
+
+Create `__tests__/prompt-scheduler/engine.test.ts`:
+
+```typescript
+import Database from 'better-sqlite3';
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PromptJobStore } from '@/src/prompt-scheduler/store';
+import { pollDueJobs } from '@/src/prompt-scheduler/engine';
+import { readFileSync } from 'fs';
+import path from 'path';
+
+function createTestDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(readFileSync(path.join(__dirname, '../../db/sqlite/001_agx_board_schema.sql'), 'utf-8'));
+  db.exec(readFileSync(path.join(__dirname, '../../db/sqlite/002_prompt_scheduler_schema.sql'), 'utf-8'));
+  return db;
+}
+
+describe('pollDueJobs', () => {
+  let db: Database.Database;
+  let store: PromptJobStore;
+
+  beforeEach(() => {
+    db = createTestDb();
+    store = new PromptJobStore(db);
+  });
+
+  it('creates runs for due jobs and advances nextRunAt', () => {
+    const job = store.createJob({ name: 'A', prompt: 'hello', cli: 'claude', cronExpr: '* * * * *', cadence: '' });
+    db.prepare('UPDATE prompt_jobs SET next_run_at = ? WHERE id = ?').run(Date.now() - 60000, job.id);
+
+    const result = pollDueJobs(store);
+
+    expect(result.queued).toHaveLength(1);
+    expect(result.queued[0].jobId).toBe(job.id);
+    expect(result.queued[0].status).toBe('queued');
+
+    const updated = store.getJob(job.id)!;
+    expect(updated.nextRunAt).toBeGreaterThan(Date.now() - 1000);
+  });
+
+  it('skips jobs with overlap_policy=skip when a run is active', () => {
+    const job = store.createJob({ name: 'A', prompt: 'hello', cli: 'claude', cronExpr: '* * * * *', cadence: '' });
+    db.prepare('UPDATE prompt_jobs SET next_run_at = ? WHERE id = ?').run(Date.now() - 60000, job.id);
+
+    const run = store.createRun(job.id);
+    store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+
+    const result = pollDueJobs(store);
+    expect(result.queued).toHaveLength(0);
+    expect(result.skipped).toHaveLength(1);
+  });
+
+  it('queues jobs with overlap_policy=allow even when running', () => {
+    const job = store.createJob({ name: 'A', prompt: 'hello', cli: 'claude', cronExpr: '* * * * *', cadence: '' });
+    store.updateJob(job.id, { overlapPolicy: 'allow' });
+    db.prepare('UPDATE prompt_jobs SET next_run_at = ? WHERE id = ?').run(Date.now() - 60000, job.id);
+
+    const run = store.createRun(job.id);
+    store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+
+    const result = pollDueJobs(store);
+    expect(result.queued).toHaveLength(1);
+  });
+
+  it('returns empty when no jobs are due', () => {
+    store.createJob({ name: 'A', prompt: 'hello', cli: 'claude', cronExpr: '0 9 * * *', cadence: '' });
+    const result = pollDueJobs(store);
+    expect(result.queued).toHaveLength(0);
+    expect(result.skipped).toHaveLength(0);
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/engine.test.ts
+```
+
+Expected: FAIL — `Cannot find module '@/src/prompt-scheduler/engine'`
+
+- [ ] **Step 3: Implement the engine**
+
+Create `src/prompt-scheduler/engine.ts`:
+
+```typescript
+import type { PromptRun } from './types';
+import type { PromptJobStore } from './store';
+import { computeNextRun } from './cron';
+
+export interface PollResult {
+  queued: PromptRun[];
+  skipped: Array<{ jobId: string; reason: string }>;
+}
+
+export function pollDueJobs(store: PromptJobStore, now: number = Date.now()): PollResult {
+  const dueJobs = store.getDueJobs(now);
+  const queued: PromptRun[] = [];
+  const skipped: Array<{ jobId: string; reason: string }> = [];
+
+  for (const job of dueJobs) {
+    if (job.overlapPolicy === 'skip' && store.hasRunningRun(job.id)) {
+      skipped.push({ jobId: job.id, reason: 'overlap_skip' });
+      // Still advance nextRunAt so we don't re-check this tick
+      const nextRunAt = computeNextRun(job.cronExpr, now);
+      store.updateJob(job.id, { nextRunAt });
+      continue;
+    }
+
+    const run = store.createRun(job.id);
+    queued.push(run);
+
+    const nextRunAt = computeNextRun(job.cronExpr, now);
+    store.updateJob(job.id, {
+      nextRunAt,
+      lastRunAt: now,
+    });
+  }
+
+  return { queued, skipped };
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/engine.test.ts
+```
+
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/prompt-scheduler/engine.ts __tests__/prompt-scheduler/engine.test.ts
+git commit -m "feat: add poll engine — finds due jobs, handles overlap, creates runs"
+```
+
+---
+
+## Task 5: Runner — CLI execution with cancel checking
+
+**Files:**
+- Create: `src/prompt-scheduler/runner.ts`
+- Create: `__tests__/prompt-scheduler/runner.test.ts`
+
+- [ ] **Step 1: Write failing tests**
+
+Create `__tests__/prompt-scheduler/runner.test.ts`:
+
+```typescript
+import { describe, it, expect, vi } from 'vitest';
+import { buildCliCommand, executeRun } from '@/src/prompt-scheduler/runner';
+
+describe('buildCliCommand', () => {
+  it('builds claude command', () => {
+    const { cmd, args } = buildCliCommand('claude', 'summarize inbox');
+    expect(cmd).toBe('claude');
+    expect(args).toEqual(['-p', 'summarize inbox']);
+  });
+
+  it('builds codex command', () => {
+    const { cmd, args } = buildCliCommand('codex', 'fix the bug');
+    expect(cmd).toBe('codex');
+    expect(args).toEqual(['-p', 'fix the bug']);
+  });
+
+  it('builds gemini command', () => {
+    const { cmd, args } = buildCliCommand('gemini', 'review PR');
+    expect(cmd).toBe('gemini');
+    expect(args).toEqual(['-p', 'review PR']);
+  });
+
+  it('builds custom cli command with {prompt} template', () => {
+    const { cmd, args } = buildCliCommand('my-cli run --input {prompt}', 'hello world');
+    expect(cmd).toBe('my-cli');
+    expect(args).toEqual(['run', '--input', 'hello world']);
+  });
+});
+
+describe('executeRun', () => {
+  it('calls onStart, onComplete callbacks', async () => {
+    const onStart = vi.fn();
+    const onComplete = vi.fn();
+    const isCancelled = vi.fn().mockResolvedValue(false);
+
+    // Use echo as a simple CLI that exits immediately
+    await executeRun({
+      cli: 'echo',
+      prompt: 'hello',
+      cancelCheckSec: 1,
+      isCancelled,
+      onStart,
+      onComplete,
+    });
+
+    expect(onStart).toHaveBeenCalledOnce();
+    expect(onComplete).toHaveBeenCalledOnce();
+    expect(onComplete).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 'success',
+        output: expect.stringContaining('hello'),
+      })
+    );
+  });
+
+  it('cancels when isCancelled returns true', async () => {
+    const onStart = vi.fn();
+    const onComplete = vi.fn();
+    // Return true on second call to cancel mid-run
+    const isCancelled = vi.fn()
+      .mockResolvedValueOnce(false)
+      .mockResolvedValue(true);
+
+    await executeRun({
+      cli: 'sleep',
+      prompt: '10',
+      cancelCheckSec: 0.1,
+      isCancelled,
+      onStart,
+      onComplete,
+    });
+
+    expect(onComplete).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'cancelled' })
+    );
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/runner.test.ts
+```
+
+Expected: FAIL — `Cannot find module '@/src/prompt-scheduler/runner'`
+
+- [ ] **Step 3: Implement the runner**
+
+Create `src/prompt-scheduler/runner.ts`:
+
+```typescript
+import { spawn, type ChildProcess } from 'child_process';
+
+const KNOWN_CLIS: Record<string, string[]> = {
+  claude: ['-p'],
+  codex: ['-p'],
+  gemini: ['-p'],
+};
+
+export function buildCliCommand(cli: string, prompt: string): { cmd: string; args: string[] } {
+  const knownFlags = KNOWN_CLIS[cli];
+  if (knownFlags) {
+    return { cmd: cli, args: [...knownFlags, prompt] };
+  }
+
+  // Custom CLI with {prompt} template
+  if (cli.includes('{prompt}')) {
+    const parts = cli.replace('{prompt}', prompt).split(/\s+/);
+    return { cmd: parts[0], args: parts.slice(1) };
+  }
+
+  // Custom CLI: append prompt as last arg
+  const parts = cli.split(/\s+/);
+  return { cmd: parts[0], args: [...parts.slice(1), prompt] };
+}
+
+export interface RunResult {
+  status: 'success' | 'failed' | 'cancelled';
+  output: string;
+  error: string;
+  durationMs: number;
+}
+
+export interface ExecuteRunOptions {
+  cli: string;
+  prompt: string;
+  cancelCheckSec: number;
+  isCancelled: () => Promise<boolean>;
+  onStart: () => void;
+  onComplete: (result: RunResult) => void;
+}
+
+export async function executeRun(opts: ExecuteRunOptions): Promise<void> {
+  const { cli, prompt, cancelCheckSec, isCancelled, onStart, onComplete } = opts;
+  const { cmd, args } = buildCliCommand(cli, prompt);
+  const startTime = Date.now();
+
+  opts.onStart();
+
+  return new Promise<void>((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    const child: ChildProcess = spawn(cmd, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: false,
+    });
+
+    child.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    const cancelInterval = setInterval(async () => {
+      try {
+        if (await isCancelled()) {
+          killed = true;
+          child.kill('SIGTERM');
+          clearInterval(cancelInterval);
+        }
+      } catch {
+        // ignore cancel check errors
+      }
+    }, cancelCheckSec * 1000);
+
+    child.on('close', (code) => {
+      clearInterval(cancelInterval);
+      const durationMs = Date.now() - startTime;
+
+      if (killed) {
+        onComplete({ status: 'cancelled', output: stdout, error: stderr, durationMs });
+      } else if (code === 0) {
+        onComplete({ status: 'success', output: stdout, error: stderr, durationMs });
+      } else {
+        onComplete({ status: 'failed', output: stdout, error: stderr || `Exit code ${code}`, durationMs });
+      }
+      resolve();
+    });
+
+    child.on('error', (err) => {
+      clearInterval(cancelInterval);
+      const durationMs = Date.now() - startTime;
+      onComplete({ status: 'failed', output: stdout, error: err.message, durationMs });
+      resolve();
+    });
+  });
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npx vitest run __tests__/prompt-scheduler/runner.test.ts
+```
+
+Expected: All tests PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/prompt-scheduler/runner.ts __tests__/prompt-scheduler/runner.test.ts
+git commit -m "feat: add CLI runner with cancel checking and custom CLI templates"
+```
+
+---
+
+## Task 6: API Routes — CRUD + poll + cancel
+
+**Files:**
+- Create: `app/api/prompt-jobs/route.ts`
+- Create: `app/api/prompt-jobs/[id]/route.ts`
+- Create: `app/api/prompt-jobs/[id]/runs/route.ts`
+- Create: `app/api/prompt-jobs/[id]/cancel/route.ts`
+- Create: `app/api/prompt-jobs/poll/route.ts`
+
+- [ ] **Step 1: Implement list + create endpoint**
+
+Create `app/api/prompt-jobs/route.ts`:
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { parseCadence, computeNextRun } from '@/src/prompt-scheduler/cron';
+
+export async function GET(req: NextRequest) {
+  const store = getPromptJobStore();
+  const state = req.nextUrl.searchParams.get('state') ?? undefined;
+  const jobs = store.listJobs(state ? { state } : undefined);
+  return NextResponse.json({ count: jobs.length, jobs });
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { name, prompt, cli, cadence, overlapPolicy, cancelCheckSec } = body;
+
+  if (!name || !prompt || !cadence) {
+    return NextResponse.json({ error: 'name, prompt, and cadence are required' }, { status: 400 });
+  }
+
+  const parsed = parseCadence(cadence);
+  if (!parsed) {
+    return NextResponse.json({ error: `Could not parse cadence: "${cadence}"` }, { status: 400 });
+  }
+
+  const store = getPromptJobStore();
+  const job = store.createJob({
+    name,
+    prompt,
+    cli: cli ?? 'claude',
+    cronExpr: parsed.cronExpr,
+    cadence: parsed.cadence,
+    overlapPolicy,
+    cancelCheckSec,
+  });
+
+  return NextResponse.json(job, { status: 201 });
+}
+```
+
+- [ ] **Step 2: Implement get, update, delete endpoint**
+
+Create `app/api/prompt-jobs/[id]/route.ts`:
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { parseCadence, computeNextRun } from '@/src/prompt-scheduler/cron';
+
+export async function GET(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const store = getPromptJobStore();
+  const job = store.getJob(id);
+  if (!job) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  return NextResponse.json(job);
+}
+
+export async function PATCH(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const store = getPromptJobStore();
+  const job = store.getJob(id);
+  if (!job) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+
+  const body = await req.json();
+  const updates: Record<string, unknown> = {};
+
+  if (body.name !== undefined) updates.name = body.name;
+  if (body.prompt !== undefined) updates.prompt = body.prompt;
+  if (body.cli !== undefined) updates.cli = body.cli;
+  if (body.state !== undefined) updates.state = body.state;
+  if (body.overlapPolicy !== undefined) updates.overlapPolicy = body.overlapPolicy;
+  if (body.cancelCheckSec !== undefined) updates.cancelCheckSec = body.cancelCheckSec;
+
+  if (body.cadence !== undefined) {
+    const parsed = parseCadence(body.cadence);
+    if (!parsed) return NextResponse.json({ error: `Could not parse cadence: "${body.cadence}"` }, { status: 400 });
+    updates.cronExpr = parsed.cronExpr;
+    updates.cadence = parsed.cadence;
+    updates.nextRunAt = computeNextRun(parsed.cronExpr);
+  }
+
+  const updated = store.updateJob(id, updates);
+  return NextResponse.json(updated);
+}
+
+export async function DELETE(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const store = getPromptJobStore();
+  store.deleteJob(id);
+  return NextResponse.json({ ok: true });
+}
+```
+
+- [ ] **Step 3: Implement runs endpoint**
+
+Create `app/api/prompt-jobs/[id]/runs/route.ts`:
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+
+export async function GET(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const store = getPromptJobStore();
+  const runs = store.listRuns(id);
+  return NextResponse.json({ count: runs.length, runs });
+}
+```
+
+- [ ] **Step 4: Implement cancel endpoint**
+
+Create `app/api/prompt-jobs/[id]/cancel/route.ts`:
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+
+export async function POST(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const store = getPromptJobStore();
+
+  // Find the active run for this job
+  const runs = store.listRuns(id, 1);
+  const activeRun = runs.find(r => r.status === 'running' || r.status === 'queued');
+  if (!activeRun) {
+    return NextResponse.json({ error: 'No active run to cancel' }, { status: 404 });
+  }
+
+  store.updateRun(activeRun.id, {
+    status: 'cancelled',
+    cancelledAt: new Date().toISOString(),
+  });
+
+  return NextResponse.json({ ok: true, runId: activeRun.id });
+}
+```
+
+- [ ] **Step 5: Implement poll endpoint**
+
+Create `app/api/prompt-jobs/poll/route.ts`:
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { pollDueJobs } from '@/src/prompt-scheduler/engine';
+import { executeRun } from '@/src/prompt-scheduler/runner';
+
+export async function POST(req: NextRequest) {
+  const store = getPromptJobStore();
+  const body = await req.json().catch(() => ({}));
+  const { jobId } = body as { jobId?: string };
+
+  // If specific job requested, force-queue it
+  if (jobId) {
+    const job = store.getJob(jobId);
+    if (!job) return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+    const run = store.createRun(job.id);
+
+    // Execute async — don't block the response
+    executeRunInBackground(store, job.id, run.id, job.cli, job.prompt, job.cancelCheckSec);
+
+    return NextResponse.json({ queued: [run], skipped: [] });
+  }
+
+  // Normal poll: find due jobs
+  const result = pollDueJobs(store);
+
+  // Execute all queued runs in background
+  for (const run of result.queued) {
+    const job = store.getJob(run.jobId);
+    if (!job) continue;
+    executeRunInBackground(store, job.id, run.id, job.cli, job.prompt, job.cancelCheckSec);
+  }
+
+  return NextResponse.json({
+    queued: result.queued.length,
+    skipped: result.skipped.length,
+    details: result,
+  });
+}
+
+function executeRunInBackground(
+  store: ReturnType<typeof getPromptJobStore>,
+  jobId: string,
+  runId: string,
+  cli: string,
+  prompt: string,
+  cancelCheckSec: number,
+) {
+  executeRun({
+    cli,
+    prompt,
+    cancelCheckSec,
+    isCancelled: async () => store.isRunCancelled(runId),
+    onStart: () => {
+      store.updateRun(runId, { status: 'running', startedAt: new Date().toISOString() });
+    },
+    onComplete: (result) => {
+      store.updateRun(runId, {
+        status: result.status,
+        output: result.output,
+        error: result.error || undefined,
+        durationMs: result.durationMs,
+        finishedAt: new Date().toISOString(),
+        cancelledAt: result.status === 'cancelled' ? new Date().toISOString() : undefined,
+      });
+      store.updateJob(jobId, { lastOutcome: result.status });
+    },
+  }).catch((err) => {
+    store.updateRun(runId, {
+      status: 'failed',
+      error: `Runner error: ${err.message}`,
+      finishedAt: new Date().toISOString(),
+    });
+    store.updateJob(jobId, { lastOutcome: 'failed' });
+  });
+}
+```
+
+- [ ] **Step 6: Create store accessor**
+
+Create `src/prompt-scheduler/get-store.ts`:
+
+```typescript
+import { PromptJobStore } from './store';
+import { getSQLiteDb } from '@/lib/sqlite-query-adapter';
+import { readFileSync } from 'fs';
+import path from 'path';
+
+let _store: PromptJobStore | null = null;
+
+export function getPromptJobStore(): PromptJobStore {
+  if (!_store) {
+    const db = getSQLiteDb();
+    // Run migration if prompt_jobs table doesn't exist
+    const tableExists = db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='table' AND name='prompt_jobs'"
+    ).get();
+    if (!tableExists) {
+      const migration = readFileSync(
+        path.join(process.cwd(), 'db/sqlite/002_prompt_scheduler_schema.sql'),
+        'utf-8'
+      );
+      db.exec(migration);
+    }
+    _store = new PromptJobStore(db);
+  }
+  return _store;
+}
+```
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add app/api/prompt-jobs/ src/prompt-scheduler/get-store.ts
+git commit -m "feat: add API routes for prompt jobs — CRUD, poll, cancel, runs"
+```
+
+---
+
+## Task 7: UI — PromptJobBoard replacing AutomationsBoard
+
+**Files:**
+- Create: `components/PromptJobBoard.tsx`
+- Create: `hooks/usePromptJobs.ts`
+- Modify: `app/automations/page.tsx`
+
+- [ ] **Step 1: Create the data hook**
+
+Create `hooks/usePromptJobs.ts`:
+
+```typescript
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import type { PromptJob, PromptRun } from '@/src/prompt-scheduler/types';
+
+export interface UsePromptJobsResult {
+  jobs: PromptJob[];
+  loading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+  createJob: (input: { name: string; prompt: string; cli: string; cadence: string }) => Promise<PromptJob | null>;
+  updateJob: (id: string, updates: Record<string, unknown>) => Promise<boolean>;
+  deleteJob: (id: string) => Promise<boolean>;
+  toggleJob: (job: PromptJob) => Promise<boolean>;
+  runNow: (id: string) => Promise<boolean>;
+  cancelRun: (id: string) => Promise<boolean>;
+  fetchRuns: (jobId: string) => Promise<PromptRun[]>;
+}
+
+export function usePromptJobs(): UsePromptJobsResult {
+  const [jobs, setJobs] = useState<PromptJob[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      const res = await fetch('/api/prompt-jobs');
+      const data = await res.json();
+      setJobs(data.jobs);
+      setError(null);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Failed to fetch');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    refresh();
+    const interval = setInterval(refresh, 10_000);
+    return () => clearInterval(interval);
+  }, [refresh]);
+
+  const createJob = async (input: { name: string; prompt: string; cli: string; cadence: string }) => {
+    try {
+      const res = await fetch('/api/prompt-jobs', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(input),
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        setError(data.error || 'Failed to create');
+        return null;
+      }
+      const job = await res.json();
+      await refresh();
+      return job;
+    } catch {
+      return null;
+    }
+  };
+
+  const updateJob = async (id: string, updates: Record<string, unknown>) => {
+    try {
+      const res = await fetch(`/api/prompt-jobs/${id}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(updates),
+      });
+      if (res.ok) { await refresh(); return true; }
+      return false;
+    } catch { return false; }
+  };
+
+  const deleteJob = async (id: string) => {
+    try {
+      const res = await fetch(`/api/prompt-jobs/${id}`, { method: 'DELETE' });
+      if (res.ok) { await refresh(); return true; }
+      return false;
+    } catch { return false; }
+  };
+
+  const toggleJob = async (job: PromptJob) => {
+    const newState = job.state === 'active' ? 'paused' : 'active';
+    return updateJob(job.id, { state: newState });
+  };
+
+  const runNow = async (id: string) => {
+    try {
+      const res = await fetch('/api/prompt-jobs/poll', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ jobId: id }),
+      });
+      if (res.ok) { setTimeout(refresh, 1000); return true; }
+      return false;
+    } catch { return false; }
+  };
+
+  const cancelRun = async (id: string) => {
+    try {
+      const res = await fetch(`/api/prompt-jobs/${id}/cancel`, { method: 'POST' });
+      if (res.ok) { await refresh(); return true; }
+      return false;
+    } catch { return false; }
+  };
+
+  const fetchRuns = async (jobId: string): Promise<PromptRun[]> => {
+    try {
+      const res = await fetch(`/api/prompt-jobs/${jobId}/runs`);
+      const data = await res.json();
+      return data.runs;
+    } catch { return []; }
+  };
+
+  return { jobs, loading, error, refresh, createJob, updateJob, deleteJob, toggleJob, runNow, cancelRun, fetchRuns };
+}
+```
+
+- [ ] **Step 2: Create the board component**
+
+Create `components/PromptJobBoard.tsx`:
+
+```tsx
+'use client';
+
+import { useState } from 'react';
+import { usePromptJobs } from '@/hooks/usePromptJobs';
+import type { PromptJob, PromptRun, PromptJobState } from '@/src/prompt-scheduler/types';
+import { Play, Pause, Trash2, Plus, X, Clock, Terminal, RefreshCw } from 'lucide-react';
+
+type FilterState = 'all' | PromptJobState;
+
+export default function PromptJobBoard() {
+  const { jobs, loading, error, createJob, deleteJob, toggleJob, runNow, cancelRun, fetchRuns, refresh } = usePromptJobs();
+  const [filter, setFilter] = useState<FilterState>('all');
+  const [showCreate, setShowCreate] = useState(false);
+  const [selectedJobId, setSelectedJobId] = useState<string | null>(null);
+  const [runs, setRuns] = useState<PromptRun[]>([]);
+  const [busy, setBusy] = useState<Set<string>>(new Set());
+
+  const filtered = filter === 'all' ? jobs : jobs.filter(j => j.state === filter);
+  const counts = {
+    all: jobs.length,
+    active: jobs.filter(j => j.state === 'active').length,
+    paused: jobs.filter(j => j.state === 'paused').length,
+    stopped: jobs.filter(j => j.state === 'stopped').length,
+  };
+
+  const selectJob = async (id: string) => {
+    setSelectedJobId(id);
+    const r = await fetchRuns(id);
+    setRuns(r);
+  };
+
+  const withBusy = async (id: string, fn: () => Promise<unknown>) => {
+    setBusy(prev => new Set(prev).add(id));
+    try { await fn(); } finally {
+      setBusy(prev => { const next = new Set(prev); next.delete(id); return next; });
+    }
+  };
+
+  if (loading) return <div className="p-8 text-[var(--muted-foreground)]">Loading...</div>;
+
+  return (
+    <div className="flex h-full">
+      {/* Main panel */}
+      <div className="flex-1 p-6 overflow-auto">
+        <div className="flex items-center justify-between mb-6">
+          <h1 className="text-xl font-semibold text-[var(--foreground)]">Prompt Scheduler</h1>
+          <div className="flex gap-2">
+            <button onClick={refresh} className="p-2 rounded hover:bg-[var(--card-bg)]">
+              <RefreshCw size={16} className="text-[var(--muted-foreground)]" />
+            </button>
+            <button onClick={() => setShowCreate(true)} className="flex items-center gap-1.5 px-3 py-1.5 rounded bg-[var(--primary)] text-white text-sm">
+              <Plus size={14} /> New Job
+            </button>
+          </div>
+        </div>
+
+        {error && <div className="mb-4 p-3 rounded bg-red-500/10 text-red-400 text-sm">{error}</div>}
+
+        {/* Filter pills */}
+        <div className="flex gap-2 mb-4">
+          {(['all', 'active', 'paused', 'stopped'] as FilterState[]).map(f => (
+            <button
+              key={f}
+              onClick={() => setFilter(f)}
+              className={`px-3 py-1 rounded-full text-xs font-medium ${filter === f ? 'bg-[var(--primary)] text-white' : 'bg-[var(--card-bg)] text-[var(--muted-foreground)]'}`}
+            >
+              {f} ({counts[f]})
+            </button>
+          ))}
+        </div>
+
+        {/* Job cards */}
+        <div className="grid grid-cols-1 lg:grid-cols-2 gap-3">
+          {filtered.map(job => (
+            <div
+              key={job.id}
+              onClick={() => selectJob(job.id)}
+              className={`p-4 rounded-lg border cursor-pointer transition-colors ${selectedJobId === job.id ? 'border-[var(--primary)] bg-[var(--primary)]/5' : 'border-[var(--card-border)] bg-[var(--card-bg)] hover:border-[var(--muted-foreground)]/30'}`}
+            >
+              <div className="flex items-start justify-between mb-2">
+                <div>
+                  <h3 className="font-medium text-sm text-[var(--foreground)]">{job.name}</h3>
+                  <p className="text-xs text-[var(--muted-foreground)] mt-0.5">{job.cadence || job.cronExpr}</p>
+                </div>
+                <div className="flex items-center gap-1">
+                  <span className={`px-2 py-0.5 rounded text-xs font-medium ${
+                    job.state === 'active' ? 'bg-green-500/10 text-green-400' :
+                    job.state === 'paused' ? 'bg-yellow-500/10 text-yellow-400' :
+                    'bg-gray-500/10 text-gray-400'
+                  }`}>
+                    {job.state}
+                  </span>
+                </div>
+              </div>
+
+              <p className="text-xs text-[var(--muted-foreground)] truncate mb-3">{job.prompt}</p>
+
+              <div className="flex items-center justify-between">
+                <div className="flex items-center gap-2 text-xs text-[var(--muted-foreground)]">
+                  <Terminal size={12} />
+                  <span>{job.cli}</span>
+                  {job.nextRunAt && (
+                    <>
+                      <Clock size={12} className="ml-2" />
+                      <span>{formatNextRun(job.nextRunAt)}</span>
+                    </>
+                  )}
+                </div>
+                <div className="flex gap-1">
+                  <button
+                    onClick={(e) => { e.stopPropagation(); withBusy(job.id, () => runNow(job.id)); }}
+                    disabled={busy.has(job.id)}
+                    className="p-1.5 rounded hover:bg-[var(--background)]"
+                    title="Run now"
+                  >
+                    <Play size={14} className="text-green-400" />
+                  </button>
+                  <button
+                    onClick={(e) => { e.stopPropagation(); withBusy(job.id, () => toggleJob(job)); }}
+                    disabled={busy.has(job.id)}
+                    className="p-1.5 rounded hover:bg-[var(--background)]"
+                    title={job.state === 'active' ? 'Pause' : 'Resume'}
+                  >
+                    <Pause size={14} className="text-yellow-400" />
+                  </button>
+                  <button
+                    onClick={(e) => { e.stopPropagation(); if (confirm('Delete this job?')) withBusy(job.id, () => deleteJob(job.id)); }}
+                    disabled={busy.has(job.id)}
+                    className="p-1.5 rounded hover:bg-[var(--background)]"
+                    title="Delete"
+                  >
+                    <Trash2 size={14} className="text-red-400" />
+                  </button>
+                </div>
+              </div>
+            </div>
+          ))}
+        </div>
+
+        {filtered.length === 0 && (
+          <div className="text-center py-12 text-[var(--muted-foreground)]">
+            {jobs.length === 0 ? 'No jobs yet. Create one to get started.' : 'No jobs match this filter.'}
+          </div>
+        )}
+      </div>
+
+      {/* Inspector panel */}
+      {selectedJobId && (
+        <InspectorPanel
+          job={jobs.find(j => j.id === selectedJobId)!}
+          runs={runs}
+          onClose={() => setSelectedJobId(null)}
+          onCancel={() => withBusy(selectedJobId, () => cancelRun(selectedJobId))}
+        />
+      )}
+
+      {/* Create modal */}
+      {showCreate && (
+        <CreateJobModal
+          onClose={() => setShowCreate(false)}
+          onCreate={async (input) => {
+            const job = await createJob(input);
+            if (job) setShowCreate(false);
+          }}
+        />
+      )}
+    </div>
+  );
+}
+
+function InspectorPanel({ job, runs, onClose, onCancel }: {
+  job: PromptJob;
+  runs: PromptRun[];
+  onClose: () => void;
+  onCancel: () => void;
+}) {
+  const activeRun = runs.find(r => r.status === 'running' || r.status === 'queued');
+
+  return (
+    <div className="w-80 border-l border-[var(--card-border)] bg-[var(--card-bg)] p-4 overflow-auto">
+      <div className="flex items-center justify-between mb-4">
+        <h2 className="font-medium text-sm text-[var(--foreground)]">{job.name}</h2>
+        <button onClick={onClose} className="p-1 rounded hover:bg-[var(--background)]">
+          <X size={14} className="text-[var(--muted-foreground)]" />
+        </button>
+      </div>
+
+      <div className="space-y-3 text-xs mb-4">
+        <div><span className="text-[var(--muted-foreground)]">CLI:</span> <span className="text-[var(--foreground)]">{job.cli}</span></div>
+        <div><span className="text-[var(--muted-foreground)]">Schedule:</span> <span className="text-[var(--foreground)]">{job.cadence || job.cronExpr}</span></div>
+        <div><span className="text-[var(--muted-foreground)]">Overlap:</span> <span className="text-[var(--foreground)]">{job.overlapPolicy}</span></div>
+        <div><span className="text-[var(--muted-foreground)]">Last outcome:</span> <span className="text-[var(--foreground)]">{job.lastOutcome ?? 'never run'}</span></div>
+      </div>
+
+      <div className="mb-3">
+        <h3 className="text-xs font-medium text-[var(--muted-foreground)] mb-1">Prompt</h3>
+        <pre className="text-xs bg-[var(--background)] p-2 rounded whitespace-pre-wrap text-[var(--foreground)]">{job.prompt}</pre>
+      </div>
+
+      {activeRun && (
+        <button onClick={onCancel} className="w-full mb-4 px-3 py-1.5 rounded bg-red-500/10 text-red-400 text-xs font-medium hover:bg-red-500/20">
+          Cancel Running
+        </button>
+      )}
+
+      <h3 className="text-xs font-medium text-[var(--muted-foreground)] mb-2">Recent Runs</h3>
+      <div className="space-y-2">
+        {runs.slice(0, 10).map(run => (
+          <div key={run.id} className="p-2 rounded bg-[var(--background)] text-xs">
+            <div className="flex justify-between mb-1">
+              <span className={`font-medium ${
+                run.status === 'success' ? 'text-green-400' :
+                run.status === 'failed' ? 'text-red-400' :
+                run.status === 'cancelled' ? 'text-yellow-400' :
+                run.status === 'running' ? 'text-blue-400' :
+                'text-[var(--muted-foreground)]'
+              }`}>{run.status}</span>
+              {run.durationMs != null && <span className="text-[var(--muted-foreground)]">{(run.durationMs / 1000).toFixed(1)}s</span>}
+            </div>
+            {run.output && <pre className="text-[var(--muted-foreground)] whitespace-pre-wrap truncate max-h-16 overflow-hidden">{run.output.slice(0, 200)}</pre>}
+            {run.error && <pre className="text-red-400 whitespace-pre-wrap truncate max-h-16 overflow-hidden">{run.error.slice(0, 200)}</pre>}
+          </div>
+        ))}
+        {runs.length === 0 && <div className="text-[var(--muted-foreground)]">No runs yet</div>}
+      </div>
+    </div>
+  );
+}
+
+function CreateJobModal({ onClose, onCreate }: {
+  onClose: () => void;
+  onCreate: (input: { name: string; prompt: string; cli: string; cadence: string }) => Promise<void>;
+}) {
+  const [name, setName] = useState('');
+  const [prompt, setPrompt] = useState('');
+  const [cli, setCli] = useState('claude');
+  const [cadence, setCadence] = useState('');
+  const [submitting, setSubmitting] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setSubmitting(true);
+    await onCreate({ name, prompt, cli, cadence });
+    setSubmitting(false);
+  };
+
+  return (
+    <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50" onClick={onClose}>
+      <form
+        onClick={e => e.stopPropagation()}
+        onSubmit={handleSubmit}
+        className="bg-[var(--card-bg)] border border-[var(--card-border)] rounded-lg p-6 w-[480px] max-h-[80vh] overflow-auto"
+      >
+        <h2 className="text-lg font-semibold text-[var(--foreground)] mb-4">New Prompt Job</h2>
+
+        <label className="block mb-3">
+          <span className="text-xs text-[var(--muted-foreground)]">Name</span>
+          <input value={name} onChange={e => setName(e.target.value)} required
+            className="mt-1 w-full px-3 py-2 rounded bg-[var(--background)] border border-[var(--card-border)] text-sm text-[var(--foreground)]"
+            placeholder="Daily inbox summary" />
+        </label>
+
+        <label className="block mb-3">
+          <span className="text-xs text-[var(--muted-foreground)]">Prompt</span>
+          <textarea value={prompt} onChange={e => setPrompt(e.target.value)} required rows={4}
+            className="mt-1 w-full px-3 py-2 rounded bg-[var(--background)] border border-[var(--card-border)] text-sm text-[var(--foreground)]"
+            placeholder="Summarize my unread emails from the last 24 hours" />
+        </label>
+
+        <label className="block mb-3">
+          <span className="text-xs text-[var(--muted-foreground)]">CLI</span>
+          <select value={cli} onChange={e => setCli(e.target.value)}
+            className="mt-1 w-full px-3 py-2 rounded bg-[var(--background)] border border-[var(--card-border)] text-sm text-[var(--foreground)]">
+            <option value="claude">claude</option>
+            <option value="codex">codex</option>
+            <option value="gemini">gemini</option>
+          </select>
+        </label>
+
+        <label className="block mb-4">
+          <span className="text-xs text-[var(--muted-foreground)]">Schedule</span>
+          <input value={cadence} onChange={e => setCadence(e.target.value)} required
+            className="mt-1 w-full px-3 py-2 rounded bg-[var(--background)] border border-[var(--card-border)] text-sm text-[var(--foreground)]"
+            placeholder="daily at 9am, every 2 hours, 0 */6 * * *" />
+        </label>
+
+        <div className="flex justify-end gap-2">
+          <button type="button" onClick={onClose} className="px-4 py-2 rounded text-sm text-[var(--muted-foreground)] hover:bg-[var(--background)]">
+            Cancel
+          </button>
+          <button type="submit" disabled={submitting} className="px-4 py-2 rounded bg-[var(--primary)] text-white text-sm disabled:opacity-50">
+            {submitting ? 'Creating...' : 'Create'}
+          </button>
+        </div>
+      </form>
+    </div>
+  );
+}
+
+function formatNextRun(epochMs: number): string {
+  const diff = epochMs - Date.now();
+  if (diff < 0) return 'overdue';
+  if (diff < 60_000) return 'in <1m';
+  if (diff < 3_600_000) return `in ${Math.round(diff / 60_000)}m`;
+  if (diff < 86_400_000) return `in ${Math.round(diff / 3_600_000)}h`;
+  return `in ${Math.round(diff / 86_400_000)}d`;
+}
+```
+
+- [ ] **Step 3: Update the automations page to use new board**
+
+Modify `app/automations/page.tsx` — replace the import:
+
+```typescript
+// Replace:
+import AutomationsBoard from '@/components/AutomationsBoard';
+// With:
+import PromptJobBoard from '@/components/PromptJobBoard';
+```
+
+And replace the JSX:
+
+```tsx
+// Replace:
+<AutomationsBoard />
+// With:
+<PromptJobBoard />
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add components/PromptJobBoard.tsx hooks/usePromptJobs.ts app/automations/page.tsx
+git commit -m "feat: add PromptJobBoard UI replacing AutomationsBoard"
+```
+
+---
+
+## Task 8: Integration — wire up migration and smoke test
+
+**Files:**
+- Modify: `app/automations/page.tsx` (verify)
+
+- [ ] **Step 1: Run the schema migration manually to verify**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && sqlite3 agx-board.db < db/sqlite/002_prompt_scheduler_schema.sql
+```
+
+Expected: No errors. Tables `prompt_jobs` and `prompt_runs` created.
+
+- [ ] **Step 2: Start the dev server**
+
+```bash
+cd /Users/mendrika/Projects/Agents/agx-cloud && npm run dev
+```
+
+- [ ] **Step 3: Smoke test via curl**
+
+Create a job:
+```bash
+curl -X POST http://localhost:3000/api/prompt-jobs \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"Test Job","prompt":"Say hello","cli":"echo","cadence":"every hour"}'
+```
+Expected: 201 with JSON containing the created job.
+
+List jobs:
+```bash
+curl http://localhost:3000/api/prompt-jobs
+```
+Expected: 200 with `{ count: 1, jobs: [...] }`.
+
+Poll (run now):
+```bash
+curl -X POST http://localhost:3000/api/prompt-jobs/poll \
+  -H 'Content-Type: application/json' \
+  -d '{"jobId":"<id from create>"}'
+```
+Expected: 200 with queued run.
+
+Check runs:
+```bash
+curl http://localhost:3000/api/prompt-jobs/<id>/runs
+```
+Expected: 200 with run entries showing status progression.
+
+- [ ] **Step 4: Open browser and verify UI**
+
+Navigate to `http://localhost:3000/automations`:
+- Verify the PromptJobBoard renders
+- Verify the test job appears
+- Click "New Job" and create a job via the form
+- Click "Run now" on a job and verify run appears in inspector
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add -A
+git commit -m "feat: prompt scheduler integration — migration, smoke test passing"
+```