@toist/aja 0.7.1 → 0.8.0

package/src/pipeline.ts

@@ -1,605 +0,0 @@
-// 2121
-// Pipeline loader, in-memory store, and (legacy) sequential executor.
-//
-// Spec types and validation live in `@toist/spec`; this file is the
-// runner side: file watch, registry-aware validation, the executor, and the
-// public-spec serialization helper. Phase B replaces the sequential executor
-// with a discriminator-aware parallel dispatcher.
-
-import { readFileSync, readdirSync, watch } from "node:fs"
-import { basename, extname, join, resolve as resolvePath } from "node:path"
-import {
-  parseYaml,
-  validateSpec as specValidate,
-  resolveDisc,
-  YamlError,
-  type PipelineSpec,
-  type PipelineNode,
-  type ParsedNode,
-  type ValidateResult,
-  type SubRunOutcome,
-  type HitlSpec,
-  type ErrorReviewSpec,
-} from "@toist/spec"
-import { getKind, type ExecContext, type PlatformCtx } from "./kinds/index.ts"
-import { runtimeDb } from "./db-handles.ts"
-import { HitlSuspend, ErrorReviewSuspend, makeSuspend, createErrorReviewTask, persistNodeOutputs } from "./hitl.ts"
-
-export type { PipelineSpec, PipelineNode } from "@toist/spec"
-
-const SLUG_RE = /^[A-Za-z][\w-]*$/
-
-export interface StepResult {
-  id: string
-  kind: string
-  label: string
-  status: "complete" | "failed"
-  params?: Record<string, unknown>
-  input?:  Record<string, unknown>
-  output?: unknown
-  error?:  string
-  duration_ms: number
-}
-
-// ─── Validation (runner-aware: knows the kind registry) ──────────────────────
-
-/** Runner-side validation. Injects the live kind registry as the resolver
- *  so spec validation reports unknown kinds precisely AND enforces per-kind
- *  manifest shape (required params / inputs, no unknown keys). CLI tools
- *  that don't have the registry call `specValidate` directly with no resolver. */
-export function validateSpec(input: unknown): ValidateResult {
-  return specValidate(input, {
-    hasKind: (id) => !!getKind(id),
-    getKindManifest: (id) => {
-      const k = getKind(id)
-      if (!k) return undefined
-      const { run: _r, ...manifest } = k
-      return manifest
-    },
-  })
-}
-
-// ─── In-memory store ─────────────────────────────────────────────────────────
-
-const _pipelines: Map<string, PipelineSpec> = new Map()
-let _dir = "../pipelines"
-
-export function getPipelines(): PipelineSpec[] {
-  return [..._pipelines.values()].sort((a, b) => a.id.localeCompare(b.id))
-}
-
-export function getPipeline(id: string): PipelineSpec | undefined {
-  return _pipelines.get(id)
-}
-
-function loadFromFile(path: string): PipelineSpec | null {
-  let raw: string
-  try {
-    raw = readFileSync(path, "utf8")
-  } catch (err) {
-    console.warn(`[runner] failed to read ${path}: ${(err as Error).message}`)
-    return null
-  }
-
-  let parsed: unknown
-  try {
-    parsed = parseYaml(raw)
-  } catch (err) {
-    if (err instanceof YamlError) {
-      console.warn(`[runner] ${path}: ${err.message}`)
-    } else {
-      console.warn(`[runner] ${path}: YAML parse error: ${(err as Error).message}`)
-    }
-    return null
-  }
-
-  // Default id from filename stem when stem matches the slug pattern (§2).
-  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-    const stem = basename(path, extname(path))
-    if ((parsed as { id?: unknown }).id === undefined && SLUG_RE.test(stem)) {
-      ;(parsed as Record<string, unknown>).id = stem
-    }
-  }
-
-  const result = validateSpec(parsed)
-  if (!result.ok) {
-    console.warn(`[runner] ${path}: validation failed`)
-    for (const e of result.errors) console.warn(`  - ${e}`)
-    return null
-  }
-  for (const w of result.warnings ?? []) {
-    console.warn(`[runner] ${path}: warning: ${w}`)
-  }
-
-  result.parsed!._source = path
-  return result.parsed!
-}
-
-export function loadAll(dir = _dir): Map<string, PipelineSpec> {
-  _dir = dir
-  _pipelines.clear()
-  let entries: string[] = []
-  try {
-    entries = readdirSync(dir).filter((f) => /\.ya?ml$/.test(f))
-  } catch {
-    console.warn(`[runner] pipelines dir not found: ${dir}`)
-    return _pipelines
-  }
-  for (const f of entries) {
-    const spec = loadFromFile(join(dir, f))
-    if (spec) _pipelines.set(spec.id, spec)
-  }
-  console.log(`[runner] loaded ${_pipelines.size} pipeline(s) from ${resolvePath(dir)}`)
-  return _pipelines
-}
-
-export function watchAll(dir = _dir, onChange?: (id: string, action: "load" | "remove") => void) {
-  watch(dir, { persistent: true }, (_event, filename) => {
-    if (!filename || !/\.ya?ml$/.test(filename)) return
-    const path = join(dir, filename)
-    const spec = loadFromFile(path)
-    if (spec) {
-      _pipelines.set(spec.id, spec)
-      console.log(`[runner] reloaded pipeline "${spec.id}" (${spec.nodes.length} nodes)`)
-      onChange?.(spec.id, "load")
-    } else {
-      // file may have been deleted or invalid; try to find by source path.
-      for (const [id, p] of _pipelines) {
-        if (p._source === path) {
-          _pipelines.delete(id)
-          console.log(`[runner] removed pipeline "${id}"`)
-          onChange?.(id, "remove")
-          break
-        }
-      }
-    }
-  })
-}
-
-/** Strip non-serializable fields (parsed trees, ajv validator) from a spec
- *  before sending to HTTP clients. `edges` are returned as a flat
- *  { from, to } list since clients expect that shape. */
-export function publicSpec(spec: PipelineSpec): Record<string, unknown> {
-  return {
-    apiVersion: spec.apiVersion,
-    id: spec.id,
-    label: spec.label,
-    description: spec.description,
-    schedule: spec.schedule,
-    payloadSchema: spec.payloadSchema,
-    nodes: spec.nodes,
-    edges: spec.edges.map(({ from, to }) => ({ from, to })),
-    warnings: spec.warnings,
-  }
-}
-
-/** Backwards-compatible deps map keyed by node id. Computed from
- *  parsedNodes.refs ∪ dependsOn. */
-export function deriveDeps(spec: PipelineSpec): Map<string, Set<string>> {
-  const out = new Map<string, Set<string>>()
-  for (const node of spec.parsedNodes) {
-    const deps = new Set<string>([...node.refs, ...node.dependsOn])
-    out.set(node.id, deps)
-  }
-  return out
-}
-
-// ─── Execution — parallel dispatcher (pipeline-spec v1 §11) ──────────────────
-
-/** Suspension provenance — distinguishes HITL pauses from error_review
- *  suspends. The shape carries the same fields either way (prompt + assignee
- *  appear on both spec types); kind drives UI presentation and resume payload
- *  semantics. */
-export type SuspendCause =
-  | { kind: "human.input";  spec: HitlSpec }
-  | { kind: "error_review"; spec: ErrorReviewSpec }
-
-export type RunOutcome =
-  | { status: "done";      output: unknown; steps: StepResult[]; results: Record<string, unknown> }
-  | { status: "suspended"; suspendedAt: { taskId: number; nodeId: string; cause: SuspendCause }
-                           steps: StepResult[]; results: Record<string, unknown> }
-
-export interface RunOptions {
-  /** Pre-computed node outputs from a previous (suspended) run. Nodes whose
-   *  id appears here are skipped — their output is treated as already-known.
-   *  Used for resume after HITL response. */
-  resumeOutputs?: Record<string, unknown>
-}
-
-export type RunResult = Extract<RunOutcome, { status: "done" }>
-
-interface NodeOutcome {
-  params: Record<string, unknown>
-  input: Record<string, unknown>
-  durationMs: number
-  result:
-    | { kind: "complete"; output: unknown }
-    | { kind: "suspend"; taskId: number; nodeId: string; cause: SuspendCause }
-    | { kind: "error"; error: Error }
-}
-
-export async function runPipeline(
-  spec: PipelineSpec,
-  payload: Record<string, unknown>,
-  baseCtx: PlatformCtx,
-  options: RunOptions = {},
-): Promise<RunOutcome> {
-  // Run-time payload validation (pipeline-spec §10).
-  if (spec.payloadValidator && !spec.payloadValidator(payload)) {
-    const errs = (spec.payloadValidator.errors ?? [])
-      .map((e) => `${e.instancePath || "/"} ${e.message}`)
-      .join("; ")
-    throw new Error(`payload schema violation: ${errs}`)
-  }
-
-  const nodes = spec.parsedNodes
-  const byId = new Map(nodes.map((n) => [n.id, n]))
-
-  // Build dep maps from spec.edges.
-  const incoming = new Map<string, Set<string>>()
-  const outgoing = new Map<string, Set<string>>()
-  for (const n of nodes) { incoming.set(n.id, new Set()); outgoing.set(n.id, new Set()) }
-  for (const e of spec.edges) {
-    incoming.get(e.to)!.add(e.from)
-    outgoing.get(e.from)!.add(e.to)
-  }
-
-  const results: Record<string, unknown> = { ...(options.resumeOutputs ?? {}) }
-  const steps: StepResult[] = []
-  const done = new Set<string>(Object.keys(options.resumeOutputs ?? {}))
-
-  // Synthesise step entries for resumed nodes so the timeline is complete.
-  for (const id of done) {
-    const node = byId.get(id)
-    if (!node) continue
-    const kind = getKind(node.kind)
-    steps.push({
-      id, kind: node.kind, label: node.label ?? kind?.label ?? id,
-      status: "complete", output: results[id], duration_ms: 0,
-    })
-  }
-
-  // Branch-level suspend tracking. A node is blocked if any of its transitive
-  // ancestors suspended; sibling branches whose ancestors are all done can
-  // still run.
-  const blocked = new Set<string>()
-  const propagateBlock = (id: string) => {
-    if (blocked.has(id)) return
-    blocked.add(id)
-    for (const next of outgoing.get(id) ?? []) propagateBlock(next)
-  }
-
-  // Initial ready set: any unblocked, undone node whose deps are all done.
-  const ready: string[] = []
-  const enqueueIfReady = (id: string) => {
-    if (done.has(id) || blocked.has(id) || ready.includes(id)) return
-    if (inFlight.has(id)) return
-    const deps = incoming.get(id)!
-    for (const d of deps) if (!done.has(d)) return
-    ready.push(id)
-  }
-
-  const inFlight = new Map<string, Promise<{ id: string; outcome: NodeOutcome }>>()
-  let firstSuspend: { taskId: number; nodeId: string; cause: SuspendCause } | null = null
-  let failure: Error | null = null
-  let failedNodeId: string | null = null
-
-  for (const n of nodes) enqueueIfReady(n.id)
-
-  // Main dispatch loop: drain ready, race in-flight, propagate completion.
-  while (true) {
-    while (ready.length > 0 && !failure) {
-      const id = ready.shift()!
-      startOne(id)
-    }
-    if (inFlight.size === 0) break
-
-    const winner = await Promise.race(inFlight.values())
-    inFlight.delete(winner.id)
-
-    const node = byId.get(winner.id)!
-    const kind = getKind(node.kind)!
-    const label = node.label ?? kind.label
-    const o = winner.outcome
-
-    if (o.result.kind === "complete") {
-      results[winner.id] = o.result.output
-      done.add(winner.id)
-      // Persist every completed node output, not only pre-suspend checkpoints.
-      // This keeps /runs/:id/nodes and runs.nodeOutput useful for normal done
-      // runs, while preserving the same resume-skip storage semantics.
-      persistNodeOutputs(runtimeDb(), baseCtx.runId, { [winner.id]: o.result.output })
-      steps.push({
-        id: winner.id, kind: node.kind, label, status: "complete",
-        params: o.params, input: o.input, output: o.result.output,
-        duration_ms: o.durationMs,
-      })
-      for (const next of outgoing.get(winner.id) ?? []) enqueueIfReady(next)
-    } else if (o.result.kind === "suspend") {
-      // Branch-level suspend. Mark this node and all transitive descendants
-      // blocked; sibling branches keep running. Capture the first suspend as
-      // the surfaced one (multiple HITL nodes in a single dispatch are rare;
-      // resume handles them serially).
-      if (!firstSuspend) {
-        firstSuspend = { taskId: o.result.taskId, nodeId: winner.id, cause: o.result.cause }
-      }
-      propagateBlock(winner.id)
-      steps.push({
-        id: winner.id, kind: node.kind, label, status: "complete",
-        params: o.params, input: o.input,
-        output: {
-          __suspended: true,
-          taskId: o.result.taskId,
-          taskKind: o.result.cause.kind,
-          prompt: o.result.cause.spec.prompt,
-        },
-        duration_ms: o.durationMs,
-      })
-    } else {
-      // Strict abort. v1 default per pipeline-spec §11. Capture the failure;
-      // wait for in-flight to settle (best-effort), then throw.
-      failure = o.result.error
-      failedNodeId = winner.id
-      steps.push({
-        id: winner.id, kind: node.kind, label, status: "failed",
-        params: o.params, input: o.input,
-        error: o.result.error.message,
-        duration_ms: o.durationMs,
-      })
-    }
-  }
-
-  if (failure) {
-    // Drain any remaining in-flight promises that started before the abort.
-    await Promise.allSettled(inFlight.values())
-    throw new Error(`Step "${failedNodeId}" (${byId.get(failedNodeId!)?.kind}) failed: ${failure.message}`)
-  }
-
-  if (firstSuspend) {
-    return { status: "suspended", suspendedAt: firstSuspend, steps, results }
-  }
-
-  // Final output: topologically last node's output. Per pipeline-spec §11.7,
-  // a terminal `sink` is the output when present; since `sink.run` returns
-  // its `input.value`, the topo-last result coincides.
-  const topo = topoSort(spec)
-  const lastNode = topo[topo.length - 1]
-  const output = lastNode ? results[lastNode.id] : null
-  return { status: "done", output, steps, results }
-
-  // ─── helpers (closures over loop state) ────────────────────────────────────
-
-  function startOne(id: string) {
-    const node = byId.get(id)!
-    const promise = runOneNode(node, payload, results, baseCtx).then((outcome) => ({ id, outcome }))
-    inFlight.set(id, promise)
-  }
-}
-
-async function runOneNode(
-  node: ParsedNode,
-  payload: Record<string, unknown>,
-  results: Record<string, unknown>,
-  baseCtx: PlatformCtx,
-): Promise<NodeOutcome> {
-  const t0 = performance.now()
-  const ctx = { params: payload, results, resource: baseCtx.resource }
-
-  let params: Record<string, unknown> = {}
-  let input: Record<string, unknown> = {}
-  try {
-    params = (resolveDisc(node.paramsTree, ctx) ?? {}) as Record<string, unknown>
-    input  = (resolveDisc(node.inputTree, ctx)  ?? {}) as Record<string, unknown>
-  } catch (err) {
-    return {
-      params, input,
-      durationMs: Math.round(performance.now() - t0),
-      result: { kind: "error", error: err instanceof Error ? err : new Error(String(err)) },
-    }
-  }
-
-  const kind = getKind(node.kind)!
-  const stepCtx: ExecContext = {
-    ...baseCtx,
-    step:    { nodeId: node.id },
-    suspend: makeSuspend(runtimeDb(), baseCtx.runId, node.id),
-  }
-
-  // §11 / §16.1 — failure-handling policy (default abort).
-  const policy = node.onError
-  const maxAttempts = policy.kind === "retry" ? policy.times + 1 : 1
-
-  let lastError: Error | null = null
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    if (attempt > 0 && policy.kind === "retry") {
-      // Backoff before each retry. Linear: 1s, 2s, 3s ...
-      // Exponential: 1s, 2s, 4s, 8s ... capped at 30s.
-      const delayMs = policy.backoff === "exponential"
-        ? Math.min(1000 * 2 ** (attempt - 1), 30000)
-        : 1000 * attempt
-      await new Promise((r) => setTimeout(r, delayMs))
-      baseCtx.log("info", `retrying node "${node.id}" (attempt ${attempt + 1}/${maxAttempts}) after ${delayMs}ms`)
-    }
-
-    try {
-      const output = await kind.run(stepCtx, params, input)
-      return {
-        params, input,
-        durationMs: Math.round(performance.now() - t0),
-        result: { kind: "complete", output },
-      }
-    } catch (err) {
-      // HITL short-circuits the retry loop — it's a pause, not a failure.
-      if (err instanceof HitlSuspend) {
-        return {
-          params, input,
-          durationMs: Math.round(performance.now() - t0),
-          result: { kind: "suspend", taskId: err.taskId, nodeId: err.nodeId, cause: { kind: "human.input", spec: err.spec } },
-        }
-      }
-      lastError = err instanceof Error ? err : new Error(String(err))
-      // Continue to next retry attempt if any. Otherwise fall through below.
-    }
-  }
-
-  // All attempts exhausted (or maxAttempts === 1, i.e. no retry policy).
-  // Apply the post-retry policy. retry-exhausted falls through to abort.
-  const errFinal = lastError ?? new Error(`node "${node.id}" failed without an error object`)
-
-  if (policy.kind === "skip-with") {
-    try {
-      const subst = resolveDisc(policy.valueTree, ctx) ?? null
-      baseCtx.log("warn", `node "${node.id}" failed (${errFinal.message}); skip-with substitution applied`)
-      return {
-        params, input,
-        durationMs: Math.round(performance.now() - t0),
-        result: { kind: "complete", output: subst },
-      }
-    } catch (substErr) {
-      // skip-with substitution itself blew up — escalate as an error.
-      return {
-        params, input,
-        durationMs: Math.round(performance.now() - t0),
-        result: { kind: "error", error: substErr instanceof Error ? substErr : new Error(String(substErr)) },
-      }
-    }
-  }
-
-  if (policy.kind === "suspend") {
-    const errSpec: ErrorReviewSpec = {
-      prompt: errFinal.message,
-      error:  errFinal.message,
-      details: { kind: node.kind, errorName: errFinal.name },
-    }
-    try {
-      const { id: taskId } = createErrorReviewTask(runtimeDb(), baseCtx.runId, node.id, errSpec)
-      baseCtx.log("warn", `node "${node.id}" failed (${errFinal.message}); suspended for error_review task ${taskId}`)
-      return {
-        params, input,
-        durationMs: Math.round(performance.now() - t0),
-        result: { kind: "suspend", taskId, nodeId: node.id, cause: { kind: "error_review", spec: errSpec } },
-      }
-    } catch (taskErr) {
-      // Failed to even create the suspend task — escalate the original error.
-      baseCtx.log("error", `node "${node.id}" failed AND error_review task creation failed: ${(taskErr as Error).message}`)
-      return {
-        params, input,
-        durationMs: Math.round(performance.now() - t0),
-        result: { kind: "error", error: errFinal },
-      }
-    }
-  }
-
-  // abort (default) and retry-exhausted both end here.
-  return {
-    params, input,
-    durationMs: Math.round(performance.now() - t0),
-    result: { kind: "error", error: errFinal },
-  }
-}
-
-/** Deterministic topological order. Used to pick the final output node. */
-function topoSort(spec: PipelineSpec): PipelineNode[] {
-  const indeg = new Map<string, number>()
-  const reverse = new Map<string, string[]>()
-
-  for (const n of spec.nodes) indeg.set(n.id, 0)
-  for (const e of spec.edges) {
-    indeg.set(e.to, (indeg.get(e.to) ?? 0) + 1)
-    if (!reverse.has(e.from)) reverse.set(e.from, [])
-    reverse.get(e.from)!.push(e.to)
-  }
-
-  const byId = new Map(spec.nodes.map((n) => [n.id, n]))
-  const queue: string[] = []
-  for (const [id, d] of indeg) if (d === 0) queue.push(id)
-
-  const order: PipelineNode[] = []
-  while (queue.length) {
-    const id = queue.shift()!
-    order.push(byId.get(id)!)
-    for (const next of reverse.get(id) ?? []) {
-      const v = (indeg.get(next) ?? 0) - 1
-      indeg.set(next, v)
-      if (v === 0) queue.push(next)
-    }
-  }
-  return order
-}
-
-// ─── Sub-run trigger (pipeline-spec.md §12, M2) ──────────────────────────────
-
-/** Builds a run-scoped logger that writes to the logs table. Public so the
- *  HTTP layer can use the same shape as sub-run launches. */
-export function makeLogger(runId: number): (level: "info" | "warn" | "error", msg: string) => void {
-  const stmt = runtimeDb().prepare("INSERT INTO logs (run_id, level, msg) VALUES (?, ?, ?)")
-  return (level, msg) => { stmt.run(runId, level, msg) }
-}
-
-/** Invoke another pipeline as a sub-run from inside a kind's run() (the
- *  pipeline.run kind's path). Each sub-run gets its own row in `runs`,
- *  its own logger, and persists into `node_outputs` exactly like a
- *  top-level run. The returned SubRunOutcome surfaces the result shape
- *  the kind needs to honour its `onFailure` policy.
- *
- *  baseCtx is the parent run's context. The sub-run inherits db / cache /
- *  resource (shared platform-instance singletons) but gets a fresh runId
- *  and logger. The sub-run's own subRun closure is rebound so its own
- *  recursive calls thread correctly. */
-export async function triggerSubRun(
-  pipelineId: string,
-  payload: Record<string, unknown>,
-  baseCtx: PlatformCtx,
-): Promise<SubRunOutcome> {
-  const spec = getPipeline(pipelineId)
-  if (!spec) {
-    return { status: "failed", runId: -1, error: `pipeline "${pipelineId}" not found`, partialResults: {} }
-  }
-
-  const inserted = runtimeDb().prepare(
-    "INSERT INTO runs (pipeline, status, payload, trigger, updated_at) VALUES (?, 'running', ?, 'sub-run', datetime('now')) RETURNING id",
-  ).get(pipelineId, JSON.stringify(payload)) as { id: number }
-  const subRunId = inserted.id
-
-  // Build a sub-run baseCtx with its own runId, logger, and a self-bound
-  // subRun closure so recursive sub-runs thread correctly.
-  const subBaseCtx: PlatformCtx = {
-    ...baseCtx,
-    runId: subRunId,
-    log: makeLogger(subRunId),
-    subRun: undefined as unknown as PlatformCtx["subRun"],
-  }
-  subBaseCtx.subRun = (pid, p) => triggerSubRun(pid, p, subBaseCtx)
-
-  try {
-    const outcome = await runPipeline(spec, payload, subBaseCtx)
-
-    if (outcome.status === "done") {
-      runtimeDb().prepare(
-        `UPDATE runs SET status='done', result=?, steps=?, finished_at=datetime('now'),
-                          updated_at=datetime('now'), current_node=NULL WHERE id=?`,
-      ).run(JSON.stringify(outcome.output), JSON.stringify(outcome.steps), subRunId)
-      return { status: "done", runId: subRunId, output: outcome.output }
-    }
-
-    // suspended (HITL or error_review). Sub-run is parked; the parent's
-    // pipeline.run kind will surface the suspension in its output.
-    persistNodeOutputs(runtimeDb(), subRunId, outcome.results)
-    runtimeDb().prepare(
-      `UPDATE runs SET status='suspended', steps=?, current_node=?, updated_at=datetime('now') WHERE id=?`,
-    ).run(JSON.stringify(outcome.steps), outcome.suspendedAt.nodeId, subRunId)
-    return {
-      status: "suspended",
-      runId: subRunId,
-      suspendedAt: outcome.suspendedAt.nodeId,
-      partialResults: outcome.results,
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err)
-    runtimeDb().prepare(
-      "UPDATE runs SET status='error', error=?, finished_at=datetime('now'), updated_at=datetime('now') WHERE id=?",
-    ).run(message, subRunId)
-    return { status: "failed", runId: subRunId, error: message, partialResults: {} }
-  }
-}

package/src/runs.ts

@@ -1,53 +0,0 @@
-// 2121
-// Read-only capability over the runtime ledger, exposed to kinds as
-// ctx.runs. Powers the runs.lastOutput and runs.nodeOutput kinds (M3, M4
-// in pipeline-spec.md §12). Kept here rather than in runtime-db.ts because
-// the latter is intentionally not exposed to kinds — kinds see ctx.db
-// (data store) and ctx.cache (capability), not the runtime tables.
-
-import type { Database } from "bun:sqlite"
-import type { RunStore } from "@toist/spec"
-
-interface RunRow {
-  id: number
-  result: string | null
-}
-
-interface NodeOutputRow {
-  output_json: string | null
-}
-
-export function makeRunStore(runtimeDb: Database): RunStore {
-  return {
-    lastOutput(pipeline, opts) {
-      const status = opts?.status ?? "done"
-      const row = runtimeDb.prepare(
-        "SELECT id, result FROM runs WHERE pipeline = ? AND status = ? ORDER BY id DESC LIMIT 1",
-      ).get(pipeline, status) as RunRow | undefined
-      if (!row || row.result === null) return null
-      try {
-        return JSON.parse(row.result) as unknown
-      } catch {
-        return null
-      }
-    },
-
-    nodeOutput(pipeline, node, opts) {
-      const status = opts?.status ?? "done"
-      const row = runtimeDb.prepare(
-        `SELECT no.output_json
-           FROM node_outputs no
-           JOIN runs r ON no.run_id = r.id
-          WHERE r.pipeline = ? AND r.status = ? AND no.node_id = ?
-          ORDER BY r.id DESC
-          LIMIT 1`,
-      ).get(pipeline, status, node) as NodeOutputRow | undefined
-      if (!row || row.output_json === null) return null
-      try {
-        return JSON.parse(row.output_json) as unknown
-      } catch {
-        return null
-      }
-    },
-  }
-}