@hasna/loops 0.3.60 → 0.4.0

package/dist/sdk/index.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`);
@@ -356,20 +921,6 @@ function optionalStringArray(value, label) {
   }).filter(Boolean);
   return values.length ? values : undefined;
 }
-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"
-]);
 function optionalAccountRef(value, label) {
   if (value === undefined)
     return;
@@ -390,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}` : ""}`);
@@ -409,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;
   }
@@ -456,74 +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`);
-    if (value.provider === "codewith" && value.agent !== undefined) {
-      throw new Error(`${label}.agent is not supported for provider codewith durable background-agent execution`);
-    }
     const extraArgs = optionalStringArray(value.extraArgs, `${label}.extraArgs`);
-    if (value.provider === "codewith") {
-      const unsafe = 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`);
-    }
     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`);
@@ -653,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);
 }
@@ -675,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,
@@ -694,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) {
@@ -741,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,
@@ -926,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,
@@ -945,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))
@@ -952,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);
@@ -967,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(`
@@ -982,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,
@@ -1021,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,
@@ -1245,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();
@@ -1276,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;
@@ -1357,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 = {}) {
@@ -1401,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
@@ -1633,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
@@ -1655,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);
@@ -1694,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);
@@ -2214,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) {
@@ -2244,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);
@@ -2335,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
       });
@@ -2374,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) {
@@ -2382,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);
@@ -2389,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)
@@ -2479,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}`);
@@ -2487,8 +3090,7 @@ class Store {
       try {
         this.db.exec("ROLLBACK");
       } catch {}
-      if (manifestPath)
-        rmSync(manifestPath, { force: true });
+      discardWorkflowRunManifest(staged);
       throw error;
     }
   }
@@ -2586,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,
@@ -2623,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()
@@ -2633,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)
@@ -2681,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 {
@@ -2693,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)
@@ -2744,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);
@@ -2777,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();
@@ -2879,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;
           }
@@ -2888,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,
@@ -2910,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')
@@ -2958,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,
@@ -2965,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();
@@ -3049,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
@@ -3056,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();
@@ -3148,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());
@@ -3181,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();
@@ -3243,16 +3963,245 @@ class Store {
   }
 }
 
+// src/lib/doctor.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { accessSync as accessSync2, constants as constants2 } from "fs";
+
+// src/daemon/control.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { hostname } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+
+// src/daemon/loop.ts
+function realSleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function runLoop(opts) {
+  const sleep = opts.sleep ?? realSleep;
+  const sliceMs = opts.sliceMs ?? 200;
+  while (!opts.shouldStop()) {
+    try {
+      await opts.tickFn();
+    } catch (err) {
+      opts.onTickError?.(err);
+    }
+    let waited = 0;
+    while (waited < opts.intervalMs && !opts.shouldStop()) {
+      const chunk = Math.min(sliceMs, opts.intervalMs - waited);
+      await sleep(chunk);
+      waited += chunk;
+    }
+  }
+}
+
+// src/daemon/control.ts
+function readPidRecord(path = pidFilePath()) {
+  if (!existsSync2(path))
+    return;
+  let raw;
+  try {
+    raw = readFileSync3(path, "utf8").trim();
+  } catch {
+    return;
+  }
+  if (!raw)
+    return;
+  if (raw.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(raw);
+      const pid2 = Number(parsed.pid);
+      if (!Number.isInteger(pid2) || pid2 <= 0)
+        return;
+      const startedAt = Number(parsed.startedAt);
+      return { pid: pid2, startedAt: Number.isFinite(startedAt) ? startedAt : undefined };
+    } catch {
+      return;
+    }
+  }
+  const pid = Number(raw);
+  return Number.isInteger(pid) && pid > 0 ? { pid } : undefined;
+}
+function writePid(pid = process.pid, path = pidFilePath()) {
+  mkdirSync4(dirname3(path), { recursive: true, mode: 448 });
+  writeFileSync2(path, JSON.stringify({ pid, startedAt: processStartTimeMs(pid) }));
+}
+function removePid(path = pidFilePath()) {
+  rmSync3(path, { force: true });
+}
+function isAlive(pid, startedAt) {
+  try {
+    process.kill(pid, 0);
+  } catch (err) {
+    if (err.code !== "EPERM")
+      return false;
+  }
+  return sameProcessStart(startedAt, processStartTimeMs(pid));
+}
+function isDaemonRunning(path = pidFilePath()) {
+  const record = readPidRecord(path);
+  if (!record)
+    return { running: false, stale: false };
+  if (isAlive(record.pid, record.startedAt))
+    return { running: true, stale: false, pid: record.pid };
+  return { running: false, stale: true, pid: record.pid };
+}
+function toReapableProcess(run) {
+  return { pid: run.pid, pgid: run.pgid, processStartedAt: run.processStartedAt };
+}
+function ownProcessGroupId() {
+  if (process.platform === "linux") {
+    const fields = procStatFields("/proc/self/stat");
+    const pgrp = fields ? Number(fields[2]) : Number.NaN;
+    if (Number.isInteger(pgrp) && pgrp > 0)
+      return pgrp;
+  }
+  try {
+    const run = spawnSync2("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8" });
+    const pgid = Number(run.stdout.trim());
+    if (run.status === 0 && Number.isInteger(pgid) && pgid > 0)
+      return pgid;
+  } catch {}
+  return;
+}
+function signalReapTarget(target, signal) {
+  try {
+    process.kill(target.group ? -target.id : target.id, signal);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function reapProcessGroups(entries, opts = {}) {
+  const sleep = opts.sleep ?? realSleep;
+  const graceMs = Math.max(100, opts.graceMs ?? 2000);
+  const ownPgid = ownProcessGroupId();
+  const targets = new Map;
+  for (const entry of entries) {
+    const leaderPid = entry.pid ?? entry.pgid;
+    if (leaderPid !== undefined && processExists(leaderPid)) {
+      if (entry.processStartedAt === undefined) {
+        opts.log?.(`skipping reap of pid ${leaderPid}: no recorded start-time fingerprint to verify identity`);
+        continue;
+      }
+      if (!verifiedProcessStart(entry.processStartedAt, processStartTimeMs(leaderPid))) {
+        opts.log?.(`skipping reap of pid ${leaderPid}: start-time fingerprint mismatch or unverifiable (pid recycled)`);
+        continue;
+      }
+    }
+    const usableGroup = entry.pgid !== undefined && Number.isInteger(entry.pgid) && entry.pgid > 1 && entry.pgid !== process.pid && entry.pgid !== ownPgid;
+    const usablePid = entry.pid !== undefined && Number.isInteger(entry.pid) && entry.pid > 1 && entry.pid !== process.pid;
+    const target = usableGroup ? { id: entry.pgid, group: true } : usablePid ? { id: entry.pid, group: false } : undefined;
+    if (!target)
+      continue;
+    targets.set(`${target.group ? "g" : "p"}:${target.id}`, target);
+  }
+  const live = [...targets.values()].filter((target) => signalReapTarget(target, "SIGTERM"));
+  if (live.length === 0)
+    return [];
+  const steps = Math.max(1, Math.ceil(graceMs / 100));
+  let remaining = live;
+  for (let i = 0;i < steps && remaining.length > 0; i++) {
+    await sleep(100);
+    remaining = remaining.filter((target) => signalReapTarget(target, 0));
+  }
+  for (const target of remaining) {
+    signalReapTarget(target, "SIGKILL");
+    opts.log?.(`escalated to SIGKILL for ${target.group ? "pgid" : "pid"} ${target.id}`);
+  }
+  return live.map((target) => target.id);
+}
+function daemonStatus(store, path = pidFilePath()) {
+  return {
+    ...isDaemonRunning(path),
+    lease: store.getDaemonLease(),
+    host: hostname(),
+    loops: {
+      total: store.countLoops(),
+      active: store.countLoops("active"),
+      paused: store.countLoops("paused"),
+      stopped: store.countLoops("stopped"),
+      expired: store.countLoops("expired"),
+      archived: store.countLoops(undefined, { archived: true })
+    },
+    runs: {
+      total: store.countRuns(),
+      running: store.countRuns("running"),
+      failed: store.countRuns("failed"),
+      succeeded: store.countRuns("succeeded"),
+      abandoned: store.countRuns("abandoned")
+    },
+    logPath: daemonLogPath()
+  };
+}
+async function stopDaemon(opts = {}) {
+  const path = opts.path ?? pidFilePath();
+  const record = readPidRecord(path);
+  const state = isDaemonRunning(path);
+  if (state.stale) {
+    removePid(path);
+    return { wasRunning: false, stopped: false, forced: false, pid: state.pid };
+  }
+  if (!state.running || !state.pid)
+    return { wasRunning: false, stopped: false, forced: false };
+  const sleep = opts.sleep ?? realSleep;
+  const store = new Store(join4(dirname3(path), "loops.db"));
+  try {
+    const lease = store.getDaemonLease();
+    if (!lease || lease.pid !== state.pid || new Date(lease.expiresAt).getTime() <= Date.now()) {
+      removePid(path);
+      return { wasRunning: false, stopped: false, forced: false, pid: state.pid };
+    }
+    try {
+      process.kill(state.pid, "SIGTERM");
+    } catch {
+      removePid(path);
+      return { wasRunning: true, stopped: true, forced: false, pid: state.pid };
+    }
+    const steps = Math.max(1, Math.ceil((opts.timeoutMs ?? 6000) / 100));
+    for (let i = 0;i < steps; i++) {
+      await sleep(100);
+      if (!isAlive(state.pid, record?.startedAt)) {
+        removePid(path);
+        return { wasRunning: true, stopped: true, forced: false, pid: state.pid };
+      }
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+    } catch {}
+    await sleep(150);
+    removePid(path);
+    const ownedRuns = store.listRuns({ status: "running", limit: 1000 }).filter((run) => run.claimedBy !== undefined && run.claimedBy.endsWith(`:${lease.id}`));
+    const reapedPgids = await reapProcessGroups(ownedRuns.map(toReapableProcess), {
+      sleep,
+      graceMs: opts.reapGraceMs
+    });
+    return { wasRunning: true, stopped: !isAlive(state.pid, record?.startedAt), forced: true, pid: state.pid, reapedPgids };
+  } finally {
+    store.close();
+  }
+}
+
 // src/lib/executor.ts
-import { spawn, spawnSync as spawnSync2 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { once } from "events";
-import { resolveMachineCommand } from "@hasna/machines/consumer";
+import { lstatSync, mkdirSync as mkdirSync5, realpathSync } from "fs";
+import { dirname as dirname4, resolve as resolve2 } from "path";
 
 // src/lib/accounts.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync2 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
 var EXPORT_RE = /^export\s+([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+var ACCOUNTS_ENV_TIMEOUT_MS = 30000;
 function accountToolForProvider(provider) {
   switch (provider) {
     case "claude":
@@ -3314,21 +4263,17 @@ function accountDirEnvVar(tool) {
       return;
   }
 }
-function resolveAccountEnv(account, toolHint, env) {
-  if (!account)
-    return {};
+function requiredAccountTool(account, toolHint) {
   const tool = account.tool ?? toolHint;
   if (!tool)
     throw new Error("account.tool is required when no provider tool can be inferred");
-  const result = spawnSync("accounts", ["env", account.profile, "--tool", tool], {
-    encoding: "utf8",
-    env,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
+  return tool;
+}
+function accountEnvFromResult(account, tool, result) {
   if (result.error) {
-    throw new Error(`failed to run accounts env for ${account.profile}/${tool}: ${result.error.message}`);
+    throw new Error(`failed to run accounts env for ${account.profile}/${tool}: ${result.error}`);
   }
-  if ((result.status ?? 0) !== 0) {
+  if ((result.status ?? 1) !== 0) {
     const stderr = result.stderr.trim();
     throw new Error(`accounts env failed for ${account.profile}/${tool}${stderr ? `: ${stderr}` : ""}`);
   }
@@ -3336,7 +4281,7 @@ function resolveAccountEnv(account, toolHint, env) {
   const profileDir = (accountDirEnvVar(tool) ? accountEnv[accountDirEnvVar(tool)] : undefined) ?? primaryAccountDir(result.stdout);
   if (!profileDir)
     throw new Error(`accounts env returned no profile directory for ${account.profile}/${tool}`);
-  if (!existsSync2(profileDir))
+  if (!existsSync3(profileDir))
     throw new Error(`account profile directory does not exist for ${account.profile}/${tool}: ${profileDir}`);
   return {
     ...accountEnv,
@@ -3344,11 +4289,38 @@ function resolveAccountEnv(account, toolHint, env) {
     LOOPS_ACCOUNT_TOOL: tool
   };
 }
+async function resolveAccountEnv(account, toolHint, env) {
+  if (!account)
+    return {};
+  const tool = requiredAccountTool(account, toolHint);
+  const result = await spawnCapture("accounts", ["env", account.profile, "--tool", tool], {
+    env,
+    timeoutMs: ACCOUNTS_ENV_TIMEOUT_MS
+  });
+  return accountEnvFromResult(account, tool, result);
+}
+function resolveAccountEnvSync(account, toolHint, env) {
+  if (!account)
+    return {};
+  const tool = requiredAccountTool(account, toolHint);
+  const result = spawnSync3("accounts", ["env", account.profile, "--tool", tool], {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: ACCOUNTS_ENV_TIMEOUT_MS
+  });
+  return accountEnvFromResult(account, tool, {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error?.message
+  });
+}
 
 // src/lib/env.ts
 import { accessSync, constants } from "fs";
 import { homedir as homedir2 } from "os";
-import { delimiter, join as join4 } from "path";
+import { delimiter, join as join5 } from "path";
 function compactPathParts(parts) {
   const seen = new Set;
   const result = [];
@@ -3364,14 +4336,14 @@ function compactPathParts(parts) {
 function commonExecutableDirs(env = process.env) {
   const home = env.HOME || homedir2();
   return compactPathParts([
-    join4(home, ".local", "bin"),
-    join4(home, ".bun", "bin"),
-    join4(home, ".cargo", "bin"),
-    join4(home, ".npm-global", "bin"),
-    join4(home, "bin"),
-    env.BUN_INSTALL ? join4(env.BUN_INSTALL, "bin") : undefined,
+    join5(home, ".local", "bin"),
+    join5(home, ".bun", "bin"),
+    join5(home, ".cargo", "bin"),
+    join5(home, ".npm-global", "bin"),
+    join5(home, "bin"),
+    env.BUN_INSTALL ? join5(env.BUN_INSTALL, "bin") : undefined,
     env.PNPM_HOME,
-    env.NPM_CONFIG_PREFIX ? join4(env.NPM_CONFIG_PREFIX, "bin") : undefined,
+    env.NPM_CONFIG_PREFIX ? join5(env.NPM_CONFIG_PREFIX, "bin") : undefined,
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -3395,7 +4367,7 @@ function executableExists(command, env = process.env) {
   if (command.includes("/"))
     return isExecutable(command);
   for (const dir of (env.PATH ?? "").split(delimiter)) {
-    if (dir && isExecutable(join4(dir, command)))
+    if (dir && isExecutable(join5(dir, command)))
       return true;
   }
   return false;
@@ -3405,10 +4377,20 @@ function commandNotFoundMessage(command, env = process.env) {
 }
 
 // src/lib/machines.ts
-import {
-  discoverMachineTopology,
-  resolveMachineRoute
-} from "@hasna/machines/consumer";
+import { createRequire } from "module";
+var consumerModule;
+function machinesConsumer() {
+  if (!consumerModule) {
+    try {
+      const resolved = Bun.resolveSync("@hasna/machines/consumer", import.meta.dir);
+      consumerModule = createRequire(import.meta.url)(resolved);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`@hasna/machines is not available; install the optional dependency to use machine-assigned loops: ${detail}`);
+    }
+  }
+  return consumerModule;
+}
 function compact(value) {
   const text = value?.trim();
   return text ? text : undefined;
@@ -3445,14 +4427,18 @@ function machineFromRoute(route, topology) {
   };
 }
 function listOpenMachines() {
-  const topology = discoverMachineTopology();
+  const topology = machinesConsumer().discoverMachineTopology();
   return topology.machines.map((entry) => entryToSummary(entry, topology));
 }
 function resolveLoopMachine(machineId) {
-  const topology = discoverMachineTopology();
-  const route = resolveMachineRoute(machineId, { topology });
+  const consumer = machinesConsumer();
+  const topology = consumer.discoverMachineTopology();
+  const route = consumer.resolveMachineRoute(machineId, { topology });
   return machineFromRoute(route, topology);
 }
+function resolveMachineCommand(machineId, command) {
+  return machinesConsumer().resolveMachineCommand(machineId, command);
+}
 function refreshLoopMachine(machine) {
   return resolveLoopMachine(machine.id);
 }
@@ -3460,6 +4446,10 @@ function refreshLoopMachine(machine) {
 // src/lib/executor.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60000;
 var DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
+var DEFAULT_AGENT_IDLE_TIMEOUT_MS = 30 * 60000;
+var BUFFERED_OUTPUT_PROVIDERS = new Set(["claude", "codewith", "opencode", "aicopilot"]);
+var DEFAULT_BUFFERED_AGENT_IDLE_TIMEOUT_MS = 4 * 60 * 60000;
+var WORKTREE_GIT_TIMEOUT_MS = 5 * 60000;
 var AUTH_ENV_KEYS = [
   "CLAUDE_CONFIG_DIR",
   "CODEWITH_HOME",
@@ -3495,34 +4485,39 @@ var TRANSPORT_ENV_KEYS = new Set([
   "USER",
   "XDG_RUNTIME_DIR"
 ]);
-function appendBounded(current, chunk, maxBytes) {
-  const next = current + chunk.toString("utf8");
-  if (Buffer.byteLength(next, "utf8") <= maxBytes)
-    return next;
-  const overflow = Buffer.byteLength(next, "utf8") - maxBytes;
-  return `[truncated ${overflow} bytes]
-${next.slice(-maxBytes)}`;
-}
-function appendBoundedText(current, chunk, maxBytes) {
-  return appendBounded(current, Buffer.from(chunk, "utf8"), maxBytes);
-}
-function killProcessGroup(pid) {
-  try {
-    process.kill(-pid, "SIGTERM");
-  } catch {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {}
-  }
-  setTimeout(() => {
-    try {
-      process.kill(-pid, "SIGKILL");
-    } catch {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {}
-    }
-  }, 2000).unref();
+function boundedText(text, maxBytes) {
+  const buffer = new BoundedOutputBuffer(maxBytes);
+  buffer.append(text);
+  return buffer.value();
+}
+function buildResult(status, startedAt, fields = {}) {
+  const finishedAt = fields.finishedAt ?? nowIso();
+  return {
+    status,
+    exitCode: fields.exitCode,
+    stdout: fields.stdout ?? "",
+    stderr: fields.stderr ?? "",
+    error: fields.error,
+    pid: fields.pid,
+    startedAt,
+    finishedAt,
+    durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
+  };
+}
+function failureResult(startedAt, error, fields = {}) {
+  return buildResult("failed", startedAt, { ...fields, error });
+}
+function timeoutResult(startedAt, error, fields = {}) {
+  return buildResult("timed_out", startedAt, { ...fields, error });
+}
+function successResult(startedAt, fields = {}) {
+  return buildResult("succeeded", startedAt, fields);
+}
+function notifySpawn(pid, opts) {
+  if (!pid)
+    return;
+  opts.onSpawn?.(pid);
+  opts.onSpawnProcess?.({ pid, pgid: pid, processStartedAt: nowIso() });
 }
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -3578,229 +4573,21 @@ function allowlistEnv(allowlist) {
     env.LOOPS_AGENT_ALLOWLIST_ENFORCEMENT = "metadata_only";
   return env;
 }
-function providerCommand(provider) {
-  switch (provider) {
-    case "claude":
-      return "claude";
-    case "cursor":
-      return "sh";
-    case "codewith":
-      return "codewith";
-    case "aicopilot":
-      return "aicopilot";
-    case "opencode":
-      return "opencode";
-    case "codex":
-      return "codex";
-  }
-}
-function codewithLikeSandbox(target) {
-  const sandbox = target.sandbox ?? (target.permissionMode === "bypass" ? "danger-full-access" : "workspace-write");
-  if (sandbox !== "read-only" && sandbox !== "workspace-write" && sandbox !== "danger-full-access") {
-    throw new Error(`${target.provider} sandbox must be read-only, workspace-write, or danger-full-access`);
-  }
-  return sandbox;
-}
-function configStringValue(value) {
-  return JSON.stringify(value);
-}
-var UNSAFE_CODEWITH_DURABLE_EXTRA_ARGS2 = 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"
-]);
-function assertStringOption(value, label) {
-  if (value !== undefined && typeof value !== "string")
-    throw new Error(`${label} must be a string`);
-}
-function assertSupportedAgentOptions(target) {
-  assertStringOption(target.variant, `${target.provider}.variant`);
-  assertStringOption(target.model, `${target.provider}.model`);
-  assertStringOption(target.agent, `${target.provider}.agent`);
-  assertStringOption(target.authProfile, `${target.provider}.authProfile`);
-  assertStringOption(target.configIsolation, `${target.provider}.configIsolation`);
-  if (target.provider === "opencode" && (target.model === undefined || target.model.trim() === "")) {
-    throw new Error("opencode.model is required; pass a provider/model id such as openrouter/google/gemini-2.5-flash");
-  }
-  if (target.configIsolation !== undefined && target.configIsolation !== "safe" && target.configIsolation !== "none") {
-    throw new Error(`${target.provider}.configIsolation must be safe or none`);
-  }
-  if (target.authProfile !== undefined && target.provider !== "codewith") {
-    throw new Error(`${target.provider}.authProfile is supported only for codewith`);
-  }
-  if (target.addDirs?.length && !["codewith", "codex"].includes(target.provider)) {
-    throw new Error(`${target.provider}.addDirs is currently supported only for codewith or codex`);
-  }
-  if (target.permissionMode && !["default", "plan", "auto", "bypass"].includes(target.permissionMode)) {
-    throw new Error(`${target.provider}.permissionMode must be default, plan, auto, or bypass`);
-  }
-  if (target.sandbox && !["read-only", "workspace-write", "danger-full-access", "enabled", "disabled"].includes(target.sandbox)) {
-    throw new Error(`${target.provider}.sandbox is not supported: ${target.sandbox}`);
-  }
-  if (target.provider === "codex" && target.agent !== undefined)
-    throw new Error("codex.agent is not supported");
-  if (target.provider === "codewith" && target.agent !== undefined) {
-    throw new Error("codewith.agent is not supported by the durable background-agent adapter");
-  }
-  if (target.provider === "codewith") {
-    const unsafe = target.extraArgs?.find((arg) => UNSAFE_CODEWITH_DURABLE_EXTRA_ARGS2.has(arg));
-    if (unsafe)
-      throw new Error(`codewith.extraArgs cannot include ${unsafe}; durable agent steps use codewith agent start, not exec/ephemeral flags`);
-  }
-  if (["codewith", "codex"].includes(target.provider)) {
-    if (target.permissionMode && !["default", "bypass"].includes(target.permissionMode)) {
-      throw new Error(`${target.provider}.permissionMode supports only default or bypass`);
-    }
-    if (target.sandbox)
-      codewithLikeSandbox(target);
-    return;
-  }
-  if (target.provider === "claude") {
-    if (target.sandbox !== undefined)
-      throw new Error("claude.sandbox is not supported");
+function defaultAgentIdleTimeoutMs(target, opts) {
+  if (target.timeoutMs !== undefined || target.idleTimeoutMs !== undefined)
     return;
+  const raw = opts.env?.LOOPS_AGENT_IDLE_TIMEOUT_MS ?? process.env.LOOPS_AGENT_IDLE_TIMEOUT_MS;
+  if (raw !== undefined && raw !== "") {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "0" || normalized === "none" || normalized === "off")
+      return;
+    const parsed = Number(normalized);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
   }
-  if (target.provider === "cursor") {
-    if (target.variant !== undefined)
-      throw new Error("cursor.variant is not supported");
-    if (target.permissionMode === "auto")
-      throw new Error("cursor.permissionMode auto is not supported; use provider-specific extraArgs for Cursor auto-review");
-    if (target.sandbox !== undefined && target.sandbox !== "enabled" && target.sandbox !== "disabled") {
-      throw new Error("cursor.sandbox must be enabled or disabled");
-    }
-    return;
-  }
-  if (target.permissionMode && !["default", "bypass"].includes(target.permissionMode)) {
-    throw new Error(`${target.provider}.permissionMode supports only default or bypass`);
-  }
-  if (target.sandbox !== undefined)
-    throw new Error(`${target.provider}.sandbox is not supported`);
-}
-function agentArgs(target) {
-  assertSupportedAgentOptions(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 === "plan" || permissionMode === "auto" ? permissionMode : undefined;
-        if (mode)
-          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 args;
-    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) {
-        if (cursorSandbox !== "enabled" && cursorSandbox !== "disabled")
-          throw new Error("cursor sandbox must be enabled or disabled");
-        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 args;
-    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 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 args;
-    case "aicopilot":
-      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 args;
-    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 args;
-  }
+  return BUFFERED_OUTPUT_PROVIDERS.has(target.provider) ? DEFAULT_BUFFERED_AGENT_IDLE_TIMEOUT_MS : DEFAULT_AGENT_IDLE_TIMEOUT_MS;
 }
-function commandSpec(target) {
+function commandSpec(target, opts) {
   if (target.type === "command") {
     const commandTarget = target;
     return {
@@ -3816,25 +4603,27 @@ function commandSpec(target) {
     };
   }
   const agentTarget = target;
+  const adapter = providerAdapter(agentTarget.provider);
+  const invocation = adapter.buildInvocation(agentTarget);
   return {
-    command: providerCommand(agentTarget.provider),
-    args: agentArgs(agentTarget),
+    command: invocation.command,
+    args: invocation.args,
     cwd: agentTarget.cwd,
     timeoutMs: agentTarget.timeoutMs ?? null,
-    idleTimeoutMs: agentTarget.idleTimeoutMs,
+    idleTimeoutMs: agentTarget.idleTimeoutMs ?? defaultAgentIdleTimeoutMs(agentTarget, opts),
     account: agentTarget.account,
     accountTool: agentTarget.account?.tool ?? accountToolForProvider(agentTarget.provider),
     nativeAuthProfile: agentTarget.authProfile ? { provider: agentTarget.provider, profile: agentTarget.authProfile } : undefined,
-    preflightAnyOf: agentTarget.provider === "cursor" ? ["agent"] : undefined,
-    stdin: agentTarget.provider === "codewith" ? undefined : agentTarget.prompt,
+    preflightAnyOf: invocation.preflightAnyOf,
+    stdin: invocation.stdin,
     allowlist: agentTarget.allowlist,
-    codewithDurableAgent: agentTarget.provider === "codewith" ? { target: agentTarget } : undefined
+    worktree: agentTarget.worktree,
+    codewithDurableAgent: adapter.capabilities.durable ? { target: agentTarget } : undefined
   };
 }
-function executionEnv(spec, metadata, opts) {
+function composeExecutionEnv(spec, metadata, opts, accountEnv) {
   const env = { ...opts.env ?? process.env };
-  if (spec.account) {
-    const accountEnv = resolveAccountEnv(spec.account, spec.accountTool, env);
+  if (accountEnv) {
     for (const key of AUTH_ENV_KEYS)
       delete env[key];
     Object.assign(env, accountEnv);
@@ -3845,6 +4634,14 @@ function executionEnv(spec, metadata, opts) {
   Object.assign(env, metadataEnv(metadata));
   return env;
 }
+async function executionEnv(spec, metadata, opts) {
+  const accountEnv = spec.account ? await resolveAccountEnv(spec.account, spec.accountTool, { ...opts.env ?? process.env }) : undefined;
+  return composeExecutionEnv(spec, metadata, opts, accountEnv);
+}
+function executionEnvSync(spec, metadata, opts) {
+  const accountEnv = spec.account ? resolveAccountEnvSync(spec.account, spec.accountTool, { ...opts.env ?? process.env }) : undefined;
+  return composeExecutionEnv(spec, metadata, opts, accountEnv);
+}
 function resolvedMachine(opts) {
   if (!opts.machine)
     return;
@@ -3862,13 +4659,21 @@ function hereDoc(value) {
   }
   return [`cat > "$__OPENLOOPS_STDIN" <<'${delimiter2}'`, value, delimiter2];
 }
-function remoteBootstrapLines(spec, metadata) {
+function remoteBootstrapLines(spec, metadata, opts = {}) {
   const lines = [
     "set -e",
     'export PATH="$HOME/.local/bin:$HOME/.bun/bin:$HOME/.cargo/bin:$HOME/.npm-global/bin:$HOME/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin${PATH:+:$PATH}"'
   ];
-  if (spec.cwd)
+  const worktree = spec.worktree;
+  const worktreeManaged = worktree?.enabled && (worktree.mode === "auto" || worktree.mode === "required");
+  if (opts.worktree && worktree && worktreeManaged) {
+    lines.push(...remoteWorktreePrepareLines(worktree));
+    lines.push(...remoteWorktreeEnterLines(worktree, spec.cwd));
+  } else if (worktree && worktreeManaged) {
+    lines.push(`cd ${shellQuote(worktree.originalCwd)}`);
+  } else if (spec.cwd) {
     lines.push(`cd ${shellQuote(spec.cwd)}`);
+  }
   if (spec.account) {
     if (!spec.accountTool)
       throw new Error("account.tool is required when no provider tool can be inferred");
@@ -3884,16 +4689,79 @@ function remoteBootstrapLines(spec, metadata) {
   }
   return lines;
 }
-function remoteScript(spec, metadata) {
-  const lines = remoteBootstrapLines(spec, metadata);
+function remoteWorktreePrepareLines(worktree) {
+  const { repoRoot, path, branch } = worktree;
+  if (!repoRoot || !path || !branch) {
+    return [
+      "__openloops_prepare_worktree() {",
+      `  echo ${shellQuote("worktree preparation requires repoRoot, path, and branch metadata")} >&2`,
+      "  return 1",
+      "}"
+    ];
+  }
+  return [
+    "__openloops_prepare_worktree() {",
+    `  local repo=${shellQuote(repoRoot)} path=${shellQuote(path)} branch=${shellQuote(branch)}`,
+    "  local top expected_common actual_common current",
+    '  if [ -L "$path" ]; then echo "refusing symlinked worktree path $path" >&2; return 1; fi',
+    '  if [ -e "$path" ]; then',
+    '    top="$(git -C "$path" rev-parse --show-toplevel 2>/dev/null)" || { echo "refusing to reuse non-worktree path: $path" >&2; return 1; }',
+    '    if [ "$(cd "$top" 2>/dev/null && pwd -P)" != "$(cd "$path" 2>/dev/null && pwd -P)" ]; then echo "existing worktree top-level mismatch for $path: $top" >&2; return 1; fi',
+    '    expected_common="$(cd "$repo" 2>/dev/null && cd "$(git rev-parse --git-common-dir 2>/dev/null)" 2>/dev/null && pwd -P)"',
+    '    actual_common="$(cd "$path" 2>/dev/null && cd "$(git rev-parse --git-common-dir 2>/dev/null)" 2>/dev/null && pwd -P)"',
+    '    if [ -z "$expected_common" ] || [ "$expected_common" != "$actual_common" ]; then echo "existing worktree $path belongs to a different git common dir" >&2; return 1; fi',
+    '    current="$(git -C "$path" branch --show-current 2>/dev/null)"',
+    '    if [ "$current" != "$branch" ]; then echo "existing worktree $path is on branch ${current:-unknown}, expected $branch" >&2; return 1; fi',
+    "    return 0",
+    "  fi",
+    '  git -C "$repo" rev-parse --is-inside-work-tree >/dev/null 2>&1 || { echo "worktree repoRoot is not a git repository: $repo" >&2; return 1; }',
+    '  mkdir -p "$(dirname "$path")" || return 1',
+    "  # Preparation chatter goes to stderr so run stdout stays the agent's.",
+    '  if git -C "$repo" show-ref --verify --quiet "refs/heads/$branch"; then',
+    '    git -C "$repo" worktree add "$path" "$branch" 1>&2 || return 1',
+    "  else",
+    '    git -C "$repo" worktree add -b "$branch" "$path" HEAD 1>&2 || return 1',
+    "  fi",
+    "}"
+  ];
+}
+function remoteWorktreeEnterLines(worktree, cwd) {
+  const workdir = cwd ?? worktree.cwd;
+  if (worktree.mode === "required") {
+    return [
+      "if ! __openloops_prepare_worktree; then",
+      `  echo ${shellQuote("worktree preparation failed (mode=required)")} >&2`,
+      "  exit 1",
+      "fi",
+      "__OPENLOOPS_WORKTREE_OK=1",
+      `cd ${shellQuote(workdir)}`
+    ];
+  }
+  return [
+    "if __openloops_prepare_worktree; then",
+    "  __OPENLOOPS_WORKTREE_OK=1",
+    `  cd ${shellQuote(workdir)}`,
+    "else",
+    `  echo ${shellQuote(`worktree preparation failed (mode=${worktree.mode}); falling back to ${worktree.originalCwd}`)} >&2`,
+    "  __OPENLOOPS_WORKTREE_OK=0",
+    `  cd ${shellQuote(worktree.originalCwd)}`,
+    "fi"
+  ];
+}
+function remoteScript(spec, metadata, fallbackSpec) {
+  const lines = remoteBootstrapLines(spec, metadata, { worktree: true });
   let stdinRedirect = "";
   if (spec.stdin !== undefined) {
     lines.push('__OPENLOOPS_STDIN="$(mktemp -t openloops-stdin.XXXXXX)"', `trap 'rm -f "$__OPENLOOPS_STDIN"' EXIT`);
     lines.push(...hereDoc(spec.stdin));
     stdinRedirect = ' < "$__OPENLOOPS_STDIN"';
   }
-  const invocation = spec.shell ? `sh -c ${shellQuote(commandForShell(spec))}${stdinRedirect}` : `${[spec.command, ...spec.args].map(shellQuote).join(" ")}${stdinRedirect}`;
-  lines.push(invocation);
+  const invocationFor = (invocationSpec) => invocationSpec.shell ? `sh -c ${shellQuote(commandForShell(invocationSpec))}${stdinRedirect}` : `${[invocationSpec.command, ...invocationSpec.args].map(shellQuote).join(" ")}${stdinRedirect}`;
+  if (spec.worktree?.enabled && spec.worktree.mode === "auto" && fallbackSpec) {
+    lines.push('if [ "${__OPENLOOPS_WORKTREE_OK:-0}" = 1 ]; then', `  ${invocationFor(spec)}`, "else", `  ${invocationFor(fallbackSpec)}`, "fi");
+  } else {
+    lines.push(invocationFor(spec));
+  }
   return `${lines.join(`
 `)}
 `;
@@ -3925,31 +4793,43 @@ function transportEnv(opts) {
   env.PATH = normalizeExecutionPath(env);
   return env;
 }
-function preflightNativeAuthProfile(spec, env) {
-  if (!spec.nativeAuthProfile)
-    return;
-  if (spec.nativeAuthProfile.provider !== "codewith")
-    return;
-  const result = spawnSync2(spec.command, ["profile", "list"], {
-    encoding: "utf8",
-    env,
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 15000
-  });
+function assertCodewithProfileListed(profile, result) {
   if (result.error) {
-    throw new Error(`codewith auth profile preflight failed: ${result.error.message}`);
+    throw new Error(`codewith auth profile preflight failed: ${result.error}`);
   }
   if ((result.status ?? 1) !== 0) {
     const detail = (result.stderr || result.stdout || `exit ${result.status ?? "unknown"}`).trim();
     throw new Error(`codewith auth profile preflight failed${detail ? `: ${detail}` : ""}`);
   }
   const profiles = new Set((result.stdout || "").split(/\r?\n/).slice(1).map((line) => line.trim().split(/\s+/)[0]).filter(Boolean));
-  if (!profiles.has(spec.nativeAuthProfile.profile)) {
-    throw new Error(`codewith auth profile not found: ${spec.nativeAuthProfile.profile}`);
+  if (!profiles.has(profile)) {
+    throw new Error(`codewith auth profile not found: ${profile}`);
   }
 }
+function preflightNativeAuthProfileSync(spec, env) {
+  if (spec.nativeAuthProfile?.provider !== "codewith")
+    return;
+  const result = spawnSync4(spec.command, ["profile", "list"], {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 15000
+  });
+  assertCodewithProfileListed(spec.nativeAuthProfile.profile, {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error?.message
+  });
+}
+async function preflightNativeAuthProfile(spec, env) {
+  if (spec.nativeAuthProfile?.provider !== "codewith")
+    return;
+  const result = await spawnCapture(spec.command, ["profile", "list"], { env, timeoutMs: 15000 });
+  assertCodewithProfileListed(spec.nativeAuthProfile.profile, result);
+}
 function codewithAgentStartArgs(target, idempotencyKey) {
-  const args = agentArgs(target);
+  const args = providerAdapter(target.provider).buildInvocation(target).args;
   const startIndex = args.findIndex((arg, index) => arg === "start" && args[index - 1] === "agent");
   if (startIndex === -1)
     throw new Error("internal error: codewith durable agent args missing agent start");
@@ -4023,7 +4903,7 @@ function codewithAgentEvidence(startJson, readJson, logsJson) {
   }, null, 2);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt) {
   const target = spec.codewithDurableAgent?.target;
@@ -4031,116 +4911,84 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
     throw new Error("internal error: missing codewith durable target");
   const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   const idempotencyKey = codewithAgentIdempotencyKey(metadata);
-  const start = spawnSync2(spec.command, codewithAgentStartArgs(target, idempotencyKey), {
+  const start = await spawnCapture(spec.command, codewithAgentStartArgs(target, idempotencyKey), {
     cwd: spec.cwd,
     env,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 30000
+    timeoutMs: 30000,
+    maxOutputBytes
   });
-  let stderr = start.stderr || "";
+  const stderr = new BoundedOutputBuffer(maxOutputBytes);
+  stderr.append(start.stderr);
   if (start.error || (start.status ?? 1) !== 0) {
-    const finishedAt = nowIso();
-    return {
-      status: "failed",
+    return failureResult(startedAt, start.error ?? `codewith agent start exited with code ${start.status ?? "unknown"}`, {
       exitCode: start.status ?? undefined,
-      stdout: start.stdout || "",
-      stderr,
-      error: start.error?.message ?? `codewith agent start exited with code ${start.status ?? "unknown"}`,
-      startedAt,
-      finishedAt,
-      durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-    };
+      stdout: start.stdout,
+      stderr: stderr.value()
+    });
   }
   let startJson;
   try {
     startJson = parseJsonOutput(start.stdout || "{}", "codewith agent start");
   } catch (error) {
-    const finishedAt = nowIso();
-    return {
-      status: "failed",
-      stdout: start.stdout || "",
-      stderr,
-      error: error instanceof Error ? error.message : String(error),
-      startedAt,
-      finishedAt,
-      durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-    };
+    return failureResult(startedAt, error instanceof Error ? error.message : String(error), { stdout: start.stdout, stderr: stderr.value() });
   }
   const agentId = stringField(recordField(startJson, "agent"), "agentId");
   if (!agentId) {
-    const finishedAt = nowIso();
-    return {
-      status: "failed",
-      stdout: start.stdout || "",
-      stderr,
-      error: "codewith agent start did not return agent.agentId",
-      startedAt,
-      finishedAt,
-      durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-    };
+    return failureResult(startedAt, "codewith agent start did not return agent.agentId", { stdout: start.stdout, stderr: stderr.value() });
   }
+  const stopAgent = async () => {
+    await spawnCapture(spec.command, codewithAgentControlArgs(target, "stop", agentId), {
+      cwd: spec.cwd,
+      env,
+      timeoutMs: 15000,
+      maxOutputBytes
+    });
+  };
   const pollMs = Math.max(100, Number(opts.env?.LOOPS_CODEWITH_AGENT_POLL_MS ?? process.env.LOOPS_CODEWITH_AGENT_POLL_MS ?? 2000) || 2000);
   let lastReadJson = startJson;
   let lastLogsJson;
-  let stdout = "";
+  let lastFingerprint;
+  let lastProgressAt = Date.now();
+  const evidence = () => boundedText(codewithAgentEvidence(startJson, lastReadJson, lastLogsJson), maxOutputBytes);
   while (true) {
     if (opts.signal?.aborted) {
-      spawnSync2(spec.command, codewithAgentControlArgs(target, "stop", agentId), { cwd: spec.cwd, env, stdio: "ignore", timeout: 15000 });
-      const finishedAt = nowIso();
-      return {
-        status: "failed",
-        stdout: appendBoundedText(stdout, codewithAgentEvidence(startJson, lastReadJson, lastLogsJson), maxOutputBytes),
-        stderr,
-        error: "cancelled",
-        startedAt,
-        finishedAt,
-        durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-      };
+      await stopAgent();
+      return failureResult(startedAt, "cancelled", { stdout: evidence(), stderr: stderr.value() });
     }
-    const read = spawnSync2(spec.command, codewithAgentControlArgs(target, "read", agentId), {
+    const read = await spawnCapture(spec.command, codewithAgentControlArgs(target, "read", agentId), {
       cwd: spec.cwd,
       env,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 30000
+      timeoutMs: 30000,
+      maxOutputBytes
     });
-    stderr = appendBoundedText(stderr, read.stderr || "", maxOutputBytes);
+    stderr.append(read.stderr);
     if (read.error || (read.status ?? 1) !== 0) {
-      const finishedAt = nowIso();
-      return {
-        status: "failed",
+      return failureResult(startedAt, read.error ?? `codewith agent read exited with code ${read.status ?? "unknown"}`, {
         exitCode: read.status ?? undefined,
-        stdout: appendBoundedText(stdout, codewithAgentEvidence(startJson, lastReadJson, lastLogsJson), maxOutputBytes),
-        stderr,
-        error: read.error?.message ?? `codewith agent read exited with code ${read.status ?? "unknown"}`,
-        startedAt,
-        finishedAt,
-        durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-      };
+        stdout: evidence(),
+        stderr: stderr.value()
+      });
     }
     try {
       lastReadJson = parseJsonOutput(read.stdout || "{}", "codewith agent read");
     } catch (error) {
-      const finishedAt = nowIso();
-      return {
-        status: "failed",
-        stdout: appendBoundedText(stdout, read.stdout || "", maxOutputBytes),
-        stderr,
-        error: error instanceof Error ? error.message : String(error),
-        startedAt,
-        finishedAt,
-        durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-      };
+      return failureResult(startedAt, error instanceof Error ? error.message : String(error), {
+        stdout: boundedText(read.stdout, maxOutputBytes),
+        stderr: stderr.value()
+      });
     }
     const status = codewithAgentStatus(lastReadJson);
+    const fingerprint = JSON.stringify({ status, snapshot: recordField(lastReadJson, "statusSnapshot") ?? null });
+    if (fingerprint !== lastFingerprint) {
+      lastFingerprint = fingerprint;
+      lastProgressAt = Date.now();
+    }
     if (status === "completed" || status === "failed" || status === "cancelled") {
-      const logs = spawnSync2(spec.command, codewithAgentControlArgs(target, "logs", agentId), {
+      const logs = await spawnCapture(spec.command, codewithAgentControlArgs(target, "logs", agentId), {
         cwd: spec.cwd,
         env,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: 30000
+        timeoutMs: 30000,
+        maxOutputBytes
       });
       if (!logs.error && (logs.status ?? 1) === 0) {
         try {
@@ -4149,40 +4997,129 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
           lastLogsJson = undefined;
         }
       } else {
-        stderr = appendBoundedText(stderr, logs.stderr || logs.error?.message || "", maxOutputBytes);
+        stderr.append(logs.stderr || logs.error || "");
       }
-      const finishedAt = nowIso();
-      const resultStatus = status === "completed" ? "succeeded" : "failed";
-      return {
-        status: resultStatus,
-        exitCode: resultStatus === "succeeded" ? 0 : 1,
-        stdout: appendBoundedText(stdout, codewithAgentEvidence(startJson, lastReadJson, lastLogsJson), maxOutputBytes),
-        stderr,
-        error: resultStatus === "succeeded" ? undefined : stringField(recordField(lastReadJson, "agent"), "statusReason") ?? `codewith agent ${status}`,
-        startedAt,
-        finishedAt,
-        durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-      };
+      if (status === "completed") {
+        return successResult(startedAt, { exitCode: 0, stdout: evidence(), stderr: stderr.value() });
+      }
+      return failureResult(startedAt, stringField(recordField(lastReadJson, "agent"), "statusReason") ?? `codewith agent ${status}`, { exitCode: 1, stdout: evidence(), stderr: stderr.value() });
     }
     if (typeof spec.timeoutMs === "number" && new Date(nowIso()).getTime() - new Date(startedAt).getTime() >= spec.timeoutMs) {
-      spawnSync2(spec.command, codewithAgentControlArgs(target, "stop", agentId), { cwd: spec.cwd, env, stdio: "ignore", timeout: 15000 });
-      const finishedAt = nowIso();
-      return {
-        status: "timed_out",
-        stdout: appendBoundedText(stdout, codewithAgentEvidence(startJson, lastReadJson, lastLogsJson), maxOutputBytes),
-        stderr,
-        error: `timed out after ${spec.timeoutMs}ms`,
-        startedAt,
-        finishedAt,
-        durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
-      };
+      await stopAgent();
+      return timeoutResult(startedAt, `timed out after ${spec.timeoutMs}ms`, { stdout: evidence(), stderr: stderr.value() });
+    }
+    if (typeof spec.idleTimeoutMs === "number" && Date.now() - lastProgressAt >= spec.idleTimeoutMs) {
+      await stopAgent();
+      return timeoutResult(startedAt, `idle timed out after ${spec.idleTimeoutMs}ms without agent progress`, {
+        stdout: evidence(),
+        stderr: stderr.value()
+      });
     }
     await sleep(pollMs);
   }
 }
+function resolvedDirEquals(left, right) {
+  try {
+    return realpathSync(left) === realpathSync(right);
+  } catch {
+    return false;
+  }
+}
+async function ensureLocalWorktree(worktree, env) {
+  const { repoRoot, path, branch } = worktree;
+  if (!repoRoot || !path || !branch) {
+    return { error: "worktree preparation requires repoRoot, path, and branch metadata" };
+  }
+  const git = (args) => spawnCapture("git", args, { env, timeoutMs: WORKTREE_GIT_TIMEOUT_MS });
+  let stats;
+  try {
+    stats = lstatSync(path);
+  } catch {
+    stats = undefined;
+  }
+  if (stats?.isSymbolicLink())
+    return { error: `refusing symlinked worktree path ${path}` };
+  const commonDir = async (base) => {
+    const result = await git(["-C", base, "rev-parse", "--git-common-dir"]);
+    if (result.error || (result.status ?? 1) !== 0)
+      return;
+    const raw = result.stdout.trim();
+    if (!raw)
+      return;
+    try {
+      return realpathSync(resolve2(base, raw));
+    } catch {
+      return resolve2(base, raw);
+    }
+  };
+  if (stats) {
+    const top = await git(["-C", path, "rev-parse", "--show-toplevel"]);
+    if (top.error || (top.status ?? 1) !== 0) {
+      return { error: `refusing to reuse non-worktree path: ${path}` };
+    }
+    if (!resolvedDirEquals(top.stdout.trim(), path)) {
+      return { error: `existing worktree top-level mismatch for ${path}: ${top.stdout.trim()}` };
+    }
+    const expectedCommon = await commonDir(repoRoot);
+    const actualCommon = await commonDir(path);
+    if (!expectedCommon || expectedCommon !== actualCommon) {
+      return { error: `existing worktree ${path} belongs to a different git common dir` };
+    }
+    const current = await git(["-C", path, "branch", "--show-current"]);
+    const actualBranch = current.stdout.trim();
+    if (current.error || (current.status ?? 1) !== 0 || actualBranch !== branch) {
+      return { error: `existing worktree ${path} is on branch ${actualBranch || "unknown"}, expected ${branch}` };
+    }
+    return { cwd: worktree.cwd };
+  }
+  const inside = await git(["-C", repoRoot, "rev-parse", "--is-inside-work-tree"]);
+  if (inside.error || (inside.status ?? 1) !== 0) {
+    return { error: `worktree repoRoot is not a git repository: ${repoRoot}` };
+  }
+  try {
+    mkdirSync5(dirname4(path), { recursive: true });
+  } catch (error) {
+    return { error: `could not create worktree parent directory: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const hasBranch = await git(["-C", repoRoot, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+  const add = hasBranch.status === 0 ? await git(["-C", repoRoot, "worktree", "add", path, branch]) : await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
+  if (add.error || (add.status ?? 1) !== 0) {
+    const detail = (add.stderr || add.stdout || add.error || "").toString().trim();
+    return { error: `git worktree add failed for ${path}${detail ? `: ${detail}` : ""}` };
+  }
+  return { cwd: worktree.cwd };
+}
+async function enterWorktree(spec, opts, env, startedAt) {
+  const worktree = spec.worktree;
+  if (!worktree?.enabled || worktree.mode === "off" || worktree.mode === "main")
+    return;
+  const prepared = await ensureLocalWorktree(worktree, env);
+  if (prepared.error) {
+    if (worktree.mode === "required") {
+      return { failure: failureResult(startedAt, `worktree preparation failed (mode=required): ${prepared.error}`) };
+    }
+    opts.log?.(`worktree preparation failed (mode=${worktree.mode}); falling back to ${worktree.originalCwd}: ${prepared.error}`);
+    spec.cwd = worktree.originalCwd;
+    return { fallbackCwd: worktree.originalCwd };
+  }
+  spec.cwd = prepared.cwd ?? spec.cwd;
+  opts.log?.(`entered worktree ${worktree.path ?? spec.cwd}${worktree.branch ? ` branch ${worktree.branch}` : ""}`);
+  return;
+}
+function worktreeFallbackSpec(target, opts, fallbackCwd) {
+  if (target.type !== "agent")
+    return;
+  const agentTarget = target;
+  const fallbackTarget = {
+    ...agentTarget,
+    cwd: fallbackCwd,
+    worktree: agentTarget.worktree ? { ...agentTarget.worktree, enabled: false, cwd: fallbackCwd, reason: "auto worktree preparation failed" } : undefined
+  };
+  return commandSpec(fallbackTarget, opts);
+}
 function preflightRemoteSpec(spec, machine, metadata, opts) {
   const plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
-  const result = spawnSync2(plan.command, plan.args, {
+  const result = spawnSync4(plan.command, plan.args, {
     encoding: "utf8",
     env: transportEnv(opts),
     input: remotePreflightScript(spec, metadata),
@@ -4196,11 +5133,11 @@ function preflightRemoteSpec(spec, machine, metadata, opts) {
     throw new Error(`remote preflight failed on ${machine.id}${detail ? `: ${detail}` : ""}`);
   }
 }
-async function executeRemoteSpec(spec, machine, metadata, opts) {
+async function executeRemoteSpec(spec, machine, metadata, opts, fallbackSpec) {
   const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   const startedAt = nowIso();
-  let stdout = "";
-  let stderr = "";
+  const stdout = new BoundedOutputBuffer(maxOutputBytes);
+  const stderr = new BoundedOutputBuffer(maxOutputBytes);
   let timedOut = false;
   let idleTimedOut = false;
   let exitCode;
@@ -4209,25 +5146,16 @@ async function executeRemoteSpec(spec, machine, metadata, opts) {
   let script;
   try {
     plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
-    script = remoteScript(spec, metadata);
+    script = remoteScript(spec, metadata, fallbackSpec);
   } catch (err) {
-    return {
-      status: "failed",
-      stdout: "",
-      stderr: "",
-      error: err instanceof Error ? err.message : String(err),
-      startedAt,
-      finishedAt: nowIso(),
-      durationMs: 0
-    };
+    return failureResult(startedAt, err instanceof Error ? err.message : String(err));
   }
-  const child = spawn(plan.command, plan.args, {
+  const child = spawn2(plan.command, plan.args, {
     env: transportEnv(opts),
     detached: true,
     stdio: ["pipe", "pipe", "pipe"]
   });
-  if (child.pid)
-    opts.onSpawn?.(child.pid);
+  notifySpawn(child.pid, opts);
   child.stdin?.on("error", (err) => {
     if (err.code !== "EPIPE")
       error = err.message;
@@ -4261,12 +5189,14 @@ async function executeRemoteSpec(spec, machine, metadata, opts) {
     idleTimer.unref();
   };
   resetIdleTimer();
+  child.stdout?.setEncoding("utf8");
+  child.stderr?.setEncoding("utf8");
   child.stdout?.on("data", (chunk) => {
-    stdout = appendBounded(stdout, chunk, maxOutputBytes);
+    stdout.append(chunk);
     resetIdleTimer();
   });
   child.stderr?.on("data", (chunk) => {
-    stderr = appendBounded(stderr, chunk, maxOutputBytes);
+    stderr.append(chunk);
     resetIdleTimer();
   });
   try {
@@ -4284,47 +5214,17 @@ async function executeRemoteSpec(spec, machine, metadata, opts) {
       clearTimeout(idleTimer);
     opts.signal?.removeEventListener("abort", abortHandler);
   }
-  const finishedAt = nowIso();
-  const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
+  const fields = { exitCode, stdout: stdout.value(), stderr: stderr.value(), pid: child.pid };
   if (timedOut || idleTimedOut) {
-    return {
-      status: "timed_out",
-      exitCode,
-      stdout,
-      stderr,
-      error: idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`,
-      pid: child.pid,
-      startedAt,
-      finishedAt,
-      durationMs
-    };
+    return timeoutResult(startedAt, idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`, fields);
   }
   if (error || exitCode !== 0) {
-    return {
-      status: "failed",
-      exitCode,
-      stdout,
-      stderr,
-      error: error ?? `remote process on ${machine.id} exited with code ${exitCode ?? "unknown"}`,
-      pid: child.pid,
-      startedAt,
-      finishedAt,
-      durationMs
-    };
+    return failureResult(startedAt, error ?? `remote process on ${machine.id} exited with code ${exitCode ?? "unknown"}`, fields);
   }
-  return {
-    status: "succeeded",
-    exitCode,
-    stdout,
-    stderr,
-    pid: child.pid,
-    startedAt,
-    finishedAt,
-    durationMs
-  };
+  return successResult(startedAt, fields);
 }
 function preflightTarget(target, metadata = {}, opts = {}) {
-  const spec = commandSpec(target);
+  const spec = commandSpec(target, opts);
   const machine = resolvedMachine(opts);
   if (machine && !machine.local) {
     preflightRemoteSpec(spec, machine, metadata, opts);
@@ -4334,14 +5234,14 @@ function preflightTarget(target, metadata = {}, opts = {}) {
       accountTool: spec.accountTool
     };
   }
-  const env = executionEnv(spec, metadata, opts);
+  const env = executionEnvSync(spec, metadata, opts);
   if (!spec.shell && !executableExists(spec.command, env)) {
     throw new Error(commandNotFoundMessage(spec.command, env));
   }
   if (spec.preflightAnyOf?.length && !spec.preflightAnyOf.some((command) => executableExists(command, env))) {
     throw new Error(`none of required executables found: ${spec.preflightAnyOf.join(", ")}`);
   }
-  preflightNativeAuthProfile(spec, env);
+  preflightNativeAuthProfileSync(spec, env);
   return {
     command: spec.command,
     accountProfile: spec.account?.profile,
@@ -4349,79 +5249,52 @@ function preflightTarget(target, metadata = {}, opts = {}) {
   };
 }
 async function executeTarget(target, metadata = {}, opts = {}) {
-  const spec = commandSpec(target);
+  let spec = commandSpec(target, opts);
   const machine = resolvedMachine(opts);
   if (machine && !machine.local && spec.codewithDurableAgent) {
-    const startedAt2 = nowIso();
-    const finishedAt2 = nowIso();
-    return {
-      status: "failed",
-      stdout: "",
-      stderr: "",
-      error: "remote Codewith durable background-agent steps require remote status polling support; run this Codewith step locally or add remote durable readback before dispatch",
-      startedAt: startedAt2,
-      finishedAt: finishedAt2,
-      durationMs: new Date(finishedAt2).getTime() - new Date(startedAt2).getTime()
-    };
+    return failureResult(nowIso(), "remote Codewith durable background-agent steps require remote status polling support; run this Codewith step locally or add remote durable readback before dispatch");
+  }
+  if (machine && !machine.local) {
+    const remoteFallbackSpec = spec.worktree?.enabled && spec.worktree.mode === "auto" ? worktreeFallbackSpec(target, opts, spec.worktree.originalCwd) : undefined;
+    return executeRemoteSpec(spec, machine, metadata, opts, remoteFallbackSpec);
   }
-  if (machine && !machine.local)
-    return executeRemoteSpec(spec, machine, metadata, opts);
   const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   const startedAt = nowIso();
-  let stdout = "";
-  let stderr = "";
+  const stdout = new BoundedOutputBuffer(maxOutputBytes);
+  const stderr = new BoundedOutputBuffer(maxOutputBytes);
   let timedOut = false;
   let idleTimedOut = false;
   let exitCode;
   let error;
-  const env = executionEnv(spec, metadata, opts);
+  const env = await executionEnv(spec, metadata, opts);
   if (!spec.shell && !executableExists(spec.command, env)) {
-    return {
-      status: "failed",
-      stdout: "",
-      stderr: "",
-      error: commandNotFoundMessage(spec.command, env),
-      startedAt,
-      finishedAt: nowIso(),
-      durationMs: 0
-    };
+    return failureResult(startedAt, commandNotFoundMessage(spec.command, env));
   }
   if (spec.preflightAnyOf?.length && !spec.preflightAnyOf.some((command) => executableExists(command, env))) {
-    return {
-      status: "failed",
-      stdout,
-      stderr,
-      error: `none of required executables found: ${spec.preflightAnyOf.join(", ")}`,
-      startedAt,
-      finishedAt: nowIso(),
-      durationMs: 0
-    };
+    return failureResult(startedAt, `none of required executables found: ${spec.preflightAnyOf.join(", ")}`);
   }
   try {
-    preflightNativeAuthProfile(spec, env);
+    await preflightNativeAuthProfile(spec, env);
   } catch (err) {
-    return {
-      status: "failed",
-      stdout: "",
-      stderr: "",
-      error: err instanceof Error ? err.message : String(err),
-      startedAt,
-      finishedAt: nowIso(),
-      durationMs: 0
-    };
+    return failureResult(startedAt, err instanceof Error ? err.message : String(err));
+  }
+  const worktreeEntry = await enterWorktree(spec, opts, env, startedAt);
+  if (worktreeEntry?.failure)
+    return worktreeEntry.failure;
+  if (worktreeEntry?.fallbackCwd) {
+    spec = worktreeFallbackSpec(target, opts, worktreeEntry.fallbackCwd) ?? spec;
   }
   if (spec.codewithDurableAgent) {
     return executeCodewithDurableAgent(spec, metadata, opts, env, startedAt);
   }
-  const child = spawn(spec.command, spec.args, {
+  const child = spawn2(spec.command, spec.args, {
     cwd: spec.cwd,
     env,
     shell: spec.shell ?? false,
     detached: true,
     stdio: spec.stdin === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"]
   });
-  if (child.pid)
-    opts.onSpawn?.(child.pid);
+  notifySpawn(child.pid, opts);
   if (spec.stdin !== undefined && child.stdin) {
     child.stdin.on("error", (err) => {
       if (err.code !== "EPIPE")
@@ -4457,12 +5330,14 @@ async function executeTarget(target, metadata = {}, opts = {}) {
     idleTimer.unref();
   };
   resetIdleTimer();
+  child.stdout?.setEncoding("utf8");
+  child.stderr?.setEncoding("utf8");
   child.stdout?.on("data", (chunk) => {
-    stdout = appendBounded(stdout, chunk, maxOutputBytes);
+    stdout.append(chunk);
     resetIdleTimer();
   });
   child.stderr?.on("data", (chunk) => {
-    stderr = appendBounded(stderr, chunk, maxOutputBytes);
+    stderr.append(chunk);
     resetIdleTimer();
   });
   try {
@@ -4480,97 +5355,706 @@ async function executeTarget(target, metadata = {}, opts = {}) {
       clearTimeout(idleTimer);
     opts.signal?.removeEventListener("abort", abortHandler);
   }
-  const finishedAt = nowIso();
-  const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
+  const fields = { exitCode, stdout: stdout.value(), stderr: stderr.value(), pid: child.pid };
   if (timedOut || idleTimedOut) {
+    return timeoutResult(startedAt, idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`, fields);
+  }
+  if (error || exitCode !== 0) {
+    return failureResult(startedAt, error ?? `process exited with code ${exitCode ?? "unknown"}`, fields);
+  }
+  return successResult(startedAt, fields);
+}
+async function executeLoop(loop, run, opts = {}) {
+  if (loop.target.type === "workflow") {
+    throw new Error("workflow loop targets must be executed with executeLoopTarget");
+  }
+  if (loop.target.preflight?.beforeRun) {
+    const startedAt = nowIso();
+    try {
+      preflightTarget(loop.target, {
+        loopId: loop.id,
+        loopName: loop.name,
+        runId: run.id,
+        scheduledFor: run.scheduledFor
+      }, { ...opts, machine: opts.machine ?? loop.machine });
+    } catch (error) {
+      return failureResult(startedAt, `runtime preflight failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return executeTarget(loop.target, {
+    loopId: loop.id,
+    loopName: loop.name,
+    runId: run.id,
+    scheduledFor: run.scheduledFor
+  }, { ...opts, machine: opts.machine ?? loop.machine });
+}
+
+// src/lib/doctor.ts
+var PROVIDER_COMMANDS = [
+  "claude",
+  "agent",
+  "codewith",
+  "aicopilot",
+  "opencode",
+  "codex"
+];
+function hasCommand(command) {
+  const result = spawnSync5("sh", ["-c", 'command -v "$1" >/dev/null', "sh", command], { stdio: "ignore" });
+  return (result.status ?? 1) === 0;
+}
+function commandVersion(command) {
+  const result = spawnSync5(command, ["--version"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if ((result.status ?? 1) !== 0)
+    return;
+  return (result.stdout || result.stderr).trim().split(/\r?\n/)[0];
+}
+function runDoctor(store) {
+  const checks = [];
+  try {
+    const dir = ensureDataDir();
+    accessSync2(dir, constants2.R_OK | constants2.W_OK);
+    checks.push({ id: "data-dir", status: "ok", message: "data directory is writable", detail: dir });
+  } catch (error) {
+    checks.push({
+      id: "data-dir",
+      status: "fail",
+      message: "data directory is not writable",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const bunVersion = commandVersion("bun");
+  checks.push(bunVersion ? { id: "bun", status: "ok", message: "bun is available", detail: bunVersion } : { id: "bun", status: "fail", message: "bun is not available on PATH" });
+  const accountsVersion = commandVersion("accounts");
+  checks.push(accountsVersion ? { id: "accounts", status: "ok", message: "accounts is available", detail: accountsVersion } : { id: "accounts", status: "warn", message: "accounts CLI is not available; account-routed steps will fail" });
+  try {
+    const machines = listOpenMachines();
+    const local = machines.find((machine) => machine.local);
+    checks.push({
+      id: "machines",
+      status: "ok",
+      message: `OpenMachines topology available (${machines.length} machine(s))`,
+      detail: local ? `local=${local.id}` : undefined
+    });
+  } catch (error) {
+    checks.push({
+      id: "machines",
+      status: "warn",
+      message: "OpenMachines topology is not available; machine-assigned loops will fail",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  for (const command of PROVIDER_COMMANDS) {
+    checks.push(hasCommand(command) ? { id: `provider:${command}`, status: "ok", message: `${command} is available` } : { id: `provider:${command}`, status: "warn", message: `${command} is not on PATH` });
+  }
+  const status = daemonStatus(store);
+  checks.push(status.running ? { id: "daemon", status: "ok", message: `daemon is running pid=${status.pid}` } : { id: "daemon", status: status.stale ? "warn" : "ok", message: status.stale ? "daemon pid file is stale" : "daemon is not running" });
+  const failedRuns = store.countRuns("failed");
+  checks.push(failedRuns === 0 ? { id: "loop-runs", status: "ok", message: "no failed loop runs recorded" } : { id: "loop-runs", status: "warn", message: `${failedRuns} failed loop run(s) recorded` });
+  for (const loop of store.listLoops({ status: "active" })) {
+    try {
+      if (loop.target.type === "workflow") {
+        const workflow = store.requireWorkflow(loop.target.workflowId);
+        for (const step of workflowExecutionOrder(workflow)) {
+          preflightTarget({
+            ...step.target,
+            account: step.account ?? step.target.account,
+            timeoutMs: step.timeoutMs !== undefined ? step.timeoutMs : step.target.timeoutMs
+          }, { loopId: loop.id, loopName: loop.name, workflowId: workflow.id, workflowName: workflow.name, workflowStepId: step.id }, { machine: loop.machine });
+        }
+      } else {
+        preflightTarget(loop.target, { loopId: loop.id, loopName: loop.name }, { machine: loop.machine });
+      }
+      checks.push({ id: `loop:${loop.id}:preflight`, status: "ok", message: `active loop target is ready: ${loop.name}` });
+    } catch (error) {
+      checks.push({
+        id: `loop:${loop.id}:preflight`,
+        status: "fail",
+        message: `active loop target preflight failed: ${loop.name}`,
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    ok: checks.every((check) => check.status !== "fail"),
+    checks
+  };
+}
+
+// src/lib/health.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+
+// src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
+var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
+function redact(value, visible = 0) {
+  if (!value)
+    return value;
+  if (value.length <= visible)
+    return value;
+  if (visible <= 0)
+    return `[redacted ${value.length} chars]`;
+  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+}
+function truncateTextOutput(value) {
+  if (value.length <= TEXT_OUTPUT_LIMIT)
+    return value;
+  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
+[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+}
+function redactSensitivePayload(value, key) {
+  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
+    if (typeof value === "string")
+      return redact(value);
+    if (value === undefined || value === null)
+      return value;
+    return "[redacted]";
+  }
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitivePayload(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+  }
+  return value;
+}
+function textOutputBlocks(value, opts = {}) {
+  const indent = opts.indent ?? "";
+  const nested = `${indent}  `;
+  const blocks = [];
+  for (const [label, output] of [
+    ["stdout", value.stdout],
+    ["stderr", value.stderr]
+  ]) {
+    if (!output)
+      continue;
+    blocks.push(`${indent}${label}:`);
+    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
+      blocks.push(`${nested}${line}`);
+    }
+  }
+  return blocks;
+}
+function publicLoop(loop) {
+  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
+  return {
+    ...loop,
+    target
+  };
+}
+function publicRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined
+  };
+}
+function publicExecutorResult(result, showOutput = false) {
+  return {
+    ...result,
+    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
+    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
+    error: redact(result.error)
+  };
+}
+function publicWorkflow(workflow) {
+  return {
+    ...workflow,
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
+    }))
+  };
+}
+function publicWorkflowRun(run) {
+  return { ...run, error: redact(run.error) };
+}
+function publicWorkflowInvocation(invocation) {
+  return redactSensitivePayload(invocation);
+}
+function publicWorkflowWorkItem(item) {
+  return { ...item, lastReason: redact(item.lastReason, 240) };
+}
+function publicWorkflowStepRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: redact(run.error)
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event, payload: redactSensitivePayload(event.payload) };
+}
+function publicGoal(goal) {
+  return {
+    ...goal,
+    objective: redact(goal.objective, 120)
+  };
+}
+function publicGoalRun(run) {
+  return {
+    ...run,
+    evidence: redactSensitivePayload(run.evidence),
+    rawResponse: redactSensitivePayload(run.rawResponse)
+  };
+}
+
+// src/lib/health.ts
+var EVIDENCE_CHARS = 2000;
+var FINGERPRINT_EVIDENCE_CHARS = 120;
+var CLASSIFICATIONS = [
+  "rate_limit",
+  "auth",
+  "model_not_found",
+  "context_length",
+  "schema_response_format",
+  "node_init",
+  "preflight",
+  "route_functional",
+  "timeout",
+  "sigsegv",
+  "skipped_previous_active",
+  "circuit_breaker",
+  "unknown"
+];
+function bounded(value, limit = EVIDENCE_CHARS) {
+  if (!value)
+    return;
+  if (value.length <= limit)
+    return value;
+  return `${value.slice(0, limit)}
+[truncated ${value.length - limit} chars]`;
+}
+function redactedEvidence(value) {
+  return redact(bounded(value));
+}
+function searchableText(run) {
+  return [run.error, run.stderr, run.stdout].filter(Boolean).join(`
+`).toLowerCase();
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function objectField(value, key) {
+  if (!value)
+    return;
+  const field = value[key];
+  return isRecord(field) ? field : undefined;
+}
+function tagsFromValue(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => String(entry).trim()).filter(Boolean);
+  if (typeof value === "string")
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return [];
+}
+function stableFingerprint(parts) {
+  return createHash2("sha256").update(parts.join(`
+`)).digest("hex").slice(0, 16);
+}
+function stableFailureFingerprint(run, classification) {
+  return stableFingerprint([
+    run.loopId,
+    classification,
+    String(run.status),
+    String(run.exitCode ?? ""),
+    (run.error ?? run.stderr ?? run.stdout ?? "").replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
+  ]);
+}
+function stableRouteFunctionalFingerprint(loop, reason) {
+  return stableFingerprint([
+    loop.id,
+    "route_functional",
+    reason.replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
+  ]);
+}
+function healthRun(run) {
+  return {
+    ...run,
+    error: redactedEvidence(run.error),
+    stdout: redactedEvidence(run.stdout),
+    stderr: redactedEvidence(run.stderr)
+  };
+}
+function classifyRunFailure(run) {
+  if (run.status === "succeeded" || run.status === "running")
+    return;
+  const text = searchableText(run);
+  let classification = "unknown";
+  if (run.status === "timed_out")
+    classification = "timeout";
+  else if (run.status === "skipped" && /circuit breaker open/.test(text))
+    classification = "circuit_breaker";
+  else if (run.status === "skipped" && /previous run still active/.test(text))
+    classification = "skipped_previous_active";
+  else if (/runtime preflight failed|preflight failed|executable not found in path|none of required executables found|auth profile preflight failed|profile not found/.test(text))
+    classification = "preflight";
+  else if (/rate limit|too many requests|429\b|quota exceeded/.test(text))
+    classification = "rate_limit";
+  else if (/unauthorized|authentication|auth\b|api key|invalid token|permission denied|401\b|403\b/.test(text))
+    classification = "auth";
+  else if (/model .*not found|model_not_found|unknown model|invalid model|404.*model/.test(text))
+    classification = "model_not_found";
+  else if (/context length|context_length|context window|maximum context|token limit|too many tokens/.test(text))
+    classification = "context_length";
+  else if (/response_format|json schema|schema validation|invalid schema|structured output/.test(text))
+    classification = "schema_response_format";
+  else if (/cannot find module|module not found|node:internal|bun: command not found|node: command not found|npm err!|err_module_not_found/.test(text))
+    classification = "node_init";
+  else if (/sigsegv|segmentation fault|signal 11/.test(text))
+    classification = "sigsegv";
+  return {
+    classification,
+    fingerprint: stableFailureFingerprint(run, classification),
+    evidence: {
+      error: redactedEvidence(run.error),
+      stdout: redactedEvidence(run.stdout),
+      stderr: redactedEvidence(run.stderr),
+      exitCode: run.exitCode
+    }
+  };
+}
+var ROUTE_FUNCTIONAL_DISALLOWED_TAGS = new Set([
+  "no-auto",
+  "manual",
+  "manual-required",
+  "approval-required",
+  "blocked",
+  "completed",
+  "done",
+  "cancelled",
+  "canceled",
+  "failed",
+  "archived"
+]);
+var ROUTE_FUNCTIONAL_DISALLOWED_STATUSES = new Set([
+  "blocked",
+  "completed",
+  "done",
+  "cancelled",
+  "canceled",
+  "failed",
+  "archived"
+]);
+function parseJsonObject(raw) {
+  if (!raw?.trim())
+    return;
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function routeEvidenceReport(run) {
+  const stdoutReport = parseJsonObject(run.stdout);
+  const evidencePath = stringValue(stdoutReport?.evidencePath);
+  if (evidencePath && existsSync4(evidencePath)) {
+    try {
+      return parseJsonObject(readFileSync4(evidencePath, "utf8")) ?? stdoutReport;
+    } catch {
+      return stdoutReport;
+    }
+  }
+  return stdoutReport;
+}
+function commandName(command) {
+  return command.split(/[\\/]/).at(-1) ?? command;
+}
+function argsContainSequence(args, sequence) {
+  for (let index = 0;index <= args.length - sequence.length; index += 1) {
+    if (sequence.every((part, offset) => args[index + offset] === part))
+      return true;
+  }
+  return false;
+}
+function isRouteDrainLoop(loop) {
+  if (loop.target.type !== "command")
+    return false;
+  if (commandName(loop.target.command) !== "loops")
+    return false;
+  const args = loop.target.args ?? [];
+  return argsContainSequence(args, ["events", "drain", "todos-task"]) || argsContainSequence(args, ["routes", "drain", "todos-task"]) || argsContainSequence(args, ["route", "drain", "todos-task"]);
+}
+function routeResultTaskState(result) {
+  const event = objectField(result, "event");
+  const data = objectField(event, "data");
+  const task = objectField(data, "task");
+  const payload = objectField(data, "payload");
+  const payloadTask = objectField(payload, "task");
+  const metadata = objectField(data, "metadata");
+  const records = [data, task, payload, payloadTask, metadata].filter(isRecord);
+  const tags = new Set;
+  for (const record of records) {
+    for (const tag of tagsFromValue(record.tags ?? record.task_tags ?? record.taskTags)) {
+      tags.add(tag.toLowerCase());
+    }
+  }
+  const status = records.map((record) => stringValue(record.status ?? record.task_status ?? record.taskStatus)?.toLowerCase()).find(Boolean);
+  return {
+    taskId: stringValue(event?.subject) ?? stringValue(data?.id) ?? stringValue(task?.id) ?? stringValue(payloadTask?.id),
+    tags: [...tags],
+    status
+  };
+}
+function detectRouteFunctionalFailure(store, loop, run) {
+  if (run.status !== "succeeded")
+    return;
+  if (!isRouteDrainLoop(loop))
+    return;
+  const report = routeEvidenceReport(run);
+  const rawResults = Array.isArray(report?.results) ? report.results.filter(isRecord) : [];
+  for (const result of rawResults) {
+    const kind = stringValue(result.kind);
+    const task = routeResultTaskState(result);
+    const disallowedTag = task.tags.find((tag) => ROUTE_FUNCTIONAL_DISALLOWED_TAGS.has(tag));
+    if (kind && kind !== "skipped" && disallowedTag) {
+      const reason2 = `route drain ${kind} task ${task.taskId ?? "unknown"} with disallowed tag ${disallowedTag}`;
+      return {
+        classification: "route_functional",
+        fingerprint: stableRouteFunctionalFingerprint(loop, reason2),
+        evidence: { error: reason2, stdout: redactedEvidence(run.stdout), exitCode: run.exitCode }
+      };
+    }
+    if (kind && kind !== "skipped" && task.status && ROUTE_FUNCTIONAL_DISALLOWED_STATUSES.has(task.status)) {
+      const reason2 = `route drain ${kind} task ${task.taskId ?? "unknown"} with non-routable status ${task.status}`;
+      return {
+        classification: "route_functional",
+        fingerprint: stableRouteFunctionalFingerprint(loop, reason2),
+        evidence: { error: reason2, stdout: redactedEvidence(run.stdout), exitCode: run.exitCode }
+      };
+    }
+    const reason = stringValue(result.reason);
+    if (kind === "skipped" && reason === "task metadata requires manual or approval-gated handling") {
+      const message = `route drain skipped task ${task.taskId ?? "unknown"} with ambiguous manual-gate reason`;
+      return {
+        classification: "route_functional",
+        fingerprint: stableRouteFunctionalFingerprint(loop, message),
+        evidence: { error: message, stdout: redactedEvidence(run.stdout), exitCode: run.exitCode }
+      };
+    }
+    const sourceTaskUpdate = objectField(result, "sourceTaskUpdate");
+    if (kind === "skipped" && sourceTaskUpdate && sourceTaskUpdate.ok === false) {
+      const updateError = stringValue(sourceTaskUpdate.error);
+      const message = `route drain skipped task ${task.taskId ?? "unknown"} but failed to update source task${updateError ? `: ${updateError}` : ""}`;
+      return {
+        classification: "route_functional",
+        fingerprint: stableRouteFunctionalFingerprint(loop, message),
+        evidence: { error: message, stdout: redactedEvidence(run.stdout), exitCode: run.exitCode }
+      };
+    }
+    const childLoopId = stringValue(objectField(result, "loop")?.id) ?? stringValue(result.loopId);
+    const childRun = childLoopId ? store.listRuns({ loopId: childLoopId, limit: 1 })[0] : undefined;
+    if (childRun && !["succeeded", "running"].includes(childRun.status)) {
+      const message = `route drain ${kind ?? "handled"} task ${task.taskId ?? "unknown"} but child loop ${childLoopId} latest run is ${childRun.status}`;
+      return {
+        classification: "route_functional",
+        fingerprint: stableRouteFunctionalFingerprint(loop, message),
+        evidence: { error: message, stdout: redactedEvidence(run.stdout), stderr: redactedEvidence(childRun.stderr), exitCode: childRun.exitCode }
+      };
+    }
+  }
+  return;
+}
+function targetRoute(loop) {
+  if (loop.target.type === "agent") {
     return {
-      status: "timed_out",
-      exitCode,
-      stdout,
-      stderr,
-      error: idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`,
-      pid: child.pid,
-      startedAt,
-      finishedAt,
-      durationMs
+      source: "openloops",
+      kind: "loop_expectation",
+      loopId: loop.id,
+      loopName: loop.name,
+      cwd: loop.target.cwd,
+      provider: loop.target.provider
     };
   }
-  if (error || exitCode !== 0) {
+  if (loop.target.type === "command") {
     return {
-      status: "failed",
-      exitCode,
-      stdout,
-      stderr,
-      error: error ?? `process exited with code ${exitCode ?? "unknown"}`,
-      pid: child.pid,
-      startedAt,
-      finishedAt,
-      durationMs
+      source: "openloops",
+      kind: "loop_expectation",
+      loopId: loop.id,
+      loopName: loop.name,
+      cwd: loop.target.cwd
     };
   }
   return {
-    status: "succeeded",
-    exitCode,
-    stdout,
-    stderr,
-    pid: child.pid,
-    startedAt,
-    finishedAt,
-    durationMs
+    source: "openloops",
+    kind: "loop_expectation",
+    loopId: loop.id,
+    loopName: loop.name
   };
 }
-async function executeLoop(loop, run, opts = {}) {
-  if (loop.target.type === "workflow") {
-    throw new Error("workflow loop targets must be executed with executeLoopTarget");
+function recommendedTask(loop, run, failure, route) {
+  const title = `BUG: open-loops loop failure - ${loop.name}`;
+  const description = [
+    `OpenLoops expectation failed for loop ${loop.name} (${loop.id}).`,
+    `Run: ${run.id}`,
+    `Status: ${run.status}`,
+    `Classification: ${failure.classification}`,
+    `Fingerprint: ${failure.fingerprint}`,
+    `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
+    route.cwd ? `Route cwd: ${route.cwd}` : undefined,
+    route.provider ? `Provider: ${route.provider}` : undefined,
+    failure.evidence.error ? `Error:
+${failure.evidence.error}` : undefined,
+    failure.evidence.stderr ? `Stderr:
+${failure.evidence.stderr}` : undefined
+  ].filter(Boolean).join(`
+
+`);
+  const dedupeKey = `openloops:${loop.id}:${failure.fingerprint}`;
+  const tags = ["bug", "openloops", "loop-health", failure.classification];
+  const priority = failure.classification === "auth" || failure.classification === "rate_limit" ? "high" : "medium";
+  return {
+    title,
+    description,
+    priority,
+    tags,
+    dedupeKey,
+    search: { query: dedupeKey },
+    compatibilityFallback: {
+      search: ["todos", "search", dedupeKey, "--json"],
+      add: ["todos", "add", title, "--description", description, "--tag", tags.join(","), "--priority", priority],
+      comment: ["todos", "comment", "<task-id>", description]
+    },
+    futureNativeUpsert: {
+      command: "todos upsert",
+      fields: {
+        title,
+        description,
+        priority,
+        tags,
+        dedupeKey,
+        routeSource: route.source,
+        routeKind: route.kind,
+        routeLoopId: route.loopId,
+        routeLoopName: route.loopName
+      }
+    }
+  };
+}
+function expectationForLoop(store, loop) {
+  const latestRun = store.listRuns({ loopId: loop.id, limit: 1 })[0];
+  const route = targetRoute(loop);
+  if (!latestRun) {
+    return {
+      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      ok: true,
+      check: { id: "latest-run-succeeded", status: "warn", message: "loop has no recorded runs yet" },
+      route
+    };
   }
-  if (loop.target.preflight?.beforeRun) {
-    const startedAt = nowIso();
-    try {
-      preflightTarget(loop.target, {
-        loopId: loop.id,
-        loopName: loop.name,
-        runId: run.id,
-        scheduledFor: run.scheduledFor
-      }, { ...opts, machine: opts.machine ?? loop.machine });
-    } catch (error) {
-      const finishedAt = nowIso();
+  const routeFailure = detectRouteFunctionalFailure(store, loop, latestRun);
+  if (routeFailure) {
+    return {
+      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      ok: false,
+      check: { id: "route-functional-health", status: "fail", message: routeFailure.evidence.error ?? "route functional blocker detected" },
+      latestRun: healthRun(latestRun),
+      failure: routeFailure,
+      route,
+      recommendedTask: recommendedTask(loop, latestRun, routeFailure, route)
+    };
+  }
+  if (latestRun.status === "succeeded") {
+    return {
+      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      ok: true,
+      check: { id: "latest-run-succeeded", status: "pass", message: "latest run succeeded" },
+      latestRun: healthRun(latestRun),
+      route
+    };
+  }
+  const failure = classifyRunFailure(latestRun);
+  if (failure?.classification === "circuit_breaker") {
+    if (loop.status !== "paused") {
       return {
-        status: "failed",
-        stdout: "",
-        stderr: "",
-        error: `runtime preflight failed: ${error instanceof Error ? error.message : String(error)}`,
-        startedAt,
-        finishedAt,
-        durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
+        loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+        ok: true,
+        check: { id: "latest-run-succeeded", status: "warn", message: "circuit breaker cleared by resume; awaiting next run" },
+        latestRun: healthRun(latestRun),
+        route
       };
     }
+    return {
+      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      ok: false,
+      check: { id: "latest-run-succeeded", status: "fail", message: latestRun.error ?? "circuit breaker open; loop auto-paused" },
+      latestRun: healthRun(latestRun),
+      failure,
+      route,
+      recommendedTask: recommendedTask(loop, latestRun, failure, route)
+    };
   }
-  return executeTarget(loop.target, {
-    loopId: loop.id,
-    loopName: loop.name,
-    runId: run.id,
-    scheduledFor: run.scheduledFor
-  }, { ...opts, machine: opts.machine ?? loop.machine });
+  return {
+    loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+    ok: false,
+    check: { id: "latest-run-succeeded", status: "fail", message: `latest run is ${latestRun.status}` },
+    latestRun: healthRun(latestRun),
+    failure,
+    route,
+    recommendedTask: failure ? recommendedTask(loop, latestRun, failure, route) : undefined
+  };
 }
-
-// src/lib/goal/runner.ts
-import { generateObject } from "ai";
-import { z } from "zod";
-
-// src/lib/goal/model-factory.ts
-import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-var DEFAULT_GOAL_MODEL = "openai/gpt-4o-mini";
-function resolveGoalModel(opts = {}) {
-  const env = opts.env ?? process.env;
-  const apiKey = opts.apiKey ?? env.OPENROUTER_API_KEY;
-  if (!apiKey) {
-    throw new Error("OPENROUTER_API_KEY is required to run goals with the OpenRouter AI SDK provider");
+function buildHealthReport(store, opts = {}) {
+  const loops = store.listLoops({ includeArchived: opts.includeArchived, limit: opts.limit ?? 200 }).filter((loop) => opts.includeInactive || loop.status === "active" || loop.status === "paused");
+  const expectations = loops.map((loop) => expectationForLoop(store, loop));
+  const classifications = Object.fromEntries(CLASSIFICATIONS.map((key) => [key, 0]));
+  for (const expectation of expectations) {
+    if (expectation.failure)
+      classifications[expectation.failure.classification] += 1;
   }
-  const provider = createOpenRouter({
-    apiKey,
-    baseURL: opts.baseURL ?? env.LOOPS_GOAL_BASE_URL ?? env.OPENROUTER_BASE_URL
-  });
-  return provider.chat(opts.model ?? env.LOOPS_GOAL_MODEL ?? DEFAULT_GOAL_MODEL);
+  const unhealthy = expectations.filter((expectation) => !expectation.ok).length;
+  const warnings = expectations.filter((expectation) => expectation.check.status === "warn").length;
+  return {
+    ok: unhealthy === 0,
+    generatedAt: new Date().toISOString(),
+    summary: {
+      loops: expectations.length,
+      healthy: expectations.length - unhealthy,
+      unhealthy,
+      warnings
+    },
+    classifications,
+    expectations
+  };
+}
+
+// src/lib/goal/metadata.ts
+function goalExecutionContext(parts) {
+  return {
+    loopId: parts.loop?.id,
+    loopName: parts.loop?.name,
+    loopRunId: parts.loopRun?.id,
+    scheduledFor: parts.loopRun?.scheduledFor ?? parts.scheduledFor,
+    workflowId: parts.workflow?.id,
+    workflowName: parts.workflow?.name,
+    workflowRunId: parts.workflowRunId,
+    workflowStepId: parts.workflowStepId
+  };
+}
+function executionMetadata(context, goal, node) {
+  return {
+    loopId: context?.loopId,
+    loopName: context?.loopName,
+    runId: context?.loopRunId,
+    scheduledFor: context?.scheduledFor,
+    workflowId: context?.workflowId,
+    workflowName: context?.workflowName,
+    workflowRunId: context?.workflowRunId,
+    workflowStepId: context?.workflowStepId,
+    goalId: goal?.goalId,
+    goalObjective: goal?.objective,
+    goalNodeKey: node?.key
+  };
+}
+function withGoalNodeEnv(env, node) {
+  return { ...env ?? process.env, LOOPS_GOAL_NODE_KEY: node.key, LOOPS_GOAL_NODE_OBJECTIVE: node.objective };
 }
 
 // src/lib/goal/prompts.ts
@@ -4586,6 +6070,23 @@ function planPrompt(spec) {
   ].join(`
 `);
 }
+function iterationPrompt(goal, node) {
+  return [
+    "Continue executing the goal plan without losing budget discipline.",
+    `Goal: ${goal.objective}`,
+    `Plan node: ${node.key}`,
+    `Node objective: ${node.objective}`,
+    "Work only on this node's objective in this run; other plan nodes run in their own iterations."
+  ].join(`
+`);
+}
+function goalNodeTarget(target, goal, node) {
+  if (target.type !== "agent")
+    return target;
+  return { ...target, prompt: `${target.prompt}
+
+${iterationPrompt(goal, node)}` };
+}
 function achievementPrompt(goal, nodes, evidence) {
   return [
     "Run an adversarial achievement audit.",
@@ -4605,6 +6106,79 @@ ${evidence.join(`
 `);
 }
 
+// src/lib/goal/runner.ts
+import { generateObject } from "ai";
+import { z } from "zod";
+
+// src/lib/run-envelope.ts
+var ENVELOPE_EXCERPT_CHARS = 2048;
+var BLOCKED_STEP_ERROR_PREFIX = "blocked:";
+function boundedExcerpt(text, limit = ENVELOPE_EXCERPT_CHARS) {
+  if (!text)
+    return;
+  const scrubbed = scrubSecrets(text);
+  if (scrubbed.length <= limit * 2)
+    return scrubbed;
+  const omitted = scrubbed.length - limit * 2;
+  return `${scrubbed.slice(0, limit)}
+[... ${omitted} chars omitted ...]
+${scrubbed.slice(-limit)}`;
+}
+function summarizeOutput(stdout, stderr) {
+  return {
+    stdoutBytes: stdout ? Buffer.byteLength(stdout, "utf8") : 0,
+    stderrBytes: stderr ? Buffer.byteLength(stderr, "utf8") : 0,
+    stdoutExcerpt: boundedExcerpt(stdout),
+    stderrExcerpt: boundedExcerpt(stderr)
+  };
+}
+function summarizeExecutorResult(result) {
+  return {
+    ...summarizeOutput(result.stdout, result.stderr),
+    status: result.status,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs,
+    error: boundedExcerpt(result.error)
+  };
+}
+function isBlockedStepRun(step) {
+  return step?.status === "skipped" && (step.error?.startsWith(BLOCKED_STEP_ERROR_PREFIX) ?? false);
+}
+function summarizeWorkflowStepRun(step) {
+  return {
+    ...summarizeOutput(step.stdout, step.stderr),
+    stepId: step.stepId,
+    status: step.status,
+    exitCode: step.exitCode,
+    durationMs: step.durationMs,
+    error: boundedExcerpt(step.error),
+    blocked: isBlockedStepRun(step)
+  };
+}
+function workflowRunEnvelope(run, steps) {
+  return JSON.stringify({ workflowRun: run, steps: steps.map(summarizeWorkflowStepRun) }, null, 2);
+}
+
+// src/lib/goal/model-factory.ts
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+var DEFAULT_GOAL_MODEL = "openai/gpt-4o-mini";
+function resolveGoalModel(opts = {}) {
+  const env = opts.env ?? process.env;
+  const apiKey = opts.apiKey ?? env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENROUTER_API_KEY is required to run goals with the OpenRouter AI SDK provider");
+  }
+  const provider = createOpenRouter({
+    apiKey,
+    baseURL: opts.baseURL ?? env.LOOPS_GOAL_BASE_URL ?? env.OPENROUTER_BASE_URL
+  });
+  return provider.chat(opts.model ?? env.LOOPS_GOAL_MODEL ?? DEFAULT_GOAL_MODEL);
+}
+function resolveGoalVerifierModel(opts = {}) {
+  const env = opts.env ?? process.env;
+  return resolveGoalModel({ ...opts, model: opts.model ?? env.LOOPS_GOAL_VERIFIER_MODEL });
+}
+
 // src/lib/goal/runner.ts
 var DEFAULT_MAX_TURNS = 10;
 var PlanNodeSchema = z.object({
@@ -4732,34 +6306,39 @@ function noReadyDiagnostic(goal, nodes) {
     incompleteNodes: incompleteDetails
   };
 }
-function metadataFor(goal, node, context) {
-  return {
-    loopId: context?.loopId,
-    loopName: context?.loopName,
-    runId: context?.loopRunId,
-    scheduledFor: context?.scheduledFor,
-    workflowId: context?.workflowId,
-    workflowName: context?.workflowName,
-    workflowRunId: context?.workflowRunId,
-    workflowStepId: context?.workflowStepId,
-    goalId: goal.goalId,
-    goalObjective: goal.objective,
-    goalNodeKey: node.key
-  };
-}
 async function executeUnderlyingTarget(target, goal, node, opts) {
-  const metadata = metadataFor(goal, node, opts.context);
+  const metadata = executionMetadata(opts.context, goal, node);
   if (opts.executeNode)
     return opts.executeNode(node, metadata);
   if (!target)
     throw new Error("runGoal requires either target or executeNode");
-  return executeTarget(target, metadata, {
-    env: opts.env,
+  return executeTarget(goalNodeTarget(target, goal, node), metadata, {
+    env: withGoalNodeEnv(opts.env, node),
     daemonLeaseId: opts.daemonLeaseId,
     beforePersist: opts.beforePersist,
     signal: opts.signal
   });
 }
+function verifierModelFor(spec, opts, planner) {
+  if (opts.verifierModel)
+    return opts.verifierModel;
+  const env = opts.env ?? process.env;
+  const configured = spec.verifierModel ?? env.LOOPS_GOAL_VERIFIER_MODEL;
+  if (!configured)
+    return planner;
+  return resolveGoalVerifierModel({ model: configured, env: opts.env });
+}
+function nodeEvidence(node, result) {
+  const summary = summarizeExecutorResult(result);
+  return [
+    `node ${node.key} ${summary.status} (exit ${summary.exitCode ?? "unknown"}, ${summary.durationMs}ms, ` + `stdout ${summary.stdoutBytes}B, stderr ${summary.stderrBytes}B)`,
+    summary.stdoutExcerpt ? `stdout excerpt:
+${summary.stdoutExcerpt}` : undefined,
+    summary.stderrExcerpt ? `stderr excerpt:
+${summary.stderrExcerpt}` : undefined
+  ].filter(Boolean).join(`
+`);
+}
 async function planGoal(store, goal, spec, model, opts) {
   const existing = store.listGoalPlanNodes(goal.goalId);
   if (existing.length > 0)
@@ -4793,18 +6372,19 @@ async function planGoal(store, goal, spec, model, opts) {
   return store.createGoalPlanNodes(goal.goalId, rawNodes, { daemonLeaseId: opts.daemonLeaseId });
 }
 function stdoutFor(goal, nodes, evidence, validation, diagnostics) {
-  return JSON.stringify({
+  return scrubSecrets(JSON.stringify(scrubSecretsDeep({
     goal,
     rollup: rollupSummary(nodes),
     nodes,
     evidence,
     validation,
     diagnostics
-  }, null, 2);
+  }), null, 2));
 }
 async function runGoal(store, input, opts = {}) {
   const spec = normalizeGoalSpec2(input);
   const model = opts.model ?? resolveGoalModel({ model: spec.model, env: opts.env });
+  const verifier = verifierModelFor(spec, opts, model);
   const startedAt = nowIso();
   const existing = store.findGoalByContext({
     loopRunId: opts.context?.loopRunId,
@@ -4837,6 +6417,13 @@ async function runGoal(store, input, opts = {}) {
     goal = store.updateGoalStatus(goal.goalId, "budgetLimited", { daemonLeaseId: opts.daemonLeaseId });
     return resultFromGoal(goal, "failed", stdoutFor(goal, nodes, evidence), "goal token budget exhausted after planning", startedAt);
   }
+  if ((goal.autoExecute ?? spec.autoExecute) === "off") {
+    nodes = syncReadyFlags(store, goal, nodes, opts);
+    return resultFromGoal(goal, "succeeded", stdoutFor(goal, nodes, evidence, undefined, {
+      autoExecute: "off",
+      note: "autoExecute is off: goal plan persisted without executing any nodes"
+    }), undefined, startedAt);
+  }
   for (let turn = 1;turn <= (spec.maxTurns ?? DEFAULT_MAX_TURNS); turn++) {
     if (opts.signal?.aborted) {
       goal = store.updateGoalStatus(goal.goalId, "cancelled", { daemonLeaseId: opts.daemonLeaseId });
@@ -4875,11 +6462,7 @@ async function runGoal(store, input, opts = {}) {
           }
         }, { daemonLeaseId: opts.daemonLeaseId });
         if (result.status === "succeeded") {
-          evidence.push(`node ${node.key} succeeded
-stdout:
-${result.stdout}
-stderr:
-${result.stderr}`);
+          evidence.push(nodeEvidence(node, result));
           store.updateGoalPlanNode(goal.goalId, node.key, {
             status: "complete",
             timeUsedSeconds: Math.round(result.durationMs / 1000)
@@ -4906,7 +6489,7 @@ ${result.stderr}`);
     }
     if (nodes.every((node) => node.status === "complete")) {
       const judged = await generateObject({
-        model,
+        model: verifier,
         schema: AchievementSchema,
         temperature: 0,
         prompt: achievementPrompt(goal, nodes, evidence),
@@ -4975,19 +6558,31 @@ ${result.stderr}`);
 }
 
 // src/lib/workflow-runner.ts
-function targetWithStepAccount(step) {
+var DEFAULT_BLOCKED_EXIT_CODES = [12];
+var GATE_STEP_PATTERN = /(^|[^a-z])gate([^a-z]|$)/i;
+function blockedExitCodesForStep(step) {
+  const explicit = step.blockedExitCodes;
+  if (explicit !== undefined)
+    return explicit.filter((code) => Number.isInteger(code));
+  return GATE_STEP_PATTERN.test(step.name ? `${step.id} ${step.name}` : step.id) ? DEFAULT_BLOCKED_EXIT_CODES : [];
+}
+function targetWithStepAccount(step, goalNodePrompt) {
   const account = step.account ?? step.target.account;
   const timeoutMs = step.timeoutMs !== undefined ? step.timeoutMs : step.target.timeoutMs;
-  if (!account && timeoutMs === step.target.timeoutMs)
-    return step.target;
-  return { ...step.target, account, timeoutMs };
+  const target = !account && timeoutMs === step.target.timeoutMs ? step.target : { ...step.target, account, timeoutMs };
+  if (goalNodePrompt && target.type === "agent") {
+    return { ...target, prompt: `${target.prompt}
+
+${goalNodePrompt}` };
+  }
+  return target;
 }
-function workflowResult(workflowRun, status, startedAt, finishedAt, stdout, error) {
+function workflowResult(workflowRun, status, startedAt, finishedAt, steps, error) {
   const executorStatus = status === "succeeded" ? "succeeded" : status === "timed_out" ? "timed_out" : "failed";
   return {
     status: executorStatus,
     exitCode: executorStatus === "succeeded" ? 0 : 1,
-    stdout,
+    stdout: workflowRunEnvelope(workflowRun, steps),
     stderr: "",
     error,
     startedAt,
@@ -4997,20 +6592,16 @@ function workflowResult(workflowRun, status, startedAt, finishedAt, stdout, erro
 }
 async function executeWorkflow(store, workflow, opts = {}) {
   if (workflow.goal) {
+    const goalSpec = workflow.goal;
     const workflowWithoutGoal = { ...workflow, goal: undefined };
-    return runGoal(store, workflow.goal, {
+    return runGoal(store, goalSpec, {
       ...opts,
       model: opts.goalModel,
-      context: {
-        loopId: opts.loop?.id,
-        loopName: opts.loop?.name,
-        loopRunId: opts.loopRun?.id,
-        scheduledFor: opts.loopRun?.scheduledFor ?? opts.scheduledFor,
-        workflowId: workflow.id,
-        workflowName: workflow.name
-      },
+      context: goalExecutionContext({ loop: opts.loop, loopRun: opts.loopRun, scheduledFor: opts.scheduledFor, workflow }),
       executeNode: async (node) => executeWorkflow(store, workflowWithoutGoal, {
         ...opts,
+        env: withGoalNodeEnv(opts.env, node),
+        goalNodePrompt: iterationPrompt(goalSpec, node),
         idempotencyKey: `${opts.idempotencyKey ?? workflow.id}:goal:${node.key}`
       })
     });
@@ -5025,8 +6616,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
   });
   const startedAt = run.startedAt ?? nowIso();
   if (run.status === "succeeded" || run.status === "failed" || run.status === "timed_out" || run.status === "cancelled") {
-    const steps2 = store.listWorkflowStepRuns(run.id);
-    return workflowResult(run, run.status, startedAt, run.finishedAt ?? nowIso(), JSON.stringify({ workflowRun: run, steps: steps2 }, null, 2), run.error);
+    return workflowResult(run, run.status, startedAt, run.finishedAt ?? nowIso(), store.listWorkflowStepRuns(run.id), run.error);
   }
   const ordered = workflowExecutionOrder(workflow);
   const byId = new Map(workflow.steps.map((step) => [step.id, step]));
@@ -5056,6 +6646,12 @@ async function executeWorkflow(store, workflow, opts = {}) {
     });
     if (blockedBy) {
       opts.beforePersist?.();
+      if (isBlockedStepRun(store.getWorkflowStepRun(run.id, blockedBy))) {
+        store.skipWorkflowStepRun(run.id, step.id, `${BLOCKED_STEP_ERROR_PREFIX} upstream step ${blockedBy} was blocked`, {
+          daemonLeaseId: opts.daemonLeaseId
+        });
+        continue;
+      }
       store.skipWorkflowStepRun(run.id, step.id, `dependency did not succeed: ${blockedBy}`, { daemonLeaseId: opts.daemonLeaseId });
       blockingError ??= `step ${step.id} blocked by dependency ${blockedBy}`;
       terminalStatus = "failed";
@@ -5068,16 +6664,14 @@ async function executeWorkflow(store, workflow, opts = {}) {
       blockingError = `step ${step.id} could not start because workflow is no longer running`;
       break;
     }
-    const metadata = {
-      loopId: opts.loop?.id,
-      loopName: opts.loop?.name,
-      runId: opts.loopRun?.id,
-      scheduledFor: opts.loopRun?.scheduledFor ?? opts.scheduledFor,
-      workflowId: workflow.id,
-      workflowName: workflow.name,
+    const stepContext = goalExecutionContext({
+      loop: opts.loop,
+      loopRun: opts.loopRun,
+      scheduledFor: opts.scheduledFor,
+      workflow,
       workflowRunId: run.id,
       workflowStepId: step.id
-    };
+    });
     let result;
     const controller = new AbortController;
     const externalAbort = () => controller.abort();
@@ -5096,19 +6690,10 @@ async function executeWorkflow(store, workflow, opts = {}) {
           model: opts.goalModel,
           target: targetWithStepAccount(step),
           signal: controller.signal,
-          context: {
-            loopId: opts.loop?.id,
-            loopName: opts.loop?.name,
-            loopRunId: opts.loopRun?.id,
-            scheduledFor: opts.loopRun?.scheduledFor ?? opts.scheduledFor,
-            workflowId: workflow.id,
-            workflowName: workflow.name,
-            workflowRunId: run.id,
-            workflowStepId: step.id
-          }
+          context: stepContext
         });
       } else {
-        result = await executeTarget(targetWithStepAccount(step), metadata, {
+        result = await executeTarget(targetWithStepAccount(step, opts.goalNodePrompt), executionMetadata(stepContext), {
           ...opts,
           machine: opts.machine ?? opts.loop?.machine,
           signal: controller.signal,
@@ -5144,6 +6729,21 @@ async function executeWorkflow(store, workflow, opts = {}) {
       break;
     }
     opts.beforePersist?.();
+    const blockedExit = result.status === "failed" && result.exitCode !== undefined && blockedExitCodesForStep(step).includes(result.exitCode);
+    if (blockedExit) {
+      store.finalizeWorkflowStepRun(run.id, step.id, {
+        status: "skipped",
+        finishedAt: result.finishedAt,
+        durationMs: result.durationMs,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        error: `${BLOCKED_STEP_ERROR_PREFIX} step ${step.id} exited with blocked exit code ${result.exitCode}`
+      }, {
+        daemonLeaseId: opts.daemonLeaseId
+      });
+      continue;
+    }
     store.finalizeWorkflowStepRun(run.id, step.id, {
       status: result.status,
       finishedAt: result.finishedAt,
@@ -5174,8 +6774,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
   const finishedAt = nowIso();
   if (store.isWorkflowRunTerminal(run.id)) {
     const terminalRun = store.requireWorkflowRun(run.id);
-    const steps2 = store.listWorkflowStepRuns(run.id);
-    return workflowResult(terminalRun, terminalRun.status, startedAt, terminalRun.finishedAt ?? finishedAt, JSON.stringify({ workflowRun: terminalRun, steps: steps2 }, null, 2), terminalRun.error ?? blockingError);
+    return workflowResult(terminalRun, terminalRun.status, startedAt, terminalRun.finishedAt ?? finishedAt, store.listWorkflowStepRuns(run.id), terminalRun.error ?? blockingError);
   }
   opts.beforePersist?.();
   const finalRun = store.finalizeWorkflowRun(run.id, terminalStatus, {
@@ -5185,8 +6784,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
   }, {
     daemonLeaseId: opts.daemonLeaseId
   });
-  const steps = store.listWorkflowStepRuns(run.id);
-  return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, JSON.stringify({ workflowRun: finalRun, steps }, null, 2), blockingError);
+  return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), blockingError);
 }
 function preflightWorkflow(workflow, opts = {}) {
   return workflowExecutionOrder(workflow).map((step) => {
@@ -5237,12 +6835,7 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
         ...opts,
         model: opts.goalModel,
         target: loop.target,
-        context: {
-          loopId: loop.id,
-          loopName: loop.name,
-          loopRunId: run.id,
-          scheduledFor: run.scheduledFor
-        }
+        context: goalExecutionContext({ loop, loopRun: run })
       });
     }
     return executeLoop(loop, run, opts);
@@ -5257,23 +6850,19 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
     }
   }
   if (loop.goal) {
+    const loopGoal = loop.goal;
     const workflowForLoopGoal = workflow.goal ? { ...workflow, goal: undefined } : workflow;
-    return runGoal(store, loop.goal, {
+    return runGoal(store, loopGoal, {
       ...opts,
       model: opts.goalModel,
-      context: {
-        loopId: loop.id,
-        loopName: loop.name,
-        loopRunId: run.id,
-        scheduledFor: run.scheduledFor,
-        workflowId: workflow.id,
-        workflowName: workflow.name
-      },
+      context: goalExecutionContext({ loop, loopRun: run, workflow }),
       executeNode: async (node) => executeWorkflow(store, workflowForLoopGoal, {
         ...opts,
         loop,
         loopRun: run,
         scheduledFor: run.scheduledFor,
+        env: withGoalNodeEnv(opts.env, node),
+        goalNodePrompt: iterationPrompt(loopGoal, node),
         idempotencyKey: `${loop.id}:${run.scheduledFor}:attempt:${run.attempt}:goal:${node.key}`
       })
     });
@@ -5338,12 +6927,129 @@ function manualRunSource(loop, scheduledFor, now = new Date) {
     return "retry_slot";
   return "due_slot";
 }
-function nextAfterRetry(loop, now) {
-  return new Date(now.getTime() + loop.retryDelayMs).toISOString();
+var INLINE_RUNNER_ID_PATTERN = /^[^:\s]+:(\d+)$/;
+function inlineRunnerOwnerPid(claimedBy) {
+  const match = claimedBy ? INLINE_RUNNER_ID_PATTERN.exec(claimedBy) : null;
+  return match ? Number(match[1]) : undefined;
+}
+async function runLoopNow(deps) {
+  const { store, runnerId } = deps;
+  const loop = store.requireLoop(deps.idOrName);
+  if (loop.archivedAt)
+    throw new LoopArchivedError(loop.name || deps.idOrName);
+  const now = deps.now?.() ?? new Date;
+  if (deps.mode === "schedule") {
+    const scheduledFor2 = now.toISOString();
+    const updated = store.updateLoop(loop.id, { status: "active", nextRunAt: scheduledFor2 });
+    return { mode: "schedule", loop: updated, scheduledFor: scheduledFor2 };
+  }
+  let scheduledFor = manualRunScheduledFor(loop, now);
+  let source = manualRunSource(loop, scheduledFor, now);
+  let shouldAdvance = shouldAdvanceManualRun(loop, scheduledFor, now);
+  let claim = store.claimRun(loop, scheduledFor, runnerId, now);
+  if (!claim && shouldAdvance) {
+    const existing = store.getRunBySlot(loop.id, scheduledFor);
+    if (existing && existing.status !== "running") {
+      scheduledFor = now.toISOString();
+      source = "ad_hoc";
+      shouldAdvance = false;
+      claim = store.claimRun(loop, scheduledFor, runnerId, now);
+    }
+  }
+  if (!claim)
+    throw new Error(`could not claim manual run for ${deps.idOrName}`);
+  const run = await executeClaimedRun({
+    store,
+    runnerId,
+    loop: claim.loop,
+    run: claim.run,
+    now: deps.now,
+    execute: deps.execute
+  });
+  if (shouldAdvance) {
+    advanceLoop(store, claim.loop, run, new Date(run.finishedAt ?? new Date), run.status === "succeeded");
+  }
+  return { mode: "inline", loop: claim.loop, run, source, advancedLoop: shouldAdvance };
+}
+var MAX_RETRY_DELAY_MS = 6 * 60 * 60 * 1000;
+var DEFAULT_CIRCUIT_BREAKER_THRESHOLD = 5;
+var CIRCUIT_BREAKER_REASON_PREFIX = "circuit breaker open";
+var MAX_SKIPS_PER_LOOP_PER_TICK = 10;
+var THROTTLED_RETRY_MULTIPLIER = 4;
+var MAX_RETRY_EXPONENT = 20;
+function retryBackoffDelayMs(loop, run, random = Math.random) {
+  const attempt = Math.max(1, run.attempt);
+  const failure = classifyRunFailure(run);
+  const throttled = failure?.classification === "rate_limit" || failure?.classification === "auth";
+  const growth = 2 ** Math.min(attempt - 1, MAX_RETRY_EXPONENT);
+  const base = loop.retryDelayMs * growth * (throttled ? THROTTLED_RETRY_MULTIPLIER : 1);
+  const jitter = 0.5 + random();
+  return Math.min(MAX_RETRY_DELAY_MS, Math.round(base * jitter));
+}
+function nextAfterRetry(loop, run, now, random) {
+  return new Date(now.getTime() + retryBackoffDelayMs(loop, run, random)).toISOString();
 }
 function isDaemonLeaseLost(error) {
   return error instanceof Error && error.message === "daemon lease lost";
 }
+function resolveBreakerThreshold(loop, override) {
+  const perLoop = loop.circuitBreakerThreshold;
+  if (typeof perLoop === "number" && Number.isFinite(perLoop))
+    return Math.floor(perLoop);
+  const resolved = typeof override === "function" ? override(loop) : override;
+  if (typeof resolved === "number" && Number.isFinite(resolved))
+    return Math.floor(resolved);
+  return DEFAULT_CIRCUIT_BREAKER_THRESHOLD;
+}
+function consecutiveFailureCount(store, loopId, maxAttempts = 1, scanLimit = 50) {
+  const runs = store.listRuns({ loopId, limit: scanLimit });
+  let watermark;
+  for (const run of runs) {
+    if (run.status !== "skipped" || !run.error?.startsWith(CIRCUIT_BREAKER_REASON_PREFIX))
+      continue;
+    const at = new Date(run.scheduledFor).getTime();
+    if (watermark === undefined || at > watermark)
+      watermark = at;
+  }
+  let count = 0;
+  for (const run of runs) {
+    if (run.status === "running" || run.status === "skipped")
+      continue;
+    if (watermark !== undefined && new Date(run.scheduledFor).getTime() <= watermark)
+      continue;
+    if (run.status === "succeeded")
+      break;
+    if (run.attempt < maxAttempts)
+      continue;
+    count += 1;
+  }
+  return count;
+}
+function awaitStrictlyNewerRunTimestamp(store, loopId) {
+  const latest = store.listRuns({ loopId, limit: 1 })[0];
+  if (!latest)
+    return;
+  const latestMs = new Date(latest.createdAt).getTime();
+  for (let spin = 0;spin < 1e6 && Date.now() <= latestMs; spin += 1) {}
+}
+function tripCircuitBreaker(store, loop, run, finishedAt, failures, opts) {
+  awaitStrictlyNewerRunTimestamp(store, loop.id);
+  const reason = `${CIRCUIT_BREAKER_REASON_PREFIX}: ${failures} consecutive failed runs; loop auto-paused (resume with 'loops resume ${loop.name}')`;
+  let markerAtMs = finishedAt.getTime();
+  for (let probe = 0;probe < 1000 && store.getRunBySlot(loop.id, new Date(markerAtMs).toISOString()); probe += 1) {
+    markerAtMs += 1;
+  }
+  const marker = store.createSkippedRun(loop, new Date(markerAtMs).toISOString(), reason, {
+    daemonLeaseId: opts.daemonLeaseId
+  });
+  const nextRunAt = computeNextAfter(loop.schedule, new Date(run.scheduledFor), finishedAt);
+  store.updateLoop(loop.id, {
+    status: "paused",
+    nextRunAt,
+    retryScheduledFor: undefined
+  }, { daemonLeaseId: opts.daemonLeaseId });
+  opts.onRun?.(marker);
+}
 function advanceLoop(store, loop, run, finishedAt, succeeded, opts = {}) {
   if (run.status === "running")
     return;
@@ -5356,7 +7062,7 @@ function advanceLoop(store, loop, run, finishedAt, succeeded, opts = {}) {
   if (shouldRetry) {
     store.updateLoop(current.id, {
       status: "active",
-      nextRunAt: nextAfterRetry(current, finishedAt),
+      nextRunAt: nextAfterRetry(current, run, finishedAt, opts.random),
       retryScheduledFor: run.scheduledFor
     }, { daemonLeaseId: opts.daemonLeaseId });
     return;
@@ -5365,11 +7071,21 @@ function advanceLoop(store, loop, run, finishedAt, succeeded, opts = {}) {
   if (deferredRetry) {
     store.updateLoop(current.id, {
       status: "active",
-      nextRunAt: nextAfterRetry(current, finishedAt),
+      nextRunAt: nextAfterRetry(current, deferredRetry, finishedAt, opts.random),
       retryScheduledFor: deferredRetry.scheduledFor
     }, { daemonLeaseId: opts.daemonLeaseId });
     return;
   }
+  if (!succeeded) {
+    const threshold = resolveBreakerThreshold(current, opts.circuitBreakerThreshold);
+    if (threshold > 0) {
+      const failures = consecutiveFailureCount(store, current.id, current.maxAttempts, Math.max(threshold * 4, 50));
+      if (failures >= threshold) {
+        tripCircuitBreaker(store, current, run, finishedAt, failures, opts);
+        return;
+      }
+    }
+  }
   const nextRunAt = computeNextAfter(current.schedule, new Date(run.scheduledFor), finishedAt);
   store.updateLoop(current.id, {
     status: nextRunAt ? "active" : "stopped",
@@ -5431,6 +7147,14 @@ async function executeClaimedRun(deps) {
       clearInterval(heartbeat);
   }
 }
+function advanceOptions(deps) {
+  return {
+    daemonLeaseId: deps.daemonLeaseId,
+    random: deps.random,
+    circuitBreakerThreshold: deps.circuitBreakerThreshold,
+    onRun: deps.onRun
+  };
+}
 async function runSlot(deps, loop, scheduledFor) {
   const now = deps.now?.() ?? new Date;
   deps.beforeRun?.(loop, scheduledFor);
@@ -5445,7 +7169,7 @@ async function runSlot(deps, loop, scheduledFor) {
         return;
       throw error;
     }
-    advanceLoop(deps.store, loop, skipped, now, true, { daemonLeaseId: deps.daemonLeaseId });
+    advanceLoop(deps.store, loop, skipped, now, true, advanceOptions(deps));
     deps.onRun?.(skipped);
     return skipped;
   }
@@ -5472,7 +7196,7 @@ async function runSlot(deps, loop, scheduledFor) {
     daemonLeaseId: deps.daemonLeaseId,
     onError: deps.onError
   });
-  advanceLoop(deps.store, claim.loop, finalRun, new Date(finalRun.finishedAt ?? new Date), finalRun.status === "succeeded", { daemonLeaseId: deps.daemonLeaseId });
+  advanceLoop(deps.store, claim.loop, finalRun, new Date(finalRun.finishedAt ?? new Date), finalRun.status === "succeeded", advanceOptions(deps));
   deps.onRun?.(finalRun);
   return finalRun;
 }
@@ -5492,7 +7216,7 @@ function claimSlot(deps, loop, scheduledFor) {
         return;
       throw error;
     }
-    advanceLoop(deps.store, loop, skipped, now, true, { daemonLeaseId: deps.daemonLeaseId });
+    advanceLoop(deps.store, loop, skipped, now, true, advanceOptions(deps));
     deps.onRun?.(skipped);
     return skipped;
   }
@@ -5510,8 +7234,7 @@ function claimSlot(deps, loop, scheduledFor) {
   deps.onRun?.(claim.run);
   return claim;
 }
-function claimDueRuns(deps) {
-  const now = deps.now?.() ?? new Date;
+function recoverAndExpire(deps, now) {
   const recovered = deps.store.recoverExpiredRunLeases(now, { daemonLeaseId: deps.daemonLeaseId });
   const recoveredByLoop = new Map;
   for (const run of recovered) {
@@ -5523,21 +7246,22 @@ function claimDueRuns(deps) {
       continue;
     const retryable = runs.filter((run) => run.attempt < loop.maxAttempts).sort((a, b) => new Date(a.scheduledFor).getTime() - new Date(b.scheduledFor).getTime())[0];
     if (retryable) {
-      advanceLoop(deps.store, loop, retryable, new Date(retryable.finishedAt ?? now), false, {
-        daemonLeaseId: deps.daemonLeaseId
-      });
+      advanceLoop(deps.store, loop, retryable, new Date(retryable.finishedAt ?? now), false, advanceOptions(deps));
       continue;
     }
     for (const run of runs) {
       const current = deps.store.getLoop(run.loopId);
       if (current) {
-        advanceLoop(deps.store, current, run, new Date(run.finishedAt ?? now), false, {
-          daemonLeaseId: deps.daemonLeaseId
-        });
+        advanceLoop(deps.store, current, run, new Date(run.finishedAt ?? now), false, advanceOptions(deps));
       }
     }
   }
   const expired = deps.store.expireLoops(now, { daemonLeaseId: deps.daemonLeaseId });
+  return { recovered, expired };
+}
+function claimDueRuns(deps) {
+  const now = deps.now?.() ?? new Date;
+  const { recovered, expired } = recoverAndExpire(deps, now);
   const claims = [];
   const claimed = [];
   const skipped = [];
@@ -5545,11 +7269,14 @@ function claimDueRuns(deps) {
   if (maxClaims === 0)
     return { claims, claimed, completed: [], skipped, recovered, expired };
   for (const loop of deps.store.dueLoops(now)) {
-    if (claims.length + skipped.length >= maxClaims)
+    if (claims.length >= maxClaims)
       break;
     const plan = dueSlots(loop, now);
+    let loopSkips = 0;
     for (const slot of plan.slots) {
-      if (claims.length + skipped.length >= maxClaims)
+      if (claims.length >= maxClaims)
+        break;
+      if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
         break;
       const run = claimSlot(deps, loop, slot);
       if (!run)
@@ -5559,6 +7286,7 @@ function claimDueRuns(deps) {
         claimed.push(run.run);
       } else if (run.status === "skipped") {
         skipped.push(run);
+        loopSkips += 1;
       }
     }
   }
@@ -5566,46 +7294,25 @@ function claimDueRuns(deps) {
 }
 async function tick(deps) {
   const now = deps.now?.() ?? new Date;
-  const recovered = deps.store.recoverExpiredRunLeases(now, { daemonLeaseId: deps.daemonLeaseId });
-  const recoveredByLoop = new Map;
-  for (const run of recovered) {
-    recoveredByLoop.set(run.loopId, [...recoveredByLoop.get(run.loopId) ?? [], run]);
-  }
-  for (const runs of recoveredByLoop.values()) {
-    const loop = deps.store.getLoop(runs[0].loopId);
-    if (!loop)
-      continue;
-    const retryable = runs.filter((run) => run.attempt < loop.maxAttempts).sort((a, b) => new Date(a.scheduledFor).getTime() - new Date(b.scheduledFor).getTime())[0];
-    if (retryable) {
-      advanceLoop(deps.store, loop, retryable, new Date(retryable.finishedAt ?? now), false, {
-        daemonLeaseId: deps.daemonLeaseId
-      });
-      continue;
-    }
-    for (const run of runs) {
-      const current = deps.store.getLoop(run.loopId);
-      if (current) {
-        advanceLoop(deps.store, current, run, new Date(run.finishedAt ?? now), false, {
-          daemonLeaseId: deps.daemonLeaseId
-        });
-      }
-    }
-  }
-  const expired = deps.store.expireLoops(now, { daemonLeaseId: deps.daemonLeaseId });
+  const { recovered, expired } = recoverAndExpire(deps, now);
   const claimed = [];
   const completed = [];
   const skipped = [];
   for (const loop of deps.store.dueLoops(now)) {
     const plan = dueSlots(loop, now);
+    let loopSkips = 0;
     for (const slot of plan.slots) {
+      if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
+        break;
       const run = await runSlot(deps, loop, slot);
       if (!run)
         continue;
       if (run.status === "running")
         claimed.push(run);
-      else if (run.status === "skipped")
+      else if (run.status === "skipped") {
         skipped.push(run);
-      else
+        loopSkips += 1;
+      } else
         completed.push(run);
       if (["failed", "timed_out", "abandoned"].includes(run.status) && run.attempt < loop.maxAttempts)
         break;
@@ -5627,29 +7334,25 @@ class LoopsClient {
   create(input) {
     return this.store.createLoop(input);
   }
-  list() {
-    return this.store.listLoops();
+  list(filters = {}) {
+    return this.store.listLoops({
+      status: filters.status,
+      limit: filters.limit,
+      includeArchived: filters.includeArchived,
+      archived: filters.archivedOnly
+    });
   }
   get(idOrName) {
     return this.store.requireLoop(idOrName);
   }
   pause(idOrName) {
-    const loop = this.get(idOrName);
-    if (loop.archivedAt)
-      throw new Error(`loop is archived; unarchive it before pausing: ${idOrName}`);
-    return this.store.updateLoop(loop.id, { status: "paused" });
+    return this.store.updateLoop(this.get(idOrName).id, { status: "paused" });
   }
   resume(idOrName) {
-    const loop = this.get(idOrName);
-    if (loop.archivedAt)
-      throw new Error(`loop is archived; unarchive it before resuming: ${idOrName}`);
-    return this.store.updateLoop(loop.id, { status: "active" });
+    return this.store.updateLoop(this.get(idOrName).id, { status: "active" });
   }
   stop(idOrName) {
-    const loop = this.get(idOrName);
-    if (loop.archivedAt)
-      throw new Error(`loop is archived; unarchive it before stopping: ${idOrName}`);
-    return this.store.updateLoop(loop.id, { status: "stopped", nextRunAt: undefined });
+    return this.store.updateLoop(this.get(idOrName).id, { status: "stopped", nextRunAt: undefined });
   }
   archive(idOrName) {
     return this.store.archiveLoop(idOrName);
@@ -5660,8 +7363,24 @@ class LoopsClient {
   delete(idOrName) {
     return this.store.deleteLoop(idOrName);
   }
-  runs(loopId) {
-    return this.store.listRuns({ loopId });
+  runs(idOrName, filters = {}) {
+    let loopId;
+    if (idOrName) {
+      try {
+        loopId = this.get(idOrName).id;
+      } catch (error) {
+        if (error instanceof LoopNotFoundError)
+          return [];
+        throw error;
+      }
+    }
+    return this.store.listRuns({ loopId, status: filters.status, limit: filters.limit });
+  }
+  doctor() {
+    return runDoctor(this.store);
+  }
+  health(opts = {}) {
+    return buildHealthReport(this.store, opts);
   }
   goal(idOrName) {
     const goal = this.store.getGoal(idOrName) ?? this.store.findGoalByLoop(idOrName) ?? this.store.findGoalByRunId(idOrName);
@@ -5674,28 +7393,8 @@ class LoopsClient {
     return tick({ store: this.store, runnerId: this.runnerId });
   }
   async runNow(idOrName) {
-    const loop = this.get(idOrName);
-    if (loop.archivedAt)
-      throw new Error(`loop is archived; unarchive it before running: ${idOrName}`);
-    const now = new Date;
-    let scheduledFor = manualRunScheduledFor(loop, now);
-    let shouldAdvance = shouldAdvanceManualRun(loop, scheduledFor, now);
-    let claim = this.store.claimRun(loop, scheduledFor, this.runnerId, now);
-    if (!claim && shouldAdvance) {
-      const existing = this.store.getRunBySlot(loop.id, scheduledFor);
-      if (existing && existing.status !== "running") {
-        scheduledFor = now.toISOString();
-        shouldAdvance = false;
-        claim = this.store.claimRun(loop, scheduledFor, this.runnerId, now);
-      }
-    }
-    if (!claim)
-      throw new Error(`could not claim manual run for ${idOrName}`);
-    const run = await executeClaimedRun({ store: this.store, runnerId: this.runnerId, loop: claim.loop, run: claim.run });
-    if (shouldAdvance) {
-      advanceLoop(this.store, claim.loop, run, new Date(run.finishedAt ?? new Date), run.status === "succeeded");
-    }
-    return run;
+    const result = await runLoopNow({ store: this.store, idOrName, runnerId: this.runnerId });
+    return result.run;
   }
   close() {
     if (this.ownStore)