@hasna/loops 0.4.13 → 0.4.22

package/dist/api/index.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.13",
+  version: "0.4.22",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -12,6 +12,7 @@ var package_default = {
     loops: "dist/cli/index.js",
     "loops-daemon": "dist/daemon/index.js",
     "loops-api": "dist/api/index.js",
+    "loops-serve": "dist/serve/index.js",
     "loops-runner": "dist/runner/index.js",
     "loops-mcp": "dist/mcp/index.js"
   },
@@ -24,6 +25,14 @@ var package_default = {
       types: "./dist/sdk/index.d.ts",
       import: "./dist/sdk/index.js"
     },
+    "./sdk/http": {
+      types: "./dist/sdk/http.d.ts",
+      import: "./dist/sdk/http.js"
+    },
+    "./serve": {
+      types: "./dist/serve/index.d.ts",
+      import: "./dist/serve/index.js"
+    },
     "./mcp": {
       types: "./dist/mcp/index.d.ts",
       import: "./dist/mcp/index.js"
@@ -69,7 +78,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 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: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/serve/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/sdk/http.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/serve/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",
@@ -109,13 +118,16 @@ var package_default = {
     "@openrouter/ai-sdk-provider": "2.9.1",
     ai: "6.0.204",
     commander: "^13.1.0",
+    pg: "^8.13.1",
     zod: "4.4.3"
   },
   optionalDependencies: {
-    "@hasna/machines": "0.0.49"
+    "@hasna/machines": "0.0.49",
+    "@hasna/contracts": "^0.4.2"
   },
   devDependencies: {
     "@types/bun": "latest",
+    "@types/pg": "^8.11.10",
     typescript: "^5.7.3"
   },
   publishConfig: {
@@ -426,6 +438,9 @@ function publicRun(run, showOutput = false, opts = {}) {
     error: opts.redactError ? redact(run.error) : run.error
   };
 }
+function publicRunReceipt(receipt) {
+  return { ...receipt };
+}
 function publicExecutorResult(result, showOutput = false) {
   return {
     ...result,
@@ -815,11 +830,1194 @@ function scrubSecretsDeep(value) {
   }
   return value;
 }
+// openapi/loops.json
+var loops_default = {
+  openapi: "3.1.0",
+  info: {
+    title: "OpenLoops",
+    version: "0.4.14",
+    description: "OpenLoops self-hosted control-plane HTTP API (loops-serve). RDS-direct (Amendment A1). All /v1 routes require an API key (x-api-key or Authorization: Bearer) with a loops:* scope."
+  },
+  servers: [
+    {
+      url: "https://loops.hasna.xyz"
+    }
+  ],
+  paths: {
+    "/health": {
+      get: {
+        operationId: "healthCheck",
+        summary: "Liveness probe",
+        responses: {
+          "200": {
+            description: "alive",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/ready": {
+      get: {
+        operationId: "readyCheck",
+        summary: "Readiness probe (storage reachable + migrated)",
+        responses: {
+          "200": {
+            description: "ready",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          },
+          "503": {
+            description: "not ready",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/version": {
+      get: {
+        operationId: "getVersion",
+        summary: "Service version",
+        responses: {
+          "200": {
+            description: "version",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Foundation"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/loops": {
+      get: {
+        operationId: "listLoops",
+        summary: "List loops",
+        parameters: [
+          {
+            name: "status",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string",
+              enum: [
+                "active",
+                "paused",
+                "stopped",
+                "expired"
+              ]
+            }
+          },
+          {
+            name: "limit",
+            in: "query",
+            required: false,
+            schema: {
+              type: "integer"
+            }
+          },
+          {
+            name: "includeArchived",
+            in: "query",
+            required: false,
+            schema: {
+              type: "boolean"
+            }
+          },
+          {
+            name: "archived",
+            in: "query",
+            required: false,
+            schema: {
+              type: "boolean"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "loops",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LoopListResponse"
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "createLoop",
+        summary: "Create a loop",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/CreateLoopInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "created",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LoopResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/loops/count": {
+      get: {
+        operationId: "countLoops",
+        summary: "Count loops (total-row verification)",
+        parameters: [
+          {
+            name: "status",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "includeArchived",
+            in: "query",
+            required: false,
+            schema: {
+              type: "boolean"
+            }
+          },
+          {
+            name: "archived",
+            in: "query",
+            required: false,
+            schema: {
+              type: "boolean"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "count",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/CountResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/loops/{id}": {
+      get: {
+        operationId: "getLoop",
+        summary: "Get a loop by id",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "loop",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LoopResponse"
+                }
+              }
+            }
+          }
+        }
+      },
+      patch: {
+        operationId: "updateLoop",
+        summary: "Update a loop (status / schedule fields)",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/UpdateLoopInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "loop",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LoopResponse"
+                }
+              }
+            }
+          }
+        }
+      },
+      delete: {
+        operationId: "deleteLoop",
+        summary: "Delete a loop",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "deleted",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/DeleteResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/loops/{id}/archive": {
+      post: {
+        operationId: "archiveLoop",
+        summary: "Archive a loop",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "loop",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LoopResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/loops/{id}/unarchive": {
+      post: {
+        operationId: "unarchiveLoop",
+        summary: "Unarchive a loop",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "loop",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LoopResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/runs": {
+      get: {
+        operationId: "listRuns",
+        summary: "List runs",
+        parameters: [
+          {
+            name: "loopId",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "status",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "limit",
+            in: "query",
+            required: false,
+            schema: {
+              type: "integer"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "runs",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/RunListResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/runs/count": {
+      get: {
+        operationId: "countRuns",
+        summary: "Count runs (total-row verification)",
+        parameters: [
+          {
+            name: "status",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "count",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/CountResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/runs/{id}": {
+      get: {
+        operationId: "getRun",
+        summary: "Get a run by id",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "run",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/RunResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/import": {
+      post: {
+        operationId: "importRows",
+        summary: "Bulk id-preserving import (self-hosted backfill)",
+        description: "Upsert full workflow/loop/run rows by id (idempotent; ON CONFLICT(id) DO UPDATE). Preserves id, status, archived state, and timestamps. Applied FK-safe: workflows, then loops, then runs. Volatile running runs are skipped and reported.",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ImportInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "import counts",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/ImportResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/receipts": {
+      get: {
+        operationId: "listRunReceipts",
+        summary: "List run receipts",
+        parameters: [
+          {
+            name: "loopId",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "repo",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "taskId",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "knowledgeId",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "status",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "limit",
+            in: "query",
+            required: false,
+            schema: {
+              type: "integer"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "run receipts",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/RunReceiptListResponse"
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "writeRunReceipt",
+        summary: "Write a run receipt",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/WriteRunReceiptInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "run receipt",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/RunReceiptResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/receipts/{runId}": {
+      get: {
+        operationId: "getRunReceipt",
+        summary: "Get a run receipt by run id",
+        parameters: [
+          {
+            name: "runId",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "run receipt",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/RunReceiptResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  components: {
+    schemas: {
+      Foundation: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string"
+          },
+          version: {
+            type: "string"
+          },
+          mode: {
+            type: "string"
+          },
+          service: {
+            type: "string"
+          },
+          detail: {
+            type: "string"
+          }
+        },
+        required: [
+          "status",
+          "version",
+          "mode"
+        ]
+      },
+      Loop: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          name: {
+            type: "string"
+          },
+          description: {
+            type: "string",
+            nullable: true
+          },
+          status: {
+            type: "string"
+          },
+          schedule: {
+            type: "object",
+            additionalProperties: true
+          },
+          target: {
+            type: "object",
+            additionalProperties: true
+          },
+          nextRunAt: {
+            type: "string",
+            nullable: true
+          },
+          createdAt: {
+            type: "string"
+          },
+          updatedAt: {
+            type: "string"
+          }
+        },
+        required: [
+          "id",
+          "name",
+          "status"
+        ]
+      },
+      CreateLoopInput: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          description: {
+            type: "string"
+          },
+          schedule: {
+            type: "object",
+            additionalProperties: true
+          },
+          target: {
+            type: "object",
+            additionalProperties: true
+          }
+        },
+        required: [
+          "name",
+          "schedule",
+          "target"
+        ]
+      },
+      UpdateLoopInput: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: [
+              "active",
+              "paused",
+              "stopped",
+              "expired"
+            ]
+          },
+          nextRunAt: {
+            type: "string",
+            nullable: true
+          },
+          retryScheduledFor: {
+            type: "string",
+            nullable: true
+          },
+          expiresAt: {
+            type: "string",
+            nullable: true
+          }
+        }
+      },
+      Run: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string"
+          },
+          loopId: {
+            type: "string"
+          },
+          status: {
+            type: "string"
+          },
+          attempt: {
+            type: "integer"
+          },
+          scheduledFor: {
+            type: "string"
+          },
+          startedAt: {
+            type: "string",
+            nullable: true
+          },
+          finishedAt: {
+            type: "string",
+            nullable: true
+          }
+        },
+        required: [
+          "id",
+          "loopId",
+          "status"
+        ]
+      },
+      LoopResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          loop: {
+            $ref: "#/components/schemas/Loop"
+          }
+        },
+        required: [
+          "ok",
+          "loop"
+        ]
+      },
+      LoopListResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          loops: {
+            type: "array",
+            items: {
+              $ref: "#/components/schemas/Loop"
+            }
+          }
+        },
+        required: [
+          "ok",
+          "loops"
+        ]
+      },
+      RunResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          run: {
+            $ref: "#/components/schemas/Run"
+          }
+        },
+        required: [
+          "ok",
+          "run"
+        ]
+      },
+      RunListResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          runs: {
+            type: "array",
+            items: {
+              $ref: "#/components/schemas/Run"
+            }
+          }
+        },
+        required: [
+          "ok",
+          "runs"
+        ]
+      },
+      DeleteResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          deleted: {
+            type: "boolean"
+          }
+        },
+        required: [
+          "ok",
+          "deleted"
+        ]
+      },
+      RunReceiptMachine: {
+        oneOf: [
+          {
+            type: "string"
+          },
+          {
+            type: "object",
+            additionalProperties: true
+          }
+        ]
+      },
+      RunReceiptSummary: {
+        type: "object",
+        required: [
+          "stdout_bytes",
+          "stderr_bytes"
+        ],
+        properties: {
+          text: {
+            type: "string"
+          },
+          stdout_bytes: {
+            type: "integer",
+            minimum: 0
+          },
+          stderr_bytes: {
+            type: "integer",
+            minimum: 0
+          },
+          stdout_excerpt: {
+            type: "string"
+          },
+          stderr_excerpt: {
+            type: "string"
+          },
+          error: {
+            type: "string"
+          },
+          duration_ms: {
+            type: "integer",
+            minimum: 0
+          }
+        },
+        additionalProperties: false
+      },
+      RunReceipt: {
+        type: "object",
+        required: [
+          "loop_id",
+          "run_id",
+          "machine",
+          "repo",
+          "task_ids",
+          "knowledge_ids",
+          "digest_id",
+          "started_at",
+          "finished_at",
+          "status",
+          "exit_code",
+          "summary",
+          "evidence_paths",
+          "created_at",
+          "updated_at"
+        ],
+        properties: {
+          loop_id: {
+            type: "string"
+          },
+          run_id: {
+            type: "string"
+          },
+          machine: {
+            $ref: "#/components/schemas/RunReceiptMachine"
+          },
+          repo: {
+            type: "string"
+          },
+          task_ids: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          knowledge_ids: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          digest_id: {
+            type: "string"
+          },
+          started_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          finished_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          status: {
+            type: "string"
+          },
+          exit_code: {
+            type: "integer",
+            nullable: true
+          },
+          summary: {
+            $ref: "#/components/schemas/RunReceiptSummary"
+          },
+          evidence_paths: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          created_at: {
+            type: "string",
+            format: "date-time"
+          },
+          updated_at: {
+            type: "string",
+            format: "date-time"
+          }
+        },
+        additionalProperties: false
+      },
+      WriteRunReceiptInput: {
+        type: "object",
+        required: [
+          "run_id"
+        ],
+        properties: {
+          loop_id: {
+            type: "string"
+          },
+          run_id: {
+            type: "string"
+          },
+          machine: {
+            $ref: "#/components/schemas/RunReceiptMachine"
+          },
+          repo: {
+            type: "string"
+          },
+          task_ids: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          knowledge_ids: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          digest_id: {
+            type: "string"
+          },
+          started_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          finished_at: {
+            type: "string",
+            format: "date-time",
+            nullable: true
+          },
+          status: {
+            type: "string"
+          },
+          exit_code: {
+            type: "integer",
+            nullable: true
+          },
+          summary: {
+            oneOf: [
+              {
+                type: "string"
+              },
+              {
+                $ref: "#/components/schemas/RunReceiptSummary"
+              },
+              {
+                type: "null"
+              }
+            ]
+          },
+          evidence_paths: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          stdout: {
+            type: "string"
+          },
+          stderr: {
+            type: "string"
+          },
+          error: {
+            type: "string"
+          },
+          duration_ms: {
+            type: "integer",
+            minimum: 0
+          }
+        },
+        additionalProperties: false
+      },
+      RunReceiptResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          receipt: {
+            $ref: "#/components/schemas/RunReceipt"
+          }
+        },
+        required: [
+          "ok",
+          "receipt"
+        ]
+      },
+      RunReceiptListResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          receipts: {
+            type: "array",
+            items: {
+              $ref: "#/components/schemas/RunReceipt"
+            }
+          }
+        },
+        required: [
+          "ok",
+          "receipts"
+        ]
+      },
+      ImportInput: {
+        type: "object",
+        description: "Batches of full rows to upsert by id. Any array may be omitted.",
+        properties: {
+          workflows: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: true
+            }
+          },
+          loops: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: true
+            }
+          },
+          runs: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: true
+            }
+          },
+          replace: {
+            type: "boolean",
+            description: "Update existing rows whose id matches (default false: existing rows are left unchanged)."
+          }
+        }
+      },
+      ImportResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          imported: {
+            type: "object",
+            properties: {
+              workflows: {
+                type: "integer"
+              },
+              loops: {
+                type: "integer"
+              },
+              runs: {
+                type: "integer"
+              }
+            },
+            required: [
+              "workflows",
+              "loops",
+              "runs"
+            ]
+          },
+          skippedRunning: {
+            type: "integer"
+          }
+        },
+        required: [
+          "ok",
+          "imported",
+          "skippedRunning"
+        ]
+      },
+      CountResponse: {
+        type: "object",
+        properties: {
+          ok: {
+            type: "boolean"
+          },
+          count: {
+            type: "integer"
+          }
+        },
+        required: [
+          "ok",
+          "count"
+        ]
+      }
+    },
+    securitySchemes: {
+      apiKey: {
+        type: "apiKey",
+        in: "header",
+        name: "x-api-key"
+      }
+    }
+  },
+  security: [
+    {
+      apiKey: []
+    }
+  ]
+};
 
 // src/api/index.ts
+function openApiDocument() {
+  return { ...loops_default, info: { ...loops_default.info, version: packageVersion() } };
+}
 var program = new Command;
 var DEFAULT_BODY_LIMIT_BYTES = 64 * 1024;
 var DEFAULT_EVIDENCE_LIMIT_BYTES = 256 * 1024;
+var DEFAULT_IMPORT_LIMIT_BYTES = 32 * 1024 * 1024;
 var MIN_RUNNER_LEASE_MS = 1000;
 program.name("loops-api").description("OpenLoops self-hosted control-plane API foundation").version(packageVersion()).option("-j, --json", "print JSON");
 function wantsJson(opts) {
@@ -866,21 +2064,62 @@ function apiStatus() {
     status: buildDeploymentStatus({ perspective: "self_hosted" })
   };
 }
+function foundationMode() {
+  return buildDeploymentStatus({}).activeDeploymentMode;
+}
+function foundationEnvelope(status, extra = {}) {
+  return { status, version: packageVersion(), mode: foundationMode(), service: "loops", ...extra };
+}
 function createLoopsApiServer(opts = {}) {
   const host = opts.host ?? "127.0.0.1";
   const port = opts.port ?? 8787;
-  if (!isLocalBind(host) && !configuredAuthToken()) {
-    throw new Error("non-local loops-api binds require LOOPS_API_TOKEN or HASNA_LOOPS_API_TOKEN");
+  if (!isLocalBind(host) && !opts.authenticator && !configuredAuthToken()) {
+    throw new Error("non-local loops-serve binds require an API-key authenticator or LOOPS_API_TOKEN");
   }
+  const defaultReady = async () => {
+    if (!opts.storage)
+      return { ready: false, detail: "storage_unconfigured" };
+    try {
+      await opts.storage.listLoops({ limit: 1 });
+      return { ready: true };
+    } catch (error) {
+      return { ready: false, detail: error instanceof Error ? error.message : "storage_unreachable" };
+    }
+  };
+  const readyCheck = opts.readyCheck ?? defaultReady;
   return Bun.serve({
     hostname: host,
     port,
-    fetch(request) {
-      const unauthorized = authorizeRequest(request, host);
-      if (unauthorized)
-        return unauthorized;
+    idleTimeout: 60,
+    async fetch(request) {
       const url = new URL(request.url);
-      if (url.pathname === "/health" || url.pathname === "/status") {
+      if (request.method === "GET" && (url.pathname === "/health" || url.pathname === "/healthz")) {
+        return Response.json(foundationEnvelope("ok"));
+      }
+      if (request.method === "GET" && (url.pathname === "/version" || url.pathname === "/v1/version")) {
+        return Response.json(foundationEnvelope("ok"));
+      }
+      if (request.method === "GET" && (url.pathname === "/ready" || url.pathname === "/readyz")) {
+        const result = await readyCheck();
+        return Response.json(foundationEnvelope(result.ready ? "ready" : "not_ready", result.detail ? { detail: result.detail } : {}), { status: result.ready ? 200 : 503 });
+      }
+      if (request.method === "GET" && url.pathname === "/openapi.json") {
+        return Response.json(openApiDocument());
+      }
+      if (opts.authenticator) {
+        const decision = await opts.authenticator.authenticate(request.headers, {
+          method: request.method,
+          path: url.pathname
+        });
+        if (!decision.ok) {
+          return Response.json({ ok: false, error: decision.reason ?? "unauthorized", message: decision.message }, { status: decision.status || 401 });
+        }
+      } else {
+        const unauthorized = authorizeRequest(request, host);
+        if (unauthorized)
+          return unauthorized;
+      }
+      if (request.method === "GET" && url.pathname === "/status") {
         return Response.json(apiStatus());
       }
       return handleV1Request({
@@ -889,6 +2128,7 @@ function createLoopsApiServer(opts = {}) {
         storage: opts.storage,
         bodyLimitBytes: opts.bodyLimitBytes ?? DEFAULT_BODY_LIMIT_BYTES,
         evidenceLimitBytes: opts.evidenceLimitBytes ?? DEFAULT_EVIDENCE_LIMIT_BYTES,
+        importLimitBytes: opts.importLimitBytes ?? DEFAULT_IMPORT_LIMIT_BYTES,
         now: opts.now ?? (() => new Date)
       });
     }
@@ -903,10 +2143,28 @@ async function handleV1Request(ctx) {
   if (ctx.request.method === "GET" && segments[1] === "status")
     return Response.json(apiStatus());
   try {
+    if (segments[1] === "import")
+      return await handleImportRequest(ctx, segments.slice(2));
     if (segments[1] === "loops")
       return await handleLoopsRequest(ctx, segments.slice(2));
     if (segments[1] === "runs")
       return await handleRunsRequest(ctx, segments.slice(2));
+    if (segments[1] === "receipts")
+      return await handleReceiptsRequest(ctx, segments.slice(2));
+    if (segments[1] === "workflows")
+      return await handleWorkflowsRequest(ctx, segments.slice(2));
+    if (segments[1] === "workflow-runs")
+      return await handleWorkflowRunsRequest(ctx, segments.slice(2));
+    if (segments[1] === "work-items")
+      return await handleWorkItemsRequest(ctx, segments.slice(2));
+    if (segments[1] === "invocations")
+      return await handleInvocationsRequest(ctx, segments.slice(2));
+    if (segments[1] === "goals")
+      return await handleGoalsRequest(ctx, segments.slice(2));
+    if (segments[1] === "goal-runs")
+      return await handleGoalRunsRequest(ctx, segments.slice(2));
+    if (segments[1] === "history")
+      return await handleHistoryRequest(ctx, segments.slice(2));
     if (segments[1] === "runners")
       return await handleRunnerRequest(ctx, segments.slice(2));
     if (segments[1] === "leases" && segments[2] === "recover" && ctx.request.method === "POST") {
@@ -917,14 +2175,45 @@ async function handleV1Request(ctx) {
     return errorResponse(error);
   }
 }
+async function handleImportRequest(ctx, segments) {
+  if (segments.length !== 0 || ctx.request.method !== "POST")
+    return fail("not_found", 404);
+  const storage = requireStorage(ctx.storage);
+  const body = await readJsonBody(ctx.request, ctx.importLimitBytes);
+  const replace = body.replace === true;
+  const workflows = Array.isArray(body.workflows) ? body.workflows : [];
+  const loops = Array.isArray(body.loops) ? body.loops : [];
+  const runs = Array.isArray(body.runs) ? body.runs : [];
+  const imported = { workflows: 0, loops: 0, runs: 0 };
+  let skippedRunning = 0;
+  for (const workflow of workflows) {
+    await storage.upsertMigrationWorkflow(workflow, { replace });
+    imported.workflows += 1;
+  }
+  for (const loop of loops) {
+    await storage.upsertMigrationLoop(loop, { replace });
+    imported.loops += 1;
+  }
+  for (const run of runs) {
+    if (run.status === "running") {
+      skippedRunning += 1;
+      continue;
+    }
+    await storage.upsertMigrationRun(run, { replace });
+    imported.runs += 1;
+  }
+  return ok({ imported, skippedRunning });
+}
 async function handleLoopsRequest(ctx, segments) {
   const storage = requireStorage(ctx.storage);
   if (segments.length === 0 && ctx.request.method === "GET") {
     const loops = await storage.listLoops({
       status: optionalEnum(ctx.url.searchParams.get("status"), ["active", "paused", "stopped", "expired"]),
       limit: optionalLimit(ctx.url.searchParams.get("limit")),
+      offset: optionalOffset(ctx.url.searchParams.get("offset")),
       includeArchived: optionalBoolean(ctx.url.searchParams.get("includeArchived")),
-      archived: optionalBoolean(ctx.url.searchParams.get("archived"))
+      archived: optionalBoolean(ctx.url.searchParams.get("archived")),
+      name: optionalString(ctx.url.searchParams.get("name"))
     });
     return ok({ loops: loops.map(publicLoop) });
   }
@@ -933,6 +2222,13 @@ async function handleLoopsRequest(ctx, segments) {
     const loop = await storage.createLoop(body);
     return ok({ loop: publicLoop(loop) }, { status: 201 });
   }
+  if (segments.length === 1 && segments[0] === "count" && ctx.request.method === "GET") {
+    const count = await storage.countLoops(optionalEnum(ctx.url.searchParams.get("status"), ["active", "paused", "stopped", "expired"]), {
+      includeArchived: optionalBoolean(ctx.url.searchParams.get("includeArchived")),
+      archived: optionalBoolean(ctx.url.searchParams.get("archived"))
+    });
+    return ok({ count });
+  }
   const id = segments[0];
   if (!id)
     return fail("not_found", 404);
@@ -965,6 +2261,170 @@ async function handleLoopsRequest(ctx, segments) {
   if (segments.length === 2 && segments[1] === "unarchive" && ctx.request.method === "POST") {
     return ok({ loop: publicLoop(await storage.unarchiveLoop(id)) });
   }
+  if (segments.length === 2 && segments[1] === "rename" && ctx.request.method === "POST") {
+    const body = await readJsonBody(ctx.request, ctx.bodyLimitBytes);
+    const name = requiredString(body.name, "name");
+    return ok({ loop: publicLoop(await storage.renameLoop(id, name)) });
+  }
+  return fail("not_found", 404);
+}
+async function handleWorkflowsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const workflows = await storage.listWorkflows({
+      status: optionalEnum(ctx.url.searchParams.get("status"), ["active", "archived"]),
+      limit: optionalLimit(ctx.url.searchParams.get("limit")),
+      offset: optionalOffset(ctx.url.searchParams.get("offset"))
+    });
+    return ok({ workflows: workflows.map(publicWorkflow) });
+  }
+  if (segments.length === 0 && ctx.request.method === "POST") {
+    const body = await readJsonBody(ctx.request, ctx.bodyLimitBytes);
+    return ok({ workflow: publicWorkflow(await storage.createWorkflow(body)) }, { status: 201 });
+  }
+  if (segments.length === 1 && segments[0] === "count" && ctx.request.method === "GET") {
+    const count = await storage.countWorkflows({
+      status: optionalEnum(ctx.url.searchParams.get("status"), ["active", "archived"])
+    });
+    return ok({ count });
+  }
+  const id = segments[0];
+  if (!id)
+    return fail("not_found", 404);
+  if (segments.length === 1 && ctx.request.method === "GET") {
+    const workflow = await storage.getWorkflow(id);
+    if (!workflow)
+      return fail("workflow_not_found", 404);
+    return ok({ workflow: publicWorkflow(workflow) });
+  }
+  if (segments.length === 2 && segments[1] === "archive" && ctx.request.method === "POST") {
+    return ok({ workflow: publicWorkflow(await storage.archiveWorkflow(id)) });
+  }
+  return fail("not_found", 404);
+}
+async function handleWorkflowRunsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const runs = await storage.listWorkflowRuns({
+      workflowId: ctx.url.searchParams.get("workflowId") ?? undefined,
+      loopRunId: ctx.url.searchParams.get("loopRunId") ?? undefined,
+      limit: optionalLimit(ctx.url.searchParams.get("limit"))
+    });
+    return ok({ workflowRuns: runs.map(publicWorkflowRun) });
+  }
+  const id = segments[0];
+  if (!id)
+    return fail("not_found", 404);
+  if (segments.length === 1 && ctx.request.method === "GET") {
+    const run = await storage.getWorkflowRun(id);
+    if (!run)
+      return fail("workflow_run_not_found", 404);
+    return ok({ workflowRun: publicWorkflowRun(run) });
+  }
+  if (segments.length === 2 && segments[1] === "steps" && ctx.request.method === "GET") {
+    const steps = await storage.listWorkflowStepRuns(id);
+    return ok({ steps: steps.map((step) => publicWorkflowStepRun(step)) });
+  }
+  if (segments.length === 2 && segments[1] === "events" && ctx.request.method === "GET") {
+    const events = await storage.listWorkflowEvents(id, optionalLimit(ctx.url.searchParams.get("limit")) ?? 200);
+    return ok({ events: events.map(publicWorkflowEvent) });
+  }
+  if (segments.length === 2 && segments[1] === "recover" && ctx.request.method === "POST") {
+    const body = await readJsonBody(ctx.request, ctx.bodyLimitBytes);
+    const reason = optionalText(body.reason);
+    const result = reason === undefined ? await storage.recoverWorkflowRun(id) : await storage.recoverWorkflowRun(id, reason);
+    return ok({
+      workflowRun: publicWorkflowRun(result.run),
+      recoveredSteps: result.recoveredSteps.map((step) => publicWorkflowStepRun(step))
+    });
+  }
+  return fail("not_found", 404);
+}
+async function handleWorkItemsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const items = await storage.listWorkflowWorkItems({
+      status: optionalString(ctx.url.searchParams.get("status")),
+      routeKey: ctx.url.searchParams.get("routeKey") ?? undefined,
+      limit: optionalLimit(ctx.url.searchParams.get("limit"))
+    });
+    return ok({ workItems: items.map(publicWorkflowWorkItem) });
+  }
+  const id = segments[0];
+  if (!id)
+    return fail("not_found", 404);
+  if (segments.length === 1 && ctx.request.method === "GET") {
+    const item = await storage.getWorkflowWorkItem(id);
+    if (!item)
+      return fail("work_item_not_found", 404);
+    return ok({ workItem: publicWorkflowWorkItem(item) });
+  }
+  return fail("not_found", 404);
+}
+async function handleInvocationsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const invocations = await storage.listWorkflowInvocations({ limit: optionalLimit(ctx.url.searchParams.get("limit")) });
+    return ok({ invocations: invocations.map(publicWorkflowInvocation) });
+  }
+  const id = segments[0];
+  if (!id)
+    return fail("not_found", 404);
+  if (segments.length === 1 && ctx.request.method === "GET") {
+    const invocation = await storage.getWorkflowInvocation(id);
+    if (!invocation)
+      return fail("invocation_not_found", 404);
+    return ok({ invocation: publicWorkflowInvocation(invocation) });
+  }
+  return fail("not_found", 404);
+}
+async function handleGoalsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const goals = await storage.listGoals({
+      status: optionalString(ctx.url.searchParams.get("status")),
+      limit: optionalLimit(ctx.url.searchParams.get("limit"))
+    });
+    return ok({ goals: goals.map(publicGoal) });
+  }
+  const id = segments[0];
+  if (!id)
+    return fail("not_found", 404);
+  if (segments.length === 1 && ctx.request.method === "GET") {
+    const goal = await storage.getGoal(id);
+    if (!goal)
+      return fail("goal_not_found", 404);
+    return ok({ goal: publicGoal(goal) });
+  }
+  if (segments.length === 2 && segments[1] === "plan-nodes" && ctx.request.method === "GET") {
+    const nodes = await storage.listGoalPlanNodes(id);
+    return ok({ nodes });
+  }
+  return fail("not_found", 404);
+}
+async function handleGoalRunsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const runs = await storage.listGoalRuns({
+      goalId: ctx.url.searchParams.get("goalId") ?? undefined,
+      runId: ctx.url.searchParams.get("runId") ?? undefined,
+      limit: optionalLimit(ctx.url.searchParams.get("limit"))
+    });
+    return ok({ goalRuns: runs.map(publicGoalRun) });
+  }
+  return fail("not_found", 404);
+}
+async function handleHistoryRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  if (segments.length === 1 && segments[0] === "prune" && ctx.request.method === "POST") {
+    const body = await readJsonBody(ctx.request, ctx.bodyLimitBytes);
+    const history = await storage.pruneHistory({
+      maxAgeDays: optionalInteger(body.maxAgeDays),
+      keepPerLoop: optionalInteger(body.keepPerLoop),
+      dryRun: body.dryRun === undefined ? undefined : Boolean(body.dryRun)
+    });
+    return ok({ history });
+  }
   return fail("not_found", 404);
 }
 async function handleRunsRequest(ctx, segments) {
@@ -1000,11 +2460,16 @@ async function handleRunsRequest(ctx, segments) {
   }
   const storage = requireStorage(ctx.storage);
   const showOutput = optionalBoolean(ctx.url.searchParams.get("showOutput")) ?? false;
+  if (segments.length === 1 && id === "count" && ctx.request.method === "GET") {
+    const count = await storage.countRuns(optionalEnum(ctx.url.searchParams.get("status"), ["running", "succeeded", "failed", "timed_out", "abandoned", "skipped"]));
+    return ok({ count });
+  }
   if (segments.length === 0 && ctx.request.method === "GET") {
     const runs = await storage.listRuns({
       loopId: ctx.url.searchParams.get("loopId") ?? undefined,
       status: optionalEnum(ctx.url.searchParams.get("status"), ["running", "succeeded", "failed", "timed_out", "abandoned", "skipped"]),
-      limit: optionalLimit(ctx.url.searchParams.get("limit"))
+      limit: optionalLimit(ctx.url.searchParams.get("limit")),
+      offset: optionalOffset(ctx.url.searchParams.get("offset"))
     });
     return ok({ runs: runs.map((run) => publicRun(run, showOutput, { redactError: true })) });
   }
@@ -1018,6 +2483,34 @@ async function handleRunsRequest(ctx, segments) {
   }
   return fail("not_found", 404);
 }
+async function handleReceiptsRequest(ctx, segments) {
+  const storage = requireStorage(ctx.storage);
+  const id = segments[0];
+  if (segments.length === 0 && ctx.request.method === "GET") {
+    const receipts = await storage.listRunReceipts({
+      loopId: ctx.url.searchParams.get("loopId") ?? undefined,
+      repo: ctx.url.searchParams.get("repo") ?? undefined,
+      taskId: ctx.url.searchParams.get("taskId") ?? undefined,
+      knowledgeId: ctx.url.searchParams.get("knowledgeId") ?? undefined,
+      status: ctx.url.searchParams.get("status") ?? undefined,
+      limit: optionalLimit(ctx.url.searchParams.get("limit"))
+    });
+    return ok({ receipts: receipts.map(publicRunReceipt) });
+  }
+  if (segments.length === 0 && ctx.request.method === "POST") {
+    const body = await readJsonBody(ctx.request, ctx.evidenceLimitBytes);
+    return ok({ receipt: publicRunReceipt(await storage.writeRunReceipt(body)) }, { status: 201 });
+  }
+  if (!id)
+    return fail("not_found", 404);
+  if (segments.length === 1 && ctx.request.method === "GET") {
+    const receipt = await storage.getRunReceipt(id);
+    if (!receipt)
+      return fail("run_receipt_not_found", 404);
+    return ok({ receipt: publicRunReceipt(receipt) });
+  }
+  return fail("not_found", 404);
+}
 async function handleRunnerRequest(ctx, segments) {
   if (ctx.request.method !== "POST")
     return fail("not_found", 404);
@@ -1229,13 +2722,22 @@ async function readBodyText(request, limitBytes) {
 function runnerProtocolPending(message) {
   return fail("runner_protocol_pending", 501, { message });
 }
+var MAX_PAGE_LIMIT = 1000;
 function optionalLimit(value) {
   if (value == null || value === "")
     return;
   const limit = Number(value);
-  if (!Number.isInteger(limit) || limit < 1 || limit > 1000)
+  if (!Number.isInteger(limit) || limit < 1)
     throw Object.assign(new Error("invalid_limit"), { status: 422 });
-  return limit;
+  return Math.min(limit, MAX_PAGE_LIMIT);
+}
+function optionalOffset(value) {
+  if (value == null || value === "")
+    return;
+  const offset = Number(value);
+  if (!Number.isInteger(offset) || offset < 0)
+    throw Object.assign(new Error("invalid_offset"), { status: 422 });
+  return offset;
 }
 function optionalString(value) {
   if (value === undefined || value === null)
@@ -1341,13 +2843,14 @@ program.command("serve").description("serve the foundation health/status endpoin
   const server = createLoopsApiServer({ host, port });
   console.log(`loops-api listening on http://${server.hostname}:${server.port}`);
 });
-if (import.meta.main) {
+if (import.meta.main && (import.meta.url.endsWith("api/index.ts") || import.meta.url.endsWith("api/index.js"))) {
   main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   });
 }
 export {
+  openApiDocument,
   main,
   createLoopsApiServer,
   apiStatus