@hasna/loops 0.4.14 → 0.4.23

package/dist/serve/index.js

@@ -1204,6 +1204,175 @@ function discardWorkflowRunManifest(staged) {
   } catch {}
 }
 
+// src/lib/run-receipts.ts
+import { createHash as createHash2 } from "crypto";
+import { hostname } from "os";
+
+// src/lib/run-envelope.ts
+var ENVELOPE_EXCERPT_CHARS = 2048;
+var BLOCKED_STEP_ERROR_PREFIX = "blocked:";
+function boundedExcerpt(text, limit = ENVELOPE_EXCERPT_CHARS) {
+  if (!text)
+    return;
+  const scrubbed = scrubSecrets(text);
+  if (scrubbed.length <= limit * 2)
+    return scrubbed;
+  const omitted = scrubbed.length - limit * 2;
+  return `${scrubbed.slice(0, limit)}
+[... ${omitted} chars omitted ...]
+${scrubbed.slice(-limit)}`;
+}
+function summarizeOutput(stdout, stderr) {
+  return {
+    stdoutBytes: stdout ? Buffer.byteLength(stdout, "utf8") : 0,
+    stderrBytes: stderr ? Buffer.byteLength(stderr, "utf8") : 0,
+    stdoutExcerpt: boundedExcerpt(stdout),
+    stderrExcerpt: boundedExcerpt(stderr)
+  };
+}
+function summarizeExecutorResult(result) {
+  return {
+    ...summarizeOutput(result.stdout, result.stderr),
+    status: result.status,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs,
+    error: boundedExcerpt(result.error)
+  };
+}
+function isBlockedStepRun(step) {
+  return step?.status === "skipped" && (step.error?.startsWith(BLOCKED_STEP_ERROR_PREFIX) ?? false);
+}
+function summarizeWorkflowStepRun(step) {
+  return {
+    ...summarizeOutput(step.stdout, step.stderr),
+    stepId: step.stepId,
+    status: step.status,
+    exitCode: step.exitCode,
+    durationMs: step.durationMs,
+    error: boundedExcerpt(step.error),
+    blocked: isBlockedStepRun(step)
+  };
+}
+function workflowRunEnvelope(run, steps) {
+  return JSON.stringify({ workflowRun: run, steps: steps.map(summarizeWorkflowStepRun) }, null, 2);
+}
+
+// src/lib/run-receipts.ts
+var RUN_RECEIPT_SUMMARY_TEXT_CHARS = 4096;
+var RUN_RECEIPT_MAX_IDS = 100;
+var RUN_RECEIPT_MAX_EVIDENCE_PATHS = 100;
+var RUN_RECEIPT_MAX_PATH_CHARS = 1024;
+function canonicalJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function digestReceipt(receipt) {
+  return `sha256:${createHash2("sha256").update(canonicalJson(receipt)).digest("hex")}`;
+}
+function isoOrNull(value, label) {
+  if (value === undefined || value === null || value === "")
+    return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()))
+    throw new Error(`${label} must be a valid ISO date/time`);
+  return date.toISOString();
+}
+function nonEmpty(value, label) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    throw new Error(`${label} must be non-empty`);
+  return trimmed;
+}
+function normalizedStringArray(values, opts) {
+  const out = [];
+  const seen = new Set;
+  for (const raw of values ?? []) {
+    const value = String(raw).trim();
+    if (!value || seen.has(value))
+      continue;
+    seen.add(value);
+    out.push(opts.itemMax ? value.slice(0, opts.itemMax) : value);
+    if (out.length >= opts.max)
+      break;
+  }
+  if ((values?.length ?? 0) > opts.max) {
+    out.push(`[truncated ${values.length - opts.max} ${opts.label}]`);
+  }
+  return out;
+}
+function receiptMachine(input, opts) {
+  if (typeof input.machine === "string")
+    return nonEmpty(input.machine, "machine");
+  if (input.machine && typeof input.machine === "object")
+    return input.machine;
+  if (opts.loop?.machine)
+    return { ...opts.loop.machine };
+  if (typeof opts.defaultMachine === "string")
+    return nonEmpty(opts.defaultMachine, "machine");
+  if (opts.defaultMachine && typeof opts.defaultMachine === "object")
+    return opts.defaultMachine;
+  return hostname();
+}
+function normalizeSummary(input, run) {
+  const stdout = input.stdout ?? run?.stdout;
+  const stderr = input.stderr ?? run?.stderr;
+  const output = summarizeOutput(stdout, stderr);
+  const summaryInput = input.summary;
+  const provided = typeof summaryInput === "object" && summaryInput !== null ? summaryInput : {};
+  const text = typeof summaryInput === "string" ? boundedExcerpt(summaryInput, Math.floor(RUN_RECEIPT_SUMMARY_TEXT_CHARS / 2)) : typeof provided.text === "string" ? boundedExcerpt(provided.text, Math.floor(RUN_RECEIPT_SUMMARY_TEXT_CHARS / 2)) : undefined;
+  return {
+    text,
+    stdout_bytes: Number.isFinite(provided.stdout_bytes) ? Number(provided.stdout_bytes) : output.stdoutBytes,
+    stderr_bytes: Number.isFinite(provided.stderr_bytes) ? Number(provided.stderr_bytes) : output.stderrBytes,
+    stdout_excerpt: typeof provided.stdout_excerpt === "string" ? boundedExcerpt(provided.stdout_excerpt) : output.stdoutExcerpt,
+    stderr_excerpt: typeof provided.stderr_excerpt === "string" ? boundedExcerpt(provided.stderr_excerpt) : output.stderrExcerpt,
+    error: typeof provided.error === "string" ? boundedExcerpt(provided.error) : boundedExcerpt(input.error ?? run?.error),
+    duration_ms: Number.isFinite(provided.duration_ms) ? Number(provided.duration_ms) : input.duration_ms ?? run?.durationMs
+  };
+}
+function normalizeRunReceipt(input, opts = {}) {
+  const now = (opts.now ?? new Date).toISOString();
+  const run = opts.run;
+  const loopId = input.loop_id ?? run?.loopId ?? opts.loop?.id;
+  const normalized = {
+    loop_id: nonEmpty(loopId, "loop_id"),
+    run_id: nonEmpty(input.run_id ?? run?.id, "run_id"),
+    machine: receiptMachine(input, opts),
+    repo: nonEmpty(input.repo ?? opts.defaultRepo ?? targetRepo(opts.loop) ?? process.cwd(), "repo"),
+    task_ids: normalizedStringArray(input.task_ids, { max: RUN_RECEIPT_MAX_IDS, label: "task_ids" }),
+    knowledge_ids: normalizedStringArray(input.knowledge_ids, { max: RUN_RECEIPT_MAX_IDS, label: "knowledge_ids" }),
+    started_at: isoOrNull(input.started_at ?? run?.startedAt, "started_at"),
+    finished_at: isoOrNull(input.finished_at ?? run?.finishedAt, "finished_at"),
+    status: nonEmpty(input.status ?? run?.status, "status"),
+    exit_code: input.exit_code === undefined ? run?.exitCode ?? null : input.exit_code,
+    summary: normalizeSummary(input, run),
+    evidence_paths: normalizedStringArray(input.evidence_paths, {
+      max: RUN_RECEIPT_MAX_EVIDENCE_PATHS,
+      label: "evidence_paths",
+      itemMax: RUN_RECEIPT_MAX_PATH_CHARS
+    })
+  };
+  return {
+    ...normalized,
+    digest_id: input.digest_id?.trim() || digestReceipt(normalized),
+    created_at: opts.existing?.created_at ?? now,
+    updated_at: now
+  };
+}
+function targetRepo(loop) {
+  if (!loop)
+    return;
+  if (loop.target.type === "command")
+    return loop.target.cwd;
+  if (loop.target.type === "agent")
+    return loop.target.cwd;
+  return;
+}
+
 // src/lib/route/todos-cli.ts
 import { closeSync, mkdtempSync, openSync, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
@@ -1275,6 +1444,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,
@@ -1398,7 +1570,7 @@ function todosMutationSummary(result) {
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
 var LIVE_EXPIRED_RUN_GRACE_MS = 60000;
-var SCHEMA_USER_VERSION = 7;
+var SCHEMA_USER_VERSION = 8;
 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"]);
@@ -1454,6 +1626,25 @@ function rowToRun(row) {
     updatedAt: row.updated_at
   };
 }
+function rowToRunReceipt(row) {
+  return {
+    loop_id: row.loop_id,
+    run_id: row.run_id,
+    machine: JSON.parse(row.machine_json),
+    repo: row.repo,
+    task_ids: JSON.parse(row.task_ids_json),
+    knowledge_ids: JSON.parse(row.knowledge_ids_json),
+    digest_id: row.digest_id,
+    started_at: row.started_at,
+    finished_at: row.finished_at,
+    status: row.status,
+    exit_code: row.exit_code,
+    summary: JSON.parse(row.summary_json),
+    evidence_paths: JSON.parse(row.evidence_paths_json),
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
 function latestRunTime(row) {
   return row.finished_at ?? row.started_at ?? row.created_at;
 }
@@ -1517,6 +1708,7 @@ function rowToWorkflowWorkItem(row) {
     subjectRef: row.subject_ref,
     projectKey: row.project_key ?? undefined,
     projectGroup: row.project_group ?? undefined,
+    machineId: row.machine_id ?? undefined,
     routeScope: row.route_scope ?? undefined,
     priority: row.priority,
     status: row.status,
@@ -1674,6 +1866,7 @@ function scrubbedOrNull(value) {
   return value == null ? null : scrubSecrets(value);
 }
 var MAX_PERSISTED_RUN_OUTPUT_CHARS = 64 * 1024;
+var MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS = 64 * 1024;
 function clampPersistedRunOutput(value) {
   if (value == null || value.length <= MAX_PERSISTED_RUN_OUTPUT_CHARS)
     return value;
@@ -1688,6 +1881,42 @@ ${tail}`;
 function persistedRunOutput(value) {
   return clampPersistedRunOutput(scrubbedOrNull(value));
 }
+function clampTextToChars(value, maxChars, reason) {
+  if (value.length <= maxChars)
+    return value;
+  const marker = `
+...[truncated by ${reason}]...
+`;
+  const budget = Math.max(0, maxChars - marker.length);
+  const headLength = Math.ceil(budget / 2);
+  const tailLength = Math.floor(budget / 2);
+  return `${value.slice(0, headLength)}${marker}${value.slice(value.length - tailLength)}`;
+}
+function boundedWorkflowEventPayloadJson(scrubbedJson) {
+  if (scrubbedJson.length <= MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS)
+    return scrubbedJson;
+  const base = {
+    truncated: true,
+    originalChars: scrubbedJson.length,
+    maxChars: MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS,
+    preview: ""
+  };
+  const baseChars = JSON.stringify(base).length;
+  let previewBudget = Math.max(0, MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS - baseChars - 64);
+  while (true) {
+    const preview = clampTextToChars(scrubbedJson, previewBudget, "loops workflow-event payload retention");
+    const bounded = JSON.stringify({ ...base, preview });
+    if (bounded.length <= MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS || previewBudget === 0)
+      return bounded;
+    previewBudget = Math.max(0, previewBudget - (bounded.length - MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS) - 64);
+  }
+}
+function persistedWorkflowEventPayload(payload) {
+  if (payload == null)
+    return null;
+  const scrubbed = scrubSecretsDeep(payload);
+  return boundedWorkflowEventPayloadJson(scrubSecrets(JSON.stringify(scrubbed)));
+}
 function chmodIfExists(path, mode) {
   try {
     if (existsSync(path))
@@ -1805,6 +2034,17 @@ class Store {
           this.addColumnIfMissing("workflow_work_items", "route_scope", "TEXT");
           this.db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status)");
         }
+      },
+      {
+        id: "0009_run_receipts",
+        apply: () => this.createRunReceiptsSchema()
+      },
+      {
+        id: "0010_work_item_machine_id",
+        apply: () => {
+          this.addColumnIfMissing("workflow_work_items", "machine_id", "TEXT");
+          this.db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_work_items_machine ON workflow_work_items(machine_id, status)");
+        }
       }
     ];
   }
@@ -1866,6 +2106,28 @@ class Store {
       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 TABLE IF NOT EXISTS run_receipts (
+        run_id TEXT PRIMARY KEY,
+        loop_id TEXT NOT NULL,
+        machine_json TEXT NOT NULL,
+        repo TEXT NOT NULL,
+        task_ids_json TEXT NOT NULL,
+        knowledge_ids_json TEXT NOT NULL,
+        digest_id TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        status TEXT NOT NULL,
+        exit_code INTEGER,
+        summary_json TEXT NOT NULL,
+        evidence_paths_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_loop ON run_receipts(loop_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_repo ON run_receipts(repo, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_digest ON run_receipts(digest_id);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_status ON run_receipts(status, created_at DESC);
+
       CREATE TABLE IF NOT EXISTS daemon_lease (
         id TEXT PRIMARY KEY,
         pid INTEGER NOT NULL,
@@ -1952,6 +2214,7 @@ class Store {
         subject_ref TEXT NOT NULL,
         project_key TEXT,
         project_group TEXT,
+        machine_id TEXT,
         route_scope TEXT,
         priority INTEGER NOT NULL,
         status TEXT NOT NULL,
@@ -1970,10 +2233,10 @@ class Store {
       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);
-      -- idx_workflow_work_items_scope (route_scope, status) is created ONLY by
-      -- migration 0008_work_item_route_scope, never here: this baseline DDL
+      -- New-column indexes (route_scope, machine_id, etc.) are created ONLY by
+      -- their additive migrations, never here: this baseline DDL
       -- re-runs on EVERY open (0001 is not skip-guarded), and on a pre-0008
-      -- database the CREATE TABLE above is a no-op, so an index on route_scope
+      -- database the CREATE TABLE above is a no-op, so an index on a new column
       -- here would execute before the column exists and crash the open
       -- ("no such column: route_scope"). New columns may be folded into the
       -- CREATE TABLE (fresh-db only); their indexes must live in the migration.
@@ -2084,6 +2347,31 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_goal_runs_workflow_run ON goal_runs(workflow_run_id);
     `);
   }
+  createRunReceiptsSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS run_receipts (
+        run_id TEXT PRIMARY KEY,
+        loop_id TEXT NOT NULL,
+        machine_json TEXT NOT NULL,
+        repo TEXT NOT NULL,
+        task_ids_json TEXT NOT NULL,
+        knowledge_ids_json TEXT NOT NULL,
+        digest_id TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        status TEXT NOT NULL,
+        exit_code INTEGER,
+        summary_json TEXT NOT NULL,
+        evidence_paths_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_loop ON run_receipts(loop_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_repo ON run_receipts(repo, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_digest ON run_receipts(digest_id);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_status ON run_receipts(status, created_at DESC);
+    `);
+  }
   addColumnIfMissing(table, column, definition) {
     const columns = this.db.query(`PRAGMA table_info(${table})`).all();
     if (columns.some((c) => c.name === column))
@@ -2195,19 +2483,24 @@ class Store {
   }
   listLoops(opts = {}) {
     const limit = opts.limit ?? 200;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
+    if (opts.name != null) {
+      const rows2 = this.db.query("SELECT * FROM loops WHERE name = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.name, limit, offset);
+      return this.withLatestRunSummaries(rows2.map(rowToLoop));
+    }
     let rows;
     if (opts.status && opts.archived) {
-      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else if (opts.status && opts.includeArchived) {
-      rows = this.db.query("SELECT * FROM loops WHERE status = ? ORDER BY next_run_at ASC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loops WHERE status = ? ORDER BY next_run_at ASC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else if (opts.status) {
-      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else if (opts.archived) {
-      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT ? OFFSET ?").all(limit, offset);
     } else if (opts.includeArchived) {
-      rows = this.db.query("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT ? OFFSET ?").all(limit, offset);
     } else {
-      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ? OFFSET ?").all(limit, offset);
     }
     return this.withLatestRunSummaries(rows.map(rowToLoop));
   }
@@ -2885,10 +3178,10 @@ class Store {
     const id = genId();
     const status = input.status ?? "queued";
     this.db.query(`INSERT INTO workflow_work_items (id, route_key, idempotency_key, invocation_id, source_type, source_ref,
-          subject_ref, project_key, project_group, route_scope, priority, status, attempts, next_attempt_at, lease_expires_at,
+          subject_ref, project_key, project_group, machine_id, route_scope, priority, status, attempts, next_attempt_at, lease_expires_at,
           workflow_id, loop_id, workflow_run_id, last_reason, created_at, updated_at)
          VALUES ($id, $routeKey, $idempotencyKey, $invocationId, $sourceType, $sourceRef, $subjectRef,
-          $projectKey, $projectGroup, $routeScope, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
+          $projectKey, $projectGroup, $machineId, $routeScope, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
           $lastReason, $created, $updated)
          ON CONFLICT(route_key, idempotency_key) DO UPDATE SET
           invocation_id=excluded.invocation_id,
@@ -2897,6 +3190,10 @@ class Store {
           subject_ref=excluded.subject_ref,
           project_key=excluded.project_key,
           project_group=excluded.project_group,
+          machine_id=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.machine_id
+            ELSE excluded.machine_id
+          END,
           route_scope=excluded.route_scope,
           priority=excluded.priority,
           status=CASE
@@ -2939,6 +3236,7 @@ class Store {
       $subjectRef: input.subjectRef,
       $projectKey: input.projectKey ?? null,
       $projectGroup: input.projectGroup ?? null,
+      $machineId: input.machineId ?? null,
       $routeScope: input.routeScope ?? null,
       $priority: input.priority ?? 0,
       $status: status,
@@ -3448,7 +3746,7 @@ class Store {
            VALUES ($id, $workflowRunId, 1, 'created', NULL, $payload, $created)`).run({
         $id: genId(),
         $workflowRunId: runId,
-        $payload: JSON.stringify({
+        $payload: persistedWorkflowEventPayload({
           workflowId: input.workflow.id,
           workflowName: input.workflow.name,
           stepCount: input.workflow.steps.length,
@@ -3779,7 +4077,7 @@ class Store {
         $sequence: sequence,
         $eventType: eventType,
         $stepId: stepId ?? null,
-        $payload: payload ? JSON.stringify(payload) : null,
+        $payload: persistedWorkflowEventPayload(payload),
         $created: now
       });
       const event = this.db.query("SELECT * FROM workflow_events WHERE id = ?").get(id);
@@ -4102,18 +4400,93 @@ class Store {
   }
   listRuns(opts = {}) {
     const limit = opts.limit ?? 100;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
     let rows;
     if (opts.loopId && opts.status) {
-      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? AND status = ? ORDER BY created_at DESC LIMIT ?").all(opts.loopId, opts.status, limit);
+      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? AND status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.loopId, opts.status, limit, offset);
     } else if (opts.loopId) {
-      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? ORDER BY created_at DESC LIMIT ?").all(opts.loopId, limit);
+      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.loopId, limit, offset);
     } else if (opts.status) {
-      rows = this.db.query("SELECT * FROM loop_runs WHERE status = ? ORDER BY created_at DESC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loop_runs WHERE status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else {
-      rows = this.db.query("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
     }
     return rows.map(rowToRun);
   }
+  writeRunReceipt(input, opts = {}) {
+    const inputRunId = typeof input.run_id === "string" && input.run_id.trim() ? input.run_id : undefined;
+    const existing = inputRunId ? this.getRunReceipt(inputRunId) : undefined;
+    const run = inputRunId ? this.getRun(inputRunId) : undefined;
+    const loop = input.loop_id ? this.getLoop(input.loop_id) : run ? this.getLoop(run.loopId) : undefined;
+    const receipt = normalizeRunReceipt(input, { now: opts.now, run, loop, existing });
+    this.db.query(`INSERT INTO run_receipts (run_id, loop_id, machine_json, repo, task_ids_json, knowledge_ids_json, digest_id,
+          started_at, finished_at, status, exit_code, summary_json, evidence_paths_json, created_at, updated_at)
+         VALUES ($runId, $loopId, $machineJson, $repo, $taskIdsJson, $knowledgeIdsJson, $digestId,
+          $startedAt, $finishedAt, $status, $exitCode, $summaryJson, $evidencePathsJson, $createdAt, $updatedAt)
+         ON CONFLICT(run_id) DO UPDATE SET
+          loop_id=excluded.loop_id,
+          machine_json=excluded.machine_json,
+          repo=excluded.repo,
+          task_ids_json=excluded.task_ids_json,
+          knowledge_ids_json=excluded.knowledge_ids_json,
+          digest_id=excluded.digest_id,
+          started_at=excluded.started_at,
+          finished_at=excluded.finished_at,
+          status=excluded.status,
+          exit_code=excluded.exit_code,
+          summary_json=excluded.summary_json,
+          evidence_paths_json=excluded.evidence_paths_json,
+          updated_at=excluded.updated_at`).run({
+      $runId: receipt.run_id,
+      $loopId: receipt.loop_id,
+      $machineJson: JSON.stringify(receipt.machine),
+      $repo: receipt.repo,
+      $taskIdsJson: JSON.stringify(receipt.task_ids),
+      $knowledgeIdsJson: JSON.stringify(receipt.knowledge_ids),
+      $digestId: receipt.digest_id,
+      $startedAt: receipt.started_at,
+      $finishedAt: receipt.finished_at,
+      $status: receipt.status,
+      $exitCode: receipt.exit_code,
+      $summaryJson: JSON.stringify(receipt.summary),
+      $evidencePathsJson: JSON.stringify(receipt.evidence_paths),
+      $createdAt: receipt.created_at,
+      $updatedAt: receipt.updated_at
+    });
+    return this.getRunReceipt(receipt.run_id) ?? receipt;
+  }
+  getRunReceipt(runId) {
+    const row = this.db.query("SELECT * FROM run_receipts WHERE run_id = ?").get(runId);
+    return row ? rowToRunReceipt(row) : undefined;
+  }
+  listRunReceipts(opts = {}) {
+    const limit = opts.limit ?? 100;
+    const filters = [];
+    const params = [];
+    if (opts.loopId) {
+      filters.push("loop_id = ?");
+      params.push(opts.loopId);
+    }
+    if (opts.repo) {
+      filters.push("repo = ?");
+      params.push(opts.repo);
+    }
+    if (opts.status) {
+      filters.push("status = ?");
+      params.push(opts.status);
+    }
+    if (opts.taskId) {
+      filters.push("EXISTS (SELECT 1 FROM json_each(run_receipts.task_ids_json) WHERE value = ?)");
+      params.push(opts.taskId);
+    }
+    if (opts.knowledgeId) {
+      filters.push("EXISTS (SELECT 1 FROM json_each(run_receipts.knowledge_ids_json) WHERE value = ?)");
+      params.push(opts.knowledgeId);
+    }
+    const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+    const rows = this.db.query(`SELECT * FROM run_receipts ${where} ORDER BY created_at DESC LIMIT ?`).all(...params, limit);
+    return rows.map(rowToRunReceipt);
+  }
   deferLiveExpiredRun(id, now, opts = {}) {
     const updated = now.toISOString();
     const deferredUntil = new Date(now.getTime() + LIVE_EXPIRED_RUN_GRACE_MS).toISOString();
@@ -4272,6 +4645,9 @@ class Store {
     const runs = includeRuns ? this.db.query("SELECT * FROM loop_runs ORDER BY created_at ASC, id ASC").all().map(rowToRun) : [];
     return { schemaVersion: SCHEMA_USER_VERSION, workflows, loops, runs, checks: this.migrationChecks() };
   }
+  exportMigrationRunPage(opts) {
+    return this.db.query("SELECT * FROM loop_runs ORDER BY created_at ASC, id ASC LIMIT ? OFFSET ?").all(opts.limit, opts.offset).map(rowToRun);
+  }
   countTable(table) {
     const row = this.db.query(`SELECT COUNT(*) AS count FROM ${table}`).get();
     return row?.count ?? 0;
@@ -4596,7 +4972,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.14",
+  version: "0.4.23",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4706,7 +5082,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",
@@ -4716,7 +5091,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",
@@ -5093,6 +5469,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",
@@ -5283,6 +5703,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",
@@ -5310,54 +5758,205 @@ var loops_default = {
           }
         }
       }
-    }
-  },
-  components: {
-    schemas: {
-      Foundation: {
-        type: "object",
-        properties: {
-          status: {
-            type: "string"
-          },
-          version: {
-            type: "string"
-          },
-          mode: {
-            type: "string"
-          },
-          service: {
-            type: "string"
-          },
-          detail: {
-            type: "string"
+    },
+    "/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"
+              }
+            }
           }
         },
-        required: [
-          "status",
-          "version",
-          "mode"
-        ]
-      },
-      Loop: {
-        type: "object",
-        properties: {
-          id: {
-            type: "string"
-          },
-          name: {
-            type: "string"
+        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"
+            }
           },
-          description: {
-            type: "string",
-            nullable: true
+          {
+            name: "repo",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
           },
-          status: {
-            type: "string"
+          {
+            name: "taskId",
+            in: "query",
+            required: false,
+            schema: {
+              type: "string"
+            }
           },
-          schedule: {
-            type: "object",
-            additionalProperties: true
+          {
+            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",
@@ -5452,96 +6051,424 @@ var loops_default = {
             type: "string",
             nullable: true
           },
-          finishedAt: {
-            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
           }
         },
-        required: [
-          "id",
-          "loopId",
-          "status"
-        ]
+        additionalProperties: false
       },
-      LoopResponse: {
+      RunReceiptResponse: {
         type: "object",
         properties: {
           ok: {
             type: "boolean"
           },
-          loop: {
-            $ref: "#/components/schemas/Loop"
+          receipt: {
+            $ref: "#/components/schemas/RunReceipt"
           }
         },
         required: [
           "ok",
-          "loop"
+          "receipt"
         ]
       },
-      LoopListResponse: {
+      RunReceiptListResponse: {
         type: "object",
         properties: {
           ok: {
             type: "boolean"
           },
-          loops: {
+          receipts: {
             type: "array",
             items: {
-              $ref: "#/components/schemas/Loop"
+              $ref: "#/components/schemas/RunReceipt"
             }
           }
         },
         required: [
           "ok",
-          "loops"
+          "receipts"
         ]
       },
-      RunResponse: {
+      ImportInput: {
         type: "object",
+        description: "Batches of full rows to upsert by id. Any array may be omitted.",
         properties: {
-          ok: {
-            type: "boolean"
+          workflows: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: true
+            }
           },
-          run: {
-            $ref: "#/components/schemas/Run"
+          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)."
           }
-        },
-        required: [
-          "ok",
-          "run"
-        ]
+        }
       },
-      RunListResponse: {
+      ImportResponse: {
         type: "object",
         properties: {
           ok: {
             type: "boolean"
           },
-          runs: {
-            type: "array",
-            items: {
-              $ref: "#/components/schemas/Run"
-            }
+          imported: {
+            type: "object",
+            properties: {
+              workflows: {
+                type: "integer"
+              },
+              loops: {
+                type: "integer"
+              },
+              runs: {
+                type: "integer"
+              }
+            },
+            required: [
+              "workflows",
+              "loops",
+              "runs"
+            ]
+          },
+          skippedRunning: {
+            type: "integer"
           }
         },
         required: [
           "ok",
-          "runs"
+          "imported",
+          "skippedRunning"
         ]
       },
-      DeleteResponse: {
+      CountResponse: {
         type: "object",
         properties: {
           ok: {
             type: "boolean"
           },
-          deleted: {
-            type: "boolean"
+          count: {
+            type: "integer"
           }
         },
         required: [
           "ok",
-          "deleted"
+          "count"
         ]
       }
     },
@@ -5567,6 +6494,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) {
@@ -5677,6 +6605,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)
       });
     }
@@ -5691,10 +6620,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") {
@@ -5705,14 +6652,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: optionalBoolean2(ctx.url.searchParams.get("includeArchived")),
-      archived: optionalBoolean2(ctx.url.searchParams.get("archived"))
+      archived: optionalBoolean2(ctx.url.searchParams.get("archived")),
+      name: optionalString(ctx.url.searchParams.get("name"))
     });
     return ok({ loops: loops.map(publicLoop) });
   }
@@ -5721,6 +6699,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: optionalBoolean2(ctx.url.searchParams.get("includeArchived")),
+      archived: optionalBoolean2(ctx.url.searchParams.get("archived"))
+    });
+    return ok({ count });
+  }
   const id = segments[0];
   if (!id)
     return fail("not_found", 404);
@@ -5753,6 +6738,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) {
@@ -5788,11 +6937,16 @@ async function handleRunsRequest(ctx, segments) {
   }
   const storage = requireStorage(ctx.storage);
   const showOutput = optionalBoolean2(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 })) });
   }
@@ -5806,6 +6960,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);
@@ -5828,14 +7010,14 @@ async function handleRunnerRequest(ctx, segments) {
 }
 function runnerRecord(body) {
   const machineId = optionalString(body.machineId);
-  const hostname = optionalString(body.hostname);
-  const id = optionalString(body.runnerId) ?? machineId ?? hostname;
+  const hostname2 = optionalString(body.hostname);
+  const id = optionalString(body.runnerId) ?? machineId ?? hostname2;
   if (!id)
     throw Object.assign(new Error("runner_id_required"), { status: 422 });
   return {
     id,
     machineId,
-    hostname,
+    hostname: hostname2,
     labels: stringRecord(body.labels),
     capabilities: objectRecord(body.capabilities),
     lastSeenAt: new Date().toISOString()
@@ -6017,13 +7199,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)
@@ -6137,12 +7328,12 @@ if (import.meta.main && (import.meta.url.endsWith("api/index.ts") || import.meta
 }
 
 // src/lib/storage/postgres-schema.ts
-import { createHash as createHash2 } from "crypto";
+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:${createHash2("sha256").update(normalized).digest("hex")}`;
+  return `sha256:${createHash3("sha256").update(normalized).digest("hex")}`;
 }
 function migration(id, sql) {
   return Object.freeze({ id, sql: sql.trim(), checksum: checksumStorageSql(sql) });
@@ -6460,6 +7651,35 @@ CREATE INDEX IF NOT EXISTS idx_audit_events_action ON audit_events(action, creat
   migration("0004_work_item_route_scope", `
 ALTER TABLE workflow_work_items ADD COLUMN IF NOT EXISTS route_scope TEXT;
 CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status);
+    `),
+  migration("0005_run_receipts", `
+CREATE TABLE IF NOT EXISTS run_receipts (
+  run_id TEXT PRIMARY KEY,
+  loop_id TEXT NOT NULL,
+  machine_json JSONB NOT NULL,
+  repo TEXT NOT NULL,
+  task_ids_json JSONB NOT NULL,
+  knowledge_ids_json JSONB NOT NULL,
+  digest_id TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  status TEXT NOT NULL,
+  exit_code INTEGER,
+  summary_json JSONB NOT NULL,
+  evidence_paths_json JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_loop ON run_receipts(loop_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_repo ON run_receipts(repo, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_digest ON run_receipts(digest_id);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_status ON run_receipts(status, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_task_ids ON run_receipts USING GIN (task_ids_json);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_knowledge_ids ON run_receipts USING GIN (knowledge_ids_json);
+    `),
+  migration("0006_work_item_machine_id", `
+ALTER TABLE workflow_work_items ADD COLUMN IF NOT EXISTS machine_id TEXT;
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_machine ON workflow_work_items(machine_id, status);
     `)
 ]);
 
@@ -6738,6 +7958,9 @@ class NotImplementedError extends Error {
 }
 var TERMINAL_RUN_STATUSES2 = ["succeeded", "failed", "timed_out", "abandoned", "skipped"];
 var PRUNE_BATCH_SIZE2 = 400;
+function isUniqueViolation(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "23505";
+}
 var DEFAULT_RECOVERY_BATCH_LIMIT2 = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER2 = 5;
 
@@ -6869,19 +8092,22 @@ class PostgresLoopStorage {
   async listLoops(...args) {
     const opts = args[0] ?? {};
     const limit = opts.limit ?? 200;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
     let rows;
-    if (opts.status && opts.archived) {
-      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+    if (opts.name != null) {
+      rows = await this.client.many("SELECT * FROM loops WHERE name = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3", [opts.name, limit, offset]);
+    } else if (opts.status && opts.archived) {
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else if (opts.status && opts.includeArchived) {
-      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 ORDER BY next_run_at ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else if (opts.status) {
-      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else if (opts.archived) {
-      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT $1 OFFSET $2", [limit, offset]);
     } else if (opts.includeArchived) {
-      rows = await this.client.many("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT $1 OFFSET $2", [limit, offset]);
     } else {
-      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT $1 OFFSET $2", [limit, offset]);
     }
     return rows.map(rowToLoop);
   }
@@ -7012,6 +8238,172 @@ class PostgresLoopStorage {
     const row = await this.client.get(sql, params);
     return row?.count ?? 0;
   }
+  async upsertMigrationWorkflow(...args) {
+    const [workflow, opts = {}] = args;
+    const existing = await this.getWorkflow(workflow.id);
+    if (existing && !opts.replace)
+      return existing;
+    try {
+      await this.client.execute(`INSERT INTO workflow_specs (id, name, description, version, status, goal_json, steps_json, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,$5,$6::jsonb,$7::jsonb,$8,$9)
+         ON CONFLICT(id) DO UPDATE SET
+           name=EXCLUDED.name,
+           description=EXCLUDED.description,
+           version=EXCLUDED.version,
+           status=EXCLUDED.status,
+           goal_json=EXCLUDED.goal_json,
+           steps_json=EXCLUDED.steps_json,
+           created_at=EXCLUDED.created_at,
+           updated_at=EXCLUDED.updated_at`, [
+        workflow.id,
+        workflow.name,
+        workflow.description ?? null,
+        workflow.version,
+        workflow.status,
+        workflow.goal ? JSON.stringify(workflow.goal) : null,
+        JSON.stringify(workflow.steps),
+        workflow.createdAt,
+        workflow.updatedAt
+      ]);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        const owner = await this.client.get("SELECT * FROM workflow_specs WHERE name = $1 AND status = 'active' LIMIT 1", [workflow.name]);
+        if (owner)
+          return rowToWorkflow(owner);
+      }
+      throw error;
+    }
+    const imported = await this.getWorkflow(workflow.id);
+    if (!imported)
+      throw new Error(`workflow not found after migration import: ${workflow.id}`);
+    return imported;
+  }
+  async upsertMigrationLoop(...args) {
+    const [loop, opts = {}] = args;
+    const existing = await this.loadLoop(this.client, loop.id);
+    if (existing && !opts.replace)
+      return existing;
+    await this.client.execute(`INSERT INTO loops (id, name, description, status, archived_at, archived_from_status, schedule_json, target_json,
+        goal_json, machine_json, next_run_at, retry_scheduled_for, catch_up, catch_up_limit, overlap, max_attempts,
+        retry_delay_ms, lease_ms, expires_at, created_at, updated_at)
+       VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)
+       ON CONFLICT(id) DO UPDATE SET
+         name=EXCLUDED.name,
+         description=EXCLUDED.description,
+         status=EXCLUDED.status,
+         archived_at=EXCLUDED.archived_at,
+         archived_from_status=EXCLUDED.archived_from_status,
+         schedule_json=EXCLUDED.schedule_json,
+         target_json=EXCLUDED.target_json,
+         goal_json=EXCLUDED.goal_json,
+         machine_json=EXCLUDED.machine_json,
+         next_run_at=EXCLUDED.next_run_at,
+         retry_scheduled_for=EXCLUDED.retry_scheduled_for,
+         catch_up=EXCLUDED.catch_up,
+         catch_up_limit=EXCLUDED.catch_up_limit,
+         overlap=EXCLUDED.overlap,
+         max_attempts=EXCLUDED.max_attempts,
+         retry_delay_ms=EXCLUDED.retry_delay_ms,
+         lease_ms=EXCLUDED.lease_ms,
+         expires_at=EXCLUDED.expires_at,
+         created_at=EXCLUDED.created_at,
+         updated_at=EXCLUDED.updated_at`, [
+      loop.id,
+      loop.name,
+      loop.description ?? null,
+      loop.status,
+      loop.archivedAt ?? null,
+      loop.archivedFromStatus ?? null,
+      JSON.stringify(loop.schedule),
+      JSON.stringify(loop.target),
+      loop.goal ? JSON.stringify(loop.goal) : null,
+      loop.machine ? JSON.stringify(loop.machine) : null,
+      loop.nextRunAt ?? null,
+      loop.retryScheduledFor ?? null,
+      loop.catchUp,
+      loop.catchUpLimit,
+      loop.overlap,
+      loop.maxAttempts,
+      loop.retryDelayMs,
+      loop.leaseMs,
+      loop.expiresAt ?? null,
+      loop.createdAt,
+      loop.updatedAt
+    ]);
+    const imported = await this.loadLoop(this.client, loop.id);
+    if (!imported)
+      throw new Error(`loop not found after migration import: ${loop.id}`);
+    return imported;
+  }
+  async upsertMigrationRun(...args) {
+    const [run, opts = {}] = args;
+    if (run.status === "running")
+      throw new ValidationError(`cannot import running run ${run.id}`);
+    const existing = await this.loadRun(this.client, run.id);
+    if (existing && !opts.replace)
+      return existing;
+    try {
+      await this.client.execute(`INSERT INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+        claimed_by, claim_token, lease_expires_at, pid, pgid, process_started_at, exit_code, duration_ms,
+        stdout, stderr, error, goal_run_id, created_at, updated_at)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,NULL,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)
+       ON CONFLICT(id) DO UPDATE SET
+         loop_id=EXCLUDED.loop_id,
+         loop_name=EXCLUDED.loop_name,
+         scheduled_for=EXCLUDED.scheduled_for,
+         attempt=EXCLUDED.attempt,
+         status=EXCLUDED.status,
+         started_at=EXCLUDED.started_at,
+         finished_at=EXCLUDED.finished_at,
+         claimed_by=EXCLUDED.claimed_by,
+         claim_token=NULL,
+         lease_expires_at=EXCLUDED.lease_expires_at,
+         pid=EXCLUDED.pid,
+         pgid=EXCLUDED.pgid,
+         process_started_at=EXCLUDED.process_started_at,
+         exit_code=EXCLUDED.exit_code,
+         duration_ms=EXCLUDED.duration_ms,
+         stdout=EXCLUDED.stdout,
+         stderr=EXCLUDED.stderr,
+         error=EXCLUDED.error,
+         goal_run_id=EXCLUDED.goal_run_id,
+         created_at=EXCLUDED.created_at,
+         updated_at=EXCLUDED.updated_at`, [
+        run.id,
+        run.loopId,
+        run.loopName,
+        run.scheduledFor,
+        run.attempt,
+        run.status,
+        run.startedAt ?? null,
+        run.finishedAt ?? null,
+        run.claimedBy ?? null,
+        run.leaseExpiresAt ?? null,
+        run.pid ?? null,
+        run.pgid ?? null,
+        run.processStartedAt ?? null,
+        run.exitCode ?? null,
+        run.durationMs ?? null,
+        persistedRunOutput(run.stdout),
+        persistedRunOutput(run.stderr),
+        scrubbedOrNull(run.error),
+        run.goalRunId ?? null,
+        run.createdAt,
+        run.updatedAt
+      ]);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        const slot = await this.loadRunBySlot(this.client, run.loopId, run.scheduledFor);
+        if (slot)
+          return slot;
+      }
+      throw error;
+    }
+    const imported = await this.loadRun(this.client, run.id);
+    if (!imported)
+      throw new Error(`run not found after migration import: ${run.id}`);
+    return imported;
+  }
   async createSkippedRun(...args) {
     const [loop, scheduledFor, reason, opts = {}] = args;
     const now = nowIso();
@@ -7179,18 +8571,102 @@ class PostgresLoopStorage {
   async listRuns(...args) {
     const opts = args[0] ?? {};
     const limit = opts.limit ?? 100;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
     let rows;
     if (opts.loopId && opts.status) {
-      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 AND status = $2 ORDER BY created_at DESC LIMIT $3", [opts.loopId, opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 AND status = $2 ORDER BY created_at DESC LIMIT $3 OFFSET $4", [opts.loopId, opts.status, limit, offset]);
     } else if (opts.loopId) {
-      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.loopId, limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3", [opts.loopId, limit, offset]);
     } else if (opts.status) {
-      rows = await this.client.many("SELECT * FROM loop_runs WHERE status = $1 ORDER BY created_at DESC LIMIT $2", [opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else {
-      rows = await this.client.many("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT $1 OFFSET $2", [limit, offset]);
     }
     return rows.map(rowToRun);
   }
+  async writeRunReceipt(...args) {
+    const [input, opts = {}] = args;
+    const inputRunId = typeof input.run_id === "string" && input.run_id.trim() ? input.run_id : undefined;
+    const existing = inputRunId ? await this.getRunReceipt(inputRunId) : undefined;
+    const run = inputRunId ? await this.getRun(inputRunId) : undefined;
+    const loop = input.loop_id ? await this.getLoop(input.loop_id) : run ? await this.getLoop(run.loopId) : undefined;
+    const receipt = normalizeRunReceipt(input, { now: opts.now, run, loop, existing });
+    await this.client.execute(`INSERT INTO run_receipts (run_id, loop_id, machine_json, repo, task_ids_json, knowledge_ids_json, digest_id,
+        started_at, finished_at, status, exit_code, summary_json, evidence_paths_json, created_at, updated_at)
+       VALUES ($1,$2,$3::jsonb,$4,$5::jsonb,$6::jsonb,$7,$8,$9,$10,$11,$12::jsonb,$13::jsonb,$14,$15)
+       ON CONFLICT(run_id) DO UPDATE SET
+        loop_id=EXCLUDED.loop_id,
+        machine_json=EXCLUDED.machine_json,
+        repo=EXCLUDED.repo,
+        task_ids_json=EXCLUDED.task_ids_json,
+        knowledge_ids_json=EXCLUDED.knowledge_ids_json,
+        digest_id=EXCLUDED.digest_id,
+        started_at=EXCLUDED.started_at,
+        finished_at=EXCLUDED.finished_at,
+        status=EXCLUDED.status,
+        exit_code=EXCLUDED.exit_code,
+        summary_json=EXCLUDED.summary_json,
+        evidence_paths_json=EXCLUDED.evidence_paths_json,
+        updated_at=EXCLUDED.updated_at`, [
+      receipt.run_id,
+      receipt.loop_id,
+      JSON.stringify(receipt.machine),
+      receipt.repo,
+      JSON.stringify(receipt.task_ids),
+      JSON.stringify(receipt.knowledge_ids),
+      receipt.digest_id,
+      receipt.started_at,
+      receipt.finished_at,
+      receipt.status,
+      receipt.exit_code,
+      JSON.stringify(receipt.summary),
+      JSON.stringify(receipt.evidence_paths),
+      receipt.created_at,
+      receipt.updated_at
+    ]);
+    return await this.getRunReceipt(receipt.run_id) ?? receipt;
+  }
+  async getRunReceipt(...args) {
+    const row = await this.client.get("SELECT * FROM run_receipts WHERE run_id = $1", [args[0]]);
+    return row ? rowToRunReceipt(row) : undefined;
+  }
+  async listRunReceipts(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    const filters = [];
+    const params = [];
+    const next = () => `$${params.length + 1}`;
+    if (opts.loopId) {
+      const slot = next();
+      filters.push(`loop_id = ${slot}`);
+      params.push(opts.loopId);
+    }
+    if (opts.repo) {
+      const slot = next();
+      filters.push(`repo = ${slot}`);
+      params.push(opts.repo);
+    }
+    if (opts.status) {
+      const slot = next();
+      filters.push(`status = ${slot}`);
+      params.push(opts.status);
+    }
+    if (opts.taskId) {
+      const slot = next();
+      filters.push(`task_ids_json ? ${slot}`);
+      params.push(opts.taskId);
+    }
+    if (opts.knowledgeId) {
+      const slot = next();
+      filters.push(`knowledge_ids_json ? ${slot}`);
+      params.push(opts.knowledgeId);
+    }
+    const limitSlot = next();
+    params.push(limit);
+    const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+    const rows = await this.client.many(`SELECT * FROM run_receipts ${where} ORDER BY created_at DESC LIMIT ${limitSlot}`, params);
+    return rows.map(rowToRunReceipt);
+  }
   async countRuns(...args) {
     const status = args[0];
     const row = status ? await this.client.get("SELECT COUNT(*)::int AS count FROM loop_runs WHERE status = $1", [status]) : await this.client.get("SELECT COUNT(*)::int AS count FROM loop_runs", []);
@@ -7513,7 +8989,7 @@ var APP = "loops";
 function resolveDatabaseUrl2() {
   const dsn = process.env.HASNA_LOOPS_DATABASE_URL?.trim() || process.env.LOOPS_DATABASE_URL?.trim() || process.env.DATABASE_URL?.trim();
   if (!dsn) {
-    throw new Error("loops-serve requires a cloud database URL: set HASNA_LOOPS_DATABASE_URL (or LOOPS_DATABASE_URL / DATABASE_URL)");
+    throw new Error("loops-serve requires a self-hosted database URL: set HASNA_LOOPS_DATABASE_URL (or LOOPS_DATABASE_URL / DATABASE_URL)");
   }
   return dsn;
 }