@hasna/loops 0.4.0 → 0.4.2

package/dist/lib/storage/sqlite.js

@@ -0,0 +1,4187 @@
+// @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";
+
+// src/lib/errors.ts
+class CodedError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+  }
+}
+
+class LoopNotFoundError extends CodedError {
+  constructor(idOrName) {
+    super("LOOP_NOT_FOUND", `loop not found: ${idOrName}`);
+  }
+}
+
+class LoopArchivedError extends CodedError {
+  constructor(idOrName) {
+    super("LOOP_ARCHIVED", `loop is archived: ${idOrName}; unarchive it before modifying`);
+  }
+}
+
+class AmbiguousNameError extends CodedError {
+  constructor(name) {
+    super("AMBIGUOUS_NAME", `ambiguous loop name: ${name}; use a loop id`);
+  }
+}
+
+class ValidationError extends CodedError {
+  constructor(message) {
+    super("VALIDATION_ERROR", message);
+  }
+}
+
+// src/lib/ids.ts
+import { randomBytes } from "crypto";
+var TIME_HEX_LENGTH = 12;
+function genId() {
+  const time = Date.now().toString(16).padStart(TIME_HEX_LENGTH, "0");
+  return `${time}${randomBytes(10).toString("hex")}`;
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+
+// src/lib/paths.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function dataDir() {
+  return process.env.LOOPS_DATA_DIR || join(homedir(), ".hasna", "loops");
+}
+function ensureDataDir() {
+  const dir = dataDir();
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+function dbPath() {
+  return join(dataDir(), "loops.db");
+}
+function pidFilePath() {
+  return join(dataDir(), "daemon.pid");
+}
+function daemonLogPath() {
+  return join(dataDir(), "daemon.log");
+}
+function systemdServicePath() {
+  return join(homedir(), ".config", "systemd", "user", "loops-daemon.service");
+}
+function launchdPlistPath() {
+  return join(homedir(), "Library", "LaunchAgents", "com.hasna.loops.daemon.plist");
+}
+
+// src/lib/process-identity.ts
+import { readFileSync } from "fs";
+import { spawnSync } from "child_process";
+var START_TIME_TOLERANCE_MS = 5000;
+var clockTicksCache;
+function clockTicksPerSecond() {
+  if (clockTicksCache !== undefined)
+    return clockTicksCache;
+  try {
+    const run = spawnSync("getconf", ["CLK_TCK"], { encoding: "utf8" });
+    const value = Number(run.stdout.trim());
+    clockTicksCache = run.status === 0 && Number.isFinite(value) && value > 0 ? value : 100;
+  } catch {
+    clockTicksCache = 100;
+  }
+  return clockTicksCache;
+}
+var bootTimeCache;
+var bootTimeResolved = false;
+function bootTimeMs() {
+  if (bootTimeResolved)
+    return bootTimeCache;
+  bootTimeResolved = true;
+  try {
+    const match = readFileSync("/proc/stat", "utf8").match(/^btime (\d+)$/m);
+    bootTimeCache = match ? Number(match[1]) * 1000 : undefined;
+  } catch {
+    bootTimeCache = undefined;
+  }
+  return bootTimeCache;
+}
+function procStatFields(path) {
+  try {
+    const stat = readFileSync(path, "utf8");
+    const closeParen = stat.lastIndexOf(")");
+    if (closeParen < 0)
+      return;
+    return stat.slice(closeParen + 2).split(" ");
+  } catch {
+    return;
+  }
+}
+function processStartTimeMs(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return;
+  if (process.platform === "linux") {
+    const fields = procStatFields(`/proc/${pid}/stat`);
+    const startTicks = fields ? Number(fields[19]) : Number.NaN;
+    const boot = bootTimeMs();
+    if (Number.isFinite(startTicks) && boot !== undefined) {
+      return boot + Math.round(startTicks / clockTicksPerSecond() * 1000);
+    }
+  }
+  try {
+    const run = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" });
+    if (run.status === 0) {
+      const parsed = Date.parse(run.stdout.trim());
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  } catch {}
+  return;
+}
+function sameProcessStart(recorded, actualMs, toleranceMs = START_TIME_TOLERANCE_MS) {
+  if (recorded === undefined || actualMs === undefined)
+    return true;
+  const recordedMs = typeof recorded === "number" ? recorded : Date.parse(recorded);
+  if (!Number.isFinite(recordedMs))
+    return true;
+  return Math.abs(recordedMs - actualMs) <= toleranceMs;
+}
+function verifiedProcessStart(recorded, actualMs, toleranceMs = START_TIME_TOLERANCE_MS) {
+  if (recorded === undefined || actualMs === undefined)
+    return false;
+  const recordedMs = typeof recorded === "number" ? recorded : Date.parse(recorded);
+  if (!Number.isFinite(recordedMs))
+    return false;
+  return Math.abs(recordedMs - actualMs) <= toleranceMs;
+}
+
+// src/lib/redact.ts
+var SCRUBBED = "[SCRUBBED]";
+var TOKEN_PATTERNS = [
+  /\bsk-ant-[A-Za-z0-9_-]{8,}/g,
+  /\bsk-proj-[A-Za-z0-9_-]{8,}/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bghp_[A-Za-z0-9]{16,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{16,}\b/g,
+  /\bxox[a-z]-[A-Za-z0-9-]{8,}/g,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{10,}\b/g
+];
+var AUTHORIZATION_PATTERN = /(\bAuthorization(?:\\?["'])?\s*[:=]\s*(?:\\?["'])?(?:Bearer|Basic)\s+)[A-Za-z0-9._~+/=-]{16,}/gi;
+var PEM_PATTERN = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/g;
+var ASSIGNMENT_PATTERN = /([A-Za-z0-9_.-]{0,64}(?:key|token|secret|passwd|password|passphrase|credentials?)(?:\\?["'])?\s*[:=]\s*)(\\"([^"\\\r\n]{12,})\\"|"((?:[^"\\\r\n]|\\[^\r\n]){12,})"|'([^'\\\r\n]{12,})'|([A-Za-z0-9+/_.=-]{16,}))/gi;
+var BENIGN_KEY_NAME_PATTERN = /(?:^|[._-])(?:idempotency|dedupe|route)[_-]?key$/i;
+var ASSIGNMENT_HINTS = ["key", "token", "secret", "pass", "credential"];
+function mayContainAssignment(text) {
+  const lowered = text.toLowerCase();
+  return ASSIGNMENT_HINTS.some((hint) => lowered.includes(hint));
+}
+function shannonEntropy(value) {
+  const counts = new Map;
+  for (const char of value)
+    counts.set(char, (counts.get(char) ?? 0) + 1);
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const probability = count / value.length;
+    entropy -= probability * Math.log2(probability);
+  }
+  return entropy;
+}
+function isLikelySecretValue(value) {
+  if (value.length < 12)
+    return false;
+  if (value.includes(SCRUBBED))
+    return false;
+  if (value.startsWith("/") || value.startsWith("~") || value.startsWith("./"))
+    return false;
+  return shannonEntropy(value) >= 3.2;
+}
+function scrubSecrets(text) {
+  if (!text)
+    return text;
+  let scrubbed = text;
+  for (const pattern of TOKEN_PATTERNS)
+    scrubbed = scrubbed.replace(pattern, SCRUBBED);
+  scrubbed = scrubbed.replace(AUTHORIZATION_PATTERN, `$1${SCRUBBED}`);
+  scrubbed = scrubbed.replace(PEM_PATTERN, SCRUBBED);
+  if (!mayContainAssignment(scrubbed))
+    return scrubbed;
+  scrubbed = scrubbed.replace(ASSIGNMENT_PATTERN, (match, prefix, quotedValue, escapedQuoted, doubleQuoted, singleQuoted, bare) => {
+    const value = escapedQuoted ?? doubleQuoted ?? singleQuoted ?? bare ?? "";
+    const keyName = /^[A-Za-z0-9_.-]*/.exec(prefix)?.[0] ?? "";
+    if (BENIGN_KEY_NAME_PATTERN.test(keyName))
+      return match;
+    if (!isLikelySecretValue(value))
+      return match;
+    const quote = quotedValue.startsWith("\\\"") ? "\\\"" : quotedValue.startsWith('"') ? '"' : quotedValue.startsWith("'") ? "'" : "";
+    return `${prefix}${quote}${SCRUBBED}${quote}`;
+  });
+  return scrubbed;
+}
+function scrubSecretsDeep(value) {
+  if (typeof value === "string")
+    return scrubSecrets(value);
+  if (Array.isArray(value))
+    return value.map((entry) => scrubSecretsDeep(entry));
+  if (value !== null && typeof value === "object") {
+    const toJSON = value.toJSON;
+    if (typeof toJSON === "function")
+      return scrubSecretsDeep(toJSON.call(value));
+    const scrubbed = {};
+    for (const [key, entry] of Object.entries(value))
+      scrubbed[key] = scrubSecretsDeep(entry);
+    return scrubbed;
+  }
+  return value;
+}
+
+// src/lib/recurrence.ts
+function assertDate(value, label) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()))
+    throw new Error(`invalid ${label}: ${value}`);
+  return date;
+}
+function parseField(expr, min, max) {
+  const out = new Set;
+  for (const part of expr.split(",")) {
+    const [rangePart, stepPart] = part.split("/");
+    const step = stepPart ? Number(stepPart) : 1;
+    if (!Number.isInteger(step) || step <= 0)
+      throw new Error(`invalid cron step: ${part}`);
+    let lo = min;
+    let hi = max;
+    if (rangePart && rangePart !== "*") {
+      const bounds = rangePart.split("-");
+      if (bounds.length === 1) {
+        lo = hi = Number(bounds[0]);
+      } else if (bounds.length === 2) {
+        lo = Number(bounds[0]);
+        hi = Number(bounds[1]);
+      } else {
+        throw new Error(`invalid cron range: ${part}`);
+      }
+      if (!Number.isInteger(lo) || !Number.isInteger(hi))
+        throw new Error(`invalid cron field: ${part}`);
+    }
+    for (let v = lo;v <= hi; v += step) {
+      if (v < min || v > max)
+        throw new Error(`cron value out of range: ${v} in ${expr}`);
+      out.add(v);
+    }
+  }
+  return out;
+}
+var MINUTE_MS = 60000;
+var PARSED_CRON_CACHE_LIMIT = 256;
+var parsedCronCache = new Map;
+var emittedScheduleWarnings = new Set;
+function warnOnce(key, message) {
+  if (emittedScheduleWarnings.has(key))
+    return;
+  emittedScheduleWarnings.add(key);
+  console.warn(`[open-loops] WARN ${message}`);
+}
+function parseCron(expr) {
+  const cached = parsedCronCache.get(expr);
+  if (cached)
+    return cached;
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5)
+    throw new Error(`cron must have 5 fields, got ${fields.length}: "${expr}"`);
+  const [minute, hour, dom, month, dow] = fields;
+  const dowSet = parseField(dow, 0, 7);
+  if (dowSet.has(7)) {
+    dowSet.delete(7);
+    dowSet.add(0);
+  }
+  const parsed = {
+    minute: parseField(minute, 0, 59),
+    hour: parseField(hour, 0, 23),
+    dom: parseField(dom, 1, 31),
+    month: parseField(month, 1, 12),
+    dow: dowSet,
+    domRestricted: dom !== "*",
+    dowRestricted: dow !== "*"
+  };
+  if (parsedCronCache.size >= PARSED_CRON_CACHE_LIMIT) {
+    const oldest = parsedCronCache.keys().next().value;
+    if (oldest !== undefined)
+      parsedCronCache.delete(oldest);
+  }
+  parsedCronCache.set(expr, parsed);
+  return parsed;
+}
+function cronMatches(cron, date) {
+  if (!cron.minute.has(date.getMinutes()))
+    return false;
+  if (!cron.hour.has(date.getHours()))
+    return false;
+  if (!cron.month.has(date.getMonth() + 1))
+    return false;
+  const domOk = cron.dom.has(date.getDate());
+  const dowOk = cron.dow.has(date.getDay());
+  if (cron.domRestricted && cron.dowRestricted)
+    return domOk || dowOk;
+  if (cron.domRestricted)
+    return domOk;
+  if (cron.dowRestricted)
+    return dowOk;
+  return true;
+}
+function nextCronRun(expr, from) {
+  const cron = parseCron(expr);
+  const date = new Date(from.getTime());
+  date.setSeconds(0, 0);
+  date.setMinutes(date.getMinutes() + 1);
+  const limit = from.getTime() + 366 * 24 * 60 * 60 * 1000;
+  while (date.getTime() <= limit) {
+    if (cronMatches(cron, date))
+      return date;
+    date.setMinutes(date.getMinutes() + 1);
+  }
+  throw new Error(`no cron match within one year for: ${expr}`);
+}
+function initialNextRun(schedule, from = new Date) {
+  switch (schedule.type) {
+    case "once":
+      return assertDate(schedule.at, "schedule.at").toISOString();
+    case "interval":
+      if (!Number.isFinite(schedule.everyMs) || schedule.everyMs <= 0)
+        throw new Error("interval everyMs must be > 0");
+      return new Date(from.getTime() + schedule.everyMs).toISOString();
+    case "cron":
+      return nextCronRun(schedule.expression, from).toISOString();
+    case "dynamic":
+      return new Date(from.getTime() + (schedule.minIntervalMs ?? 60000)).toISOString();
+  }
+}
+function computeNextAfter(schedule, scheduledFor, finishedAt) {
+  switch (schedule.type) {
+    case "once":
+      return;
+    case "interval": {
+      const anchor = schedule.anchor ?? "fixed_rate";
+      const base = anchor === "fixed_delay" ? finishedAt : scheduledFor;
+      let next = new Date(base.getTime() + schedule.everyMs);
+      while (next.getTime() <= finishedAt.getTime())
+        next = new Date(next.getTime() + schedule.everyMs);
+      return next.toISOString();
+    }
+    case "cron": {
+      let next = nextCronRun(schedule.expression, scheduledFor);
+      while (next.getTime() <= finishedAt.getTime())
+        next = nextCronRun(schedule.expression, next);
+      return next.toISOString();
+    }
+    case "dynamic":
+      return new Date(finishedAt.getTime() + (schedule.minIntervalMs ?? 60000)).toISOString();
+  }
+}
+function latestIntervalSlot(first, now, everyMs) {
+  if (first.getTime() > now.getTime())
+    return first;
+  const steps = Math.floor((now.getTime() - first.getTime()) / everyMs);
+  return new Date(first.getTime() + steps * everyMs);
+}
+function floorToMinute(date) {
+  const floored = new Date(date.getTime());
+  floored.setSeconds(0, 0);
+  return floored;
+}
+var LATEST_CRON_SCAN_LIMIT_MINUTES = 366 * 24 * 60;
+function latestDailyCronSlot(cron, now) {
+  const hoursDesc = [...cron.hour].sort((a, b) => b - a);
+  const minutesDesc = [...cron.minute].sort((a, b) => b - a);
+  const candidate = floorToMinute(now);
+  for (let dayOffset = 0;dayOffset < 2; dayOffset += 1) {
+    const isToday = dayOffset === 0;
+    for (const hour of hoursDesc) {
+      if (isToday && hour > now.getHours())
+        continue;
+      const minuteCap = isToday && hour === now.getHours() ? now.getMinutes() : 59;
+      const minute = minutesDesc.find((value) => value <= minuteCap);
+      if (minute === undefined)
+        continue;
+      candidate.setHours(hour, minute, 0, 0);
+      return candidate;
+    }
+    candidate.setDate(candidate.getDate() - 1);
+  }
+  throw new Error("unreachable: daily cron pattern must match within two days");
+}
+function latestCronSlot(first, now, expression) {
+  if (first.getTime() > now.getTime())
+    return first;
+  const cron = parseCron(expression);
+  if (!cron.domRestricted && !cron.dowRestricted && cron.month.size === 12) {
+    const latest = latestDailyCronSlot(cron, now);
+    return latest.getTime() >= first.getTime() ? latest : first;
+  }
+  const scanFloorMs = Math.max(first.getTime(), now.getTime() - LATEST_CRON_SCAN_LIMIT_MINUTES * MINUTE_MS);
+  const cursor = floorToMinute(now);
+  while (cursor.getTime() >= scanFloorMs) {
+    if (cronMatches(cron, cursor))
+      return cursor;
+    cursor.setMinutes(cursor.getMinutes() - 1);
+  }
+  if (first.getTime() < scanFloorMs) {
+    warnOnce(`latest-cron:${expression}`, `latestCronSlot: no match for "${expression}" within the ${LATEST_CRON_SCAN_LIMIT_MINUTES}-minute scan window; using the stored next run as the latest slot`);
+  }
+  return first;
+}
+var MAX_CATCH_UP_SLOTS = 1000;
+function catchUpSlotLimit(loop) {
+  if (loop.catchUpLimit > MAX_CATCH_UP_SLOTS) {
+    warnOnce(`catch-up-limit:${loop.id}`, `dueSlots: loop ${loop.id} catchUpLimit ${loop.catchUpLimit} exceeds the per-plan cap; using ${MAX_CATCH_UP_SLOTS}`);
+    return MAX_CATCH_UP_SLOTS;
+  }
+  return loop.catchUpLimit;
+}
+function dueSlots(loop, now) {
+  if (!loop.nextRunAt || loop.status !== "active")
+    return { slots: [] };
+  if (loop.expiresAt && new Date(loop.expiresAt).getTime() <= now.getTime())
+    return { slots: [] };
+  const next = assertDate(loop.nextRunAt, "loop.nextRunAt");
+  if (next.getTime() > now.getTime())
+    return { slots: [] };
+  if (loop.retryScheduledFor)
+    return { slots: [loop.retryScheduledFor] };
+  const catchUp = loop.catchUp;
+  switch (loop.schedule.type) {
+    case "once":
+    case "dynamic":
+      return { slots: [next.toISOString()] };
+    case "interval": {
+      if (catchUp === "all") {
+        const limit = catchUpSlotLimit(loop);
+        const slots = [];
+        let cursor = next;
+        while (cursor.getTime() <= now.getTime() && slots.length < limit) {
+          slots.push(cursor.toISOString());
+          cursor = new Date(cursor.getTime() + loop.schedule.everyMs);
+        }
+        return { slots };
+      }
+      if (catchUp === "latest")
+        return { slots: [latestIntervalSlot(next, now, loop.schedule.everyMs).toISOString()] };
+      return { slots: [next.toISOString()] };
+    }
+    case "cron": {
+      if (catchUp === "all") {
+        const limit = catchUpSlotLimit(loop);
+        const slots = [];
+        let cursor = next;
+        while (cursor.getTime() <= now.getTime() && slots.length < limit) {
+          slots.push(cursor.toISOString());
+          cursor = nextCronRun(loop.schedule.expression, cursor);
+        }
+        return { slots };
+      }
+      if (catchUp === "latest")
+        return { slots: [latestCronSlot(next, now, loop.schedule.expression).toISOString()] };
+      return { slots: [next.toISOString()] };
+    }
+  }
+}
+function parseDuration(input) {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/);
+  if (!match)
+    throw new Error(`invalid duration: ${input}`);
+  const value = Number(match[1]);
+  const unit = match[2] ?? "ms";
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60000 : unit === "h" ? 3600000 : 86400000;
+  return Math.round(value * multiplier);
+}
+
+// src/lib/goal/types.ts
+var GOAL_TERMINAL = ["budgetLimited", "complete", "cancelled"];
+var GOAL_OBJECTIVE_MAX_CHARS = 4000;
+
+// src/lib/goal/status.ts
+function isTerminal(status) {
+  return GOAL_TERMINAL.includes(status);
+}
+function nodeBudgetExhausted(node) {
+  return node.tokenBudget !== undefined && node.tokensUsed >= node.tokenBudget;
+}
+function readyNodeKeys(plan) {
+  if (plan.status !== "active")
+    return [];
+  const byKey = new Map(plan.nodes.map((node) => [node.key, node]));
+  return plan.nodes.filter((node) => {
+    if (node.status !== "pending")
+      return false;
+    if (nodeBudgetExhausted(node))
+      return false;
+    return node.dependsOn.every((dependency) => byKey.get(dependency)?.status === "complete");
+  }).sort((a, b) => b.priority - a.priority || a.sequence - b.sequence || a.key.localeCompare(b.key)).map((node) => node.key);
+}
+function rollupSummary(nodes) {
+  const rollup = {
+    total: nodes.length,
+    pending: 0,
+    active: 0,
+    paused: 0,
+    blocked: 0,
+    usageLimited: 0,
+    budgetLimited: 0,
+    complete: 0,
+    cancelled: 0
+  };
+  for (const node of nodes) {
+    if (node.status in rollup) {
+      rollup[node.status] += 1;
+    }
+  }
+  return rollup;
+}
+function assertGoalTransition(from, to) {
+  if (isTerminal(from) && from !== to) {
+    throw new Error(`cannot transition terminal goal status ${from} to ${to}`);
+  }
+}
+function assertAcyclicNodes(nodes) {
+  const byKey = new Map(nodes.map((node) => [node.key, node]));
+  const visiting = new Set;
+  const visited = new Set;
+  function visit(key) {
+    if (visited.has(key))
+      return;
+    if (visiting.has(key))
+      throw new Error(`goal dependency cycle includes node ${key}`);
+    const node = byKey.get(key);
+    if (!node)
+      throw new Error(`goal plan references missing node ${key}`);
+    visiting.add(key);
+    for (const dependency of node.dependsOn) {
+      if (!byKey.has(dependency))
+        throw new Error(`goal node ${key} depends on missing node ${dependency}`);
+      visit(dependency);
+    }
+    visiting.delete(key);
+    visited.add(key);
+  }
+  for (const node of nodes)
+    visit(node.key);
+}
+function updateReadyFlags(nodes, planStatus) {
+  const ready = new Set(readyNodeKeys({ status: planStatus, nodes }));
+  return nodes.map((node) => ({ ...node, ready: ready.has(node.key) }));
+}
+
+// src/lib/workflow-spec.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { isAbsolute, resolve } from "path";
+
+// src/lib/agent-adapter.ts
+import { spawn } from "child_process";
+var UNSAFE_CODEWITH_DURABLE_EXTRA_ARGS = new Set([
+  "e",
+  "exec",
+  "agent",
+  "start",
+  "--ephemeral",
+  "--ignore-rules",
+  "--skip-git-repo-check",
+  "--json",
+  "--output-last-message",
+  "-o",
+  "--output-schema",
+  "--dangerously-bypass-approvals-and-sandbox"
+]);
+var CODEX_LIKE_SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
+var CURSOR_SANDBOXES = ["enabled", "disabled"];
+var PERMISSION_MODES = ["default", "plan", "auto", "bypass"];
+function assertOptionalNonEmptyString(value, label) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || value.trim() === "")
+    throw new Error(`${label} must be a non-empty string`);
+}
+function validateAgentOptions(target, label, capabilities) {
+  const provider = target.provider;
+  if (typeof target.prompt !== "string" || target.prompt.trim() === "") {
+    throw new Error(`${label}.prompt must be a non-empty string`);
+  }
+  assertOptionalNonEmptyString(target.model, `${label}.model`);
+  assertOptionalNonEmptyString(target.variant, `${label}.variant`);
+  assertOptionalNonEmptyString(target.agent, `${label}.agent`);
+  assertOptionalNonEmptyString(target.authProfile, `${label}.authProfile`);
+  assertOptionalNonEmptyString(target.configIsolation, `${label}.configIsolation`);
+  if (target.configIsolation !== undefined && target.configIsolation !== "safe" && target.configIsolation !== "none") {
+    throw new Error(`${label}.configIsolation must be safe or none`);
+  }
+  if (target.authProfile !== undefined && provider !== "codewith") {
+    throw new Error(`${label}.authProfile is currently supported only for provider codewith`);
+  }
+  if (provider === "opencode" && (typeof target.model !== "string" || target.model.trim() === "")) {
+    throw new Error(`${label}.model is required for provider opencode; pass a provider/model id such as openrouter/google/gemini-2.5-flash`);
+  }
+  if (provider === "cursor" && target.variant !== undefined) {
+    throw new Error(`${label}.variant is not supported for provider cursor`);
+  }
+  if (provider === "codex" && target.agent !== undefined) {
+    throw new Error(`${label}.agent is not supported for provider codex`);
+  }
+  if (provider === "codewith" && target.agent !== undefined) {
+    throw new Error(`${label}.agent is not supported for provider codewith durable background-agent execution`);
+  }
+  if (provider === "codewith") {
+    const unsafe = target.extraArgs?.find((arg) => UNSAFE_CODEWITH_DURABLE_EXTRA_ARGS.has(arg));
+    if (unsafe) {
+      throw new Error(`${label}.extraArgs cannot include ${unsafe}; codewith agent steps use durable agent start, not exec/ephemeral flags`);
+    }
+  }
+  if (target.addDirs?.length && !["codewith", "codex"].includes(provider)) {
+    throw new Error(`${label}.addDirs is currently supported only for provider codewith or codex`);
+  }
+  if (target.permissionMode !== undefined) {
+    if (!PERMISSION_MODES.includes(target.permissionMode)) {
+      throw new Error(`${label}.permissionMode must be one of ${PERMISSION_MODES.join(", ")}`);
+    }
+    if (target.permissionMode === "plan" && !["claude", "cursor"].includes(provider)) {
+      throw new Error(`${label}.permissionMode plan is currently supported only for provider claude or cursor`);
+    }
+    if (target.permissionMode === "auto" && provider !== "claude") {
+      throw new Error(`${label}.permissionMode auto is currently supported only for provider claude`);
+    }
+  }
+  if (target.sandbox !== undefined) {
+    if (!capabilities.sandbox.length) {
+      throw new Error(`${label}.sandbox is currently supported only for provider codewith, codex, or cursor`);
+    }
+    if (!capabilities.sandbox.includes(target.sandbox)) {
+      throw new Error(`${label}.sandbox must be one of ${capabilities.sandbox.join(", ")}`);
+    }
+  }
+}
+function codewithLikeSandbox(target) {
+  return target.sandbox ?? (target.permissionMode === "bypass" ? "danger-full-access" : "workspace-write");
+}
+function configStringValue(value) {
+  return JSON.stringify(value);
+}
+function buildAgentInvocation(target) {
+  const isolation = target.configIsolation ?? "safe";
+  const permissionMode = target.permissionMode ?? "default";
+  const args = [];
+  switch (target.provider) {
+    case "claude": {
+      if (isolation === "safe")
+        args.push("--safe-mode", "--setting-sources", "local", "--no-session-persistence");
+      if (permissionMode !== "default") {
+        const mode = permissionMode === "bypass" ? "bypassPermissions" : permissionMode;
+        args.push("--permission-mode", mode);
+      }
+      args.push("-p", "--output-format", "json");
+      if (target.model)
+        args.push("--model", target.model);
+      if (target.variant)
+        args.push("--effort", target.variant);
+      if (target.agent)
+        args.push("--agent", target.agent);
+      args.push(...target.extraArgs ?? []);
+      return { command: "claude", args, stdin: target.prompt };
+    }
+    case "cursor": {
+      args.push("-c", [
+        "set -eu",
+        "if command -v agent >/dev/null 2>&1; then",
+        '  exec agent "$@"',
+        "else",
+        "  echo 'Executable not found in PATH: agent' >&2",
+        "  exit 127",
+        "fi"
+      ].join(`
+`), "openloops-cursor", "-p");
+      if (permissionMode === "plan")
+        args.push("--mode", "plan");
+      if (permissionMode === "bypass")
+        args.push("--force");
+      const cursorSandbox = target.sandbox ?? (isolation === "safe" ? "enabled" : undefined);
+      if (cursorSandbox)
+        args.push("--sandbox", cursorSandbox);
+      if (target.model)
+        args.push("--model", target.model);
+      if (target.agent)
+        args.push("--agent", target.agent);
+      args.push(...target.extraArgs ?? []);
+      return { command: "sh", args, stdin: target.prompt, preflightAnyOf: ["agent"] };
+    }
+    case "codewith": {
+      args.push(...target.authProfile ? ["--auth-profile", target.authProfile] : []);
+      if (target.variant)
+        args.push("-c", `model_reasoning_effort=${configStringValue(target.variant)}`);
+      args.push("--ask-for-approval", "never", "--sandbox", codewithLikeSandbox(target));
+      if (target.cwd)
+        args.push("--cd", target.cwd);
+      for (const dir of target.addDirs ?? [])
+        args.push("--add-dir", dir);
+      if (target.model)
+        args.push("--model", target.model);
+      args.push(...target.extraArgs ?? []);
+      args.push("agent", "start");
+      if (target.cwd)
+        args.push("--cwd", target.cwd);
+      args.push(target.prompt);
+      return { command: "codewith", args };
+    }
+    case "codex": {
+      if (target.variant)
+        args.push("-c", `model_reasoning_effort=${configStringValue(target.variant)}`);
+      args.push("--ask-for-approval", "never", "exec", "--json", "--ephemeral", "--sandbox", codewithLikeSandbox(target), "--skip-git-repo-check");
+      if (isolation === "safe")
+        args.push("--ignore-rules");
+      if (target.cwd)
+        args.push("--cd", target.cwd);
+      for (const dir of target.addDirs ?? [])
+        args.push("--add-dir", dir);
+      if (target.model)
+        args.push("--model", target.model);
+      args.push(...target.extraArgs ?? []);
+      return { command: "codex", args, stdin: target.prompt };
+    }
+    case "aicopilot":
+    case "opencode": {
+      args.push("run", "--format", "json");
+      if (isolation === "safe")
+        args.push("--pure");
+      if (permissionMode === "bypass")
+        args.push("--dangerously-skip-permissions");
+      if (target.cwd)
+        args.push("--dir", target.cwd);
+      if (target.model)
+        args.push("--model", target.model);
+      if (target.variant)
+        args.push("--variant", target.variant);
+      if (target.agent)
+        args.push("--agent", target.agent);
+      args.push(...target.extraArgs ?? []);
+      return { command: target.provider, args, stdin: target.prompt };
+    }
+  }
+}
+function adapterFor(provider, capabilities) {
+  return {
+    provider,
+    capabilities,
+    validate(target, label = provider) {
+      validateAgentOptions(target, label, capabilities);
+    },
+    buildInvocation(target) {
+      validateAgentOptions(target, provider, capabilities);
+      return buildAgentInvocation(target);
+    }
+  };
+}
+var PROVIDER_ADAPTERS = {
+  claude: adapterFor("claude", { sandbox: [], durable: false, remote: true, promptChannel: "stdin" }),
+  cursor: adapterFor("cursor", { sandbox: CURSOR_SANDBOXES, durable: false, remote: true, promptChannel: "stdin" }),
+  codewith: adapterFor("codewith", { sandbox: CODEX_LIKE_SANDBOXES, durable: true, remote: false, promptChannel: "argv" }),
+  codex: adapterFor("codex", { sandbox: CODEX_LIKE_SANDBOXES, durable: false, remote: true, promptChannel: "stdin" }),
+  aicopilot: adapterFor("aicopilot", { sandbox: [], durable: false, remote: true, promptChannel: "stdin" }),
+  opencode: adapterFor("opencode", { sandbox: [], durable: false, remote: true, promptChannel: "stdin" })
+};
+var AGENT_PROVIDERS = Object.keys(PROVIDER_ADAPTERS);
+function providerAdapter(provider) {
+  const adapter = PROVIDER_ADAPTERS[provider];
+  if (!adapter)
+    throw new Error(`unsupported agent provider: ${String(provider)}`);
+  return adapter;
+}
+var DEFAULT_CAPTURE_MAX_OUTPUT_BYTES = 256 * 1024;
+function killProcessGroup(pgid) {
+  try {
+    process.kill(-pgid, "SIGTERM");
+  } catch {
+    try {
+      process.kill(pgid, "SIGTERM");
+    } catch {}
+  }
+  setTimeout(() => {
+    try {
+      process.kill(-pgid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pgid, "SIGKILL");
+      } catch {}
+    }
+  }, 2000).unref();
+}
+
+class BoundedOutputBuffer {
+  maxBytes;
+  text = "";
+  truncatedBytes = 0;
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+  }
+  append(chunk) {
+    if (!chunk)
+      return;
+    this.text += chunk;
+    if (Buffer.byteLength(this.text, "utf8") <= this.maxBytes)
+      return;
+    this.text = scrubSecrets(this.text);
+    const encoded = Buffer.from(this.text, "utf8");
+    if (encoded.length <= this.maxBytes)
+      return;
+    let start = encoded.length - this.maxBytes;
+    while (start < encoded.length && (encoded[start] & 192) === 128)
+      start++;
+    this.truncatedBytes += start;
+    this.text = encoded.subarray(start).toString("utf8");
+  }
+  value() {
+    if (this.truncatedBytes === 0)
+      return this.text;
+    return `[truncated ${this.truncatedBytes} bytes]
+${this.text}`;
+  }
+}
+async function spawnCapture(command, args, opts) {
+  const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_CAPTURE_MAX_OUTPUT_BYTES;
+  const stdout = new BoundedOutputBuffer(maxOutputBytes);
+  const stderr = new BoundedOutputBuffer(maxOutputBytes);
+  let timedOut = false;
+  let error;
+  const child = spawn(command, args, {
+    cwd: opts.cwd,
+    env: opts.env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    if (child.pid)
+      killProcessGroup(child.pid);
+  }, opts.timeoutMs);
+  timer.unref();
+  child.stdout?.setEncoding("utf8");
+  child.stderr?.setEncoding("utf8");
+  child.stdout?.on("data", (chunk) => stdout.append(chunk));
+  child.stderr?.on("data", (chunk) => stderr.append(chunk));
+  const [status, signal] = await new Promise((resolve) => {
+    child.once("error", (err) => {
+      error = err.message;
+      resolve([null, null]);
+    });
+    child.once("close", (code, sig) => resolve([code, sig]));
+  });
+  clearTimeout(timer);
+  if (timedOut && !error)
+    error = `timed out after ${opts.timeoutMs}ms`;
+  return { status, signal, stdout: stdout.value(), stderr: stderr.value(), error, timedOut };
+}
+
+// src/lib/workflow-spec.ts
+function assertObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+}
+function assertString(value, label) {
+  if (typeof value !== "string" || value.trim() === "")
+    throw new Error(`${label} must be a non-empty string`);
+}
+function optionalPositiveInteger(value, label) {
+  if (value === undefined)
+    return;
+  if (!Number.isInteger(value) || value <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return value;
+}
+function optionalTimeoutMs(value, label) {
+  if (value === undefined)
+    return;
+  if (value === null)
+    return null;
+  if (!Number.isInteger(value) || value <= 0)
+    throw new Error(`${label} must be a positive integer or null for unlimited`);
+  return value;
+}
+function optionalBoolean(value, label) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "boolean")
+    throw new Error(`${label} must be a boolean`);
+  return value;
+}
+function optionalStringArray(value, label) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    throw new Error(`${label} must be an array`);
+  const values = value.map((entry, index) => {
+    assertString(entry, `${label}[${index}]`);
+    return entry.trim();
+  }).filter(Boolean);
+  return values.length ? values : undefined;
+}
+function optionalAccountRef(value, label) {
+  if (value === undefined)
+    return;
+  assertObject(value, label);
+  assertString(value.profile, `${label}.profile`);
+  if (value.tool !== undefined)
+    assertString(value.tool, `${label}.tool`);
+  return {
+    profile: value.profile.trim(),
+    tool: typeof value.tool === "string" ? value.tool.trim() : undefined
+  };
+}
+function promptFilePath(rawPath, opts) {
+  return isAbsolute(rawPath) ? resolve(rawPath) : resolve(opts.baseDir ?? process.cwd(), rawPath);
+}
+function readPromptFile(rawPath, label, opts) {
+  assertString(rawPath, `${label}.promptFile`);
+  const path = promptFilePath(rawPath.trim(), opts);
+  let prompt;
+  try {
+    prompt = readFileSync2(path, "utf8");
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+    throw new Error(`${label}.promptFile could not be read${code ? `: ${code}` : ""}`);
+  }
+  if (prompt.trim() === "")
+    throw new Error(`${label}.promptFile must contain a non-empty prompt`);
+  return { prompt, promptSource: { type: "file", path } };
+}
+function matchingPromptSource(value, prompt, opts) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  if (value.type !== "file")
+    return;
+  const rawPath = value.path;
+  if (typeof rawPath !== "string" || rawPath.trim() === "")
+    return;
+  const path = promptFilePath(rawPath.trim(), opts);
+  try {
+    return readFileSync2(path, "utf8") === prompt ? { type: "file", path } : undefined;
+  } catch {
+    return;
+  }
+}
+function normalizeGoalSpec(value, label = "goal") {
+  if (value === undefined)
+    return;
+  assertObject(value, label);
+  assertString(value.objective, `${label}.objective`);
+  const objective = value.objective.trim();
+  if (objective.length > GOAL_OBJECTIVE_MAX_CHARS) {
+    throw new Error(`${label}.objective must be ${GOAL_OBJECTIVE_MAX_CHARS} characters or fewer`);
+  }
+  const autoExecute = value.autoExecute === undefined ? undefined : String(value.autoExecute);
+  if (autoExecute !== undefined && !["off", "readyOnly", "aiDirected"].includes(autoExecute)) {
+    throw new Error(`${label}.autoExecute must be off, readyOnly, or aiDirected`);
+  }
+  return {
+    objective,
+    tokenBudget: optionalPositiveInteger(value.tokenBudget, `${label}.tokenBudget`),
+    maxTurns: optionalPositiveInteger(value.maxTurns, `${label}.maxTurns`),
+    maxTokens: optionalPositiveInteger(value.maxTokens, `${label}.maxTokens`),
+    model: typeof value.model === "string" && value.model.trim() ? value.model.trim() : undefined,
+    autoExecute
+  };
+}
+function validateTarget(value, label, opts) {
+  assertObject(value, label);
+  if (value.type === "command") {
+    assertString(value.command, `${label}.command`);
+    optionalTimeoutMs(value.timeoutMs, `${label}.timeoutMs`);
+    optionalPositiveInteger(value.idleTimeoutMs, `${label}.idleTimeoutMs`);
+    if (value.shell !== true && /\s/.test(value.command.trim())) {
+      throw new Error(`${label}.command must be an executable without spaces when shell is false; put flags in args or set shell true`);
+    }
+    return value;
+  }
+  if (value.type === "agent") {
+    assertString(value.provider, `${label}.provider`);
+    const hasPrompt = typeof value.prompt === "string" && value.prompt.trim() !== "";
+    const hasPromptFile = typeof value.promptFile === "string" && value.promptFile.trim() !== "";
+    if (hasPrompt && hasPromptFile)
+      throw new Error(`${label} must use either prompt or promptFile, not both`);
+    if (!hasPrompt && !hasPromptFile)
+      throw new Error(`${label}.prompt must be a non-empty string or ${label}.promptFile must be set`);
+    const promptFields = hasPrompt ? { prompt: value.prompt, promptSource: matchingPromptSource(value.promptSource, value.prompt, opts) } : readPromptFile(value.promptFile, label, opts);
+    if (!AGENT_PROVIDERS.includes(value.provider)) {
+      throw new Error(`${label}.provider must be one of ${AGENT_PROVIDERS.join(", ")}`);
+    }
+    optionalTimeoutMs(value.timeoutMs, `${label}.timeoutMs`);
+    optionalPositiveInteger(value.idleTimeoutMs, `${label}.idleTimeoutMs`);
+    const extraArgs = optionalStringArray(value.extraArgs, `${label}.extraArgs`);
+    optionalStringArray(value.addDirs, `${label}.addDirs`);
+    providerAdapter(value.provider).validate({ ...value, extraArgs, ...promptFields }, label);
+    if (value.allowlist !== undefined) {
+      assertObject(value.allowlist, `${label}.allowlist`);
+      optionalStringArray(value.allowlist.tools, `${label}.allowlist.tools`);
+      optionalStringArray(value.allowlist.commands, `${label}.allowlist.commands`);
+      if (value.allowlist.enforcement !== undefined && value.allowlist.enforcement !== "metadata_only") {
+        throw new Error(`${label}.allowlist.enforcement must be metadata_only`);
+      }
+    }
+    if (value.worktree !== undefined) {
+      assertObject(value.worktree, `${label}.worktree`);
+      assertString(value.worktree.mode, `${label}.worktree.mode`);
+      const modes = ["auto", "required", "off", "main"];
+      if (!modes.includes(value.worktree.mode))
+        throw new Error(`${label}.worktree.mode must be one of ${modes.join(", ")}`);
+      if (typeof value.worktree.enabled !== "boolean")
+        throw new Error(`${label}.worktree.enabled must be a boolean`);
+      assertString(value.worktree.originalCwd, `${label}.worktree.originalCwd`);
+      assertString(value.worktree.cwd, `${label}.worktree.cwd`);
+      if (value.worktree.repoRoot !== undefined)
+        assertString(value.worktree.repoRoot, `${label}.worktree.repoRoot`);
+      if (value.worktree.root !== undefined)
+        assertString(value.worktree.root, `${label}.worktree.root`);
+      if (value.worktree.path !== undefined)
+        assertString(value.worktree.path, `${label}.worktree.path`);
+      if (value.worktree.branch !== undefined)
+        assertString(value.worktree.branch, `${label}.worktree.branch`);
+      if (value.worktree.reason !== undefined)
+        assertString(value.worktree.reason, `${label}.worktree.reason`);
+    }
+    if (value.routing !== undefined) {
+      assertObject(value.routing, `${label}.routing`);
+      if (value.routing.projectPath !== undefined)
+        assertString(value.routing.projectPath, `${label}.routing.projectPath`);
+      if (value.routing.projectGroup !== undefined)
+        assertString(value.routing.projectGroup, `${label}.routing.projectGroup`);
+      if (value.routing.taskId !== undefined)
+        assertString(value.routing.taskId, `${label}.routing.taskId`);
+      if (value.routing.eventId !== undefined)
+        assertString(value.routing.eventId, `${label}.routing.eventId`);
+      if (value.routing.eventType !== undefined)
+        assertString(value.routing.eventType, `${label}.routing.eventType`);
+      if (value.routing.eventSource !== undefined)
+        assertString(value.routing.eventSource, `${label}.routing.eventSource`);
+    }
+    const target = { ...value, extraArgs };
+    if (!extraArgs)
+      delete target.extraArgs;
+    delete target.promptFile;
+    delete target.promptSource;
+    return { ...target, ...promptFields };
+  }
+  throw new Error(`${label}.type must be command or agent`);
+}
+function normalizeCreateWorkflowInput(input, opts = {}) {
+  assertString(input.name, "workflow.name");
+  const goal = normalizeGoalSpec(input.goal, "goal");
+  if (!Array.isArray(input.steps) || input.steps.length === 0)
+    throw new Error("workflow.steps must contain at least one step");
+  const seen = new Set;
+  const steps = input.steps.map((step, index) => {
+    assertObject(step, `workflow.steps[${index}]`);
+    assertString(step.id, `workflow.steps[${index}].id`);
+    if (seen.has(step.id))
+      throw new Error(`duplicate workflow step id: ${step.id}`);
+    seen.add(step.id);
+    return {
+      ...step,
+      id: step.id,
+      goal: normalizeGoalSpec(step.goal, `workflow.steps[${index}].goal`),
+      target: validateTarget(step.target, `workflow.steps[${index}].target`, opts),
+      dependsOn: optionalStringArray(step.dependsOn, `workflow.steps[${index}].dependsOn`) ?? [],
+      continueOnFailure: optionalBoolean(step.continueOnFailure, `workflow.steps[${index}].continueOnFailure`) ?? false,
+      timeoutMs: optionalTimeoutMs(step.timeoutMs, `workflow.steps[${index}].timeoutMs`),
+      account: optionalAccountRef(step.account, `workflow.steps[${index}].account`)
+    };
+  });
+  for (const step of steps) {
+    for (const dependency of step.dependsOn ?? []) {
+      if (!seen.has(dependency))
+        throw new Error(`step ${step.id} depends on missing step ${dependency}`);
+      if (dependency === step.id)
+        throw new Error(`step ${step.id} cannot depend on itself`);
+    }
+  }
+  workflowExecutionOrder({ steps });
+  return { ...input, name: input.name.trim(), goal, version: input.version ?? 1, steps };
+}
+function workflowExecutionOrder(workflow) {
+  const byId = new Map(workflow.steps.map((step) => [step.id, step]));
+  const visiting = new Set;
+  const visited = new Set;
+  const order = [];
+  function visit(step) {
+    if (visited.has(step.id))
+      return;
+    if (visiting.has(step.id))
+      throw new Error(`workflow dependency cycle includes step ${step.id}`);
+    visiting.add(step.id);
+    for (const dependencyId of step.dependsOn ?? []) {
+      const dependency = byId.get(dependencyId);
+      if (!dependency)
+        throw new Error(`step ${step.id} depends on missing step ${dependencyId}`);
+      visit(dependency);
+    }
+    visiting.delete(step.id);
+    visited.add(step.id);
+    order.push(step);
+  }
+  for (const step of workflow.steps)
+    visit(step);
+  return order;
+}
+function workflowBodyFromJson(value, fallbackName, opts = {}) {
+  assertObject(value, "workflow file");
+  const rawName = fallbackName ?? value.name;
+  assertString(rawName, "workflow.name");
+  if (!Array.isArray(value.steps))
+    throw new Error("workflow.steps must be an array");
+  return normalizeCreateWorkflowInput({
+    name: rawName,
+    description: typeof value.description === "string" ? value.description : undefined,
+    goal: normalizeGoalSpec(value.goal, "goal"),
+    version: typeof value.version === "number" ? value.version : undefined,
+    steps: value.steps
+  }, opts);
+}
+
+// src/lib/run-artifacts.ts
+import { createHash } from "crypto";
+import { mkdirSync as mkdirSync2, renameSync, rmdirSync, rmSync, writeFileSync } from "fs";
+import { basename, dirname, join as join2 } from "path";
+function shortHash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function safeRunPathSlug(value, fallback) {
+  const raw = value?.trim() || fallback;
+  const slug = raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72);
+  return slug || fallback;
+}
+function workflowRunSubjectKey(kind, rawSubjectRef) {
+  const raw = rawSubjectRef?.trim() || "subject";
+  const kindSlug = safeRunPathSlug(kind, "subject").slice(0, 24);
+  const subjectSlug = safeRunPathSlug(raw, "subject").slice(0, 48);
+  return `${kindSlug}-${subjectSlug}-${shortHash(`${kindSlug}
+${raw}`)}`;
+}
+function workflowRunProjectSlug(projectKey) {
+  if (!projectKey?.trim())
+    return "global";
+  return safeRunPathSlug(projectKey.startsWith("/") ? basename(projectKey) : projectKey, "project");
+}
+function stageWorkflowRunManifest(args) {
+  const projectSlug = workflowRunProjectSlug(args.projectKey);
+  const subjectKey = workflowRunSubjectKey(args.subjectKind, args.rawSubjectRef);
+  const dir = join2(args.loopsDataDir, "runs", projectSlug, subjectKey, args.workflowRunId);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  const manifestPath = join2(dir, "manifest.json");
+  const tmpPath = `${manifestPath}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify({
+    version: 1,
+    workflowRunId: args.workflowRunId,
+    workflowId: args.workflowId,
+    workflowName: args.workflowName,
+    invocationId: args.invocationId,
+    workItemId: args.workItemId,
+    projectSlug,
+    subjectKey,
+    requiredReading: [],
+    createdAt: new Date().toISOString(),
+    ...args.payload
+  }, null, 2), { mode: 384 });
+  return { manifestPath, tmpPath };
+}
+function commitWorkflowRunManifest(staged) {
+  renameSync(staged.tmpPath, staged.manifestPath);
+  return staged.manifestPath;
+}
+function discardWorkflowRunManifest(staged) {
+  rmSync(staged.tmpPath, { force: true });
+  try {
+    rmdirSync(dirname(staged.manifestPath));
+  } catch {}
+}
+
+// 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 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"]);
+function rowToLoop(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? undefined,
+    status: row.status,
+    archivedAt: row.archived_at ?? undefined,
+    archivedFromStatus: row.archived_from_status ? row.archived_from_status : undefined,
+    schedule: JSON.parse(row.schedule_json),
+    target: JSON.parse(row.target_json),
+    goal: row.goal_json ? JSON.parse(row.goal_json) : undefined,
+    machine: row.machine_json ? JSON.parse(row.machine_json) : undefined,
+    nextRunAt: row.next_run_at ?? undefined,
+    retryScheduledFor: row.retry_scheduled_for ?? undefined,
+    catchUp: row.catch_up,
+    catchUpLimit: row.catch_up_limit,
+    overlap: row.overlap,
+    maxAttempts: row.max_attempts,
+    retryDelayMs: row.retry_delay_ms,
+    leaseMs: row.lease_ms,
+    expiresAt: row.expires_at ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToRun(row) {
+  return {
+    id: row.id,
+    loopId: row.loop_id,
+    loopName: row.loop_name,
+    scheduledFor: row.scheduled_for,
+    attempt: row.attempt,
+    status: row.status,
+    startedAt: row.started_at ?? undefined,
+    finishedAt: row.finished_at ?? undefined,
+    claimedBy: row.claimed_by ?? undefined,
+    leaseExpiresAt: row.lease_expires_at ?? undefined,
+    pid: row.pid ?? undefined,
+    pgid: row.pgid ?? undefined,
+    processStartedAt: row.process_started_at ?? undefined,
+    exitCode: row.exit_code ?? undefined,
+    durationMs: row.duration_ms ?? undefined,
+    stdout: row.stdout ?? undefined,
+    stderr: row.stderr ?? undefined,
+    error: row.error ?? undefined,
+    goalRunId: row.goal_run_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? undefined,
+    version: row.version,
+    status: row.status,
+    goal: row.goal_json ? JSON.parse(row.goal_json) : undefined,
+    steps: JSON.parse(row.steps_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowRun(row) {
+  return {
+    id: row.id,
+    workflowId: row.workflow_id,
+    workflowName: row.workflow_name,
+    loopId: row.loop_id ?? undefined,
+    loopRunId: row.loop_run_id ?? undefined,
+    invocationId: row.invocation_id ?? undefined,
+    workItemId: row.work_item_id ?? undefined,
+    scheduledFor: row.scheduled_for ?? undefined,
+    idempotencyKey: row.idempotency_key ?? undefined,
+    manifestPath: row.manifest_path ?? undefined,
+    status: row.status,
+    startedAt: row.started_at ?? undefined,
+    finishedAt: row.finished_at ?? undefined,
+    durationMs: row.duration_ms ?? undefined,
+    error: row.error ?? undefined,
+    goalRunId: row.goal_run_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowInvocation(row) {
+  return {
+    id: row.id,
+    workflowId: row.workflow_id ?? undefined,
+    templateId: row.template_id ?? undefined,
+    sourceRef: JSON.parse(row.source_json),
+    subjectRef: JSON.parse(row.subject_json),
+    intent: row.intent,
+    scope: row.scope_json ? JSON.parse(row.scope_json) : undefined,
+    outputPolicy: row.output_policy_json ? JSON.parse(row.output_policy_json) : undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowWorkItem(row) {
+  return {
+    id: row.id,
+    routeKey: row.route_key,
+    idempotencyKey: row.idempotency_key,
+    invocationId: row.invocation_id,
+    sourceType: row.source_type,
+    sourceRef: row.source_ref,
+    subjectRef: row.subject_ref,
+    projectKey: row.project_key ?? undefined,
+    projectGroup: row.project_group ?? undefined,
+    priority: row.priority,
+    status: row.status,
+    attempts: row.attempts,
+    nextAttemptAt: row.next_attempt_at ?? undefined,
+    leaseExpiresAt: row.lease_expires_at ?? undefined,
+    workflowId: row.workflow_id ?? undefined,
+    loopId: row.loop_id ?? undefined,
+    workflowRunId: row.workflow_run_id ?? undefined,
+    lastReason: row.last_reason ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowStepRun(row) {
+  return {
+    id: row.id,
+    workflowRunId: row.workflow_run_id,
+    stepId: row.step_id,
+    sequence: row.sequence,
+    status: row.status,
+    startedAt: row.started_at ?? undefined,
+    finishedAt: row.finished_at ?? undefined,
+    exitCode: row.exit_code ?? undefined,
+    pid: row.pid ?? undefined,
+    durationMs: row.duration_ms ?? undefined,
+    stdout: row.stdout ?? undefined,
+    stderr: row.stderr ?? undefined,
+    error: row.error ?? undefined,
+    accountProfile: row.account_profile ?? undefined,
+    accountTool: row.account_tool ?? undefined,
+    goalRunId: row.goal_run_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToGoal(row) {
+  return {
+    goalId: row.id,
+    planId: row.plan_id,
+    objective: row.objective,
+    status: row.status,
+    tokenBudget: row.token_budget ?? undefined,
+    tokensUsed: row.tokens_used,
+    timeUsedSeconds: row.time_used_seconds,
+    autoExecute: row.auto_execute,
+    maxTokens: row.max_tokens ?? undefined,
+    sourceType: row.source_type ?? undefined,
+    sourceId: row.source_id ?? undefined,
+    loopId: row.loop_id ?? undefined,
+    loopRunId: row.loop_run_id ?? undefined,
+    workflowId: row.workflow_id ?? undefined,
+    workflowRunId: row.workflow_run_id ?? undefined,
+    workflowStepId: row.workflow_step_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToGoalPlanNode(row) {
+  return {
+    nodeId: row.id,
+    planId: row.plan_id,
+    key: row.key,
+    sequence: row.sequence,
+    priority: row.priority,
+    objective: row.objective,
+    status: row.status,
+    ready: row.ready === 1,
+    tokenBudget: row.token_budget ?? undefined,
+    tokensUsed: row.tokens_used,
+    timeUsedSeconds: row.time_used_seconds,
+    dependsOn: JSON.parse(row.depends_on_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToGoalRun(row) {
+  return {
+    runId: row.id,
+    goalId: row.goal_id,
+    planId: row.plan_id,
+    loopId: row.loop_id ?? undefined,
+    loopRunId: row.loop_run_id ?? undefined,
+    workflowId: row.workflow_id ?? undefined,
+    workflowRunId: row.workflow_run_id ?? undefined,
+    workflowStepId: row.workflow_step_id ?? undefined,
+    turn: row.turn,
+    phase: row.phase,
+    status: row.status,
+    nodeKey: row.node_key ?? undefined,
+    tokensUsed: row.tokens_used,
+    evidence: row.evidence_json ? JSON.parse(row.evidence_json) : undefined,
+    rawResponse: row.raw_response_json ? JSON.parse(row.raw_response_json) : undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowEvent(row) {
+  return {
+    id: row.id,
+    workflowRunId: row.workflow_run_id,
+    sequence: row.sequence,
+    eventType: row.event_type,
+    stepId: row.step_id ?? undefined,
+    payload: row.payload_json ? JSON.parse(row.payload_json) : undefined,
+    createdAt: row.created_at
+  };
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRecordedProcessAlive(pid, processStartedAt) {
+  if (!pid || !isProcessAlive(pid))
+    return false;
+  return sameProcessStart(processStartedAt ?? undefined, processStartTimeMs(pid));
+}
+function isoProcessStart(pid) {
+  const startedMs = processStartTimeMs(pid);
+  return startedMs === undefined ? undefined : new Date(startedMs).toISOString();
+}
+function isLiveStepProcess(pid, stepStartedAt) {
+  if (!isProcessAlive(pid))
+    return false;
+  const actualMs = processStartTimeMs(pid);
+  const stepStartMs = stepStartedAt ? Date.parse(stepStartedAt) : Number.NaN;
+  if (actualMs === undefined || !Number.isFinite(stepStartMs))
+    return true;
+  return actualMs >= stepStartMs - START_TIME_TOLERANCE_MS;
+}
+function rowToLease(row) {
+  return {
+    id: row.id,
+    pid: row.pid,
+    hostname: row.hostname,
+    heartbeatAt: row.heartbeat_at,
+    expiresAt: row.expires_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function workItemStatusForLoopRun(status, attempt, maxAttempts) {
+  if (status === "succeeded")
+    return "succeeded";
+  if (["failed", "timed_out", "abandoned"].includes(status)) {
+    return maxAttempts !== undefined && attempt < maxAttempts ? "admitted" : "failed";
+  }
+  return;
+}
+function scrubbedOrNull(value) {
+  return value == null ? null : scrubSecrets(value);
+}
+function chmodIfExists(path, mode) {
+  try {
+    if (existsSync(path))
+      chmodSync(path, mode);
+  } catch {}
+}
+function ensurePrivateStorePath(file) {
+  const dir = dirname2(file);
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  chmodIfExists(dir, 448);
+  chmodIfExists(file, 384);
+  chmodIfExists(`${file}-wal`, 384);
+  chmodIfExists(`${file}-shm`, 384);
+}
+
+class Store {
+  db;
+  rootDir;
+  constructor(path) {
+    const file = path ?? dbPath();
+    if (file !== ":memory:")
+      ensurePrivateStorePath(file);
+    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    this.db = new Database(file);
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.db.exec("PRAGMA busy_timeout = 5000;");
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    if (file !== ":memory:")
+      ensurePrivateStorePath(file);
+    try {
+      this.migrate();
+    } catch (error) {
+      this.db.close();
+      throw error;
+    }
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        id TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      );
+    `);
+    const versionRow = this.db.query("PRAGMA user_version").get();
+    const userVersion = versionRow?.user_version ?? 0;
+    if (userVersion > SCHEMA_USER_VERSION) {
+      throw new Error(`loops database schema version ${userVersion} is newer than this binary supports (${SCHEMA_USER_VERSION}); upgrade open-loops before opening this database`);
+    }
+    const applied = new Set(this.db.query("SELECT id FROM schema_migrations").all().map((row) => row.id));
+    for (const migration of this.migrations()) {
+      if (!migration.baseline && applied.has(migration.id))
+        continue;
+      migration.apply();
+      if (!applied.has(migration.id)) {
+        this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run(migration.id, nowIso());
+      }
+    }
+    if (userVersion !== SCHEMA_USER_VERSION)
+      this.db.exec(`PRAGMA user_version = ${SCHEMA_USER_VERSION}`);
+  }
+  migrations() {
+    return [
+      { id: "0001_initial_and_workflows", baseline: true, apply: () => this.createBaseSchema() },
+      { id: "0002_loop_machines", baseline: true, apply: () => this.addColumnIfMissing("loops", "machine_json", "TEXT") },
+      {
+        id: "0003_goals",
+        baseline: true,
+        apply: () => {
+          this.addColumnIfMissing("loops", "goal_json", "TEXT");
+          this.addColumnIfMissing("loop_runs", "goal_run_id", "TEXT");
+          this.addColumnIfMissing("workflow_specs", "goal_json", "TEXT");
+          this.addColumnIfMissing("workflow_runs", "goal_run_id", "TEXT");
+          this.addColumnIfMissing("workflow_step_runs", "goal_run_id", "TEXT");
+        }
+      },
+      {
+        id: "0004_loop_archive_metadata",
+        baseline: true,
+        apply: () => {
+          this.addColumnIfMissing("loops", "archived_at", "TEXT");
+          this.addColumnIfMissing("loops", "archived_from_status", "TEXT");
+        }
+      },
+      {
+        id: "0005_workflow_invocations_and_admission",
+        baseline: true,
+        apply: () => {
+          this.addColumnIfMissing("workflow_runs", "invocation_id", "TEXT");
+          this.addColumnIfMissing("workflow_runs", "work_item_id", "TEXT");
+          this.addColumnIfMissing("workflow_runs", "manifest_path", "TEXT");
+          this.addColumnIfMissing("workflow_step_runs", "pid", "INTEGER");
+          this.createWorkflowRunBackfillIndexes();
+        }
+      },
+      {
+        id: "0006_run_process_tracking",
+        apply: () => {
+          this.addColumnIfMissing("loop_runs", "pgid", "INTEGER");
+          this.addColumnIfMissing("loop_runs", "process_started_at", "TEXT");
+        }
+      },
+      {
+        id: "0007_run_claim_tokens",
+        apply: () => {
+          this.addColumnIfMissing("loop_runs", "claim_token", "TEXT");
+          this.db.exec("CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL");
+        }
+      }
+    ];
+  }
+  createBaseSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS loops (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL,
+        archived_at TEXT,
+        archived_from_status TEXT,
+        schedule_json TEXT NOT NULL,
+        target_json TEXT NOT NULL,
+        goal_json TEXT,
+        machine_json TEXT,
+        next_run_at TEXT,
+        retry_scheduled_for TEXT,
+        catch_up TEXT NOT NULL,
+        catch_up_limit INTEGER NOT NULL,
+        overlap TEXT NOT NULL,
+        max_attempts INTEGER NOT NULL,
+        retry_delay_ms INTEGER NOT NULL,
+        lease_ms INTEGER NOT NULL,
+        expires_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_loops_status_next ON loops(status, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_loops_name ON loops(name);
+
+      CREATE TABLE IF NOT EXISTS loop_runs (
+        id TEXT PRIMARY KEY,
+        loop_id TEXT NOT NULL,
+        loop_name TEXT NOT NULL,
+        scheduled_for TEXT NOT NULL,
+        attempt INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        claimed_by TEXT,
+        claim_token TEXT,
+        lease_expires_at TEXT,
+        pid INTEGER,
+        pgid INTEGER,
+        process_started_at TEXT,
+        exit_code INTEGER,
+        duration_ms INTEGER,
+        stdout TEXT,
+        stderr TEXT,
+        error TEXT,
+        goal_run_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(loop_id, scheduled_for)
+      );
+      CREATE INDEX IF NOT EXISTS idx_runs_loop ON loop_runs(loop_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_runs_status ON loop_runs(status);
+      CREATE INDEX IF NOT EXISTS idx_runs_status_lease ON loop_runs(status, lease_expires_at);
+      CREATE INDEX IF NOT EXISTS idx_runs_scheduled ON loop_runs(scheduled_for);
+      CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL;
+
+      CREATE TABLE IF NOT EXISTS daemon_lease (
+        id TEXT PRIMARY KEY,
+        pid INTEGER NOT NULL,
+        hostname TEXT NOT NULL,
+        heartbeat_at TEXT NOT NULL,
+        expires_at TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS workflow_specs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        version INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        goal_json TEXT,
+        steps_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflows_status_name ON workflow_specs(status, name);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workflows_name_active ON workflow_specs(name) WHERE status = 'active';
+
+      CREATE TABLE IF NOT EXISTS workflow_runs (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL REFERENCES workflow_specs(id) ON DELETE CASCADE,
+        workflow_name TEXT NOT NULL,
+        loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+        loop_run_id TEXT REFERENCES loop_runs(id) ON DELETE SET NULL,
+        invocation_id TEXT,
+        work_item_id TEXT,
+        scheduled_for TEXT,
+        idempotency_key TEXT,
+        manifest_path TEXT,
+        status TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        duration_ms INTEGER,
+        error TEXT,
+        goal_run_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_runs_idempotency
+        ON workflow_runs(workflow_id, idempotency_key)
+        WHERE idempotency_key IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow_created ON workflow_runs(workflow_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_loop_run ON workflow_runs(loop_run_id);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+
+      CREATE TABLE IF NOT EXISTS workflow_invocations (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT,
+        template_id TEXT,
+        source_kind TEXT NOT NULL,
+        source_id TEXT,
+        source_dedupe_key TEXT,
+        source_json TEXT NOT NULL,
+        subject_kind TEXT NOT NULL,
+        subject_id TEXT,
+        subject_path TEXT,
+        subject_url TEXT,
+        subject_json TEXT NOT NULL,
+        intent TEXT NOT NULL,
+        scope_json TEXT,
+        output_policy_json TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflow_invocations_source ON workflow_invocations(source_kind, source_id);
+      CREATE INDEX IF NOT EXISTS idx_workflow_invocations_subject ON workflow_invocations(subject_kind, subject_id, subject_path);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_invocations_dedupe
+        ON workflow_invocations(source_kind, source_dedupe_key)
+        WHERE source_dedupe_key IS NOT NULL;
+
+      CREATE TABLE IF NOT EXISTS workflow_work_items (
+        id TEXT PRIMARY KEY,
+        route_key TEXT NOT NULL,
+        idempotency_key TEXT NOT NULL,
+        invocation_id TEXT NOT NULL REFERENCES workflow_invocations(id) ON DELETE CASCADE,
+        source_type TEXT NOT NULL,
+        source_ref TEXT NOT NULL,
+        subject_ref TEXT NOT NULL,
+        project_key TEXT,
+        project_group TEXT,
+        priority INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        attempts INTEGER NOT NULL,
+        next_attempt_at TEXT,
+        lease_expires_at TEXT,
+        workflow_id TEXT REFERENCES workflow_specs(id) ON DELETE SET NULL,
+        loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+        workflow_run_id TEXT REFERENCES workflow_runs(id) ON DELETE SET NULL,
+        last_reason TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(route_key, idempotency_key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflow_work_items_status_next ON workflow_work_items(status, next_attempt_at, priority DESC, created_at ASC);
+      CREATE INDEX IF NOT EXISTS idx_workflow_work_items_project ON workflow_work_items(project_key, status);
+      CREATE INDEX IF NOT EXISTS idx_workflow_work_items_group ON workflow_work_items(project_group, status);
+      CREATE INDEX IF NOT EXISTS idx_workflow_work_items_invocation ON workflow_work_items(invocation_id);
+
+      CREATE TABLE IF NOT EXISTS workflow_step_runs (
+        id TEXT PRIMARY KEY,
+        workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+        step_id TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        exit_code INTEGER,
+        pid INTEGER,
+        duration_ms INTEGER,
+        stdout TEXT,
+        stderr TEXT,
+        error TEXT,
+        account_profile TEXT,
+        account_tool TEXT,
+        goal_run_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(workflow_run_id, step_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_run_sequence ON workflow_step_runs(workflow_run_id, sequence);
+      CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_status ON workflow_step_runs(status);
+
+      CREATE TABLE IF NOT EXISTS workflow_events (
+        id TEXT PRIMARY KEY,
+        workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+        sequence INTEGER NOT NULL,
+        event_type TEXT NOT NULL,
+        step_id TEXT,
+        payload_json TEXT,
+        created_at TEXT NOT NULL,
+        UNIQUE(workflow_run_id, sequence)
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_run_sequence ON workflow_events(workflow_run_id, sequence);
+
+      CREATE TABLE IF NOT EXISTS goals (
+        id TEXT PRIMARY KEY,
+        plan_id TEXT NOT NULL,
+        objective TEXT NOT NULL,
+        status TEXT NOT NULL,
+        token_budget INTEGER,
+        tokens_used INTEGER NOT NULL,
+        time_used_seconds INTEGER NOT NULL,
+        auto_execute TEXT NOT NULL,
+        max_tokens INTEGER,
+        source_type TEXT,
+        source_id TEXT,
+        loop_id TEXT,
+        loop_run_id TEXT,
+        workflow_id TEXT,
+        workflow_run_id TEXT,
+        workflow_step_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_goals_status_updated ON goals(status, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_goals_loop_run ON goals(loop_run_id);
+      CREATE INDEX IF NOT EXISTS idx_goals_workflow_run ON goals(workflow_run_id);
+      CREATE INDEX IF NOT EXISTS idx_goals_source ON goals(source_type, source_id);
+
+      CREATE TABLE IF NOT EXISTS goal_plan_nodes (
+        id TEXT PRIMARY KEY,
+        goal_id TEXT NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+        plan_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        priority INTEGER NOT NULL,
+        objective TEXT NOT NULL,
+        status TEXT NOT NULL,
+        ready INTEGER NOT NULL,
+        token_budget INTEGER,
+        tokens_used INTEGER NOT NULL,
+        time_used_seconds INTEGER NOT NULL,
+        depends_on_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(plan_id, key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_goal_plan_nodes_goal_sequence ON goal_plan_nodes(goal_id, sequence);
+      CREATE INDEX IF NOT EXISTS idx_goal_plan_nodes_status ON goal_plan_nodes(status);
+
+      CREATE TABLE IF NOT EXISTS goal_runs (
+        id TEXT PRIMARY KEY,
+        goal_id TEXT NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+        plan_id TEXT NOT NULL,
+        loop_id TEXT,
+        loop_run_id TEXT,
+        workflow_id TEXT,
+        workflow_run_id TEXT,
+        workflow_step_id TEXT,
+        turn INTEGER NOT NULL,
+        phase TEXT NOT NULL,
+        status TEXT NOT NULL,
+        node_key TEXT,
+        tokens_used INTEGER NOT NULL,
+        evidence_json TEXT,
+        raw_response_json TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_goal_runs_goal_created ON goal_runs(goal_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_goal_runs_loop_run ON goal_runs(loop_run_id);
+      CREATE INDEX IF NOT EXISTS idx_goal_runs_workflow_run ON goal_runs(workflow_run_id);
+    `);
+  }
+  addColumnIfMissing(table, column, definition) {
+    const columns = this.db.query(`PRAGMA table_info(${table})`).all();
+    if (columns.some((c) => c.name === column))
+      return;
+    this.db.query(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`).run();
+  }
+  createWorkflowRunBackfillIndexes() {
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_invocation ON workflow_runs(invocation_id);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_work_item ON workflow_runs(work_item_id);
+    `);
+  }
+  transact(fn) {
+    return this.db.inTransaction ? fn() : this.writeTransaction(fn);
+  }
+  assertDaemonLeaseFence(opts = {}, now = nowIso()) {
+    if (!opts.daemonLeaseId)
+      return;
+    const row = this.db.query("SELECT id FROM daemon_lease WHERE id = ? AND expires_at > ?").get(opts.daemonLeaseId, now);
+    if (!row)
+      throw new Error("daemon lease lost");
+  }
+  assertNoNestedWorkflowGoal(target, goal) {
+    if (!goal || target.type !== "workflow")
+      return;
+    const workflow = this.getWorkflow(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`);
+    }
+  }
+  createLoop(input, from = new Date) {
+    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;
+    this.assertNoNestedWorkflowGoal(target, input.goal);
+    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
+    };
+    this.db.query(`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 ($id, $name, $description, $status, $schedule, $target, $machine, $nextRun, NULL, $goal, $catchUp, $catchUpLimit,
+          $overlap, $maxAttempts, $retryDelay, $leaseMs, $expiresAt, $created, $updated)`).run({
+      $id: loop.id,
+      $name: loop.name,
+      $description: loop.description ?? null,
+      $status: loop.status,
+      $schedule: JSON.stringify(loop.schedule),
+      $target: JSON.stringify(loop.target),
+      $machine: loop.machine ? JSON.stringify(loop.machine) : null,
+      $goal: loop.goal ? JSON.stringify(loop.goal) : null,
+      $nextRun: loop.nextRunAt ?? null,
+      $catchUp: loop.catchUp,
+      $catchUpLimit: loop.catchUpLimit,
+      $overlap: loop.overlap,
+      $maxAttempts: loop.maxAttempts,
+      $retryDelay: loop.retryDelayMs,
+      $leaseMs: loop.leaseMs,
+      $expiresAt: loop.expiresAt ?? null,
+      $created: loop.createdAt,
+      $updated: loop.updatedAt
+    });
+    return loop;
+  }
+  getLoop(id) {
+    const row = this.db.query("SELECT * FROM loops WHERE id = ?").get(id);
+    return row ? rowToLoop(row) : undefined;
+  }
+  findLoopByName(name) {
+    const row = this.db.query("SELECT * FROM loops WHERE name = ? ORDER BY created_at DESC LIMIT 1").get(name);
+    return row ? rowToLoop(row) : undefined;
+  }
+  requireUniqueLoop(idOrName) {
+    const byId = this.getLoop(idOrName);
+    if (byId)
+      return byId;
+    const rows = this.db.query("SELECT * FROM loops WHERE name = ? ORDER BY created_at DESC LIMIT 2").all(idOrName);
+    if (rows.length === 0)
+      throw new LoopNotFoundError(idOrName);
+    if (rows.length > 1)
+      throw new AmbiguousNameError(idOrName);
+    return rowToLoop(rows[0]);
+  }
+  requireLoop(idOrName) {
+    return this.getLoop(idOrName) ?? this.findLoopByName(idOrName) ?? (() => {
+      throw new LoopNotFoundError(idOrName);
+    })();
+  }
+  listLoops(opts = {}) {
+    const limit = opts.limit ?? 200;
+    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);
+    } 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);
+    } 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);
+    } 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);
+    } else if (opts.includeArchived) {
+      rows = this.db.query("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
+    } else {
+      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
+    }
+    return rows.map(rowToLoop);
+  }
+  dueLoops(now, limit = 500) {
+    const rows = this.db.query(`SELECT * FROM loops
+         WHERE status = 'active'
+           AND archived_at IS NULL
+           AND next_run_at IS NOT NULL
+           AND next_run_at <= ?
+         ORDER BY next_run_at ASC
+         LIMIT ?`).all(now.toISOString(), limit);
+    return rows.map(rowToLoop);
+  }
+  updateLoop(id, patch, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.getLoop(id);
+      if (!current)
+        throw new LoopNotFoundError(id);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || id);
+      const merged = { ...current, ...patch, updatedAt: updated };
+      const res = this.db.query(`UPDATE loops SET status=$status, next_run_at=$nextRun, retry_scheduled_for=$retrySlot,
+           expires_at=$expiresAt, 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: id,
+        $status: merged.status,
+        $nextRun: merged.nextRunAt ?? null,
+        $retrySlot: merged.retryScheduledFor ?? null,
+        $expiresAt: merged.expiresAt ?? null,
+        $updated: merged.updatedAt,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      if (patch.status && patch.status !== "active") {
+        const status = patch.status === "paused" ? "deferred" : "cancelled";
+        this.setWorkflowWorkItemsForLoop(id, status, `loop ${patch.status}`, updated);
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+    const after = this.getLoop(id);
+    if (!after)
+      throw new Error(`loop not found after update: ${id}`);
+    return after;
+  }
+  activeLoopReferenceCount(workflowId) {
+    const rows = this.db.query("SELECT target_json FROM loops WHERE archived_at IS NULL").all();
+    let count = 0;
+    for (const row of rows) {
+      try {
+        const target = JSON.parse(row.target_json);
+        if (target.type === "workflow" && target.workflowId === workflowId)
+          count += 1;
+      } catch {}
+    }
+    return count;
+  }
+  archiveWorkflowIfUnreferenced(workflowId, updated) {
+    if (this.activeLoopReferenceCount(workflowId) > 0)
+      return;
+    const workflow = this.getWorkflow(workflowId);
+    if (!workflow || workflow.status !== "active")
+      return;
+    const res = this.db.query("UPDATE workflow_specs SET status='archived', updated_at=? WHERE id=? AND status='active'").run(updated, workflowId);
+    if (res.changes !== 1)
+      return;
+    return this.getWorkflow(workflowId);
+  }
+  retargetWorkflowLoop(idOrName, workflowId, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireLoop(idOrName);
+      if (current.target.type !== "workflow")
+        throw new Error(`loop is not a workflow loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to retarget running loop: ${current.id}`);
+      const workflow = this.requireWorkflow(workflowId);
+      if (current.goal && workflow.goal) {
+        throw new Error(`workflow loop cannot retarget ${current.name} to workflow ${workflow.name} because both define top-level goals`);
+      }
+      const target = { ...current.target, workflowId: workflow.id };
+      if (opts.workflowTimeoutMs !== undefined)
+        target.timeoutMs = opts.workflowTimeoutMs;
+      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 retarget: ${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();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.target.type !== "workflow")
+        throw new Error(`loop is not a workflow loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to retarget running loop: ${current.id}`);
+      if (current.goal && normalized.goal) {
+        throw new Error(`workflow loop cannot retarget ${current.name} to a workflow that also defines a top-level goal`);
+      }
+      const previousWorkflow = this.requireWorkflow(current.target.workflowId);
+      const workflow = {
+        id: genId(),
+        name: normalized.name,
+        description: normalized.description,
+        version: normalized.version ?? 1,
+        status: "active",
+        goal: normalized.goal,
+        steps: normalized.steps,
+        createdAt: updated,
+        updatedAt: updated
+      };
+      this.db.query(`INSERT INTO workflow_specs (id, name, description, version, status, goal_json, steps_json, created_at, updated_at)
+           VALUES ($id, $name, $description, $version, $status, $goal, $steps, $created, $updated)`).run({
+        $id: workflow.id,
+        $name: workflow.name,
+        $description: workflow.description ?? null,
+        $version: workflow.version,
+        $status: workflow.status,
+        $goal: workflow.goal ? JSON.stringify(workflow.goal) : null,
+        $steps: JSON.stringify(workflow.steps),
+        $created: workflow.createdAt,
+        $updated: workflow.updatedAt
+      });
+      const target = { ...current.target, workflowId: workflow.id };
+      if (opts.workflowTimeoutMs !== undefined)
+        target.timeoutMs = opts.workflowTimeoutMs;
+      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");
+      const archivedOld = opts.archiveOld ? this.archiveWorkflowIfUnreferenced(previousWorkflow.id, updated) : undefined;
+      this.db.exec("COMMIT");
+      const loop = this.getLoop(current.id);
+      if (!loop)
+        throw new Error(`loop not found after retarget: ${current.id}`);
+      return { loop, workflow, previousWorkflow, archivedOld };
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  cloneWorkflowWithoutGoalAndRetargetLoop(idOrName, opts) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.target.type !== "workflow")
+        throw new Error(`loop is not a workflow loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to retarget running loop: ${current.id}`);
+      if (!current.goal)
+        throw new Error(`workflow loop ${current.name} has no loop-level goal wrapper`);
+      const previousWorkflow = this.requireWorkflow(current.target.workflowId);
+      if (!previousWorkflow.goal)
+        throw new Error(`workflow ${previousWorkflow.name} has no top-level goal wrapper`);
+      const workflow = {
+        id: genId(),
+        name: opts.workflowName,
+        description: previousWorkflow.description,
+        version: previousWorkflow.version,
+        status: "active",
+        steps: previousWorkflow.steps,
+        createdAt: updated,
+        updatedAt: updated
+      };
+      this.db.query(`INSERT INTO workflow_specs (id, name, description, version, status, goal_json, steps_json, created_at, updated_at)
+           VALUES ($id, $name, $description, $version, $status, NULL, $steps, $created, $updated)`).run({
+        $id: workflow.id,
+        $name: workflow.name,
+        $description: workflow.description ?? null,
+        $version: workflow.version,
+        $status: workflow.status,
+        $steps: JSON.stringify(workflow.steps),
+        $created: workflow.createdAt,
+        $updated: workflow.updatedAt
+      });
+      const target = { ...current.target, workflowId: workflow.id };
+      if (opts.workflowTimeoutMs !== undefined)
+        target.timeoutMs = opts.workflowTimeoutMs;
+      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");
+      const archivedOld = opts.archiveOld ? this.archiveWorkflowIfUnreferenced(previousWorkflow.id, updated) : undefined;
+      this.db.exec("COMMIT");
+      const loop = this.getLoop(current.id);
+      if (!loop)
+        throw new Error(`loop not found after retarget: ${current.id}`);
+      return { loop, workflow, previousWorkflow, archivedOld };
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  renameLoop(id, name, opts = {}) {
+    const current = 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();
+    this.db.query(`UPDATE loops SET name=$name, 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: id,
+      $name: trimmed,
+      $updated: updated,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: updated
+    });
+    const after = this.getLoop(id);
+    if (!after)
+      throw new Error(`loop not found after rename: ${id}`);
+    return after;
+  }
+  archiveLoop(idOrName) {
+    return this.transact(() => {
+      const loop = this.requireLoop(idOrName);
+      if (loop.archivedAt)
+        return loop;
+      const updated = nowIso();
+      const archivedStatus = loop.status === "active" ? "paused" : loop.status;
+      this.db.query(`UPDATE loops
+           SET status=$status, archived_at=$archivedAt, archived_from_status=$archivedFromStatus, updated_at=$updated
+           WHERE id=$id`).run({
+        $id: loop.id,
+        $status: archivedStatus,
+        $archivedAt: updated,
+        $archivedFromStatus: loop.status,
+        $updated: updated
+      });
+      this.setWorkflowWorkItemsForLoop(loop.id, "deferred", "loop archived", updated);
+      const archived = this.getLoop(loop.id);
+      if (!archived)
+        throw new Error(`loop not found after archive: ${loop.id}`);
+      return archived;
+    });
+  }
+  unarchiveLoop(idOrName) {
+    const loop = this.requireLoop(idOrName);
+    if (!loop.archivedAt)
+      return loop;
+    const updated = nowIso();
+    const restoredStatus = loop.archivedFromStatus ?? loop.status;
+    this.db.query(`UPDATE loops
+         SET status=$status, archived_at=NULL, archived_from_status=NULL, updated_at=$updated
+         WHERE id=$id`).run({
+      $id: loop.id,
+      $status: restoredStatus,
+      $updated: updated
+    });
+    const unarchived = this.getLoop(loop.id);
+    if (!unarchived)
+      throw new Error(`loop not found after unarchive: ${loop.id}`);
+    return unarchived;
+  }
+  deleteLoop(idOrName) {
+    return this.transact(() => {
+      const loop = this.requireLoop(idOrName);
+      this.setWorkflowWorkItemsForLoop(loop.id, "cancelled", "loop deleted", nowIso());
+      const res = this.db.query("DELETE FROM loops WHERE id = ?").run(loop.id);
+      return res.changes > 0;
+    });
+  }
+  createWorkflow(input) {
+    const normalized = normalizeCreateWorkflowInput(input);
+    const now = nowIso();
+    const workflow = {
+      id: genId(),
+      name: normalized.name,
+      description: normalized.description,
+      version: normalized.version ?? 1,
+      status: "active",
+      goal: normalized.goal,
+      steps: normalized.steps,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.query(`INSERT INTO workflow_specs (id, name, description, version, status, goal_json, steps_json, created_at, updated_at)
+         VALUES ($id, $name, $description, $version, $status, $goal, $steps, $created, $updated)`).run({
+      $id: workflow.id,
+      $name: workflow.name,
+      $description: workflow.description ?? null,
+      $version: workflow.version,
+      $status: workflow.status,
+      $goal: workflow.goal ? JSON.stringify(workflow.goal) : null,
+      $steps: JSON.stringify(workflow.steps),
+      $created: workflow.createdAt,
+      $updated: workflow.updatedAt
+    });
+    return workflow;
+  }
+  getWorkflow(id) {
+    const row = this.db.query("SELECT * FROM workflow_specs WHERE id = ?").get(id);
+    return row ? rowToWorkflow(row) : undefined;
+  }
+  findWorkflowByName(name) {
+    const row = this.db.query("SELECT * FROM workflow_specs WHERE name = ? AND status = 'active' ORDER BY updated_at DESC LIMIT 1").get(name);
+    return row ? rowToWorkflow(row) : undefined;
+  }
+  requireWorkflow(idOrName) {
+    return this.getWorkflow(idOrName) ?? this.findWorkflowByName(idOrName) ?? (() => {
+      throw new Error(`workflow not found: ${idOrName}`);
+    })();
+  }
+  listWorkflows(opts = {}) {
+    const offset = Math.max(0, opts.offset ?? 0);
+    let rows;
+    if (opts.status && opts.limit !== undefined) {
+      rows = this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?").all(opts.status, opts.limit, offset);
+    } else if (opts.status) {
+      rows = this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT -1 OFFSET ?").all(opts.status, offset);
+    } else if (opts.limit !== undefined) {
+      rows = this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT ? OFFSET ?").all(opts.limit, offset);
+    } else {
+      rows = this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT -1 OFFSET ?").all(offset);
+    }
+    return rows.map(rowToWorkflow);
+  }
+  countWorkflows(opts = {}) {
+    const row = opts.status ? this.db.query("SELECT COUNT(*) AS count FROM workflow_specs WHERE status = ?").get(opts.status) : this.db.query("SELECT COUNT(*) AS count FROM workflow_specs").get();
+    return row?.count ?? 0;
+  }
+  archiveWorkflow(idOrName) {
+    const workflow = this.requireWorkflow(idOrName);
+    const updated = nowIso();
+    this.db.query("UPDATE workflow_specs SET status='archived', updated_at=? WHERE id=?").run(updated, workflow.id);
+    const archived = this.getWorkflow(workflow.id);
+    if (!archived)
+      throw new Error(`workflow not found after archive: ${workflow.id}`);
+    return archived;
+  }
+  generatedRouteArchiveContext(args) {
+    if (!args.loopId || !args.workItemId)
+      return;
+    const workItem = this.getWorkflowWorkItem(args.workItemId);
+    if (!workItem || !GENERATED_ROUTE_KEYS.has(workItem.routeKey))
+      return;
+    const invocation = this.getWorkflowInvocation(workItem.invocationId);
+    if (!invocation?.templateId || !GENERATED_ROUTE_TEMPLATE_IDS.has(invocation.templateId))
+      return;
+    const loop = this.getLoop(args.loopId);
+    if (!loop || loop.schedule.type !== "once" || loop.target.type !== "workflow" || loop.target.workflowId !== args.workflowId)
+      return;
+    const input = loop.target.input ?? {};
+    if (input.workflowWorkItemId && input.workflowWorkItemId !== workItem.id)
+      return;
+    if (input.workflowInvocationId && input.workflowInvocationId !== invocation.id)
+      return;
+    if (workItem.workflowId && workItem.workflowId !== args.workflowId)
+      return;
+    const workflow = this.getWorkflow(args.workflowId);
+    if (!workflow)
+      return;
+    return { workflow, loop, workItem, invocation };
+  }
+  maybeArchiveGeneratedRouteWorkflow(args) {
+    const context = this.generatedRouteArchiveContext(args);
+    if (!context)
+      return;
+    const { workflow, loop, workItem } = context;
+    if (!workflow || workflow.status !== "active")
+      return;
+    const nonTerminal = this.db.query(`SELECT COUNT(*) AS count FROM workflow_runs
+         WHERE workflow_id = ? AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).get(args.workflowId)?.count ?? 0;
+    if (nonTerminal > 0)
+      return;
+    const res = this.db.query("UPDATE workflow_specs SET status='archived', updated_at=? WHERE id=? AND status='active'").run(args.updated, args.workflowId);
+    if (res.changes === 1 && args.workflowRunId) {
+      this.appendWorkflowEvent(args.workflowRunId, "workflow_archived", undefined, {
+        workflowId: args.workflowId,
+        loopId: loop.id,
+        workItemId: workItem.id,
+        routeKey: workItem.routeKey,
+        reason: "terminal generated one-shot route workflow"
+      });
+    }
+  }
+  maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, updated) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run)
+      return;
+    this.maybeArchiveGeneratedRouteWorkflow({
+      workflowId: run.workflowId,
+      loopId: run.loopId,
+      workItemId: run.workItemId,
+      workflowRunId,
+      updated
+    });
+  }
+  createWorkflowInvocation(input) {
+    const now = nowIso();
+    const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
+    if (sourceDedupeKey) {
+      const existing = this.db.query("SELECT * FROM workflow_invocations WHERE source_kind = ? AND source_dedupe_key = ? LIMIT 1").get(input.sourceRef.kind, sourceDedupeKey);
+      if (existing)
+        return rowToWorkflowInvocation(existing);
+    }
+    const id = input.id ?? genId();
+    this.db.query(`INSERT INTO workflow_invocations (id, workflow_id, template_id, source_kind, source_id, source_dedupe_key,
+          source_json, subject_kind, subject_id, subject_path, subject_url, subject_json, intent, scope_json,
+          output_policy_json, created_at, updated_at)
+         VALUES ($id, $workflowId, $templateId, $sourceKind, $sourceId, $sourceDedupeKey, $sourceJson,
+          $subjectKind, $subjectId, $subjectPath, $subjectUrl, $subjectJson, $intent, $scopeJson,
+          $outputPolicyJson, $created, $updated)`).run({
+      $id: id,
+      $workflowId: input.workflowId ?? null,
+      $templateId: input.templateId ?? null,
+      $sourceKind: input.sourceRef.kind,
+      $sourceId: input.sourceRef.id ?? null,
+      $sourceDedupeKey: sourceDedupeKey ?? null,
+      $sourceJson: JSON.stringify(input.sourceRef),
+      $subjectKind: input.subjectRef.kind,
+      $subjectId: input.subjectRef.id ?? null,
+      $subjectPath: input.subjectRef.path ?? null,
+      $subjectUrl: input.subjectRef.url ?? null,
+      $subjectJson: JSON.stringify(input.subjectRef),
+      $intent: input.intent,
+      $scopeJson: input.scope ? JSON.stringify(input.scope) : null,
+      $outputPolicyJson: input.outputPolicy ? JSON.stringify(input.outputPolicy) : null,
+      $created: now,
+      $updated: now
+    });
+    const row = this.db.query("SELECT * FROM workflow_invocations WHERE id = ?").get(id);
+    if (!row)
+      throw new Error(`workflow invocation not found after create: ${id}`);
+    return rowToWorkflowInvocation(row);
+  }
+  refreshWorkflowInvocationForWorkItem(workItemId, input) {
+    const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
+    if (!sourceDedupeKey)
+      throw new Error("cannot refresh workflow invocation without sourceRef.dedupeKey");
+    const now = nowIso();
+    const claimableStatuses = ["queued", "deferred"];
+    const statusBindings = Object.fromEntries(claimableStatuses.map((status, index) => [`$status${index}`, status]));
+    const placeholders = claimableStatuses.map((_, index) => `$status${index}`).join(",");
+    const result = this.db.query(`UPDATE workflow_invocations
+         SET workflow_id=COALESCE($workflowId, workflow_id),
+          template_id=COALESCE($templateId, template_id),
+          source_id=COALESCE($sourceId, source_id),
+          source_json=$sourceJson,
+          subject_kind=$subjectKind,
+          subject_id=COALESCE($subjectId, subject_id),
+          subject_path=COALESCE($subjectPath, subject_path),
+          subject_url=COALESCE($subjectUrl, subject_url),
+          subject_json=$subjectJson,
+          intent=$intent,
+          scope_json=COALESCE($scopeJson, scope_json),
+          output_policy_json=COALESCE($outputPolicyJson, output_policy_json),
+          updated_at=$updated
+         WHERE source_kind=$sourceKind
+          AND source_dedupe_key=$sourceDedupeKey
+          AND EXISTS (
+            SELECT 1
+            FROM workflow_work_items
+            WHERE id=$workItemId
+              AND invocation_id=workflow_invocations.id
+              AND status IN (${placeholders})
+          )`).run({
+      $workItemId: workItemId,
+      $sourceKind: input.sourceRef.kind,
+      $sourceDedupeKey: sourceDedupeKey,
+      $workflowId: input.workflowId ?? null,
+      $templateId: input.templateId ?? null,
+      $sourceId: input.sourceRef.id ?? null,
+      $sourceJson: JSON.stringify(input.sourceRef),
+      $subjectKind: input.subjectRef.kind,
+      $subjectId: input.subjectRef.id ?? null,
+      $subjectPath: input.subjectRef.path ?? null,
+      $subjectUrl: input.subjectRef.url ?? null,
+      $subjectJson: JSON.stringify(input.subjectRef),
+      $intent: input.intent,
+      $scopeJson: input.scope ? JSON.stringify(input.scope) : null,
+      $outputPolicyJson: input.outputPolicy ? JSON.stringify(input.outputPolicy) : null,
+      $updated: now,
+      ...statusBindings
+    });
+    if (result.changes !== 1)
+      throw new Error(`workflow work item is not refreshable: ${workItemId}`);
+    const updated = this.db.query(`SELECT workflow_invocations.*
+         FROM workflow_invocations
+         JOIN workflow_work_items ON workflow_work_items.invocation_id = workflow_invocations.id
+         WHERE workflow_work_items.id = ?`).get(workItemId);
+    if (!updated)
+      throw new Error(`workflow invocation not found after refresh for work item: ${workItemId}`);
+    return rowToWorkflowInvocation(updated);
+  }
+  getWorkflowInvocation(id) {
+    const row = this.db.query("SELECT * FROM workflow_invocations WHERE id = ?").get(id);
+    return row ? rowToWorkflowInvocation(row) : undefined;
+  }
+  listWorkflowInvocations(opts = {}) {
+    const rows = this.db.query("SELECT * FROM workflow_invocations ORDER BY created_at DESC LIMIT ?").all(opts.limit ?? 100);
+    return rows.map(rowToWorkflowInvocation);
+  }
+  upsertWorkflowWorkItem(input) {
+    const now = nowIso();
+    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, 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, $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,
+          source_type=excluded.source_type,
+          source_ref=excluded.source_ref,
+          subject_ref=excluded.subject_ref,
+          project_key=excluded.project_key,
+          project_group=excluded.project_group,
+          priority=excluded.priority,
+          status=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled')
+              THEN workflow_work_items.status
+            ELSE excluded.status
+          END,
+          workflow_id=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.workflow_id
+            ELSE NULL
+          END,
+          loop_id=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.loop_id
+            ELSE NULL
+          END,
+          workflow_run_id=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.workflow_run_id
+            ELSE NULL
+          END,
+          lease_expires_at=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.lease_expires_at
+            ELSE NULL
+          END,
+          next_attempt_at=excluded.next_attempt_at,
+          last_reason=CASE
+            WHEN workflow_work_items.attempts > 0
+              AND workflow_work_items.status IN ('queued', 'deferred')
+              AND workflow_work_items.last_reason IS NOT NULL
+              AND excluded.last_reason IS NOT NULL
+              THEN workflow_work_items.last_reason || '; ' || excluded.last_reason
+            ELSE COALESCE(excluded.last_reason, workflow_work_items.last_reason)
+          END,
+          updated_at=excluded.updated_at`).run({
+      $id: id,
+      $routeKey: input.routeKey,
+      $idempotencyKey: input.idempotencyKey,
+      $invocationId: input.invocationId,
+      $sourceType: input.sourceType,
+      $sourceRef: input.sourceRef,
+      $subjectRef: input.subjectRef,
+      $projectKey: input.projectKey ?? null,
+      $projectGroup: input.projectGroup ?? null,
+      $priority: input.priority ?? 0,
+      $status: status,
+      $nextAttemptAt: input.nextAttemptAt ?? null,
+      $lastReason: input.lastReason ?? null,
+      $created: now,
+      $updated: now
+    });
+    const row = this.db.query("SELECT * FROM workflow_work_items WHERE route_key = ? AND idempotency_key = ? LIMIT 1").get(input.routeKey, input.idempotencyKey);
+    if (!row)
+      throw new Error(`workflow work item not found after upsert: ${input.routeKey}/${input.idempotencyKey}`);
+    return rowToWorkflowWorkItem(row);
+  }
+  getWorkflowWorkItem(id) {
+    const row = this.db.query("SELECT * FROM workflow_work_items WHERE id = ?").get(id);
+    return row ? rowToWorkflowWorkItem(row) : undefined;
+  }
+  findWorkflowWorkItem(routeKey, idempotencyKey) {
+    const row = this.db.query("SELECT * FROM workflow_work_items WHERE route_key = ? AND idempotency_key = ? LIMIT 1").get(routeKey, idempotencyKey);
+    return row ? rowToWorkflowWorkItem(row) : undefined;
+  }
+  listWorkflowWorkItems(opts = {}) {
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.status && opts.routeKey) {
+      rows = this.db.query("SELECT * FROM workflow_work_items WHERE route_key = ? AND status = ? ORDER BY priority DESC, created_at ASC LIMIT ?").all(opts.routeKey, opts.status, limit);
+    } else if (opts.status) {
+      rows = this.db.query("SELECT * FROM workflow_work_items WHERE status = ? ORDER BY priority DESC, created_at ASC LIMIT ?").all(opts.status, limit);
+    } else if (opts.routeKey) {
+      rows = this.db.query("SELECT * FROM workflow_work_items WHERE route_key = ? ORDER BY created_at DESC LIMIT ?").all(opts.routeKey, limit);
+    } else {
+      rows = this.db.query("SELECT * FROM workflow_work_items ORDER BY created_at DESC LIMIT ?").all(limit);
+    }
+    return rows.map(rowToWorkflowWorkItem);
+  }
+  countActiveWorkflowWorkItems(args = {}) {
+    const active = ["admitted", "running"];
+    const placeholders = active.map(() => "?").join(",");
+    const global = this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders})`).get(...active)?.count ?? 0;
+    const project = args.projectKey ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_key = ?`).get(...active, args.projectKey)?.count ?? 0 : 0;
+    const projectGroup = args.projectGroup ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_group = ?`).get(...active, args.projectGroup)?.count ?? 0 : undefined;
+    return { global, project, ...projectGroup !== undefined ? { projectGroup } : {} };
+  }
+  requeueWorkflowWorkItem(id, patch = {}) {
+    const current = this.getWorkflowWorkItem(id);
+    if (!current)
+      throw new Error(`workflow work item not found: ${id}`);
+    const requeueableStatuses = ["succeeded", "failed", "dead_letter", "cancelled"];
+    if (!requeueableStatuses.includes(current.status)) {
+      throw new Error(`workflow work item is not requeueable: ${id} status=${current.status}`);
+    }
+    const now = nowIso();
+    const reason = patch.reason?.trim() || `requeued from ${current.status}`;
+    const placeholders = requeueableStatuses.map(() => "?").join(",");
+    const res = this.db.query(`UPDATE workflow_work_items
+         SET status='queued', workflow_id=NULL, loop_id=NULL, workflow_run_id=NULL,
+          next_attempt_at=NULL, lease_expires_at=NULL, last_reason=?, updated_at=?
+         WHERE id=? AND status IN (${placeholders})`).run(reason, now, id, ...requeueableStatuses);
+    const item = this.getWorkflowWorkItem(id);
+    if (!item)
+      throw new Error(`workflow work item not found after requeue: ${id}`);
+    if (res.changes !== 1)
+      throw new Error(`workflow work item was not requeued: ${id} status=${item.status}`);
+    return item;
+  }
+  admitWorkflowWorkItem(id, patch) {
+    const now = nowIso();
+    const res = this.db.query(`UPDATE workflow_work_items
+         SET status='admitted', attempts=attempts + 1, workflow_id=$workflowId, loop_id=$loopId,
+          next_attempt_at=NULL,
+          lease_expires_at=NULL,
+          last_reason=CASE
+            WHEN last_reason IS NOT NULL AND $reason IS NOT NULL THEN last_reason || '; ' || $reason
+            ELSE COALESCE($reason, last_reason)
+          END,
+          updated_at=$updated
+         WHERE id=$id AND status IN ('queued', 'deferred')`).run({
+      $id: id,
+      $workflowId: patch.workflowId,
+      $loopId: patch.loopId,
+      $reason: patch.reason ?? null,
+      $updated: now
+    });
+    const item = this.getWorkflowWorkItem(id);
+    if (!item)
+      throw new Error(`workflow work item not found after admit: ${id}`);
+    if (res.changes !== 1)
+      throw new Error(`workflow work item is not claimable: ${id} status=${item.status}`);
+    return item;
+  }
+  setWorkflowWorkItemsForLoop(loopId, status, reason, updated, statuses = ["admitted", "running"]) {
+    const placeholders = statuses.map(() => "?").join(",");
+    this.db.query(`UPDATE workflow_work_items
+         SET status=?, lease_expires_at=NULL, last_reason=COALESCE(?, last_reason), updated_at=?
+         WHERE loop_id = ? AND status IN (${placeholders})`).run(status, reason ?? null, updated, loopId, ...statuses);
+  }
+  setWorkflowWorkItemsForWorkflowRun(workflowRunId, status, reason, updated, statuses = ["admitted", "running"]) {
+    const placeholders = statuses.map(() => "?").join(",");
+    this.db.query(`UPDATE workflow_work_items
+         SET status=?, lease_expires_at=NULL, last_reason=COALESCE(?, last_reason), updated_at=?
+         WHERE workflow_run_id = ? AND status IN (${placeholders})`).run(status, reason ?? null, updated, workflowRunId, ...statuses);
+  }
+  setWorkflowWorkItemsForLoopRun(run, reason, updated) {
+    const loop = this.getLoop(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;
+    this.setWorkflowWorkItemsForLoop(run.loopId, status, nextReason, updated, statuses);
+  }
+  createGoal(input, opts = {}) {
+    const now = nowIso();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.assertDaemonLeaseFence(opts, now);
+      const id = genId();
+      this.db.query(`INSERT INTO goals (id, plan_id, objective, status, token_budget, tokens_used, time_used_seconds, auto_execute,
+            max_tokens, source_type, source_id, loop_id, loop_run_id, workflow_id, workflow_run_id, workflow_step_id,
+            created_at, updated_at)
+           VALUES ($id, $planId, $objective, 'active', $tokenBudget, 0, 0, $autoExecute, $maxTokens, $sourceType,
+            $sourceId, $loopId, $loopRunId, $workflowId, $workflowRunId, $workflowStepId, $created, $updated)`).run({
+        $id: id,
+        $planId: id,
+        $objective: input.objective,
+        $tokenBudget: input.tokenBudget ?? null,
+        $autoExecute: input.autoExecute ?? "readyOnly",
+        $maxTokens: input.maxTokens ?? input.tokenBudget ?? null,
+        $sourceType: input.sourceType ?? null,
+        $sourceId: input.sourceId ?? null,
+        $loopId: input.loopId ?? null,
+        $loopRunId: input.loopRunId ?? null,
+        $workflowId: input.workflowId ?? null,
+        $workflowRunId: input.workflowRunId ?? null,
+        $workflowStepId: input.workflowStepId ?? null,
+        $created: now,
+        $updated: now
+      });
+      this.db.exec("COMMIT");
+      return this.requireGoal(id);
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  getGoal(id) {
+    const row = this.db.query("SELECT * FROM goals WHERE id = ?").get(id);
+    return row ? rowToGoal(row) : undefined;
+  }
+  requireGoal(id) {
+    const goal = this.getGoal(id);
+    if (!goal)
+      throw new Error(`goal not found: ${id}`);
+    return goal;
+  }
+  findGoalByLoop(idOrName) {
+    const loop = this.getLoop(idOrName) ?? this.findLoopByName(idOrName);
+    if (!loop)
+      return;
+    const row = this.db.query("SELECT * FROM goals WHERE loop_id = ? ORDER BY created_at DESC LIMIT 1").get(loop.id);
+    return row ? rowToGoal(row) : undefined;
+  }
+  findGoalByRunId(id) {
+    const direct = this.getGoal(id);
+    if (direct)
+      return direct;
+    const event = this.db.query("SELECT * FROM goal_runs WHERE id = ?").get(id);
+    if (event)
+      return this.getGoal(event.goal_id);
+    const row = this.db.query(`SELECT * FROM goals
+         WHERE loop_run_id = ? OR workflow_run_id = ? OR workflow_step_id = ?
+         ORDER BY created_at DESC LIMIT 1`).get(id, id, id);
+    return row ? rowToGoal(row) : undefined;
+  }
+  findGoalByContext(context) {
+    if (context.loopRunId) {
+      const row = this.db.query(`SELECT * FROM goals
+           WHERE loop_run_id = ? AND (? IS NULL OR workflow_step_id = ?)
+           ORDER BY created_at DESC LIMIT 1`).get(context.loopRunId, context.workflowStepId ?? null, context.workflowStepId ?? null);
+      if (row)
+        return rowToGoal(row);
+    }
+    if (context.workflowRunId) {
+      const row = this.db.query(`SELECT * FROM goals
+           WHERE workflow_run_id = ? AND (? IS NULL OR workflow_step_id = ?)
+           ORDER BY created_at DESC LIMIT 1`).get(context.workflowRunId, context.workflowStepId ?? null, context.workflowStepId ?? null);
+      if (row)
+        return rowToGoal(row);
+    }
+    if (context.sourceType && context.sourceId) {
+      const row = this.db.query("SELECT * FROM goals WHERE source_type = ? AND source_id = ? ORDER BY created_at DESC LIMIT 1").get(context.sourceType, context.sourceId);
+      if (row)
+        return rowToGoal(row);
+    }
+    return;
+  }
+  listGoals(opts = {}) {
+    const limit = opts.limit ?? 100;
+    const rows = opts.status ? this.db.query("SELECT * FROM goals WHERE status = ? ORDER BY created_at DESC LIMIT ?").all(opts.status, limit) : this.db.query("SELECT * FROM goals ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map(rowToGoal);
+  }
+  createGoalPlanNodes(goalId, nodes, opts = {}) {
+    const goal = this.requireGoal(goalId);
+    const now = nowIso();
+    const materialized = nodes.map((node, sequence) => ({
+      nodeId: genId(),
+      planId: goal.planId,
+      key: node.key,
+      sequence,
+      priority: node.priority ?? 0,
+      objective: node.objective,
+      status: "pending",
+      ready: false,
+      tokenBudget: node.tokenBudget,
+      tokensUsed: 0,
+      timeUsedSeconds: 0,
+      dependsOn: node.dependsOn ?? [],
+      createdAt: now,
+      updatedAt: now
+    }));
+    const withReady = updateReadyFlags(materialized, "active");
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.assertDaemonLeaseFence(opts, now);
+      for (const node of withReady) {
+        this.insertGoalPlanNode(goal, node);
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+    return this.listGoalPlanNodes(goalId);
+  }
+  insertGoalPlanNode(goal, node) {
+    let id = node.nodeId;
+    for (let attempt = 0;attempt < 3; attempt += 1) {
+      const res = this.db.query(`INSERT OR IGNORE INTO goal_plan_nodes (id, goal_id, plan_id, key, sequence, priority, objective, status, ready,
+            token_budget, tokens_used, time_used_seconds, depends_on_json, created_at, updated_at)
+           VALUES ($id, $goalId, $planId, $key, $sequence, $priority, $objective, $status, $ready, $tokenBudget,
+            $tokensUsed, $timeUsedSeconds, $dependsOn, $created, $updated)`).run({
+        $id: id,
+        $goalId: goal.goalId,
+        $planId: goal.planId,
+        $key: node.key,
+        $sequence: node.sequence,
+        $priority: node.priority,
+        $objective: node.objective,
+        $status: node.status,
+        $ready: node.ready ? 1 : 0,
+        $tokenBudget: node.tokenBudget ?? null,
+        $tokensUsed: node.tokensUsed,
+        $timeUsedSeconds: node.timeUsedSeconds,
+        $dependsOn: JSON.stringify(node.dependsOn),
+        $created: node.createdAt,
+        $updated: node.updatedAt
+      });
+      if (res.changes === 1)
+        return;
+      const existingByKey = this.db.query("SELECT id FROM goal_plan_nodes WHERE plan_id = ? AND key = ? LIMIT 1").get(goal.planId, node.key);
+      if (existingByKey)
+        return;
+      id = genId();
+    }
+    throw new Error(`goal plan node was not inserted after id retries: ${goal.planId}/${node.key}`);
+  }
+  listGoalPlanNodes(goalIdOrPlanId) {
+    const rows = this.db.query("SELECT * FROM goal_plan_nodes WHERE goal_id = ? OR plan_id = ? ORDER BY sequence ASC").all(goalIdOrPlanId, goalIdOrPlanId);
+    return rows.map(rowToGoalPlanNode);
+  }
+  updateGoalStatus(goalId, status, opts = {}) {
+    const current = this.requireGoal(goalId);
+    assertGoalTransition(current.status, status);
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.query(`UPDATE goals SET status=$status, 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: goalId,
+      $status: status,
+      $updated: now,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    });
+    return this.requireGoal(goalId);
+  }
+  addGoalUsage(goalId, tokens, timeUsedSeconds = 0, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.query(`UPDATE goals
+         SET tokens_used=tokens_used + $tokens, time_used_seconds=time_used_seconds + $seconds, 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: goalId,
+      $tokens: tokens,
+      $seconds: timeUsedSeconds,
+      $updated: now,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    });
+    return this.requireGoal(goalId);
+  }
+  updateGoalPlanNode(goalId, key, patch, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.query(`UPDATE goal_plan_nodes
+         SET status=COALESCE($status, status),
+          tokens_used=COALESCE($tokensUsed, tokens_used),
+          time_used_seconds=COALESCE($timeUsedSeconds, time_used_seconds),
+          ready=COALESCE($ready, ready),
+          updated_at=$updated
+         WHERE goal_id=$goalId AND key=$key
+           AND ($daemonLeaseId IS NULL OR EXISTS (
+             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+           ))`).run({
+      $goalId: goalId,
+      $key: key,
+      $status: patch.status ?? null,
+      $tokensUsed: patch.tokensUsed ?? null,
+      $timeUsedSeconds: patch.timeUsedSeconds ?? null,
+      $ready: patch.ready === undefined ? null : patch.ready ? 1 : 0,
+      $updated: now,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    });
+    const node = this.listGoalPlanNodes(goalId).find((entry) => entry.key === key);
+    if (!node)
+      throw new Error(`goal node not found: ${goalId}/${key}`);
+    return node;
+  }
+  recordGoalEvent(input, opts = {}) {
+    const goal = this.requireGoal(input.goalId);
+    const now = nowIso();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.assertDaemonLeaseFence(opts, now);
+      const previous = this.db.query("SELECT MAX(turn) AS turn FROM goal_runs WHERE goal_id = ?").get(goal.goalId);
+      const turn = input.turn ?? (previous?.turn ?? 0) + 1;
+      const id = genId();
+      this.db.query(`INSERT INTO goal_runs (id, goal_id, plan_id, loop_id, loop_run_id, workflow_id, workflow_run_id, workflow_step_id,
+            turn, phase, status, node_key, tokens_used, evidence_json, raw_response_json, created_at, updated_at)
+           VALUES ($id, $goalId, $planId, $loopId, $loopRunId, $workflowId, $workflowRunId, $workflowStepId,
+            $turn, $phase, $status, $nodeKey, $tokensUsed, $evidence, $rawResponse, $created, $updated)`).run({
+        $id: id,
+        $goalId: goal.goalId,
+        $planId: goal.planId,
+        $loopId: goal.loopId ?? null,
+        $loopRunId: goal.loopRunId ?? null,
+        $workflowId: goal.workflowId ?? null,
+        $workflowRunId: goal.workflowRunId ?? null,
+        $workflowStepId: goal.workflowStepId ?? null,
+        $turn: turn,
+        $phase: input.phase,
+        $status: input.status,
+        $nodeKey: input.nodeKey ?? null,
+        $tokensUsed: input.tokensUsed ?? 0,
+        $evidence: input.evidence ? scrubSecrets(JSON.stringify(scrubSecretsDeep(input.evidence))) : null,
+        $rawResponse: input.rawResponse === undefined ? null : scrubSecrets(JSON.stringify(scrubSecretsDeep(input.rawResponse))),
+        $created: now,
+        $updated: now
+      });
+      if (input.tokensUsed && input.tokensUsed > 0) {
+        this.db.query("UPDATE goals SET tokens_used=tokens_used + ?, updated_at=? WHERE id=?").run(input.tokensUsed, now, goal.goalId);
+      }
+      this.db.exec("COMMIT");
+      const event = this.db.query("SELECT * FROM goal_runs WHERE id = ?").get(id);
+      if (!event)
+        throw new Error(`goal run not found after record: ${id}`);
+      return rowToGoalRun(event);
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  listGoalRuns(opts = {}) {
+    const limit = opts.limit ?? 200;
+    let rows;
+    if (opts.goalId) {
+      rows = this.db.query("SELECT * FROM goal_runs WHERE goal_id = ? ORDER BY created_at ASC LIMIT ?").all(opts.goalId, limit);
+    } else if (opts.runId) {
+      rows = this.db.query(`SELECT * FROM goal_runs
+           WHERE id = ? OR loop_run_id = ? OR workflow_run_id = ?
+           ORDER BY created_at ASC LIMIT ?`).all(opts.runId, opts.runId, opts.runId, limit);
+    } else {
+      rows = this.db.query("SELECT * FROM goal_runs ORDER BY created_at DESC LIMIT ?").all(limit);
+    }
+    return rows.map(rowToGoalRun);
+  }
+  createWorkflowRun(input) {
+    const now = nowIso();
+    const targetInput = input.loop?.target.type === "workflow" ? input.loop.target.input : undefined;
+    const invocationId = input.invocationId ?? targetInput?.workflowInvocationId ?? targetInput?.invocationId;
+    const workItemId = input.workItemId ?? targetInput?.workflowWorkItemId ?? targetInput?.workItemId;
+    if (input.idempotencyKey) {
+      const existing = this.db.query("SELECT * FROM workflow_runs WHERE workflow_id = ? AND idempotency_key = ? LIMIT 1").get(input.workflow.id, input.idempotencyKey);
+      if (existing) {
+        this.assertDaemonLeaseFence(input);
+        return rowToWorkflowRun(existing);
+      }
+    }
+    const runId = genId();
+    const workItem = workItemId ? this.getWorkflowWorkItem(workItemId) : undefined;
+    const invocation = invocationId ? this.getWorkflowInvocation(invocationId) : undefined;
+    const staged = stageWorkflowRunManifest({
+      loopsDataDir: this.rootDir,
+      workflowRunId: runId,
+      workflowId: input.workflow.id,
+      workflowName: input.workflow.name,
+      invocationId,
+      workItemId,
+      projectKey: workItem?.projectKey ?? invocation?.scope?.projectPath,
+      subjectKind: invocation?.subjectRef.kind ?? (input.loop ? "loop" : "workflow"),
+      rawSubjectRef: workItem?.subjectRef ?? invocation?.subjectRef.path ?? invocation?.subjectRef.id ?? invocation?.subjectRef.url ?? input.loop?.name ?? input.workflow.name,
+      payload: {
+        workflowInvocation: invocation,
+        workflowWorkItem: workItem,
+        loopId: input.loop?.id,
+        loopRunId: input.loopRun?.id,
+        scheduledFor: input.scheduledFor ?? input.loopRun?.scheduledFor
+      }
+    });
+    const manifestPath = staged.manifestPath;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.assertDaemonLeaseFence(input, now);
+      if (input.idempotencyKey) {
+        const existing = this.db.query("SELECT * FROM workflow_runs WHERE workflow_id = ? AND idempotency_key = ? LIMIT 1").get(input.workflow.id, input.idempotencyKey);
+        if (existing) {
+          this.db.exec("COMMIT");
+          discardWorkflowRunManifest(staged);
+          return rowToWorkflowRun(existing);
+        }
+      }
+      this.db.query(`INSERT INTO workflow_runs (id, workflow_id, workflow_name, loop_id, loop_run_id, invocation_id, work_item_id,
+            scheduled_for, idempotency_key, manifest_path, status, started_at, finished_at, duration_ms, error,
+            created_at, updated_at)
+           VALUES ($id, $workflowId, $workflowName, $loopId, $loopRunId, $invocationId, $workItemId, $scheduledFor,
+            $idempotencyKey, $manifestPath, 'running', $started, NULL, NULL, NULL, $created, $updated)`).run({
+        $id: runId,
+        $workflowId: input.workflow.id,
+        $workflowName: input.workflow.name,
+        $loopId: input.loop?.id ?? null,
+        $loopRunId: input.loopRun?.id ?? null,
+        $invocationId: invocationId ?? null,
+        $workItemId: workItemId ?? null,
+        $scheduledFor: input.scheduledFor ?? input.loopRun?.scheduledFor ?? null,
+        $idempotencyKey: input.idempotencyKey ?? null,
+        $manifestPath: manifestPath ?? null,
+        $started: now,
+        $created: now,
+        $updated: now
+      });
+      if (workItemId) {
+        const workItemRes = this.db.query(`UPDATE workflow_work_items
+             SET status='running', workflow_run_id=$workflowRunId, lease_expires_at=$leaseExpiresAt, updated_at=$updated
+             WHERE id=$id AND status IN ('admitted', 'queued', 'deferred', 'running')`).run({
+          $id: workItemId,
+          $workflowRunId: runId,
+          $leaseExpiresAt: input.loop ? new Date(Date.now() + input.loop.leaseMs).toISOString() : null,
+          $updated: now
+        });
+        if (workItemRes.changes !== 1) {
+          const current = this.getWorkflowWorkItem(workItemId);
+          throw new Error(`workflow work item is not runnable: ${workItemId}${current ? ` status=${current.status}` : ""}`);
+        }
+      }
+      input.workflow.steps.forEach((step, sequence) => {
+        const account = step.account ?? step.target.account;
+        this.db.query(`INSERT INTO workflow_step_runs (id, workflow_run_id, step_id, sequence, status, started_at, finished_at,
+              exit_code, pid, duration_ms, stdout, stderr, error, account_profile, account_tool, created_at, updated_at)
+             VALUES ($id, $workflowRunId, $stepId, $sequence, 'pending', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+              $accountProfile, $accountTool, $created, $updated)`).run({
+          $id: genId(),
+          $workflowRunId: runId,
+          $stepId: step.id,
+          $sequence: sequence,
+          $accountProfile: account?.profile ?? null,
+          $accountTool: account?.tool ?? null,
+          $created: now,
+          $updated: now
+        });
+      });
+      this.db.query(`INSERT INTO workflow_events (id, workflow_run_id, sequence, event_type, step_id, payload_json, created_at)
+           VALUES ($id, $workflowRunId, 1, 'created', NULL, $payload, $created)`).run({
+        $id: genId(),
+        $workflowRunId: runId,
+        $payload: JSON.stringify({
+          workflowId: input.workflow.id,
+          workflowName: input.workflow.name,
+          stepCount: input.workflow.steps.length,
+          loopId: input.loop?.id,
+          loopRunId: input.loopRun?.id,
+          invocationId,
+          workItemId,
+          manifestPath
+        }),
+        $created: now
+      });
+      this.db.exec("COMMIT");
+      commitWorkflowRunManifest(staged);
+      const run = this.getWorkflowRun(runId);
+      if (!run)
+        throw new Error(`workflow run not found after create: ${runId}`);
+      return run;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      discardWorkflowRunManifest(staged);
+      throw error;
+    }
+  }
+  getWorkflowRun(id) {
+    const row = this.db.query("SELECT * FROM workflow_runs WHERE id = ?").get(id);
+    return row ? rowToWorkflowRun(row) : undefined;
+  }
+  requireWorkflowRun(id) {
+    const run = this.getWorkflowRun(id);
+    if (!run)
+      throw new Error(`workflow run not found: ${id}`);
+    return run;
+  }
+  listWorkflowRuns(opts = {}) {
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.workflowId) {
+      rows = this.db.query("SELECT * FROM workflow_runs WHERE workflow_id = ? ORDER BY created_at DESC LIMIT ?").all(opts.workflowId, limit);
+    } else if (opts.loopRunId) {
+      rows = this.db.query("SELECT * FROM workflow_runs WHERE loop_run_id = ? ORDER BY created_at DESC LIMIT ?").all(opts.loopRunId, limit);
+    } else {
+      rows = this.db.query("SELECT * FROM workflow_runs ORDER BY created_at DESC LIMIT ?").all(limit);
+    }
+    return rows.map(rowToWorkflowRun);
+  }
+  listWorkflowStepRuns(workflowRunId) {
+    const rows = this.db.query("SELECT * FROM workflow_step_runs WHERE workflow_run_id = ? ORDER BY sequence ASC").all(workflowRunId);
+    return rows.map(rowToWorkflowStepRun);
+  }
+  getWorkflowStepRun(workflowRunId, stepId) {
+    const row = this.db.query("SELECT * FROM workflow_step_runs WHERE workflow_run_id = ? AND step_id = ?").get(workflowRunId, stepId);
+    return row ? rowToWorkflowStepRun(row) : undefined;
+  }
+  isWorkflowRunTerminal(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    return Boolean(run && ["succeeded", "failed", "timed_out", "cancelled"].includes(run.status));
+  }
+  startWorkflowStepRun(workflowRunId, stepId, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const res = this.db.query(`UPDATE workflow_step_runs
+           SET status='running', started_at=$started, finished_at=NULL, exit_code=NULL, duration_ms=NULL,
+            pid=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
+           WHERE workflow_run_id=$workflowRunId
+             AND step_id=$stepId
+             AND status IN ('pending', 'failed', 'timed_out')
+             AND EXISTS (
+               SELECT 1 FROM workflow_runs
+               WHERE id=$workflowRunId AND status='running'
+             )
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $workflowRunId: workflowRunId,
+        $stepId: stepId,
+        $started: now,
+        $updated: now,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: now
+      });
+      const run = this.getWorkflowStepRun(workflowRunId, stepId);
+      if (!run)
+        throw new Error(`workflow step run not found: ${workflowRunId}/${stepId}`);
+      if (res.changes !== 1) {
+        throw new Error(`workflow step is not claimable: ${workflowRunId}/${stepId} status=${run.status}`);
+      }
+      this.appendWorkflowEvent(workflowRunId, "step_started", stepId);
+      this.db.exec("COMMIT");
+      return run;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  markWorkflowStepPid(workflowRunId, stepId, pid, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.query(`UPDATE workflow_step_runs SET pid=$pid, updated_at=$updated
+         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status='running'
+           AND ($daemonLeaseId IS NULL OR EXISTS (
+             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+           ))`).run({
+      $workflowRunId: workflowRunId,
+      $stepId: stepId,
+      $pid: pid,
+      $updated: now,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    });
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after pid update: ${workflowRunId}/${stepId}`);
+    return run;
+  }
+  recoverWorkflowRun(workflowRunId, reason = "workflow run recovered for retry") {
+    return this.transact(() => {
+      const now = nowIso();
+      const before = this.listWorkflowStepRuns(workflowRunId).filter((step) => step.status === "running");
+      const live = before.filter((step) => step.pid !== undefined && isLiveStepProcess(step.pid, step.startedAt));
+      if (live.length > 0) {
+        throw new Error(`cannot recover workflow run while step processes are still alive: ${live.map((step) => `${step.stepId} pid=${step.pid}`).join(", ")}`);
+      }
+      this.db.query(`UPDATE workflow_step_runs
+           SET status='pending', started_at=NULL, finished_at=NULL, exit_code=NULL, pid=NULL, duration_ms=NULL,
+            stdout=NULL, stderr=NULL, error=$reason, updated_at=$updated
+           WHERE workflow_run_id=$workflowRunId AND status='running'`).run({ $workflowRunId: workflowRunId, $reason: reason, $updated: now });
+      if (before.length > 0) {
+        this.appendWorkflowEvent(workflowRunId, "recovered", undefined, {
+          reason,
+          recoveredSteps: before.map((step) => step.stepId)
+        });
+      }
+      return {
+        run: this.requireWorkflowRun(workflowRunId),
+        recoveredSteps: before.map((step) => this.getWorkflowStepRun(workflowRunId, step.stepId)).filter(Boolean)
+      };
+    });
+  }
+  finalizeWorkflowStepRun(workflowRunId, stepId, patch, opts = {}) {
+    const finishedAt = patch.finishedAt ?? nowIso();
+    const error = patch.error === undefined ? undefined : scrubSecrets(patch.error);
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const res = this.db.query(`UPDATE workflow_step_runs SET status=$status, finished_at=$finished, exit_code=$exitCode, duration_ms=$durationMs,
+           pid=NULL, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
+           WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status='running'
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $workflowRunId: workflowRunId,
+        $stepId: stepId,
+        $status: patch.status,
+        $finished: finishedAt,
+        $exitCode: patch.exitCode ?? null,
+        $durationMs: patch.durationMs ?? null,
+        $stdout: scrubbedOrNull(patch.stdout),
+        $stderr: scrubbedOrNull(patch.stderr),
+        $error: error ?? null,
+        $updated: finishedAt,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: (opts.now ?? new Date(finishedAt)).toISOString()
+      });
+      if (res.changes === 1) {
+        this.appendWorkflowEvent(workflowRunId, `step_${patch.status}`, stepId, {
+          exitCode: patch.exitCode,
+          error
+        });
+      }
+      this.db.exec("COMMIT");
+    } catch (error2) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error2;
+    }
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after finalize: ${workflowRunId}/${stepId}`);
+    return run;
+  }
+  skipWorkflowStepRun(workflowRunId, stepId, reason, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const res = this.db.query(`UPDATE workflow_step_runs SET status='skipped', finished_at=$finished, pid=NULL, error=$error, updated_at=$updated
+           WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status IN ('pending', 'running')
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $workflowRunId: workflowRunId,
+        $stepId: stepId,
+        $finished: now,
+        $error: reason,
+        $updated: now,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: now
+      });
+      if (res.changes === 1)
+        this.appendWorkflowEvent(workflowRunId, "step_skipped", stepId, { reason });
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after skip: ${workflowRunId}/${stepId}`);
+    return run;
+  }
+  finalizeWorkflowRun(workflowRunId, status, patch = {}, opts = {}) {
+    const finishedAt = patch.finishedAt ?? nowIso();
+    const error = patch.error === undefined ? undefined : scrubSecrets(patch.error);
+    let changed = false;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const res = this.db.query(`UPDATE workflow_runs SET status=$status, finished_at=$finished, duration_ms=$durationMs, error=$error, updated_at=$updated
+           WHERE id=$id AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: workflowRunId,
+        $status: status,
+        $finished: finishedAt,
+        $durationMs: patch.durationMs ?? null,
+        $error: error ?? null,
+        $updated: finishedAt,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: (opts.now ?? new Date(finishedAt)).toISOString()
+      });
+      changed = res.changes === 1;
+      if (changed)
+        this.appendWorkflowEvent(workflowRunId, status, undefined, { error });
+      if (changed) {
+        const itemStatus = status === "succeeded" ? "succeeded" : status === "cancelled" ? "cancelled" : "failed";
+        this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, itemStatus, error, finishedAt);
+        this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, finishedAt);
+      }
+      this.db.exec("COMMIT");
+    } catch (error2) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error2;
+    }
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run)
+      throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    return run;
+  }
+  cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
+    const now = nowIso();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const run = this.requireWorkflowRun(workflowRunId);
+      if (!["succeeded", "failed", "timed_out", "cancelled"].includes(run.status)) {
+        this.db.query(`UPDATE workflow_runs
+             SET status='cancelled', finished_at=$finished, error=$reason, updated_at=$updated
+             WHERE id=$id AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).run({ $id: workflowRunId, $finished: now, $reason: reason, $updated: now });
+        this.db.query(`UPDATE workflow_step_runs
+             SET status='cancelled', finished_at=$finished, pid=NULL, error=$reason, updated_at=$updated
+             WHERE workflow_run_id=$workflowRunId AND status IN ('pending', 'running')`).run({ $workflowRunId: workflowRunId, $finished: now, $reason: reason, $updated: now });
+        this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, "cancelled", reason, now);
+        this.appendWorkflowEvent(workflowRunId, "cancelled", undefined, { reason });
+        this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, now);
+      }
+      this.db.exec("COMMIT");
+      return this.requireWorkflowRun(workflowRunId);
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  appendWorkflowEvent(workflowRunId, eventType, stepId, payload) {
+    return this.transact(() => {
+      const now = nowIso();
+      const current = this.db.query("SELECT MAX(sequence) AS sequence FROM workflow_events WHERE workflow_run_id = ?").get(workflowRunId);
+      const sequence = (current?.sequence ?? 0) + 1;
+      const id = genId();
+      this.db.query(`INSERT INTO workflow_events (id, workflow_run_id, sequence, event_type, step_id, payload_json, created_at)
+           VALUES ($id, $workflowRunId, $sequence, $eventType, $stepId, $payload, $created)`).run({
+        $id: id,
+        $workflowRunId: workflowRunId,
+        $sequence: sequence,
+        $eventType: eventType,
+        $stepId: stepId ?? null,
+        $payload: payload ? JSON.stringify(payload) : null,
+        $created: now
+      });
+      const event = this.db.query("SELECT * FROM workflow_events WHERE id = ?").get(id);
+      if (!event)
+        throw new Error(`workflow event not found after append: ${id}`);
+      return rowToWorkflowEvent(event);
+    });
+  }
+  listWorkflowEvents(workflowRunId, limit = 200) {
+    const rows = this.db.query("SELECT * FROM workflow_events WHERE workflow_run_id = ? ORDER BY sequence ASC LIMIT ?").all(workflowRunId, limit);
+    return rows.map(rowToWorkflowEvent);
+  }
+  hasRunningRun(loopId) {
+    const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND status = 'running'").get(loopId);
+    return (row?.count ?? 0) > 0;
+  }
+  hasRunningRunForSlot(loopId, scheduledFor) {
+    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;
+  }
+  markRunPid(id, pid, claimedBy, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    const startedMs = processStartTimeMs(pid);
+    const processStartedAt = startedMs === undefined ? null : new Date(startedMs).toISOString();
+    const res = claimedBy ? this.db.query(`UPDATE loop_runs SET pid=$pid, process_started_at=$processStartedAt, updated_at=$updated
+             WHERE id=$id AND status='running' AND claimed_by=$claimedBy
+               AND ($daemonLeaseId IS NULL OR EXISTS (
+                 SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+               ))`).run({
+      $id: id,
+      $pid: pid,
+      $processStartedAt: processStartedAt,
+      $updated: now,
+      $claimedBy: claimedBy,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    }) : this.db.query(`UPDATE loop_runs SET pid=$pid, process_started_at=$processStartedAt, updated_at=$updated
+             WHERE id=$id AND status='running'
+               AND ($daemonLeaseId IS NULL OR EXISTS (
+                 SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+               ))`).run({
+      $id: id,
+      $pid: pid,
+      $processStartedAt: processStartedAt,
+      $updated: now,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    });
+    if (res.changes !== 1)
+      return;
+    return this.getRun(id);
+  }
+  recordRunProcess(runId, info, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    const res = this.db.query(`UPDATE loop_runs SET pid=$pid, pgid=$pgid, process_started_at=$processStartedAt, updated_at=$updated
+         WHERE id=$id AND status='running'
+           AND ($daemonLeaseId IS NULL OR EXISTS (
+             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+           ))`).run({
+      $id: runId,
+      $pid: info.pid,
+      $pgid: info.pgid ?? null,
+      $processStartedAt: info.processStartedAt ?? isoProcessStart(info.pid) ?? now,
+      $updated: now,
+      $daemonLeaseId: opts.daemonLeaseId ?? null,
+      $now: now
+    });
+    if (res.changes !== 1)
+      return;
+    return this.getRun(runId);
+  }
+  hasLiveWorkflowStepProcesses(loopRunId) {
+    const liveWorkflowSteps = this.db.query(`SELECT wr.id AS workflow_run_id, wsr.step_id AS step_id, wsr.pid AS pid, wsr.started_at AS started_at
+         FROM workflow_runs wr
+         JOIN workflow_step_runs wsr ON wsr.workflow_run_id = wr.id
+         WHERE wr.loop_run_id = ?
+           AND wr.status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')
+           AND wsr.status = 'running'
+           AND wsr.pid IS NOT NULL`).all(loopRunId);
+    return liveWorkflowSteps.some((step) => isLiveStepProcess(step.pid, step.started_at));
+  }
+  createSkippedRun(loop, scheduledFor, reason, opts = {}) {
+    const now = nowIso();
+    const run = {
+      id: genId(),
+      loopId: loop.id,
+      loopName: loop.name,
+      scheduledFor,
+      attempt: 1,
+      status: "skipped",
+      finishedAt: now,
+      error: reason,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.assertDaemonLeaseFence(opts, now);
+      this.db.query(`INSERT OR IGNORE INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+            claimed_by, lease_expires_at, pid, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+           VALUES ($id, $loopId, $loopName, $scheduledFor, $attempt, $status, NULL, $finished, NULL, NULL, NULL, NULL, NULL,
+            NULL, NULL, $error, $created, $updated)`).run({
+        $id: run.id,
+        $loopId: run.loopId,
+        $loopName: run.loopName,
+        $scheduledFor: run.scheduledFor,
+        $attempt: run.attempt,
+        $status: run.status,
+        $finished: run.finishedAt ?? null,
+        $error: run.error ?? null,
+        $created: run.createdAt,
+        $updated: run.updatedAt
+      });
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+    return this.getRunBySlot(loop.id, scheduledFor) ?? run;
+  }
+  getRun(id) {
+    const row = this.db.query("SELECT * FROM loop_runs WHERE id = ?").get(id);
+    return row ? rowToRun(row) : undefined;
+  }
+  getRunBySlot(loopId, scheduledFor) {
+    const row = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? AND scheduled_for = ?").get(loopId, scheduledFor);
+    return row ? rowToRun(row) : undefined;
+  }
+  nextRetryableRun(loopId, maxAttempts, afterScheduledFor) {
+    const row = afterScheduledFor ? this.db.query(`SELECT * FROM loop_runs
+             WHERE loop_id = ? AND scheduled_for > ? AND status IN ('failed', 'timed_out', 'abandoned') AND attempt < ?
+             ORDER BY scheduled_for ASC LIMIT 1`).get(loopId, afterScheduledFor, maxAttempts) : this.db.query(`SELECT * FROM loop_runs
+             WHERE loop_id = ? AND status IN ('failed', 'timed_out', 'abandoned') AND attempt < ?
+             ORDER BY scheduled_for ASC LIMIT 1`).get(loopId, maxAttempts);
+    return row ? rowToRun(row) : undefined;
+  }
+  claimRun(loop, scheduledFor, runnerId, now = new Date, opts = {}) {
+    const startedAt = now.toISOString();
+    const claimToken = opts.claimToken ?? genId();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.assertDaemonLeaseFence(opts, startedAt);
+      const currentLoop = this.getLoop(loop.id);
+      if (!currentLoop || currentLoop.archivedAt) {
+        this.db.exec("COMMIT");
+        return;
+      }
+      loop = currentLoop;
+      const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
+      const existing = this.getRunBySlot(loop.id, scheduledFor);
+      if (existing) {
+        if (existing.status === "running") {
+          if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
+            this.db.exec("COMMIT");
+            return;
+          }
+          if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && this.hasLiveWorkflowStepProcesses(existing.id)) {
+            this.db.exec("COMMIT");
+            return;
+          }
+          const res3 = this.db.query(`UPDATE loop_runs SET status='running', started_at=$started, finished_at=NULL,
+               claimed_by=$claimedBy, claim_token=$claimToken, lease_expires_at=$lease, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL,
+               duration_ms=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
+               WHERE id=$id AND status='running' AND lease_expires_at <= $now`).run({
+            $id: existing.id,
+            $started: startedAt,
+            $claimedBy: runnerId,
+            $claimToken: claimToken,
+            $lease: leaseExpiresAt,
+            $updated: startedAt,
+            $now: startedAt
+          });
+          this.db.exec("COMMIT");
+          if (res3.changes !== 1)
+            return;
+          const run3 = this.getRun(existing.id);
+          return run3 ? { run: run3, loop, claimToken } : undefined;
+        }
+        if (existing.status === "succeeded" || existing.status === "skipped") {
+          this.db.exec("COMMIT");
+          return;
+        }
+        const attempt = existing.attempt + 1;
+        const res2 = this.db.query(`UPDATE loop_runs SET attempt=$attempt, status='running', started_at=$started, finished_at=NULL,
+             claimed_by=$claimedBy, claim_token=$claimToken, lease_expires_at=$lease, pid=NULL, pgid=NULL, process_started_at=NULL, exit_code=NULL,
+             duration_ms=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
+             WHERE id=$id
+               AND status IN ('failed', 'timed_out', 'abandoned')
+               AND attempt < $maxAttempts`).run({
+          $id: existing.id,
+          $attempt: attempt,
+          $started: startedAt,
+          $claimedBy: runnerId,
+          $claimToken: claimToken,
+          $lease: leaseExpiresAt,
+          $updated: startedAt,
+          $maxAttempts: loop.maxAttempts
+        });
+        this.db.exec("COMMIT");
+        if (res2.changes !== 1)
+          return;
+        const run2 = this.getRun(existing.id);
+        return run2 ? { run: run2, loop, claimToken } : undefined;
+      }
+      const id = genId();
+      const res = this.db.query(`INSERT OR IGNORE INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+            claimed_by, claim_token, lease_expires_at, pid, exit_code, duration_ms, stdout, stderr, error, created_at, updated_at)
+           VALUES ($id, $loopId, $loopName, $scheduledFor, 1, 'running', $started, NULL, $claimedBy, $claimToken, $lease,
+            NULL, NULL, NULL, NULL, NULL, NULL, $created, $updated)`).run({
+        $id: id,
+        $loopId: loop.id,
+        $loopName: loop.name,
+        $scheduledFor: scheduledFor,
+        $started: startedAt,
+        $claimedBy: runnerId,
+        $claimToken: claimToken,
+        $lease: leaseExpiresAt,
+        $created: startedAt,
+        $updated: startedAt
+      });
+      this.db.exec("COMMIT");
+      if (res.changes !== 1)
+        return;
+      const run = this.getRun(id);
+      return run ? { run, loop, claimToken } : undefined;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  finalizeRun(id, patch, opts = {}) {
+    const finishedAt = patch.finishedAt ?? nowIso();
+    const error = patch.error === undefined ? undefined : scrubSecrets(patch.error);
+    const params = {
+      $id: id,
+      $status: patch.status,
+      $finished: finishedAt,
+      $pid: patch.pid ?? null,
+      $exitCode: patch.exitCode ?? null,
+      $durationMs: patch.durationMs ?? null,
+      $stdout: scrubbedOrNull(patch.stdout),
+      $stderr: scrubbedOrNull(patch.stderr),
+      $error: error ?? null,
+      $updated: finishedAt,
+      $claimedBy: opts.claimedBy ?? null,
+      $claimToken: opts.claimToken ?? null,
+      $now: (opts.now ?? new Date).toISOString(),
+      $daemonLeaseId: opts.daemonLeaseId ?? null
+    };
+    return this.transact(() => {
+      const res = opts.claimedBy ? this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, claim_token=NULL, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
+               duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
+               WHERE id=$id AND status='running' AND claimed_by=$claimedBy AND lease_expires_at > $now
+                 AND ($claimToken IS NULL OR claim_token=$claimToken)
+                 AND ($daemonLeaseId IS NULL OR EXISTS (
+                   SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+                 ))`).run(params) : this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, claim_token=NULL, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
+               duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated WHERE id=$id`).run(params);
+      const run = this.getRun(id);
+      if (!run)
+        throw new Error(`run not found after finalize: ${id}`);
+      if (opts.claimedBy && res.changes !== 1)
+        return run;
+      if (res.changes === 1) {
+        this.setWorkflowWorkItemsForLoopRun(run, error, finishedAt);
+        const loop = this.getLoop(run.loopId);
+        const itemStatus = workItemStatusForLoopRun(run.status, run.attempt, loop?.maxAttempts);
+        if (loop?.target.type === "workflow" && itemStatus && itemStatus !== "admitted") {
+          const workItemId = loop.target.input?.workflowWorkItemId ?? loop.target.input?.workItemId;
+          this.maybeArchiveGeneratedRouteWorkflow({
+            workflowId: loop.target.workflowId,
+            loopId: loop.id,
+            workItemId,
+            updated: finishedAt
+          });
+        }
+      }
+      return run;
+    });
+  }
+  heartbeatRunLease(id, claimedBy, leaseMs, now = new Date, opts = {}) {
+    const expiresAt = new Date(now.getTime() + leaseMs).toISOString();
+    const res = this.db.query(`UPDATE loop_runs SET lease_expires_at=$expires, updated_at=$updated
+         WHERE id=$id AND status='running' AND claimed_by=$claimedBy AND lease_expires_at > $now
+           AND ($claimToken IS NULL OR claim_token=$claimToken)
+           AND ($daemonLeaseId IS NULL OR EXISTS (
+             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+           ))`).run({
+      $id: id,
+      $claimedBy: claimedBy,
+      $claimToken: opts.claimToken ?? null,
+      $expires: expiresAt,
+      $updated: now.toISOString(),
+      $now: now.toISOString(),
+      $daemonLeaseId: opts.daemonLeaseId ?? null
+    });
+    if (res.changes !== 1)
+      return;
+    return this.getRun(id);
+  }
+  listRuns(opts = {}) {
+    const limit = opts.limit ?? 100;
+    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);
+    } 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);
+    } else if (opts.status) {
+      rows = this.db.query("SELECT * FROM loop_runs WHERE status = ? ORDER BY created_at DESC LIMIT ?").all(opts.status, limit);
+    } else {
+      rows = this.db.query("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT ?").all(limit);
+    }
+    return rows.map(rowToRun);
+  }
+  deferLiveExpiredRun(id, now, opts = {}) {
+    const updated = now.toISOString();
+    const deferredUntil = new Date(now.getTime() + LIVE_EXPIRED_RUN_GRACE_MS).toISOString();
+    this.db.query(`UPDATE loop_runs SET lease_expires_at=$deferredUntil, updated_at=$updated
+         WHERE id=$id AND status='running' AND lease_expires_at <= $now
+           AND ($daemonLeaseId IS NULL OR EXISTS (
+             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+           ))`).run({
+      $id: id,
+      $deferredUntil: deferredUntil,
+      $updated: updated,
+      $now: updated,
+      $daemonLeaseId: opts.daemonLeaseId ?? null
+    });
+  }
+  recoverExpiredRunLeases(now = new Date, opts = {}) {
+    return this.recoverExpiredRunLeasesDetailed(now, opts).abandoned;
+  }
+  recoverExpiredRunLeasesDetailed(now = new Date, opts = {}) {
+    const limit = Math.max(1, Math.min(1000, Math.floor(opts.limit ?? DEFAULT_RECOVERY_BATCH_LIMIT)));
+    const scanLimit = Math.max(limit, Math.min(5000, Math.floor(opts.scanLimit ?? limit * DEFAULT_RECOVERY_SCAN_MULTIPLIER)));
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE status = 'running' AND lease_expires_at <= ?
+         ORDER BY lease_expires_at ASC
+         LIMIT ?`).all(now.toISOString(), scanLimit);
+    const recovered = [];
+    const deferred = [];
+    for (const row of rows) {
+      if (recovered.length >= limit)
+        break;
+      if (isRecordedProcessAlive(row.pid, row.process_started_at) || this.hasLiveWorkflowStepProcesses(row.id)) {
+        this.deferLiveExpiredRun(row.id, now, opts);
+        const deferredRun = this.getRun(row.id);
+        if (deferredRun)
+          deferred.push(deferredRun);
+        continue;
+      }
+      const finished = now.toISOString();
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const res = this.db.query(`UPDATE loop_runs SET status='abandoned', finished_at=$finished, lease_expires_at=NULL,
+             error='run lease expired before completion', updated_at=$updated
+             WHERE id=$id AND status='running' AND lease_expires_at <= $now
+               AND ($daemonLeaseId IS NULL OR EXISTS (
+                 SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+               ))`).run({
+          $id: row.id,
+          $finished: finished,
+          $updated: finished,
+          $now: finished,
+          $daemonLeaseId: opts.daemonLeaseId ?? null
+        });
+        if (res.changes !== 1) {
+          this.db.exec("COMMIT");
+          continue;
+        }
+        const workflowRows = this.db.query("SELECT * FROM workflow_runs WHERE loop_run_id = ? AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')").all(row.id);
+        for (const workflowRow of workflowRows) {
+          const workflowRes = this.db.query(`UPDATE workflow_runs
+               SET status='failed', finished_at=$finished, error='parent loop run lease expired before completion', updated_at=$updated
+               WHERE id=$id AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')
+                 AND ($daemonLeaseId IS NULL OR EXISTS (
+                   SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+                 ))`).run({
+            $id: workflowRow.id,
+            $finished: finished,
+            $updated: finished,
+            $now: finished,
+            $daemonLeaseId: opts.daemonLeaseId ?? null
+          });
+          if (workflowRes.changes !== 1)
+            continue;
+          this.db.query(`UPDATE workflow_step_runs
+               SET status='skipped', finished_at=$finished, pid=NULL, error='parent loop run lease expired before completion', updated_at=$updated
+               WHERE workflow_run_id=$workflowRunId AND status IN ('pending', 'running')
+                 AND ($daemonLeaseId IS NULL OR EXISTS (
+                   SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+                 ))`).run({
+            $workflowRunId: workflowRow.id,
+            $finished: finished,
+            $updated: finished,
+            $now: finished,
+            $daemonLeaseId: opts.daemonLeaseId ?? null
+          });
+          this.appendWorkflowEvent(workflowRow.id, "failed", undefined, {
+            error: "parent loop run lease expired before completion",
+            loopRunId: row.id
+          });
+          this.setWorkflowWorkItemsForWorkflowRun(workflowRow.id, "failed", "parent loop run lease expired before completion", finished);
+          this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRow.id, finished);
+        }
+        const loop = this.getLoop(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";
+          this.setWorkflowWorkItemsForLoop(row.loop_id, itemStatus, reason, finished, statuses);
+          if (loop?.target.type === "workflow" && itemStatus !== "admitted") {
+            const workItemId = loop.target.input?.workflowWorkItemId ?? loop.target.input?.workItemId;
+            this.maybeArchiveGeneratedRouteWorkflow({
+              workflowId: loop.target.workflowId,
+              loopId: loop.id,
+              workItemId,
+              updated: finished
+            });
+          }
+        }
+        this.db.exec("COMMIT");
+      } catch (error) {
+        try {
+          this.db.exec("ROLLBACK");
+        } catch {}
+        throw error;
+      }
+      const run = this.getRun(row.id);
+      if (run)
+        recovered.push(run);
+    }
+    return { abandoned: recovered, deferred };
+  }
+  expireLoops(now = new Date, opts = {}) {
+    const rows = this.db.query("SELECT * FROM loops WHERE status = 'active' AND archived_at IS NULL AND expires_at IS NOT NULL AND expires_at <= ?").all(now.toISOString());
+    const expired = [];
+    for (const row of rows) {
+      const updated = this.updateLoop(row.id, { status: "expired", nextRunAt: undefined }, opts);
+      if (updated.status === "expired")
+        expired.push(updated);
+    }
+    return expired;
+  }
+  countLoops(status, opts = {}) {
+    let row;
+    if (status && opts.archived) {
+      row = this.db.query("SELECT COUNT(*) AS count FROM loops WHERE status = ? AND archived_at IS NOT NULL").get(status);
+    } else if (status && opts.includeArchived) {
+      row = this.db.query("SELECT COUNT(*) AS count FROM loops WHERE status = ?").get(status);
+    } else if (status) {
+      row = this.db.query("SELECT COUNT(*) AS count FROM loops WHERE status = ? AND archived_at IS NULL").get(status);
+    } else if (opts.archived) {
+      row = this.db.query("SELECT COUNT(*) AS count FROM loops WHERE archived_at IS NOT NULL").get();
+    } else if (opts.includeArchived) {
+      row = this.db.query("SELECT COUNT(*) AS count FROM loops").get();
+    } else {
+      row = this.db.query("SELECT COUNT(*) AS count FROM loops WHERE archived_at IS NULL").get();
+    }
+    return row?.count ?? 0;
+  }
+  countRuns(status) {
+    const row = status ? this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE status = ?").get(status) : this.db.query("SELECT COUNT(*) AS count FROM loop_runs").get();
+    return row?.count ?? 0;
+  }
+  pruneHistory(opts) {
+    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_STATUSES.map((status) => `'${status}'`).join(",");
+    const candidateIds = this.db.query(`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 ($cutoff IS NULL OR created_at < $cutoff)
+           AND ($keep IS NULL OR recency > $keep)`).all({ $cutoff: cutoff ?? null, $keep: keepPerLoop ?? null }).map((row) => row.id);
+    const summary = {
+      dryRun,
+      cutoff,
+      keepPerLoop,
+      loopRuns: dryRun ? candidateIds.length : 0,
+      workflowRuns: 0,
+      goalRuns: 0
+    };
+    const manifestPaths = [];
+    for (let offset = 0;offset < candidateIds.length; offset += PRUNE_BATCH_SIZE) {
+      const batch = candidateIds.slice(offset, offset + PRUNE_BATCH_SIZE);
+      const batchPlaceholders = batch.map(() => "?").join(",");
+      if (dryRun) {
+        const workflowRunIds = this.db.query(`SELECT id FROM workflow_runs WHERE loop_run_id IN (${batchPlaceholders})`).all(...batch).map((row) => row.id);
+        const workflowPlaceholders = workflowRunIds.map(() => "?").join(",") || "''";
+        summary.workflowRuns += workflowRunIds.length;
+        summary.goalRuns += this.db.query(`SELECT COUNT(*) AS count FROM goal_runs
+             WHERE loop_run_id IN (${batchPlaceholders}) OR workflow_run_id IN (${workflowPlaceholders})`).get(...batch, ...workflowRunIds)?.count ?? 0;
+        continue;
+      }
+      this.transact(() => {
+        const confirmed = this.db.query(`SELECT id FROM loop_runs WHERE id IN (${batchPlaceholders}) AND status IN (${terminal})`).all(...batch).map((row) => row.id);
+        if (confirmed.length === 0)
+          return;
+        const runPlaceholders = confirmed.map(() => "?").join(",");
+        const workflowRuns = this.db.query(`SELECT id, manifest_path FROM workflow_runs WHERE loop_run_id IN (${runPlaceholders})`).all(...confirmed);
+        const workflowRunIds = workflowRuns.map((row) => row.id);
+        const workflowPlaceholders = workflowRunIds.map(() => "?").join(",") || "''";
+        summary.loopRuns += confirmed.length;
+        summary.workflowRuns += workflowRunIds.length;
+        summary.goalRuns += this.db.query(`DELETE FROM goal_runs WHERE loop_run_id IN (${runPlaceholders}) OR workflow_run_id IN (${workflowPlaceholders})`).run(...confirmed, ...workflowRunIds).changes;
+        if (workflowRunIds.length > 0) {
+          this.db.query(`DELETE FROM workflow_runs WHERE id IN (${workflowPlaceholders})`).run(...workflowRunIds);
+        }
+        this.db.query(`DELETE FROM loop_runs WHERE id IN (${runPlaceholders}) AND status IN (${terminal})`).run(...confirmed);
+        for (const row of workflowRuns) {
+          if (row.manifest_path)
+            manifestPaths.push(row.manifest_path);
+        }
+      });
+    }
+    for (const manifestPath of manifestPaths) {
+      const runDir = dirname2(manifestPath);
+      try {
+        if (/^[0-9a-f]{12,64}$/.test(basename2(runDir))) {
+          rmSync2(runDir, { recursive: true, force: true });
+        } else {
+          rmSync2(manifestPath, { force: true });
+        }
+      } catch {}
+    }
+    return summary;
+  }
+  acquireDaemonLease(input) {
+    const now = input.now ?? new Date;
+    const expiresAt = new Date(now.getTime() + input.ttlMs).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const existing = this.db.query("SELECT * FROM daemon_lease LIMIT 1").get();
+      if (existing && existing.expires_at > now.toISOString() && existing.id !== input.id) {
+        this.db.exec("COMMIT");
+        return;
+      }
+      this.db.query("DELETE FROM daemon_lease").run();
+      this.db.query(`INSERT INTO daemon_lease (id, pid, hostname, heartbeat_at, expires_at, created_at, updated_at)
+           VALUES ($id, $pid, $hostname, $heartbeat, $expires, $created, $updated)`).run({
+        $id: input.id,
+        $pid: input.pid,
+        $hostname: input.hostname,
+        $heartbeat: now.toISOString(),
+        $expires: expiresAt,
+        $created: now.toISOString(),
+        $updated: now.toISOString()
+      });
+      this.db.exec("COMMIT");
+      return this.getDaemonLease();
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  heartbeatDaemonLease(id, ttlMs, now = new Date) {
+    const expiresAt = new Date(now.getTime() + ttlMs).toISOString();
+    const res = this.db.query(`UPDATE daemon_lease SET heartbeat_at=$heartbeat, expires_at=$expires, updated_at=$updated WHERE id=$id AND expires_at > $now`).run({ $id: id, $heartbeat: now.toISOString(), $expires: expiresAt, $updated: now.toISOString(), $now: now.toISOString() });
+    if (res.changes !== 1)
+      return;
+    return this.getDaemonLease();
+  }
+  releaseDaemonLease(id) {
+    this.db.query("DELETE FROM daemon_lease WHERE id = ?").run(id);
+  }
+  getDaemonLease() {
+    const row = this.db.query("SELECT * FROM daemon_lease LIMIT 1").get();
+    return row ? rowToLease(row) : undefined;
+  }
+  writeTransaction(fn) {
+    this.db.exec("BEGIN IMMEDIATE;");
+    try {
+      const result = fn();
+      this.db.exec("COMMIT;");
+      return result;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK;");
+      } catch {}
+      throw error;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+}
+
+// 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));
+}
+export {
+  createSqliteLoopStorage,
+  SqliteLoopStorage
+};