@hasna/loops 0.3.25 → 0.3.27

package/dist/index.js

@@ -416,6 +416,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`);
@@ -2187,6 +2223,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();
   }
@@ -4222,6 +4271,10 @@ function loops(opts = {}) {
   return new LoopsClient(opts);
 }
 // src/lib/templates.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename, 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";
@@ -4235,6 +4288,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." },
@@ -4244,7 +4299,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." }
     ]
   },
   {
@@ -4258,6 +4316,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." },
@@ -4267,7 +4327,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." }
     ]
   },
   {
@@ -4279,6 +4342,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." },
@@ -4289,6 +4354,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." }
     ]
   }
@@ -4330,6 +4398,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 (!existsSync2(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(basename(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;
@@ -4338,7 +4583,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);
@@ -4346,7 +4591,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,
@@ -4354,10 +4599,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));
 }
@@ -4369,18 +4637,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.",
@@ -4393,6 +4673,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.",
@@ -4405,12 +4686,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
       },
       {
@@ -4418,10 +4699,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) {
@@ -4435,18 +4716,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.",
     "",
@@ -4458,6 +4752,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.",
     "",
@@ -4469,12 +4764,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
       },
       {
@@ -4482,10 +4777,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) {
@@ -4494,11 +4789,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,
@@ -4509,6 +4806,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(`
@@ -4517,12 +4815,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
       },
       {
@@ -4530,10 +4828,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) {
@@ -4543,6 +4841,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),
@@ -4555,6 +4855,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
     });
@@ -4568,6 +4871,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),
@@ -4579,7 +4884,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) {
@@ -4588,6 +4896,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),
@@ -4600,6 +4910,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
     });
   }
@@ -4617,13 +4930,13 @@ import { spawnSync as spawnSync3 } from "child_process";
 import { accessSync as accessSync2, constants as constants2 } from "fs";
 
 // src/daemon/control.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync, rmSync, writeFileSync } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2 } from "path";
 
 // src/daemon/loop.ts
 function realSleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function runLoop(opts) {
   const sleep = opts.sleep ?? realSleep;
@@ -4645,7 +4958,7 @@ async function runLoop(opts) {
 
 // src/daemon/control.ts
 function readPid(path = pidFilePath()) {
-  if (!existsSync2(path))
+  if (!existsSync3(path))
     return;
   try {
     const pid = Number(readFileSync(path, "utf8").trim());
@@ -5180,7 +5493,7 @@ function buildHealthReport(store, opts = {}) {
   };
 }
 // src/lib/hygiene.ts
-import { basename } from "path";
+import { basename as basename2 } from "path";
 var PROVIDER_TOKENS = new Set([
   "codewith",
   "claude",
@@ -5201,7 +5514,7 @@ function repoSlugFromCwd(cwd) {
     return "";
   if (cwd.includes("/.hasna/loops/"))
     return "";
-  return slugify(basename(cwd));
+  return slugify(basename2(cwd));
 }
 function scopeForLoop(loop) {
   const cwd = loop.target.type === "command" || loop.target.type === "agent" ? loop.target.cwd : undefined;

package/dist/lib/store.d.ts

@@ -179,6 +179,7 @@ export declare class Store {
     heartbeatDaemonLease(id: string, ttlMs: number, now?: Date): DaemonLease | undefined;
     releaseDaemonLease(id: string): void;
     getDaemonLease(): DaemonLease | undefined;
+    writeTransaction<T>(fn: () => T): T;
     close(): void;
 }
 export {};