@hasna/loops 0.4.0 → 0.4.2

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"]);
@@ -1573,6 +1573,13 @@ class Store {
           this.addColumnIfMissing("loop_runs", "pgid", "INTEGER");
           this.addColumnIfMissing("loop_runs", "process_started_at", "TEXT");
         }
+      },
+      {
+        id: "0007_run_claim_tokens",
+        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 +1621,7 @@ class Store {
         started_at TEXT,
         finished_at TEXT,
         claimed_by TEXT,
+        claim_token TEXT,
         lease_expires_at TEXT,
         pid INTEGER,
         pgid INTEGER,
@@ -1632,6 +1640,7 @@ class Store {
       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,
@@ -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(),
@@ -3962,6 +3979,273 @@ class Store {
     this.db.close();
   }
 }
+// package.json
+var package_default = {
+  name: "@hasna/loops",
+  version: "0.4.2",
+  description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    loops: "dist/cli/index.js",
+    "loops-daemon": "dist/daemon/index.js",
+    "loops-api": "dist/api/index.js",
+    "loops-runner": "dist/runner/index.js",
+    "loops-mcp": "dist/mcp/index.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./sdk": {
+      types: "./dist/sdk/index.d.ts",
+      import: "./dist/sdk/index.js"
+    },
+    "./mcp": {
+      types: "./dist/mcp/index.d.ts",
+      import: "./dist/mcp/index.js"
+    },
+    "./api": {
+      types: "./dist/api/index.d.ts",
+      import: "./dist/api/index.js"
+    },
+    "./runner": {
+      types: "./dist/runner/index.d.ts",
+      import: "./dist/runner/index.js"
+    },
+    "./mode": {
+      types: "./dist/lib/mode.d.ts",
+      import: "./dist/lib/mode.js"
+    },
+    "./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: [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "docs",
+    "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 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",
+    "test:boundary": "bun run scripts/no-private-cloud-boundary.mjs",
+    prepare: "test -d dist || bun run build",
+    "dev:cli": "bun run src/cli/index.ts",
+    "dev:daemon": "bun run src/daemon/index.ts",
+    prepublishOnly: "bun run build && bun run test:boundary"
+  },
+  keywords: [
+    "loops",
+    "scheduler",
+    "daemon",
+    "agents",
+    "claude",
+    "cursor",
+    "codewith",
+    "opencode",
+    "cli"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hasna/loops.git"
+  },
+  homepage: "https://github.com/hasna/loops#readme",
+  bugs: {
+    url: "https://github.com/hasna/loops/issues"
+  },
+  author: "Hasna <andrei@hasna.com>",
+  license: "Apache-2.0",
+  engines: {
+    bun: ">=1.0.0"
+  },
+  dependencies: {
+    "@hasna/events": "^0.1.9",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@openrouter/ai-sdk-provider": "2.9.1",
+    ai: "6.0.204",
+    commander: "^13.1.0",
+    zod: "4.4.3"
+  },
+  optionalDependencies: {
+    "@hasna/machines": "0.0.49"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    typescript: "^5.7.3"
+  },
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  }
+};
+
+// src/lib/version.ts
+function packageVersion() {
+  if (typeof package_default.version !== "string" || package_default.version.trim() === "")
+    throw new Error("package.json version is missing");
+  return package_default.version;
+}
+
+// src/lib/mode.ts
+var LOOP_DEPLOYMENT_MODES = ["local", "self_hosted", "cloud"];
+var MODE_ENV_KEYS = ["LOOPS_MODE", "HASNA_LOOPS_MODE"];
+var API_URL_ENV_KEYS = ["LOOPS_API_URL", "HASNA_LOOPS_API_URL"];
+var CLOUD_API_URL_ENV_KEYS = ["LOOPS_CLOUD_API_URL", "HASNA_LOOPS_CLOUD_API_URL"];
+var DATABASE_URL_ENV_KEYS = ["LOOPS_DATABASE_URL", "HASNA_LOOPS_DATABASE_URL"];
+var API_TOKEN_ENV_KEYS = ["LOOPS_API_TOKEN", "HASNA_LOOPS_API_TOKEN"];
+var CLOUD_TOKEN_ENV_KEYS = ["LOOPS_CLOUD_TOKEN", "HASNA_LOOPS_CLOUD_TOKEN"];
+var TOKEN_ENV_KEYS = [...API_TOKEN_ENV_KEYS, ...CLOUD_TOKEN_ENV_KEYS];
+function envValue(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
+  }
+  return;
+}
+function normalizeLoopDeploymentMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "local")
+    return "local";
+  if (normalized === "self_hosted" || normalized === "selfhosted")
+    return "self_hosted";
+  if (normalized === "cloud" || normalized === "saas")
+    return "cloud";
+  throw new Error(`unsupported OpenLoops deployment mode "${value}"; expected local, self_hosted, or cloud`);
+}
+function resolveLoopDeploymentMode(env = process.env) {
+  const explicitMode = envValue(env, MODE_ENV_KEYS);
+  if (explicitMode) {
+    return {
+      deploymentMode: normalizeLoopDeploymentMode(explicitMode.value),
+      source: explicitMode.key
+    };
+  }
+  const cloudApiUrl = envValue(env, CLOUD_API_URL_ENV_KEYS);
+  if (cloudApiUrl)
+    return { deploymentMode: "cloud", source: cloudApiUrl.key };
+  const apiUrl = envValue(env, API_URL_ENV_KEYS);
+  if (apiUrl)
+    return { deploymentMode: "self_hosted", source: apiUrl.key };
+  const databaseUrl = envValue(env, DATABASE_URL_ENV_KEYS);
+  if (databaseUrl)
+    return { deploymentMode: "self_hosted", source: databaseUrl.key };
+  return { deploymentMode: "local", source: "default" };
+}
+function loopControlPlaneConfig(env = process.env) {
+  return {
+    apiUrl: envValue(env, API_URL_ENV_KEYS)?.value,
+    cloudApiUrl: envValue(env, CLOUD_API_URL_ENV_KEYS)?.value,
+    databaseUrlPresent: Boolean(envValue(env, DATABASE_URL_ENV_KEYS)),
+    apiAuthTokenPresent: Boolean(envValue(env, API_TOKEN_ENV_KEYS)),
+    cloudAuthTokenPresent: Boolean(envValue(env, CLOUD_TOKEN_ENV_KEYS)),
+    authTokenPresent: Boolean(envValue(env, TOKEN_ENV_KEYS))
+  };
+}
+function sourceOfTruthForMode(mode) {
+  if (mode === "local")
+    return "local_sqlite";
+  if (mode === "self_hosted")
+    return "self_hosted_control_plane";
+  return "cloud_control_plane";
+}
+function displayControlPlaneUrl(value) {
+  if (!value)
+    return;
+  try {
+    const url = new URL(value);
+    const path = url.pathname === "/" ? "" : url.pathname.replace(/\/+$/g, "");
+    return `${url.origin}${path}`;
+  } catch {
+    return "[invalid-url]";
+  }
+}
+function buildDeploymentStatus(opts = {}) {
+  const env = opts.env ?? process.env;
+  const active = resolveLoopDeploymentMode(env);
+  const deploymentMode = opts.perspective ?? active.deploymentMode;
+  const config = loopControlPlaneConfig(env);
+  const rawApiUrl = deploymentMode === "cloud" ? config.cloudApiUrl : config.apiUrl;
+  const apiUrl = displayControlPlaneUrl(rawApiUrl);
+  const controlPlaneKind = deploymentMode === "local" ? "none" : deploymentMode;
+  const deploymentAuthTokenPresent = deploymentMode === "cloud" ? config.cloudAuthTokenPresent : deploymentMode === "self_hosted" ? config.apiAuthTokenPresent : false;
+  const controlPlaneConfigured = deploymentMode === "local" ? false : deploymentMode === "self_hosted" ? Boolean(config.apiUrl || config.databaseUrlPresent) : Boolean(config.cloudApiUrl && deploymentAuthTokenPresent);
+  const warnings = [];
+  if (deploymentMode === "self_hosted" && !controlPlaneConfigured) {
+    warnings.push("self_hosted mode needs LOOPS_API_URL or LOOPS_DATABASE_URL before it can become authoritative");
+  }
+  if (deploymentMode === "cloud" && config.apiUrl && !config.cloudApiUrl) {
+    warnings.push("LOOPS_API_URL selects self_hosted; cloud mode uses LOOPS_CLOUD_API_URL");
+  }
+  if (deploymentMode === "cloud" && !config.cloudApiUrl) {
+    warnings.push("cloud mode is a public contract until LOOPS_CLOUD_API_URL is configured");
+  }
+  if (deploymentMode === "cloud" && config.cloudApiUrl && !deploymentAuthTokenPresent) {
+    warnings.push("cloud mode needs LOOPS_CLOUD_TOKEN or HASNA_LOOPS_CLOUD_TOKEN before it can become ready");
+  }
+  if (opts.perspective && opts.perspective !== active.deploymentMode) {
+    warnings.push(`active deployment mode is ${active.deploymentMode}; this is the ${opts.perspective} perspective`);
+  }
+  return {
+    packageVersion: packageVersion(),
+    deploymentMode,
+    activeDeploymentMode: active.deploymentMode,
+    active: deploymentMode === active.deploymentMode,
+    deploymentModeSource: active.source,
+    sourceOfTruth: sourceOfTruthForMode(deploymentMode),
+    localStore: {
+      role: deploymentMode === "local" ? "authoritative" : "cache_and_spool"
+    },
+    controlPlane: {
+      kind: controlPlaneKind,
+      configured: controlPlaneConfigured,
+      apiUrl,
+      databaseUrlPresent: config.databaseUrlPresent,
+      authTokenPresent: deploymentAuthTokenPresent
+    },
+    runner: {
+      required: deploymentMode !== "local",
+      role: deploymentMode === "local" ? "daemon" : "control_plane_worker"
+    },
+    warnings
+  };
+}
+function deploymentStatusLine(status) {
+  const configured = status.controlPlane.kind === "none" ? "none" : String(status.controlPlane.configured);
+  const active = status.active ? "active" : `active=${status.activeDeploymentMode}`;
+  return [
+    `deploymentMode=${status.deploymentMode}`,
+    active,
+    `source=${status.deploymentModeSource}`,
+    `truth=${status.sourceOfTruth}`,
+    `local=${status.localStore.role}`,
+    `control_plane=${configured}`
+  ].join(" ");
+}
 
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -5545,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) {
@@ -7323,105 +7608,6 @@ async function tick(deps) {
   }
   return { claimed, completed, skipped, recovered, expired };
 }
-// package.json
-var package_default = {
-  name: "@hasna/loops",
-  version: "0.4.0",
-  description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
-  type: "module",
-  main: "dist/index.js",
-  types: "dist/index.d.ts",
-  bin: {
-    loops: "dist/cli/index.js",
-    "loops-daemon": "dist/daemon/index.js",
-    "loops-mcp": "dist/mcp/index.js"
-  },
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    },
-    "./sdk": {
-      types: "./dist/sdk/index.d.ts",
-      import: "./dist/sdk/index.js"
-    },
-    "./mcp": {
-      types: "./dist/mcp/index.d.ts",
-      import: "./dist/mcp/index.js"
-    },
-    "./storage": {
-      types: "./dist/lib/store.d.ts",
-      import: "./dist/lib/store.js"
-    }
-  },
-  files: [
-    "dist",
-    "README.md",
-    "CHANGELOG.md",
-    "docs",
-    "LICENSE"
-  ],
-  scripts: {
-    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/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",
-    prepare: "test -d dist || bun run build",
-    "dev:cli": "bun run src/cli/index.ts",
-    "dev:daemon": "bun run src/daemon/index.ts",
-    prepublishOnly: "bun run build"
-  },
-  keywords: [
-    "loops",
-    "scheduler",
-    "daemon",
-    "agents",
-    "claude",
-    "cursor",
-    "codewith",
-    "opencode",
-    "cli"
-  ],
-  repository: {
-    type: "git",
-    url: "git+https://github.com/hasna/loops.git"
-  },
-  homepage: "https://github.com/hasna/loops#readme",
-  bugs: {
-    url: "https://github.com/hasna/loops/issues"
-  },
-  author: "Hasna <andrei@hasna.com>",
-  license: "Apache-2.0",
-  engines: {
-    bun: ">=1.0.0"
-  },
-  dependencies: {
-    "@hasna/events": "^0.1.9",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openrouter/ai-sdk-provider": "2.9.1",
-    ai: "6.0.204",
-    commander: "^13.1.0",
-    zod: "4.4.3"
-  },
-  optionalDependencies: {
-    "@hasna/machines": "0.0.49"
-  },
-  devDependencies: {
-    "@types/bun": "latest",
-    typescript: "^5.7.3"
-  },
-  publishConfig: {
-    registry: "https://registry.npmjs.org",
-    access: "public"
-  }
-};
-
-// src/lib/version.ts
-function packageVersion() {
-  if (typeof package_default.version !== "string" || package_default.version.trim() === "")
-    throw new Error("package.json version is missing");
-  return package_default.version;
-}
 
 // src/mcp/index.ts
 var LOOP_STATUSES = ["active", "paused", "stopped", "expired"];
@@ -8141,15 +8327,15 @@ function openAutomationsRuntimeBinding(overrides = {}) {
     failCommand: "automations queue fail",
     eventHandoff: {
       envelopeCommand: "automations webhooks event",
-      handlerCommand: "loops events handle generic",
-      pipeExample: "automations --json webhooks event <route> --body-json '<json>' | loops --json events handle generic",
+      handlerCommand: "loops routes create generic",
+      pipeExample: "automations --json webhooks event <route> --body-json '<json>' | loops --json routes create generic",
       boundary: "Use only for explicit event-envelope workflow handoff. OpenAutomations still owns deterministic automation materialization and queue state; OpenLoops owns workflow invocation."
     },
     requiredEnvironment: ["HASNA_AUTOMATIONS_DIR"],
     guarantees: [
       "OpenAutomations owns automation specs, run materialization, queue state, DLQ, replay, idempotency, and approvals.",
       "OpenLoops may execute claimed actions through explicit command or SDK handoff only.",
-      "OpenLoops may consume exported event envelopes only through explicit events handle commands.",
+      "OpenLoops may consume exported event envelopes only through explicit routes create commands.",
       "Workers must complete or fail actions by action id and runner id so OpenAutomations can enforce queue leases."
     ],
     nonGoals: [
@@ -8167,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";
@@ -8251,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" })
     ]
@@ -8291,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"),
@@ -8421,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) {
@@ -8479,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(`
 `);
@@ -8542,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)};`,
@@ -8561,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 || '';",
@@ -8578,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}`);",
@@ -8707,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)}`,
@@ -8717,7 +9540,7 @@ function prHandoffCommand(opts) {
     "bun - <<'BUN'",
     PR_HANDOFF_SCRIPT,
     "BUN"
-  ].join(`
+  ].filter((line) => Boolean(line)).join(`
 `);
 }
 // src/lib/templates-custom.ts
@@ -9307,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
@@ -9324,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
@@ -9333,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",
@@ -9343,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 ?? ""
@@ -9429,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,
@@ -9439,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,
@@ -9460,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,
@@ -9477,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,
@@ -9497,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,
@@ -9508,6 +10336,7 @@ function renderTaskLifecycleWorkflow(input) {
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
     todosProjectPath,
+    todosDbPath,
     worktree: worktreeContextFragment(plan)
   };
   const handoffArtifactPath = prHandoffArtifactPath(plan, input.taskId);
@@ -9521,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.",
     "",
@@ -9531,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"),
@@ -9559,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
@@ -9568,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,
@@ -9578,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",
@@ -9592,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"),
@@ -9610,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"),
@@ -9625,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",
@@ -9850,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),
@@ -9914,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
     });
@@ -9955,6 +10788,7 @@ function renderLoopTemplate(id, values, opts = {}) {
 }
 // src/lib/hygiene.ts
 import { basename as basename4 } from "path";
+import { homedir as homedir4 } from "os";
 var PROVIDER_TOKENS = new Set([
   "codewith",
   "claude",
@@ -9969,11 +10803,14 @@ var PROVIDER_TOKENS = new Set([
 var REPO_GENERIC_TOKENS = new Set(["repo", "repoops"]);
 var CADENCE_SUFFIX_TOKENS = new Set(["hourly", "daily", "weekly", "monthly"]);
 var CADENCE_SUFFIX_PATTERN = /^(?:every-?)?\d+(?:s|m|h|d|w)$/;
+function userHome() {
+  return process.env.HOME || homedir4();
+}
 function slugify(value) {
   return value.normalize("NFKD").replace(/[^\w\s.-]/g, "-").replace(/[_\s.:/]+/g, "-").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
 }
 function repoSlugFromCwd(cwd) {
-  if (!cwd || cwd === process.env.HOME || cwd === "/home/hasna")
+  if (!cwd || cwd === userHome())
     return "";
   if (cwd.includes("/.hasna/loops/"))
     return "";
@@ -10156,7 +10993,7 @@ function commandText(loop) {
   return [loop.target.command, ...loop.target.args ?? []].join(" ");
 }
 function scriptNeedles(scriptsDir) {
-  const home = process.env.HOME ?? "/home/hasna";
+  const home = userHome();
   const normalized = scriptsDir.replace(/\/+$/g, "");
   const values = [
     normalized,
@@ -10174,7 +11011,7 @@ function scriptNeedles(scriptsDir) {
   return [...new Set(values)];
 }
 function buildScriptInventoryReport(store, opts = {}) {
-  const scriptsDir = opts.scriptsDir ?? `${process.env.HOME ?? "/home/hasna"}/.hasna/loops/scripts`;
+  const scriptsDir = opts.scriptsDir ?? `${userHome()}/.hasna/loops/scripts`;
   const needles = scriptNeedles(scriptsDir);
   const loops2 = managedLoops(store, { includeInactive: opts.includeInactive, includeStopped: true, limit: opts.limit });
   const scriptBacked = loops2.map((loop) => {
@@ -10210,6 +11047,7 @@ export {
   runDoctor,
   rollupSummary,
   resolveLoopMachine,
+  resolveLoopDeploymentMode,
   resolveGoalModel,
   renderTodosTaskWorkerVerifierWorkflow,
   renderLoopTemplate,
@@ -10222,8 +11060,10 @@ export {
   parseDuration,
   parseCron,
   openAutomationsRuntimeBinding,
+  normalizeLoopDeploymentMode,
   nextCronRun,
   loops,
+  loopControlPlaneConfig,
   listToolsForCli,
   listOpenMachines,
   listLoopTemplates,
@@ -10235,19 +11075,29 @@ export {
   executeTarget,
   executeLoopTarget,
   executeLoop,
+  deploymentStatusLine,
+  createSqliteLoopStorage,
+  createPostgresStorage,
   createLoopsMcpServer,
   computeNextAfter,
   classifyRunFailure,
+  checksumStorageSql,
   buildScriptInventoryReport,
   buildNameHygieneReport,
   buildHealthReport,
   buildDuplicateOverlapReport,
+  buildDeploymentStatus,
   ValidationError,
   TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID,
   Store,
+  SqliteLoopStorage,
+  PostgresStorage,
+  POSTGRES_STORAGE_MIGRATIONS,
+  POSTGRES_MIGRATION_LEDGER_TABLE,
   LoopsClient,
   LoopNotFoundError,
   LoopArchivedError,
+  LOOP_DEPLOYMENT_MODES,
   LOOPS_MCP_TOOLS,
   EVENT_WORKER_VERIFIER_TEMPLATE_ID,
   CodedError,