@hasna/loops 0.3.47 → 0.3.49

package/dist/cli/index.js

@@ -329,6 +329,13 @@ function optionalPositiveInteger(value, label) {
     throw new Error(`${label} must be a positive integer`);
   return value;
 }
+function optionalBoolean(value, label) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "boolean")
+    throw new Error(`${label} must be a boolean`);
+  return value;
+}
 function optionalStringArray(value, label) {
   if (value === undefined)
     return;
@@ -340,6 +347,18 @@ function optionalStringArray(value, label) {
   }).filter(Boolean);
   return values.length ? values : undefined;
 }
+function optionalAccountRef(value, label) {
+  if (value === undefined)
+    return;
+  assertObject(value, label);
+  assertString(value.profile, `${label}.profile`);
+  if (value.tool !== undefined)
+    assertString(value.tool, `${label}.tool`);
+  return {
+    profile: value.profile.trim(),
+    tool: typeof value.tool === "string" ? value.tool.trim() : undefined
+  };
+}
 function normalizeGoalSpec(value, label = "goal") {
   if (value === undefined)
     return;
@@ -386,8 +405,21 @@ function validateTarget(value, label) {
       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.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`);
     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`);
@@ -484,8 +516,10 @@ function normalizeCreateWorkflowInput(input) {
       id: step.id,
       goal: normalizeGoalSpec(step.goal, `workflow.steps[${index}].goal`),
       target: validateTarget(step.target, `workflow.steps[${index}].target`),
-      dependsOn: step.dependsOn ?? [],
-      continueOnFailure: step.continueOnFailure ?? false
+      dependsOn: optionalStringArray(step.dependsOn, `workflow.steps[${index}].dependsOn`) ?? [],
+      continueOnFailure: optionalBoolean(step.continueOnFailure, `workflow.steps[${index}].continueOnFailure`) ?? false,
+      timeoutMs: optionalPositiveInteger(step.timeoutMs, `workflow.steps[${index}].timeoutMs`),
+      account: optionalAccountRef(step.account, `workflow.steps[${index}].account`)
     };
   });
   for (const step of steps) {
@@ -586,6 +620,11 @@ function writeWorkflowRunManifest(args) {
 }
 
 // src/lib/store.ts
+var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
+var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
+var LIVE_EXPIRED_RUN_GRACE_MS = 60000;
+var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "event-worker-verifier"]);
+var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -852,6 +891,7 @@ class Store {
       ensurePrivateStorePath(file);
     this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname(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:")
@@ -915,6 +955,7 @@ class Store {
       );
       CREATE INDEX IF NOT EXISTS idx_runs_loop ON loop_runs(loop_id, created_at);
       CREATE INDEX IF NOT EXISTS idx_runs_status ON loop_runs(status);
+      CREATE INDEX IF NOT EXISTS idx_runs_status_lease ON loop_runs(status, lease_expires_at);
       CREATE INDEX IF NOT EXISTS idx_runs_scheduled ON loop_runs(scheduled_for);
 
       CREATE TABLE IF NOT EXISTS daemon_lease (
@@ -1242,39 +1283,51 @@ class Store {
     }
     return rows.map(rowToLoop);
   }
-  dueLoops(now) {
+  dueLoops(now, limit = 500) {
     const rows = this.db.query(`SELECT * FROM loops
          WHERE status = 'active'
            AND archived_at IS NULL
            AND next_run_at IS NOT NULL
            AND next_run_at <= ?
-         ORDER BY next_run_at ASC`).all(now.toISOString());
+         ORDER BY next_run_at ASC
+         LIMIT ?`).all(now.toISOString(), limit);
     return rows.map(rowToLoop);
   }
   updateLoop(id, patch, opts = {}) {
-    const current = this.getLoop(id);
-    if (!current)
-      throw new Error(`loop not found: ${id}`);
     const updated = (opts.now ?? new Date).toISOString();
-    const merged = { ...current, ...patch, updatedAt: updated };
-    this.db.query(`UPDATE loops SET status=$status, next_run_at=$nextRun, retry_scheduled_for=$retrySlot,
-         expires_at=$expiresAt, updated_at=$updated
-         WHERE id=$id
-           AND ($daemonLeaseId IS NULL OR EXISTS (
-             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
-           ))`).run({
-      $id: id,
-      $status: merged.status,
-      $nextRun: merged.nextRunAt ?? null,
-      $retrySlot: merged.retryScheduledFor ?? null,
-      $expiresAt: merged.expiresAt ?? null,
-      $updated: merged.updatedAt,
-      $daemonLeaseId: opts.daemonLeaseId ?? null,
-      $now: updated
-    });
-    if (patch.status && patch.status !== "active") {
-      const status = patch.status === "paused" ? "deferred" : "cancelled";
-      this.setWorkflowWorkItemsForLoop(id, status, `loop ${patch.status}`, updated);
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.getLoop(id);
+      if (!current)
+        throw new Error(`loop not found: ${id}`);
+      const merged = { ...current, ...patch, updatedAt: updated };
+      const res = this.db.query(`UPDATE loops SET status=$status, next_run_at=$nextRun, retry_scheduled_for=$retrySlot,
+           expires_at=$expiresAt, updated_at=$updated
+           WHERE id=$id
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: id,
+        $status: merged.status,
+        $nextRun: merged.nextRunAt ?? null,
+        $retrySlot: merged.retryScheduledFor ?? null,
+        $expiresAt: merged.expiresAt ?? null,
+        $updated: merged.updatedAt,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      if (patch.status && patch.status !== "active") {
+        const status = patch.status === "paused" ? "deferred" : "cancelled";
+        this.setWorkflowWorkItemsForLoop(id, status, `loop ${patch.status}`, updated);
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
     }
     const after = this.getLoop(id);
     if (!after)
@@ -1392,10 +1445,23 @@ class Store {
     })();
   }
   listWorkflows(opts = {}) {
-    const limit = opts.limit ?? 200;
-    const rows = opts.status ? this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT ?").all(opts.status, limit) : this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT ?").all(limit);
+    const offset = Math.max(0, opts.offset ?? 0);
+    let rows;
+    if (opts.status && opts.limit !== undefined) {
+      rows = this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?").all(opts.status, opts.limit, offset);
+    } else if (opts.status) {
+      rows = this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT -1 OFFSET ?").all(opts.status, offset);
+    } else if (opts.limit !== undefined) {
+      rows = this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT ? OFFSET ?").all(opts.limit, offset);
+    } else {
+      rows = this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT -1 OFFSET ?").all(offset);
+    }
     return rows.map(rowToWorkflow);
   }
+  countWorkflows(opts = {}) {
+    const row = opts.status ? this.db.query("SELECT COUNT(*) AS count FROM workflow_specs WHERE status = ?").get(opts.status) : this.db.query("SELECT COUNT(*) AS count FROM workflow_specs").get();
+    return row?.count ?? 0;
+  }
   archiveWorkflow(idOrName) {
     const workflow = this.requireWorkflow(idOrName);
     const updated = nowIso();
@@ -1405,6 +1471,64 @@ class Store {
       throw new Error(`workflow not found after archive: ${workflow.id}`);
     return archived;
   }
+  generatedRouteArchiveContext(args) {
+    if (!args.loopId || !args.workItemId)
+      return;
+    const workItem = this.getWorkflowWorkItem(args.workItemId);
+    if (!workItem || !GENERATED_ROUTE_KEYS.has(workItem.routeKey))
+      return;
+    const invocation = this.getWorkflowInvocation(workItem.invocationId);
+    if (!invocation?.templateId || !GENERATED_ROUTE_TEMPLATE_IDS.has(invocation.templateId))
+      return;
+    const loop = this.getLoop(args.loopId);
+    if (!loop || loop.schedule.type !== "once" || loop.target.type !== "workflow" || loop.target.workflowId !== args.workflowId)
+      return;
+    const input = loop.target.input ?? {};
+    if (input.workflowWorkItemId && input.workflowWorkItemId !== workItem.id)
+      return;
+    if (input.workflowInvocationId && input.workflowInvocationId !== invocation.id)
+      return;
+    if (workItem.workflowId && workItem.workflowId !== args.workflowId)
+      return;
+    const workflow = this.getWorkflow(args.workflowId);
+    if (!workflow)
+      return;
+    return { workflow, loop, workItem, invocation };
+  }
+  maybeArchiveGeneratedRouteWorkflow(args) {
+    const context = this.generatedRouteArchiveContext(args);
+    if (!context)
+      return;
+    const { workflow, loop, workItem } = context;
+    if (!workflow || workflow.status !== "active")
+      return;
+    const nonTerminal = this.db.query(`SELECT COUNT(*) AS count FROM workflow_runs
+         WHERE workflow_id = ? AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).get(args.workflowId)?.count ?? 0;
+    if (nonTerminal > 0)
+      return;
+    const res = this.db.query("UPDATE workflow_specs SET status='archived', updated_at=? WHERE id=? AND status='active'").run(args.updated, args.workflowId);
+    if (res.changes === 1 && args.workflowRunId) {
+      this.appendWorkflowEvent(args.workflowRunId, "workflow_archived", undefined, {
+        workflowId: args.workflowId,
+        loopId: loop.id,
+        workItemId: workItem.id,
+        routeKey: workItem.routeKey,
+        reason: "terminal generated one-shot route workflow"
+      });
+    }
+  }
+  maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, updated) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run)
+      return;
+    this.maybeArchiveGeneratedRouteWorkflow({
+      workflowId: run.workflowId,
+      loopId: run.loopId,
+      workItemId: run.workItemId,
+      workflowRunId,
+      updated
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -2190,6 +2314,7 @@ class Store {
       if (changed) {
         const itemStatus = status === "succeeded" ? "succeeded" : status === "cancelled" ? "cancelled" : "failed";
         this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, itemStatus, patch.error, finishedAt);
+        this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, finishedAt);
       }
       this.db.exec("COMMIT");
     } catch (error) {
@@ -2217,6 +2342,7 @@ class Store {
              WHERE workflow_run_id=$workflowRunId AND status IN ('pending', 'running')`).run({ $workflowRunId: workflowRunId, $finished: now, $reason: reason, $updated: now });
         this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, "cancelled", reason, now);
         this.appendWorkflowEvent(workflowRunId, "cancelled", undefined, { reason });
+        this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, now);
       }
       this.db.exec("COMMIT");
       return this.requireWorkflowRun(workflowRunId);
@@ -2469,8 +2595,20 @@ class Store {
       throw new Error(`run not found after finalize: ${id}`);
     if (opts.claimedBy && res.changes !== 1)
       return run;
-    if (res.changes === 1)
+    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 run;
   }
   heartbeatRunLease(id, claimedBy, leaseMs, now = new Date, opts = {}) {
@@ -2505,14 +2643,40 @@ class Store {
     }
     return rows.map(rowToRun);
   }
+  deferLiveExpiredRun(id, now, opts = {}) {
+    const updated = now.toISOString();
+    const deferredUntil = new Date(now.getTime() + LIVE_EXPIRED_RUN_GRACE_MS).toISOString();
+    this.db.query(`UPDATE loop_runs SET lease_expires_at=$deferredUntil, updated_at=$updated
+         WHERE id=$id AND status='running' AND lease_expires_at <= $now
+           AND ($daemonLeaseId IS NULL OR EXISTS (
+             SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+           ))`).run({
+      $id: id,
+      $deferredUntil: deferredUntil,
+      $updated: updated,
+      $now: updated,
+      $daemonLeaseId: opts.daemonLeaseId ?? null
+    });
+  }
   recoverExpiredRunLeases(now = new Date, opts = {}) {
-    const rows = this.db.query("SELECT * FROM loop_runs WHERE status = 'running' AND lease_expires_at <= ?").all(now.toISOString());
+    const limit = Math.max(1, Math.min(1000, Math.floor(opts.limit ?? DEFAULT_RECOVERY_BATCH_LIMIT)));
+    const scanLimit = Math.max(limit, Math.min(5000, Math.floor(opts.scanLimit ?? limit * DEFAULT_RECOVERY_SCAN_MULTIPLIER)));
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE status = 'running' AND lease_expires_at <= ?
+         ORDER BY lease_expires_at ASC
+         LIMIT ?`).all(now.toISOString(), scanLimit);
     const recovered = [];
     for (const row of rows) {
-      if (row.pid && isProcessAlive(row.pid))
+      if (recovered.length >= limit)
+        break;
+      if (row.pid && isProcessAlive(row.pid)) {
+        this.deferLiveExpiredRun(row.id, now, opts);
         continue;
-      if (this.hasLiveWorkflowStepProcesses(row.id))
+      }
+      if (this.hasLiveWorkflowStepProcesses(row.id)) {
+        this.deferLiveExpiredRun(row.id, now, opts);
         continue;
+      }
       const finished = now.toISOString();
       this.db.exec("BEGIN IMMEDIATE");
       try {
@@ -2565,6 +2729,7 @@ class Store {
             loopRunId: row.id
           });
           this.setWorkflowWorkItemsForWorkflowRun(workflowRow.id, "failed", "parent loop run lease expired before completion", finished);
+          this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRow.id, finished);
         }
         const loop = this.getLoop(row.loop_id);
         const itemStatus = workItemStatusForLoopRun("abandoned", row.attempt, loop?.maxAttempts);
@@ -2572,6 +2737,15 @@ class Store {
           const statuses = itemStatus === "admitted" ? ["admitted", "running", "failed"] : ["admitted", "running"];
           const reason = itemStatus === "admitted" ? "run lease expired before completion; retry pending" : "run lease expired before completion";
           this.setWorkflowWorkItemsForLoop(row.loop_id, itemStatus, reason, finished, statuses);
+          if (loop?.target.type === "workflow" && itemStatus !== "admitted") {
+            const workItemId = loop.target.input?.workflowWorkItemId ?? loop.target.input?.workItemId;
+            this.maybeArchiveGeneratedRouteWorkflow({
+              workflowId: loop.target.workflowId,
+              loopId: loop.id,
+              workItemId,
+              updated: finished
+            });
+          }
         }
         this.db.exec("COMMIT");
       } catch (error) {
@@ -3025,6 +3199,7 @@ var AUTH_ENV_KEYS = [
   "CODEWITH_HOME",
   "CODEX_HOME",
   "CURSOR_CONFIG_DIR",
+  "CURSOR_API_KEY",
   "OPENCODE_CONFIG_DIR",
   "AICOPILOT_CONFIG_DIR",
   "ANTHROPIC_API_KEY",
@@ -3154,6 +3329,10 @@ function assertSupportedAgentOptions(target) {
   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.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`);
   }
@@ -3166,6 +3345,8 @@ function assertSupportedAgentOptions(target) {
   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 (["codewith", "codex"].includes(target.provider)) {
     if (target.permissionMode && !["default", "bypass"].includes(target.permissionMode)) {
       throw new Error(`${target.provider}.permissionMode supports only default or bypass`);
@@ -3180,6 +3361,8 @@ function assertSupportedAgentOptions(target) {
     return;
   }
   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") {
@@ -3221,10 +3404,8 @@ function agentArgs(target) {
         "set -eu",
         "if command -v agent >/dev/null 2>&1; then",
         '  exec agent "$@"',
-        "elif command -v cursor >/dev/null 2>&1; then",
-        '  exec cursor agent "$@"',
         "else",
-        "  echo 'Executable not found in PATH: cursor agent or agent' >&2",
+        "  echo 'Executable not found in PATH: agent' >&2",
         "  exit 127",
         "fi"
       ].join(`
@@ -3265,7 +3446,7 @@ function agentArgs(target) {
     case "codex":
       if (target.variant)
         args.push("-c", `model_reasoning_effort=${configStringValue(target.variant)}`);
-      args.push("exec", "--json", "--ephemeral", "--sandbox", codewithLikeSandbox(target), "--skip-git-repo-check");
+      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)
@@ -3335,7 +3516,7 @@ function commandSpec(target) {
     account: agentTarget.account,
     accountTool: agentTarget.account?.tool ?? accountToolForProvider(agentTarget.provider),
     nativeAuthProfile: agentTarget.authProfile ? { provider: agentTarget.provider, profile: agentTarget.authProfile } : undefined,
-    preflightAnyOf: agentTarget.provider === "cursor" ? ["cursor", "agent"] : undefined,
+    preflightAnyOf: agentTarget.provider === "cursor" ? ["agent"] : undefined,
     stdin: agentTarget.prompt,
     allowlist: agentTarget.allowlist
   };
@@ -4718,12 +4899,14 @@ function claimDueRuns(deps) {
   const claimed = [];
   const skipped = [];
   const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
+  if (maxClaims === 0)
+    return { claims, claimed, completed: [], skipped, recovered, expired };
   for (const loop of deps.store.dueLoops(now)) {
-    if (claims.length >= maxClaims)
+    if (claims.length + skipped.length >= maxClaims)
       break;
     const plan = dueSlots(loop, now);
     for (const slot of plan.slots) {
-      if (claims.length >= maxClaims)
+      if (claims.length + skipped.length >= maxClaims)
         break;
       const run = claimSlot(deps, loop, slot);
       if (!run)
@@ -5179,35 +5362,17 @@ import { spawnSync as spawnSync4 } from "child_process";
 import { accessSync as accessSync2, constants as constants2 } from "fs";
 var PROVIDER_COMMANDS = [
   "claude",
-  "cursor agent",
+  "agent",
   "codewith",
   "aicopilot",
   "opencode",
   "codex"
 ];
 function hasCommand(command) {
-  if (command === "cursor agent") {
-    return hasCommand("cursor") || hasCommand("agent");
-  }
   const result = spawnSync4("sh", ["-c", 'command -v "$1" >/dev/null', "sh", command], { stdio: "ignore" });
   return (result.status ?? 1) === 0;
 }
 function commandVersion(command) {
-  if (command === "cursor agent") {
-    const cursorResult = spawnSync4("cursor", ["agent", "--version"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if ((cursorResult.status ?? 1) === 0)
-      return (cursorResult.stdout || cursorResult.stderr).trim().split(/\r?\n/)[0];
-    const agentResult = spawnSync4("agent", ["--version"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if ((agentResult.status ?? 1) === 0)
-      return (agentResult.stdout || agentResult.stderr).trim().split(/\r?\n/)[0];
-    return;
-  }
   const result = spawnSync4(command, ["--version"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -5743,7 +5908,7 @@ function buildScriptInventoryReport(store, opts = {}) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.3.47",
+  version: "0.3.49",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -6834,6 +6999,13 @@ function validateLoopTargetForStorage(target, context) {
     validationFailed(error, context);
   }
 }
+function normalizeWorkflowForStorage(body, context) {
+  try {
+    return workflowBodyFromJson(body);
+  } catch (error) {
+    validationFailed(error, context);
+  }
+}
 function preflightLoopTarget(target, context, metadata, opts) {
   try {
     return preflightTarget(target, metadata, opts);
@@ -6886,6 +7058,14 @@ function positiveInteger(raw, label) {
     throw new Error(`${label} must be a positive integer`);
   return value;
 }
+function nonNegativeInteger(raw, label) {
+  if (raw === undefined)
+    return;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0)
+    throw new Error(`${label} must be a non-negative integer`);
+  return value;
+}
 function positiveDuration(raw, label) {
   if (raw === undefined)
     return;
@@ -7367,6 +7547,23 @@ function taskRouteEligibility(data, metadata) {
   }
   return { eligible: true, tags };
 }
+function skippedDrainTask(task, event, reason) {
+  const taskId = taskField(task, ["id", "task_id", "taskId"]) ?? event?.subject ?? "unknown";
+  return {
+    kind: "skipped",
+    value: {
+      skipped: true,
+      reason,
+      taskId,
+      event,
+      routeError: true
+    },
+    human: `skipped task ${taskId}: ${reason}`
+  };
+}
+function isSkippableDrainRouteError(message) {
+  return message.startsWith("worktreeMode=required but projectPath is not an existing git repository:");
+}
 function generatedRouteSandboxPreflight(workflow) {
   const checks = [];
   for (const step of workflow.steps) {
@@ -7533,7 +7730,7 @@ function routeTodosTaskEvent(event, opts) {
   const routeProjectPath = normalizeRoutePath(projectPath) ?? resolve2(projectPath);
   const projectGroup = routeProjectGroup(opts.projectGroup, data, metadata);
   const throttleLimits = routeThrottleLimitsFromOpts(opts);
-  const idempotencyKey = `todos-task:${taskId}:${event.type}`;
+  const idempotencyKey = `todos-task:${taskId}`;
   const idempotencySuffix = stableSuffix(idempotencyKey);
   const namePrefix = opts.namePrefix ?? "event:todos-task";
   const workflowName = `${namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
@@ -7571,7 +7768,7 @@ function routeTodosTaskEvent(event, opts) {
   const permissionMode = permissionModeFromOpts({ permissionMode: opts.permissionMode ?? "bypass" }, provider);
   const sandbox = sandboxFromOpts({ sandbox: opts.sandbox }, provider);
   const authProfile = providerAuthProfileFromOpts({ authProfile: opts.authProfile }, provider);
-  const workflowBody = renderTodosTaskWorkerVerifierWorkflow({
+  let workflowBody = renderTodosTaskWorkerVerifierWorkflow({
     taskId,
     taskTitle,
     taskDescription,
@@ -7603,6 +7800,11 @@ function routeTodosTaskEvent(event, opts) {
   });
   workflowBody.name = workflowName;
   workflowBody.description = `Task-triggered worker/verifier workflow for ${taskTitle ?? taskId} from ${event.source}/${event.type}; ` + `idempotency=${idempotencyKey}; event=${event.id}; project=${projectPath}; projectGroup=${projectGroup ?? "-"}`;
+  workflowBody = normalizeWorkflowForStorage(workflowBody, {
+    name: workflowName,
+    type: "todos-task-event-workflow",
+    event: event.id
+  });
   const sandboxPreflight = generatedRouteSandboxPreflight(workflowBody);
   const invocationInput = {
     templateId: "todos-task-worker-verifier",
@@ -7782,7 +7984,7 @@ function routeGenericEvent(event, opts) {
   const permissionMode = permissionModeFromOpts({ permissionMode: opts.permissionMode ?? "bypass" }, provider);
   const sandbox = sandboxFromOpts({ sandbox: opts.sandbox }, provider);
   const authProfile = providerAuthProfileFromOpts({ authProfile: opts.authProfile }, provider);
-  const workflowBody = renderEventWorkerVerifierWorkflow({
+  let workflowBody = renderEventWorkerVerifierWorkflow({
     eventId: event.id,
     eventType: event.type,
     eventSource: event.source,
@@ -7814,6 +8016,11 @@ function routeGenericEvent(event, opts) {
   });
   workflowBody.name = workflowName;
   workflowBody.description = `Event-triggered worker/verifier workflow for ${event.source}/${event.type}; project=${projectPath}; projectGroup=${projectGroup ?? "-"}`;
+  workflowBody = normalizeWorkflowForStorage(workflowBody, {
+    name: workflowName,
+    type: "generic-event-workflow",
+    event: event.id
+  });
   const sandboxPreflight = generatedRouteSandboxPreflight(workflowBody);
   const invocationInput = {
     templateId: "event-worker-verifier",
@@ -8230,8 +8437,12 @@ var goal = program.command("goal").description("inspect goal runs");
 function addRouteEventOptions(command) {
   return command.option("--event-file <file>", "read event envelope JSON from a file instead of stdin/HASNA_EVENT_JSON").option("--event-json <json>", "read event envelope JSON from this string instead of stdin/HASNA_EVENT_JSON").option("--todos-project <path>", "todos storage project path for generated task commands", defaultLoopsProject()).option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--auth-profile-pool <profiles>", "comma-separated provider-native auth profile pool").option("--worker-auth-profile <profile>", "provider-native auth profile for worker step").option("--verifier-auth-profile <profile>", "provider-native auth profile for verifier step").option("--account <profile>", "OpenAccounts profile name").option("--account-pool <profiles>", "comma-separated OpenAccounts profile pool").option("--worker-account <profile>", "OpenAccounts profile for worker step").option("--verifier-account <profile>", "OpenAccounts profile for verifier step").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--add-dir <dir>", "additional writable directory for provider sandboxes; may be repeated or comma-separated", collectValues, []).option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--manual-break-glass", "allow danger-full-access in generated worker/verifier workflow metadata; for explicit operator emergency use only").option("--project-path <path>", "fallback project/repo working directory").option("--project-group <name>", "optional project group for concurrency limits").option("--max-active <n>", "skip creating a workflow when this many active routed workflows already exist globally").option("--max-active-per-project <n>", "skip creating a workflow when this many active routed workflows already exist for the project").option("--max-active-per-project-group <n>", "skip creating a workflow when this many active routed workflows already exist for the project group").option("--worktree-mode <mode>", "worktree isolation mode: auto, required, off, or main", "auto").option("--worktree-root <path>", "base directory for OpenLoops-managed git worktrees").option("--worktree-branch-prefix <prefix>", "branch prefix for generated worktrees", "openloops").option("--name-prefix <prefix>", "workflow/loop name prefix").option("--preflight", "check generated workflow steps before storing the workflow loop");
 }
-function addTodosDrainOptions(command) {
-  return command.option("--todos-project <path>", "todos storage project path", defaultLoopsProject()).option("--todos-project-id <id>", "filter todos ready output to one todos project id").option("--task-list <id-or-slug>", "filter ready tasks to one task-list id, slug, or name").option("--project-path-prefix <path>", "filter ready tasks to a project/repo path prefix").option("--tags <tags>", "require all comma-separated tags before routing").option("--tag <tags>", "alias for --tags").option("--limit <n>", "maximum filtered ready-task candidates to consider", "50").option("--scan-limit <n>", "maximum raw todos ready rows to fetch before filters; defaults to 500 when filters are used").option("--max-dispatch <n>", "maximum new workflow loops to create in this drain run", "1").option("--evidence-dir <path>", "write a JSON drain report to this directory").option("--compact", "print compact JSON to stdout while preserving the full evidence file").option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--auth-profile-pool <profiles>", "comma-separated provider-native auth profile pool").option("--worker-auth-profile <profile>", "provider-native auth profile for worker step").option("--verifier-auth-profile <profile>", "provider-native auth profile for verifier step").option("--account <profile>", "OpenAccounts profile name").option("--account-pool <profiles>", "comma-separated OpenAccounts profile pool").option("--worker-account <profile>", "OpenAccounts profile for worker step").option("--verifier-account <profile>", "OpenAccounts profile for verifier step").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--add-dir <dir>", "additional writable directory for provider sandboxes; may be repeated or comma-separated", collectValues, []).option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--manual-break-glass", "allow danger-full-access in generated worker/verifier workflow metadata; for explicit operator emergency use only").option("--project-path <path>", "fallback project/repo working directory").option("--project-group <name>", "optional project group for concurrency limits").option("--max-active <n>", "skip creating a workflow when this many active routed workflows already exist globally").option("--max-active-per-project <n>", "skip creating a workflow when this many active routed workflows already exist for the project").option("--max-active-per-project-group <n>", "skip creating a workflow when this many active routed workflows already exist for the project group").option("--worktree-mode <mode>", "worktree isolation mode: auto, required, off, or main", "auto").option("--worktree-root <path>", "base directory for OpenLoops-managed git worktrees").option("--worktree-branch-prefix <prefix>", "branch prefix for generated task worktrees", "openloops").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:todos-task").option("--preflight", "check generated workflow steps before storing workflow loops").option("--dry-run", "preview selected tasks and generated workflow loops without storing anything");
+function addTodosDrainOptions(command, opts = {}) {
+  let configured = command.option("--todos-project <path>", "todos storage project path", defaultLoopsProject()).option("--todos-project-id <id>", "filter todos ready output to one todos project id").option("--task-list <id-or-slug>", "filter ready tasks to one task-list id, slug, or name").option("--project-path-prefix <path>", "filter ready tasks to a project/repo path prefix").option("--tags <tags>", "require all comma-separated tags before routing").option("--tag <tags>", "alias for --tags").option("--limit <n>", "maximum filtered ready-task candidates to consider", "50").option("--scan-limit <n>", "maximum raw todos ready rows to fetch before filters; defaults to 500 when filters are used").option("--max-dispatch <n>", "maximum new workflow loops to create in this drain run", "1").option("--evidence-dir <path>", "write a JSON drain report to this directory").option("--compact", "print compact JSON to stdout while preserving the full evidence file").option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--auth-profile-pool <profiles>", "comma-separated provider-native auth profile pool").option("--worker-auth-profile <profile>", "provider-native auth profile for worker step").option("--verifier-auth-profile <profile>", "provider-native auth profile for verifier step").option("--account <profile>", "OpenAccounts profile name").option("--account-pool <profiles>", "comma-separated OpenAccounts profile pool").option("--worker-account <profile>", "OpenAccounts profile for worker step").option("--verifier-account <profile>", "OpenAccounts profile for verifier step").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--add-dir <dir>", "additional writable directory for provider sandboxes; may be repeated or comma-separated", collectValues, []).option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--manual-break-glass", "allow danger-full-access in generated worker/verifier workflow metadata; for explicit operator emergency use only").option("--project-path <path>", "fallback project/repo working directory").option("--project-group <name>", "optional project group for concurrency limits").option("--max-active <n>", "skip creating a workflow when this many active routed workflows already exist globally").option("--max-active-per-project <n>", "skip creating a workflow when this many active routed workflows already exist for the project").option("--max-active-per-project-group <n>", "skip creating a workflow when this many active routed workflows already exist for the project group").option("--worktree-mode <mode>", "worktree isolation mode: auto, required, off, or main", "auto").option("--worktree-root <path>", "base directory for OpenLoops-managed git worktrees").option("--worktree-branch-prefix <prefix>", "branch prefix for generated task worktrees", "openloops").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:todos-task").option("--preflight", opts.preflightDescription ?? "check generated workflow steps before storing workflow loops");
+  if (opts.includeDryRun ?? true) {
+    configured = configured.option("--dry-run", "preview selected tasks and generated workflow loops without storing anything");
+  }
+  return configured;
 }
 function routeEventByKind(kind, event, opts) {
   if (kind === "todos-task")
@@ -8312,8 +8523,17 @@ function drainTodosTaskRoutes(opts) {
   for (const task of candidates) {
     if (created >= maxDispatch)
       break;
-    const event = taskDrainEvent(task);
-    const result = routeTodosTaskEvent(event, opts);
+    let event;
+    let result;
+    try {
+      event = taskDrainEvent(task);
+      result = routeTodosTaskEvent(event, opts);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!isSkippableDrainRouteError(message))
+        throw error;
+      result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed");
+    }
     results.push(result);
     if (result.kind === "created" && !opts.dryRun)
       created += 1;
@@ -8374,6 +8594,57 @@ function drainTodosTaskRoutes(opts) {
   } : { ...report, evidencePath };
   print(output, `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped}`);
 }
+function formatTemplateVariable(template, name) {
+  const variable = template.variables.find((entry) => entry.name === name);
+  const placeholder = variable?.default ? variable.default : `<${name}>`;
+  return `  --var ${name}=${placeholder}`;
+}
+function printTemplateDetails(template) {
+  console.log(`${template.id} (${template.kind})`);
+  console.log(template.name);
+  console.log("");
+  console.log(template.description);
+  console.log("");
+  console.log("Variables:");
+  const nameWidth = Math.max(...template.variables.map((variable) => variable.name.length), 4);
+  for (const variable of template.variables) {
+    const required = variable.required ? "required" : "optional";
+    const defaultValue = variable.default ? ` default=${variable.default}` : "";
+    const description = variable.description ? `  ${variable.description}` : "";
+    console.log(`  ${variable.name.padEnd(nameWidth)}  ${required}${defaultValue}${description}`);
+  }
+  const requiredVariables = template.variables.filter((variable) => variable.required).map((variable) => variable.name);
+  const hintVariables = requiredVariables.length ? requiredVariables : template.variables.slice(0, 2).map((variable) => variable.name);
+  const renderArgs = hintVariables.map((name) => formatTemplateVariable(template, name));
+  const renderHint = renderArgs.length ? ` \\
+${renderArgs.join(" \\\n")}` : "";
+  console.log("");
+  console.log("Usage:");
+  console.log(`  loops templates render ${template.id}${renderHint}`);
+  if (template.kind === "workflow")
+    console.log(`  loops templates create-workflow ${template.id}${renderHint}`);
+}
+function workflowStatusFromOpts(status, all) {
+  if (all) {
+    if (status && status !== "active")
+      throw new Error("use either --all or --status, not both");
+    return;
+  }
+  const value = status ?? "active";
+  if (value === "all")
+    return;
+  if (value === "active" || value === "archived")
+    return value;
+  throw new Error("--status must be active, archived, or all");
+}
+function printWorkflowListWarning(args) {
+  if (args.shown + args.offset >= args.total && args.offset === 0)
+    return;
+  const scope = args.status ?? "all";
+  const nextOffset = args.offset + args.shown;
+  const next = args.limit && nextOffset < args.total ? ` next page: --limit ${args.limit} --offset ${nextOffset}` : "";
+  console.error(`showing ${args.offset + args.shown} of ${args.total} ${scope} workflows.${next}`);
+}
 templates.command("list").alias("ls").description("list built-in OpenLoops templates").action(() => {
   const values = listLoopTemplates();
   if (isJson())
@@ -8388,7 +8659,10 @@ templates.command("show <id>").description("show a built-in template").action((i
   const template = getLoopTemplate(id);
   if (!template)
     throw new Error(`template not found: ${id}`);
-  print(template, `${template.id} ${template.kind}`);
+  if (isJson())
+    print(template);
+  else
+    printTemplateDetails(template);
 });
 templates.command("render <id>").description("render a template as workflow JSON").option("--var <key=value>", "template variable; may be repeated", collectValues, []).action((id, opts) => {
   const workflow = renderLoopTemplate(id, parseVars(opts.var));
@@ -8472,7 +8746,10 @@ addTodosDrainOptions(routes.command("drain <kind>").description("drain a durable
     throw new Error("route drain currently supports kind todos-task");
   drainTodosTaskRoutes(opts);
 });
-addScheduleOptions(addTodosDrainOptions(routes.command("schedule <kind> <name>").description("schedule a deterministic route drain loop"))).action((kind, name, opts) => {
+addScheduleOptions(addTodosDrainOptions(routes.command("schedule <kind> <name>").description("schedule a deterministic route drain loop"), {
+  includeDryRun: false,
+  preflightDescription: "forward generated workflow preflight checks into each future drain run"
+})).action((kind, name, opts) => {
   if (kind !== "todos-task")
     throw new Error("route schedule currently supports kind todos-task");
   const store = new Store;
@@ -8499,288 +8776,13 @@ eventsHandle.command("todos-task").description("create a one-shot worker/verifie
   print(result.value, result.human);
 });
 var eventsDrain = events.command("drain").description("drain durable source queues into bounded OpenLoops workflows");
-eventsDrain.command("todos-task").description("drain ready todos tasks into bounded worker/verifier workflow loops").option("--todos-project <path>", "todos storage project path", defaultLoopsProject()).option("--todos-project-id <id>", "filter todos ready output to one todos project id").option("--task-list <id-or-slug>", "filter ready tasks to one task-list id, slug, or name").option("--project-path-prefix <path>", "filter ready tasks to a project/repo path prefix").option("--tags <tags>", "require all comma-separated tags before routing").option("--tag <tags>", "alias for --tags").option("--limit <n>", "maximum filtered ready-task candidates to consider", "50").option("--scan-limit <n>", "maximum raw todos ready rows to fetch before filters; defaults to 500 when filters are used").option("--max-dispatch <n>", "maximum new workflow loops to create in this drain run", "1").option("--evidence-dir <path>", "write a JSON drain report to this directory").option("--compact", "print compact JSON to stdout while preserving the full evidence file").option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--auth-profile-pool <profiles>", "comma-separated provider-native auth profile pool").option("--worker-auth-profile <profile>", "provider-native auth profile for worker step").option("--verifier-auth-profile <profile>", "provider-native auth profile for verifier step").option("--account <profile>", "OpenAccounts profile name").option("--account-pool <profiles>", "comma-separated OpenAccounts profile pool").option("--worker-account <profile>", "OpenAccounts profile for worker step").option("--verifier-account <profile>", "OpenAccounts profile for verifier step").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--add-dir <dir>", "additional writable directory for provider sandboxes; may be repeated or comma-separated", collectValues, []).option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--manual-break-glass", "allow danger-full-access in generated worker/verifier workflow metadata; for explicit operator emergency use only").option("--project-path <path>", "fallback project/repo working directory").option("--project-group <name>", "optional project group for concurrency limits").option("--max-active <n>", "skip creating a workflow when this many active routed workflows already exist globally").option("--max-active-per-project <n>", "skip creating a workflow when this many active routed workflows already exist for the project").option("--max-active-per-project-group <n>", "skip creating a workflow when this many active routed workflows already exist for the project group").option("--worktree-mode <mode>", "worktree isolation mode: auto, required, off, or main", "auto").option("--worktree-root <path>", "base directory for OpenLoops-managed git worktrees").option("--worktree-branch-prefix <prefix>", "branch prefix for generated task worktrees", "openloops").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:todos-task").option("--preflight", "check generated workflow steps before storing workflow loops").option("--dry-run", "preview selected tasks and generated workflow loops without storing anything").action((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 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;
-  const scanLimit = positiveInteger(opts.scanLimit ?? String(defaultScanLimit), "--scan-limit") ?? defaultScanLimit;
-  const ready = loadReadyTodosTasks(opts, scanLimit);
-  const filteredCandidates = ready.filter((task) => taskMatchesDrainFilters(task, {
-    projectId: opts.todosProjectId,
-    taskListId: taskListFilter,
-    projectPathPrefix: opts.projectPathPrefix,
-    tags: requiredTags
-  }));
-  const candidates = filteredCandidates.slice(0, candidateLimit);
-  const results = [];
-  let created = 0;
-  for (const task of candidates) {
-    if (created >= maxDispatch)
-      break;
-    const event = taskDrainEvent(task);
-    const result = routeTodosTaskEvent(event, opts);
-    results.push(result);
-    if (result.kind === "created" && !opts.dryRun)
-      created += 1;
-    if (result.kind === "created" && opts.dryRun)
-      created += 1;
-  }
-  const report = {
-    drainedAt: new Date().toISOString(),
-    todosProject,
-    todosProjectId: opts.todosProjectId,
-    taskList: opts.taskList,
-    taskListId: taskListFilter,
-    projectPathPrefix: opts.projectPathPrefix,
-    tags: requiredTags,
-    limit: candidateLimit,
-    scanLimit,
-    filtersApplied: hasPostFilters,
-    scanned: ready.length,
-    candidates: candidates.length,
-    filteredCandidates: filteredCandidates.length,
-    scanExhausted: ready.length >= scanLimit && filteredCandidates.length < candidateLimit,
-    considered: results.length,
-    created: results.filter((result) => result.kind === "created" && !result.value.deduped).length,
-    deduped: results.filter((result) => result.kind === "deduped").length,
-    throttled: results.filter((result) => result.kind === "throttled").length,
-    skipped: results.filter((result) => result.kind === "skipped").length,
-    maxDispatch,
-    source: "todos ready",
-    dryRun: Boolean(opts.dryRun),
-    results: results.map((result) => ({ kind: result.kind, ...result.value }))
-  };
-  const evidencePath = writeRouteEvidence("todos-task-drain", report, opts.evidenceDir);
-  const output = opts.compact ? {
-    drainedAt: report.drainedAt,
-    todosProject: report.todosProject,
-    todosProjectId: report.todosProjectId,
-    taskList: report.taskList,
-    taskListId: report.taskListId,
-    projectPathPrefix: report.projectPathPrefix,
-    tags: report.tags,
-    limit: report.limit,
-    scanLimit: report.scanLimit,
-    filtersApplied: report.filtersApplied,
-    scanned: report.scanned,
-    candidates: report.candidates,
-    filteredCandidates: report.filteredCandidates,
-    scanExhausted: report.scanExhausted,
-    considered: report.considered,
-    created: report.created,
-    deduped: report.deduped,
-    throttled: report.throttled,
-    skipped: report.skipped,
-    maxDispatch: report.maxDispatch,
-    source: report.source,
-    dryRun: report.dryRun,
-    evidencePath,
-    results: results.map(compactDrainResult)
-  } : { ...report, evidencePath };
-  print(output, `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped}`);
+addTodosDrainOptions(eventsDrain.command("todos-task").description("drain ready todos tasks into bounded worker/verifier workflow loops")).action((opts) => {
+  drainTodosTaskRoutes(opts);
 });
 eventsHandle.command("generic").description("create a one-shot worker/verifier workflow loop for any Hasna event").option("--provider <provider>", "agent provider", "codewith").option("--auth-profile <profile>", "provider-native auth profile; currently supported for codewith").option("--auth-profile-pool <profiles>", "comma-separated provider-native auth profile pool").option("--worker-auth-profile <profile>", "provider-native auth profile for worker step").option("--verifier-auth-profile <profile>", "provider-native auth profile for verifier step").option("--account <profile>", "OpenAccounts profile name").option("--account-pool <profiles>", "comma-separated OpenAccounts profile pool").option("--worker-account <profile>", "OpenAccounts profile for worker step").option("--verifier-account <profile>", "OpenAccounts profile for verifier step").option("--account-tool <tool>", "OpenAccounts tool id").option("--model <model>", "provider model").option("--variant <variant>", "provider-specific model variant or reasoning effort").option("--agent <agent>", "provider-specific agent").option("--add-dir <dir>", "additional writable directory for provider sandboxes; may be repeated or comma-separated", collectValues, []).option("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--manual-break-glass", "allow danger-full-access in generated worker/verifier workflow metadata; for explicit operator emergency use only").option("--project-path <path>", "fallback project/repo working directory").option("--project-group <name>", "optional project group for concurrency limits").option("--max-active <n>", "skip creating a workflow when this many active routed workflows already exist globally").option("--max-active-per-project <n>", "skip creating a workflow when this many active routed workflows already exist for the project").option("--max-active-per-project-group <n>", "skip creating a workflow when this many active routed workflows already exist for the project group").option("--worktree-mode <mode>", "worktree isolation mode: auto, required, off, or main", "auto").option("--worktree-root <path>", "base directory for OpenLoops-managed git worktrees").option("--worktree-branch-prefix <prefix>", "branch prefix for generated event worktrees", "openloops").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:generic").option("--preflight", "check generated workflow steps before storing the workflow loop").option("--dry-run", "print the workflow and loop input without storing anything").action(async (opts) => {
   const event = await readEventEnvelopeFromStdin();
-  const data = eventData(event);
-  const metadata = eventMetadata(event);
-  const projectPath = opts.projectPath ?? taskEventField(data, ["working_dir", "workingDir", "project_path", "projectPath", "cwd", "repo_path", "repoPath"]) ?? taskEventField(metadata, ["working_dir", "workingDir", "project_path", "projectPath", "project_canonical_path", "cwd", "repo_path", "repoPath"]) ?? process.cwd();
-  const routeProjectPath = normalizeRoutePath(projectPath) ?? resolve2(projectPath);
-  const projectGroup = routeProjectGroup(opts.projectGroup, data, metadata);
-  const throttleLimits = routeThrottleLimitsFromOpts(opts);
-  const eventSuffix = event.id.slice(0, 8);
-  const source = slugSegment2(event.source, "source");
-  const type = slugSegment2(event.type, "type");
-  const workflowName = `${opts.namePrefix}:${source}:${type}:${eventSuffix}:workflow`;
-  const loopName = `${opts.namePrefix}:${source}:${type}:${eventSuffix}:run`;
-  const idempotencyKey = `generic-event:${event.source}:${event.type}:${event.id}`;
-  const provider = opts.provider;
-  if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider))
-    throw new Error("unsupported provider");
-  const permissionMode = permissionModeFromOpts({ permissionMode: opts.permissionMode }, provider);
-  const sandbox = sandboxFromOpts({ sandbox: opts.sandbox }, provider);
-  const authProfile = providerAuthProfileFromOpts({ authProfile: opts.authProfile }, provider);
-  const workflowBody = renderEventWorkerVerifierWorkflow({
-    eventId: event.id,
-    eventType: event.type,
-    eventSource: event.source,
-    eventSubject: stringField(event.subject),
-    eventMessage: stringField(event.message),
-    eventJson: JSON.stringify(event),
-    projectPath,
-    routeProjectPath,
-    projectGroup,
-    provider,
-    authProfile,
-    authProfilePool: splitList(opts.authProfilePool),
-    workerAuthProfile: opts.workerAuthProfile,
-    verifierAuthProfile: opts.verifierAuthProfile,
-    account: accountFromOpts(opts),
-    accountPool: accountPoolFromOpts(opts),
-    workerAccount: roleAccountFromOpts(opts, opts.workerAccount),
-    verifierAccount: roleAccountFromOpts(opts, opts.verifierAccount),
-    model: opts.model,
-    variant: opts.variant,
-    agent: opts.agent,
-    addDirs: listFromRepeatedOpts(opts.addDir),
-    permissionMode,
-    sandbox,
-    manualBreakGlass: Boolean(opts.manualBreakGlass),
-    worktreeMode: opts.worktreeMode,
-    worktreeRoot: opts.worktreeRoot,
-    worktreeBranchPrefix: opts.worktreeBranchPrefix
-  });
-  workflowBody.name = workflowName;
-  workflowBody.description = `Event-triggered worker/verifier workflow for ${event.source}/${event.type}; project=${projectPath}; projectGroup=${projectGroup ?? "-"}`;
-  const sandboxPreflight = generatedRouteSandboxPreflight(workflowBody);
-  const invocationInput = {
-    templateId: "event-worker-verifier",
-    sourceRef: {
-      kind: "event",
-      id: event.id,
-      dedupeKey: idempotencyKey,
-      raw: { source: event.source, type: event.type }
-    },
-    subjectRef: {
-      kind: "event",
-      id: stringField(event.subject) ?? event.id,
-      path: routeProjectPath,
-      raw: { message: stringField(event.message) }
-    },
-    intent: "route",
-    scope: {
-      projectPath: routeProjectPath,
-      projectGroup,
-      worktreePolicy: opts.worktreeMode ?? "auto",
-      permissions: permissionMode,
-      manualBreakGlass: Boolean(opts.manualBreakGlass),
-      accountPolicy: opts.authProfilePool || opts.accountPool ? "pool" : "single",
-      concurrencyGroup: projectGroup ?? routeProjectPath
-    },
-    outputPolicy: {
-      report: "always",
-      createTask: "on_failure"
-    }
-  };
-  const workItemInput = {
-    routeKey: "generic-event",
-    idempotencyKey,
-    invocationId: "<created-invocation-id>",
-    sourceType: event.type,
-    sourceRef: event.id,
-    subjectRef: stringField(event.subject) ?? event.id,
-    projectKey: routeProjectPath,
-    projectGroup,
-    priority: 0,
-    status: "queued"
-  };
-  const loopInput = {
-    name: loopName,
-    description: `Run ${workflowBody.name} once for event ${event.id}; idempotency=${idempotencyKey}`,
-    schedule: { type: "once", at: new Date(Date.now() + 1000).toISOString() },
-    target: { type: "workflow", workflowId: "<created-workflow-id>", input: {} },
-    overlap: "skip",
-    maxAttempts: 1,
-    retryDelayMs: 60000,
-    leaseMs: 90 * 60000
-  };
-  if (opts.dryRun) {
-    const throttle = hasThrottleLimits(throttleLimits) ? routeThrottleDryRunPreview({ projectPath: routeProjectPath, projectGroup, limits: throttleLimits }) : undefined;
-    const preflight = opts.preflight ? preflightStoredWorkflow(workflowSpecForPreflight(workflowBody, "event-preflight"), {
-      name: workflowBody.name,
-      type: "generic-event-workflow",
-      event: event.id
-    }, {}) : undefined;
-    print({ event, idempotencyKey, invocation: invocationInput, workItem: workItemInput, workflow: workflowBody, loop: loopInput, throttle, sandboxPreflight, preflight }, `dry-run ${loopName}`);
-    return;
-  }
-  const store = new Store;
-  try {
-    const workflowPreflightSpec = workflowSpecForPreflight(workflowBody, "event-preflight");
-    generatedRouteSandboxPreflight(workflowPreflightSpec);
-    const preflight = opts.preflight ? preflightStoredWorkflow(workflowPreflightSpec, {
-      name: workflowBody.name,
-      type: "generic-event-workflow",
-      event: event.id
-    }, {}) : undefined;
-    const outcome = store.writeTransaction(() => {
-      const invocation = store.createWorkflowInvocation(invocationInput);
-      const existingItem = store.findWorkflowWorkItem("generic-event", idempotencyKey);
-      if (existingItem?.loopId && ["admitted", "running", "succeeded"].includes(existingItem.status)) {
-        const existingLoop = store.getLoop(existingItem.loopId);
-        const existingWorkflow = existingItem.workflowId ? store.getWorkflow(existingItem.workflowId) : undefined;
-        return { kind: "deduped", existingItem, existingLoop, existingWorkflow, invocation };
-      }
-      const throttle = hasThrottleLimits(throttleLimits) ? routeThrottleDecision(store, { projectPath: routeProjectPath, projectGroup, limits: throttleLimits }) : undefined;
-      const workItem = store.upsertWorkflowWorkItem({
-        ...workItemInput,
-        invocationId: invocation.id,
-        status: throttle && !throttle.allowed ? "deferred" : "queued",
-        lastReason: throttle && !throttle.allowed ? throttle.reason : undefined
-      });
-      if (throttle && !throttle.allowed)
-        return { kind: "throttled", invocation, workItem, throttle };
-      const workflow = routeWorkflowForStorage(store, workflowBody);
-      const loop = store.createLoop({
-        ...loopInput,
-        target: {
-          type: "workflow",
-          workflowId: workflow.id,
-          input: {
-            workflowInvocationId: invocation.id,
-            workflowWorkItemId: workItem.id
-          }
-        }
-      });
-      const admitted = store.admitWorkflowWorkItem(workItem.id, { workflowId: workflow.id, loopId: loop.id, reason: "admitted by generic-event route" });
-      return { kind: "created", invocation, workItem: admitted, workflow, loop, throttle };
-    });
-    if (outcome.kind === "deduped") {
-      print({
-        deduped: true,
-        idempotencyKey,
-        dedupedBy: "work-item",
-        event,
-        invocation: publicWorkflowInvocation(outcome.invocation),
-        workItem: publicWorkflowWorkItem(outcome.existingItem),
-        workflow: outcome.existingWorkflow ? publicWorkflow(outcome.existingWorkflow) : undefined,
-        loop: outcome.existingLoop ? publicLoop(outcome.existingLoop) : undefined
-      }, `deduped existing work item ${outcome.existingItem.id} for event=${event.id} idempotency=${idempotencyKey}`);
-      return;
-    }
-    if (outcome.kind === "throttled") {
-      print({
-        skipped: true,
-        queuedAtSource: true,
-        reason: outcome.throttle.reason,
-        idempotencyKey,
-        event,
-        invocation: publicWorkflowInvocation(outcome.invocation),
-        workItem: publicWorkflowWorkItem(outcome.workItem),
-        throttle: outcome.throttle,
-        workflow: workflowBody,
-        loop: loopInput
-      }, `skipped event ${event.id}: ${outcome.throttle.reason}`);
-      return;
-    }
-    print({
-      deduped: false,
-      idempotencyKey,
-      event,
-      invocation: publicWorkflowInvocation(outcome.invocation),
-      workItem: publicWorkflowWorkItem(outcome.workItem),
-      workflow: publicWorkflow(outcome.workflow),
-      loop: publicLoop(outcome.loop),
-      throttle: outcome.throttle,
-      sandboxPreflight,
-      preflight
-    }, `created ${outcome.loop.id} (${outcome.loop.name}) workflow=${outcome.workflow.name} event=${event.id} idempotency=${idempotencyKey}`);
-  } finally {
-    store.close();
-  }
+  const result = routeGenericEvent(event, opts);
+  print(result.value, result.human);
 });
 goal.command("show <idOrName>").description("show a goal or configured loop/workflow goal").action((idOrName) => {
   const store = new Store;
@@ -8860,10 +8862,14 @@ workflows.command("create <file>").description("validate and store a workflow JS
     store.close();
   }
 });
-workflows.command("list").alias("ls").option("--status <status>", "active or archived", "active").action((opts) => {
+workflows.command("list").alias("ls").option("--status <status>", "active, archived, or all", "active").option("--all", "include active and archived workflows").option("--limit <n>", "maximum rows to print; omitted means all matching workflows").option("--offset <n>", "number of matching rows to skip before printing", "0").action((opts) => {
   const store = new Store;
   try {
-    const workflowsList = store.listWorkflows({ status: opts.status });
+    const status = workflowStatusFromOpts(opts.status, opts.all);
+    const limit = positiveInteger(opts.limit, "--limit");
+    const offset = nonNegativeInteger(opts.offset, "--offset") ?? 0;
+    const workflowsList = store.listWorkflows({ status, limit, offset });
+    const total = store.countWorkflows({ status });
     if (isJson())
       print(workflowsList.map(publicWorkflow));
     else {
@@ -8871,6 +8877,8 @@ workflows.command("list").alias("ls").option("--status <status>", "active or arc
         console.log(`${workflow.id}  ${workflow.status.padEnd(8)}  steps=${workflow.steps.length}  ${workflow.name}`);
       }
     }
+    if (limit !== undefined || offset > 0)
+      printWorkflowListWarning({ shown: workflowsList.length, total, status, offset, limit });
   } finally {
     store.close();
   }