@hasna/loops 0.4.5 → 0.4.7

package/dist/cli/index.js

@@ -726,7 +726,7 @@ function buildAgentInvocation(target) {
       if (target.model)
         args.push("--model", target.model);
       args.push(...target.extraArgs ?? []);
-      args.push("agent", "start");
+      args.push("agent", "start", "--json");
       if (target.cwd)
         args.push("--cwd", target.cwd);
       args.push(target.prompt);
@@ -1493,11 +1493,14 @@ function ensurePrivateStorePath(file) {
 class Store {
   db;
   rootDir;
+  memoryRootDir;
   constructor(path) {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
     this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    if (file === ":memory:")
+      this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
     this.db.exec("PRAGMA foreign_keys = ON;");
     this.db.exec("PRAGMA busy_timeout = 5000;");
@@ -1950,9 +1953,12 @@ class Store {
     const rows = this.db.query("SELECT * FROM loops WHERE name = ? ORDER BY created_at DESC LIMIT 2").all(idOrName);
     if (rows.length === 0)
       throw new LoopNotFoundError(idOrName);
-    if (rows.length > 1)
+    if (rows.length === 1)
+      return rowToLoop(rows[0]);
+    const active = this.db.query("SELECT * FROM loops WHERE name = ? AND archived_at IS NULL ORDER BY created_at DESC LIMIT 2").all(idOrName);
+    if (active.length !== 1)
       throw new AmbiguousNameError(idOrName);
-    return rowToLoop(rows[0]);
+    return rowToLoop(active[0]);
   }
   requireLoop(idOrName) {
     return this.getLoop(idOrName) ?? this.findLoopByName(idOrName) ?? (() => {
@@ -2293,6 +2299,7 @@ class Store {
     return this.transact(() => {
       const loop = this.requireLoop(idOrName);
       this.setWorkflowWorkItemsForLoop(loop.id, "cancelled", "loop deleted", nowIso());
+      this.db.query("DELETE FROM loop_runs WHERE loop_id = ?").run(loop.id);
       const res = this.db.query("DELETE FROM loops WHERE id = ?").run(loop.id);
       return res.changes > 0;
     });
@@ -2777,7 +2784,10 @@ class Store {
         return rowToGoal(row);
     }
     if (context.sourceType && context.sourceId) {
-      const row = this.db.query("SELECT * FROM goals WHERE source_type = ? AND source_id = ? ORDER BY created_at DESC LIMIT 1").get(context.sourceType, context.sourceId);
+      const terminalPlaceholders = GOAL_TERMINAL.map(() => "?").join(", ");
+      const row = this.db.query(`SELECT * FROM goals
+           WHERE source_type = ? AND source_id = ? AND status NOT IN (${terminalPlaceholders})
+           ORDER BY created_at DESC LIMIT 1`).get(context.sourceType, context.sourceId, ...GOAL_TERMINAL);
       if (row)
         return rowToGoal(row);
     }
@@ -3197,6 +3207,41 @@ class Store {
       throw new Error(`workflow step run not found after pid update: ${workflowRunId}/${stepId}`);
     return run;
   }
+  recordWorkflowStepProgress(workflowRunId, stepId, progress, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const res = this.db.query(`UPDATE workflow_step_runs
+           SET stdout=COALESCE($stdout, stdout),
+               stderr=COALESCE($stderr, stderr),
+               updated_at=$updated
+           WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status='running'
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $workflowRunId: workflowRunId,
+        $stepId: stepId,
+        $stdout: progress.stdout === undefined ? null : scrubbedOrNull(progress.stdout),
+        $stderr: progress.stderr === undefined ? null : scrubbedOrNull(progress.stderr),
+        $updated: now,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: now
+      });
+      if (res.changes === 1) {
+        this.appendWorkflowEvent(workflowRunId, "step_progress", stepId, progress.payload);
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after progress update: ${workflowRunId}/${stepId}`);
+    return run;
+  }
   recoverWorkflowRun(workflowRunId, reason = "workflow run recovered for retry") {
     return this.transact(() => {
       const now = nowIso();
@@ -3634,7 +3679,8 @@ class Store {
                  AND ($daemonLeaseId IS NULL OR EXISTS (
                    SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
                  ))`).run(params) : this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, claim_token=NULL, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
-               duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated WHERE id=$id`).run(params);
+               duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
+               WHERE id=$id AND status='running'`).run(params);
       const run = this.getRun(id);
       if (!run)
         throw new Error(`run not found after finalize: ${id}`);
@@ -4162,12 +4208,18 @@ class Store {
   }
   close() {
     this.db.close();
+    if (this.memoryRootDir) {
+      try {
+        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+      } catch {}
+      this.memoryRootDir = undefined;
+    }
   }
 }
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.5",
+  version: "0.4.7",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4882,7 +4934,12 @@ function notifySpawn(pid, opts) {
   if (!pid)
     return;
   opts.onSpawn?.(pid);
-  opts.onSpawnProcess?.({ pid, pgid: pid, processStartedAt: nowIso() });
+  const startedMs = processStartTimeMs(pid);
+  opts.onSpawnProcess?.({
+    pid,
+    pgid: pid,
+    processStartedAt: startedMs !== undefined ? new Date(startedMs).toISOString() : nowIso()
+  });
 }
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -5207,18 +5264,60 @@ function codewithAgentControlArgs(target, command, agentId) {
     "agent",
     command,
     ...command === "logs" ? ["--limit", "20"] : [],
+    "--json",
     agentId
   ];
 }
+function extractFirstJsonObject(text) {
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0;i < text.length; i += 1) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      if (depth === 0)
+        start = i;
+      depth += 1;
+    } else if (ch === "}") {
+      if (depth > 0) {
+        depth -= 1;
+        if (depth === 0 && start !== -1)
+          return text.slice(start, i + 1);
+      }
+    }
+  }
+  return;
+}
 function parseJsonOutput(stdout, label) {
-  try {
-    const value = JSON.parse(stdout || "{}");
-    if (!value || typeof value !== "object" || Array.isArray(value))
-      throw new Error("not an object");
-    return value;
-  } catch (error) {
-    throw new Error(`${label} did not return JSON${error instanceof Error ? `: ${error.message}` : ""}`);
+  const raw = stdout || "{}";
+  const candidates = [raw.trim()];
+  const scanned = extractFirstJsonObject(raw);
+  if (scanned && scanned !== raw.trim())
+    candidates.push(scanned);
+  let lastError;
+  for (const candidate of candidates) {
+    try {
+      const value = JSON.parse(candidate);
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("not an object");
+      return value;
+    } catch (error) {
+      lastError = error;
+    }
   }
+  throw new Error(`${label} did not return JSON${lastError instanceof Error ? `: ${lastError.message}` : ""}`);
 }
 function recordField(value, key) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -5237,6 +5336,13 @@ function numberField(value, key) {
 function codewithAgentStatus(readJson) {
   return stringField(recordField(readJson, "agent"), "status") ?? stringField(recordField(readJson, "statusSnapshot"), "status");
 }
+function codewithAgentLastEventSeq(readJson) {
+  const agentSeq = numberField(recordField(readJson, "agent"), "lastEventSeq");
+  const snapshotSeq = numberField(recordField(readJson, "statusSnapshot"), "lastEventSeq");
+  if (agentSeq !== undefined && snapshotSeq !== undefined)
+    return Math.max(agentSeq, snapshotSeq);
+  return agentSeq ?? snapshotSeq;
+}
 function codewithAgentEvidence(startJson, readJson, logsJson) {
   const agent = recordField(readJson, "agent") ?? recordField(startJson, "agent");
   const statusSnapshot = recordField(readJson, "statusSnapshot");
@@ -5267,6 +5373,21 @@ function codewithAgentEvidence(startJson, readJson, logsJson) {
     events
   }, null, 2);
 }
+function codewithAgentProgress(readJson) {
+  const agent = recordField(readJson, "agent");
+  const statusSnapshot = recordField(readJson, "statusSnapshot");
+  return {
+    provider: "codewith",
+    agentId: stringField(agent, "agentId"),
+    status: stringField(agent, "status") ?? stringField(statusSnapshot, "status"),
+    summary: stringField(statusSnapshot, "summary"),
+    statusReason: stringField(agent, "statusReason"),
+    threadId: stringField(agent, "threadId"),
+    rolloutPath: stringField(agent, "rolloutPath"),
+    pid: numberField(agent, "pid"),
+    lastEventSeq: codewithAgentLastEventSeq(readJson)
+  };
+}
 function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
@@ -5301,6 +5422,7 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
   if (!agentId) {
     return failureResult(startedAt, "codewith agent start did not return agent.agentId", { stdout: start.stdout, stderr: stderr.value() });
   }
+  opts.onAgentProgress?.(codewithAgentProgress(startJson));
   const stopAgent = async () => {
     await spawnCapture(spec.command, codewithAgentControlArgs(target, "stop", agentId), {
       cwd: spec.cwd,
@@ -5343,10 +5465,15 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
       });
     }
     const status = codewithAgentStatus(lastReadJson);
-    const fingerprint = JSON.stringify({ status, snapshot: recordField(lastReadJson, "statusSnapshot") ?? null });
+    const fingerprint = JSON.stringify({
+      status,
+      agentLastEventSeq: numberField(recordField(lastReadJson, "agent"), "lastEventSeq"),
+      snapshot: recordField(lastReadJson, "statusSnapshot") ?? null
+    });
     if (fingerprint !== lastFingerprint) {
       lastFingerprint = fingerprint;
       lastProgressAt = Date.now();
+      opts.onAgentProgress?.(codewithAgentProgress(lastReadJson));
     }
     if (status === "completed" || status === "failed" || status === "cancelled") {
       const logs = await spawnCapture(spec.command, codewithAgentControlArgs(target, "logs", agentId), {
@@ -6347,173 +6474,213 @@ async function executeWorkflow(store, workflow, opts = {}) {
   if (run.status === "succeeded" || run.status === "failed" || run.status === "timed_out" || run.status === "cancelled") {
     return workflowResult(run, run.status, startedAt, run.finishedAt ?? nowIso(), store.listWorkflowStepRuns(run.id), run.error);
   }
+  const resumedRunningSteps = store.listWorkflowStepRuns(run.id).filter((step) => step.status === "running");
+  if (resumedRunningSteps.length > 0 && resumedRunningSteps.every((step) => step.pid !== undefined)) {
+    try {
+      store.recoverWorkflowRun(run.id, "workflow run resumed after lease takeover");
+    } catch {}
+  }
   const ordered = workflowExecutionOrder(workflow);
   const byId = new Map(workflow.steps.map((step) => [step.id, step]));
   let blockingError;
   let terminalStatus = "succeeded";
-  for (const step of ordered) {
-    if (store.isWorkflowRunTerminal(run.id)) {
-      terminalStatus = store.requireWorkflowRun(run.id).status;
-      blockingError = "workflow run was cancelled";
-      break;
-    }
-    const pendingTimeout = opts.signal?.aborted ? opts.signalTimeoutMessage?.() : undefined;
-    if (pendingTimeout) {
-      terminalStatus = "timed_out";
-      blockingError = pendingTimeout;
-      break;
-    }
-    const existing = store.getWorkflowStepRun(run.id, step.id);
-    if (existing?.status === "succeeded" || existing?.status === "skipped" || existing?.status === "cancelled")
-      continue;
-    const blockedBy = (step.dependsOn ?? []).find((dependencyId) => {
-      const dependencyRun = store.getWorkflowStepRun(run.id, dependencyId);
-      const dependencyStep = byId.get(dependencyId);
-      if (dependencyRun?.status === "succeeded")
-        return false;
-      return !dependencyStep?.continueOnFailure;
-    });
-    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
-        });
+  try {
+    for (const step of ordered) {
+      if (store.isWorkflowRunTerminal(run.id)) {
+        terminalStatus = store.requireWorkflowRun(run.id).status;
+        blockingError = "workflow run was cancelled";
+        break;
+      }
+      const pendingTimeout = opts.signal?.aborted ? opts.signalTimeoutMessage?.() : undefined;
+      if (pendingTimeout) {
+        terminalStatus = "timed_out";
+        blockingError = pendingTimeout;
+        break;
+      }
+      const existing = store.getWorkflowStepRun(run.id, step.id);
+      if (existing?.status === "succeeded" || existing?.status === "skipped" || existing?.status === "cancelled")
+        continue;
+      const blockedBy = (step.dependsOn ?? []).find((dependencyId) => {
+        const dependencyRun = store.getWorkflowStepRun(run.id, dependencyId);
+        const dependencyStep = byId.get(dependencyId);
+        if (dependencyRun?.status === "succeeded")
+          return false;
+        return !dependencyStep?.continueOnFailure;
+      });
+      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";
         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";
-      continue;
-    }
-    opts.beforePersist?.();
-    const startedStep = store.startWorkflowStepRun(run.id, step.id, { daemonLeaseId: opts.daemonLeaseId });
-    if (startedStep.status !== "running") {
-      terminalStatus = "failed";
-      blockingError = `step ${step.id} could not start because workflow is no longer running`;
-      break;
-    }
-    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();
-    if (opts.signal?.aborted)
-      controller.abort();
-    opts.signal?.addEventListener("abort", externalAbort, { once: true });
-    const cancelTimer = setInterval(() => {
-      if (store.getWorkflowRun(run.id)?.status === "cancelled")
+      opts.beforePersist?.();
+      const startedStep = store.startWorkflowStepRun(run.id, step.id, { daemonLeaseId: opts.daemonLeaseId });
+      if (startedStep.status !== "running") {
+        terminalStatus = "failed";
+        blockingError = `step ${step.id} could not start because workflow is no longer running`;
+        break;
+      }
+      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();
+      if (opts.signal?.aborted)
         controller.abort();
-    }, opts.cancelPollMs ?? 500);
-    cancelTimer.unref();
-    try {
-      if (step.goal) {
-        result = await runGoal(store, step.goal, {
-          ...opts,
-          model: opts.goalModel,
-          target: targetWithStepAccount(step),
-          signal: controller.signal,
-          context: stepContext
-        });
-      } else {
-        result = await executeTarget(targetWithStepAccount(step, opts.goalNodePrompt), executionMetadata(stepContext), {
-          ...opts,
-          machine: opts.machine ?? opts.loop?.machine,
-          signal: controller.signal,
-          onSpawn: (pid) => {
-            opts.beforePersist?.();
-            store.markWorkflowStepPid(run.id, step.id, pid, { daemonLeaseId: opts.daemonLeaseId });
-            opts.onSpawn?.(pid);
-          }
+      opts.signal?.addEventListener("abort", externalAbort, { once: true });
+      const cancelTimer = setInterval(() => {
+        if (store.getWorkflowRun(run.id)?.status === "cancelled")
+          controller.abort();
+      }, opts.cancelPollMs ?? 500);
+      cancelTimer.unref();
+      try {
+        if (step.goal) {
+          result = await runGoal(store, step.goal, {
+            ...opts,
+            model: opts.goalModel,
+            target: targetWithStepAccount(step),
+            signal: controller.signal,
+            context: stepContext
+          });
+        } else {
+          result = await executeTarget(targetWithStepAccount(step, opts.goalNodePrompt), executionMetadata(stepContext), {
+            ...opts,
+            machine: opts.machine ?? opts.loop?.machine,
+            signal: controller.signal,
+            onAgentProgress: (progress) => {
+              const stdout = JSON.stringify({ agentProgress: progress }, null, 2);
+              opts.beforePersist?.();
+              store.recordWorkflowStepProgress(run.id, step.id, {
+                stdout,
+                payload: progress
+              }, {
+                daemonLeaseId: opts.daemonLeaseId
+              });
+              opts.onAgentProgress?.(progress);
+            },
+            onSpawn: (pid) => {
+              opts.beforePersist?.();
+              store.markWorkflowStepPid(run.id, step.id, pid, { daemonLeaseId: opts.daemonLeaseId });
+              opts.onSpawn?.(pid);
+            }
+          });
+        }
+      } catch (error) {
+        const finishedAt2 = nowIso();
+        result = {
+          status: "failed",
+          stdout: "",
+          stderr: "",
+          error: error instanceof Error ? error.message : String(error),
+          startedAt: startedStep.startedAt ?? finishedAt2,
+          finishedAt: finishedAt2,
+          durationMs: new Date(finishedAt2).getTime() - new Date(startedStep.startedAt ?? finishedAt2).getTime()
+        };
+      } finally {
+        clearInterval(cancelTimer);
+        opts.signal?.removeEventListener("abort", externalAbort);
+      }
+      const timeoutMessage = opts.signal?.aborted ? opts.signalTimeoutMessage?.() : undefined;
+      if (timeoutMessage && result.status === "failed") {
+        result = { ...result, status: "timed_out", error: timeoutMessage };
+      }
+      if (store.isWorkflowRunTerminal(run.id)) {
+        terminalStatus = store.requireWorkflowRun(run.id).status;
+        blockingError = "workflow run was cancelled";
+        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;
       }
-    } catch (error) {
-      const finishedAt2 = nowIso();
-      result = {
-        status: "failed",
-        stdout: "",
-        stderr: "",
-        error: error instanceof Error ? error.message : String(error),
-        startedAt: startedStep.startedAt ?? finishedAt2,
-        finishedAt: finishedAt2,
-        durationMs: new Date(finishedAt2).getTime() - new Date(startedStep.startedAt ?? finishedAt2).getTime()
-      };
-    } finally {
-      clearInterval(cancelTimer);
-      opts.signal?.removeEventListener("abort", externalAbort);
-    }
-    const timeoutMessage = opts.signal?.aborted ? opts.signalTimeoutMessage?.() : undefined;
-    if (timeoutMessage && result.status === "failed") {
-      result = { ...result, status: "timed_out", error: timeoutMessage };
-    }
-    if (store.isWorkflowRunTerminal(run.id)) {
-      terminalStatus = store.requireWorkflowRun(run.id).status;
-      blockingError = "workflow run was cancelled";
-      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",
+        status: result.status,
         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}`
+        error: result.error
       }, {
         daemonLeaseId: opts.daemonLeaseId
       });
-      continue;
+      if (result.status !== "succeeded" && !step.continueOnFailure) {
+        terminalStatus = result.status;
+        blockingError = `step ${step.id} ${result.status}${result.error ? `: ${result.error}` : ""}`;
+        break;
+      }
     }
-    store.finalizeWorkflowStepRun(run.id, step.id, {
-      status: result.status,
-      finishedAt: result.finishedAt,
-      durationMs: result.durationMs,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exitCode: result.exitCode,
-      error: result.error
+    if (terminalStatus !== "succeeded") {
+      for (const step of ordered) {
+        const existing = store.getWorkflowStepRun(run.id, step.id);
+        if (existing?.status === "pending" || existing?.status === "running") {
+          store.skipWorkflowStepRun(run.id, step.id, blockingError ?? "workflow stopped before step could run", {
+            daemonLeaseId: opts.daemonLeaseId
+          });
+        }
+      }
+    }
+    const finishedAt = nowIso();
+    if (store.isWorkflowRunTerminal(run.id)) {
+      const terminalRun = store.requireWorkflowRun(run.id);
+      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, {
+      finishedAt,
+      durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
+      error: blockingError
     }, {
       daemonLeaseId: opts.daemonLeaseId
     });
-    if (result.status !== "succeeded" && !step.continueOnFailure) {
-      terminalStatus = result.status;
-      blockingError = `step ${step.id} ${result.status}${result.error ? `: ${result.error}` : ""}`;
-      break;
-    }
-  }
-  if (terminalStatus !== "succeeded") {
-    for (const step of ordered) {
-      const existing = store.getWorkflowStepRun(run.id, step.id);
-      if (existing?.status === "pending" || existing?.status === "running") {
-        store.skipWorkflowStepRun(run.id, step.id, blockingError ?? "workflow stopped before step could run", {
+    return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), blockingError);
+  } catch (error) {
+    if (opts.daemonLeaseId && error instanceof Error && error.message === "daemon lease lost")
+      throw error;
+    if (error instanceof Error && error.message.includes("workflow step is not claimable"))
+      throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    const finishedAt = nowIso();
+    try {
+      if (!store.isWorkflowRunTerminal(run.id)) {
+        store.finalizeWorkflowRun(run.id, "failed", {
+          finishedAt,
+          durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
+          error: message
+        }, {
           daemonLeaseId: opts.daemonLeaseId
         });
       }
-    }
-  }
-  const finishedAt = nowIso();
-  if (store.isWorkflowRunTerminal(run.id)) {
-    const terminalRun = store.requireWorkflowRun(run.id);
-    return workflowResult(terminalRun, terminalRun.status, startedAt, terminalRun.finishedAt ?? finishedAt, store.listWorkflowStepRuns(run.id), terminalRun.error ?? blockingError);
+    } catch {}
+    const current = store.getWorkflowRun(run.id) ?? run;
+    const resultStatus = current.status === "running" ? "failed" : current.status;
+    return workflowResult(current, resultStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), current.error ?? message);
   }
-  opts.beforePersist?.();
-  const finalRun = store.finalizeWorkflowRun(run.id, terminalStatus, {
-    finishedAt,
-    durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
-    error: blockingError
-  }, {
-    daemonLeaseId: opts.daemonLeaseId
-  });
-  return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), blockingError);
 }
 function preflightWorkflow(workflow, opts = {}) {
   return workflowExecutionOrder(workflow).map((step) => {
@@ -6935,7 +7102,7 @@ ${failure.evidence.stderr}` : undefined
 
 `);
   const dedupeKey = `openloops:${loop.id}:${failure.fingerprint}`;
-  const tags = ["bug", "openloops", "loop-health", failure.classification];
+  const tags = ["bug", "openloops", "loops", "loop-health", failure.classification];
   const priority = failure.classification === "auth" || failure.classification === "rate_limit" ? "high" : "medium";
   return {
     title,
@@ -6950,7 +7117,7 @@ ${failure.evidence.stderr}` : undefined
       comment: ["todos", "comment", "<task-id>", description]
     },
     futureNativeUpsert: {
-      command: "todos upsert",
+      command: "todos task upsert",
       fields: {
         title,
         description,
@@ -7309,6 +7476,25 @@ function advanceOptions(deps) {
     onRun: deps.onRun
   };
 }
+var TERMINAL_RUN_STATUSES2 = new Set([
+  "succeeded",
+  "failed",
+  "timed_out",
+  "abandoned",
+  "skipped"
+]);
+function repairWedgedTerminalSlot(deps, loop, scheduledFor, now) {
+  const existing = deps.store.getRunBySlot(loop.id, scheduledFor);
+  if (!existing || !TERMINAL_RUN_STATUSES2.has(existing.status))
+    return;
+  try {
+    advanceLoop(deps.store, loop, existing, new Date(existing.finishedAt ?? now), existing.status === "succeeded", advanceOptions(deps));
+  } catch (error) {
+    if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+      return;
+    throw error;
+  }
+}
 async function runSlot(deps, loop, scheduledFor) {
   const now = deps.now?.() ?? new Date;
   deps.beforeRun?.(loop, scheduledFor);
@@ -7335,8 +7521,10 @@ async function runSlot(deps, loop, scheduledFor) {
       return;
     throw error;
   }
-  if (!claim)
+  if (!claim) {
+    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
     return;
+  }
   deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
   deps.onRun?.(claim.run);
   const finalRun = await executeClaimedRun({
@@ -7382,8 +7570,10 @@ function claimSlot(deps, loop, scheduledFor) {
       return;
     throw error;
   }
-  if (!claim)
+  if (!claim) {
+    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
     return;
+  }
   deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
   deps.onRun?.(claim.run);
   return claim;
@@ -7664,10 +7854,7 @@ async function stopDaemon(opts = {}) {
   const store = new Store(join5(dirname4(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 };
-    }
+    const leaseVerified = Boolean(lease && lease.pid === state.pid && new Date(lease.expiresAt).getTime() > Date.now());
     try {
       process.kill(state.pid, "SIGTERM");
     } catch {
@@ -7687,11 +7874,14 @@ async function stopDaemon(opts = {}) {
     } catch {}
     await sleep2(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: sleep2,
-      graceMs: opts.reapGraceMs
-    });
+    let reapedPgids = [];
+    if (leaseVerified && lease) {
+      const ownedRuns = store.listRuns({ status: "running", limit: 1000 }).filter((run) => run.claimedBy !== undefined && run.claimedBy.endsWith(`:${lease.id}`));
+      reapedPgids = await reapProcessGroups(ownedRuns.map(toReapableProcess), {
+        sleep: sleep2,
+        graceMs: opts.reapGraceMs
+      });
+    }
     return { wasRunning: true, stopped: !isAlive(state.pid, record?.startedAt), forced: true, pid: state.pid, reapedPgids };
   } finally {
     store.close();
@@ -7879,7 +8069,14 @@ async function runDaemon(opts = {}) {
       try {
         const liveInlineOwner = (run) => {
           const ownerPid = inlineRunnerOwnerPid(run.claimedBy);
-          return ownerPid !== undefined && isAlive(ownerPid);
+          if (ownerPid === undefined || !isAlive(ownerPid))
+            return false;
+          const ownerStartMs = processStartTimeMs(ownerPid);
+          const runStartMs = run.startedAt ? Date.parse(run.startedAt) : Number.NaN;
+          if (ownerStartMs !== undefined && Number.isFinite(runStartMs) && ownerStartMs > runStartMs + START_TIME_TOLERANCE_MS) {
+            return false;
+          }
+          return true;
         };
         const staleCandidates = store.listRuns({ status: "running", limit: 1000 }).filter((run) => run.leaseExpiresAt !== undefined && new Date(run.leaseExpiresAt).getTime() <= Date.now());
         const startup = claimDueRuns({ store, runnerId, daemonLeaseId: leaseId, maxClaims: 0 });
@@ -9164,6 +9361,9 @@ function roleFragment(role, flow) {
 function goalHeaderFragment(goal, role, flow) {
   return [`/goal ${goal}`, "", roleFragment(role, flow)];
 }
+function boundedStepHeaderFragment(objective, role, flow) {
+  return [`Objective: ${objective}`, "", roleFragment(role, flow)];
+}
 function adversarialReviewFragment(inspect, focus) {
   return `Use fresh context. Inspect ${inspect}. Act as an adversarial reviewer focused on ${focus}.`;
 }
@@ -9815,6 +10015,28 @@ function importCustomLoopTemplate(file, reservedKeys, opts = {}) {
 function compactJson(value) {
   return JSON.stringify(value);
 }
+function prReviewRoutingContext(input) {
+  return input.prReviewRouting?.required ? input.prReviewRouting : undefined;
+}
+function prReviewFollowUpFragment(input) {
+  const routing = prReviewRoutingContext(input);
+  const author = routing?.author?.trim();
+  const reviewers = routing?.reviewers?.map((reviewer) => reviewer.trim()).filter(Boolean) ?? [];
+  const evidenceLines = [
+    author ? `- Source PR author evidence: GitHub author is ${author}` : undefined,
+    reviewers.length ? `- Source PR reviewer evidence: GitHub reviewer pool: ${reviewers.join(", ")}` : undefined,
+    routing?.selectedReviewer ? `- Selected non-author reviewer: ${routing.selectedReviewer}` : undefined
+  ].filter(Boolean);
+  return [
+    "PR-derived follow-up todos: If any lifecycle step creates a follow-up todo that references a GitHub PR, PR approval, PR review, or PR merge work, the todo description must include parser-compatible routing evidence so downstream drains can select a non-author reviewer.",
+    ...evidenceLines,
+    "Copy these exact evidence lines from the source task when present, or derive them from the referenced PR before creating the follow-up todo:",
+    "GitHub author is <login>",
+    "GitHub reviewer pool: <login>, <login>",
+    "When the source PR author or reviewer pool cannot be determined, do not create an auto-routable PR-derived follow-up todo; comment the source task with the blocker instead."
+  ].join(`
+`);
+}
 function taskLabel(input) {
   const head = input.taskTitle?.trim() || input.taskId;
   return head.length > 160 ? `${head.slice(0, 157)}...` : head;
@@ -10270,6 +10492,7 @@ function renderTaskLifecycleWorkflow(input) {
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
     todosProjectPath,
+    prReviewRouting: prReviewRoutingContext(input),
     worktree: worktreeContextFragment(plan)
   };
   const handoffArtifactPath = prHandoffArtifactPath(plan, input.taskId);
@@ -10287,6 +10510,7 @@ function renderTaskLifecycleWorkflow(input) {
     ]),
     NO_TMUX_DISPATCH_FRAGMENT,
     "Preserve unrelated user changes and keep scope tied to the task acceptance criteria.",
+    prReviewFollowUpFragment(input),
     "",
     `Task context JSON: ${compactJson(taskContext)}`,
     prHandoffGuidance
@@ -10296,7 +10520,7 @@ function renderTaskLifecycleWorkflow(input) {
   const blockTaskCommand = `todos --project ${todosProjectPath} update ${input.taskId} --status blocked`;
   const gateStopFragment = (stage, stops) => `The deterministic ${stage} gate will stop ${stops} unless the latest ${stage} marker is the exact go marker and the task has no blocked/completed/done/cancelled/failed/archived/no-auto/manual/approval-required state.`;
   const triagePrompt = [
-    ...goalHeaderFragment(`Triage todos task ${input.taskId} for safe automated execution.`, "triage", "lifecycle"),
+    ...boundedStepHeaderFragment(`Triage todos task ${input.taskId} for safe automated execution.`, "triage", "lifecycle"),
     shared,
     "Decide whether the task is eligible for loop execution. Check status, dependencies, duplicate tasks, no-auto/manual/approval metadata, project path, acceptance criteria, and whether the requested work should be split before implementation.",
     "Do not implement repo changes in this step.",
@@ -10308,7 +10532,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].join(`
 `);
   const plannerPrompt = [
-    ...goalHeaderFragment(`Plan todos task ${input.taskId} before implementation.`, "planner", "lifecycle"),
+    ...boundedStepHeaderFragment(`Plan todos task ${input.taskId} before implementation.`, "planner", "lifecycle"),
     shared,
     "Read the triage comment and current task details.",
     `If the task is ready for implementation, add a task comment whose first line is exactly: ${gateMarker("planner", "go")}`,
@@ -10319,7 +10543,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].join(`
 `);
   const workerPrompt = [
-    ...goalHeaderFragment(`Complete todos task ${input.taskId} according to the planner evidence.`, "worker", "lifecycle"),
+    ...boundedStepHeaderFragment(`Complete todos task ${input.taskId} according to the planner evidence.`, "worker", "lifecycle"),
     shared,
     todosStartLine(todosProjectPath, input.taskId),
     "Read the triage and planner comments first. Implement only the scoped task, run focused validation, and record changed files, commits, evidence, blockers, and residual risks.",
@@ -10328,7 +10552,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].filter(Boolean).join(`
 `);
   const verifierPrompt = [
-    ...goalHeaderFragment(`Verify todos task ${input.taskId} after the full lifecycle worker step.`, "verifier", "lifecycle"),
+    ...boundedStepHeaderFragment(`Verify todos task ${input.taskId} after the full lifecycle worker step.`, "verifier", "lifecycle"),
     shared,
     todosVerificationLine(todosProjectPath, input.taskId),
     todosDoneLine(todosProjectPath, input.taskId),
@@ -11034,7 +11258,7 @@ function taskRouteEligibility(data, metadata) {
   const records = taskEventRecords(data, metadata);
   const automation = automationRecords(data, metadata);
   const tags = taskEventTags(records);
-  const hasRouteOptIn = tags.includes("auto:route") || hasTruthyField(records, ["route_enabled", "routeEnabled", "automation_allowed", "automationAllowed"]) || hasTruthyField(automation, ["allowed"]);
+  const hasRouteOptIn = tags.includes("auto:route") || tags.includes("route:enabled") || hasTruthyField(records, ["route_enabled", "routeEnabled", "automation_allowed", "automationAllowed"]) || hasTruthyField(automation, ["allowed"]);
   if (!hasRouteOptIn)
     return { eligible: false, reason: "missing explicit route opt-in", tags };
   const status = taskEventField(data, ["status", "task_status", "taskStatus"])?.toLowerCase();
@@ -11472,12 +11696,30 @@ function routeEvidenceText(records) {
   const values = [];
   for (const record of records) {
     for (const field of fields)
-      values.push(...recordFieldValues(record, field));
+      values.push(...routeTextFieldValues(record, field));
     values.push(...tagsFromValue2(record.tags ?? record.task_tags ?? record.taskTags));
   }
   return values.join(`
 `);
 }
+function textValuesFromUnknown(value) {
+  if (Array.isArray(value))
+    return value.flatMap((entry) => textValuesFromUnknown(entry));
+  if (typeof value === "string" && value.trim())
+    return [value.trim()];
+  if (typeof value === "number" || typeof value === "boolean")
+    return [String(value)];
+  return [];
+}
+function routeTextFieldValues(record, field) {
+  const expected = canonicalRouteField(field);
+  const values = [];
+  for (const [key, value] of Object.entries(record)) {
+    if (canonicalRouteField(key) === expected)
+      values.push(...textValuesFromUnknown(value));
+  }
+  return values;
+}
 function authorFromPrText(text) {
   const patterns = [
     /\bauthor\s+(?:is\s+also|is|=|:)\s+@?([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))/i,
@@ -11492,6 +11734,18 @@ function authorFromPrText(text) {
   }
   return;
 }
+function reviewersFromPrText(text) {
+  const reviewers = [];
+  const patterns = [
+    /\bgithub\s+reviewer\s+pool\s*(?:is|=|:)\s*([^\r\n]+)/gi,
+    /\bgithub\s+reviewers?\s*(?:are|is|=|:)\s*([^\r\n]+)/gi
+  ];
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern))
+      reviewers.push(...splitList(match[1]) ?? []);
+  }
+  return githubLogins(reviewers);
+}
 function prReviewRoutingDecision(data, metadata, opts) {
   const records = [...taskEventRecords(data, metadata), ...automationRecords(data, metadata)];
   const text = routeEvidenceText(records);
@@ -11517,7 +11771,8 @@ function prReviewRoutingDecision(data, metadata, opts) {
     opts.githubReviewer,
     ...splitList(opts.githubReviewerPool) ?? [],
     ...PR_REVIEWER_FIELDS.flatMap((field) => routeFieldValues(records, field)),
-    ...PR_REVIEWER_POOL_FIELDS.flatMap((field) => routeFieldValues(records, field))
+    ...PR_REVIEWER_POOL_FIELDS.flatMap((field) => routeFieldValues(records, field)),
+    ...reviewersFromPrText(text)
   ]);
   const selectedReviewer = author ? reviewers.find((reviewer) => reviewer.toLowerCase() !== author.toLowerCase()) : undefined;
   if (!author) {
@@ -11905,7 +12160,16 @@ function routeTodosTaskEvent(event, opts) {
   }
   const taskTitle = taskEventField(data, ["title", "task_title", "taskTitle"]);
   const taskDescription = taskEventField(data, ["description", "body"]);
-  const dataProjectPath = taskEventField(data, ["working_dir", "workingDir", "project_path", "projectPath", "cwd"]);
+  const sourceTodosProjectPath = opts.sourceTodosProjectPath?.trim();
+  const dataProjectPath = taskEventField(data, [
+    "route_project_path",
+    "routeProjectPath",
+    "project_path",
+    "projectPath",
+    "working_dir",
+    "workingDir",
+    "cwd"
+  ]);
   const metadataProjectPath = taskEventField(metadata, [
     "working_dir",
     "workingDir",
@@ -11918,7 +12182,8 @@ function routeTodosTaskEvent(event, opts) {
   const routeProjectPath = normalizeRoutePath(projectPath) ?? resolve7(projectPath);
   const projectGroup = routeProjectGroup(opts.projectGroup, data, metadata);
   const throttleLimits = routeThrottleLimitsFromOpts(opts);
-  const idempotencyKey = `todos-task:${taskId}`;
+  const sourceProjectIdempotencyPrefix = sourceTodosProjectPath ? normalizeRoutePath(sourceTodosProjectPath) ?? resolve7(sourceTodosProjectPath) : undefined;
+  const idempotencyKey = sourceProjectIdempotencyPrefix ? `todos-task:${sourceProjectIdempotencyPrefix}:${taskId}` : `todos-task:${taskId}`;
   const idempotencySuffix = stableSuffix(idempotencyKey);
   const namePrefix = opts.namePrefix ?? "event:todos-task";
   const workflowName = `${namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
@@ -11992,9 +12257,10 @@ function routeTodosTaskEvent(event, opts) {
     worktreeRoot: opts.worktreeRoot,
     worktreeBranchPrefix: opts.worktreeBranchPrefix ?? "openloops",
     prHandoff: templateId === TASK_LIFECYCLE_TEMPLATE_ID ? Boolean(opts.prHandoff) : false,
+    prReviewRouting: prReviewRouting.required ? prReviewRouting : undefined,
     eventId: event.id,
     eventType: event.type,
-    todosProjectPath: opts.todosProject
+    todosProjectPath: sourceTodosProjectPath || opts.todosProject
   };
   const workflowContext = {
     name: workflowName,
@@ -12262,8 +12528,8 @@ function taskField(task, keys) {
   }
   return;
 }
-function taskListId(task) {
-  return taskField(task, ["task_list_id", "taskListId"]) ?? stringField2(task.task_list?.id);
+function taskRoutePathFromRegistry(sourceProjectPath) {
+  return normalizeRoutePath(sourceProjectPath) ?? resolve8(sourceProjectPath);
 }
 function taskProjectId(task) {
   return taskField(task, ["project_id", "projectId"]);
@@ -12277,12 +12543,28 @@ function taskProjectPath(task) {
   const metadata = objectField2(task.metadata) ?? {};
   return taskField(task, ["project_path", "projectPath"]) ?? taskEventField(metadata, ["project_path", "projectPath", "project_canonical_path"]) ?? taskDescriptionProjectPath(task) ?? taskField(task, ["working_dir", "workingDir", "cwd"]) ?? taskEventField(metadata, ["working_dir", "workingDir", "cwd"]);
 }
-function taskDrainEvent(task) {
+function taskListValues(task) {
+  const taskList = objectField2(task.task_list);
+  return [
+    taskField(task, ["task_list_id", "taskListId"]),
+    stringField2(task.task_list?.id),
+    stringField2(task.task_list?.slug),
+    stringField2(taskList?.name),
+    taskField(task, ["task_list", "taskList"])
+  ].filter((value) => Boolean(value));
+}
+function taskDrainEvent(task, sourceProjectPath) {
   const taskId = taskField(task, ["id", "task_id", "taskId"]);
   if (!taskId)
     throw new Error("todos ready returned a task without an id");
-  const metadata = objectField2(task.metadata) ?? {};
+  const metadata = { ...objectField2(task.metadata) ?? {} };
   const workingDir = taskProjectPath(task);
+  const routeWorkingDir = taskField(task, ["project_path", "projectPath"]) ?? workingDir;
+  const sourceProject = sourceProjectPath?.trim();
+  if (!sourceProject) {
+    delete metadata.source_project_path;
+    delete metadata.sourceProjectPath;
+  }
   const data = {
     ...task,
     id: taskId,
@@ -12292,10 +12574,23 @@ function taskDrainEvent(task) {
     tags: tagsFromValue2(task.tags),
     metadata
   };
+  if (!sourceProject) {
+    delete data.source_project_path;
+    delete data.sourceProjectPath;
+  }
   if (workingDir) {
-    data.working_dir = workingDir;
-    data.project_path = taskField(task, ["project_path", "projectPath"]) ?? workingDir;
-    data.cwd = taskField(task, ["cwd"]) ?? workingDir;
+    data.working_dir = routeWorkingDir;
+    data.project_path = routeWorkingDir;
+    data.cwd = taskField(task, ["cwd"]) ?? routeWorkingDir;
+  }
+  if (sourceProject) {
+    data.source_project_path = sourceProject;
+    if (!data.project_path)
+      data.project_path = sourceProject;
+    data.route_project_path = data.project_path;
+    data.routeProjectPath = data.project_path;
+    metadata.route_project_path = data.project_path;
+    metadata.routeProjectPath = data.project_path;
   }
   const time = new Date().toISOString();
   return {
@@ -12309,6 +12604,7 @@ function taskDrainEvent(task) {
     schemaVersion: "1.0",
     metadata: {
       ...metadata,
+      ...sourceProject ? { source_project_path: sourceProject } : {},
       ...workingDir ? { working_dir: workingDir, project_path: data.project_path, cwd: data.cwd } : {},
       drained_by: "@hasna/loops",
       drained_from: "todos ready"
@@ -12335,26 +12631,78 @@ function compactDrainResult(result) {
     workflowName: stringField2(workflow?.name),
     providerRouting,
     requeue,
-    queuedAtSource: value.queuedAtSource
+    queuedAtSource: value.queuedAtSource,
+    fatal: value.fatal === true ? true : undefined
   };
 }
-function loadReadyTodosTasks(opts, scanLimit) {
-  const todosProject = opts.todosProject ?? defaultLoopsProject();
-  const args = ["--project", todosProject, "--json", "ready", "--limit", String(scanLimit)];
-  const result = runLocalCommandWithStdoutFile("todos", args, { timeoutMs: 60000, maxBuffer: 64 * 1024 * 1024 });
-  if (!result.ok)
-    throw new Error(result.stderr || result.error || "todos ready failed");
-  let parsed;
+function parseTodosReadyJson(stdout) {
+  try {
+    return JSON.parse(stdout || "[]");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`failed to parse todos ready --json output (${stdout.length} bytes): ${message}`);
+  }
+}
+function parseTodoProjectsJson(stdout) {
   try {
-    parsed = JSON.parse(result.stdout || "[]");
+    return JSON.parse(stdout || "[]");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`failed to parse todos ready --json output (${result.stdout.length} bytes): ${message}`);
+    throw new Error(`failed to parse todos projects --json output (${stdout.length} bytes): ${message}`);
   }
+}
+function loadTodoProjectPathsFromRegistry(opts) {
+  const result = runLocalCommand("todos", ["projects", "--json"], { timeoutMs: 60000 });
+  if (!result.ok)
+    throw new Error(result.stderr || result.error || "todos projects failed");
+  const payload = parseTodoProjectsJson(result.stdout);
+  const projectsPayload = Array.isArray(payload) ? payload : objectField2(payload)?.projects;
+  if (!Array.isArray(projectsPayload))
+    throw new Error("todos projects --json returned a non-array value");
+  const includeFilters = listFromRepeatedOpts(opts.todosProjectInclude)?.map((entry) => normalizeRoutePath(entry) ?? resolve8(entry)) ?? [];
+  const includesPrefix = normalizeRoutePath(opts.projectPathPrefix) ?? (opts.projectPathPrefix ? resolve8(opts.projectPathPrefix) : undefined);
+  const fromProjects = projectsPayload.map((entry) => objectField2(entry)).filter((project) => Boolean(project)).map((project) => {
+    const path = stringField2(project.path) ?? stringField2(project.projectPath) ?? stringField2(project.project_path) ?? stringField2(project.dir) ?? stringField2(project.root) ?? stringField2(project.cwd);
+    if (!path)
+      return;
+    return { path };
+  }).filter((project) => Boolean(project));
+  const paths = fromProjects.map((project) => project.path).filter(Boolean).filter((path) => {
+    const normalizedPath = normalizeRoutePath(path) ?? resolve8(path);
+    if (includesPrefix && !(normalizedPath === includesPrefix || normalizedPath.startsWith(`${includesPrefix}/`)))
+      return false;
+    if (includeFilters.length === 0)
+      return true;
+    return includeFilters.some((prefix) => normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`));
+  });
+  return [...new Set(paths)];
+}
+function loadReadyTodosTasksForProject(projectPath, scanLimit) {
+  const args = ["--project", projectPath, "--json", "ready", "--limit", String(scanLimit)];
+  const result = runLocalCommandWithStdoutFile("todos", args, { timeoutMs: 60000, maxBuffer: 64 * 1024 * 1024 });
+  if (!result.ok)
+    throw new Error(result.stderr || result.error || "todos ready failed");
+  const parsed = parseTodosReadyJson(result.stdout);
   if (!Array.isArray(parsed))
     throw new Error("todos ready --json returned a non-array value");
   return parsed;
 }
+function loadReadyTodosTasks(opts, scanLimit) {
+  if (!opts.todosProjectsFromRegistry) {
+    const todosProject = opts.todosProject ?? defaultLoopsProject();
+    return loadReadyTodosTasksForProject(todosProject, scanLimit);
+  }
+  const projectPaths = loadTodoProjectPathsFromRegistry(opts);
+  const ready = projectPaths.flatMap((projectPath) => loadReadyTodosTasksForProject(projectPath, scanLimit).map((task) => {
+    const sourceProject = projectPath;
+    return {
+      ...task,
+      source_project_path: sourceProject,
+      project_path: taskRoutePathFromRegistry(sourceProject)
+    };
+  }));
+  return ready;
+}
 function resolveTaskListFilter(todosProject, filter) {
   const wanted = filter?.trim();
   if (!wanted)
@@ -12369,7 +12717,7 @@ function resolveTaskListFilter(todosProject, filter) {
 function taskMatchesDrainFilters(task, filters) {
   if (filters.projectId && taskProjectId(task) !== filters.projectId)
     return false;
-  if (filters.taskListId && taskListId(task) !== filters.taskListId)
+  if (filters.taskList && !taskListValues(task).includes(filters.taskList))
     return false;
   if (filters.projectPathPrefix) {
     const path = taskProjectPath(task);
@@ -12407,14 +12755,14 @@ function skippedDrainTask(task, event, reason, extra = {}) {
 function isSkippableDrainRouteError(message) {
   return message.startsWith("worktreeMode=required but projectPath is not an existing git repository:");
 }
-function markInvalidDrainTaskNonRouteable(todosProject, task, reason) {
+function markInvalidDrainTaskNonRouteable(sourceTodosProject, task, reason) {
   const taskId = taskField(task, ["id", "task_id", "taskId"]);
   if (!taskId)
     return { attempted: false, reason: "task id missing" };
   const comment = `OpenLoops route blocked for task ${taskId}: ${reason}. Added no-auto and removed auto:route so route drains do not repeatedly route this task until its project path is fixed.`;
-  const commentResult = runLocalCommand("todos", ["--project", todosProject, "comment", taskId, comment], { timeoutMs: 30000 });
-  const tagResult = runLocalCommand("todos", ["--project", todosProject, "tag", taskId, "no-auto"], { timeoutMs: 30000 });
-  const untagResult = runLocalCommand("todos", ["--project", todosProject, "untag", taskId, "auto:route"], { timeoutMs: 30000 });
+  const commentResult = runLocalCommand("todos", ["--project", sourceTodosProject, "comment", taskId, comment], { timeoutMs: 30000 });
+  const tagResult = runLocalCommand("todos", ["--project", sourceTodosProject, "tag", taskId, "no-auto"], { timeoutMs: 30000 });
+  const untagResult = runLocalCommand("todos", ["--project", sourceTodosProject, "untag", taskId, "auto:route"], { timeoutMs: 30000 });
   const ok = commentResult.ok && tagResult.ok && untagResult.ok;
   return {
     ok,
@@ -12430,7 +12778,7 @@ function drainTodosTaskRoutes(opts) {
   const maxDispatch = positiveInteger(opts.maxDispatch ?? "1", "--max-dispatch") ?? 1;
   const todosProject = opts.todosProject ?? defaultLoopsProject();
   const requiredTags = splitList(opts.tags ?? opts.tag) ?? [];
-  const taskListFilter = resolveTaskListFilter(todosProject, opts.taskList);
+  const taskListFilter = opts.todosProjectsFromRegistry ? opts.taskList?.trim() : resolveTaskListFilter(todosProject, opts.taskList);
   const candidateLimit = positiveInteger(opts.limit ?? "50", "--limit") ?? 50;
   const hasPostFilters = Boolean(opts.todosProjectId || taskListFilter || opts.projectPathPrefix || requiredTags.length);
   const defaultScanLimit = hasPostFilters ? Math.max(candidateLimit, 500) : candidateLimit;
@@ -12438,7 +12786,7 @@ function drainTodosTaskRoutes(opts) {
   const ready = loadReadyTodosTasks(opts, scanLimit);
   const filteredCandidates = ready.filter((task) => taskMatchesDrainFilters(task, {
     projectId: opts.todosProjectId,
-    taskListId: taskListFilter,
+    taskList: taskListFilter,
     projectPathPrefix: opts.projectPathPrefix,
     tags: requiredTags
   }));
@@ -12451,14 +12799,21 @@ function drainTodosTaskRoutes(opts) {
     let event;
     let result;
     try {
-      event = taskDrainEvent(task);
-      result = routeTodosTaskEvent(event, opts);
+      const sourceProject = opts.todosProjectsFromRegistry ? taskField(task, ["source_project_path", "sourceProjectPath"]) : undefined;
+      event = taskDrainEvent(task, sourceProject);
+      result = routeTodosTaskEvent(event, {
+        ...opts,
+        ...sourceProject ? { sourceTodosProjectPath: sourceProject } : {}
+      });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (!isSkippableDrainRouteError(message))
-        throw error;
-      const sourceTaskUpdate = opts.dryRun ? { attempted: false, reason: "dry-run" } : markInvalidDrainTaskNonRouteable(todosProject, task, message);
-      result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { sourceTaskUpdate });
+      if (isSkippableDrainRouteError(message)) {
+        const sourceTaskProject = opts.todosProjectsFromRegistry ? taskField(task, ["source_project_path", "sourceProjectPath"]) ?? todosProject : todosProject;
+        const sourceTaskUpdate = opts.dryRun ? { attempted: false, reason: "dry-run" } : markInvalidDrainTaskNonRouteable(sourceTaskProject, task, message);
+        result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { sourceTaskUpdate });
+      } else {
+        result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { fatal: true });
+      }
     }
     results.push(result);
     if (result.kind === "created")
@@ -12485,6 +12840,7 @@ function drainTodosTaskRoutes(opts) {
     deduped: results.filter((result) => result.kind === "deduped").length,
     throttled: results.filter((result) => result.kind === "throttled").length,
     skipped: results.filter((result) => result.kind === "skipped").length,
+    fatal: results.filter((result) => result.value.fatal === true).length,
     maxDispatch,
     source: "todos ready",
     dryRun: Boolean(opts.dryRun),
@@ -12512,6 +12868,7 @@ function drainTodosTaskRoutes(opts) {
     deduped: report.deduped,
     throttled: report.throttled,
     skipped: report.skipped,
+    fatal: report.fatal,
     maxDispatch: report.maxDispatch,
     source: report.source,
     dryRun: report.dryRun,
@@ -12520,7 +12877,7 @@ function drainTodosTaskRoutes(opts) {
   } : { ...report, evidencePath };
   return {
     value,
-    human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped}`
+    human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped} fatal=${report.fatal}`
   };
 }
 // src/lib/route/route-tasks.ts
@@ -12797,6 +13154,19 @@ var EVENT_INPUT_OPTION_SPECS = [
   { flags: "--event-json <json>", key: "eventJson", kind: "value", description: "read event envelope JSON from this string instead of stdin/HASNA_EVENT_JSON" }
 ];
 var DRAIN_FILTER_OPTION_SPECS = [
+  {
+    flags: "--todos-projects-from-registry",
+    key: "todosProjectsFromRegistry",
+    kind: "boolean",
+    description: "scan registered todos projects from `todos projects --json` instead of one --todos-project"
+  },
+  {
+    flags: "--todos-project-include <path>",
+    key: "todosProjectInclude",
+    kind: "repeat",
+    description: "include additional registered project path prefixes when scanning via --todos-projects-from-registry",
+    serializeValue: (opts) => listFromRepeatedOpts(opts.todosProjectInclude)
+  },
   { flags: "--todos-project-id <id>", key: "todosProjectId", kind: "value", description: "filter todos ready output to one todos project id" },
   { flags: "--task-list <id-or-slug>", key: "taskList", kind: "value", description: "filter ready tasks to one task-list id, slug, or name" },
   { flags: "--project-path-prefix <path>", key: "projectPathPrefix", kind: "value", description: "filter ready tasks to a project/repo path prefix" },
@@ -13721,6 +14091,11 @@ function handleRouteDrain(kind, opts) {
     throw new ValidationError("route drain currently supports kind todos-task");
   const result = drainTodosTaskRoutes(opts);
   print(result.value, result.human);
+  const fatal = Number(result.value.fatal ?? 0);
+  if (fatal > 0) {
+    console.error(`route drain hit ${fatal} non-skippable task error(s); see evidence file`);
+    process.exitCode = 1;
+  }
 }
 addRouteEventOptions(routes.command("preview <kind>").description("(deprecated: use 'routes create <kind> --dry-run') preview a route-created workflow invocation without storing it")).action(runAction(async (kind, opts) => handleRouteEvent(kind, { ...opts, dryRun: true })));
 addRouteEventOptions(routes.command("create <kind>").description("create a route workflow invocation and admit it when capacity allows"), { dryRunDescription: "preview the generated workflow invocation and loop without storing anything" }).action(runAction(async (kind, opts) => handleRouteEvent(kind, opts)));
@@ -13922,7 +14297,7 @@ workflows.command("runs [idOrName]").description("list workflow runs, optionally
   const store = new Store;
   try {
     const workflow = idOrName ? store.requireWorkflow(idOrName) : undefined;
-    const runs = store.listWorkflowRuns({ workflowId: workflow?.id, limit: Number(opts.limit) });
+    const runs = store.listWorkflowRuns({ workflowId: workflow?.id, limit: positiveInteger(opts.limit, "--limit") ?? 50 });
     if (isJson())
       print(runs.map(publicWorkflowRun));
     else {
@@ -13937,7 +14312,7 @@ workflows.command("runs [idOrName]").description("list workflow runs, optionally
 workflows.command("events <runId>").description("list step/lifecycle events for a workflow run").option("--limit <n>", "limit", "200").action(runAction((runId, opts) => {
   const store = new Store;
   try {
-    const runEvents = store.listWorkflowEvents(runId, Number(opts.limit));
+    const runEvents = store.listWorkflowEvents(runId, positiveInteger(opts.limit, "--limit") ?? 200);
     if (isJson())
       print(runEvents.map(publicWorkflowEvent));
     else {
@@ -14178,7 +14553,7 @@ program.command("runs [idOrName]").description("list recent runs, optionally for
   const store = new Store;
   try {
     const loop = idOrName ? store.requireLoop(idOrName) : undefined;
-    const runs = store.listRuns({ loopId: loop?.id, limit: Number(opts.limit) });
+    const runs = store.listRuns({ loopId: loop?.id, limit: positiveInteger(opts.limit, "--limit") ?? 50 });
     if (isJson())
       print(runs.map((run) => publicRun(run, opts.showOutput)));
     else {
@@ -14195,7 +14570,7 @@ program.command("runs [idOrName]").description("list recent runs, optionally for
 program.command("expectations [idOrName]").description("evaluate deterministic loop expectations without mutating external task systems").option("--limit <n>", "maximum loops to inspect when no loop is specified", "200").action(runAction((idOrName, opts) => {
   const store = new Store;
   try {
-    const loops = idOrName ? [store.requireLoop(idOrName)] : store.listLoops({ limit: Number(opts.limit) });
+    const loops = idOrName ? [store.requireLoop(idOrName)] : store.listLoops({ limit: positiveInteger(opts.limit, "--limit") ?? 200 });
     const values = loops.map((loop) => expectationForLoop(store, loop));
     if (isJson())
       console.log(JSON.stringify(idOrName ? values[0] : values, null, 2));
@@ -14233,7 +14608,7 @@ var health = program.command("health").description("summarize loop health and la
 health.command("route-tasks").description("upsert deduped todos tasks for failed loop health expectations").option("--project <path>", "todos project path", defaultLoopsProject()).option("--task-list <slug>", "todos task-list slug", "loop-error-self-heal").option("--limit <n>", "maximum loops to inspect", "200").option("--max-actions <n>", "maximum todos tasks to upsert", "5").option("--include-inactive", "also route stopped or expired loops").option("--auto-route", "opt routed tasks into task-created headless worker/verifier automation").option("--route-project-path <path>", "fallback project path for --auto-route when the failed loop has no cwd").option("--evidence-dir <path>", "write the route result JSON to this directory").option("--dry-run", "print intended task upserts without mutating todos").action(runAction((opts) => {
   const store = new Store;
   try {
-    const report = buildHealthReport(store, { limit: Number(opts.limit), includeInactive: Boolean(opts.includeInactive) });
+    const report = buildHealthReport(store, { limit: positiveInteger(opts.limit, "--limit") ?? 200, includeInactive: Boolean(opts.includeInactive) });
     const failures = report.expectations.filter((entry) => !entry.ok && entry.recommendedTask);
     const result = upsertRouteTasks({
       project: opts.project,
@@ -14246,7 +14621,7 @@ health.command("route-tasks").description("upsert deduped todos tasks for failed
         autoRoute: Boolean(opts.autoRoute),
         routeProjectPath: opts.routeProjectPath
       }),
-      maxActions: Number(opts.maxActions),
+      maxActions: positiveInteger(opts.maxActions, "--max-actions") ?? 5,
       dryRun: Boolean(opts.dryRun),
       autoRoute: Boolean(opts.autoRoute),
       routeProjectPath: opts.routeProjectPath,
@@ -14300,7 +14675,7 @@ hygiene.command("names").description("check or apply canonical machine-/repo-pre
       apply: false,
       includeStopped: Boolean(opts.includeStopped),
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit)
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000
     });
     let outputReport = report;
     const backupPath = opts.apply && report.changed > 0 ? backupLoopsDatabase("name-hygiene") : undefined;
@@ -14309,7 +14684,7 @@ hygiene.command("names").description("check or apply canonical machine-/repo-pre
         apply: true,
         includeStopped: Boolean(opts.includeStopped),
         includeInactive: Boolean(opts.includeInactive),
-        limit: Number(opts.limit)
+        limit: positiveInteger(opts.limit, "--limit") ?? 1000
       });
     } else if (opts.apply) {
       outputReport = { ...report, applied: true };
@@ -14336,7 +14711,7 @@ hygiene.command("duplicates").description("detect duplicate/overlapping loops wi
   try {
     const report = buildDuplicateOverlapReport(store, {
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit)
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000
     });
     if (isJson())
       console.log(JSON.stringify(report, null, 2));
@@ -14358,7 +14733,7 @@ hygiene.command("scripts").description("inventory loops still backed by local ~/
     const report = buildScriptInventoryReport(store, {
       scriptsDir: opts.scriptsDir,
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit)
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000
     });
     if (isJson())
       console.log(JSON.stringify(report, null, 2));
@@ -14380,7 +14755,7 @@ hygiene.command("route-tasks").description("upsert deduped todos tasks for hygie
     const route = buildHygieneRouteTasks(store, {
       checks,
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit),
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000,
       scriptsDir: opts.scriptsDir
     });
     const result = upsertRouteTasks({
@@ -14394,7 +14769,7 @@ hygiene.command("route-tasks").description("upsert deduped todos tasks for hygie
         autoRoute: Boolean(opts.autoRoute),
         routeProjectPath: opts.routeProjectPath
       }),
-      maxActions: Number(opts.maxActions),
+      maxActions: positiveInteger(opts.maxActions, "--max-actions") ?? 10,
       dryRun: Boolean(opts.dryRun),
       autoRoute: Boolean(opts.autoRoute),
       routeProjectPath: opts.routeProjectPath,
@@ -14434,7 +14809,7 @@ program.command("stop <idOrName>").description("stop a loop and clear its next s
 program.command("rename <idOrName> <newName>").description("rename a loop without changing its id, schedule, runs, or history").action(runAction((idOrName, newName) => {
   const store = new Store;
   try {
-    const loop = store.requireLoop(idOrName);
+    const loop = store.requireUniqueLoop(idOrName);
     const oldName = loop.name;
     const trimmed = String(newName).trim();
     if (!trimmed)
@@ -14471,10 +14846,17 @@ backup=${backupPath ?? "skipped (recent rename backup exists)"}`);
 function updateStatus(idOrName, status) {
   const store = new Store;
   try {
-    const loop = store.requireLoop(idOrName);
+    const loop = store.requireUniqueLoop(idOrName);
     if (loop.archivedAt)
       throw new Error(`loop is archived; run 'loops unarchive ${idOrName}' first`);
-    const updated = store.updateLoop(loop.id, { status, nextRunAt: status === "stopped" ? undefined : loop.nextRunAt });
+    let nextRunAt = loop.nextRunAt;
+    if (status === "stopped") {
+      nextRunAt = undefined;
+    } else if (status === "active" && !loop.nextRunAt) {
+      const now = new Date;
+      nextRunAt = computeNextAfter(loop.schedule, now, now);
+    }
+    const updated = store.updateLoop(loop.id, { status, nextRunAt });
     print(publicLoop(updated), `${updated.id} ${updated.status}`);
   } finally {
     store.close();
@@ -14483,7 +14865,7 @@ function updateStatus(idOrName, status) {
 program.command("remove <idOrName>").alias("rm").description("delete a loop and its run history").action(runAction((idOrName) => {
   const store = new Store;
   try {
-    const removed = store.deleteLoop(idOrName);
+    const removed = store.deleteLoop(store.requireUniqueLoop(idOrName).id);
     print({ removed }, removed ? "removed" : "not removed");
   } finally {
     store.close();
@@ -14510,7 +14892,7 @@ program.command("unarchive <idOrName>").alias("restore").description("restore an
 program.command("run-now <idOrName>").description("claim and execute one loop run immediately").option("--show-output", "show stdout/stderr").action(runAction(async (idOrName, opts) => {
   const store = new Store;
   try {
-    const loop = store.requireLoop(idOrName);
+    const loop = store.requireUniqueLoop(idOrName);
     if (loop.archivedAt)
       throw new Error(`loop is archived; run 'loops unarchive ${idOrName}' before running it`);
     const runnerId = `manual:${process.pid}`;
@@ -14690,15 +15072,16 @@ ${result.enableResults.map((item) => `${item.command} -> ${item.status === 0 ? "
 ${result.instructions.join(`
 `)}${enableText}`);
 }));
-daemon.command("logs").description("print the tail of the daemon log").option("-n, --lines <n>", "lines", "80").action(runAction((opts) => {
+daemon.command("logs").description("print the tail of the daemon log").option("-n, --lines <n>", "lines", "80").option("--tail <n>", "alias for --lines").action(runAction((opts) => {
   const path = daemonLogPath();
   if (!existsSync10(path)) {
     console.log("");
     return;
   }
+  const count = positiveInteger(opts.tail ?? opts.lines, opts.tail !== undefined ? "--tail" : "--lines") ?? 80;
   const lines = readFileSync10(path, "utf8").trimEnd().split(`
 `);
-  console.log(lines.slice(-Number(opts.lines)).join(`
+  console.log(lines.slice(-count).join(`
 `));
 }));
 await program.parseAsync(process.argv);