@hasna/loops 0.4.14 → 0.4.22

package/dist/api/index.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.14",
+  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",
@@ -113,7 +113,6 @@ var package_default = {
     bun: ">=1.0.0"
   },
   dependencies: {
-    "@hasna/contracts": "^0.4.1",
     "@hasna/events": "^0.1.9",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@openrouter/ai-sdk-provider": "2.9.1",
@@ -123,7 +122,8 @@ var package_default = {
     zod: "4.4.3"
   },
   optionalDependencies: {
-    "@hasna/machines": "0.0.49"
+    "@hasna/machines": "0.0.49",
+    "@hasna/contracts": "^0.4.2"
   },
   devDependencies: {
     "@types/bun": "latest",
@@ -438,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,
@@ -989,6 +992,50 @@ var loops_default = {
         }
       }
     },
+    "/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",
@@ -1179,6 +1226,34 @@ var loops_default = {
         }
       }
     },
+    "/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",
@@ -1206,6 +1281,157 @@ var loops_default = {
           }
         }
       }
+    },
+    "/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: {
@@ -1439,6 +1665,334 @@ var loops_default = {
           "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: {
@@ -1463,6 +2017,7 @@ function openApiDocument() {
 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) {
@@ -1573,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)
       });
     }
@@ -1587,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") {
@@ -1601,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) });
   }
@@ -1617,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);
@@ -1649,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) {
@@ -1684,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 })) });
   }
@@ -1702,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);
@@ -1913,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)