@hasna/loops 0.4.13 → 0.4.14

package/dist/lib/storage/index.js

@@ -1,9 +1,9 @@
 // @bun
 // src/lib/store.ts
 import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname2, join as join3 } from "path";
+import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 
 // src/lib/errors.ts
 class CodedError extends Error {
@@ -1202,6 +1202,196 @@ function discardWorkflowRunManifest(staged) {
   } catch {}
 }
 
+// src/lib/route/todos-cli.ts
+import { closeSync, mkdtempSync, openSync, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { join as join3 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
+
+// src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
+var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
+function redact(value, visible = 0) {
+  if (!value)
+    return value;
+  if (value.length <= visible)
+    return value;
+  if (visible <= 0)
+    return `[redacted ${value.length} chars]`;
+  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+}
+function truncateTextOutput(value) {
+  if (value.length <= TEXT_OUTPUT_LIMIT)
+    return value;
+  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
+[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+}
+function redactSensitivePayload(value, key) {
+  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
+    if (typeof value === "string")
+      return redact(value);
+    if (value === undefined || value === null)
+      return value;
+    return "[redacted]";
+  }
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitivePayload(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+  }
+  return value;
+}
+function textOutputBlocks(value, opts = {}) {
+  const indent = opts.indent ?? "";
+  const nested = `${indent}  `;
+  const blocks = [];
+  for (const [label, output] of [
+    ["stdout", value.stdout],
+    ["stderr", value.stderr]
+  ]) {
+    if (!output)
+      continue;
+    blocks.push(`${indent}${label}:`);
+    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
+      blocks.push(`${nested}${line}`);
+    }
+  }
+  return blocks;
+}
+function publicLoop(loop) {
+  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
+  return {
+    ...loop,
+    target
+  };
+}
+function publicRun(run, showOutput = false, opts = {}) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: opts.redactError ? redact(run.error) : run.error
+  };
+}
+function publicExecutorResult(result, showOutput = false) {
+  return {
+    ...result,
+    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
+    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
+    error: redact(result.error)
+  };
+}
+function publicWorkflow(workflow) {
+  return {
+    ...workflow,
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
+    }))
+  };
+}
+function publicWorkflowRun(run) {
+  return { ...run, error: redact(run.error) };
+}
+function publicWorkflowInvocation(invocation) {
+  return redactSensitivePayload(invocation);
+}
+function publicWorkflowWorkItem(item) {
+  return { ...item, lastReason: redact(item.lastReason, 240) };
+}
+function publicWorkflowStepRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: redact(run.error)
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event, payload: redactSensitivePayload(event.payload) };
+}
+function publicGoal(goal) {
+  return {
+    ...goal,
+    objective: redact(goal.objective, 120)
+  };
+}
+function publicGoalRun(run) {
+  return {
+    ...run,
+    evidence: redactSensitivePayload(run.evidence),
+    rawResponse: redactSensitivePayload(run.rawResponse)
+  };
+}
+
+// src/lib/route/todos-cli.ts
+function defaultLoopsProject() {
+  return process.env.LOOPS_TASK_PROJECT || process.env.LOOPS_DATA_DIR || `${process.env.HOME || homedir2()}/.hasna/loops`;
+}
+function runLocalCommand(command, args, opts = {}) {
+  const result = spawnSync2(command, args, {
+    input: opts.input,
+    encoding: "utf8",
+    timeout: opts.timeoutMs ?? 30000,
+    maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+    env: process.env
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? String(result.error.message || result.error) : ""
+  };
+}
+function runLocalCommandWithStdoutFile(command, args, opts = {}) {
+  const tempDir = mkdtempSync(join3(tmpdir(), "loops-command-output-"));
+  const stdoutPath = join3(tempDir, "stdout");
+  const stdoutFd = openSync(stdoutPath, "w");
+  let result;
+  try {
+    result = spawnSync2(command, args, {
+      input: opts.input,
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 30000,
+      maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+      env: process.env,
+      stdio: ["pipe", stdoutFd, "pipe"]
+    });
+  } finally {
+    closeSync(stdoutFd);
+  }
+  try {
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout: readFileSync3(stdoutPath, "utf8"),
+      stderr: typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() || "",
+      error: result.error ? String(result.error.message || result.error) : ""
+    };
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+}
+function ensureTodosTaskList(project, slug, name, description) {
+  runLocalCommand("todos", ["--project", project, "task-lists", "--add", name, "--slug", slug, "-d", description]);
+  const list = runLocalCommand("todos", ["--project", project, "--json", "task-lists"]);
+  if (!list.ok)
+    throw new Error(list.stderr || list.error || "failed to list todos task lists");
+  const values = JSON.parse(list.stdout || "[]");
+  const found = values.find((entry) => entry.slug === slug);
+  if (!found)
+    throw new Error(`todos task list not found after ensure: ${slug}`);
+  return found.id;
+}
+function todosMutationSummary(result) {
+  return {
+    ok: result.ok,
+    status: result.status,
+    error: result.ok ? undefined : redact(result.stderr || result.error || "todos mutation failed", 320)
+  };
+}
+
 // src/lib/store.ts
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
@@ -1211,6 +1401,7 @@ var TERMINAL_RUN_STATUSES = ["succeeded", "failed", "timed_out", "abandoned", "s
 var PRUNE_BATCH_SIZE = 400;
 var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "task-lifecycle", "event-worker-verifier"]);
 var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
+var TASK_LIFECYCLE_TEMPLATE_ID = "task-lifecycle";
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -1261,6 +1452,9 @@ function rowToRun(row) {
     updatedAt: row.updated_at
   };
 }
+function latestRunTime(row) {
+  return row.finished_at ?? row.started_at ?? row.created_at;
+}
 function rowToWorkflow(row) {
   return {
     id: row.id,
@@ -1515,7 +1709,7 @@ class Store {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
-    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    this.rootDir = file === ":memory:" ? mkdtempSync2(join4(tmpdir2(), "open-loops-store-")) : dirname2(file);
     if (file === ":memory:")
       this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
@@ -2013,7 +2207,32 @@ class Store {
     } else {
       rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
     }
-    return rows.map(rowToLoop);
+    return this.withLatestRunSummaries(rows.map(rowToLoop));
+  }
+  withLatestRunSummaries(loops) {
+    if (loops.length === 0)
+      return loops;
+    const placeholders = loops.map(() => "?").join(",");
+    const rows = this.db.query(`SELECT loop_id, id, status, started_at, finished_at, created_at
+         FROM (
+           SELECT loop_id, id, status, started_at, finished_at, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS rn
+           FROM loop_runs
+           WHERE loop_id IN (${placeholders})
+         )
+         WHERE rn = 1`).all(...loops.map((loop) => loop.id));
+    const latestByLoopId = new Map(rows.map((row) => [row.loop_id, row]));
+    return loops.map((loop) => {
+      const latest = latestByLoopId.get(loop.id);
+      if (!latest)
+        return loop;
+      return {
+        ...loop,
+        latestRunId: latest.id,
+        latestRunStatus: latest.status,
+        lastRunAt: latestRunTime(latest)
+      };
+    });
   }
   dueLoops(now, limit = 500) {
     const rows = this.db.query(`SELECT * FROM loops
@@ -2132,6 +2351,45 @@ class Store {
       throw error;
     }
   }
+  updateAgentLoopTimeout(idOrName, timeoutMs, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || current.id);
+      if (current.target.type !== "agent")
+        throw new Error(`loop is not an agent loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to update running loop: ${current.id}`);
+      const target = { ...current.target, timeoutMs };
+      if (timeoutMs === null && target.idleTimeoutMs !== undefined)
+        delete target.idleTimeoutMs;
+      const res = this.db.query(`UPDATE loops SET target_json=$target, updated_at=$updated
+           WHERE id=$id
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: current.id,
+        $target: JSON.stringify(target),
+        $updated: updated,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      this.db.exec("COMMIT");
+      const after = this.getLoop(current.id);
+      if (!after)
+        throw new Error(`loop not found after timeout update: ${current.id}`);
+      return after;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
   createAndRetargetWorkflowLoop(idOrName, workflowInput, opts = {}) {
     const normalized = normalizeCreateWorkflowInput(workflowInput);
     const updated = (opts.now ?? new Date).toISOString();
@@ -2462,6 +2720,59 @@ class Store {
       updated
     });
   }
+  taskLifecycleTodosPointerContext(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run || run.status !== "succeeded" || !run.invocationId || !run.workItemId || !run.manifestPath)
+      return;
+    const workItem = this.getWorkflowWorkItem(run.workItemId);
+    if (!workItem || workItem.routeKey !== "todos-task")
+      return;
+    const invocation = this.getWorkflowInvocation(run.invocationId);
+    if (!invocation || invocation.templateId !== TASK_LIFECYCLE_TEMPLATE_ID)
+      return;
+    const projectPath = workItem.projectKey ?? invocation.scope?.projectPath;
+    const taskId = invocation.subjectRef.id ?? workItem.subjectRef;
+    if (!projectPath || !taskId)
+      return;
+    return {
+      projectPath,
+      taskId,
+      invocationId: invocation.id,
+      workflowRunId: run.id,
+      manifestPath: run.manifestPath
+    };
+  }
+  syncSuccessfulTaskLifecycleTodosPointers(workflowRunId) {
+    const context = this.taskLifecycleTodosPointerContext(workflowRunId);
+    if (!context)
+      return;
+    const result = runLocalCommand("todos", [
+      "--project",
+      context.projectPath,
+      "task",
+      "workflow-pointers",
+      context.taskId,
+      "--clear",
+      "--invocation",
+      context.invocationId,
+      "--run",
+      context.workflowRunId,
+      "--manifest",
+      context.manifestPath,
+      "--state",
+      "succeeded",
+      "--actor",
+      "openloops:task-lifecycle"
+    ]);
+    this.appendWorkflowEvent(workflowRunId, result.ok ? "todos_workflow_pointers_synced" : "todos_workflow_pointers_sync_failed", undefined, {
+      projectPath: context.projectPath,
+      taskId: context.taskId,
+      invocationId: context.invocationId,
+      workflowRunId: context.workflowRunId,
+      manifestPath: context.manifestPath,
+      mutation: todosMutationSummary(result)
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -3424,6 +3735,8 @@ class Store {
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
       throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    if (changed && status === "succeeded")
+      this.syncSuccessfulTaskLifecycleTodosPointers(workflowRunId);
     return run;
   }
   cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
@@ -3485,6 +3798,17 @@ class Store {
     const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND scheduled_for = ? AND status = 'running'").get(loopId, scheduledFor);
     return (row?.count ?? 0) > 0;
   }
+  hasBlockingRunningRunForOtherSlot(loopId, scheduledFor, nowIso2) {
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE loop_id = ? AND scheduled_for <> ? AND status = 'running'`).all(loopId, scheduledFor);
+    return rows.some((row) => {
+      if (!row.lease_expires_at || row.lease_expires_at > nowIso2)
+        return true;
+      if (isRecordedProcessAlive(row.pid, row.process_started_at))
+        return true;
+      return this.hasLiveWorkflowStepProcesses(row.id);
+    });
+  }
   markRunPid(id, pid, claimedBy, opts = {}) {
     const now = (opts.now ?? new Date).toISOString();
     const startedMs = processStartTimeMs(pid);
@@ -3617,6 +3941,10 @@ class Store {
       loop = currentLoop;
       const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
       const existing = this.getRunBySlot(loop.id, scheduledFor);
+      if (loop.overlap === "skip" && this.hasBlockingRunningRunForOtherSlot(loop.id, scheduledFor, startedAt)) {
+        this.db.exec("COMMIT");
+        return;
+      }
       if (existing) {
         if (existing.status === "running") {
           if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
@@ -4188,9 +4516,9 @@ class Store {
       const runDir = dirname2(manifestPath);
       try {
         if (/^[0-9a-f]{12,64}$/.test(basename2(runDir))) {
-          rmSync2(runDir, { recursive: true, force: true });
+          rmSync3(runDir, { recursive: true, force: true });
         } else {
-          rmSync2(manifestPath, { force: true });
+          rmSync3(manifestPath, { force: true });
         }
       } catch {}
     }
@@ -4257,215 +4585,13 @@ class Store {
     this.db.close();
     if (this.memoryRootDir) {
       try {
-        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+        rmSync3(this.memoryRootDir, { recursive: true, force: true });
       } catch {}
       this.memoryRootDir = undefined;
     }
   }
 }
 
-// src/lib/storage/sqlite.ts
-class SqliteLoopStorage {
-  store;
-  backend = "sqlite";
-  supportsRemoteRunners = false;
-  constructor(store = new Store) {
-    this.store = store;
-  }
-  async close() {
-    this.store.close();
-  }
-  async call(method, ...args) {
-    return this.store[method](...args);
-  }
-  createLoop(...args) {
-    return this.call("createLoop", ...args);
-  }
-  getLoop(...args) {
-    return this.call("getLoop", ...args);
-  }
-  findLoopByName(...args) {
-    return this.call("findLoopByName", ...args);
-  }
-  requireLoop(...args) {
-    return this.call("requireLoop", ...args);
-  }
-  listLoops(...args) {
-    return this.call("listLoops", ...args);
-  }
-  dueLoops(...args) {
-    return this.call("dueLoops", ...args);
-  }
-  updateLoop(...args) {
-    return this.call("updateLoop", ...args);
-  }
-  renameLoop(...args) {
-    return this.call("renameLoop", ...args);
-  }
-  archiveLoop(...args) {
-    return this.call("archiveLoop", ...args);
-  }
-  unarchiveLoop(...args) {
-    return this.call("unarchiveLoop", ...args);
-  }
-  deleteLoop(...args) {
-    return this.call("deleteLoop", ...args);
-  }
-  createWorkflow(...args) {
-    return this.call("createWorkflow", ...args);
-  }
-  getWorkflow(...args) {
-    return this.call("getWorkflow", ...args);
-  }
-  listWorkflows(...args) {
-    return this.call("listWorkflows", ...args);
-  }
-  countWorkflows(...args) {
-    return this.call("countWorkflows", ...args);
-  }
-  archiveWorkflow(...args) {
-    return this.call("archiveWorkflow", ...args);
-  }
-  createWorkflowInvocation(...args) {
-    return this.call("createWorkflowInvocation", ...args);
-  }
-  getWorkflowInvocation(...args) {
-    return this.call("getWorkflowInvocation", ...args);
-  }
-  listWorkflowInvocations(...args) {
-    return this.call("listWorkflowInvocations", ...args);
-  }
-  upsertWorkflowWorkItem(...args) {
-    return this.call("upsertWorkflowWorkItem", ...args);
-  }
-  getWorkflowWorkItem(...args) {
-    return this.call("getWorkflowWorkItem", ...args);
-  }
-  listWorkflowWorkItems(...args) {
-    return this.call("listWorkflowWorkItems", ...args);
-  }
-  countActiveWorkflowWorkItems(...args) {
-    return this.call("countActiveWorkflowWorkItems", ...args);
-  }
-  admitWorkflowWorkItem(...args) {
-    return this.call("admitWorkflowWorkItem", ...args);
-  }
-  createGoal(...args) {
-    return this.call("createGoal", ...args);
-  }
-  getGoal(...args) {
-    return this.call("getGoal", ...args);
-  }
-  listGoals(...args) {
-    return this.call("listGoals", ...args);
-  }
-  createGoalPlanNodes(...args) {
-    return this.call("createGoalPlanNodes", ...args);
-  }
-  listGoalPlanNodes(...args) {
-    return this.call("listGoalPlanNodes", ...args);
-  }
-  updateGoalStatus(...args) {
-    return this.call("updateGoalStatus", ...args);
-  }
-  updateGoalPlanNode(...args) {
-    return this.call("updateGoalPlanNode", ...args);
-  }
-  recordGoalEvent(...args) {
-    return this.call("recordGoalEvent", ...args);
-  }
-  listGoalRuns(...args) {
-    return this.call("listGoalRuns", ...args);
-  }
-  createWorkflowRun(...args) {
-    return this.call("createWorkflowRun", ...args);
-  }
-  getWorkflowRun(...args) {
-    return this.call("getWorkflowRun", ...args);
-  }
-  listWorkflowRuns(...args) {
-    return this.call("listWorkflowRuns", ...args);
-  }
-  listWorkflowStepRuns(...args) {
-    return this.call("listWorkflowStepRuns", ...args);
-  }
-  getWorkflowStepRun(...args) {
-    return this.call("getWorkflowStepRun", ...args);
-  }
-  startWorkflowStepRun(...args) {
-    return this.call("startWorkflowStepRun", ...args);
-  }
-  recoverWorkflowRun(...args) {
-    return this.call("recoverWorkflowRun", ...args);
-  }
-  finalizeWorkflowStepRun(...args) {
-    return this.call("finalizeWorkflowStepRun", ...args);
-  }
-  finalizeWorkflowRun(...args) {
-    return this.call("finalizeWorkflowRun", ...args);
-  }
-  appendWorkflowEvent(...args) {
-    return this.call("appendWorkflowEvent", ...args);
-  }
-  listWorkflowEvents(...args) {
-    return this.call("listWorkflowEvents", ...args);
-  }
-  recordRunProcess(...args) {
-    return this.call("recordRunProcess", ...args);
-  }
-  createSkippedRun(...args) {
-    return this.call("createSkippedRun", ...args);
-  }
-  getRun(...args) {
-    return this.call("getRun", ...args);
-  }
-  getRunBySlot(...args) {
-    return this.call("getRunBySlot", ...args);
-  }
-  claimRun(...args) {
-    return this.call("claimRun", ...args);
-  }
-  finalizeRun(...args) {
-    return this.call("finalizeRun", ...args);
-  }
-  heartbeatRunLease(...args) {
-    return this.call("heartbeatRunLease", ...args);
-  }
-  listRuns(...args) {
-    return this.call("listRuns", ...args);
-  }
-  recoverExpiredRunLeases(...args) {
-    return this.call("recoverExpiredRunLeases", ...args);
-  }
-  recoverExpiredRunLeasesDetailed(...args) {
-    return this.call("recoverExpiredRunLeasesDetailed", ...args);
-  }
-  countLoops(...args) {
-    return this.call("countLoops", ...args);
-  }
-  countRuns(...args) {
-    return this.call("countRuns", ...args);
-  }
-  pruneHistory(...args) {
-    return this.call("pruneHistory", ...args);
-  }
-  acquireDaemonLease(...args) {
-    return this.call("acquireDaemonLease", ...args);
-  }
-  heartbeatDaemonLease(...args) {
-    return this.call("heartbeatDaemonLease", ...args);
-  }
-  releaseDaemonLease(...args) {
-    return this.call("releaseDaemonLease", ...args);
-  }
-  getDaemonLease(...args) {
-    return this.call("getDaemonLease", ...args);
-  }
-}
-function createSqliteLoopStorage(path) {
-  return new SqliteLoopStorage(new Store(path));
-}
-
 // src/lib/storage/postgres-schema.ts
 import { createHash as createHash2 } from "crypto";
 var POSTGRES_MIGRATION_LEDGER_TABLE = "open_loops_schema_migrations";
@@ -4888,13 +5014,1005 @@ function isMissingLedgerError(error) {
   const message = error.message.toLowerCase();
   return message.includes(POSTGRES_MIGRATION_LEDGER_TABLE.toLowerCase()) && (message.includes("does not exist") || message.includes("no such table") || message.includes("undefined_table"));
 }
+
+// src/lib/storage/sqlite.ts
+class SqliteLoopStorage {
+  store;
+  backend = "sqlite";
+  supportsRemoteRunners = false;
+  constructor(store = new Store) {
+    this.store = store;
+  }
+  async close() {
+    this.store.close();
+  }
+  async call(method, ...args) {
+    return this.store[method](...args);
+  }
+  createLoop(...args) {
+    return this.call("createLoop", ...args);
+  }
+  getLoop(...args) {
+    return this.call("getLoop", ...args);
+  }
+  findLoopByName(...args) {
+    return this.call("findLoopByName", ...args);
+  }
+  requireLoop(...args) {
+    return this.call("requireLoop", ...args);
+  }
+  listLoops(...args) {
+    return this.call("listLoops", ...args);
+  }
+  dueLoops(...args) {
+    return this.call("dueLoops", ...args);
+  }
+  updateLoop(...args) {
+    return this.call("updateLoop", ...args);
+  }
+  renameLoop(...args) {
+    return this.call("renameLoop", ...args);
+  }
+  archiveLoop(...args) {
+    return this.call("archiveLoop", ...args);
+  }
+  unarchiveLoop(...args) {
+    return this.call("unarchiveLoop", ...args);
+  }
+  deleteLoop(...args) {
+    return this.call("deleteLoop", ...args);
+  }
+  createWorkflow(...args) {
+    return this.call("createWorkflow", ...args);
+  }
+  getWorkflow(...args) {
+    return this.call("getWorkflow", ...args);
+  }
+  listWorkflows(...args) {
+    return this.call("listWorkflows", ...args);
+  }
+  countWorkflows(...args) {
+    return this.call("countWorkflows", ...args);
+  }
+  archiveWorkflow(...args) {
+    return this.call("archiveWorkflow", ...args);
+  }
+  createWorkflowInvocation(...args) {
+    return this.call("createWorkflowInvocation", ...args);
+  }
+  getWorkflowInvocation(...args) {
+    return this.call("getWorkflowInvocation", ...args);
+  }
+  listWorkflowInvocations(...args) {
+    return this.call("listWorkflowInvocations", ...args);
+  }
+  upsertWorkflowWorkItem(...args) {
+    return this.call("upsertWorkflowWorkItem", ...args);
+  }
+  getWorkflowWorkItem(...args) {
+    return this.call("getWorkflowWorkItem", ...args);
+  }
+  listWorkflowWorkItems(...args) {
+    return this.call("listWorkflowWorkItems", ...args);
+  }
+  countActiveWorkflowWorkItems(...args) {
+    return this.call("countActiveWorkflowWorkItems", ...args);
+  }
+  admitWorkflowWorkItem(...args) {
+    return this.call("admitWorkflowWorkItem", ...args);
+  }
+  createGoal(...args) {
+    return this.call("createGoal", ...args);
+  }
+  getGoal(...args) {
+    return this.call("getGoal", ...args);
+  }
+  listGoals(...args) {
+    return this.call("listGoals", ...args);
+  }
+  createGoalPlanNodes(...args) {
+    return this.call("createGoalPlanNodes", ...args);
+  }
+  listGoalPlanNodes(...args) {
+    return this.call("listGoalPlanNodes", ...args);
+  }
+  updateGoalStatus(...args) {
+    return this.call("updateGoalStatus", ...args);
+  }
+  updateGoalPlanNode(...args) {
+    return this.call("updateGoalPlanNode", ...args);
+  }
+  recordGoalEvent(...args) {
+    return this.call("recordGoalEvent", ...args);
+  }
+  listGoalRuns(...args) {
+    return this.call("listGoalRuns", ...args);
+  }
+  createWorkflowRun(...args) {
+    return this.call("createWorkflowRun", ...args);
+  }
+  getWorkflowRun(...args) {
+    return this.call("getWorkflowRun", ...args);
+  }
+  listWorkflowRuns(...args) {
+    return this.call("listWorkflowRuns", ...args);
+  }
+  listWorkflowStepRuns(...args) {
+    return this.call("listWorkflowStepRuns", ...args);
+  }
+  getWorkflowStepRun(...args) {
+    return this.call("getWorkflowStepRun", ...args);
+  }
+  startWorkflowStepRun(...args) {
+    return this.call("startWorkflowStepRun", ...args);
+  }
+  recoverWorkflowRun(...args) {
+    return this.call("recoverWorkflowRun", ...args);
+  }
+  finalizeWorkflowStepRun(...args) {
+    return this.call("finalizeWorkflowStepRun", ...args);
+  }
+  finalizeWorkflowRun(...args) {
+    return this.call("finalizeWorkflowRun", ...args);
+  }
+  appendWorkflowEvent(...args) {
+    return this.call("appendWorkflowEvent", ...args);
+  }
+  listWorkflowEvents(...args) {
+    return this.call("listWorkflowEvents", ...args);
+  }
+  recordRunProcess(...args) {
+    return this.call("recordRunProcess", ...args);
+  }
+  createSkippedRun(...args) {
+    return this.call("createSkippedRun", ...args);
+  }
+  getRun(...args) {
+    return this.call("getRun", ...args);
+  }
+  getRunBySlot(...args) {
+    return this.call("getRunBySlot", ...args);
+  }
+  claimRun(...args) {
+    return this.call("claimRun", ...args);
+  }
+  finalizeRun(...args) {
+    return this.call("finalizeRun", ...args);
+  }
+  heartbeatRunLease(...args) {
+    return this.call("heartbeatRunLease", ...args);
+  }
+  listRuns(...args) {
+    return this.call("listRuns", ...args);
+  }
+  recoverExpiredRunLeases(...args) {
+    return this.call("recoverExpiredRunLeases", ...args);
+  }
+  recoverExpiredRunLeasesDetailed(...args) {
+    return this.call("recoverExpiredRunLeasesDetailed", ...args);
+  }
+  countLoops(...args) {
+    return this.call("countLoops", ...args);
+  }
+  countRuns(...args) {
+    return this.call("countRuns", ...args);
+  }
+  pruneHistory(...args) {
+    return this.call("pruneHistory", ...args);
+  }
+  acquireDaemonLease(...args) {
+    return this.call("acquireDaemonLease", ...args);
+  }
+  heartbeatDaemonLease(...args) {
+    return this.call("heartbeatDaemonLease", ...args);
+  }
+  releaseDaemonLease(...args) {
+    return this.call("releaseDaemonLease", ...args);
+  }
+  getDaemonLease(...args) {
+    return this.call("getDaemonLease", ...args);
+  }
+}
+function createSqliteLoopStorage(path) {
+  return new SqliteLoopStorage(new Store(path));
+}
+// src/lib/storage/postgres-loop-storage.ts
+import pgLib from "pg";
+var { types: pgTypes } = pgLib;
+pgTypes.setTypeParser(3802, (v) => v);
+pgTypes.setTypeParser(114, (v) => v);
+var toIso = (v) => v == null ? null : new Date(v).toISOString();
+pgTypes.setTypeParser(1184, (v) => toIso(v));
+pgTypes.setTypeParser(1114, (v) => toIso(v));
+
+class NotImplementedError extends Error {
+  code = "not_implemented";
+  constructor(method) {
+    super(`PostgresLoopStorage.${method} is not implemented on the Postgres backend yet. ` + `This path must not silently no-op; port the sqlite Store.${method} logic.`);
+    this.name = "NotImplementedError";
+  }
+}
+var TERMINAL_RUN_STATUSES2 = ["succeeded", "failed", "timed_out", "abandoned", "skipped"];
+var PRUNE_BATCH_SIZE2 = 400;
+var DEFAULT_RECOVERY_BATCH_LIMIT2 = 100;
+var DEFAULT_RECOVERY_SCAN_MULTIPLIER2 = 5;
+
+class PostgresLoopStorage {
+  client;
+  backend = "postgres";
+  supportsRemoteRunners = true;
+  constructor(client) {
+    this.client = client;
+  }
+  async close() {
+    await this.client.close();
+  }
+  async assertDaemonLeaseFence(c, opts, now) {
+    if (!opts.daemonLeaseId)
+      return;
+    const row = await c.get("SELECT id FROM daemon_lease WHERE id = $1 AND expires_at > $2", [opts.daemonLeaseId, now]);
+    if (!row)
+      throw new Error("daemon lease lost");
+  }
+  async loadLoop(c, id) {
+    const row = await c.get("SELECT * FROM loops WHERE id = $1", [id]);
+    return row ? rowToLoop(row) : undefined;
+  }
+  async loadRun(c, id) {
+    const row = await c.get("SELECT * FROM loop_runs WHERE id = $1", [id]);
+    return row ? rowToRun(row) : undefined;
+  }
+  async loadRunBySlot(c, loopId, scheduledFor) {
+    const row = await c.get("SELECT * FROM loop_runs WHERE loop_id = $1 AND scheduled_for = $2", [loopId, scheduledFor]);
+    return row ? rowToRun(row) : undefined;
+  }
+  async loadDaemonLease(c) {
+    const row = await c.get("SELECT * FROM daemon_lease LIMIT 1", []);
+    return row ? rowToLease(row) : undefined;
+  }
+  async setWorkItemsForLoop(c, loopId, status, reason, updated, statuses = ["admitted", "running"]) {
+    const placeholders = statuses.map((_, i) => `$${i + 5}`).join(",");
+    await c.execute(`UPDATE workflow_work_items
+       SET status=$1, lease_expires_at=NULL, last_reason=COALESCE($2, last_reason), updated_at=$3
+       WHERE loop_id = $4 AND status IN (${placeholders})`, [status, reason ?? null, updated, loopId, ...statuses]);
+  }
+  async setWorkItemsForWorkflowRun(c, workflowRunId, status, reason, updated, statuses = ["admitted", "running"]) {
+    const placeholders = statuses.map((_, i) => `$${i + 5}`).join(",");
+    await c.execute(`UPDATE workflow_work_items
+       SET status=$1, lease_expires_at=NULL, last_reason=COALESCE($2, last_reason), updated_at=$3
+       WHERE workflow_run_id = $4 AND status IN (${placeholders})`, [status, reason ?? null, updated, workflowRunId, ...statuses]);
+  }
+  async cascadeWorkItemsForLoopRun(c, run, reason, updated) {
+    const loop = await this.loadLoop(c, run.loopId);
+    const status = workItemStatusForLoopRun(run.status, run.attempt, loop?.maxAttempts);
+    if (!status)
+      return;
+    const statuses = status === "admitted" ? ["admitted", "running", "failed"] : ["admitted", "running"];
+    const nextReason = status === "admitted" ? reason ? `attempt failed; retry pending: ${reason}` : "attempt failed; retry pending" : reason;
+    await this.setWorkItemsForLoop(c, run.loopId, status, nextReason, updated, statuses);
+  }
+  async createLoop(...args) {
+    const [input, from = new Date] = args;
+    const now = nowIso();
+    const target = input.target.type === "workflow" ? input.target : normalizeCreateWorkflowInput({
+      name: "loop-target-validation",
+      steps: [{ id: "target", target: input.target }]
+    }).steps[0].target;
+    if (input.goal && target.type === "workflow") {
+      const workflow = await this.loadWorkflow(this.client, target.workflowId);
+      if (workflow?.goal) {
+        throw new Error(`workflow loop cannot define a loop-level goal when workflow ${workflow.name} already has a top-level goal; remove one goal wrapper`);
+      }
+    }
+    const loop = {
+      id: genId(),
+      name: input.name,
+      description: input.description,
+      status: "active",
+      schedule: input.schedule,
+      target,
+      goal: input.goal,
+      machine: input.machine,
+      nextRunAt: initialNextRun(input.schedule, from),
+      catchUp: input.catchUp ?? "latest",
+      catchUpLimit: input.catchUpLimit ?? 50,
+      overlap: input.overlap ?? "skip",
+      maxAttempts: input.maxAttempts ?? 1,
+      retryDelayMs: input.retryDelayMs ?? 60000,
+      leaseMs: input.leaseMs ?? 30 * 60000,
+      expiresAt: input.expiresAt,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.client.execute(`INSERT INTO loops (id, name, description, status, schedule_json, target_json, machine_json, next_run_at, retry_scheduled_for,
+        goal_json, catch_up, catch_up_limit, overlap, max_attempts, retry_delay_ms, lease_ms, expires_at, created_at, updated_at)
+       VALUES ($1,$2,$3,$4,$5::jsonb,$6::jsonb,$7::jsonb,$8,NULL,$9::jsonb,$10,$11,$12,$13,$14,$15,$16,$17,$18)`, [
+      loop.id,
+      loop.name,
+      loop.description ?? null,
+      loop.status,
+      JSON.stringify(loop.schedule),
+      JSON.stringify(loop.target),
+      loop.machine ? JSON.stringify(loop.machine) : null,
+      loop.nextRunAt ?? null,
+      loop.goal ? JSON.stringify(loop.goal) : null,
+      loop.catchUp,
+      loop.catchUpLimit,
+      loop.overlap,
+      loop.maxAttempts,
+      loop.retryDelayMs,
+      loop.leaseMs,
+      loop.expiresAt ?? null,
+      loop.createdAt,
+      loop.updatedAt
+    ]);
+    return loop;
+  }
+  async getLoop(...args) {
+    return this.loadLoop(this.client, args[0]);
+  }
+  async findLoopByName(...args) {
+    const row = await this.client.get("SELECT * FROM loops WHERE name = $1 ORDER BY created_at DESC LIMIT 1", [args[0]]);
+    return row ? rowToLoop(row) : undefined;
+  }
+  async requireLoop(...args) {
+    const idOrName = args[0];
+    const found = await this.getLoop(idOrName) ?? await this.findLoopByName(idOrName);
+    if (!found)
+      throw new LoopNotFoundError(idOrName);
+    return found;
+  }
+  async listLoops(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 200;
+    let rows;
+    if (opts.status && opts.archived) {
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+    } else if (opts.status && opts.includeArchived) {
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+    } else if (opts.status) {
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+    } else if (opts.archived) {
+      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT $1", [limit]);
+    } else if (opts.includeArchived) {
+      rows = await this.client.many("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT $1", [limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToLoop);
+  }
+  async dueLoops(...args) {
+    const [now, limit = 500] = args;
+    const rows = await this.client.many(`SELECT * FROM loops
+       WHERE status = 'active' AND archived_at IS NULL AND next_run_at IS NOT NULL AND next_run_at <= $1
+       ORDER BY next_run_at ASC LIMIT $2`, [now.toISOString(), limit]);
+    return rows.map(rowToLoop);
+  }
+  async updateLoop(...args) {
+    const [id, patch, opts = {}] = args;
+    const updated = (opts.now ?? new Date).toISOString();
+    return this.client.transaction(async (c) => {
+      const current = await this.loadLoop(c, id);
+      if (!current)
+        throw new LoopNotFoundError(id);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || id);
+      const merged = { ...current, ...patch, updatedAt: updated };
+      const res = await c.query(`UPDATE loops SET status=$1, next_run_at=$2, retry_scheduled_for=$3, expires_at=$4, updated_at=$5
+         WHERE id=$6
+           AND ($7::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$7 AND expires_at > $8))`, [
+        merged.status,
+        merged.nextRunAt ?? null,
+        merged.retryScheduledFor ?? null,
+        merged.expiresAt ?? null,
+        merged.updatedAt,
+        id,
+        opts.daemonLeaseId ?? null,
+        updated
+      ]);
+      if (res.rowCount !== 1)
+        throw new Error("daemon lease lost");
+      if (patch.status && patch.status !== "active") {
+        const status = patch.status === "paused" ? "deferred" : "cancelled";
+        await this.setWorkItemsForLoop(c, id, status, `loop ${patch.status}`, updated);
+      }
+      const after = await this.loadLoop(c, id);
+      if (!after)
+        throw new Error(`loop not found after update: ${id}`);
+      return after;
+    });
+  }
+  async renameLoop(...args) {
+    const [id, name, opts = {}] = args;
+    const current = await this.getLoop(id);
+    if (!current)
+      throw new LoopNotFoundError(id);
+    const trimmed = name.trim();
+    if (!trimmed)
+      throw new ValidationError("loop name must not be empty");
+    const updated = (opts.now ?? new Date).toISOString();
+    await this.client.execute(`UPDATE loops SET name=$1, updated_at=$2
+       WHERE id=$3 AND ($4::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$4 AND expires_at > $5))`, [trimmed, updated, id, opts.daemonLeaseId ?? null, updated]);
+    const after = await this.getLoop(id);
+    if (!after)
+      throw new Error(`loop not found after rename: ${id}`);
+    return after;
+  }
+  async archiveLoop(...args) {
+    const idOrName = args[0];
+    return this.client.transaction(async (c) => {
+      const loop = await this.requireLoopIn(c, idOrName);
+      if (loop.archivedAt)
+        return loop;
+      const updated = nowIso();
+      const archivedStatus = loop.status === "active" ? "paused" : loop.status;
+      await c.execute(`UPDATE loops SET status=$1, archived_at=$2, archived_from_status=$3, updated_at=$4 WHERE id=$5`, [archivedStatus, updated, loop.status, updated, loop.id]);
+      await this.setWorkItemsForLoop(c, loop.id, "deferred", "loop archived", updated);
+      const archived = await this.loadLoop(c, loop.id);
+      if (!archived)
+        throw new Error(`loop not found after archive: ${loop.id}`);
+      return archived;
+    });
+  }
+  async unarchiveLoop(...args) {
+    const idOrName = args[0];
+    const loop = await this.requireLoop(idOrName);
+    if (!loop.archivedAt)
+      return loop;
+    const updated = nowIso();
+    const restoredStatus = loop.archivedFromStatus ?? loop.status;
+    await this.client.execute(`UPDATE loops SET status=$1, archived_at=NULL, archived_from_status=NULL, updated_at=$2 WHERE id=$3`, [restoredStatus, updated, loop.id]);
+    const unarchived = await this.getLoop(loop.id);
+    if (!unarchived)
+      throw new Error(`loop not found after unarchive: ${loop.id}`);
+    return unarchived;
+  }
+  async deleteLoop(...args) {
+    const idOrName = args[0];
+    return this.client.transaction(async (c) => {
+      const loop = await this.requireLoopIn(c, idOrName);
+      await this.setWorkItemsForLoop(c, loop.id, "cancelled", "loop deleted", nowIso());
+      const res = await c.query(`DELETE FROM loops WHERE id = $1`, [loop.id]);
+      return res.rowCount > 0;
+    });
+  }
+  async requireLoopIn(c, idOrName) {
+    const byId = await this.loadLoop(c, idOrName);
+    if (byId)
+      return byId;
+    const row = await c.get("SELECT * FROM loops WHERE name = $1 ORDER BY created_at DESC LIMIT 1", [idOrName]);
+    if (!row)
+      throw new LoopNotFoundError(idOrName);
+    return rowToLoop(row);
+  }
+  async countLoops(...args) {
+    const [status, opts = {}] = args;
+    let sql;
+    const params = [];
+    if (status && opts.archived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE status = $1 AND archived_at IS NOT NULL";
+      params.push(status);
+    } else if (status && opts.includeArchived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE status = $1";
+      params.push(status);
+    } else if (status) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE status = $1 AND archived_at IS NULL";
+      params.push(status);
+    } else if (opts.archived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE archived_at IS NOT NULL";
+    } else if (opts.includeArchived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops";
+    } else {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE archived_at IS NULL";
+    }
+    const row = await this.client.get(sql, params);
+    return row?.count ?? 0;
+  }
+  async createSkippedRun(...args) {
+    const [loop, scheduledFor, reason, opts = {}] = args;
+    const now = nowIso();
+    const id = genId();
+    return this.client.transaction(async (c) => {
+      await this.assertDaemonLeaseFence(c, opts, now);
+      await c.execute(`INSERT INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+          claimed_by, lease_expires_at, pid, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,1,'skipped',NULL,$5,NULL,NULL,NULL,NULL,NULL,NULL,NULL,$6,$7,$7)
+         ON CONFLICT (loop_id, scheduled_for) DO NOTHING`, [id, loop.id, loop.name, scheduledFor, now, reason, now]);
+      const run = await this.loadRunBySlot(c, loop.id, scheduledFor);
+      if (run)
+        return run;
+      return {
+        id,
+        loopId: loop.id,
+        loopName: loop.name,
+        scheduledFor,
+        attempt: 1,
+        status: "skipped",
+        finishedAt: now,
+        error: reason,
+        createdAt: now,
+        updatedAt: now
+      };
+    });
+  }
+  async getRun(...args) {
+    return this.loadRun(this.client, args[0]);
+  }
+  async getRunBySlot(...args) {
+    return this.loadRunBySlot(this.client, args[0], args[1]);
+  }
+  async claimRun(...args) {
+    const [loopArg, scheduledFor, runnerId, now = new Date, opts = {}] = args;
+    const startedAt = now.toISOString();
+    const claimToken = opts.claimToken ?? genId();
+    return this.client.transaction(async (c) => {
+      await this.assertDaemonLeaseFence(c, opts, startedAt);
+      const loop = await this.loadLoop(c, loopArg.id);
+      if (!loop || loop.archivedAt)
+        return;
+      const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
+      if (loop.overlap === "skip") {
+        const blocking = await c.get(`SELECT id FROM loop_runs
+           WHERE loop_id=$1 AND scheduled_for<>$2 AND status='running'
+             AND lease_expires_at IS NOT NULL AND lease_expires_at > $3
+           LIMIT 1`, [loop.id, scheduledFor, startedAt]);
+        if (blocking)
+          return;
+      }
+      const existing = await c.get("SELECT * FROM loop_runs WHERE loop_id=$1 AND scheduled_for=$2 FOR UPDATE", [loop.id, scheduledFor]);
+      if (existing) {
+        if (existing.status === "running") {
+          if (existing.lease_expires_at && existing.lease_expires_at > startedAt) {
+            return;
+          }
+          const res3 = await c.query(`UPDATE loop_runs SET status='running', started_at=$2, finished_at=NULL, claimed_by=$3, claim_token=$4,
+             lease_expires_at=$5, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL, duration_ms=NULL,
+             stdout=NULL, stderr=NULL, error=NULL, updated_at=$2
+             WHERE id=$1 AND status='running' AND lease_expires_at <= $6`, [existing.id, startedAt, runnerId, claimToken, leaseExpiresAt, startedAt]);
+          if (res3.rowCount !== 1)
+            return;
+          const run3 = await this.loadRun(c, existing.id);
+          return run3 ? { run: run3, loop, claimToken } : undefined;
+        }
+        if (existing.status === "succeeded" || existing.status === "skipped")
+          return;
+        const attempt = existing.attempt + 1;
+        const res2 = await c.query(`UPDATE loop_runs SET attempt=$2, status='running', started_at=$3, finished_at=NULL, claimed_by=$4, claim_token=$5,
+           lease_expires_at=$6, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL, duration_ms=NULL,
+           stdout=NULL, stderr=NULL, error=NULL, updated_at=$3
+           WHERE id=$1 AND status IN ('failed','timed_out','abandoned') AND attempt < $7`, [existing.id, attempt, startedAt, runnerId, claimToken, leaseExpiresAt, loop.maxAttempts]);
+        if (res2.rowCount !== 1)
+          return;
+        const run2 = await this.loadRun(c, existing.id);
+        return run2 ? { run: run2, loop, claimToken } : undefined;
+      }
+      const id = genId();
+      const res = await c.query(`INSERT INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+          claimed_by, claim_token, lease_expires_at, pid, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,1,'running',$5,NULL,$6,$7,$8,NULL,NULL,NULL,NULL,NULL,NULL,$5,$5)
+         ON CONFLICT (loop_id, scheduled_for) DO NOTHING`, [id, loop.id, loop.name, scheduledFor, startedAt, runnerId, claimToken, leaseExpiresAt]);
+      if (res.rowCount !== 1)
+        return;
+      const run = await this.loadRun(c, id);
+      return run ? { run, loop, claimToken } : undefined;
+    });
+  }
+  async finalizeRun(...args) {
+    const [id, patch, opts = {}] = args;
+    const finishedAt = patch.finishedAt ?? nowIso();
+    const error = patch.error === undefined ? undefined : persistedRunOutput(patch.error) ?? undefined;
+    const nowStr = (opts.now ?? new Date).toISOString();
+    return this.client.transaction(async (c) => {
+      let res;
+      if (opts.claimedBy) {
+        res = await c.query(`UPDATE loop_runs SET status=$2, finished_at=$3, claim_token=NULL, lease_expires_at=NULL, pid=$4, exit_code=$5,
+           duration_ms=$6, stdout=$7, stderr=$8, error=$9, updated_at=$3
+           WHERE id=$1 AND status='running' AND claimed_by=$10 AND lease_expires_at > $11
+             AND ($12::text IS NULL OR claim_token=$12)
+             AND ($13::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$13 AND expires_at > $11))`, [
+          id,
+          patch.status,
+          finishedAt,
+          patch.pid ?? null,
+          patch.exitCode ?? null,
+          patch.durationMs ?? null,
+          persistedRunOutput(patch.stdout),
+          persistedRunOutput(patch.stderr),
+          error ?? null,
+          opts.claimedBy,
+          nowStr,
+          opts.claimToken ?? null,
+          opts.daemonLeaseId ?? null
+        ]);
+      } else {
+        res = await c.query(`UPDATE loop_runs SET status=$2, finished_at=$3, claim_token=NULL, lease_expires_at=NULL, pid=$4, exit_code=$5,
+           duration_ms=$6, stdout=$7, stderr=$8, error=$9, updated_at=$3
+           WHERE id=$1 AND status='running'`, [
+          id,
+          patch.status,
+          finishedAt,
+          patch.pid ?? null,
+          patch.exitCode ?? null,
+          patch.durationMs ?? null,
+          persistedRunOutput(patch.stdout),
+          persistedRunOutput(patch.stderr),
+          error ?? null
+        ]);
+      }
+      const run = await this.loadRun(c, id);
+      if (!run)
+        throw new Error(`run not found after finalize: ${id}`);
+      if (opts.claimedBy && res.rowCount !== 1)
+        return run;
+      if (res.rowCount === 1) {
+        await this.cascadeWorkItemsForLoopRun(c, run, error, finishedAt);
+      }
+      return run;
+    });
+  }
+  async heartbeatRunLease(...args) {
+    const [id, claimedBy, leaseMs, now = new Date, opts = {}] = args;
+    const nowStr = now.toISOString();
+    const expiresAt = new Date(now.getTime() + leaseMs).toISOString();
+    const res = await this.client.query(`UPDATE loop_runs SET lease_expires_at=$2, updated_at=$3
+       WHERE id=$1 AND status='running' AND claimed_by=$4 AND lease_expires_at > $5
+         AND ($6::text IS NULL OR claim_token=$6)
+         AND ($7::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$7 AND expires_at > $5))`, [id, expiresAt, nowStr, claimedBy, nowStr, opts.claimToken ?? null, opts.daemonLeaseId ?? null]);
+    if (res.rowCount !== 1)
+      return;
+    return this.getRun(id);
+  }
+  async recordRunProcess(...args) {
+    const [runId, info, opts = {}] = args;
+    const now = (opts.now ?? new Date).toISOString();
+    const res = await this.client.query(`UPDATE loop_runs SET pid=$2, pgid=$3, process_started_at=$4, updated_at=$5
+       WHERE id=$1 AND status='running'
+         AND ($6::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$6 AND expires_at > $7))`, [runId, info.pid, info.pgid ?? null, info.processStartedAt ?? now, now, opts.daemonLeaseId ?? null, now]);
+    if (res.rowCount !== 1)
+      return;
+    return this.getRun(runId);
+  }
+  async listRuns(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.loopId && opts.status) {
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 AND status = $2 ORDER BY created_at DESC LIMIT $3", [opts.loopId, opts.status, limit]);
+    } else if (opts.loopId) {
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.loopId, limit]);
+    } else if (opts.status) {
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE status = $1 ORDER BY created_at DESC LIMIT $2", [opts.status, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToRun);
+  }
+  async countRuns(...args) {
+    const status = args[0];
+    const row = status ? await this.client.get("SELECT COUNT(*)::int AS count FROM loop_runs WHERE status = $1", [status]) : await this.client.get("SELECT COUNT(*)::int AS count FROM loop_runs", []);
+    return row?.count ?? 0;
+  }
+  async recoverExpiredRunLeases(...args) {
+    const detailed = await this.recoverExpiredRunLeasesDetailed(...args);
+    return detailed.abandoned;
+  }
+  async recoverExpiredRunLeasesDetailed(...args) {
+    const [now = new Date, opts = {}] = args;
+    const limit = Math.max(1, Math.min(1000, Math.floor(opts.limit ?? DEFAULT_RECOVERY_BATCH_LIMIT2)));
+    const scanLimit = Math.max(limit, Math.min(5000, Math.floor(opts.scanLimit ?? limit * DEFAULT_RECOVERY_SCAN_MULTIPLIER2)));
+    const finished = now.toISOString();
+    const rows = await this.client.many(`SELECT * FROM loop_runs WHERE status='running' AND lease_expires_at <= $1 ORDER BY lease_expires_at ASC LIMIT $2`, [finished, scanLimit]);
+    const recovered = [];
+    for (const row of rows) {
+      if (recovered.length >= limit)
+        break;
+      const run = await this.client.transaction(async (c) => {
+        const res = await c.query(`UPDATE loop_runs SET status='abandoned', finished_at=$2, lease_expires_at=NULL,
+           error='run lease expired before completion', updated_at=$2
+           WHERE id=$1 AND status='running' AND lease_expires_at <= $3
+             AND ($4::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$4 AND expires_at > $3))`, [row.id, finished, finished, opts.daemonLeaseId ?? null]);
+        if (res.rowCount !== 1)
+          return;
+        const workflowRows = await c.many("SELECT * FROM workflow_runs WHERE loop_run_id = $1 AND status NOT IN ('succeeded','failed','timed_out','cancelled')", [row.id]);
+        for (const wf of workflowRows) {
+          const wfRes = await c.query(`UPDATE workflow_runs SET status='failed', finished_at=$2,
+             error='parent loop run lease expired before completion', updated_at=$2
+             WHERE id=$1 AND status NOT IN ('succeeded','failed','timed_out','cancelled')`, [wf.id, finished]);
+          if (wfRes.rowCount !== 1)
+            continue;
+          await c.execute(`UPDATE workflow_step_runs SET status='skipped', finished_at=$2, pid=NULL,
+             error='parent loop run lease expired before completion', updated_at=$2
+             WHERE workflow_run_id=$1 AND status IN ('pending','running')`, [wf.id, finished]);
+          await this.setWorkItemsForWorkflowRun(c, wf.id, "failed", "parent loop run lease expired before completion", finished);
+        }
+        const loop = await this.loadLoop(c, row.loop_id);
+        const itemStatus = workItemStatusForLoopRun("abandoned", row.attempt, loop?.maxAttempts);
+        if (itemStatus) {
+          const statuses = itemStatus === "admitted" ? ["admitted", "running", "failed"] : ["admitted", "running"];
+          const reason = itemStatus === "admitted" ? "run lease expired before completion; retry pending" : "run lease expired before completion";
+          await this.setWorkItemsForLoop(c, row.loop_id, itemStatus, reason, finished, statuses);
+        }
+        return this.loadRun(c, row.id);
+      });
+      if (run)
+        recovered.push(run);
+    }
+    return { abandoned: recovered, deferred: [] };
+  }
+  async pruneHistory(...args) {
+    const opts = args[0];
+    const { maxAgeDays, keepPerLoop } = opts;
+    if (maxAgeDays === undefined && keepPerLoop === undefined) {
+      throw new ValidationError("pruneHistory requires maxAgeDays and/or keepPerLoop");
+    }
+    if (maxAgeDays !== undefined && (!Number.isFinite(maxAgeDays) || maxAgeDays < 0)) {
+      throw new ValidationError(`pruneHistory maxAgeDays must be a non-negative number: ${maxAgeDays}`);
+    }
+    if (keepPerLoop !== undefined && (!Number.isInteger(keepPerLoop) || keepPerLoop < 0)) {
+      throw new ValidationError(`pruneHistory keepPerLoop must be a non-negative integer: ${keepPerLoop}`);
+    }
+    const now = opts.now ?? new Date;
+    const dryRun = opts.dryRun ?? false;
+    const cutoff = maxAgeDays === undefined ? undefined : new Date(now.getTime() - maxAgeDays * 86400000).toISOString();
+    const terminal = TERMINAL_RUN_STATUSES2.map((s) => `'${s}'`).join(",");
+    const candidateIds = (await this.client.many(`WITH ranked AS (
+           SELECT id, status, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS recency
+           FROM loop_runs
+         )
+         SELECT id FROM ranked
+         WHERE status IN (${terminal})
+           AND ($1::timestamptz IS NULL OR created_at < $1::timestamptz)
+           AND ($2::int IS NULL OR recency > $2)`, [cutoff ?? null, keepPerLoop ?? null])).map((r) => r.id);
+    const summary = {
+      dryRun,
+      cutoff,
+      keepPerLoop,
+      loopRuns: dryRun ? candidateIds.length : 0,
+      workflowRuns: 0,
+      goalRuns: 0
+    };
+    for (let offset = 0;offset < candidateIds.length; offset += PRUNE_BATCH_SIZE2) {
+      const batch = candidateIds.slice(offset, offset + PRUNE_BATCH_SIZE2);
+      if (dryRun) {
+        const workflowRunIds = (await this.client.many(`SELECT id FROM workflow_runs WHERE loop_run_id = ANY($1)`, [batch])).map((r) => r.id);
+        summary.workflowRuns += workflowRunIds.length;
+        const gr = await this.client.get(`SELECT COUNT(*)::int AS count FROM goal_runs WHERE loop_run_id = ANY($1) OR workflow_run_id = ANY($2)`, [batch, workflowRunIds]);
+        summary.goalRuns += gr?.count ?? 0;
+        continue;
+      }
+      await this.client.transaction(async (c) => {
+        const confirmed = (await c.many(`SELECT id FROM loop_runs WHERE id = ANY($1) AND status IN (${terminal})`, [batch])).map((r) => r.id);
+        if (confirmed.length === 0)
+          return;
+        const workflowRunIds = (await c.many(`SELECT id FROM workflow_runs WHERE loop_run_id = ANY($1)`, [confirmed])).map((r) => r.id);
+        summary.loopRuns += confirmed.length;
+        summary.workflowRuns += workflowRunIds.length;
+        const gr = await c.query(`DELETE FROM goal_runs WHERE loop_run_id = ANY($1) OR workflow_run_id = ANY($2)`, [confirmed, workflowRunIds]);
+        summary.goalRuns += gr.rowCount;
+        if (workflowRunIds.length > 0) {
+          await c.execute(`DELETE FROM workflow_runs WHERE id = ANY($1)`, [workflowRunIds]);
+        }
+        await c.execute(`DELETE FROM loop_runs WHERE id = ANY($1) AND status IN (${terminal})`, [confirmed]);
+      });
+    }
+    return summary;
+  }
+  async acquireDaemonLease(...args) {
+    const input = args[0];
+    const now = input.now ?? new Date;
+    const expiresAt = new Date(now.getTime() + input.ttlMs).toISOString();
+    return this.client.transaction(async (c) => {
+      const existing = await c.get("SELECT * FROM daemon_lease LIMIT 1 FOR UPDATE", []);
+      if (existing && existing.expires_at > now.toISOString() && existing.id !== input.id) {
+        return;
+      }
+      await c.execute("DELETE FROM daemon_lease", []);
+      await c.execute(`INSERT INTO daemon_lease (id, pid, hostname, heartbeat_at, expires_at, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,$5,$4,$4)`, [input.id, input.pid, input.hostname, now.toISOString(), expiresAt]);
+      return this.loadDaemonLease(c);
+    });
+  }
+  async heartbeatDaemonLease(...args) {
+    const [id, ttlMs, now = new Date] = args;
+    const expiresAt = new Date(now.getTime() + ttlMs).toISOString();
+    const res = await this.client.query(`UPDATE daemon_lease SET heartbeat_at=$2, expires_at=$3, updated_at=$2 WHERE id=$1 AND expires_at > $4`, [id, now.toISOString(), expiresAt, now.toISOString()]);
+    if (res.rowCount !== 1)
+      return;
+    return this.getDaemonLease();
+  }
+  async releaseDaemonLease(...args) {
+    await this.client.execute("DELETE FROM daemon_lease WHERE id = $1", [args[0]]);
+  }
+  async getDaemonLease(...args) {
+    return this.loadDaemonLease(this.client);
+  }
+  async loadWorkflow(c, id) {
+    const row = await c.get("SELECT * FROM workflow_specs WHERE id = $1", [id]);
+    return row ? rowToWorkflow(row) : undefined;
+  }
+  async getWorkflow(...args) {
+    return this.loadWorkflow(this.client, args[0]);
+  }
+  async listWorkflows(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 200;
+    const offset = opts.offset ?? 0;
+    const rows = opts.status ? await this.client.many("SELECT * FROM workflow_specs WHERE status = $1 ORDER BY status ASC, name ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]) : await this.client.many("SELECT * FROM workflow_specs ORDER BY status ASC, name ASC LIMIT $1 OFFSET $2", [limit, offset]);
+    return rows.map(rowToWorkflow);
+  }
+  async countWorkflows(...args) {
+    const opts = args[0] ?? {};
+    const row = opts.status ? await this.client.get("SELECT COUNT(*)::int AS count FROM workflow_specs WHERE status = $1", [opts.status]) : await this.client.get("SELECT COUNT(*)::int AS count FROM workflow_specs", []);
+    return row?.count ?? 0;
+  }
+  async getWorkflowInvocation(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_invocations WHERE id = $1", [args[0]]);
+    return row ? rowToWorkflowInvocation(row) : undefined;
+  }
+  async listWorkflowInvocations(...args) {
+    const opts = args[0] ?? {};
+    const rows = await this.client.many("SELECT * FROM workflow_invocations ORDER BY created_at DESC LIMIT $1", [opts.limit ?? 100]);
+    return rows.map(rowToWorkflowInvocation);
+  }
+  async getWorkflowWorkItem(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_work_items WHERE id = $1", [args[0]]);
+    return row ? rowToWorkflowWorkItem(row) : undefined;
+  }
+  async listWorkflowWorkItems(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.status && opts.routeKey) {
+      rows = await this.client.many("SELECT * FROM workflow_work_items WHERE status = $1 AND route_key = $2 ORDER BY priority DESC, created_at ASC LIMIT $3", [opts.status, opts.routeKey, limit]);
+    } else if (opts.status) {
+      rows = await this.client.many("SELECT * FROM workflow_work_items WHERE status = $1 ORDER BY priority DESC, created_at ASC LIMIT $2", [opts.status, limit]);
+    } else if (opts.routeKey) {
+      rows = await this.client.many("SELECT * FROM workflow_work_items WHERE route_key = $1 ORDER BY priority DESC, created_at ASC LIMIT $2", [opts.routeKey, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM workflow_work_items ORDER BY priority DESC, created_at ASC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToWorkflowWorkItem);
+  }
+  async countActiveWorkflowWorkItems(...args) {
+    const a = args[0] ?? {};
+    const active = "('admitted','running')";
+    const scoped = async (col, val) => {
+      const row = await this.client.get(`SELECT COUNT(*)::int AS count FROM workflow_work_items WHERE status IN ${active} AND ${col} = $1`, [val]);
+      return row?.count ?? 0;
+    };
+    const routeScope = a.routeScope?.trim() || undefined;
+    const global = routeScope ? await scoped("route_scope", routeScope) : (await this.client.get(`SELECT COUNT(*)::int AS count FROM workflow_work_items WHERE status IN ${active}`, []))?.count ?? 0;
+    const project = a.projectKey ? await scoped("project_key", a.projectKey) : 0;
+    const projectGroup = a.projectGroup ? await scoped("project_group", a.projectGroup) : undefined;
+    return {
+      global,
+      project,
+      ...projectGroup !== undefined ? { projectGroup } : {}
+    };
+  }
+  async getWorkflowRun(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_runs WHERE id = $1", [args[0]]);
+    return row ? rowToWorkflowRun(row) : undefined;
+  }
+  async listWorkflowRuns(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.workflowId && opts.loopRunId) {
+      rows = await this.client.many("SELECT * FROM workflow_runs WHERE workflow_id = $1 AND loop_run_id = $2 ORDER BY created_at DESC LIMIT $3", [opts.workflowId, opts.loopRunId, limit]);
+    } else if (opts.workflowId) {
+      rows = await this.client.many("SELECT * FROM workflow_runs WHERE workflow_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.workflowId, limit]);
+    } else if (opts.loopRunId) {
+      rows = await this.client.many("SELECT * FROM workflow_runs WHERE loop_run_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.loopRunId, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM workflow_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToWorkflowRun);
+  }
+  async listWorkflowStepRuns(...args) {
+    const rows = await this.client.many("SELECT * FROM workflow_step_runs WHERE workflow_run_id = $1 ORDER BY sequence ASC", [args[0]]);
+    return rows.map(rowToWorkflowStepRun);
+  }
+  async getWorkflowStepRun(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_step_runs WHERE workflow_run_id = $1 AND step_id = $2", [args[0], args[1]]);
+    return row ? rowToWorkflowStepRun(row) : undefined;
+  }
+  async listWorkflowEvents(...args) {
+    const [workflowRunId, limit = 200] = args;
+    const rows = await this.client.many("SELECT * FROM workflow_events WHERE workflow_run_id = $1 ORDER BY sequence ASC LIMIT $2", [workflowRunId, limit]);
+    return rows.map(rowToWorkflowEvent);
+  }
+  async getGoal(...args) {
+    const row = await this.client.get("SELECT * FROM goals WHERE id = $1", [args[0]]);
+    return row ? rowToGoal(row) : undefined;
+  }
+  async listGoals(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    const rows = opts.status ? await this.client.many("SELECT * FROM goals WHERE status = $1 ORDER BY updated_at DESC LIMIT $2", [opts.status, limit]) : await this.client.many("SELECT * FROM goals ORDER BY updated_at DESC LIMIT $1", [limit]);
+    return rows.map(rowToGoal);
+  }
+  async listGoalPlanNodes(...args) {
+    const idOrPlan = args[0];
+    const rows = await this.client.many("SELECT * FROM goal_plan_nodes WHERE goal_id = $1 OR plan_id = $1 ORDER BY sequence ASC", [idOrPlan]);
+    return rows.map((r) => rowToGoalPlanNode({ ...r, ready: r.ready ? 1 : 0 }));
+  }
+  async listGoalRuns(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.runId) {
+      rows = await this.client.many("SELECT * FROM goal_runs WHERE id = $1", [opts.runId]);
+    } else if (opts.goalId) {
+      rows = await this.client.many("SELECT * FROM goal_runs WHERE goal_id = $1 ORDER BY created_at ASC LIMIT $2", [opts.goalId, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM goal_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToGoalRun);
+  }
+  createWorkflow() {
+    throw new NotImplementedError("createWorkflow");
+  }
+  archiveWorkflow() {
+    throw new NotImplementedError("archiveWorkflow");
+  }
+  createWorkflowInvocation() {
+    throw new NotImplementedError("createWorkflowInvocation");
+  }
+  upsertWorkflowWorkItem() {
+    throw new NotImplementedError("upsertWorkflowWorkItem");
+  }
+  admitWorkflowWorkItem() {
+    throw new NotImplementedError("admitWorkflowWorkItem");
+  }
+  createGoal() {
+    throw new NotImplementedError("createGoal");
+  }
+  createGoalPlanNodes() {
+    throw new NotImplementedError("createGoalPlanNodes");
+  }
+  updateGoalStatus() {
+    throw new NotImplementedError("updateGoalStatus");
+  }
+  updateGoalPlanNode() {
+    throw new NotImplementedError("updateGoalPlanNode");
+  }
+  recordGoalEvent() {
+    throw new NotImplementedError("recordGoalEvent");
+  }
+  createWorkflowRun() {
+    throw new NotImplementedError("createWorkflowRun");
+  }
+  startWorkflowStepRun() {
+    throw new NotImplementedError("startWorkflowStepRun");
+  }
+  recoverWorkflowRun() {
+    throw new NotImplementedError("recoverWorkflowRun");
+  }
+  finalizeWorkflowStepRun() {
+    throw new NotImplementedError("finalizeWorkflowStepRun");
+  }
+  finalizeWorkflowRun() {
+    throw new NotImplementedError("finalizeWorkflowRun");
+  }
+  appendWorkflowEvent() {
+    throw new NotImplementedError("appendWorkflowEvent");
+  }
+}
+function createPostgresLoopStorage(client) {
+  return new PostgresLoopStorage(client);
+}
 export {
   createSqliteLoopStorage,
   createPostgresStorage,
+  createPostgresLoopStorage,
   checksumStorageSql,
   Store,
   SqliteLoopStorage,
   PostgresStorage,
+  PostgresLoopStorage,
   POSTGRES_STORAGE_MIGRATIONS,
-  POSTGRES_MIGRATION_LEDGER_TABLE
+  POSTGRES_MIGRATION_LEDGER_TABLE,
+  NotImplementedError
 };