@hasna/loops 0.3.59 → 0.4.0

package/dist/lib/store.js

@@ -1,14 +1,50 @@
 // @bun
 // src/lib/store.ts
 import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync } from "fs";
+import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
-import { dirname, join as join3 } from "path";
+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";
-function genId(length = 12) {
-  return randomBytes(Math.ceil(length / 2)).toString("hex").slice(0, length);
+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();
@@ -42,7 +78,166 @@ function launchdPlistPath() {
   return join(homedir(), "Library", "LaunchAgents", "com.hasna.loops.daemon.plist");
 }
 
-// src/lib/schedule.ts
+// 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()))
@@ -79,7 +274,20 @@ function parseField(expr, min, max) {
   }
   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}"`);
@@ -89,7 +297,7 @@ function parseCron(expr) {
     dowSet.delete(7);
     dowSet.add(0);
   }
-  return {
+  const parsed = {
     minute: parseField(minute, 0, 59),
     hour: parseField(hour, 0, 23),
     dom: parseField(dom, 1, 31),
@@ -98,6 +306,13 @@ function parseCron(expr) {
     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()))
@@ -171,14 +386,59 @@ function latestIntervalSlot(first, now, everyMs) {
   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) {
-  let current = first;
-  while (true) {
-    const next = nextCronRun(expression, current);
-    if (next.getTime() > now.getTime())
-      return current;
-    current = next;
+  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")
@@ -197,9 +457,10 @@ function dueSlots(loop, now) {
       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 < loop.catchUpLimit) {
+        while (cursor.getTime() <= now.getTime() && slots.length < limit) {
           slots.push(cursor.toISOString());
           cursor = new Date(cursor.getTime() + loop.schedule.everyMs);
         }
@@ -211,9 +472,10 @@ function dueSlots(loop, now) {
     }
     case "cron": {
       if (catchUp === "all") {
+        const limit = catchUpSlotLimit(loop);
         const slots = [];
         let cursor = next;
-        while (cursor.getTime() <= now.getTime() && slots.length < loop.catchUpLimit) {
+        while (cursor.getTime() <= now.getTime() && slots.length < limit) {
           slots.push(cursor.toISOString());
           cursor = nextCronRun(loop.schedule.expression, cursor);
         }
@@ -312,8 +574,311 @@ function updateReadyFlags(nodes, planStatus) {
 }
 
 // src/lib/workflow-spec.ts
-import { readFileSync } from "fs";
+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`);
@@ -376,7 +941,7 @@ function readPromptFile(rawPath, label, opts) {
   const path = promptFilePath(rawPath.trim(), opts);
   let prompt;
   try {
-    prompt = readFileSync(path, "utf8");
+    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}` : ""}`);
@@ -395,7 +960,7 @@ function matchingPromptSource(value, prompt, opts) {
     return;
   const path = promptFilePath(rawPath.trim(), opts);
   try {
-    return readFileSync(path, "utf8") === prompt ? { type: "file", path } : undefined;
+    return readFileSync2(path, "utf8") === prompt ? { type: "file", path } : undefined;
   } catch {
     return;
   }
@@ -442,65 +1007,14 @@ function validateTarget(value, label, opts) {
     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);
-    const providers = ["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"];
-    if (!providers.includes(value.provider))
-      throw new Error(`${label}.provider must be one of ${providers.join(", ")}`);
+    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`);
-    if (value.authProfile !== undefined) {
-      assertString(value.authProfile, `${label}.authProfile`);
-      if (value.provider !== "codewith")
-        throw new Error(`${label}.authProfile is currently supported only for provider codewith`);
-    }
-    if (value.configIsolation !== undefined) {
-      assertString(value.configIsolation, `${label}.configIsolation`);
-      if (!["safe", "none"].includes(value.configIsolation))
-        throw new Error(`${label}.configIsolation must be safe or none`);
-    }
-    if (value.model !== undefined)
-      assertString(value.model, `${label}.model`);
-    if (value.provider === "opencode" && (typeof value.model !== "string" || value.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 (value.variant !== undefined)
-      assertString(value.variant, `${label}.variant`);
-    if (value.agent !== undefined)
-      assertString(value.agent, `${label}.agent`);
-    if (value.provider === "cursor" && value.variant !== undefined)
-      throw new Error(`${label}.variant is not supported for provider cursor`);
-    if (value.provider === "codex" && value.agent !== undefined)
-      throw new Error(`${label}.agent is not supported for provider codex`);
+    const extraArgs = optionalStringArray(value.extraArgs, `${label}.extraArgs`);
     optionalStringArray(value.addDirs, `${label}.addDirs`);
-    if (Array.isArray(value.addDirs) && value.addDirs.length > 0 && !["codewith", "codex"].includes(value.provider)) {
-      throw new Error(`${label}.addDirs is currently supported only for provider codewith or codex`);
-    }
-    if (value.permissionMode !== undefined) {
-      assertString(value.permissionMode, `${label}.permissionMode`);
-      const permissionModes = ["default", "plan", "auto", "bypass"];
-      if (!permissionModes.includes(value.permissionMode)) {
-        throw new Error(`${label}.permissionMode must be one of ${permissionModes.join(", ")}`);
-      }
-      if (value.permissionMode === "plan" && !["claude", "cursor"].includes(value.provider)) {
-        throw new Error(`${label}.permissionMode plan is currently supported only for provider claude or cursor`);
-      }
-      if (value.permissionMode === "auto" && value.provider !== "claude") {
-        throw new Error(`${label}.permissionMode auto is currently supported only for provider claude`);
-      }
-    }
-    if (value.sandbox !== undefined) {
-      assertString(value.sandbox, `${label}.sandbox`);
-      const codexLike = ["read-only", "workspace-write", "danger-full-access"];
-      const cursorLike = ["enabled", "disabled"];
-      if (["codewith", "codex"].includes(value.provider)) {
-        if (!codexLike.includes(value.sandbox))
-          throw new Error(`${label}.sandbox must be one of ${codexLike.join(", ")}`);
-      } else if (value.provider === "cursor") {
-        if (!cursorLike.includes(value.sandbox))
-          throw new Error(`${label}.sandbox must be one of ${cursorLike.join(", ")}`);
-      } else {
-        throw new Error(`${label}.sandbox is currently supported only for provider codewith, codex, or cursor`);
-      }
-    }
+    providerAdapter(value.provider).validate({ ...value, extraArgs, ...promptFields }, label);
     if (value.allowlist !== undefined) {
       assertObject(value.allowlist, `${label}.allowlist`);
       optionalStringArray(value.allowlist.tools, `${label}.allowlist.tools`);
@@ -545,7 +1059,9 @@ function validateTarget(value, label, opts) {
       if (value.routing.eventSource !== undefined)
         assertString(value.routing.eventSource, `${label}.routing.eventSource`);
     }
-    const target = { ...value };
+    const target = { ...value, extraArgs };
+    if (!extraArgs)
+      delete target.extraArgs;
     delete target.promptFile;
     delete target.promptSource;
     return { ...target, ...promptFields };
@@ -628,8 +1144,8 @@ function workflowBodyFromJson(value, fallbackName, opts = {}) {
 
 // src/lib/run-artifacts.ts
 import { createHash } from "crypto";
-import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { basename, join as join2 } from "path";
+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);
 }
@@ -650,13 +1166,14 @@ function workflowRunProjectSlug(projectKey) {
     return "global";
   return safeRunPathSlug(projectKey.startsWith("/") ? basename(projectKey) : projectKey, "project");
 }
-function writeWorkflowRunManifest(args) {
+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");
-  writeFileSync(manifestPath, JSON.stringify({
+  const tmpPath = `${manifestPath}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify({
     version: 1,
     workflowRunId: args.workflowRunId,
     workflowId: args.workflowId,
@@ -669,13 +1186,26 @@ function writeWorkflowRunManifest(args) {
     createdAt: new Date().toISOString(),
     ...args.payload
   }, null, 2), { mode: 384 });
-  return manifestPath;
+  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 = 6;
+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) {
@@ -716,6 +1246,8 @@ function rowToRun(row) {
     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,
@@ -901,6 +1433,24 @@ function isProcessAlive(pid) {
     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,
@@ -920,6 +1470,9 @@ function workItemStatusForLoopRun(status, attempt, maxAttempts) {
   }
   return;
 }
+function scrubbedOrNull(value) {
+  return value == null ? null : scrubSecrets(value);
+}
 function chmodIfExists(path, mode) {
   try {
     if (existsSync(path))
@@ -927,7 +1480,7 @@ function chmodIfExists(path, mode) {
   } catch {}
 }
 function ensurePrivateStorePath(file) {
-  const dir = dirname(file);
+  const dir = dirname2(file);
   mkdirSync3(dir, { recursive: true, mode: 448 });
   chmodIfExists(dir, 448);
   chmodIfExists(file, 384);
@@ -942,14 +1495,19 @@ class Store {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
-    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname(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);
-    this.migrate();
+    try {
+      this.migrate();
+    } catch (error) {
+      this.db.close();
+      throw error;
+    }
   }
   migrate() {
     this.db.exec(`
@@ -957,7 +1515,69 @@ class Store {
         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");
+        }
+      }
+    ];
+  }
+  createBaseSchema() {
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS loops (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
@@ -996,6 +1616,8 @@ class Store {
         claimed_by TEXT,
         lease_expires_at TEXT,
         pid INTEGER,
+        pgid INTEGER,
+        process_started_at TEXT,
         exit_code INTEGER,
         duration_ms INTEGER,
         stdout TEXT,
@@ -1220,24 +1842,6 @@ class Store {
       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);
     `);
-    this.addColumnIfMissing("loops", "machine_json", "TEXT");
-    this.addColumnIfMissing("loops", "goal_json", "TEXT");
-    this.addColumnIfMissing("loops", "archived_at", "TEXT");
-    this.addColumnIfMissing("loops", "archived_from_status", "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_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.addColumnIfMissing("workflow_step_runs", "goal_run_id", "TEXT");
-    this.createWorkflowRunBackfillIndexes();
-    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0001_initial_and_workflows", nowIso());
-    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0002_loop_machines", nowIso());
-    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0003_goals", nowIso());
-    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0004_loop_archive_metadata", nowIso());
-    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0005_workflow_invocations_and_admission", nowIso());
   }
   addColumnIfMissing(table, column, definition) {
     const columns = this.db.query(`PRAGMA table_info(${table})`).all();
@@ -1251,6 +1855,9 @@ class Store {
       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;
@@ -1332,14 +1939,14 @@ class Store {
       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 Error(`loop not found: ${idOrName}`);
+      throw new LoopNotFoundError(idOrName);
     if (rows.length > 1)
-      throw new Error(`ambiguous loop name: ${idOrName}; use a loop id`);
+      throw new AmbiguousNameError(idOrName);
     return rowToLoop(rows[0]);
   }
   requireLoop(idOrName) {
     return this.getLoop(idOrName) ?? this.findLoopByName(idOrName) ?? (() => {
-      throw new Error(`loop not found: ${idOrName}`);
+      throw new LoopNotFoundError(idOrName);
     })();
   }
   listLoops(opts = {}) {
@@ -1376,7 +1983,9 @@ class Store {
     try {
       const current = this.getLoop(id);
       if (!current)
-        throw new Error(`loop not found: ${id}`);
+        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
@@ -1608,10 +2217,10 @@ class Store {
   renameLoop(id, name, opts = {}) {
     const current = this.getLoop(id);
     if (!current)
-      throw new Error(`loop not found: ${id}`);
+      throw new LoopNotFoundError(id);
     const trimmed = name.trim();
     if (!trimmed)
-      throw new Error("loop name must not be empty");
+      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
@@ -1630,25 +2239,27 @@ class Store {
     return after;
   }
   archiveLoop(idOrName) {
-    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
+    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;
     });
-    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);
@@ -1669,10 +2280,12 @@ class Store {
     return unarchived;
   }
   deleteLoop(idOrName) {
-    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;
+    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);
@@ -2189,26 +2802,7 @@ class Store {
     try {
       this.assertDaemonLeaseFence(opts, now);
       for (const node of withReady) {
-        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: node.nodeId,
-          $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
-        });
+        this.insertGoalPlanNode(goal, node);
       }
       this.db.exec("COMMIT");
     } catch (error) {
@@ -2219,6 +2813,38 @@ class Store {
     }
     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);
@@ -2310,8 +2936,8 @@ class Store {
         $status: input.status,
         $nodeKey: input.nodeKey ?? null,
         $tokensUsed: input.tokensUsed ?? 0,
-        $evidence: input.evidence ? JSON.stringify(input.evidence) : null,
-        $rawResponse: input.rawResponse === undefined ? null : JSON.stringify(input.rawResponse),
+        $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
       });
@@ -2349,7 +2975,6 @@ class Store {
     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;
-    let manifestPath;
     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) {
@@ -2357,6 +2982,28 @@ class Store {
         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);
@@ -2364,30 +3011,10 @@ class Store {
         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);
         }
       }
-      const runId = genId();
-      const workItem = workItemId ? this.getWorkflowWorkItem(workItemId) : undefined;
-      const invocation = invocationId ? this.getWorkflowInvocation(invocationId) : undefined;
-      manifestPath = invocation || workItem ? writeWorkflowRunManifest({
-        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,
-        rawSubjectRef: workItem?.subjectRef ?? invocation?.subjectRef.path ?? invocation?.subjectRef.id ?? invocation?.subjectRef.url,
-        payload: {
-          workflowInvocation: invocation,
-          workflowWorkItem: workItem,
-          loopId: input.loop?.id,
-          loopRunId: input.loopRun?.id,
-          scheduledFor: input.scheduledFor ?? input.loopRun?.scheduledFor
-        }
-      }) : undefined;
       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)
@@ -2454,6 +3081,7 @@ class Store {
         $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}`);
@@ -2462,8 +3090,7 @@ class Store {
       try {
         this.db.exec("ROLLBACK");
       } catch {}
-      if (manifestPath)
-        rmSync(manifestPath, { force: true });
+      discardWorkflowRunManifest(staged);
       throw error;
     }
   }
@@ -2561,29 +3188,32 @@ class Store {
     return run;
   }
   recoverWorkflowRun(workflowRunId, reason = "workflow run recovered for retry") {
-    const now = nowIso();
-    const before = this.listWorkflowStepRuns(workflowRunId).filter((step) => step.status === "running");
-    const live = before.filter((step) => step.pid !== undefined && isProcessAlive(step.pid));
-    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)
-    };
+    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,
@@ -2598,9 +3228,9 @@ class Store {
         $finished: finishedAt,
         $exitCode: patch.exitCode ?? null,
         $durationMs: patch.durationMs ?? null,
-        $stdout: patch.stdout ?? null,
-        $stderr: patch.stderr ?? null,
-        $error: patch.error ?? 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()
@@ -2608,15 +3238,15 @@ class Store {
       if (res.changes === 1) {
         this.appendWorkflowEvent(workflowRunId, `step_${patch.status}`, stepId, {
           exitCode: patch.exitCode,
-          error: patch.error
+          error
         });
       }
       this.db.exec("COMMIT");
-    } catch (error) {
+    } catch (error2) {
       try {
         this.db.exec("ROLLBACK");
       } catch {}
-      throw error;
+      throw error2;
     }
     const run = this.getWorkflowStepRun(workflowRunId, stepId);
     if (!run)
@@ -2656,6 +3286,7 @@ class Store {
   }
   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 {
@@ -2668,25 +3299,25 @@ class Store {
         $status: status,
         $finished: finishedAt,
         $durationMs: patch.durationMs ?? null,
-        $error: patch.error ?? 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: patch.error });
+        this.appendWorkflowEvent(workflowRunId, status, undefined, { error });
       if (changed) {
         const itemStatus = status === "succeeded" ? "succeeded" : status === "cancelled" ? "cancelled" : "failed";
-        this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, itemStatus, patch.error, finishedAt);
+        this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, itemStatus, error, finishedAt);
         this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, finishedAt);
       }
       this.db.exec("COMMIT");
-    } catch (error) {
+    } catch (error2) {
       try {
         this.db.exec("ROLLBACK");
       } catch {}
-      throw error;
+      throw error2;
     }
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
@@ -2719,24 +3350,26 @@ class Store {
     }
   }
   appendWorkflowEvent(workflowRunId, eventType, stepId, payload) {
-    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
+    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);
     });
-    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);
@@ -2752,35 +3385,64 @@ class Store {
   }
   markRunPid(id, pid, claimedBy, opts = {}) {
     const now = (opts.now ?? new Date).toISOString();
-    const res = claimedBy ? this.db.query(`UPDATE loop_runs SET pid=$pid, updated_at=$updated
+    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, updated_at=$updated
+    }) : 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, $updated: now, $daemonLeaseId: opts.daemonLeaseId ?? null, $now: 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
+    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) => isProcessAlive(step.pid));
+    return liveWorkflowSteps.some((step) => isLiveStepProcess(step.pid, step.started_at));
   }
   createSkippedRun(loop, scheduledFor, reason, opts = {}) {
     const now = nowIso();
@@ -2854,7 +3516,7 @@ class Store {
       const existing = this.getRunBySlot(loop.id, scheduledFor);
       if (existing) {
         if (existing.status === "running") {
-          if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && existing.pid && isProcessAlive(existing.pid)) {
+          if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
             this.db.exec("COMMIT");
             return;
           }
@@ -2863,7 +3525,7 @@ class Store {
             return;
           }
           const res3 = this.db.query(`UPDATE loop_runs SET status='running', started_at=$started, finished_at=NULL,
-               claimed_by=$claimedBy, lease_expires_at=$lease, pid=NULL, exit_code=NULL,
+               claimed_by=$claimedBy, 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,
@@ -2885,7 +3547,7 @@ class Store {
         }
         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, lease_expires_at=$lease, pid=NULL, exit_code=NULL,
+             claimed_by=$claimedBy, 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')
@@ -2933,6 +3595,7 @@ class Store {
   }
   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,
@@ -2940,41 +3603,43 @@ class Store {
       $pid: patch.pid ?? null,
       $exitCode: patch.exitCode ?? null,
       $durationMs: patch.durationMs ?? null,
-      $stdout: patch.stdout ?? null,
-      $stderr: patch.stderr ?? null,
-      $error: patch.error ?? null,
+      $stdout: scrubbedOrNull(patch.stdout),
+      $stderr: scrubbedOrNull(patch.stderr),
+      $error: error ?? null,
       $updated: finishedAt,
       $claimedBy: opts.claimedBy ?? null,
       $now: (opts.now ?? new Date).toISOString(),
       $daemonLeaseId: opts.daemonLeaseId ?? null
     };
-    const res = opts.claimedBy ? this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, 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 ($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, 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, patch.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 this.transact(() => {
+      const res = opts.claimedBy ? this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, 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 ($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, 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;
+      return run;
+    });
   }
   heartbeatRunLease(id, claimedBy, leaseMs, now = new Date, opts = {}) {
     const expiresAt = new Date(now.getTime() + leaseMs).toISOString();
@@ -3024,6 +3689,9 @@ class Store {
     });
   }
   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
@@ -3031,15 +3699,15 @@ class Store {
          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 (row.pid && isProcessAlive(row.pid)) {
-        this.deferLiveExpiredRun(row.id, now, opts);
-        continue;
-      }
-      if (this.hasLiveWorkflowStepProcesses(row.id)) {
+      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();
@@ -3123,7 +3791,7 @@ class Store {
       if (run)
         recovered.push(run);
     }
-    return recovered;
+    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());
@@ -3156,6 +3824,83 @@ class Store {
     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();