@hasna/loops 0.4.13 → 0.4.22

package/dist/lib/storage/index.js

@@ -1,9 +1,9 @@
 // @bun
 // src/lib/store.ts
 import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname2, join as join3 } from "path";
+import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 
 // src/lib/errors.ts
 class CodedError extends Error {
@@ -1202,15 +1202,378 @@ 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";
+import { join as join3 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
+
+// src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
+var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
+function redact(value, visible = 0) {
+  if (!value)
+    return value;
+  if (value.length <= visible)
+    return value;
+  if (visible <= 0)
+    return `[redacted ${value.length} chars]`;
+  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+}
+function truncateTextOutput(value) {
+  if (value.length <= TEXT_OUTPUT_LIMIT)
+    return value;
+  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
+[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+}
+function redactSensitivePayload(value, key) {
+  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
+    if (typeof value === "string")
+      return redact(value);
+    if (value === undefined || value === null)
+      return value;
+    return "[redacted]";
+  }
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitivePayload(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+  }
+  return value;
+}
+function textOutputBlocks(value, opts = {}) {
+  const indent = opts.indent ?? "";
+  const nested = `${indent}  `;
+  const blocks = [];
+  for (const [label, output] of [
+    ["stdout", value.stdout],
+    ["stderr", value.stderr]
+  ]) {
+    if (!output)
+      continue;
+    blocks.push(`${indent}${label}:`);
+    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
+      blocks.push(`${nested}${line}`);
+    }
+  }
+  return blocks;
+}
+function publicLoop(loop) {
+  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
+  return {
+    ...loop,
+    target
+  };
+}
+function publicRun(run, showOutput = false, opts = {}) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: opts.redactError ? redact(run.error) : run.error
+  };
+}
+function publicRunReceipt(receipt) {
+  return { ...receipt };
+}
+function publicExecutorResult(result, showOutput = false) {
+  return {
+    ...result,
+    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
+    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
+    error: redact(result.error)
+  };
+}
+function publicWorkflow(workflow) {
+  return {
+    ...workflow,
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
+    }))
+  };
+}
+function publicWorkflowRun(run) {
+  return { ...run, error: redact(run.error) };
+}
+function publicWorkflowInvocation(invocation) {
+  return redactSensitivePayload(invocation);
+}
+function publicWorkflowWorkItem(item) {
+  return { ...item, lastReason: redact(item.lastReason, 240) };
+}
+function publicWorkflowStepRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: redact(run.error)
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event, payload: redactSensitivePayload(event.payload) };
+}
+function publicGoal(goal) {
+  return {
+    ...goal,
+    objective: redact(goal.objective, 120)
+  };
+}
+function publicGoalRun(run) {
+  return {
+    ...run,
+    evidence: redactSensitivePayload(run.evidence),
+    rawResponse: redactSensitivePayload(run.rawResponse)
+  };
+}
+
+// src/lib/route/todos-cli.ts
+function defaultLoopsProject() {
+  return process.env.LOOPS_TASK_PROJECT || process.env.LOOPS_DATA_DIR || `${process.env.HOME || homedir2()}/.hasna/loops`;
+}
+function runLocalCommand(command, args, opts = {}) {
+  const result = spawnSync2(command, args, {
+    input: opts.input,
+    encoding: "utf8",
+    timeout: opts.timeoutMs ?? 30000,
+    maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+    env: process.env
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? String(result.error.message || result.error) : ""
+  };
+}
+function runLocalCommandWithStdoutFile(command, args, opts = {}) {
+  const tempDir = mkdtempSync(join3(tmpdir(), "loops-command-output-"));
+  const stdoutPath = join3(tempDir, "stdout");
+  const stdoutFd = openSync(stdoutPath, "w");
+  let result;
+  try {
+    result = spawnSync2(command, args, {
+      input: opts.input,
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 30000,
+      maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+      env: process.env,
+      stdio: ["pipe", stdoutFd, "pipe"]
+    });
+  } finally {
+    closeSync(stdoutFd);
+  }
+  try {
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout: readFileSync3(stdoutPath, "utf8"),
+      stderr: typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() || "",
+      error: result.error ? String(result.error.message || result.error) : ""
+    };
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+}
+function ensureTodosTaskList(project, slug, name, description) {
+  runLocalCommand("todos", ["--project", project, "task-lists", "--add", name, "--slug", slug, "-d", description]);
+  const list = runLocalCommand("todos", ["--project", project, "--json", "task-lists"]);
+  if (!list.ok)
+    throw new Error(list.stderr || list.error || "failed to list todos task lists");
+  const values = JSON.parse(list.stdout || "[]");
+  const found = values.find((entry) => entry.slug === slug);
+  if (!found)
+    throw new Error(`todos task list not found after ensure: ${slug}`);
+  return found.id;
+}
+function todosMutationSummary(result) {
+  return {
+    ok: result.ok,
+    status: result.status,
+    error: result.ok ? undefined : redact(result.stderr || result.error || "todos mutation failed", 320)
+  };
+}
+
 // src/lib/store.ts
 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"]);
 var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
+var TASK_LIFECYCLE_TEMPLATE_ID = "task-lifecycle";
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -1261,6 +1624,28 @@ 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;
+}
 function rowToWorkflow(row) {
   return {
     id: row.id,
@@ -1321,6 +1706,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,
@@ -1478,6 +1864,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;
@@ -1492,6 +1879,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))
@@ -1515,7 +1938,7 @@ class Store {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
-    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    this.rootDir = file === ":memory:" ? mkdtempSync2(join4(tmpdir2(), "open-loops-store-")) : dirname2(file);
     if (file === ":memory:")
       this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
@@ -1609,6 +2032,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)");
+        }
       }
     ];
   }
@@ -1670,6 +2104,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,
@@ -1756,6 +2212,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,
@@ -1774,10 +2231,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.
@@ -1888,6 +2345,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))
@@ -1999,21 +2481,51 @@ 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 rows.map(rowToLoop);
+    return this.withLatestRunSummaries(rows.map(rowToLoop));
+  }
+  withLatestRunSummaries(loops) {
+    if (loops.length === 0)
+      return loops;
+    const placeholders = loops.map(() => "?").join(",");
+    const rows = this.db.query(`SELECT loop_id, id, status, started_at, finished_at, created_at
+         FROM (
+           SELECT loop_id, id, status, started_at, finished_at, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS rn
+           FROM loop_runs
+           WHERE loop_id IN (${placeholders})
+         )
+         WHERE rn = 1`).all(...loops.map((loop) => loop.id));
+    const latestByLoopId = new Map(rows.map((row) => [row.loop_id, row]));
+    return loops.map((loop) => {
+      const latest = latestByLoopId.get(loop.id);
+      if (!latest)
+        return loop;
+      return {
+        ...loop,
+        latestRunId: latest.id,
+        latestRunStatus: latest.status,
+        lastRunAt: latestRunTime(latest)
+      };
+    });
   }
   dueLoops(now, limit = 500) {
     const rows = this.db.query(`SELECT * FROM loops
@@ -2132,6 +2644,45 @@ class Store {
       throw error;
     }
   }
+  updateAgentLoopTimeout(idOrName, timeoutMs, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || current.id);
+      if (current.target.type !== "agent")
+        throw new Error(`loop is not an agent loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to update running loop: ${current.id}`);
+      const target = { ...current.target, timeoutMs };
+      if (timeoutMs === null && target.idleTimeoutMs !== undefined)
+        delete target.idleTimeoutMs;
+      const res = this.db.query(`UPDATE loops SET target_json=$target, updated_at=$updated
+           WHERE id=$id
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: current.id,
+        $target: JSON.stringify(target),
+        $updated: updated,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      this.db.exec("COMMIT");
+      const after = this.getLoop(current.id);
+      if (!after)
+        throw new Error(`loop not found after timeout update: ${current.id}`);
+      return after;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
   createAndRetargetWorkflowLoop(idOrName, workflowInput, opts = {}) {
     const normalized = normalizeCreateWorkflowInput(workflowInput);
     const updated = (opts.now ?? new Date).toISOString();
@@ -2462,6 +3013,59 @@ class Store {
       updated
     });
   }
+  taskLifecycleTodosPointerContext(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run || run.status !== "succeeded" || !run.invocationId || !run.workItemId || !run.manifestPath)
+      return;
+    const workItem = this.getWorkflowWorkItem(run.workItemId);
+    if (!workItem || workItem.routeKey !== "todos-task")
+      return;
+    const invocation = this.getWorkflowInvocation(run.invocationId);
+    if (!invocation || invocation.templateId !== TASK_LIFECYCLE_TEMPLATE_ID)
+      return;
+    const projectPath = workItem.projectKey ?? invocation.scope?.projectPath;
+    const taskId = invocation.subjectRef.id ?? workItem.subjectRef;
+    if (!projectPath || !taskId)
+      return;
+    return {
+      projectPath,
+      taskId,
+      invocationId: invocation.id,
+      workflowRunId: run.id,
+      manifestPath: run.manifestPath
+    };
+  }
+  syncSuccessfulTaskLifecycleTodosPointers(workflowRunId) {
+    const context = this.taskLifecycleTodosPointerContext(workflowRunId);
+    if (!context)
+      return;
+    const result = runLocalCommand("todos", [
+      "--project",
+      context.projectPath,
+      "task",
+      "workflow-pointers",
+      context.taskId,
+      "--clear",
+      "--invocation",
+      context.invocationId,
+      "--run",
+      context.workflowRunId,
+      "--manifest",
+      context.manifestPath,
+      "--state",
+      "succeeded",
+      "--actor",
+      "openloops:task-lifecycle"
+    ]);
+    this.appendWorkflowEvent(workflowRunId, result.ok ? "todos_workflow_pointers_synced" : "todos_workflow_pointers_sync_failed", undefined, {
+      projectPath: context.projectPath,
+      taskId: context.taskId,
+      invocationId: context.invocationId,
+      workflowRunId: context.workflowRunId,
+      manifestPath: context.manifestPath,
+      mutation: todosMutationSummary(result)
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -2572,10 +3176,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,
@@ -2584,6 +3188,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
@@ -2626,6 +3234,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,
@@ -3135,7 +3744,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,
@@ -3424,6 +4033,8 @@ class Store {
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
       throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    if (changed && status === "succeeded")
+      this.syncSuccessfulTaskLifecycleTodosPointers(workflowRunId);
     return run;
   }
   cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
@@ -3464,7 +4075,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);
@@ -3485,6 +4096,17 @@ class Store {
     const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND scheduled_for = ? AND status = 'running'").get(loopId, scheduledFor);
     return (row?.count ?? 0) > 0;
   }
+  hasBlockingRunningRunForOtherSlot(loopId, scheduledFor, nowIso2) {
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE loop_id = ? AND scheduled_for <> ? AND status = 'running'`).all(loopId, scheduledFor);
+    return rows.some((row) => {
+      if (!row.lease_expires_at || row.lease_expires_at > nowIso2)
+        return true;
+      if (isRecordedProcessAlive(row.pid, row.process_started_at))
+        return true;
+      return this.hasLiveWorkflowStepProcesses(row.id);
+    });
+  }
   markRunPid(id, pid, claimedBy, opts = {}) {
     const now = (opts.now ?? new Date).toISOString();
     const startedMs = processStartTimeMs(pid);
@@ -3617,6 +4239,10 @@ class Store {
       loop = currentLoop;
       const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
       const existing = this.getRunBySlot(loop.id, scheduledFor);
+      if (loop.overlap === "skip" && this.hasBlockingRunningRunForOtherSlot(loop.id, scheduledFor, startedAt)) {
+        this.db.exec("COMMIT");
+        return;
+      }
       if (existing) {
         if (existing.status === "running") {
           if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
@@ -3772,18 +4398,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();
@@ -3942,6 +4643,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;
@@ -4188,9 +4892,9 @@ class Store {
       const runDir = dirname2(manifestPath);
       try {
         if (/^[0-9a-f]{12,64}$/.test(basename2(runDir))) {
-          rmSync2(runDir, { recursive: true, force: true });
+          rmSync3(runDir, { recursive: true, force: true });
         } else {
-          rmSync2(manifestPath, { force: true });
+          rmSync3(manifestPath, { force: true });
         }
       } catch {}
     }
@@ -4257,222 +4961,20 @@ class Store {
     this.db.close();
     if (this.memoryRootDir) {
       try {
-        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+        rmSync3(this.memoryRootDir, { recursive: true, force: true });
       } catch {}
       this.memoryRootDir = undefined;
     }
   }
 }
 
-// src/lib/storage/sqlite.ts
-class SqliteLoopStorage {
-  store;
-  backend = "sqlite";
-  supportsRemoteRunners = false;
-  constructor(store = new Store) {
-    this.store = store;
-  }
-  async close() {
-    this.store.close();
-  }
-  async call(method, ...args) {
-    return this.store[method](...args);
-  }
-  createLoop(...args) {
-    return this.call("createLoop", ...args);
-  }
-  getLoop(...args) {
-    return this.call("getLoop", ...args);
-  }
-  findLoopByName(...args) {
-    return this.call("findLoopByName", ...args);
-  }
-  requireLoop(...args) {
-    return this.call("requireLoop", ...args);
-  }
-  listLoops(...args) {
-    return this.call("listLoops", ...args);
-  }
-  dueLoops(...args) {
-    return this.call("dueLoops", ...args);
-  }
-  updateLoop(...args) {
-    return this.call("updateLoop", ...args);
-  }
-  renameLoop(...args) {
-    return this.call("renameLoop", ...args);
-  }
-  archiveLoop(...args) {
-    return this.call("archiveLoop", ...args);
-  }
-  unarchiveLoop(...args) {
-    return this.call("unarchiveLoop", ...args);
-  }
-  deleteLoop(...args) {
-    return this.call("deleteLoop", ...args);
-  }
-  createWorkflow(...args) {
-    return this.call("createWorkflow", ...args);
-  }
-  getWorkflow(...args) {
-    return this.call("getWorkflow", ...args);
-  }
-  listWorkflows(...args) {
-    return this.call("listWorkflows", ...args);
-  }
-  countWorkflows(...args) {
-    return this.call("countWorkflows", ...args);
-  }
-  archiveWorkflow(...args) {
-    return this.call("archiveWorkflow", ...args);
-  }
-  createWorkflowInvocation(...args) {
-    return this.call("createWorkflowInvocation", ...args);
-  }
-  getWorkflowInvocation(...args) {
-    return this.call("getWorkflowInvocation", ...args);
-  }
-  listWorkflowInvocations(...args) {
-    return this.call("listWorkflowInvocations", ...args);
-  }
-  upsertWorkflowWorkItem(...args) {
-    return this.call("upsertWorkflowWorkItem", ...args);
-  }
-  getWorkflowWorkItem(...args) {
-    return this.call("getWorkflowWorkItem", ...args);
-  }
-  listWorkflowWorkItems(...args) {
-    return this.call("listWorkflowWorkItems", ...args);
-  }
-  countActiveWorkflowWorkItems(...args) {
-    return this.call("countActiveWorkflowWorkItems", ...args);
-  }
-  admitWorkflowWorkItem(...args) {
-    return this.call("admitWorkflowWorkItem", ...args);
-  }
-  createGoal(...args) {
-    return this.call("createGoal", ...args);
-  }
-  getGoal(...args) {
-    return this.call("getGoal", ...args);
-  }
-  listGoals(...args) {
-    return this.call("listGoals", ...args);
-  }
-  createGoalPlanNodes(...args) {
-    return this.call("createGoalPlanNodes", ...args);
-  }
-  listGoalPlanNodes(...args) {
-    return this.call("listGoalPlanNodes", ...args);
-  }
-  updateGoalStatus(...args) {
-    return this.call("updateGoalStatus", ...args);
-  }
-  updateGoalPlanNode(...args) {
-    return this.call("updateGoalPlanNode", ...args);
-  }
-  recordGoalEvent(...args) {
-    return this.call("recordGoalEvent", ...args);
-  }
-  listGoalRuns(...args) {
-    return this.call("listGoalRuns", ...args);
-  }
-  createWorkflowRun(...args) {
-    return this.call("createWorkflowRun", ...args);
-  }
-  getWorkflowRun(...args) {
-    return this.call("getWorkflowRun", ...args);
-  }
-  listWorkflowRuns(...args) {
-    return this.call("listWorkflowRuns", ...args);
-  }
-  listWorkflowStepRuns(...args) {
-    return this.call("listWorkflowStepRuns", ...args);
-  }
-  getWorkflowStepRun(...args) {
-    return this.call("getWorkflowStepRun", ...args);
-  }
-  startWorkflowStepRun(...args) {
-    return this.call("startWorkflowStepRun", ...args);
-  }
-  recoverWorkflowRun(...args) {
-    return this.call("recoverWorkflowRun", ...args);
-  }
-  finalizeWorkflowStepRun(...args) {
-    return this.call("finalizeWorkflowStepRun", ...args);
-  }
-  finalizeWorkflowRun(...args) {
-    return this.call("finalizeWorkflowRun", ...args);
-  }
-  appendWorkflowEvent(...args) {
-    return this.call("appendWorkflowEvent", ...args);
-  }
-  listWorkflowEvents(...args) {
-    return this.call("listWorkflowEvents", ...args);
-  }
-  recordRunProcess(...args) {
-    return this.call("recordRunProcess", ...args);
-  }
-  createSkippedRun(...args) {
-    return this.call("createSkippedRun", ...args);
-  }
-  getRun(...args) {
-    return this.call("getRun", ...args);
-  }
-  getRunBySlot(...args) {
-    return this.call("getRunBySlot", ...args);
-  }
-  claimRun(...args) {
-    return this.call("claimRun", ...args);
-  }
-  finalizeRun(...args) {
-    return this.call("finalizeRun", ...args);
-  }
-  heartbeatRunLease(...args) {
-    return this.call("heartbeatRunLease", ...args);
-  }
-  listRuns(...args) {
-    return this.call("listRuns", ...args);
-  }
-  recoverExpiredRunLeases(...args) {
-    return this.call("recoverExpiredRunLeases", ...args);
-  }
-  recoverExpiredRunLeasesDetailed(...args) {
-    return this.call("recoverExpiredRunLeasesDetailed", ...args);
-  }
-  countLoops(...args) {
-    return this.call("countLoops", ...args);
-  }
-  countRuns(...args) {
-    return this.call("countRuns", ...args);
-  }
-  pruneHistory(...args) {
-    return this.call("pruneHistory", ...args);
-  }
-  acquireDaemonLease(...args) {
-    return this.call("acquireDaemonLease", ...args);
-  }
-  heartbeatDaemonLease(...args) {
-    return this.call("heartbeatDaemonLease", ...args);
-  }
-  releaseDaemonLease(...args) {
-    return this.call("releaseDaemonLease", ...args);
-  }
-  getDaemonLease(...args) {
-    return this.call("getDaemonLease", ...args);
-  }
-}
-function createSqliteLoopStorage(path) {
-  return new SqliteLoopStorage(new Store(path));
-}
-
 // src/lib/storage/postgres-schema.ts
-import { createHash as 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) });
@@ -4790,6 +5292,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);
     `)
 ]);
 
@@ -4888,13 +5419,1279 @@ function isMissingLedgerError(error) {
   const message = error.message.toLowerCase();
   return message.includes(POSTGRES_MIGRATION_LEDGER_TABLE.toLowerCase()) && (message.includes("does not exist") || message.includes("no such table") || message.includes("undefined_table"));
 }
+
+// src/lib/storage/sqlite.ts
+class SqliteLoopStorage {
+  store;
+  backend = "sqlite";
+  supportsRemoteRunners = false;
+  constructor(store = new Store) {
+    this.store = store;
+  }
+  async close() {
+    this.store.close();
+  }
+  async call(method, ...args) {
+    return this.store[method](...args);
+  }
+  createLoop(...args) {
+    return this.call("createLoop", ...args);
+  }
+  getLoop(...args) {
+    return this.call("getLoop", ...args);
+  }
+  findLoopByName(...args) {
+    return this.call("findLoopByName", ...args);
+  }
+  requireLoop(...args) {
+    return this.call("requireLoop", ...args);
+  }
+  listLoops(...args) {
+    return this.call("listLoops", ...args);
+  }
+  dueLoops(...args) {
+    return this.call("dueLoops", ...args);
+  }
+  updateLoop(...args) {
+    return this.call("updateLoop", ...args);
+  }
+  renameLoop(...args) {
+    return this.call("renameLoop", ...args);
+  }
+  archiveLoop(...args) {
+    return this.call("archiveLoop", ...args);
+  }
+  unarchiveLoop(...args) {
+    return this.call("unarchiveLoop", ...args);
+  }
+  deleteLoop(...args) {
+    return this.call("deleteLoop", ...args);
+  }
+  upsertMigrationLoop(...args) {
+    return this.call("upsertMigrationLoop", ...args);
+  }
+  upsertMigrationRun(...args) {
+    return this.call("upsertMigrationRun", ...args);
+  }
+  upsertMigrationWorkflow(...args) {
+    return this.call("upsertMigrationWorkflow", ...args);
+  }
+  createWorkflow(...args) {
+    return this.call("createWorkflow", ...args);
+  }
+  getWorkflow(...args) {
+    return this.call("getWorkflow", ...args);
+  }
+  listWorkflows(...args) {
+    return this.call("listWorkflows", ...args);
+  }
+  countWorkflows(...args) {
+    return this.call("countWorkflows", ...args);
+  }
+  archiveWorkflow(...args) {
+    return this.call("archiveWorkflow", ...args);
+  }
+  createWorkflowInvocation(...args) {
+    return this.call("createWorkflowInvocation", ...args);
+  }
+  getWorkflowInvocation(...args) {
+    return this.call("getWorkflowInvocation", ...args);
+  }
+  listWorkflowInvocations(...args) {
+    return this.call("listWorkflowInvocations", ...args);
+  }
+  upsertWorkflowWorkItem(...args) {
+    return this.call("upsertWorkflowWorkItem", ...args);
+  }
+  getWorkflowWorkItem(...args) {
+    return this.call("getWorkflowWorkItem", ...args);
+  }
+  listWorkflowWorkItems(...args) {
+    return this.call("listWorkflowWorkItems", ...args);
+  }
+  countActiveWorkflowWorkItems(...args) {
+    return this.call("countActiveWorkflowWorkItems", ...args);
+  }
+  admitWorkflowWorkItem(...args) {
+    return this.call("admitWorkflowWorkItem", ...args);
+  }
+  createGoal(...args) {
+    return this.call("createGoal", ...args);
+  }
+  getGoal(...args) {
+    return this.call("getGoal", ...args);
+  }
+  listGoals(...args) {
+    return this.call("listGoals", ...args);
+  }
+  createGoalPlanNodes(...args) {
+    return this.call("createGoalPlanNodes", ...args);
+  }
+  listGoalPlanNodes(...args) {
+    return this.call("listGoalPlanNodes", ...args);
+  }
+  updateGoalStatus(...args) {
+    return this.call("updateGoalStatus", ...args);
+  }
+  updateGoalPlanNode(...args) {
+    return this.call("updateGoalPlanNode", ...args);
+  }
+  recordGoalEvent(...args) {
+    return this.call("recordGoalEvent", ...args);
+  }
+  listGoalRuns(...args) {
+    return this.call("listGoalRuns", ...args);
+  }
+  createWorkflowRun(...args) {
+    return this.call("createWorkflowRun", ...args);
+  }
+  getWorkflowRun(...args) {
+    return this.call("getWorkflowRun", ...args);
+  }
+  listWorkflowRuns(...args) {
+    return this.call("listWorkflowRuns", ...args);
+  }
+  listWorkflowStepRuns(...args) {
+    return this.call("listWorkflowStepRuns", ...args);
+  }
+  getWorkflowStepRun(...args) {
+    return this.call("getWorkflowStepRun", ...args);
+  }
+  startWorkflowStepRun(...args) {
+    return this.call("startWorkflowStepRun", ...args);
+  }
+  recoverWorkflowRun(...args) {
+    return this.call("recoverWorkflowRun", ...args);
+  }
+  finalizeWorkflowStepRun(...args) {
+    return this.call("finalizeWorkflowStepRun", ...args);
+  }
+  finalizeWorkflowRun(...args) {
+    return this.call("finalizeWorkflowRun", ...args);
+  }
+  appendWorkflowEvent(...args) {
+    return this.call("appendWorkflowEvent", ...args);
+  }
+  listWorkflowEvents(...args) {
+    return this.call("listWorkflowEvents", ...args);
+  }
+  recordRunProcess(...args) {
+    return this.call("recordRunProcess", ...args);
+  }
+  createSkippedRun(...args) {
+    return this.call("createSkippedRun", ...args);
+  }
+  getRun(...args) {
+    return this.call("getRun", ...args);
+  }
+  getRunBySlot(...args) {
+    return this.call("getRunBySlot", ...args);
+  }
+  claimRun(...args) {
+    return this.call("claimRun", ...args);
+  }
+  finalizeRun(...args) {
+    return this.call("finalizeRun", ...args);
+  }
+  heartbeatRunLease(...args) {
+    return this.call("heartbeatRunLease", ...args);
+  }
+  listRuns(...args) {
+    return this.call("listRuns", ...args);
+  }
+  writeRunReceipt(...args) {
+    return this.call("writeRunReceipt", ...args);
+  }
+  getRunReceipt(...args) {
+    return this.call("getRunReceipt", ...args);
+  }
+  listRunReceipts(...args) {
+    return this.call("listRunReceipts", ...args);
+  }
+  recoverExpiredRunLeases(...args) {
+    return this.call("recoverExpiredRunLeases", ...args);
+  }
+  recoverExpiredRunLeasesDetailed(...args) {
+    return this.call("recoverExpiredRunLeasesDetailed", ...args);
+  }
+  countLoops(...args) {
+    return this.call("countLoops", ...args);
+  }
+  countRuns(...args) {
+    return this.call("countRuns", ...args);
+  }
+  pruneHistory(...args) {
+    return this.call("pruneHistory", ...args);
+  }
+  acquireDaemonLease(...args) {
+    return this.call("acquireDaemonLease", ...args);
+  }
+  heartbeatDaemonLease(...args) {
+    return this.call("heartbeatDaemonLease", ...args);
+  }
+  releaseDaemonLease(...args) {
+    return this.call("releaseDaemonLease", ...args);
+  }
+  getDaemonLease(...args) {
+    return this.call("getDaemonLease", ...args);
+  }
+}
+function createSqliteLoopStorage(path) {
+  return new SqliteLoopStorage(new Store(path));
+}
+// src/lib/storage/postgres-loop-storage.ts
+import pgLib from "pg";
+var { types: pgTypes } = pgLib;
+pgTypes.setTypeParser(3802, (v) => v);
+pgTypes.setTypeParser(114, (v) => v);
+var toIso = (v) => v == null ? null : new Date(v).toISOString();
+pgTypes.setTypeParser(1184, (v) => toIso(v));
+pgTypes.setTypeParser(1114, (v) => toIso(v));
+
+class NotImplementedError extends Error {
+  code = "not_implemented";
+  constructor(method) {
+    super(`PostgresLoopStorage.${method} is not implemented on the Postgres backend yet. ` + `This path must not silently no-op; port the sqlite Store.${method} logic.`);
+    this.name = "NotImplementedError";
+  }
+}
+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;
+
+class PostgresLoopStorage {
+  client;
+  backend = "postgres";
+  supportsRemoteRunners = true;
+  constructor(client) {
+    this.client = client;
+  }
+  async close() {
+    await this.client.close();
+  }
+  async assertDaemonLeaseFence(c, opts, now) {
+    if (!opts.daemonLeaseId)
+      return;
+    const row = await c.get("SELECT id FROM daemon_lease WHERE id = $1 AND expires_at > $2", [opts.daemonLeaseId, now]);
+    if (!row)
+      throw new Error("daemon lease lost");
+  }
+  async loadLoop(c, id) {
+    const row = await c.get("SELECT * FROM loops WHERE id = $1", [id]);
+    return row ? rowToLoop(row) : undefined;
+  }
+  async loadRun(c, id) {
+    const row = await c.get("SELECT * FROM loop_runs WHERE id = $1", [id]);
+    return row ? rowToRun(row) : undefined;
+  }
+  async loadRunBySlot(c, loopId, scheduledFor) {
+    const row = await c.get("SELECT * FROM loop_runs WHERE loop_id = $1 AND scheduled_for = $2", [loopId, scheduledFor]);
+    return row ? rowToRun(row) : undefined;
+  }
+  async loadDaemonLease(c) {
+    const row = await c.get("SELECT * FROM daemon_lease LIMIT 1", []);
+    return row ? rowToLease(row) : undefined;
+  }
+  async setWorkItemsForLoop(c, loopId, status, reason, updated, statuses = ["admitted", "running"]) {
+    const placeholders = statuses.map((_, i) => `$${i + 5}`).join(",");
+    await c.execute(`UPDATE workflow_work_items
+       SET status=$1, lease_expires_at=NULL, last_reason=COALESCE($2, last_reason), updated_at=$3
+       WHERE loop_id = $4 AND status IN (${placeholders})`, [status, reason ?? null, updated, loopId, ...statuses]);
+  }
+  async setWorkItemsForWorkflowRun(c, workflowRunId, status, reason, updated, statuses = ["admitted", "running"]) {
+    const placeholders = statuses.map((_, i) => `$${i + 5}`).join(",");
+    await c.execute(`UPDATE workflow_work_items
+       SET status=$1, lease_expires_at=NULL, last_reason=COALESCE($2, last_reason), updated_at=$3
+       WHERE workflow_run_id = $4 AND status IN (${placeholders})`, [status, reason ?? null, updated, workflowRunId, ...statuses]);
+  }
+  async cascadeWorkItemsForLoopRun(c, run, reason, updated) {
+    const loop = await this.loadLoop(c, run.loopId);
+    const status = workItemStatusForLoopRun(run.status, run.attempt, loop?.maxAttempts);
+    if (!status)
+      return;
+    const statuses = status === "admitted" ? ["admitted", "running", "failed"] : ["admitted", "running"];
+    const nextReason = status === "admitted" ? reason ? `attempt failed; retry pending: ${reason}` : "attempt failed; retry pending" : reason;
+    await this.setWorkItemsForLoop(c, run.loopId, status, nextReason, updated, statuses);
+  }
+  async createLoop(...args) {
+    const [input, from = new Date] = args;
+    const now = nowIso();
+    const target = input.target.type === "workflow" ? input.target : normalizeCreateWorkflowInput({
+      name: "loop-target-validation",
+      steps: [{ id: "target", target: input.target }]
+    }).steps[0].target;
+    if (input.goal && target.type === "workflow") {
+      const workflow = await this.loadWorkflow(this.client, target.workflowId);
+      if (workflow?.goal) {
+        throw new Error(`workflow loop cannot define a loop-level goal when workflow ${workflow.name} already has a top-level goal; remove one goal wrapper`);
+      }
+    }
+    const loop = {
+      id: genId(),
+      name: input.name,
+      description: input.description,
+      status: "active",
+      schedule: input.schedule,
+      target,
+      goal: input.goal,
+      machine: input.machine,
+      nextRunAt: initialNextRun(input.schedule, from),
+      catchUp: input.catchUp ?? "latest",
+      catchUpLimit: input.catchUpLimit ?? 50,
+      overlap: input.overlap ?? "skip",
+      maxAttempts: input.maxAttempts ?? 1,
+      retryDelayMs: input.retryDelayMs ?? 60000,
+      leaseMs: input.leaseMs ?? 30 * 60000,
+      expiresAt: input.expiresAt,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.client.execute(`INSERT INTO loops (id, name, description, status, schedule_json, target_json, machine_json, next_run_at, retry_scheduled_for,
+        goal_json, 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::jsonb,$6::jsonb,$7::jsonb,$8,NULL,$9::jsonb,$10,$11,$12,$13,$14,$15,$16,$17,$18)`, [
+      loop.id,
+      loop.name,
+      loop.description ?? null,
+      loop.status,
+      JSON.stringify(loop.schedule),
+      JSON.stringify(loop.target),
+      loop.machine ? JSON.stringify(loop.machine) : null,
+      loop.nextRunAt ?? null,
+      loop.goal ? JSON.stringify(loop.goal) : null,
+      loop.catchUp,
+      loop.catchUpLimit,
+      loop.overlap,
+      loop.maxAttempts,
+      loop.retryDelayMs,
+      loop.leaseMs,
+      loop.expiresAt ?? null,
+      loop.createdAt,
+      loop.updatedAt
+    ]);
+    return loop;
+  }
+  async getLoop(...args) {
+    return this.loadLoop(this.client, args[0]);
+  }
+  async findLoopByName(...args) {
+    const row = await this.client.get("SELECT * FROM loops WHERE name = $1 ORDER BY created_at DESC LIMIT 1", [args[0]]);
+    return row ? rowToLoop(row) : undefined;
+  }
+  async requireLoop(...args) {
+    const idOrName = args[0];
+    const found = await this.getLoop(idOrName) ?? await this.findLoopByName(idOrName);
+    if (!found)
+      throw new LoopNotFoundError(idOrName);
+    return found;
+  }
+  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.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 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 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 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 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 OFFSET $2", [limit, offset]);
+    }
+    return rows.map(rowToLoop);
+  }
+  async dueLoops(...args) {
+    const [now, limit = 500] = args;
+    const rows = await this.client.many(`SELECT * FROM loops
+       WHERE status = 'active' AND archived_at IS NULL AND next_run_at IS NOT NULL AND next_run_at <= $1
+       ORDER BY next_run_at ASC LIMIT $2`, [now.toISOString(), limit]);
+    return rows.map(rowToLoop);
+  }
+  async updateLoop(...args) {
+    const [id, patch, opts = {}] = args;
+    const updated = (opts.now ?? new Date).toISOString();
+    return this.client.transaction(async (c) => {
+      const current = await this.loadLoop(c, id);
+      if (!current)
+        throw new LoopNotFoundError(id);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || id);
+      const merged = { ...current, ...patch, updatedAt: updated };
+      const res = await c.query(`UPDATE loops SET status=$1, next_run_at=$2, retry_scheduled_for=$3, expires_at=$4, updated_at=$5
+         WHERE id=$6
+           AND ($7::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$7 AND expires_at > $8))`, [
+        merged.status,
+        merged.nextRunAt ?? null,
+        merged.retryScheduledFor ?? null,
+        merged.expiresAt ?? null,
+        merged.updatedAt,
+        id,
+        opts.daemonLeaseId ?? null,
+        updated
+      ]);
+      if (res.rowCount !== 1)
+        throw new Error("daemon lease lost");
+      if (patch.status && patch.status !== "active") {
+        const status = patch.status === "paused" ? "deferred" : "cancelled";
+        await this.setWorkItemsForLoop(c, id, status, `loop ${patch.status}`, updated);
+      }
+      const after = await this.loadLoop(c, id);
+      if (!after)
+        throw new Error(`loop not found after update: ${id}`);
+      return after;
+    });
+  }
+  async renameLoop(...args) {
+    const [id, name, opts = {}] = args;
+    const current = await this.getLoop(id);
+    if (!current)
+      throw new LoopNotFoundError(id);
+    const trimmed = name.trim();
+    if (!trimmed)
+      throw new ValidationError("loop name must not be empty");
+    const updated = (opts.now ?? new Date).toISOString();
+    await this.client.execute(`UPDATE loops SET name=$1, updated_at=$2
+       WHERE id=$3 AND ($4::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$4 AND expires_at > $5))`, [trimmed, updated, id, opts.daemonLeaseId ?? null, updated]);
+    const after = await this.getLoop(id);
+    if (!after)
+      throw new Error(`loop not found after rename: ${id}`);
+    return after;
+  }
+  async archiveLoop(...args) {
+    const idOrName = args[0];
+    return this.client.transaction(async (c) => {
+      const loop = await this.requireLoopIn(c, idOrName);
+      if (loop.archivedAt)
+        return loop;
+      const updated = nowIso();
+      const archivedStatus = loop.status === "active" ? "paused" : loop.status;
+      await c.execute(`UPDATE loops SET status=$1, archived_at=$2, archived_from_status=$3, updated_at=$4 WHERE id=$5`, [archivedStatus, updated, loop.status, updated, loop.id]);
+      await this.setWorkItemsForLoop(c, loop.id, "deferred", "loop archived", updated);
+      const archived = await this.loadLoop(c, loop.id);
+      if (!archived)
+        throw new Error(`loop not found after archive: ${loop.id}`);
+      return archived;
+    });
+  }
+  async unarchiveLoop(...args) {
+    const idOrName = args[0];
+    const loop = await this.requireLoop(idOrName);
+    if (!loop.archivedAt)
+      return loop;
+    const updated = nowIso();
+    const restoredStatus = loop.archivedFromStatus ?? loop.status;
+    await this.client.execute(`UPDATE loops SET status=$1, archived_at=NULL, archived_from_status=NULL, updated_at=$2 WHERE id=$3`, [restoredStatus, updated, loop.id]);
+    const unarchived = await this.getLoop(loop.id);
+    if (!unarchived)
+      throw new Error(`loop not found after unarchive: ${loop.id}`);
+    return unarchived;
+  }
+  async deleteLoop(...args) {
+    const idOrName = args[0];
+    return this.client.transaction(async (c) => {
+      const loop = await this.requireLoopIn(c, idOrName);
+      await this.setWorkItemsForLoop(c, loop.id, "cancelled", "loop deleted", nowIso());
+      const res = await c.query(`DELETE FROM loops WHERE id = $1`, [loop.id]);
+      return res.rowCount > 0;
+    });
+  }
+  async requireLoopIn(c, idOrName) {
+    const byId = await this.loadLoop(c, idOrName);
+    if (byId)
+      return byId;
+    const row = await c.get("SELECT * FROM loops WHERE name = $1 ORDER BY created_at DESC LIMIT 1", [idOrName]);
+    if (!row)
+      throw new LoopNotFoundError(idOrName);
+    return rowToLoop(row);
+  }
+  async countLoops(...args) {
+    const [status, opts = {}] = args;
+    let sql;
+    const params = [];
+    if (status && opts.archived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE status = $1 AND archived_at IS NOT NULL";
+      params.push(status);
+    } else if (status && opts.includeArchived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE status = $1";
+      params.push(status);
+    } else if (status) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE status = $1 AND archived_at IS NULL";
+      params.push(status);
+    } else if (opts.archived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE archived_at IS NOT NULL";
+    } else if (opts.includeArchived) {
+      sql = "SELECT COUNT(*)::int AS count FROM loops";
+    } else {
+      sql = "SELECT COUNT(*)::int AS count FROM loops WHERE archived_at IS NULL";
+    }
+    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();
+    const id = genId();
+    return this.client.transaction(async (c) => {
+      await this.assertDaemonLeaseFence(c, opts, now);
+      await c.execute(`INSERT INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+          claimed_by, lease_expires_at, pid, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,1,'skipped',NULL,$5,NULL,NULL,NULL,NULL,NULL,NULL,NULL,$6,$7,$7)
+         ON CONFLICT (loop_id, scheduled_for) DO NOTHING`, [id, loop.id, loop.name, scheduledFor, now, reason, now]);
+      const run = await this.loadRunBySlot(c, loop.id, scheduledFor);
+      if (run)
+        return run;
+      return {
+        id,
+        loopId: loop.id,
+        loopName: loop.name,
+        scheduledFor,
+        attempt: 1,
+        status: "skipped",
+        finishedAt: now,
+        error: reason,
+        createdAt: now,
+        updatedAt: now
+      };
+    });
+  }
+  async getRun(...args) {
+    return this.loadRun(this.client, args[0]);
+  }
+  async getRunBySlot(...args) {
+    return this.loadRunBySlot(this.client, args[0], args[1]);
+  }
+  async claimRun(...args) {
+    const [loopArg, scheduledFor, runnerId, now = new Date, opts = {}] = args;
+    const startedAt = now.toISOString();
+    const claimToken = opts.claimToken ?? genId();
+    return this.client.transaction(async (c) => {
+      await this.assertDaemonLeaseFence(c, opts, startedAt);
+      const loop = await this.loadLoop(c, loopArg.id);
+      if (!loop || loop.archivedAt)
+        return;
+      const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
+      if (loop.overlap === "skip") {
+        const blocking = await c.get(`SELECT id FROM loop_runs
+           WHERE loop_id=$1 AND scheduled_for<>$2 AND status='running'
+             AND lease_expires_at IS NOT NULL AND lease_expires_at > $3
+           LIMIT 1`, [loop.id, scheduledFor, startedAt]);
+        if (blocking)
+          return;
+      }
+      const existing = await c.get("SELECT * FROM loop_runs WHERE loop_id=$1 AND scheduled_for=$2 FOR UPDATE", [loop.id, scheduledFor]);
+      if (existing) {
+        if (existing.status === "running") {
+          if (existing.lease_expires_at && existing.lease_expires_at > startedAt) {
+            return;
+          }
+          const res3 = await c.query(`UPDATE loop_runs SET status='running', started_at=$2, finished_at=NULL, claimed_by=$3, claim_token=$4,
+             lease_expires_at=$5, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL, duration_ms=NULL,
+             stdout=NULL, stderr=NULL, error=NULL, updated_at=$2
+             WHERE id=$1 AND status='running' AND lease_expires_at <= $6`, [existing.id, startedAt, runnerId, claimToken, leaseExpiresAt, startedAt]);
+          if (res3.rowCount !== 1)
+            return;
+          const run3 = await this.loadRun(c, existing.id);
+          return run3 ? { run: run3, loop, claimToken } : undefined;
+        }
+        if (existing.status === "succeeded" || existing.status === "skipped")
+          return;
+        const attempt = existing.attempt + 1;
+        const res2 = await c.query(`UPDATE loop_runs SET attempt=$2, status='running', started_at=$3, finished_at=NULL, claimed_by=$4, claim_token=$5,
+           lease_expires_at=$6, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL, duration_ms=NULL,
+           stdout=NULL, stderr=NULL, error=NULL, updated_at=$3
+           WHERE id=$1 AND status IN ('failed','timed_out','abandoned') AND attempt < $7`, [existing.id, attempt, startedAt, runnerId, claimToken, leaseExpiresAt, loop.maxAttempts]);
+        if (res2.rowCount !== 1)
+          return;
+        const run2 = await this.loadRun(c, existing.id);
+        return run2 ? { run: run2, loop, claimToken } : undefined;
+      }
+      const id = genId();
+      const res = await c.query(`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, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,1,'running',$5,NULL,$6,$7,$8,NULL,NULL,NULL,NULL,NULL,NULL,$5,$5)
+         ON CONFLICT (loop_id, scheduled_for) DO NOTHING`, [id, loop.id, loop.name, scheduledFor, startedAt, runnerId, claimToken, leaseExpiresAt]);
+      if (res.rowCount !== 1)
+        return;
+      const run = await this.loadRun(c, id);
+      return run ? { run, loop, claimToken } : undefined;
+    });
+  }
+  async finalizeRun(...args) {
+    const [id, patch, opts = {}] = args;
+    const finishedAt = patch.finishedAt ?? nowIso();
+    const error = patch.error === undefined ? undefined : persistedRunOutput(patch.error) ?? undefined;
+    const nowStr = (opts.now ?? new Date).toISOString();
+    return this.client.transaction(async (c) => {
+      let res;
+      if (opts.claimedBy) {
+        res = await c.query(`UPDATE loop_runs SET status=$2, finished_at=$3, claim_token=NULL, lease_expires_at=NULL, pid=$4, exit_code=$5,
+           duration_ms=$6, stdout=$7, stderr=$8, error=$9, updated_at=$3
+           WHERE id=$1 AND status='running' AND claimed_by=$10 AND lease_expires_at > $11
+             AND ($12::text IS NULL OR claim_token=$12)
+             AND ($13::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$13 AND expires_at > $11))`, [
+          id,
+          patch.status,
+          finishedAt,
+          patch.pid ?? null,
+          patch.exitCode ?? null,
+          patch.durationMs ?? null,
+          persistedRunOutput(patch.stdout),
+          persistedRunOutput(patch.stderr),
+          error ?? null,
+          opts.claimedBy,
+          nowStr,
+          opts.claimToken ?? null,
+          opts.daemonLeaseId ?? null
+        ]);
+      } else {
+        res = await c.query(`UPDATE loop_runs SET status=$2, finished_at=$3, claim_token=NULL, lease_expires_at=NULL, pid=$4, exit_code=$5,
+           duration_ms=$6, stdout=$7, stderr=$8, error=$9, updated_at=$3
+           WHERE id=$1 AND status='running'`, [
+          id,
+          patch.status,
+          finishedAt,
+          patch.pid ?? null,
+          patch.exitCode ?? null,
+          patch.durationMs ?? null,
+          persistedRunOutput(patch.stdout),
+          persistedRunOutput(patch.stderr),
+          error ?? null
+        ]);
+      }
+      const run = await this.loadRun(c, id);
+      if (!run)
+        throw new Error(`run not found after finalize: ${id}`);
+      if (opts.claimedBy && res.rowCount !== 1)
+        return run;
+      if (res.rowCount === 1) {
+        await this.cascadeWorkItemsForLoopRun(c, run, error, finishedAt);
+      }
+      return run;
+    });
+  }
+  async heartbeatRunLease(...args) {
+    const [id, claimedBy, leaseMs, now = new Date, opts = {}] = args;
+    const nowStr = now.toISOString();
+    const expiresAt = new Date(now.getTime() + leaseMs).toISOString();
+    const res = await this.client.query(`UPDATE loop_runs SET lease_expires_at=$2, updated_at=$3
+       WHERE id=$1 AND status='running' AND claimed_by=$4 AND lease_expires_at > $5
+         AND ($6::text IS NULL OR claim_token=$6)
+         AND ($7::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$7 AND expires_at > $5))`, [id, expiresAt, nowStr, claimedBy, nowStr, opts.claimToken ?? null, opts.daemonLeaseId ?? null]);
+    if (res.rowCount !== 1)
+      return;
+    return this.getRun(id);
+  }
+  async recordRunProcess(...args) {
+    const [runId, info, opts = {}] = args;
+    const now = (opts.now ?? new Date).toISOString();
+    const res = await this.client.query(`UPDATE loop_runs SET pid=$2, pgid=$3, process_started_at=$4, updated_at=$5
+       WHERE id=$1 AND status='running'
+         AND ($6::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$6 AND expires_at > $7))`, [runId, info.pid, info.pgid ?? null, info.processStartedAt ?? now, now, opts.daemonLeaseId ?? null, now]);
+    if (res.rowCount !== 1)
+      return;
+    return this.getRun(runId);
+  }
+  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 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 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 OFFSET $3", [opts.status, limit, offset]);
+    } else {
+      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", []);
+    return row?.count ?? 0;
+  }
+  async recoverExpiredRunLeases(...args) {
+    const detailed = await this.recoverExpiredRunLeasesDetailed(...args);
+    return detailed.abandoned;
+  }
+  async recoverExpiredRunLeasesDetailed(...args) {
+    const [now = new Date, opts = {}] = args;
+    const limit = Math.max(1, Math.min(1000, Math.floor(opts.limit ?? DEFAULT_RECOVERY_BATCH_LIMIT2)));
+    const scanLimit = Math.max(limit, Math.min(5000, Math.floor(opts.scanLimit ?? limit * DEFAULT_RECOVERY_SCAN_MULTIPLIER2)));
+    const finished = now.toISOString();
+    const rows = await this.client.many(`SELECT * FROM loop_runs WHERE status='running' AND lease_expires_at <= $1 ORDER BY lease_expires_at ASC LIMIT $2`, [finished, scanLimit]);
+    const recovered = [];
+    for (const row of rows) {
+      if (recovered.length >= limit)
+        break;
+      const run = await this.client.transaction(async (c) => {
+        const res = await c.query(`UPDATE loop_runs SET status='abandoned', finished_at=$2, lease_expires_at=NULL,
+           error='run lease expired before completion', updated_at=$2
+           WHERE id=$1 AND status='running' AND lease_expires_at <= $3
+             AND ($4::text IS NULL OR EXISTS (SELECT 1 FROM daemon_lease WHERE id=$4 AND expires_at > $3))`, [row.id, finished, finished, opts.daemonLeaseId ?? null]);
+        if (res.rowCount !== 1)
+          return;
+        const workflowRows = await c.many("SELECT * FROM workflow_runs WHERE loop_run_id = $1 AND status NOT IN ('succeeded','failed','timed_out','cancelled')", [row.id]);
+        for (const wf of workflowRows) {
+          const wfRes = await c.query(`UPDATE workflow_runs SET status='failed', finished_at=$2,
+             error='parent loop run lease expired before completion', updated_at=$2
+             WHERE id=$1 AND status NOT IN ('succeeded','failed','timed_out','cancelled')`, [wf.id, finished]);
+          if (wfRes.rowCount !== 1)
+            continue;
+          await c.execute(`UPDATE workflow_step_runs SET status='skipped', finished_at=$2, pid=NULL,
+             error='parent loop run lease expired before completion', updated_at=$2
+             WHERE workflow_run_id=$1 AND status IN ('pending','running')`, [wf.id, finished]);
+          await this.setWorkItemsForWorkflowRun(c, wf.id, "failed", "parent loop run lease expired before completion", finished);
+        }
+        const loop = await this.loadLoop(c, row.loop_id);
+        const itemStatus = workItemStatusForLoopRun("abandoned", row.attempt, loop?.maxAttempts);
+        if (itemStatus) {
+          const statuses = itemStatus === "admitted" ? ["admitted", "running", "failed"] : ["admitted", "running"];
+          const reason = itemStatus === "admitted" ? "run lease expired before completion; retry pending" : "run lease expired before completion";
+          await this.setWorkItemsForLoop(c, row.loop_id, itemStatus, reason, finished, statuses);
+        }
+        return this.loadRun(c, row.id);
+      });
+      if (run)
+        recovered.push(run);
+    }
+    return { abandoned: recovered, deferred: [] };
+  }
+  async pruneHistory(...args) {
+    const opts = args[0];
+    const { maxAgeDays, keepPerLoop } = opts;
+    if (maxAgeDays === undefined && keepPerLoop === undefined) {
+      throw new ValidationError("pruneHistory requires maxAgeDays and/or keepPerLoop");
+    }
+    if (maxAgeDays !== undefined && (!Number.isFinite(maxAgeDays) || maxAgeDays < 0)) {
+      throw new ValidationError(`pruneHistory maxAgeDays must be a non-negative number: ${maxAgeDays}`);
+    }
+    if (keepPerLoop !== undefined && (!Number.isInteger(keepPerLoop) || keepPerLoop < 0)) {
+      throw new ValidationError(`pruneHistory keepPerLoop must be a non-negative integer: ${keepPerLoop}`);
+    }
+    const now = opts.now ?? new Date;
+    const dryRun = opts.dryRun ?? false;
+    const cutoff = maxAgeDays === undefined ? undefined : new Date(now.getTime() - maxAgeDays * 86400000).toISOString();
+    const terminal = TERMINAL_RUN_STATUSES2.map((s) => `'${s}'`).join(",");
+    const candidateIds = (await this.client.many(`WITH ranked AS (
+           SELECT id, status, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS recency
+           FROM loop_runs
+         )
+         SELECT id FROM ranked
+         WHERE status IN (${terminal})
+           AND ($1::timestamptz IS NULL OR created_at < $1::timestamptz)
+           AND ($2::int IS NULL OR recency > $2)`, [cutoff ?? null, keepPerLoop ?? null])).map((r) => r.id);
+    const summary = {
+      dryRun,
+      cutoff,
+      keepPerLoop,
+      loopRuns: dryRun ? candidateIds.length : 0,
+      workflowRuns: 0,
+      goalRuns: 0
+    };
+    for (let offset = 0;offset < candidateIds.length; offset += PRUNE_BATCH_SIZE2) {
+      const batch = candidateIds.slice(offset, offset + PRUNE_BATCH_SIZE2);
+      if (dryRun) {
+        const workflowRunIds = (await this.client.many(`SELECT id FROM workflow_runs WHERE loop_run_id = ANY($1)`, [batch])).map((r) => r.id);
+        summary.workflowRuns += workflowRunIds.length;
+        const gr = await this.client.get(`SELECT COUNT(*)::int AS count FROM goal_runs WHERE loop_run_id = ANY($1) OR workflow_run_id = ANY($2)`, [batch, workflowRunIds]);
+        summary.goalRuns += gr?.count ?? 0;
+        continue;
+      }
+      await this.client.transaction(async (c) => {
+        const confirmed = (await c.many(`SELECT id FROM loop_runs WHERE id = ANY($1) AND status IN (${terminal})`, [batch])).map((r) => r.id);
+        if (confirmed.length === 0)
+          return;
+        const workflowRunIds = (await c.many(`SELECT id FROM workflow_runs WHERE loop_run_id = ANY($1)`, [confirmed])).map((r) => r.id);
+        summary.loopRuns += confirmed.length;
+        summary.workflowRuns += workflowRunIds.length;
+        const gr = await c.query(`DELETE FROM goal_runs WHERE loop_run_id = ANY($1) OR workflow_run_id = ANY($2)`, [confirmed, workflowRunIds]);
+        summary.goalRuns += gr.rowCount;
+        if (workflowRunIds.length > 0) {
+          await c.execute(`DELETE FROM workflow_runs WHERE id = ANY($1)`, [workflowRunIds]);
+        }
+        await c.execute(`DELETE FROM loop_runs WHERE id = ANY($1) AND status IN (${terminal})`, [confirmed]);
+      });
+    }
+    return summary;
+  }
+  async acquireDaemonLease(...args) {
+    const input = args[0];
+    const now = input.now ?? new Date;
+    const expiresAt = new Date(now.getTime() + input.ttlMs).toISOString();
+    return this.client.transaction(async (c) => {
+      const existing = await c.get("SELECT * FROM daemon_lease LIMIT 1 FOR UPDATE", []);
+      if (existing && existing.expires_at > now.toISOString() && existing.id !== input.id) {
+        return;
+      }
+      await c.execute("DELETE FROM daemon_lease", []);
+      await c.execute(`INSERT INTO daemon_lease (id, pid, hostname, heartbeat_at, expires_at, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,$5,$4,$4)`, [input.id, input.pid, input.hostname, now.toISOString(), expiresAt]);
+      return this.loadDaemonLease(c);
+    });
+  }
+  async heartbeatDaemonLease(...args) {
+    const [id, ttlMs, now = new Date] = args;
+    const expiresAt = new Date(now.getTime() + ttlMs).toISOString();
+    const res = await this.client.query(`UPDATE daemon_lease SET heartbeat_at=$2, expires_at=$3, updated_at=$2 WHERE id=$1 AND expires_at > $4`, [id, now.toISOString(), expiresAt, now.toISOString()]);
+    if (res.rowCount !== 1)
+      return;
+    return this.getDaemonLease();
+  }
+  async releaseDaemonLease(...args) {
+    await this.client.execute("DELETE FROM daemon_lease WHERE id = $1", [args[0]]);
+  }
+  async getDaemonLease(...args) {
+    return this.loadDaemonLease(this.client);
+  }
+  async loadWorkflow(c, id) {
+    const row = await c.get("SELECT * FROM workflow_specs WHERE id = $1", [id]);
+    return row ? rowToWorkflow(row) : undefined;
+  }
+  async getWorkflow(...args) {
+    return this.loadWorkflow(this.client, args[0]);
+  }
+  async listWorkflows(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 200;
+    const offset = opts.offset ?? 0;
+    const rows = opts.status ? await this.client.many("SELECT * FROM workflow_specs WHERE status = $1 ORDER BY status ASC, name ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]) : await this.client.many("SELECT * FROM workflow_specs ORDER BY status ASC, name ASC LIMIT $1 OFFSET $2", [limit, offset]);
+    return rows.map(rowToWorkflow);
+  }
+  async countWorkflows(...args) {
+    const opts = args[0] ?? {};
+    const row = opts.status ? await this.client.get("SELECT COUNT(*)::int AS count FROM workflow_specs WHERE status = $1", [opts.status]) : await this.client.get("SELECT COUNT(*)::int AS count FROM workflow_specs", []);
+    return row?.count ?? 0;
+  }
+  async getWorkflowInvocation(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_invocations WHERE id = $1", [args[0]]);
+    return row ? rowToWorkflowInvocation(row) : undefined;
+  }
+  async listWorkflowInvocations(...args) {
+    const opts = args[0] ?? {};
+    const rows = await this.client.many("SELECT * FROM workflow_invocations ORDER BY created_at DESC LIMIT $1", [opts.limit ?? 100]);
+    return rows.map(rowToWorkflowInvocation);
+  }
+  async getWorkflowWorkItem(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_work_items WHERE id = $1", [args[0]]);
+    return row ? rowToWorkflowWorkItem(row) : undefined;
+  }
+  async listWorkflowWorkItems(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.status && opts.routeKey) {
+      rows = await this.client.many("SELECT * FROM workflow_work_items WHERE status = $1 AND route_key = $2 ORDER BY priority DESC, created_at ASC LIMIT $3", [opts.status, opts.routeKey, limit]);
+    } else if (opts.status) {
+      rows = await this.client.many("SELECT * FROM workflow_work_items WHERE status = $1 ORDER BY priority DESC, created_at ASC LIMIT $2", [opts.status, limit]);
+    } else if (opts.routeKey) {
+      rows = await this.client.many("SELECT * FROM workflow_work_items WHERE route_key = $1 ORDER BY priority DESC, created_at ASC LIMIT $2", [opts.routeKey, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM workflow_work_items ORDER BY priority DESC, created_at ASC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToWorkflowWorkItem);
+  }
+  async countActiveWorkflowWorkItems(...args) {
+    const a = args[0] ?? {};
+    const active = "('admitted','running')";
+    const scoped = async (col, val) => {
+      const row = await this.client.get(`SELECT COUNT(*)::int AS count FROM workflow_work_items WHERE status IN ${active} AND ${col} = $1`, [val]);
+      return row?.count ?? 0;
+    };
+    const routeScope = a.routeScope?.trim() || undefined;
+    const global = routeScope ? await scoped("route_scope", routeScope) : (await this.client.get(`SELECT COUNT(*)::int AS count FROM workflow_work_items WHERE status IN ${active}`, []))?.count ?? 0;
+    const project = a.projectKey ? await scoped("project_key", a.projectKey) : 0;
+    const projectGroup = a.projectGroup ? await scoped("project_group", a.projectGroup) : undefined;
+    return {
+      global,
+      project,
+      ...projectGroup !== undefined ? { projectGroup } : {}
+    };
+  }
+  async getWorkflowRun(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_runs WHERE id = $1", [args[0]]);
+    return row ? rowToWorkflowRun(row) : undefined;
+  }
+  async listWorkflowRuns(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.workflowId && opts.loopRunId) {
+      rows = await this.client.many("SELECT * FROM workflow_runs WHERE workflow_id = $1 AND loop_run_id = $2 ORDER BY created_at DESC LIMIT $3", [opts.workflowId, opts.loopRunId, limit]);
+    } else if (opts.workflowId) {
+      rows = await this.client.many("SELECT * FROM workflow_runs WHERE workflow_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.workflowId, limit]);
+    } else if (opts.loopRunId) {
+      rows = await this.client.many("SELECT * FROM workflow_runs WHERE loop_run_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.loopRunId, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM workflow_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToWorkflowRun);
+  }
+  async listWorkflowStepRuns(...args) {
+    const rows = await this.client.many("SELECT * FROM workflow_step_runs WHERE workflow_run_id = $1 ORDER BY sequence ASC", [args[0]]);
+    return rows.map(rowToWorkflowStepRun);
+  }
+  async getWorkflowStepRun(...args) {
+    const row = await this.client.get("SELECT * FROM workflow_step_runs WHERE workflow_run_id = $1 AND step_id = $2", [args[0], args[1]]);
+    return row ? rowToWorkflowStepRun(row) : undefined;
+  }
+  async listWorkflowEvents(...args) {
+    const [workflowRunId, limit = 200] = args;
+    const rows = await this.client.many("SELECT * FROM workflow_events WHERE workflow_run_id = $1 ORDER BY sequence ASC LIMIT $2", [workflowRunId, limit]);
+    return rows.map(rowToWorkflowEvent);
+  }
+  async getGoal(...args) {
+    const row = await this.client.get("SELECT * FROM goals WHERE id = $1", [args[0]]);
+    return row ? rowToGoal(row) : undefined;
+  }
+  async listGoals(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    const rows = opts.status ? await this.client.many("SELECT * FROM goals WHERE status = $1 ORDER BY updated_at DESC LIMIT $2", [opts.status, limit]) : await this.client.many("SELECT * FROM goals ORDER BY updated_at DESC LIMIT $1", [limit]);
+    return rows.map(rowToGoal);
+  }
+  async listGoalPlanNodes(...args) {
+    const idOrPlan = args[0];
+    const rows = await this.client.many("SELECT * FROM goal_plan_nodes WHERE goal_id = $1 OR plan_id = $1 ORDER BY sequence ASC", [idOrPlan]);
+    return rows.map((r) => rowToGoalPlanNode({ ...r, ready: r.ready ? 1 : 0 }));
+  }
+  async listGoalRuns(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.runId) {
+      rows = await this.client.many("SELECT * FROM goal_runs WHERE id = $1", [opts.runId]);
+    } else if (opts.goalId) {
+      rows = await this.client.many("SELECT * FROM goal_runs WHERE goal_id = $1 ORDER BY created_at ASC LIMIT $2", [opts.goalId, limit]);
+    } else {
+      rows = await this.client.many("SELECT * FROM goal_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+    }
+    return rows.map(rowToGoalRun);
+  }
+  createWorkflow() {
+    throw new NotImplementedError("createWorkflow");
+  }
+  archiveWorkflow() {
+    throw new NotImplementedError("archiveWorkflow");
+  }
+  createWorkflowInvocation() {
+    throw new NotImplementedError("createWorkflowInvocation");
+  }
+  upsertWorkflowWorkItem() {
+    throw new NotImplementedError("upsertWorkflowWorkItem");
+  }
+  admitWorkflowWorkItem() {
+    throw new NotImplementedError("admitWorkflowWorkItem");
+  }
+  createGoal() {
+    throw new NotImplementedError("createGoal");
+  }
+  createGoalPlanNodes() {
+    throw new NotImplementedError("createGoalPlanNodes");
+  }
+  updateGoalStatus() {
+    throw new NotImplementedError("updateGoalStatus");
+  }
+  updateGoalPlanNode() {
+    throw new NotImplementedError("updateGoalPlanNode");
+  }
+  recordGoalEvent() {
+    throw new NotImplementedError("recordGoalEvent");
+  }
+  createWorkflowRun() {
+    throw new NotImplementedError("createWorkflowRun");
+  }
+  startWorkflowStepRun() {
+    throw new NotImplementedError("startWorkflowStepRun");
+  }
+  recoverWorkflowRun() {
+    throw new NotImplementedError("recoverWorkflowRun");
+  }
+  finalizeWorkflowStepRun() {
+    throw new NotImplementedError("finalizeWorkflowStepRun");
+  }
+  finalizeWorkflowRun() {
+    throw new NotImplementedError("finalizeWorkflowRun");
+  }
+  appendWorkflowEvent() {
+    throw new NotImplementedError("appendWorkflowEvent");
+  }
+}
+function createPostgresLoopStorage(client) {
+  return new PostgresLoopStorage(client);
+}
 export {
   createSqliteLoopStorage,
   createPostgresStorage,
+  createPostgresLoopStorage,
   checksumStorageSql,
   Store,
   SqliteLoopStorage,
   PostgresStorage,
+  PostgresLoopStorage,
   POSTGRES_STORAGE_MIGRATIONS,
-  POSTGRES_MIGRATION_LEDGER_TABLE
+  POSTGRES_MIGRATION_LEDGER_TABLE,
+  NotImplementedError
 };