@mndrk/agx 2.0.41 → 2.0.44

package/cloud-runtime/standalone/src/prompt-scheduler/store.ts

@@ -1,16 +1,26 @@
-import { randomUUID } from 'crypto';
-import type { DatabaseSync, SQLInputValue } from 'node:sqlite';
-import { computeNextTickFromCron } from '../graph/scheduler';
+import { randomUUID } from "crypto";
+import type { DatabaseSync, SQLInputValue } from "node:sqlite";
+
+import {
+  automationRecordToPromptJob,
+  getAutomationRepository,
+  isAutomationDualReadEnabled,
+  isAutomationFrontmatterEnabled,
+  promptJobToAutomationDefinition,
+  promptJobToAutomationRuntimeState,
+  type AutomationRecord,
+  type AutomationStatePatch,
+  type AutomationUpdatePatch,
+} from "@/src/automations";
+import { computeNextTickFromCron } from "../graph/scheduler";
 import type {
+  CreatePromptJobInput,
   PromptJob,
-  PromptRun,
   PromptJobState,
+  PromptRun,
   RunStatus,
-  CreatePromptJobInput,
   UpdatePromptJobInput,
-} from './types';
-
-// ── Row shapes from SQLite ────────────────────────────────────────────────────
+} from "./types";
 
 interface PromptJobRow {
   id: string;
@@ -51,26 +61,24 @@ interface PromptRunRow {
   created_at: string;
 }
 
-// ── Field mappers ─────────────────────────────────────────────────────────────
-
 function rowToJob(row: PromptJobRow): PromptJob {
   return {
     id: row.id,
     name: row.name,
     prompt: row.prompt,
-    agentId: row.agent_id || '',
-    projectId: row.project_id || '',
-    provider: row.provider || row.cli || 'claude',
-    model: row.model || '',
-    cliArgs: row.cli_args || '',
+    agentId: row.agent_id || "",
+    projectId: row.project_id || "",
+    provider: row.provider || row.cli || "claude",
+    model: row.model || "",
+    cliArgs: row.cli_args || "",
     cronExpr: row.cron_expr,
     cadence: row.cadence,
     state: row.state as PromptJobState,
-    overlapPolicy: row.overlap_policy as PromptJob['overlapPolicy'],
-    catchUpPolicy: (row.catch_up_policy || 'fire_once') as PromptJob['catchUpPolicy'],
+    overlapPolicy: row.overlap_policy as PromptJob["overlapPolicy"],
+    catchUpPolicy: (row.catch_up_policy || "fire_once") as PromptJob["catchUpPolicy"],
     cancelCheckSec: row.cancel_check_sec,
-    triggerType: (row.trigger_type || 'scheduled') as PromptJob['triggerType'],
-    condition: row.condition || '',
+    triggerType: (row.trigger_type || "scheduled") as PromptJob["triggerType"],
+    condition: row.condition || "",
     checkEveryMs: row.check_every_ms || 300000,
     nextRunAt: row.next_run_at,
     lastRunAt: row.last_run_at,
@@ -95,24 +103,451 @@ function rowToRun(row: PromptRunRow): PromptRun {
   };
 }
 
-// ── Store ─────────────────────────────────────────────────────────────────────
+function sortJobsByCreatedAt(jobs: PromptJob[]): PromptJob[] {
+  return [...jobs].sort((left, right) => {
+    const leftTime = Date.parse(left.createdAt);
+    const rightTime = Date.parse(right.createdAt);
+    return rightTime - leftTime;
+  });
+}
+
+function hasAnyValue(values: Record<string, unknown>): boolean {
+  return Object.values(values).some((value) => value !== undefined);
+}
 
 export class PromptJobStore {
-  constructor(private readonly db: DatabaseSync) {}
+  private automationRepository?: ReturnType<typeof getAutomationRepository>;
 
-  // ── Job operations ──────────────────────────────────────────────────────────
+  constructor(
+    private readonly db: DatabaseSync,
+    automationRepository?: ReturnType<typeof getAutomationRepository>,
+  ) {
+    this.automationRepository = automationRepository;
+  }
+
+  private getAutomationRepo() {
+    this.automationRepository ??= getAutomationRepository();
+    return this.automationRepository;
+  }
 
   createJob(input: CreatePromptJobInput): PromptJob {
+    if (!isAutomationFrontmatterEnabled()) {
+      return this.createLegacyJob(input);
+    }
+
+    const id = randomUUID();
+    const createdAt = new Date().toISOString();
+    const record = this.getAutomationRepo().createAutomation({
+      id,
+      name: input.name,
+      ...(input.projectId ? { projectId: input.projectId } : {}),
+      state: "active",
+      trigger: (input.triggerType ?? "scheduled") === "condition"
+        ? {
+          type: "condition",
+          condition: input.condition ?? "",
+          checkEveryMs: input.checkEveryMs ?? 300000,
+        }
+        : {
+          type: "scheduled",
+          ...(input.cadence ? { cadence: input.cadence } : {}),
+          ...(input.cronExpr ? { cronExpr: input.cronExpr } : {}),
+        },
+      execution: {
+        overlapPolicy: input.overlapPolicy,
+        catchUpPolicy: input.catchUpPolicy,
+        cancelCheckSec: input.cancelCheckSec,
+      },
+      target: {
+        type: "prompt_job",
+        ...(input.agentId ? { agentId: input.agentId } : {}),
+        ...(input.provider ? { provider: input.provider } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.cliArgs !== undefined ? { cliArgs: input.cliArgs } : {}),
+      },
+      createdAt,
+      body: input.prompt,
+    });
+
+    const job = automationRecordToPromptJob(record);
+    this.upsertLegacyJobRow(job);
+    return job;
+  }
+
+  getJob(id: string): PromptJob | null {
+    if (!isAutomationFrontmatterEnabled()) {
+      return this.getLegacyJob(id);
+    }
+
+    const record = this.getAutomationRepo().getAutomation(id);
+    if (record?.definition.target.type === "prompt_job") {
+      const job = automationRecordToPromptJob(record);
+      this.ensureLegacyJobRow(job);
+      return job;
+    }
+
+    return isAutomationDualReadEnabled() ? this.getLegacyJob(id) : null;
+  }
+
+  listJobs(filter?: { state?: PromptJobState; projectId?: string }): PromptJob[] {
+    if (!isAutomationFrontmatterEnabled()) {
+      return this.listLegacyJobs(filter);
+    }
+
+    const jobsById = new Map<string, PromptJob>();
+    for (const record of this.getAutomationRepo().listVisibleAutomations({
+      targetType: "prompt_job",
+      ...(filter?.state ? { state: filter.state } : {}),
+      ...(filter?.projectId ? { projectId: filter.projectId } : {}),
+    })) {
+      const job = automationRecordToPromptJob(record);
+      jobsById.set(job.id, job);
+      this.ensureLegacyJobRow(job);
+    }
+
+    if (isAutomationDualReadEnabled()) {
+      for (const job of this.listLegacyJobs(filter)) {
+        if (!jobsById.has(job.id)) {
+          jobsById.set(job.id, job);
+        }
+      }
+    }
+
+    return sortJobsByCreatedAt([...jobsById.values()]);
+  }
+
+  updateJob(id: string, updates: UpdatePromptJobInput): PromptJob | null {
+    if (!isAutomationFrontmatterEnabled()) {
+      return this.updateLegacyJob(id, updates);
+    }
+
+    let record = this.getPromptJobRecord(id, true);
+    if (!record) {
+      return null;
+    }
+
+    const definitionPatch = this.buildDefinitionPatch(record, updates);
+    if (hasAnyValue(definitionPatch as Record<string, unknown>)) {
+      const updatedRecord = this.getAutomationRepo().updateAutomation(id, definitionPatch);
+      if (!updatedRecord) {
+        return null;
+      }
+      record = updatedRecord;
+    }
+
+    const statePatch = this.buildStatePatch(updates);
+    if (hasAnyValue(statePatch as Record<string, unknown>)) {
+      const updatedStateRecord = this.getAutomationRepo().updateAutomationState(id, statePatch);
+      if (!updatedStateRecord) {
+        return null;
+      }
+      record = updatedStateRecord;
+    }
+
+    const job = automationRecordToPromptJob(record);
+    this.upsertLegacyJobRow(job);
+    return job;
+  }
+
+  deleteJob(id: string): void {
+    if (isAutomationFrontmatterEnabled()) {
+      this.getAutomationRepo().deleteAutomation(id);
+    }
+    this.db.prepare("DELETE FROM prompt_jobs WHERE id = ?").run(id);
+  }
+
+  getDueJobs(now: number = Date.now()): PromptJob[] {
+    if (!isAutomationFrontmatterEnabled()) {
+      return this.getLegacyDueJobs(now);
+    }
+
+    const jobsById = new Map<string, PromptJob>();
+    for (const record of this.getAutomationRepo().listDueAutomations(now, {
+      targetType: "prompt_job",
+    })) {
+      const job = automationRecordToPromptJob(record);
+      jobsById.set(job.id, job);
+      this.ensureLegacyJobRow(job);
+    }
+
+    if (isAutomationDualReadEnabled()) {
+      for (const job of this.getLegacyDueJobs(now)) {
+        if (!jobsById.has(job.id)) {
+          jobsById.set(job.id, job);
+        }
+      }
+    }
+
+    return [...jobsById.values()].sort((left, right) => {
+      const leftNext = left.nextRunAt ?? Number.MAX_SAFE_INTEGER;
+      const rightNext = right.nextRunAt ?? Number.MAX_SAFE_INTEGER;
+      return leftNext - rightNext;
+    });
+  }
+
+  createRun(jobId: string): PromptRun {
+    this.ensureLegacyJobRowById(jobId);
+    const id = randomUUID();
+    this.db
+      .prepare("INSERT INTO prompt_runs (id, job_id) VALUES (?, ?)")
+      .run(id, jobId);
+    return this.getRun(id) as PromptRun;
+  }
+
+  getRun(id: string): PromptRun | null {
+    const row = this.db
+      .prepare("SELECT * FROM prompt_runs WHERE id = ?")
+      .get(id) as PromptRunRow | undefined;
+    return row ? rowToRun(row) : null;
+  }
+
+  listRuns(jobId: string, limit = 50): PromptRun[] {
+    const rows = this.db
+      .prepare("SELECT * FROM prompt_runs WHERE job_id = ? ORDER BY created_at DESC LIMIT ?")
+      .all(jobId, limit) as unknown as PromptRunRow[];
+    return rows.map(rowToRun);
+  }
+
+  updateRun(id: string, updates: Partial<Omit<PromptRun, "id" | "jobId" | "createdAt">>): PromptRun | null {
+    const fieldMap: Record<string, string> = {
+      status: "status",
+      output: "output",
+      error: "error",
+      durationMs: "duration_ms",
+      startedAt: "started_at",
+      finishedAt: "finished_at",
+      cancelledAt: "cancelled_at",
+    };
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    for (const [key, value] of Object.entries(updates)) {
+      const column = fieldMap[key];
+      if (!column) {
+        continue;
+      }
+      setClauses.push(`${column} = ?`);
+      values.push(value ?? null);
+    }
+
+    if (setClauses.length === 0) {
+      return this.getRun(id);
+    }
+
+    values.push(id);
+    this.db
+      .prepare(`UPDATE prompt_runs SET ${setClauses.join(", ")} WHERE id = ?`)
+      .run(...values.map((value) => value as SQLInputValue));
+
+    return this.getRun(id);
+  }
+
+  hasRunningRun(jobId: string): boolean {
+    const row = this.db
+      .prepare("SELECT id FROM prompt_runs WHERE job_id = ? AND status IN ('queued', 'running') LIMIT 1")
+      .get(jobId);
+    return row !== undefined;
+  }
+
+  isRunCancelled(runId: string): boolean {
+    const row = this.db
+      .prepare("SELECT status FROM prompt_runs WHERE id = ?")
+      .get(runId) as { status: string } | undefined;
+    return row?.status === "cancelled";
+  }
+
+  private getPromptJobRecord(id: string, materializeLegacy: boolean): AutomationRecord | null {
+    const record = this.getAutomationRepo().getAutomation(id);
+    if (record?.definition.target.type === "prompt_job") {
+      return record;
+    }
+
+    if (!materializeLegacy || !isAutomationDualReadEnabled()) {
+      return null;
+    }
+
+    const legacyJob = this.getLegacyJob(id);
+    if (!legacyJob) {
+      return null;
+    }
+
+    return this.materializeLegacyJob(legacyJob);
+  }
+
+  private materializeLegacyJob(job: PromptJob): AutomationRecord {
+    const definition = promptJobToAutomationDefinition(job);
+    const runtimeState = promptJobToAutomationRuntimeState(job);
+    const record = this.getAutomationRepo().upsertAutomation(definition);
+    return this.getAutomationRepo().updateAutomationState(job.id, {
+      nextRunAt: runtimeState.nextRunAt,
+      lastRunAt: runtimeState.lastRunAt,
+      lastOutcome: runtimeState.lastOutcome,
+      lastError: runtimeState.lastError,
+      updatedAt: runtimeState.updatedAt,
+    }) ?? record;
+  }
+
+  private buildDefinitionPatch(
+    record: AutomationRecord,
+    updates: UpdatePromptJobInput,
+  ): AutomationUpdatePatch {
+    const patch: Record<string, unknown> = {};
+    const triggerPatch: Record<string, unknown> = {};
+    const executionPatch: Record<string, unknown> = {};
+    const targetPatch: Record<string, unknown> = {};
+
+    if (updates.name !== undefined) patch.name = updates.name;
+    if (updates.projectId !== undefined) patch.projectId = updates.projectId || null;
+    if (updates.state !== undefined) patch.state = updates.state;
+    if (updates.prompt !== undefined) patch.body = updates.prompt;
+
+    if (
+      updates.triggerType !== undefined
+      || updates.cadence !== undefined
+      || updates.cronExpr !== undefined
+      || updates.condition !== undefined
+      || updates.checkEveryMs !== undefined
+    ) {
+      const currentTrigger = record.definition.trigger;
+      const triggerType = updates.triggerType ?? currentTrigger.type;
+      triggerPatch.type = triggerType;
+
+      if (triggerType === "condition") {
+        triggerPatch.condition = updates.condition
+          ?? (currentTrigger.type === "condition" ? currentTrigger.condition : "");
+        triggerPatch.checkEveryMs = updates.checkEveryMs
+          ?? (currentTrigger.type === "condition" ? currentTrigger.checkEveryMs : 300000);
+      } else {
+        triggerPatch.cadence = updates.cadence === ""
+          ? undefined
+          : updates.cadence ?? (currentTrigger.type === "scheduled" ? currentTrigger.cadence : undefined);
+        triggerPatch.cronExpr = updates.cronExpr !== undefined
+          ? updates.cronExpr
+          : updates.cadence !== undefined && updates.cadence !== ""
+            ? undefined
+            : (currentTrigger.type === "scheduled" ? currentTrigger.cronExpr : undefined);
+        triggerPatch.intervalMs = currentTrigger.type === "scheduled" ? currentTrigger.intervalMs : undefined;
+      }
+    }
+
+    if (updates.overlapPolicy !== undefined) executionPatch.overlapPolicy = updates.overlapPolicy;
+    if (updates.catchUpPolicy !== undefined) executionPatch.catchUpPolicy = updates.catchUpPolicy;
+    if (updates.cancelCheckSec !== undefined) executionPatch.cancelCheckSec = updates.cancelCheckSec;
+
+    if (updates.agentId !== undefined) targetPatch.agentId = updates.agentId || undefined;
+    if (updates.provider !== undefined) targetPatch.provider = updates.provider || undefined;
+    if (updates.model !== undefined) targetPatch.model = updates.model || undefined;
+    if (updates.cliArgs !== undefined) targetPatch.cliArgs = updates.cliArgs;
+
+    return {
+      ...(Object.keys(patch).length > 0 ? patch : {}),
+      ...(Object.keys(triggerPatch).length > 0 ? { trigger: triggerPatch } : {}),
+      ...(Object.keys(executionPatch).length > 0 ? { execution: executionPatch } : {}),
+      ...(Object.keys(targetPatch).length > 0 ? { target: targetPatch } : {}),
+    };
+  }
+
+  private buildStatePatch(updates: UpdatePromptJobInput): AutomationStatePatch {
+    const patch: AutomationStatePatch = {};
+    if (updates.nextRunAt !== undefined) patch.nextRunAt = updates.nextRunAt;
+    if (updates.lastRunAt !== undefined) patch.lastRunAt = updates.lastRunAt;
+    if (updates.lastOutcome !== undefined) patch.lastOutcome = updates.lastOutcome;
+    return patch;
+  }
+
+  private ensureLegacyJobRowById(jobId: string): void {
+    if (this.legacyJobRowExists(jobId)) {
+      return;
+    }
+    const job = this.getJob(jobId);
+    if (job) {
+      this.upsertLegacyJobRow(job);
+    }
+  }
+
+  private ensureLegacyJobRow(job: PromptJob): void {
+    if (!this.legacyJobRowExists(job.id)) {
+      this.upsertLegacyJobRow(job);
+    }
+  }
+
+  private legacyJobRowExists(jobId: string): boolean {
+    const row = this.db
+      .prepare("SELECT 1 FROM prompt_jobs WHERE id = ?")
+      .get(jobId);
+    return row !== undefined;
+  }
+
+  private upsertLegacyJobRow(job: PromptJob): void {
+    this.db
+      .prepare(
+        `INSERT INTO prompt_jobs (
+          id, name, prompt, cli, agent_id, project_id, provider, model, cli_args,
+          cron_expr, cadence, state, overlap_policy, catch_up_policy, cancel_check_sec,
+          trigger_type, condition, check_every_ms, next_run_at, last_run_at, last_outcome,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT (id) DO UPDATE SET
+          name = excluded.name,
+          prompt = excluded.prompt,
+          cli = excluded.cli,
+          agent_id = excluded.agent_id,
+          project_id = excluded.project_id,
+          provider = excluded.provider,
+          model = excluded.model,
+          cli_args = excluded.cli_args,
+          cron_expr = excluded.cron_expr,
+          cadence = excluded.cadence,
+          state = excluded.state,
+          overlap_policy = excluded.overlap_policy,
+          catch_up_policy = excluded.catch_up_policy,
+          cancel_check_sec = excluded.cancel_check_sec,
+          trigger_type = excluded.trigger_type,
+          condition = excluded.condition,
+          check_every_ms = excluded.check_every_ms,
+          next_run_at = excluded.next_run_at,
+          last_run_at = excluded.last_run_at,
+          last_outcome = excluded.last_outcome,
+          created_at = excluded.created_at,
+          updated_at = excluded.updated_at`,
+      )
+      .run(
+        job.id,
+        job.name,
+        job.prompt,
+        job.provider || "claude",
+        job.agentId || null,
+        job.projectId || null,
+        job.provider || "claude",
+        job.model || "",
+        job.cliArgs || "",
+        job.cronExpr || "",
+        job.cadence || "",
+        job.state,
+        job.overlapPolicy,
+        job.catchUpPolicy,
+        job.cancelCheckSec,
+        job.triggerType,
+        job.condition || "",
+        job.checkEveryMs,
+        job.nextRunAt ?? null,
+        job.lastRunAt ?? null,
+        job.lastOutcome ?? null,
+        job.createdAt,
+        job.updatedAt,
+      );
+  }
+
+  private createLegacyJob(input: CreatePromptJobInput): PromptJob {
     const id = randomUUID();
     const cadence = input.cadence;
     const cronExpr = input.cronExpr || cadence;
-    const triggerType = input.triggerType ?? 'scheduled';
-    const provider = input.provider ?? 'claude';
+    const triggerType = input.triggerType ?? "scheduled";
+    const provider = input.provider ?? "claude";
 
-    // For condition triggers, nextRunAt is based on checkEveryMs from now
-    // For scheduled triggers, nextRunAt is the next cron tick
     let nextRunAt: number | null;
-    if (triggerType === 'condition') {
+    if (triggerType === "condition") {
       nextRunAt = Date.now() + (input.checkEveryMs ?? 300000);
     } else {
       nextRunAt = computeNextTickFromCron(cronExpr) ?? null;
@@ -120,8 +555,11 @@ export class PromptJobStore {
 
     this.db
       .prepare(
-        `INSERT INTO prompt_jobs (id, name, prompt, cli, agent_id, project_id, provider, model, cli_args, cron_expr, cadence, overlap_policy, catch_up_policy, cancel_check_sec, trigger_type, condition, check_every_ms, next_run_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        `INSERT INTO prompt_jobs (
+          id, name, prompt, cli, agent_id, project_id, provider, model, cli_args,
+          cron_expr, cadence, overlap_policy, catch_up_policy, cancel_check_sec,
+          trigger_type, condition, check_every_ms, next_run_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       )
       .run(
         id,
@@ -131,111 +569,110 @@ export class PromptJobStore {
         input.agentId || null,
         input.projectId || null,
         provider,
-        input.model ?? '',
-        input.cliArgs ?? '',
+        input.model ?? "",
+        input.cliArgs ?? "",
         cronExpr,
         cadence,
-        input.overlapPolicy ?? 'skip',
-        input.catchUpPolicy ?? 'fire_once',
+        input.overlapPolicy ?? "skip",
+        input.catchUpPolicy ?? "fire_once",
         input.cancelCheckSec ?? 5,
         triggerType,
-        input.condition ?? '',
+        input.condition ?? "",
         input.checkEveryMs ?? 300000,
         nextRunAt,
       );
 
-    return this.getJob(id) as PromptJob;
+    return this.getLegacyJob(id) as PromptJob;
   }
 
-  getJob(id: string): PromptJob | null {
+  private getLegacyJob(id: string): PromptJob | null {
     const row = this.db
-      .prepare('SELECT * FROM prompt_jobs WHERE id = ?')
-      .get(id) as unknown as PromptJobRow | undefined;
+      .prepare("SELECT * FROM prompt_jobs WHERE id = ?")
+      .get(id) as PromptJobRow | undefined;
     return row ? rowToJob(row) : null;
   }
 
-  listJobs(filter?: { state?: PromptJobState; projectId?: string }): PromptJob[] {
-    let sql = 'SELECT * FROM prompt_jobs';
+  private listLegacyJobs(filter?: { state?: PromptJobState; projectId?: string }): PromptJob[] {
+    let sql = "SELECT * FROM prompt_jobs";
     const conditions: string[] = [];
     const params: string[] = [];
+
     if (filter?.state) {
-      conditions.push('state = ?');
+      conditions.push("state = ?");
       params.push(filter.state);
     }
     if (filter?.projectId) {
-      conditions.push('project_id = ?');
+      conditions.push("project_id = ?");
       params.push(filter.projectId);
     }
-    if (conditions.length > 0) sql += ' WHERE ' + conditions.join(' AND ');
-    sql += ' ORDER BY created_at DESC';
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" AND ")}`;
+    }
+    sql += " ORDER BY created_at DESC";
+
     const rows = this.db.prepare(sql).all(...params) as unknown as PromptJobRow[];
     return rows.map(rowToJob);
   }
 
-  updateJob(id: string, updates: UpdatePromptJobInput): PromptJob | null {
+  private updateLegacyJob(id: string, updates: UpdatePromptJobInput): PromptJob | null {
     const fieldMap: Record<string, string> = {
-      name: 'name',
-      prompt: 'prompt',
-      cli: 'cli',
-      agentId: 'agent_id',
-      projectId: 'project_id',
-      provider: 'provider',
-      cronExpr: 'cron_expr',
-      model: 'model',
-      cliArgs: 'cli_args',
-      cadence: 'cadence',
-      state: 'state',
-      overlapPolicy: 'overlap_policy',
-      catchUpPolicy: 'catch_up_policy',
-      cancelCheckSec: 'cancel_check_sec',
-      triggerType: 'trigger_type',
-      condition: 'condition',
-      checkEveryMs: 'check_every_ms',
-      nextRunAt: 'next_run_at',
-      lastRunAt: 'last_run_at',
-      lastOutcome: 'last_outcome',
+      name: "name",
+      prompt: "prompt",
+      cli: "cli",
+      agentId: "agent_id",
+      projectId: "project_id",
+      provider: "provider",
+      cronExpr: "cron_expr",
+      model: "model",
+      cliArgs: "cli_args",
+      cadence: "cadence",
+      state: "state",
+      overlapPolicy: "overlap_policy",
+      catchUpPolicy: "catch_up_policy",
+      cancelCheckSec: "cancel_check_sec",
+      triggerType: "trigger_type",
+      condition: "condition",
+      checkEveryMs: "check_every_ms",
+      nextRunAt: "next_run_at",
+      lastRunAt: "last_run_at",
+      lastOutcome: "last_outcome",
     };
 
     const setClauses: string[] = [];
     const values: unknown[] = [];
 
     for (const [key, value] of Object.entries(updates)) {
-      const col = fieldMap[key];
-      if (!col || value === undefined) continue;
-      setClauses.push(`${col} = ?`);
+      const column = fieldMap[key];
+      if (!column || value === undefined) {
+        continue;
+      }
+
+      setClauses.push(`${column} = ?`);
       values.push(value);
 
-      // If cadence changed, also recompute cron_expr and next_run_at
-      if (key === 'cadence' && typeof value === 'string') {
-        setClauses.push('cron_expr = ?');
+      if (key === "cadence" && typeof value === "string" && updates.cronExpr === undefined) {
+        setClauses.push("cron_expr = ?");
         values.push(value);
-        const nextRunAt = computeNextTickFromCron(value) ?? null;
-        setClauses.push('next_run_at = ?');
-        values.push(nextRunAt);
+        setClauses.push("next_run_at = ?");
+        values.push(computeNextTickFromCron(value) ?? null);
       }
     }
 
     if (setClauses.length === 0) {
-      return this.getJob(id);
+      return this.getLegacyJob(id);
     }
 
     setClauses.push("updated_at = datetime('now')");
     values.push(id);
 
     this.db
-      .prepare(`UPDATE prompt_jobs SET ${setClauses.join(', ')} WHERE id = ?`)
-      .run(...values.map(v => v as SQLInputValue));
+      .prepare(`UPDATE prompt_jobs SET ${setClauses.join(", ")} WHERE id = ?`)
+      .run(...values.map((value) => value as SQLInputValue));
 
-    return this.getJob(id);
+    return this.getLegacyJob(id);
   }
 
-  deleteJob(id: string): void {
-    this.db.prepare('DELETE FROM prompt_jobs WHERE id = ?').run(id);
-  }
-
-  getDueJobs(now: number = Date.now()): PromptJob[] {
-    const nowSec = Math.floor(now / 1000);
-    // next_run_at is stored as epoch ms; compare directly
+  private getLegacyDueJobs(now: number): PromptJob[] {
     const rows = this.db
       .prepare(
         `SELECT * FROM prompt_jobs
@@ -247,81 +684,4 @@ export class PromptJobStore {
       .all(now) as unknown as PromptJobRow[];
     return rows.map(rowToJob);
   }
-
-  // ── Run operations ──────────────────────────────────────────────────────────
-
-  createRun(jobId: string): PromptRun {
-    const id = randomUUID();
-    this.db
-      .prepare(
-        `INSERT INTO prompt_runs (id, job_id) VALUES (?, ?)`,
-      )
-      .run(id, jobId);
-    return this.getRun(id) as PromptRun;
-  }
-
-  getRun(id: string): PromptRun | null {
-    const row = this.db
-      .prepare('SELECT * FROM prompt_runs WHERE id = ?')
-      .get(id) as unknown as PromptRunRow | undefined;
-    return row ? rowToRun(row) : null;
-  }
-
-  listRuns(jobId: string, limit = 50): PromptRun[] {
-    const rows = this.db
-      .prepare(
-        `SELECT * FROM prompt_runs WHERE job_id = ? ORDER BY created_at DESC LIMIT ?`,
-      )
-      .all(jobId, limit) as unknown as PromptRunRow[];
-    return rows.map(rowToRun);
-  }
-
-  updateRun(id: string, updates: Partial<Omit<PromptRun, 'id' | 'jobId' | 'createdAt'>>): PromptRun | null {
-    const fieldMap: Record<string, string> = {
-      status: 'status',
-      output: 'output',
-      error: 'error',
-      durationMs: 'duration_ms',
-      startedAt: 'started_at',
-      finishedAt: 'finished_at',
-      cancelledAt: 'cancelled_at',
-    };
-
-    const setClauses: string[] = [];
-    const values: unknown[] = [];
-
-    for (const [key, value] of Object.entries(updates)) {
-      const col = fieldMap[key];
-      if (!col) continue;
-      setClauses.push(`${col} = ?`);
-      values.push(value ?? null);
-    }
-
-    if (setClauses.length === 0) {
-      return this.getRun(id);
-    }
-
-    values.push(id);
-    this.db
-      .prepare(`UPDATE prompt_runs SET ${setClauses.join(', ')} WHERE id = ?`)
-      .run(...values.map(v => v as SQLInputValue));
-
-    return this.getRun(id);
-  }
-
-  hasRunningRun(jobId: string): boolean {
-    const row = this.db
-      .prepare(
-        `SELECT id FROM prompt_runs WHERE job_id = ? AND status IN ('queued', 'running') LIMIT 1`,
-      )
-      .get(jobId);
-    return row !== undefined;
-  }
-
-  isRunCancelled(runId: string): boolean {
-    const row = this.db
-      .prepare(`SELECT status FROM prompt_runs WHERE id = ?`)
-      .get(runId) as { status: string } | undefined;
-    return row?.status === 'cancelled';
-  }
 }