@hasna/loops 0.4.1 → 0.4.3

package/dist/index.js

@@ -1203,7 +1203,7 @@ function discardWorkflowRunManifest(staged) {
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
 var LIVE_EXPIRED_RUN_GRACE_MS = 60000;
-var SCHEMA_USER_VERSION = 6;
+var SCHEMA_USER_VERSION = 7;
 var TERMINAL_RUN_STATUSES = ["succeeded", "failed", "timed_out", "abandoned", "skipped"];
 var PRUNE_BATCH_SIZE = 400;
 var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "task-lifecycle", "event-worker-verifier"]);
@@ -1523,7 +1523,7 @@ class Store {
     }
     const applied = new Set(this.db.query("SELECT id FROM schema_migrations").all().map((row) => row.id));
     for (const migration of this.migrations()) {
-      if (!migration.baseline && applied.has(migration.id))
+      if (!migration.baseline && !migration.reapply && applied.has(migration.id))
         continue;
       migration.apply();
       if (!applied.has(migration.id)) {
@@ -1573,6 +1573,14 @@ class Store {
           this.addColumnIfMissing("loop_runs", "pgid", "INTEGER");
           this.addColumnIfMissing("loop_runs", "process_started_at", "TEXT");
         }
+      },
+      {
+        id: "0007_run_claim_tokens",
+        reapply: true,
+        apply: () => {
+          this.addColumnIfMissing("loop_runs", "claim_token", "TEXT");
+          this.db.exec("CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL");
+        }
       }
     ];
   }
@@ -1614,6 +1622,7 @@ class Store {
         started_at TEXT,
         finished_at TEXT,
         claimed_by TEXT,
+        claim_token TEXT,
         lease_expires_at TEXT,
         pid INTEGER,
         pgid INTEGER,
@@ -3503,6 +3512,7 @@ class Store {
   }
   claimRun(loop, scheduledFor, runnerId, now = new Date, opts = {}) {
     const startedAt = now.toISOString();
+    const claimToken = opts.claimToken ?? genId();
     this.db.exec("BEGIN IMMEDIATE");
     try {
       this.assertDaemonLeaseFence(opts, startedAt);
@@ -3525,12 +3535,13 @@ class Store {
             return;
           }
           const res3 = this.db.query(`UPDATE loop_runs SET status='running', started_at=$started, finished_at=NULL,
-               claimed_by=$claimedBy, lease_expires_at=$lease, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL,
+               claimed_by=$claimedBy, claim_token=$claimToken, lease_expires_at=$lease, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL,
                duration_ms=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
                WHERE id=$id AND status='running' AND lease_expires_at <= $now`).run({
             $id: existing.id,
             $started: startedAt,
             $claimedBy: runnerId,
+            $claimToken: claimToken,
             $lease: leaseExpiresAt,
             $updated: startedAt,
             $now: startedAt
@@ -3539,7 +3550,7 @@ class Store {
           if (res3.changes !== 1)
             return;
           const run3 = this.getRun(existing.id);
-          return run3 ? { run: run3, loop } : undefined;
+          return run3 ? { run: run3, loop, claimToken } : undefined;
         }
         if (existing.status === "succeeded" || existing.status === "skipped") {
           this.db.exec("COMMIT");
@@ -3547,7 +3558,7 @@ class Store {
         }
         const attempt = existing.attempt + 1;
         const res2 = this.db.query(`UPDATE loop_runs SET attempt=$attempt, status='running', started_at=$started, finished_at=NULL,
-             claimed_by=$claimedBy, lease_expires_at=$lease, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL,
+             claimed_by=$claimedBy, claim_token=$claimToken, lease_expires_at=$lease, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL,
              duration_ms=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
              WHERE id=$id
                AND status IN ('failed', 'timed_out', 'abandoned')
@@ -3556,6 +3567,7 @@ class Store {
           $attempt: attempt,
           $started: startedAt,
           $claimedBy: runnerId,
+          $claimToken: claimToken,
           $lease: leaseExpiresAt,
           $updated: startedAt,
           $maxAttempts: loop.maxAttempts
@@ -3564,12 +3576,12 @@ class Store {
         if (res2.changes !== 1)
           return;
         const run2 = this.getRun(existing.id);
-        return run2 ? { run: run2, loop } : undefined;
+        return run2 ? { run: run2, loop, claimToken } : undefined;
       }
       const id = genId();
       const res = this.db.query(`INSERT OR IGNORE 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 ($id, $loopId, $loopName, $scheduledFor, 1, 'running', $started, NULL, $claimedBy, $lease,
+            claimed_by, claim_token, lease_expires_at, pid, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+           VALUES ($id, $loopId, $loopName, $scheduledFor, 1, 'running', $started, NULL, $claimedBy, $claimToken, $lease,
             NULL, NULL, NULL, NULL, NULL, NULL, $created, $updated)`).run({
         $id: id,
         $loopId: loop.id,
@@ -3577,6 +3589,7 @@ class Store {
         $scheduledFor: scheduledFor,
         $started: startedAt,
         $claimedBy: runnerId,
+        $claimToken: claimToken,
         $lease: leaseExpiresAt,
         $created: startedAt,
         $updated: startedAt
@@ -3585,7 +3598,7 @@ class Store {
       if (res.changes !== 1)
         return;
       const run = this.getRun(id);
-      return run ? { run, loop } : undefined;
+      return run ? { run, loop, claimToken } : undefined;
     } catch (error) {
       try {
         this.db.exec("ROLLBACK");
@@ -3608,16 +3621,18 @@ class Store {
       $error: error ?? null,
       $updated: finishedAt,
       $claimedBy: opts.claimedBy ?? null,
+      $claimToken: opts.claimToken ?? null,
       $now: (opts.now ?? new Date).toISOString(),
       $daemonLeaseId: opts.daemonLeaseId ?? null
     };
     return this.transact(() => {
-      const res = opts.claimedBy ? this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
+      const res = opts.claimedBy ? this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, claim_token=NULL, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
                duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
                WHERE id=$id AND status='running' AND claimed_by=$claimedBy AND lease_expires_at > $now
+                 AND ($claimToken IS NULL OR claim_token=$claimToken)
                  AND ($daemonLeaseId IS NULL OR EXISTS (
                    SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
-                 ))`).run(params) : this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
+                 ))`).run(params) : this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, claim_token=NULL, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
                duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated WHERE id=$id`).run(params);
       const run = this.getRun(id);
       if (!run)
@@ -3645,11 +3660,13 @@ class Store {
     const expiresAt = new Date(now.getTime() + leaseMs).toISOString();
     const res = this.db.query(`UPDATE loop_runs SET lease_expires_at=$expires, updated_at=$updated
          WHERE id=$id AND status='running' AND claimed_by=$claimedBy AND lease_expires_at > $now
+           AND ($claimToken IS NULL OR claim_token=$claimToken)
            AND ($daemonLeaseId IS NULL OR EXISTS (
              SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
            ))`).run({
       $id: id,
       $claimedBy: claimedBy,
+      $claimToken: opts.claimToken ?? null,
       $expires: expiresAt,
       $updated: now.toISOString(),
       $now: now.toISOString(),
@@ -3965,7 +3982,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.1",
+  version: "0.4.3",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4005,6 +4022,22 @@ var package_default = {
     "./storage": {
       types: "./dist/lib/store.d.ts",
       import: "./dist/lib/store.js"
+    },
+    "./storage/contract": {
+      types: "./dist/lib/storage/contract.d.ts",
+      import: "./dist/lib/storage/contract.js"
+    },
+    "./storage/sqlite": {
+      types: "./dist/lib/storage/sqlite.d.ts",
+      import: "./dist/lib/storage/sqlite.js"
+    },
+    "./storage/postgres": {
+      types: "./dist/lib/storage/postgres.d.ts",
+      import: "./dist/lib/storage/postgres.js"
+    },
+    "./storage/postgres-schema": {
+      types: "./dist/lib/storage/postgres-schema.d.ts",
+      import: "./dist/lib/storage/postgres-schema.js"
     }
   },
   files: [
@@ -4015,7 +4048,7 @@ var package_default = {
     "LICENSE"
   ],
   scripts: {
-    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts src/lib/mode.ts --root src --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/api/index.js dist/runner/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
+    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts src/lib/mode.ts src/lib/storage/index.ts src/lib/storage/contract.ts src/lib/storage/sqlite.ts src/lib/storage/postgres.ts src/lib/storage/postgres-schema.ts --root src --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/api/index.js dist/runner/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
     "build:bin": "bun build src/cli/index.ts --compile --outfile dist/loops",
     typecheck: "tsc --noEmit",
     test: "bun test",
@@ -5796,11 +5829,12 @@ function publicLoop(loop) {
     target
   };
 }
-function publicRun(run, showOutput = false) {
+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
+    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) {
@@ -8319,6 +8353,627 @@ function openAutomationsRuntimeBinding(overrides = {}) {
     nonGoals: overrides.nonGoals ?? defaults.nonGoals
   };
 }
+
+// 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 createHash3 } from "crypto";
+var POSTGRES_MIGRATION_LEDGER_TABLE = "open_loops_schema_migrations";
+function checksumStorageSql(sql) {
+  const normalized = sql.trim().replace(/\r\n/g, `
+`);
+  return `sha256:${createHash3("sha256").update(normalized).digest("hex")}`;
+}
+function migration(id, sql) {
+  return Object.freeze({ id, sql: sql.trim(), checksum: checksumStorageSql(sql) });
+}
+var POSTGRES_STORAGE_MIGRATIONS = Object.freeze([
+  migration("0001_core_runtime", `
+CREATE TABLE IF NOT EXISTS loops (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL,
+  archived_at TIMESTAMPTZ,
+  archived_from_status TEXT,
+  schedule_json JSONB NOT NULL,
+  target_json JSONB NOT NULL,
+  goal_json JSONB,
+  machine_json JSONB,
+  next_run_at TIMESTAMPTZ,
+  retry_scheduled_for TIMESTAMPTZ,
+  catch_up TEXT NOT NULL,
+  catch_up_limit INTEGER NOT NULL,
+  overlap TEXT NOT NULL,
+  max_attempts INTEGER NOT NULL,
+  retry_delay_ms INTEGER NOT NULL,
+  lease_ms INTEGER NOT NULL,
+  expires_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_loops_status_next ON loops(status, next_run_at);
+CREATE INDEX IF NOT EXISTS idx_loops_name ON loops(name);
+
+CREATE TABLE IF NOT EXISTS loop_runs (
+  id TEXT PRIMARY KEY,
+  loop_id TEXT NOT NULL REFERENCES loops(id) ON DELETE CASCADE,
+  loop_name TEXT NOT NULL,
+  scheduled_for TIMESTAMPTZ NOT NULL,
+  attempt INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  claimed_by TEXT,
+  claim_token TEXT,
+  lease_expires_at TIMESTAMPTZ,
+  pid INTEGER,
+  pgid INTEGER,
+  process_started_at TIMESTAMPTZ,
+  exit_code INTEGER,
+  duration_ms INTEGER,
+  stdout TEXT,
+  stderr TEXT,
+  error TEXT,
+  goal_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(loop_id, scheduled_for)
+);
+CREATE INDEX IF NOT EXISTS idx_runs_loop ON loop_runs(loop_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_runs_status ON loop_runs(status);
+CREATE INDEX IF NOT EXISTS idx_runs_status_lease ON loop_runs(status, lease_expires_at);
+CREATE INDEX IF NOT EXISTS idx_runs_scheduled ON loop_runs(scheduled_for);
+CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS daemon_lease (
+  id TEXT PRIMARY KEY,
+  pid INTEGER NOT NULL,
+  hostname TEXT NOT NULL,
+  heartbeat_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+    `),
+  migration("0002_workflows_goals", `
+CREATE TABLE IF NOT EXISTS workflow_specs (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  version INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  goal_json JSONB,
+  steps_json JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_workflows_status_name ON workflow_specs(status, name);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflows_name_active ON workflow_specs(name) WHERE status = 'active';
+
+CREATE TABLE IF NOT EXISTS workflow_runs (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT NOT NULL REFERENCES workflow_specs(id) ON DELETE CASCADE,
+  workflow_name TEXT NOT NULL,
+  loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+  loop_run_id TEXT REFERENCES loop_runs(id) ON DELETE SET NULL,
+  invocation_id TEXT,
+  work_item_id TEXT,
+  scheduled_for TIMESTAMPTZ,
+  idempotency_key TEXT,
+  manifest_path TEXT,
+  status TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  duration_ms INTEGER,
+  error TEXT,
+  goal_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_runs_idempotency ON workflow_runs(workflow_id, idempotency_key) WHERE idempotency_key IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow_created ON workflow_runs(workflow_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_loop_run ON workflow_runs(loop_run_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_invocation ON workflow_runs(invocation_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_work_item ON workflow_runs(work_item_id);
+
+CREATE TABLE IF NOT EXISTS workflow_invocations (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT,
+  template_id TEXT,
+  source_kind TEXT NOT NULL,
+  source_id TEXT,
+  source_dedupe_key TEXT,
+  source_json JSONB NOT NULL,
+  subject_kind TEXT NOT NULL,
+  subject_id TEXT,
+  subject_path TEXT,
+  subject_url TEXT,
+  subject_json JSONB NOT NULL,
+  intent TEXT NOT NULL,
+  scope_json JSONB,
+  output_policy_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_invocations_source ON workflow_invocations(source_kind, source_id);
+CREATE INDEX IF NOT EXISTS idx_workflow_invocations_subject ON workflow_invocations(subject_kind, subject_id, subject_path);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_invocations_dedupe ON workflow_invocations(source_kind, source_dedupe_key) WHERE source_dedupe_key IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS workflow_work_items (
+  id TEXT PRIMARY KEY,
+  route_key TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  invocation_id TEXT NOT NULL REFERENCES workflow_invocations(id) ON DELETE CASCADE,
+  source_type TEXT NOT NULL,
+  source_ref TEXT NOT NULL,
+  subject_ref TEXT NOT NULL,
+  project_key TEXT,
+  project_group TEXT,
+  priority INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  attempts INTEGER NOT NULL,
+  next_attempt_at TIMESTAMPTZ,
+  lease_expires_at TIMESTAMPTZ,
+  workflow_id TEXT REFERENCES workflow_specs(id) ON DELETE SET NULL,
+  loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+  workflow_run_id TEXT REFERENCES workflow_runs(id) ON DELETE SET NULL,
+  last_reason TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(route_key, idempotency_key)
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_status_next ON workflow_work_items(status, next_attempt_at, priority DESC, created_at ASC);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_project ON workflow_work_items(project_key, status);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_group ON workflow_work_items(project_group, status);
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_invocation ON workflow_work_items(invocation_id);
+
+CREATE TABLE IF NOT EXISTS workflow_step_runs (
+  id TEXT PRIMARY KEY,
+  workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+  step_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  exit_code INTEGER,
+  pid INTEGER,
+  duration_ms INTEGER,
+  stdout TEXT,
+  stderr TEXT,
+  error TEXT,
+  account_profile TEXT,
+  account_tool TEXT,
+  goal_run_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(workflow_run_id, step_id)
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_run_sequence ON workflow_step_runs(workflow_run_id, sequence);
+CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_status ON workflow_step_runs(status);
+
+CREATE TABLE IF NOT EXISTS workflow_events (
+  id TEXT PRIMARY KEY,
+  workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+  sequence INTEGER NOT NULL,
+  event_type TEXT NOT NULL,
+  step_id TEXT,
+  payload_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(workflow_run_id, sequence)
+);
+CREATE INDEX IF NOT EXISTS idx_workflow_events_run_sequence ON workflow_events(workflow_run_id, sequence);
+
+CREATE TABLE IF NOT EXISTS goals (
+  id TEXT PRIMARY KEY,
+  plan_id TEXT NOT NULL,
+  objective TEXT NOT NULL,
+  status TEXT NOT NULL,
+  token_budget INTEGER,
+  tokens_used INTEGER NOT NULL,
+  time_used_seconds INTEGER NOT NULL,
+  auto_execute TEXT NOT NULL,
+  max_tokens INTEGER,
+  source_type TEXT,
+  source_id TEXT,
+  loop_id TEXT,
+  loop_run_id TEXT,
+  workflow_id TEXT,
+  workflow_run_id TEXT,
+  workflow_step_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_goals_status_updated ON goals(status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_goals_loop_run ON goals(loop_run_id);
+CREATE INDEX IF NOT EXISTS idx_goals_workflow_run ON goals(workflow_run_id);
+CREATE INDEX IF NOT EXISTS idx_goals_source ON goals(source_type, source_id);
+
+CREATE TABLE IF NOT EXISTS goal_plan_nodes (
+  id TEXT PRIMARY KEY,
+  goal_id TEXT NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+  plan_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  priority INTEGER NOT NULL,
+  objective TEXT NOT NULL,
+  status TEXT NOT NULL,
+  ready BOOLEAN NOT NULL,
+  token_budget INTEGER,
+  tokens_used INTEGER NOT NULL,
+  time_used_seconds INTEGER NOT NULL,
+  depends_on_json JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE(plan_id, key)
+);
+CREATE INDEX IF NOT EXISTS idx_goal_plan_nodes_goal_sequence ON goal_plan_nodes(goal_id, sequence);
+CREATE INDEX IF NOT EXISTS idx_goal_plan_nodes_status ON goal_plan_nodes(status);
+
+CREATE TABLE IF NOT EXISTS goal_runs (
+  id TEXT PRIMARY KEY,
+  goal_id TEXT NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+  plan_id TEXT NOT NULL,
+  loop_id TEXT,
+  loop_run_id TEXT,
+  workflow_id TEXT,
+  workflow_run_id TEXT,
+  workflow_step_id TEXT,
+  turn INTEGER NOT NULL,
+  phase TEXT NOT NULL,
+  status TEXT NOT NULL,
+  node_key TEXT,
+  tokens_used INTEGER NOT NULL,
+  evidence_json JSONB,
+  raw_response_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_goal_runs_goal_created ON goal_runs(goal_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_goal_runs_loop_run ON goal_runs(loop_run_id);
+CREATE INDEX IF NOT EXISTS idx_goal_runs_workflow_run ON goal_runs(workflow_run_id);
+    `),
+  migration("0003_remote_runners_and_audit", `
+CREATE TABLE IF NOT EXISTS runner_machines (
+  id TEXT PRIMARY KEY,
+  hostname TEXT NOT NULL,
+  labels_json JSONB NOT NULL DEFAULT '{}'::jsonb,
+  capabilities_json JSONB NOT NULL DEFAULT '{}'::jsonb,
+  status TEXT NOT NULL,
+  last_seen_at TIMESTAMPTZ NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_runner_machines_status_seen ON runner_machines(status, last_seen_at DESC);
+
+CREATE TABLE IF NOT EXISTS runner_leases (
+  id TEXT PRIMARY KEY,
+  runner_id TEXT NOT NULL REFERENCES runner_machines(id) ON DELETE CASCADE,
+  loop_run_id TEXT REFERENCES loop_runs(id) ON DELETE CASCADE,
+  workflow_run_id TEXT REFERENCES workflow_runs(id) ON DELETE CASCADE,
+  claim_token TEXT NOT NULL,
+  status TEXT NOT NULL,
+  heartbeat_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  CHECK (loop_run_id IS NOT NULL OR workflow_run_id IS NOT NULL)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_runner_leases_active_loop_run ON runner_leases(loop_run_id) WHERE loop_run_id IS NOT NULL AND status = 'active';
+CREATE UNIQUE INDEX IF NOT EXISTS idx_runner_leases_active_workflow_run ON runner_leases(workflow_run_id) WHERE workflow_run_id IS NOT NULL AND status = 'active';
+CREATE INDEX IF NOT EXISTS idx_runner_leases_runner_status ON runner_leases(runner_id, status, expires_at);
+CREATE INDEX IF NOT EXISTS idx_runner_leases_claim_token ON runner_leases(claim_token);
+
+CREATE TABLE IF NOT EXISTS audit_events (
+  id TEXT PRIMARY KEY,
+  actor TEXT NOT NULL,
+  action TEXT NOT NULL,
+  subject_type TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  metadata_json JSONB,
+  created_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_audit_events_subject ON audit_events(subject_type, subject_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_audit_events_action ON audit_events(action, created_at DESC);
+    `)
+]);
+
+// src/lib/storage/postgres.ts
+class PostgresStorage {
+  executor;
+  backend = "postgres";
+  migrations;
+  constructor(executor, migrations = POSTGRES_STORAGE_MIGRATIONS) {
+    this.executor = executor;
+    this.migrations = migrations;
+  }
+  async listAppliedMigrations() {
+    await this.ensureLedger();
+    return this.readAppliedMigrations();
+  }
+  async migrate(opts = {}) {
+    const dryRun = opts.dryRun === true;
+    if (!dryRun)
+      await this.ensureLedger();
+    const applied = dryRun ? await this.tryReadAppliedMigrations() : await this.readAppliedMigrations();
+    const knownMigrationIds = new Set(this.migrations.map((migration2) => migration2.id));
+    for (const row of applied) {
+      if (!knownMigrationIds.has(row.id)) {
+        throw new Error(`Postgres migration ${row.id} is not recognized by this binary`);
+      }
+    }
+    const appliedById = new Map(applied.map((row) => [row.id, row]));
+    const plan = this.migrations.map((migration2) => ({
+      migration: migration2,
+      state: appliedById.has(migration2.id) ? "already_applied" : "pending"
+    }));
+    for (const migration2 of this.migrations) {
+      const existing = appliedById.get(migration2.id);
+      if (existing && existing.checksum !== migration2.checksum) {
+        throw new Error(`Postgres migration checksum mismatch for ${migration2.id}`);
+      }
+    }
+    if (dryRun)
+      return { backend: this.backend, dryRun, applied, plan };
+    const run = async () => {
+      for (const item of plan) {
+        if (item.state === "already_applied")
+          continue;
+        await this.executor.execute(item.migration.sql);
+        await this.executor.execute(`INSERT INTO ${POSTGRES_MIGRATION_LEDGER_TABLE} (id, checksum, applied_at) VALUES ($1, $2, NOW())`, [item.migration.id, item.migration.checksum]);
+      }
+    };
+    if (this.executor.transaction)
+      await this.executor.transaction(run);
+    else
+      await run();
+    return {
+      backend: this.backend,
+      dryRun,
+      applied: await this.readAppliedMigrations(),
+      plan
+    };
+  }
+  async close() {
+    await this.executor.close?.();
+  }
+  async ensureLedger() {
+    await this.executor.execute(`
+CREATE TABLE IF NOT EXISTS ${POSTGRES_MIGRATION_LEDGER_TABLE} (
+  id TEXT PRIMARY KEY,
+  checksum TEXT NOT NULL,
+  applied_at TIMESTAMPTZ NOT NULL
+);
+    `);
+  }
+  async readAppliedMigrations() {
+    const rows = await this.executor.query(`SELECT id, checksum, applied_at FROM ${POSTGRES_MIGRATION_LEDGER_TABLE} ORDER BY id ASC`);
+    return rows.map((row) => ({
+      id: row.id,
+      checksum: row.checksum,
+      appliedAt: row.applied_at instanceof Date ? row.applied_at.toISOString() : row.applied_at
+    }));
+  }
+  async tryReadAppliedMigrations() {
+    try {
+      return await this.readAppliedMigrations();
+    } catch (error) {
+      if (isMissingLedgerError(error))
+        return [];
+      throw error;
+    }
+  }
+}
+function createPostgresStorage(executor) {
+  return new PostgresStorage(executor);
+}
+function isMissingLedgerError(error) {
+  if (!(error instanceof Error))
+    return false;
+  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/templates.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync6 } from "fs";
@@ -8403,6 +9058,7 @@ var BUILTIN_TEMPLATE_SUMMARIES = [
       { name: "taskTitle", description: "Human-readable task title." },
       projectPathVariable(),
       { name: "todosProjectPath", description: "Todos storage project path used in worker/verifier commands." },
+      { name: "todosDbPath", description: "Optional exact Todos DB path used via TODOS_DB_PATH/HASNA_TODOS_DB_PATH." },
       ...routeScopeVariables(),
       ...workerVerifierAgentVariables({ addDirs: true, branchNoun: "task/event" })
     ]
@@ -8443,6 +9099,8 @@ var BUILTIN_TEMPLATE_SUMMARIES = [
     variables: [
       { name: "taskId", required: true, description: "Todos task id." },
       projectPathVariable(),
+      { name: "todosProjectPath", description: "Todos storage project path used in lifecycle commands." },
+      { name: "todosDbPath", description: "Optional exact Todos DB path used via TODOS_DB_PATH/HASNA_TODOS_DB_PATH." },
       { name: "authProfilePool", description: "Comma-separated Codewith profiles for worker/verifier rotation." },
       roleAuthProfileVariable("triage"),
       roleAuthProfileVariable("planner"),
@@ -8573,28 +9231,29 @@ function verifierRuntimeGuidance(input) {
   ].join(`
 `);
 }
-function todosInspectLine(todosProjectPath, taskId) {
-  return `- Inspect first: todos --project ${todosProjectPath} inspect ${taskId}`;
+function todosInspectLine(todosProjectPath, taskId, todosDbPath) {
+  return `- Inspect first: ${todosCommand(todosProjectPath, todosDbPath)} inspect ${taskId}`;
 }
-function todosStartLine(todosProjectPath, taskId) {
-  return `- Claim/start if appropriate: todos --project ${todosProjectPath} start ${taskId}`;
+function todosStartLine(todosProjectPath, taskId, todosDbPath) {
+  return `- Claim/start if appropriate: ${todosCommand(todosProjectPath, todosDbPath)} start ${taskId}`;
 }
-function todosEvidenceLine(todosProjectPath, taskId, placeholder) {
-  return `- Record evidence: todos --project ${todosProjectPath} comment ${taskId} "<${placeholder}>"`;
+function todosEvidenceLine(todosProjectPath, taskId, placeholder, todosDbPath) {
+  return `- Record evidence: ${todosCommand(todosProjectPath, todosDbPath)} comment ${taskId} "<${placeholder}>"`;
 }
-function todosVerificationLine(todosProjectPath, taskId) {
-  return `- Record verification: todos --project ${todosProjectPath} comment ${taskId} "<verification evidence or blocker>"`;
+function todosVerificationLine(todosProjectPath, taskId, todosDbPath) {
+  return `- Record verification: ${todosCommand(todosProjectPath, todosDbPath)} comment ${taskId} "<verification evidence or blocker>"`;
 }
-function todosDoneLine(todosProjectPath, taskId) {
-  return `- If valid and complete: todos --project ${todosProjectPath} done ${taskId}`;
+function todosDoneLine(todosProjectPath, taskId, todosDbPath) {
+  return `- If valid and complete: ${todosCommand(todosProjectPath, todosDbPath)} done ${taskId}`;
 }
-function todosExactCommandsFragment(todosProjectPath, taskId, commandLines) {
+function todosExactCommandsFragment(todosProjectPath, taskId, commandLines, todosDbPath) {
   return [
     `Todos project path: ${todosProjectPath}`,
+    todosDbPath ? `Todos DB path: ${todosDbPath}` : undefined,
     "Use these exact todos commands so worktree cwd inference cannot attach to the wrong project:",
-    todosInspectLine(todosProjectPath, taskId),
+    todosInspectLine(todosProjectPath, taskId, todosDbPath),
     ...commandLines
-  ];
+  ].filter((line) => Boolean(line));
 }
 function worktreePrompt(plan) {
   if (plan.enabled) {
@@ -8631,10 +9290,19 @@ function worktreeContextFragment(plan) {
 function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function sourceTaskGateCommand(todosProjectPath, taskId) {
+function todosEnvPrefix(todosDbPath) {
+  return todosDbPath ? `TODOS_DB_PATH=${shellQuote2(todosDbPath)} HASNA_TODOS_DB_PATH=${shellQuote2(todosDbPath)} ` : "";
+}
+function todosCommand(todosProjectPath, todosDbPath) {
+  return `${todosEnvPrefix(todosDbPath)}todos --project ${todosProjectPath}`;
+}
+function shellTodosCommand(todosProjectPath, todosDbPath) {
+  return `${todosEnvPrefix(todosDbPath)}todos --project ${shellQuote2(todosProjectPath)}`;
+}
+function sourceTaskGateCommand(todosProjectPath, taskId, todosDbPath) {
   return [
     "set -euo pipefail",
-    `todos --project ${shellQuote2(todosProjectPath)} --json inspect ${shellQuote2(taskId)} >/dev/null`,
+    `${shellTodosCommand(todosProjectPath, todosDbPath)} --json inspect ${shellQuote2(taskId)} >/dev/null`,
     `printf "source task %s resolved in todos project %s\\n" ${shellQuote2(taskId)} ${shellQuote2(todosProjectPath)}`
   ].join(`
 `);
@@ -8694,10 +9362,10 @@ var LIFECYCLE_GATE_SCRIPT_TAIL = [
   "console.log(`task lifecycle ${stage} gate passed for ${task.id || task.taskId || 'task'} status=${status || 'unknown'}`);"
 ].join(`
 `);
-function lifecycleGateCommand(todosProjectPath, taskId, stage, goMarker, blockedMarker) {
+function lifecycleGateCommand(todosProjectPath, taskId, stage, goMarker, blockedMarker, todosDbPath) {
   return [
     "set -euo pipefail",
-    `task_json="$(todos --project ${shellQuote2(todosProjectPath)} --json inspect ${shellQuote2(taskId)})"`,
+    `task_json="$(${shellTodosCommand(todosProjectPath, todosDbPath)} --json inspect ${shellQuote2(taskId)})"`,
     `TASK_JSON="$task_json" STAGE=${shellQuote2(stage)} bun - <<'BUN'`,
     LIFECYCLE_GATE_SCRIPT_HEAD,
     `const goMarker = ${JSON.stringify(goMarker)};`,
@@ -8713,6 +9381,7 @@ var PR_HANDOFF_SCRIPT = [
   "const artifactPath = process.env.OPENLOOPS_PR_HANDOFF_ARTIFACT || '';",
   "const taskId = process.env.OPENLOOPS_PR_HANDOFF_TASK_ID || '';",
   "const todosProject = process.env.OPENLOOPS_PR_HANDOFF_TODOS_PROJECT || '';",
+  "const todosDbPath = process.env.OPENLOOPS_PR_HANDOFF_TODOS_DB_PATH || '';",
   "const fallbackWorktree = process.env.OPENLOOPS_PR_HANDOFF_WORKTREE || process.cwd();",
   "const expectedRoot = process.env.OPENLOOPS_PR_HANDOFF_WORKTREE_ROOT || fallbackWorktree;",
   "const expectedBranch = process.env.OPENLOOPS_PR_HANDOFF_EXPECTED_BRANCH || '';",
@@ -8730,7 +9399,8 @@ var PR_HANDOFF_SCRIPT = [
   "};",
   "const run = (command, args, options = {}) => spawnSync(command, args, { encoding: 'utf8', ...options });",
   "const todosArgs = (...args) => todosProject ? ['--project', todosProject, ...args] : args;",
-  "const todos = (...args) => run(todosBin, todosArgs(...args));",
+  "const todosEnv = todosDbPath ? { ...process.env, TODOS_DB_PATH: todosDbPath, HASNA_TODOS_DB_PATH: todosDbPath } : process.env;",
+  "const todos = (...args) => run(todosBin, todosArgs(...args), { env: todosEnv });",
   "const comment = (text) => {",
   "  const result = todos('comment', taskId, text);",
   "  if (result.status !== 0) console.error(`failed to comment original task: ${result.stderr || result.stdout || result.status}`);",
@@ -8859,6 +9529,7 @@ function prHandoffCommand(opts) {
     `export OPENLOOPS_PR_HANDOFF_ARTIFACT=${shellQuote2(opts.artifactPath)}`,
     `export OPENLOOPS_PR_HANDOFF_TASK_ID=${shellQuote2(opts.taskId)}`,
     `export OPENLOOPS_PR_HANDOFF_TODOS_PROJECT=${shellQuote2(opts.todosProjectPath)}`,
+    opts.todosDbPath ? `export OPENLOOPS_PR_HANDOFF_TODOS_DB_PATH=${shellQuote2(opts.todosDbPath)}` : undefined,
     `export OPENLOOPS_PR_HANDOFF_WORKTREE=${shellQuote2(opts.worktreeCwd)}`,
     `export OPENLOOPS_PR_HANDOFF_WORKTREE_ROOT=${shellQuote2(opts.worktreeRoot)}`,
     `export OPENLOOPS_PR_HANDOFF_EXPECTED_BRANCH=${shellQuote2(opts.expectedBranch)}`,
@@ -8869,7 +9540,7 @@ function prHandoffCommand(opts) {
     "bun - <<'BUN'",
     PR_HANDOFF_SCRIPT,
     "BUN"
-  ].join(`
+  ].filter((line) => Boolean(line)).join(`
 `);
 }
 // src/lib/templates-custom.ts
@@ -9459,12 +10130,12 @@ function commandStep(opts) {
     ...opts.blockedExitCodes ? { blockedExitCodes: opts.blockedExitCodes } : {}
   };
 }
-function sourceTaskGateStep(todosProjectPath, taskId, plan, description) {
+function sourceTaskGateStep(todosProjectPath, taskId, plan, description, todosDbPath) {
   return commandStep({
     id: "source-task-gate",
     name: "Source Task Gate",
     description,
-    command: sourceTaskGateCommand(todosProjectPath, taskId),
+    command: sourceTaskGateCommand(todosProjectPath, taskId, todosDbPath),
     cwd: plan.originalCwd,
     timeoutMs: 60000,
     blockedExitCodes: GATE_BLOCKED_EXIT_CODES
@@ -9476,7 +10147,7 @@ function lifecycleGateStep(opts) {
     name: opts.stage === "triage" ? "Triage Gate" : "Planner Gate",
     description: opts.description,
     dependsOn: opts.dependsOn,
-    command: lifecycleGateCommand(opts.todosProjectPath, opts.taskId, opts.stage, opts.goMarker, opts.blockedMarker),
+    command: lifecycleGateCommand(opts.todosProjectPath, opts.taskId, opts.stage, opts.goMarker, opts.blockedMarker, opts.todosDbPath),
     cwd: opts.plan.originalCwd,
     timeoutMs: 2 * 60000,
     blockedExitCodes: GATE_BLOCKED_EXIT_CODES
@@ -9485,7 +10156,7 @@ function lifecycleGateStep(opts) {
 function prHandoffArtifactPath(plan, taskId) {
   return join7(plan.cwd, ".openloops", "pr-handoff", `${slugSegment(taskId, "task")}.json`);
 }
-function prHandoffStep(input, plan, todosProjectPath) {
+function prHandoffStep(input, plan, todosProjectPath, todosDbPath) {
   return commandStep({
     id: "pr-handoff",
     name: "PR Handoff",
@@ -9495,6 +10166,7 @@ function prHandoffStep(input, plan, todosProjectPath) {
       artifactPath: prHandoffArtifactPath(plan, input.taskId),
       taskId: input.taskId,
       todosProjectPath,
+      todosDbPath,
       worktreeCwd: plan.cwd,
       worktreeRoot: plan.path ?? plan.cwd,
       expectedBranch: plan.branch ?? ""
@@ -9581,6 +10253,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
   const todosProjectPath = input.todosProjectPath ?? input.routeProjectPath ?? input.projectPath;
+  const todosDbPath = input.todosDbPath;
   const plan = worktreePlan(input, input.taskId);
   const taskContext = {
     taskId: input.taskId,
@@ -9591,15 +10264,17 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     projectPath: input.projectPath,
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
+    todosProjectPath: input.todosProjectPath ?? (input.todosDbPath ? todosProjectPath : undefined),
+    todosDbPath,
     worktree: worktreeContextFragment(plan)
   };
   const workerPrompt = [
     ...goalHeaderFragment(`Complete todos task ${input.taskId} in ${input.projectPath}.`, "worker", "task"),
     worktreePrompt(plan),
     ...todosExactCommandsFragment(todosProjectPath, input.taskId, [
-      todosStartLine(todosProjectPath, input.taskId),
-      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence and blockers")
-    ]),
+      todosStartLine(todosProjectPath, input.taskId, todosDbPath),
+      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence and blockers", todosDbPath)
+    ], todosDbPath),
     "Investigate first before changing files. Use the todos CLI as the source of truth for the task.",
     "Inspect the repository/project state, implement only the task scope, run focused validation, preserve unrelated user changes, and update the task with comments, evidence, changed files, commits, and blockers.",
     NO_TMUX_DISPATCH_FRAGMENT,
@@ -9612,9 +10287,9 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     ...goalHeaderFragment(`Verify todos task ${input.taskId} after the worker step.`, "verifier", "task"),
     worktreePrompt(plan),
     ...todosExactCommandsFragment(todosProjectPath, input.taskId, [
-      todosVerificationLine(todosProjectPath, input.taskId),
-      todosDoneLine(todosProjectPath, input.taskId)
-    ]),
+      todosVerificationLine(todosProjectPath, input.taskId, todosDbPath),
+      todosDoneLine(todosProjectPath, input.taskId, todosDbPath)
+    ], todosDbPath),
     adversarialReviewFragment("the task, repository state, commits, tests, and worker evidence", TASK_REVIEW_FOCUS),
     verifierRuntimeGuidance(input),
     TASK_VERIFIER_DECISION_FRAGMENT,
@@ -9629,7 +10304,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     description: `Task-triggered worker/verifier workflow for ${taskLabel(input)}`,
     version: 1,
     steps: [
-      sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before worker execution when the source todos task is not resolvable."),
+      sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before worker execution when the source todos task is not resolvable.", todosDbPath),
       ...workerVerifierSteps({
         input,
         seed: input.taskId,
@@ -9649,6 +10324,7 @@ function renderTaskLifecycleWorkflow(input) {
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
   const todosProjectPath = input.todosProjectPath ?? input.routeProjectPath ?? input.projectPath;
+  const todosDbPath = input.todosDbPath;
   const plan = worktreePlan(input, input.taskId);
   const taskContext = {
     taskId: input.taskId,
@@ -9660,6 +10336,7 @@ function renderTaskLifecycleWorkflow(input) {
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
     todosProjectPath,
+    todosDbPath,
     worktree: worktreeContextFragment(plan)
   };
   const handoffArtifactPath = prHandoffArtifactPath(plan, input.taskId);
@@ -9673,8 +10350,8 @@ function renderTaskLifecycleWorkflow(input) {
   const shared = [
     worktreePrompt(plan),
     ...todosExactCommandsFragment(todosProjectPath, input.taskId, [
-      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence, decision, or blocker")
-    ]),
+      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence, decision, or blocker", todosDbPath)
+    ], todosDbPath),
     NO_TMUX_DISPATCH_FRAGMENT,
     "Preserve unrelated user changes and keep scope tied to the task acceptance criteria.",
     "",
@@ -9683,7 +10360,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].join(`
 `);
   const gateMarker = (stage, state) => `openloops:${stage}=${state} task=${input.taskId}${input.eventId ? ` event=${input.eventId}` : ""}`;
-  const blockTaskCommand = `todos --project ${todosProjectPath} update ${input.taskId} --status blocked`;
+  const blockTaskCommand = `${todosEnvPrefix(todosDbPath)}todos --project ${todosProjectPath} update ${input.taskId} --status blocked`;
   const gateStopFragment = (stage, stops) => `The deterministic ${stage} gate will stop ${stops} unless the latest ${stage} marker is the exact go marker and the task has no blocked/completed/done/cancelled/failed/archived/no-auto/manual/approval-required state.`;
   const triagePrompt = [
     ...goalHeaderFragment(`Triage todos task ${input.taskId} for safe automated execution.`, "triage", "lifecycle"),
@@ -9711,7 +10388,7 @@ function renderTaskLifecycleWorkflow(input) {
   const workerPrompt = [
     ...goalHeaderFragment(`Complete todos task ${input.taskId} according to the planner evidence.`, "worker", "lifecycle"),
     shared,
-    todosStartLine(todosProjectPath, input.taskId),
+    todosStartLine(todosProjectPath, input.taskId, todosDbPath),
     "Read the triage and planner comments first. Implement only the scoped task, run focused validation, and record changed files, commits, evidence, blockers, and residual risks.",
     input.prHandoff ? `When only GitHub network access is blocked after a successful commit/validation, record the handoff artifact at ${handoffArtifactPath} instead of repeatedly retrying push/PR creation.` : undefined,
     WORKER_LEAVES_COMPLETION_FRAGMENT
@@ -9720,8 +10397,8 @@ function renderTaskLifecycleWorkflow(input) {
   const verifierPrompt = [
     ...goalHeaderFragment(`Verify todos task ${input.taskId} after the full lifecycle worker step.`, "verifier", "lifecycle"),
     shared,
-    todosVerificationLine(todosProjectPath, input.taskId),
-    todosDoneLine(todosProjectPath, input.taskId),
+    todosVerificationLine(todosProjectPath, input.taskId, todosDbPath),
+    todosDoneLine(todosProjectPath, input.taskId, todosDbPath),
     adversarialReviewFragment("triage, plan, worker evidence, repo state, commits, tests, and acceptance criteria", TASK_REVIEW_FOCUS),
     verifierRuntimeGuidance(input),
     input.prHandoff ? `If ${handoffArtifactPath} exists and there is no PR URL evidence, verify that the PR handoff step queued or completed a bounded handoff; leave the original task open or blocked until PR evidence is recorded.` : undefined,
@@ -9730,7 +10407,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].filter(Boolean).join(`
 `);
   const steps = [
-    sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before lifecycle agents execute when the source todos task is not resolvable."),
+    sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before lifecycle agents execute when the source todos task is not resolvable.", todosDbPath),
     {
       id: "triage",
       name: "Triage",
@@ -9744,6 +10421,7 @@ function renderTaskLifecycleWorkflow(input) {
       description: "Stop the lifecycle before planning when triage blocked or disallowed automation.",
       dependsOn: ["triage"],
       todosProjectPath,
+      todosDbPath,
       taskId: input.taskId,
       goMarker: gateMarker("triage", "go"),
       blockedMarker: gateMarker("triage", "blocked"),
@@ -9762,6 +10440,7 @@ function renderTaskLifecycleWorkflow(input) {
       description: "Stop the lifecycle before implementation when planning blocked or disallowed automation.",
       dependsOn: ["planner"],
       todosProjectPath,
+      todosDbPath,
       taskId: input.taskId,
       goMarker: gateMarker("planner", "go"),
       blockedMarker: gateMarker("planner", "blocked"),
@@ -9777,7 +10456,7 @@ function renderTaskLifecycleWorkflow(input) {
     }
   ];
   if (input.prHandoff) {
-    steps.push(prHandoffStep(input, plan, todosProjectPath));
+    steps.push(prHandoffStep(input, plan, todosProjectPath, todosDbPath));
   }
   steps.push({
     id: "verifier",
@@ -10002,6 +10681,7 @@ function renderLifecycleBoundedTemplate(id, values) {
       taskTitle: values.taskTitle,
       taskDescription: values.taskDescription,
       todosProjectPath: values.todosProjectPath ?? values.todosProject,
+      todosDbPath: values.todosDbPath,
       triageAuthProfile: values.triageAuthProfile,
       plannerAuthProfile: values.plannerAuthProfile,
       triageAccount: accountVar(values.triageAccount, values.accountTool),
@@ -10066,6 +10746,7 @@ function renderBuiltinLoopTemplate(id, values) {
       taskTitle: values.taskTitle,
       taskDescription: values.taskDescription,
       todosProjectPath: values.todosProjectPath ?? values.todosProject,
+      todosDbPath: values.todosDbPath,
       eventId: values.eventId,
       eventType: values.eventType
     });
@@ -10395,9 +11076,12 @@ export {
   executeLoopTarget,
   executeLoop,
   deploymentStatusLine,
+  createSqliteLoopStorage,
+  createPostgresStorage,
   createLoopsMcpServer,
   computeNextAfter,
   classifyRunFailure,
+  checksumStorageSql,
   buildScriptInventoryReport,
   buildNameHygieneReport,
   buildHealthReport,
@@ -10406,6 +11090,10 @@ export {
   ValidationError,
   TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID,
   Store,
+  SqliteLoopStorage,
+  PostgresStorage,
+  POSTGRES_STORAGE_MIGRATIONS,
+  POSTGRES_MIGRATION_LEDGER_TABLE,
   LoopsClient,
   LoopNotFoundError,
   LoopArchivedError,