@hasna/loops 0.3.26 → 0.3.28

package/dist/cli/index.js

@@ -418,6 +418,42 @@ function validateTarget(value, label) {
         throw new Error(`${label}.allowlist.enforcement must be metadata_only`);
       }
     }
+    if (value.worktree !== undefined) {
+      assertObject(value.worktree, `${label}.worktree`);
+      assertString(value.worktree.mode, `${label}.worktree.mode`);
+      const modes = ["auto", "required", "off", "main"];
+      if (!modes.includes(value.worktree.mode))
+        throw new Error(`${label}.worktree.mode must be one of ${modes.join(", ")}`);
+      if (typeof value.worktree.enabled !== "boolean")
+        throw new Error(`${label}.worktree.enabled must be a boolean`);
+      assertString(value.worktree.originalCwd, `${label}.worktree.originalCwd`);
+      assertString(value.worktree.cwd, `${label}.worktree.cwd`);
+      if (value.worktree.repoRoot !== undefined)
+        assertString(value.worktree.repoRoot, `${label}.worktree.repoRoot`);
+      if (value.worktree.root !== undefined)
+        assertString(value.worktree.root, `${label}.worktree.root`);
+      if (value.worktree.path !== undefined)
+        assertString(value.worktree.path, `${label}.worktree.path`);
+      if (value.worktree.branch !== undefined)
+        assertString(value.worktree.branch, `${label}.worktree.branch`);
+      if (value.worktree.reason !== undefined)
+        assertString(value.worktree.reason, `${label}.worktree.reason`);
+    }
+    if (value.routing !== undefined) {
+      assertObject(value.routing, `${label}.routing`);
+      if (value.routing.projectPath !== undefined)
+        assertString(value.routing.projectPath, `${label}.routing.projectPath`);
+      if (value.routing.projectGroup !== undefined)
+        assertString(value.routing.projectGroup, `${label}.routing.projectGroup`);
+      if (value.routing.taskId !== undefined)
+        assertString(value.routing.taskId, `${label}.routing.taskId`);
+      if (value.routing.eventId !== undefined)
+        assertString(value.routing.eventId, `${label}.routing.eventId`);
+      if (value.routing.eventType !== undefined)
+        assertString(value.routing.eventType, `${label}.routing.eventType`);
+      if (value.routing.eventSource !== undefined)
+        assertString(value.routing.eventSource, `${label}.routing.eventSource`);
+    }
     return value;
   }
   throw new Error(`${label}.type must be command or agent`);
@@ -2189,6 +2225,19 @@ class Store {
     const row = this.db.query("SELECT * FROM daemon_lease LIMIT 1").get();
     return row ? rowToLease(row) : undefined;
   }
+  writeTransaction(fn) {
+    this.db.exec("BEGIN IMMEDIATE;");
+    try {
+      const result = fn();
+      this.db.exec("COMMIT;");
+      return result;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK;");
+      } catch {}
+      throw error;
+    }
+  }
   close() {
     this.db.close();
   }
@@ -2196,9 +2245,9 @@ class Store {
 
 // src/cli/index.ts
 import { createHash as createHash2, randomUUID } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync2, realpathSync, writeFileSync as writeFileSync3 } from "fs";
 import { spawnSync as spawnSync5 } from "child_process";
-import { join as join3 } from "path";
+import { join as join4, resolve as resolve2 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 import { Command } from "commander";
 
@@ -5204,7 +5253,7 @@ function buildScriptInventoryReport(store, opts = {}) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.3.26",
+  version: "0.3.28",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -5293,6 +5342,10 @@ function packageVersion() {
 }
 
 // src/lib/templates.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename2, isAbsolute, join as join3, relative, resolve } from "path";
 var TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID = "todos-task-worker-verifier";
 var EVENT_WORKER_VERIFIER_TEMPLATE_ID = "event-worker-verifier";
 var BOUNDED_AGENT_WORKER_VERIFIER_TEMPLATE_ID = "bounded-agent-worker-verifier";
@@ -5306,6 +5359,8 @@ var TEMPLATE_SUMMARIES = [
       { name: "taskId", required: true, description: "Todos task id to execute." },
       { name: "taskTitle", description: "Human-readable task title." },
       { name: "projectPath", required: true, description: "Repository or project working directory." },
+      { name: "routeProjectPath", description: "Canonical project path used for scheduler concurrency limits." },
+      { name: "projectGroup", description: "Optional project group used for scheduler concurrency limits." },
       { name: "provider", default: "codewith", description: "Agent provider: codewith, claude, cursor, opencode, aicopilot, or codex." },
       { name: "authProfile", description: "Provider-native auth profile, currently Codewith." },
       { name: "authProfilePool", description: "Comma-separated provider-native auth profiles; worker/verifier are selected deterministically." },
@@ -5315,7 +5370,10 @@ var TEMPLATE_SUMMARIES = [
       { name: "model", description: "Provider model." },
       { name: "variant", description: "Provider reasoning/model effort variant." },
       { name: "permissionMode", default: "bypass", description: "Provider permission mode: default, plan, auto, or bypass." },
-      { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." }
+      { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." },
+      { name: "worktreeMode", default: "auto", description: "Worktree isolation mode: auto, required, off, or main." },
+      { name: "worktreeRoot", default: "~/.hasna/loops/worktrees", description: "Base directory for OpenLoops-managed git worktrees." },
+      { name: "worktreeBranchPrefix", default: "openloops", description: "Branch prefix for generated task/event worktree branches." }
     ]
   },
   {
@@ -5329,6 +5387,8 @@ var TEMPLATE_SUMMARIES = [
       { name: "eventSource", required: true, description: "Hasna event source." },
       { name: "eventJson", required: true, description: "Full event envelope JSON." },
       { name: "projectPath", required: true, description: "Repository or project working directory." },
+      { name: "routeProjectPath", description: "Canonical project path used for scheduler concurrency limits." },
+      { name: "projectGroup", description: "Optional project group used for scheduler concurrency limits." },
       { name: "provider", default: "codewith", description: "Agent provider: codewith, claude, cursor, opencode, aicopilot, or codex." },
       { name: "authProfile", description: "Provider-native auth profile, currently Codewith." },
       { name: "authProfilePool", description: "Comma-separated provider-native auth profiles; worker/verifier are selected deterministically." },
@@ -5338,7 +5398,10 @@ var TEMPLATE_SUMMARIES = [
       { name: "model", description: "Provider model." },
       { name: "variant", description: "Provider reasoning/model effort variant." },
       { name: "permissionMode", default: "bypass", description: "Provider permission mode: default, plan, auto, or bypass." },
-      { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." }
+      { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." },
+      { name: "worktreeMode", default: "auto", description: "Worktree isolation mode: auto, required, off, or main." },
+      { name: "worktreeRoot", default: "~/.hasna/loops/worktrees", description: "Base directory for OpenLoops-managed git worktrees." },
+      { name: "worktreeBranchPrefix", default: "openloops", description: "Branch prefix for generated event worktree branches." }
     ]
   },
   {
@@ -5350,6 +5413,8 @@ var TEMPLATE_SUMMARIES = [
       { name: "objective", required: true, description: "Narrow goal-mode objective for the worker." },
       { name: "prompt", description: "Optional extra worker prompt details." },
       { name: "projectPath", required: true, description: "Repository or project working directory." },
+      { name: "routeProjectPath", description: "Canonical project path used for scheduler concurrency limits." },
+      { name: "projectGroup", description: "Optional project group used for scheduler concurrency limits." },
       { name: "provider", default: "codewith", description: "Agent provider: codewith, claude, cursor, opencode, aicopilot, or codex." },
       { name: "authProfile", description: "Provider-native auth profile, currently Codewith." },
       { name: "authProfilePool", description: "Comma-separated provider-native auth profiles; worker/verifier are selected deterministically." },
@@ -5360,6 +5425,9 @@ var TEMPLATE_SUMMARIES = [
       { name: "variant", description: "Provider reasoning/model effort variant." },
       { name: "permissionMode", default: "bypass", description: "Provider permission mode: default, plan, auto, or bypass." },
       { name: "sandbox", default: "danger-full-access", description: "Provider sandbox mode." },
+      { name: "worktreeMode", default: "auto", description: "Worktree isolation mode: auto, required, off, or main." },
+      { name: "worktreeRoot", default: "~/.hasna/loops/worktrees", description: "Base directory for OpenLoops-managed git worktrees." },
+      { name: "worktreeBranchPrefix", default: "openloops", description: "Branch prefix for generated bounded-agent worktree branches." },
       { name: "timeoutMs", default: "2700000", description: "Step timeout in milliseconds." }
     ]
   }
@@ -5401,6 +5469,183 @@ function accountForRole(input, role, seed) {
     return input.verifierAccount;
   return rolePoolValue(input.accountPool, seed, role) ?? input.account;
 }
+function slugSegment(value, fallback = "item") {
+  const slug = (value ?? "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72);
+  return slug || fallback;
+}
+function stableHex(seed) {
+  return stableIndex(seed, 4294967295).toString(16).padStart(8, "0");
+}
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function normalizeWorktreeMode(mode) {
+  const value = mode ?? "auto";
+  if (!["auto", "required", "off", "main"].includes(value)) {
+    throw new Error(`worktreeMode must be one of auto, required, off, or main`);
+  }
+  return value;
+}
+function defaultWorktreeRoot(root) {
+  if (root?.trim()) {
+    const expanded = root.trim().replace(/^~(?=$|\/)/, homedir3());
+    return isAbsolute(expanded) ? expanded : resolve(expanded);
+  }
+  return join3(homedir3(), ".hasna", "loops", "worktrees");
+}
+function gitRootFor(path) {
+  if (!existsSync3(path))
+    return;
+  try {
+    return execFileSync("git", ["-C", path, "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return;
+  }
+}
+function prepareWorktreeCommand(plan) {
+  const repo = shellQuote2(plan.repoRoot);
+  const path = shellQuote2(plan.path);
+  const branch = shellQuote2(plan.branch);
+  return [
+    "set -euo pipefail",
+    `repo=${repo}`,
+    `path=${path}`,
+    `branch=${branch}`,
+    'resolve_path() { cd "$1" && pwd -P; }',
+    "git_common_dir() {",
+    '  local base="$1"',
+    "  local common",
+    '  common="$(git -C "$base" rev-parse --git-common-dir)"',
+    '  case "$common" in',
+    '    /*) printf "%s\\n" "$common" ;;',
+    '    *) (cd "$base" && cd "$common" && pwd -P) ;;',
+    "  esac",
+    "}",
+    'mkdir -p "$(dirname "$path")"',
+    'if [ -e "$path" ]; then',
+    '  if [ -L "$path" ]; then',
+    '    printf "refusing symlinked worktree path %s\\n" "$path" >&2',
+    "    exit 1",
+    "  fi",
+    '  if git -C "$path" rev-parse --is-inside-work-tree >/dev/null 2>&1; then',
+    '    expected_common="$(git_common_dir "$repo")"',
+    '    actual_common="$(git_common_dir "$path")"',
+    '    if [ "$actual_common" != "$expected_common" ]; then',
+    '      printf "existing worktree %s belongs to different git common dir\\n" "$path" >&2',
+    '      printf "expected %s got %s\\n" "$expected_common" "$actual_common" >&2',
+    "      exit 1",
+    "    fi",
+    '    actual_top="$(git -C "$path" rev-parse --show-toplevel)"',
+    '    actual_top="$(resolve_path "$actual_top")"',
+    '    expected_top="$(resolve_path "$path")"',
+    '    if [ "$actual_top" != "$expected_top" ]; then',
+    '      printf "existing worktree top-level mismatch for %s: %s\\n" "$path" "$actual_top" >&2',
+    "      exit 1",
+    "    fi",
+    '    actual_branch="$(git -C "$path" branch --show-current)"',
+    '    if [ "$actual_branch" != "$branch" ]; then',
+    '      printf "existing worktree %s is on branch %s, expected %s\\n" "$path" "$actual_branch" "$branch" >&2',
+    "      exit 1",
+    "    fi",
+    '    printf "existing worktree %s branch %s\\n" "$path" "$branch"',
+    "    exit 0",
+    "  fi",
+    '  printf "refusing to overwrite non-git path: %s\\n" "$path" >&2',
+    "  exit 1",
+    "fi",
+    'git -C "$repo" rev-parse --is-inside-work-tree >/dev/null',
+    'if git -C "$repo" show-ref --verify --quiet "refs/heads/$branch"; then',
+    '  git -C "$repo" worktree add "$path" "$branch"',
+    "else",
+    '  git -C "$repo" worktree add -b "$branch" "$path" HEAD',
+    "fi",
+    'printf "prepared worktree %s branch %s\\n" "$path" "$branch"'
+  ].join(`
+`);
+}
+function worktreePlan(input, seed) {
+  const mode = normalizeWorktreeMode(input.worktreeMode);
+  const originalCwd = input.projectPath;
+  if (mode === "off" || mode === "main") {
+    return {
+      mode,
+      enabled: false,
+      originalCwd,
+      cwd: originalCwd,
+      reason: mode === "main" ? "explicit main/default checkout mode" : "worktree mode disabled"
+    };
+  }
+  const repoRoot = gitRootFor(originalCwd);
+  if (!repoRoot) {
+    if (mode === "required") {
+      throw new Error(`worktreeMode=required but projectPath is not an existing git repository: ${originalCwd}`);
+    }
+    return {
+      mode,
+      enabled: false,
+      originalCwd,
+      cwd: originalCwd,
+      reason: "projectPath is not an existing git repository"
+    };
+  }
+  const root = defaultWorktreeRoot(input.worktreeRoot);
+  const repoSlug = slugSegment(basename2(repoRoot), "repo");
+  const seedSlug = `${slugSegment(seed, "run").slice(0, 48)}-${stableHex(`${repoRoot}:${seed}`)}`;
+  const worktreePath = join3(root, repoSlug, seedSlug);
+  const relativeCwd = relative(repoRoot, originalCwd);
+  const cwd = relativeCwd && !relativeCwd.startsWith("..") && !isAbsolute(relativeCwd) ? join3(worktreePath, relativeCwd) : worktreePath;
+  const branchPrefix = (input.worktreeBranchPrefix?.trim() || "openloops").replace(/^\/+|\/+$/g, "") || "openloops";
+  const branch = `${branchPrefix}/${repoSlug}/${seedSlug}`;
+  const prepareStep = {
+    id: "prepare-worktree",
+    name: "Prepare Worktree",
+    description: "Create or reuse the isolated OpenLoops git worktree for this workflow run.",
+    target: {
+      type: "command",
+      command: "bash",
+      args: ["-lc", prepareWorktreeCommand({ repoRoot, path: worktreePath, branch })],
+      cwd: repoRoot,
+      timeoutMs: 5 * 60000
+    },
+    timeoutMs: 5 * 60000
+  };
+  return {
+    mode,
+    enabled: true,
+    originalCwd,
+    cwd,
+    repoRoot,
+    root,
+    path: worktreePath,
+    branch,
+    prepareStep
+  };
+}
+function worktreePrompt(plan) {
+  if (plan.enabled) {
+    return [
+      "OpenLoops worktree policy:",
+      "- Use the isolated git worktree as the only writeable repository checkout for this task/event.",
+      `- Worktree cwd: ${plan.cwd}`,
+      `- Worktree root: ${plan.path}`,
+      `- Branch: ${plan.branch}`,
+      `- Original checkout: ${plan.originalCwd}`,
+      "- Do not mutate the original checkout/main branch except for read-only inspection.",
+      "- Preserve unrelated changes in both the original checkout and this worktree."
+    ].join(`
+`);
+  }
+  return [
+    "OpenLoops worktree policy:",
+    `- Worktree mode ${plan.mode} did not select an isolated worktree: ${plan.reason ?? "not enabled"}.`,
+    `- Cwd: ${plan.cwd}`,
+    "- Do not create ad hoc worktrees unless the task itself explicitly requires one."
+  ].join(`
+`);
+}
 function assertNativeAuthProfileSupport(input, provider) {
   if (provider === "codewith")
     return;
@@ -5409,7 +5654,7 @@ function assertNativeAuthProfileSupport(input, provider) {
     return;
   throw new Error(`authProfile, authProfilePool, workerAuthProfile, and verifierAuthProfile are supported only for provider codewith; use account/accountPool for ${provider} profile isolation`);
 }
-function agentTarget(input, prompt, role, seed) {
+function agentTarget(input, prompt, role, seed, plan) {
   const provider = input.provider ?? "codewith";
   assertNativeAuthProfileSupport(input, provider);
   const sandbox = input.sandbox ?? (provider === "codewith" || provider === "codex" ? "danger-full-access" : provider === "cursor" ? "disabled" : undefined);
@@ -5417,7 +5662,7 @@ function agentTarget(input, prompt, role, seed) {
     type: "agent",
     provider,
     prompt,
-    cwd: input.projectPath,
+    cwd: plan.cwd,
     model: input.model,
     variant: input.variant,
     agent: input.agent,
@@ -5425,10 +5670,33 @@ function agentTarget(input, prompt, role, seed) {
     configIsolation: "safe",
     permissionMode: input.permissionMode ?? "bypass",
     sandbox,
+    worktree: {
+      mode: plan.mode,
+      enabled: plan.enabled,
+      originalCwd: plan.originalCwd,
+      cwd: plan.cwd,
+      repoRoot: plan.repoRoot,
+      root: plan.root,
+      path: plan.path,
+      branch: plan.branch,
+      reason: plan.reason
+    },
+    routing: {
+      projectPath: input.routeProjectPath ?? input.projectPath,
+      ...input.projectGroup ? { projectGroup: input.projectGroup } : {}
+    },
     account: accountForRole(input, role, seed),
     timeoutMs: 45 * 60000
   };
 }
+function workflowStepsWithWorktree(plan, steps) {
+  if (!plan.prepareStep)
+    return steps;
+  return [
+    plan.prepareStep,
+    ...steps.map((step) => step.id === "worker" ? { ...step, dependsOn: [...new Set([...step.dependsOn ?? [], plan.prepareStep.id])] } : step)
+  ];
+}
 function listLoopTemplates() {
   return TEMPLATE_SUMMARIES.map((template) => structuredClone(template));
 }
@@ -5440,18 +5708,30 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     throw new Error("taskId is required");
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
+  const plan = worktreePlan(input, input.taskId);
   const taskContext = {
     taskId: input.taskId,
     taskTitle: input.taskTitle,
     taskDescription: input.taskDescription,
     eventId: input.eventId,
     eventType: input.eventType,
-    projectPath: input.projectPath
+    projectPath: input.projectPath,
+    routeProjectPath: input.routeProjectPath,
+    projectGroup: input.projectGroup,
+    worktree: {
+      mode: plan.mode,
+      enabled: plan.enabled,
+      cwd: plan.cwd,
+      path: plan.path,
+      branch: plan.branch,
+      reason: plan.reason
+    }
   };
   const workerPrompt = [
     `/goal Complete todos task ${input.taskId} in ${input.projectPath}.`,
     "",
     "You are the worker agent for a task-triggered OpenLoops workflow.",
+    worktreePrompt(plan),
     "Investigate first before changing files. Use the todos CLI as the source of truth for the task.",
     "Claim/start the task if appropriate, inspect the repository/project state, implement only the task scope, run focused validation, preserve unrelated user changes, and update the task with comments, evidence, changed files, commits, and blockers.",
     "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
@@ -5464,6 +5744,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     `/goal Verify todos task ${input.taskId} after the worker step.`,
     "",
     "You are the verifier agent for a task-triggered OpenLoops workflow.",
+    worktreePrompt(plan),
     "Use fresh context. Inspect the task, repository state, commits, tests, and worker evidence. Act as an adversarial reviewer focused on correctness, regressions, missing tests, security, and incomplete requirements.",
     "If the work is valid, record verification evidence in todos and mark/leave the task in the correct completed state according to the todos CLI. If it is not valid, add precise follow-up tasks or comments and leave the original task open or blocked with clear evidence.",
     "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
@@ -5476,12 +5757,12 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     name: `todos-task-${input.taskId.slice(0, 8)}-worker-verifier`,
     description: `Task-triggered worker/verifier workflow for ${taskLabel(input)}`,
     version: 1,
-    steps: [
+    steps: workflowStepsWithWorktree(plan, [
       {
         id: "worker",
         name: "Worker",
         description: "Implement the todos task and record evidence.",
-        target: agentTarget(input, workerPrompt, "worker", input.taskId),
+        target: agentTarget(input, workerPrompt, "worker", input.taskId, plan),
         timeoutMs: 45 * 60000
       },
       {
@@ -5489,10 +5770,10 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
         name: "Verifier",
         description: "Adversarially verify worker output and update todos.",
         dependsOn: ["worker"],
-        target: agentTarget(input, verifierPrompt, "verifier", input.taskId),
+        target: agentTarget(input, verifierPrompt, "verifier", input.taskId, plan),
         timeoutMs: 30 * 60000
       }
-    ]
+    ])
   };
 }
 function renderEventWorkerVerifierWorkflow(input) {
@@ -5506,18 +5787,31 @@ function renderEventWorkerVerifierWorkflow(input) {
     throw new Error("eventJson is required");
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
+  const seed = `${input.eventSource}:${input.eventType}:${input.eventId}`;
+  const plan = worktreePlan(input, seed);
   const eventContext = {
     eventId: input.eventId,
     eventType: input.eventType,
     eventSource: input.eventSource,
     eventSubject: input.eventSubject,
     eventMessage: input.eventMessage,
-    projectPath: input.projectPath
+    projectPath: input.projectPath,
+    routeProjectPath: input.routeProjectPath,
+    projectGroup: input.projectGroup,
+    worktree: {
+      mode: plan.mode,
+      enabled: plan.enabled,
+      cwd: plan.cwd,
+      path: plan.path,
+      branch: plan.branch,
+      reason: plan.reason
+    }
   };
   const workerPrompt = [
     `/goal Handle Hasna event ${input.eventSource}/${input.eventType} (${input.eventId}) in ${input.projectPath}.`,
     "",
     "You are the worker agent for an event-triggered OpenLoops workflow.",
+    worktreePrompt(plan),
     "Investigate first before changing files. Read the full event envelope and decide the narrow action required by that event. Preserve unrelated user changes and update the relevant local CLI/task/knowledge system with evidence, changed files, commits, and blockers.",
     "If the event is informational or does not require action, record that finding and stop without making changes.",
     "",
@@ -5529,6 +5823,7 @@ function renderEventWorkerVerifierWorkflow(input) {
     `/goal Verify handling of Hasna event ${input.eventSource}/${input.eventType} (${input.eventId}).`,
     "",
     "You are the verifier agent for an event-triggered OpenLoops workflow.",
+    worktreePrompt(plan),
     "Use fresh context. Inspect the event, repository/project state, worker evidence, tests, and any created tasks or notes. Act as an adversarial reviewer focused on correctness, regressions, security, missing evidence, and incomplete requirements.",
     "If the work is valid, record verification evidence in the relevant local system. If it is not valid, add precise follow-up tasks/comments and leave the event handling state open or blocked with clear evidence.",
     "",
@@ -5540,12 +5835,12 @@ function renderEventWorkerVerifierWorkflow(input) {
     name: `event-${input.eventSource}-${input.eventType}-${input.eventId.slice(0, 8)}-worker-verifier`.replace(/[^a-zA-Z0-9._:-]+/g, "-"),
     description: `Event-triggered worker/verifier workflow for ${input.eventSource}/${input.eventType}`,
     version: 1,
-    steps: [
+    steps: workflowStepsWithWorktree(plan, [
       {
         id: "worker",
         name: "Worker",
         description: "Handle the Hasna event and record evidence.",
-        target: agentTarget(input, workerPrompt, "worker", `${input.eventSource}:${input.eventType}:${input.eventId}`),
+        target: agentTarget(input, workerPrompt, "worker", seed, plan),
         timeoutMs: 45 * 60000
       },
       {
@@ -5553,10 +5848,10 @@ function renderEventWorkerVerifierWorkflow(input) {
         name: "Verifier",
         description: "Adversarially verify event handling.",
         dependsOn: ["worker"],
-        target: agentTarget(input, verifierPrompt, "verifier", `${input.eventSource}:${input.eventType}:${input.eventId}`),
+        target: agentTarget(input, verifierPrompt, "verifier", seed, plan),
         timeoutMs: 30 * 60000
       }
-    ]
+    ])
   };
 }
 function renderBoundedAgentWorkerVerifierWorkflow(input) {
@@ -5565,11 +5860,13 @@ function renderBoundedAgentWorkerVerifierWorkflow(input) {
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
   const seed = `${input.projectPath}:${input.objective}`;
+  const plan = worktreePlan(input, seed);
   const timeoutMs = input.timeoutMs && Number.isFinite(input.timeoutMs) ? input.timeoutMs : 45 * 60000;
   const workerPrompt = [
     `/goal ${input.objective}`,
     "",
     "You are the worker step for a bounded OpenLoops agent workflow.",
+    worktreePrompt(plan),
     "Investigate first. Keep scope narrow, use local project/task systems as the source of truth when relevant, preserve unrelated changes, run focused validation, and record concise evidence.",
     "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
     input.prompt ? "" : undefined,
@@ -5580,6 +5877,7 @@ function renderBoundedAgentWorkerVerifierWorkflow(input) {
     `/goal Adversarially verify: ${input.objective}`,
     "",
     "You are the verifier step for a bounded OpenLoops agent workflow.",
+    worktreePrompt(plan),
     "Use fresh context. Review the worker result for correctness, regressions, missing tests, safety, runaway-agent risk, output bounds, and incomplete evidence.",
     "If valid, record verification evidence. If invalid, create precise follow-up tasks or comments and leave the original work open. Do not make broad unrelated changes."
   ].join(`
@@ -5588,12 +5886,12 @@ function renderBoundedAgentWorkerVerifierWorkflow(input) {
     name: input.name ?? `bounded-agent-${stableIndex(seed, 4294967295).toString(16).padStart(8, "0")}-worker-verifier`,
     description: `Bounded worker/verifier workflow for ${input.objective.slice(0, 180)}`,
     version: 1,
-    steps: [
+    steps: workflowStepsWithWorktree(plan, [
       {
         id: "worker",
         name: "Worker",
         description: "Execute the bounded objective and record evidence.",
-        target: agentTarget(input, workerPrompt, "worker", seed),
+        target: agentTarget(input, workerPrompt, "worker", seed, plan),
         timeoutMs
       },
       {
@@ -5601,10 +5899,10 @@ function renderBoundedAgentWorkerVerifierWorkflow(input) {
         name: "Verifier",
         description: "Adversarially verify the bounded objective result.",
         dependsOn: ["worker"],
-        target: agentTarget(input, verifierPrompt, "verifier", seed),
+        target: agentTarget(input, verifierPrompt, "verifier", seed, plan),
         timeoutMs: Math.min(timeoutMs, 30 * 60000)
       }
-    ]
+    ])
   };
 }
 function renderLoopTemplate(id, values) {
@@ -5614,6 +5912,8 @@ function renderLoopTemplate(id, values) {
       taskTitle: values.taskTitle,
       taskDescription: values.taskDescription,
       projectPath: values.projectPath ?? values.cwd ?? process.cwd(),
+      routeProjectPath: values.routeProjectPath,
+      projectGroup: values.projectGroup,
       provider: values.provider,
       authProfile: values.authProfile,
       authProfilePool: listVar(values.authProfilePool),
@@ -5626,6 +5926,9 @@ function renderLoopTemplate(id, values) {
       agent: values.agent,
       permissionMode: values.permissionMode,
       sandbox: values.sandbox,
+      worktreeMode: values.worktreeMode,
+      worktreeRoot: values.worktreeRoot,
+      worktreeBranchPrefix: values.worktreeBranchPrefix,
       eventId: values.eventId,
       eventType: values.eventType
     });
@@ -5639,6 +5942,8 @@ function renderLoopTemplate(id, values) {
       eventMessage: values.eventMessage,
       eventJson: values.eventJson ?? "",
       projectPath: values.projectPath ?? values.cwd ?? process.cwd(),
+      routeProjectPath: values.routeProjectPath,
+      projectGroup: values.projectGroup,
       provider: values.provider,
       authProfile: values.authProfile,
       authProfilePool: listVar(values.authProfilePool),
@@ -5650,7 +5955,10 @@ function renderLoopTemplate(id, values) {
       variant: values.variant,
       agent: values.agent,
       permissionMode: values.permissionMode,
-      sandbox: values.sandbox
+      sandbox: values.sandbox,
+      worktreeMode: values.worktreeMode,
+      worktreeRoot: values.worktreeRoot,
+      worktreeBranchPrefix: values.worktreeBranchPrefix
     });
   }
   if (id === BOUNDED_AGENT_WORKER_VERIFIER_TEMPLATE_ID) {
@@ -5659,6 +5967,8 @@ function renderLoopTemplate(id, values) {
       objective: values.objective ?? "",
       prompt: values.prompt,
       projectPath: values.projectPath ?? values.cwd ?? process.cwd(),
+      routeProjectPath: values.routeProjectPath,
+      projectGroup: values.projectGroup,
       provider: values.provider,
       authProfile: values.authProfile,
       authProfilePool: listVar(values.authProfilePool),
@@ -5671,6 +5981,9 @@ function renderLoopTemplate(id, values) {
       agent: values.agent,
       permissionMode: values.permissionMode,
       sandbox: values.sandbox,
+      worktreeMode: values.worktreeMode,
+      worktreeRoot: values.worktreeRoot,
+      worktreeBranchPrefix: values.worktreeBranchPrefix,
       timeoutMs: values.timeoutMs ? Number(values.timeoutMs) : undefined
     });
   }
@@ -5922,9 +6235,9 @@ function ensureTodosTaskList(project, slug, name, description) {
 }
 function backupLoopsDatabase(reason) {
   const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+$/, "Z");
-  const backupDir = join3(dataDir(), "backups");
+  const backupDir = join4(dataDir(), "backups");
   mkdirSync5(backupDir, { recursive: true, mode: 448 });
-  const backupPath = join3(backupDir, `loops.db.bak-${reason}-${stamp}`);
+  const backupPath = join4(backupDir, `loops.db.bak-${reason}-${stamp}`);
   const db = new Database2(dbPath(), { readonly: true });
   try {
     writeFileSync3(backupPath, db.serialize(), { mode: 384 });
@@ -5938,11 +6251,11 @@ function stableHash(parts) {
 `)).digest("hex").slice(0, 16);
 }
 function routeCursorsPath() {
-  return join3(dataDir(), "route-cursors.json");
+  return join4(dataDir(), "route-cursors.json");
 }
 function readRouteCursors() {
   const path = routeCursorsPath();
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return {};
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf8"));
@@ -5963,7 +6276,7 @@ function writeRouteEvidence(kind, value, evidenceDir) {
     return;
   mkdirSync5(evidenceDir, { recursive: true, mode: 448 });
   const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\./g, "");
-  const evidencePath = join3(evidenceDir, `${kind}-${stamp}-${randomUUID().slice(0, 8)}.json`);
+  const evidencePath = join4(evidenceDir, `${kind}-${stamp}-${randomUUID().slice(0, 8)}.json`);
   writeFileSync3(evidencePath, JSON.stringify(value, null, 2), { mode: 384, flag: "wx" });
   return evidencePath;
 }
@@ -6079,7 +6392,7 @@ function eventMetadata(event) {
 function stringField(value) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
-function slugSegment(value, fallback = "event") {
+function slugSegment2(value, fallback = "event") {
   return value.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-|-$/g, "").slice(0, 80) || fallback;
 }
 function stableSuffix(value) {
@@ -6218,6 +6531,111 @@ function taskRouteEligibility(data, metadata) {
   }
   return { eligible: true, tags };
 }
+function routeThrottleLimitsFromOpts(opts) {
+  return {
+    maxActive: positiveInteger(opts.maxActive, "--max-active"),
+    maxActivePerProject: positiveInteger(opts.maxActivePerProject, "--max-active-per-project"),
+    maxActivePerProjectGroup: positiveInteger(opts.maxActivePerProjectGroup, "--max-active-per-project-group")
+  };
+}
+function hasThrottleLimits(limits) {
+  return limits.maxActive !== undefined || limits.maxActivePerProject !== undefined || limits.maxActivePerProjectGroup !== undefined;
+}
+function normalizeRoutePath(value) {
+  if (!value?.trim())
+    return;
+  const resolved = resolve2(value.trim());
+  let canonical = resolved;
+  try {
+    canonical = realpathSync(resolved);
+  } catch {
+    return canonical;
+  }
+  const gitRoot = spawnSync5("git", ["-C", canonical, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  if (gitRoot.status === 0 && gitRoot.stdout.trim()) {
+    try {
+      return realpathSync(gitRoot.stdout.trim());
+    } catch {
+      return resolve2(gitRoot.stdout.trim());
+    }
+  }
+  return canonical;
+}
+function routeProjectGroup(optsGroup, data, metadata) {
+  return optsGroup?.trim() || taskEventField(data, ["project_group", "projectGroup", "repo_group", "repoGroup", "workspace_group", "workspaceGroup"]) || taskEventField(metadata, ["project_group", "projectGroup", "repo_group", "repoGroup", "workspace_group", "workspaceGroup"]);
+}
+function firstWorkflowRouting(workflow) {
+  for (const step of workflow.steps) {
+    if (step.target.type !== "agent")
+      continue;
+    const target = step.target;
+    const projectPath = normalizeRoutePath(target.routing?.projectPath ?? target.worktree?.originalCwd ?? target.cwd);
+    const projectGroup = target.routing?.projectGroup?.trim();
+    if (projectPath || projectGroup) {
+      return {
+        ...projectPath ? { projectPath } : {},
+        ...projectGroup ? { projectGroup } : {}
+      };
+    }
+  }
+  return;
+}
+function activeWorkflowLoopRoutes(store) {
+  const values = [];
+  for (const loop of store.listLoops({ status: "active", limit: 1e4 })) {
+    if (loop.target.type !== "workflow")
+      continue;
+    const workflow = store.getWorkflow(loop.target.workflowId);
+    if (!workflow || workflow.status !== "active")
+      continue;
+    const routing = firstWorkflowRouting(workflow);
+    if (routing)
+      values.push({ loop, routing });
+  }
+  return values;
+}
+function routeThrottleDecision(store, args) {
+  const projectPath = normalizeRoutePath(args.projectPath) ?? resolve2(args.projectPath);
+  const projectGroup = args.projectGroup?.trim() || undefined;
+  const active = activeWorkflowLoopRoutes(store);
+  const counts = {
+    global: active.length,
+    project: active.filter((entry) => normalizeRoutePath(entry.routing.projectPath) === projectPath).length
+  };
+  if (projectGroup)
+    counts.projectGroup = active.filter((entry) => entry.routing.projectGroup?.trim() === projectGroup).length;
+  const base = {
+    projectPath,
+    ...projectGroup ? { projectGroup } : {},
+    limits: args.limits,
+    counts
+  };
+  if (args.limits.maxActive !== undefined && counts.global >= args.limits.maxActive) {
+    return { ...base, allowed: false, reason: `global active workflow limit reached (${counts.global}/${args.limits.maxActive})` };
+  }
+  if (args.limits.maxActivePerProject !== undefined && counts.project >= args.limits.maxActivePerProject) {
+    return { ...base, allowed: false, reason: `project active workflow limit reached (${counts.project}/${args.limits.maxActivePerProject})` };
+  }
+  if (projectGroup && args.limits.maxActivePerProjectGroup !== undefined && counts.projectGroup !== undefined && counts.projectGroup >= args.limits.maxActivePerProjectGroup) {
+    return {
+      ...base,
+      allowed: false,
+      reason: `project-group active workflow limit reached (${counts.projectGroup}/${args.limits.maxActivePerProjectGroup})`
+    };
+  }
+  return { ...base, allowed: true };
+}
+function routeThrottleDryRunPreview(args) {
+  const projectPath = normalizeRoutePath(args.projectPath) ?? resolve2(args.projectPath);
+  const projectGroup = args.projectGroup?.trim() || undefined;
+  return {
+    evaluated: false,
+    reason: "not evaluated in dry-run because opening the live loop store may create or migrate the database",
+    projectPath,
+    ...projectGroup ? { projectGroup } : {},
+    limits: args.limits
+  };
+}
 async function readEventEnvelopeFromStdin() {
   const raw = process.env.HASNA_EVENT_JSON || await Bun.stdin.text();
   const event = JSON.parse(raw);
@@ -6231,6 +6649,283 @@ async function readEventEnvelopeFromStdin() {
     throw new Error("event.source is required");
   return event;
 }
+function routeTodosTaskEvent(event, opts) {
+  const data = eventData(event);
+  const metadata = eventMetadata(event);
+  const taskId = taskEventField(data, ["id", "task_id", "taskId"]);
+  if (!taskId)
+    throw new Error("todos task event is missing task id in data.id, data.task_id, data.task.id, or data.payload.id");
+  const eligibility = taskRouteEligibility(data, metadata);
+  if (!eligibility.eligible) {
+    return {
+      kind: "skipped",
+      value: { skipped: true, reason: eligibility.reason, event, taskId, eligibility },
+      human: `skipped task ${taskId}: ${eligibility.reason}`
+    };
+  }
+  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 metadataProjectPath = taskEventField(metadata, [
+    "working_dir",
+    "workingDir",
+    "project_path",
+    "projectPath",
+    "project_canonical_path",
+    "cwd"
+  ]);
+  const projectPath = opts.projectPath ?? dataProjectPath ?? metadataProjectPath ?? process.cwd();
+  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 idempotencySuffix = stableSuffix(idempotencyKey);
+  const namePrefix = opts.namePrefix ?? "event:todos-task";
+  const workflowName = `${namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
+  const loopName = `${namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:run`;
+  const legacyLoopName = `${namePrefix}:${taskId.slice(0, 8)}:${event.id.slice(0, 8)}:run`;
+  if (!opts.dryRun) {
+    const store2 = new Store;
+    try {
+      const existingLoop = store2.findLoopByName(loopName) ?? store2.findLoopByName(legacyLoopName);
+      if (existingLoop) {
+        const existingWorkflow = existingLoop.target.type === "workflow" ? store2.getWorkflow(existingLoop.target.workflowId) : undefined;
+        return {
+          kind: "deduped",
+          value: {
+            deduped: true,
+            idempotencyKey,
+            dedupedBy: existingLoop.name === loopName ? "idempotency" : "legacy-event-name",
+            event,
+            workflow: existingWorkflow ? publicWorkflow(existingWorkflow) : undefined,
+            loop: publicLoop(existingLoop)
+          },
+          human: `deduped existing loop ${existingLoop.id} (${existingLoop.name}) for event=${event.id} idempotency=${idempotencyKey}`
+        };
+      }
+    } finally {
+      store2.close();
+    }
+  }
+  const provider = opts.provider ?? "codewith";
+  if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider))
+    throw new Error("unsupported provider");
+  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({
+    taskId,
+    taskTitle,
+    taskDescription,
+    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,
+    permissionMode,
+    sandbox,
+    worktreeMode: opts.worktreeMode ?? "auto",
+    worktreeRoot: opts.worktreeRoot,
+    worktreeBranchPrefix: opts.worktreeBranchPrefix ?? "openloops",
+    eventId: event.id,
+    eventType: event.type
+  });
+  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 ?? "-"}`;
+  const loopInput = {
+    name: loopName,
+    description: `Run ${workflowBody.name} once for task ${taskId}; idempotency=${idempotencyKey}; event=${event.id}`,
+    schedule: { type: "once", at: new Date(Date.now() + 1000).toISOString() },
+    target: { type: "workflow", workflowId: "<created-workflow-id>" },
+    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: "todos-task-event-workflow",
+      event: event.id
+    }, {}) : undefined;
+    return {
+      kind: "created",
+      value: { deduped: false, idempotencyKey, event, workflow: workflowBody, loop: loopInput, throttle, preflight },
+      human: `dry-run ${loopName}`
+    };
+  }
+  const store = new Store;
+  try {
+    const existingWorkflowForPreflight = store.findWorkflowByName(workflowBody.name);
+    const workflowPreflightSpec = existingWorkflowForPreflight ?? workflowSpecForPreflight(workflowBody, "event-preflight");
+    const preflight = opts.preflight ? preflightStoredWorkflow(workflowPreflightSpec, {
+      name: workflowBody.name,
+      type: "todos-task-event-workflow",
+      event: event.id
+    }, {}) : undefined;
+    const outcome = store.writeTransaction(() => {
+      const existingLoop = store.findLoopByName(loopName) ?? store.findLoopByName(legacyLoopName);
+      if (existingLoop) {
+        const existingWorkflow2 = existingLoop.target.type === "workflow" ? store.getWorkflow(existingLoop.target.workflowId) : undefined;
+        return { kind: "deduped", existingLoop, existingWorkflow: existingWorkflow2 };
+      }
+      const throttle = hasThrottleLimits(throttleLimits) ? routeThrottleDecision(store, { projectPath: routeProjectPath, projectGroup, limits: throttleLimits }) : undefined;
+      if (throttle && !throttle.allowed)
+        return { kind: "throttled", throttle };
+      const existingWorkflow = store.findWorkflowByName(workflowBody.name);
+      const workflow = existingWorkflow ?? store.createWorkflow(workflowBody);
+      const loop = store.createLoop({
+        ...loopInput,
+        target: { type: "workflow", workflowId: workflow.id }
+      });
+      return { kind: "created", workflow, loop, throttle };
+    });
+    if (outcome.kind === "deduped") {
+      return {
+        kind: "deduped",
+        value: {
+          deduped: true,
+          idempotencyKey,
+          dedupedBy: outcome.existingLoop.name === loopName ? "idempotency" : "legacy-event-name",
+          event,
+          workflow: outcome.existingWorkflow ? publicWorkflow(outcome.existingWorkflow) : undefined,
+          loop: publicLoop(outcome.existingLoop)
+        },
+        human: `deduped existing loop ${outcome.existingLoop.id} (${outcome.existingLoop.name}) for event=${event.id} idempotency=${idempotencyKey}`
+      };
+    }
+    if (outcome.kind === "throttled") {
+      return {
+        kind: "throttled",
+        value: {
+          skipped: true,
+          queuedAtSource: true,
+          reason: outcome.throttle.reason,
+          idempotencyKey,
+          event,
+          throttle: outcome.throttle,
+          workflow: workflowBody,
+          loop: loopInput
+        },
+        human: `skipped task ${taskId}: ${outcome.throttle.reason}`
+      };
+    }
+    return {
+      kind: "created",
+      value: {
+        deduped: false,
+        idempotencyKey,
+        event,
+        workflow: publicWorkflow(outcome.workflow),
+        loop: publicLoop(outcome.loop),
+        throttle: outcome.throttle,
+        preflight
+      },
+      human: `created ${outcome.loop.id} (${outcome.loop.name}) workflow=${outcome.workflow.name} event=${event.id} idempotency=${idempotencyKey}`
+    };
+  } finally {
+    store.close();
+  }
+}
+function taskField(task, keys) {
+  for (const key of keys) {
+    const value = stringField(task[key]);
+    if (value)
+      return value;
+  }
+  return;
+}
+function taskListId(task) {
+  return taskField(task, ["task_list_id", "taskListId"]) ?? stringField(task.task_list?.id);
+}
+function taskProjectId(task) {
+  return taskField(task, ["project_id", "projectId"]);
+}
+function taskDrainEvent(task) {
+  const taskId = taskField(task, ["id", "task_id", "taskId"]);
+  if (!taskId)
+    throw new Error("todos ready returned a task without an id");
+  const metadata = objectField(task.metadata) ?? {};
+  const workingDir = taskField(task, ["working_dir", "workingDir", "project_path", "projectPath", "cwd"]);
+  const data = {
+    ...task,
+    id: taskId,
+    title: taskField(task, ["title"]),
+    description: taskField(task, ["description", "body"]),
+    status: taskField(task, ["status"]),
+    tags: tagsFromValue(task.tags),
+    metadata
+  };
+  if (workingDir) {
+    data.working_dir = workingDir;
+    data.project_path = taskField(task, ["project_path", "projectPath"]) ?? workingDir;
+    data.cwd = taskField(task, ["cwd"]) ?? workingDir;
+  }
+  const time = new Date().toISOString();
+  return {
+    id: `drain-todos-task-${taskId}`,
+    type: "task.created",
+    source: "@hasna/todos",
+    subject: taskId,
+    severity: "info",
+    data,
+    time,
+    schemaVersion: "1.0",
+    metadata: {
+      ...metadata,
+      ...workingDir ? { working_dir: workingDir, project_path: data.project_path, cwd: data.cwd } : {},
+      drained_by: "@hasna/loops",
+      drained_from: "todos ready"
+    }
+  };
+}
+function loadReadyTodosTasks(opts, scanLimit) {
+  const todosProject = opts.todosProject ?? defaultLoopsProject();
+  const args = ["--project", todosProject, "--json", "ready", "--limit", String(scanLimit)];
+  const result = runLocalCommand("todos", args, { timeoutMs: 60000 });
+  if (!result.ok)
+    throw new Error(result.stderr || result.error || "todos ready failed");
+  const parsed = JSON.parse(result.stdout || "[]");
+  if (!Array.isArray(parsed))
+    throw new Error("todos ready --json returned a non-array value");
+  return parsed;
+}
+function resolveTaskListFilter(todosProject, filter) {
+  const wanted = filter?.trim();
+  if (!wanted)
+    return;
+  const result = runLocalCommand("todos", ["--project", todosProject, "--json", "task-lists"], { timeoutMs: 30000 });
+  if (!result.ok)
+    throw new Error(result.stderr || result.error || "failed to list todos task lists");
+  const values = JSON.parse(result.stdout || "[]");
+  const match = values.find((entry) => entry.id === wanted || entry.slug === wanted || entry.name === wanted);
+  return match?.id ?? wanted;
+}
+function taskMatchesDrainFilters(task, filters) {
+  if (filters.projectId && taskProjectId(task) !== filters.projectId)
+    return false;
+  if (filters.taskListId && taskListId(task) !== filters.taskListId)
+    return false;
+  if (filters.tags.length) {
+    const taskTags = new Set(tagsFromValue(task.tags));
+    for (const tag of filters.tags) {
+      if (!taskTags.has(tag))
+        return false;
+    }
+  }
+  return true;
+}
 function providerAuthProfileFromOpts(opts, provider) {
   if (!opts.authProfile)
     return;
@@ -6381,119 +7076,94 @@ templates.command("create-workflow <id>").description("render and store a templa
   }
 });
 var eventsHandle = events.command("handle").description("handle a Hasna event envelope");
-eventsHandle.command("todos-task").description("create a one-shot worker/verifier workflow loop for a todos task 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("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--project-path <path>", "fallback project/repo working directory").option("--name-prefix <prefix>", "workflow/loop name prefix", "event:todos-task").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) => {
+eventsHandle.command("todos-task").description("create a one-shot worker/verifier workflow loop for a todos task 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("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").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 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 taskId = taskEventField(data, ["id", "task_id", "taskId"]);
-  if (!taskId)
-    throw new Error("todos task event is missing task id in data.id, data.task_id, data.task.id, or data.payload.id");
-  const eligibility = taskRouteEligibility(data, metadata);
-  if (!eligibility.eligible) {
-    print({ skipped: true, reason: eligibility.reason, event, taskId, eligibility }, `skipped task ${taskId}: ${eligibility.reason}`);
-    return;
-  }
-  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 metadataProjectPath = taskEventField(metadata, [
-    "working_dir",
-    "workingDir",
-    "project_path",
-    "projectPath",
-    "project_canonical_path",
-    "cwd"
-  ]);
-  const projectPath = opts.projectPath ?? dataProjectPath ?? metadataProjectPath ?? process.cwd();
-  const idempotencyKey = `todos-task:${taskId}:${event.type}`;
-  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 = renderTodosTaskWorkerVerifierWorkflow({
-    taskId,
-    taskTitle,
-    taskDescription,
-    projectPath,
-    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,
-    permissionMode,
-    sandbox,
-    eventId: event.id,
-    eventType: event.type
-  });
-  const idempotencySuffix = stableSuffix(idempotencyKey);
-  workflowBody.name = `${opts.namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
-  workflowBody.description = `Task-triggered worker/verifier workflow for ${taskTitle ?? taskId} from ${event.source}/${event.type}; ` + `idempotency=${idempotencyKey}; event=${event.id}`;
-  const loopName = `${opts.namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:run`;
-  const legacyLoopName = `${opts.namePrefix}:${taskId.slice(0, 8)}:${event.id.slice(0, 8)}:run`;
-  const loopInput = {
-    name: loopName,
-    description: `Run ${workflowBody.name} once for task ${taskId}; idempotency=${idempotencyKey}; event=${event.id}`,
-    schedule: { type: "once", at: new Date(Date.now() + 1000).toISOString() },
-    target: { type: "workflow", workflowId: "<created-workflow-id>" },
-    overlap: "skip",
-    maxAttempts: 1,
-    retryDelayMs: 60000,
-    leaseMs: 90 * 60000
+  const result = routeTodosTaskEvent(event, opts);
+  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("--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("--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("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").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 || 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,
+    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,
+    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 }))
   };
-  if (opts.dryRun) {
-    const preflight = opts.preflight ? preflightStoredWorkflow(workflowSpecForPreflight(workflowBody, "event-preflight"), {
-      name: workflowBody.name,
-      type: "todos-task-event-workflow",
-      event: event.id
-    }, {}) : undefined;
-    print({ deduped: false, idempotencyKey, event, workflow: workflowBody, loop: loopInput, preflight }, `dry-run ${loopName}`);
-    return;
-  }
-  const store = new Store;
-  try {
-    const existingLoop = store.findLoopByName(loopName) ?? store.findLoopByName(legacyLoopName);
-    if (existingLoop) {
-      const existingWorkflow2 = existingLoop.target.type === "workflow" ? store.getWorkflow(existingLoop.target.workflowId) : undefined;
-      print({
-        deduped: true,
-        idempotencyKey,
-        dedupedBy: existingLoop.name === loopName ? "idempotency" : "legacy-event-name",
-        event,
-        workflow: existingWorkflow2 ? publicWorkflow(existingWorkflow2) : undefined,
-        loop: publicLoop(existingLoop)
-      }, `deduped existing loop ${existingLoop.id} (${existingLoop.name}) for event=${event.id} idempotency=${idempotencyKey}`);
-      return;
-    }
-    const existingWorkflow = store.findWorkflowByName(workflowBody.name);
-    const workflowPreflightSpec = existingWorkflow ?? workflowSpecForPreflight(workflowBody, "event-preflight");
-    const preflight = opts.preflight ? preflightStoredWorkflow(workflowPreflightSpec, {
-      name: workflowBody.name,
-      type: "todos-task-event-workflow",
-      event: event.id
-    }, {}) : undefined;
-    const workflow = existingWorkflow ?? store.createWorkflow(workflowBody);
-    const loop = store.createLoop({
-      ...loopInput,
-      target: { type: "workflow", workflowId: workflow.id }
-    });
-    print({ deduped: false, idempotencyKey, event, workflow: publicWorkflow(workflow), loop: publicLoop(loop), preflight }, `created ${loop.id} (${loop.name}) workflow=${workflow.name} event=${event.id} idempotency=${idempotencyKey}`);
-  } finally {
-    store.close();
-  }
+  const evidencePath = writeRouteEvidence("todos-task-drain", report, opts.evidenceDir);
+  print({ ...report, evidencePath }, `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped}`);
 });
-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("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").option("--project-path <path>", "fallback project/repo working directory").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) => {
+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("--permission-mode <mode>", "provider permission mode: default, plan, auto, or bypass", "bypass").option("--sandbox <mode>", "provider sandbox").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 projectPath = opts.projectPath ?? taskEventField(data, ["working_dir", "workingDir", "project_path", "projectPath", "cwd", "repo_path", "repoPath"]) ?? process.cwd();
+  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`;
+  if (!opts.dryRun) {
+    const store2 = new Store;
+    try {
+      const existingLoop = store2.findLoopByName(loopName);
+      if (existingLoop) {
+        const existingWorkflow = existingLoop.target.type === "workflow" ? store2.getWorkflow(existingLoop.target.workflowId) : undefined;
+        print({ deduped: true, event, workflow: existingWorkflow ? publicWorkflow(existingWorkflow) : undefined, loop: publicLoop(existingLoop) }, `deduped existing loop ${existingLoop.id} (${existingLoop.name})`);
+        return;
+      }
+    } finally {
+      store2.close();
+    }
+  }
   const provider = opts.provider;
   if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider))
     throw new Error("unsupported provider");
@@ -6508,6 +7178,8 @@ eventsHandle.command("generic").description("create a one-shot worker/verifier w
     eventMessage: stringField(event.message),
     eventJson: JSON.stringify(event),
     projectPath,
+    routeProjectPath,
+    projectGroup,
     provider,
     authProfile,
     authProfilePool: splitList(opts.authProfilePool),
@@ -6521,14 +7193,13 @@ eventsHandle.command("generic").description("create a one-shot worker/verifier w
     variant: opts.variant,
     agent: opts.agent,
     permissionMode,
-    sandbox
+    sandbox,
+    worktreeMode: opts.worktreeMode,
+    worktreeRoot: opts.worktreeRoot,
+    worktreeBranchPrefix: opts.worktreeBranchPrefix
   });
-  const eventSuffix = event.id.slice(0, 8);
-  const source = slugSegment(event.source, "source");
-  const type = slugSegment(event.type, "type");
-  workflowBody.name = `${opts.namePrefix}:${source}:${type}:${eventSuffix}:workflow`;
-  workflowBody.description = `Event-triggered worker/verifier workflow for ${event.source}/${event.type}`;
-  const loopName = `${opts.namePrefix}:${source}:${type}:${eventSuffix}:run`;
+  workflowBody.name = workflowName;
+  workflowBody.description = `Event-triggered worker/verifier workflow for ${event.source}/${event.type}; project=${projectPath}; projectGroup=${projectGroup ?? "-"}`;
   const loopInput = {
     name: loopName,
     description: `Run ${workflowBody.name} once for event ${event.id}`,
@@ -6540,35 +7211,50 @@ eventsHandle.command("generic").description("create a one-shot worker/verifier w
     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, workflow: workflowBody, loop: loopInput, preflight }, `dry-run ${loopName}`);
+    print({ event, workflow: workflowBody, loop: loopInput, throttle, preflight }, `dry-run ${loopName}`);
     return;
   }
   const store = new Store;
   try {
-    const existingLoop = store.findLoopByName(loopName);
-    if (existingLoop) {
-      const existingWorkflow2 = existingLoop.target.type === "workflow" ? store.getWorkflow(existingLoop.target.workflowId) : undefined;
-      print({ deduped: true, event, workflow: existingWorkflow2 ? publicWorkflow(existingWorkflow2) : undefined, loop: publicLoop(existingLoop) }, `deduped existing loop ${existingLoop.id} (${existingLoop.name})`);
-      return;
-    }
-    const existingWorkflow = store.findWorkflowByName(workflowBody.name);
-    const workflowPreflightSpec = existingWorkflow ?? workflowSpecForPreflight(workflowBody, "event-preflight");
+    const existingWorkflowForPreflight = store.findWorkflowByName(workflowBody.name);
+    const workflowPreflightSpec = existingWorkflowForPreflight ?? workflowSpecForPreflight(workflowBody, "event-preflight");
     const preflight = opts.preflight ? preflightStoredWorkflow(workflowPreflightSpec, {
       name: workflowBody.name,
       type: "generic-event-workflow",
       event: event.id
     }, {}) : undefined;
-    const workflow = existingWorkflow ?? store.createWorkflow(workflowBody);
-    const loop = store.createLoop({
-      ...loopInput,
-      target: { type: "workflow", workflowId: workflow.id }
+    const outcome = store.writeTransaction(() => {
+      const existingLoop = store.findLoopByName(loopName);
+      if (existingLoop) {
+        const existingWorkflow2 = existingLoop.target.type === "workflow" ? store.getWorkflow(existingLoop.target.workflowId) : undefined;
+        return { kind: "deduped", existingLoop, existingWorkflow: existingWorkflow2 };
+      }
+      const throttle = hasThrottleLimits(throttleLimits) ? routeThrottleDecision(store, { projectPath: routeProjectPath, projectGroup, limits: throttleLimits }) : undefined;
+      if (throttle && !throttle.allowed)
+        return { kind: "throttled", throttle };
+      const existingWorkflow = store.findWorkflowByName(workflowBody.name);
+      const workflow = existingWorkflow ?? store.createWorkflow(workflowBody);
+      const loop = store.createLoop({
+        ...loopInput,
+        target: { type: "workflow", workflowId: workflow.id }
+      });
+      return { kind: "created", workflow, loop, throttle };
     });
-    print({ deduped: false, event, workflow: publicWorkflow(workflow), loop: publicLoop(loop), preflight }, `created ${loop.id} (${loop.name}) workflow=${workflow.name}`);
+    if (outcome.kind === "deduped") {
+      print({ deduped: true, event, workflow: outcome.existingWorkflow ? publicWorkflow(outcome.existingWorkflow) : undefined, loop: publicLoop(outcome.existingLoop) }, `deduped existing loop ${outcome.existingLoop.id} (${outcome.existingLoop.name})`);
+      return;
+    }
+    if (outcome.kind === "throttled") {
+      print({ skipped: true, queuedAtSource: true, reason: outcome.throttle.reason, event, throttle: outcome.throttle, workflow: workflowBody, loop: loopInput }, `skipped event ${event.id}: ${outcome.throttle.reason}`);
+      return;
+    }
+    print({ deduped: false, event, workflow: publicWorkflow(outcome.workflow), loop: publicLoop(outcome.loop), throttle: outcome.throttle, preflight }, `created ${outcome.loop.id} (${outcome.loop.name}) workflow=${outcome.workflow.name}`);
   } finally {
     store.close();
   }
@@ -7402,7 +8088,7 @@ ${result.instructions.join(`
 });
 daemon.command("logs").option("-n, --lines <n>", "lines", "80").action((opts) => {
   const path = daemonLogPath();
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     console.log("");
     return;
   }