@bastani/atomic 0.9.61-alpha.1 → 0.9.61-alpha.3

package/dist/builtin/workflows/src/index.js

@@ -13456,9 +13456,104 @@ var init_workflow_artifacts = __esm(() => {
   pendingArtifactPrunes = new Map;
 });
 
-// dist/builtin/workflows/src/runs/shared/worktree-generation.ts
+// dist/builtin/workflows/src/runs/shared/worktree-allocation.ts
+import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+function nextBucketId() {
+  return nextBucketIdOverride?.() ?? randomBytes(2).toString("hex");
+}
+function errorCode(error) {
+  return error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+}
+function allocateWorktreeCheckoutPath(root, repositoryName) {
+  for (let attempt = 0;attempt < MAX_BUCKET_ATTEMPTS; attempt++) {
+    const bucket = path.join(root, nextBucketId());
+    try {
+      fs.mkdirSync(bucket);
+      return path.join(bucket, repositoryName);
+    } catch (error) {
+      if (errorCode(error) === "EEXIST")
+        continue;
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to create worktree bucket ${bucket} under gitWorktreeDir ${root}: ${message}`);
+    }
+  }
+  throw new Error(`Every worktree bucket identifier under gitWorktreeDir ${root} is already in use.`);
+}
+function removeEmptyWorktreeBucket(checkout) {
+  try {
+    fs.rmdirSync(path.dirname(checkout));
+  } catch {}
+}
+function linkedGitDirectory(checkout) {
+  let pointer;
+  try {
+    if (!fs.lstatSync(path.join(checkout, ".git")).isFile())
+      return;
+    pointer = fs.readFileSync(path.join(checkout, ".git"), "utf8");
+  } catch {
+    return;
+  }
+  if (!pointer.startsWith("gitdir:"))
+    return;
+  const gitDir = pointer.slice("gitdir:".length).trim();
+  return gitDir ? path.resolve(checkout, gitDir) : undefined;
+}
+function readWorktreeOwner(gitDir) {
+  let contents;
+  try {
+    contents = fs.readFileSync(path.join(gitDir, WORKTREE_OWNER_FILENAME), "utf8");
+  } catch {
+    return;
+  }
+  try {
+    const record = JSON.parse(contents);
+    return record.version === WORKTREE_OWNER_VERSION && typeof record.ownerRunId === "string" && record.ownerRunId ? record.ownerRunId : undefined;
+  } catch {
+    return;
+  }
+}
+function findOwnedWorktreeCheckouts(root, repositoryName, ownerRunId) {
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const owned = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !BUCKET_PATTERN.test(entry.name))
+      continue;
+    const checkout = path.join(root, entry.name, repositoryName);
+    try {
+      if (!fs.lstatSync(checkout).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    const gitDir = linkedGitDirectory(checkout);
+    if (gitDir !== undefined && readWorktreeOwner(gitDir) === ownerRunId)
+      owned.push(checkout);
+  }
+  return owned.sort();
+}
+function bindWorktreeOwner(gitDir, ownerRunId) {
+  const record = { version: WORKTREE_OWNER_VERSION, ownerRunId };
+  fs.writeFileSync(path.join(gitDir, WORKTREE_OWNER_FILENAME), `${JSON.stringify(record)}
+`, {
+    encoding: "utf8",
+    flag: "wx"
+  });
+}
+var WORKTREE_OWNER_FILENAME = "atomic-workflow-run.json", WORKTREE_OWNER_VERSION = 1, BUCKET_PATTERN, MAX_BUCKET_ATTEMPTS = 65536, nextBucketIdOverride;
+var init_worktree_allocation = __esm(() => {
+  BUCKET_PATTERN = /^[0-9a-f]{4}$/;
+});
+
+// dist/builtin/workflows/src/runs/shared/worktree-generation.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 function sameFileIdentity(left, right) {
   return left.dev === right.dev && left.ino === right.ino;
 }
@@ -13468,7 +13563,7 @@ function openMainCheckoutAnchor(gitDir) {
     assertCurrent() {
       if (disposed)
         throw new Error(`cached .git identity anchor is already disposed: ${gitDir}`);
-      if (!fs.lstatSync(gitDir).isDirectory()) {
+      if (!fs2.lstatSync(gitDir).isDirectory()) {
         throw new Error(`cached main-checkout .git directory is no longer current: ${gitDir}`);
       }
     },
@@ -13478,17 +13573,17 @@ function openMainCheckoutAnchor(gitDir) {
   };
 }
 function openGitWorktreeGenerationAnchor(worktreeRoot) {
-  const gitFile = path.join(worktreeRoot, ".git");
-  if (fs.lstatSync(gitFile).isDirectory())
+  const gitFile = path2.join(worktreeRoot, ".git");
+  if (fs2.lstatSync(gitFile).isDirectory())
     return openMainCheckoutAnchor(gitFile);
-  const descriptor = fs.openSync(gitFile, "r");
+  const descriptor = fs2.openSync(gitFile, "r");
   let disposed = false;
   const anchor = {
     assertCurrent() {
       if (disposed)
         throw new Error(`cached .git identity anchor is already disposed: ${gitFile}`);
-      const held = fs.fstatSync(descriptor, { bigint: true });
-      const current = fs.lstatSync(gitFile, { bigint: true });
+      const held = fs2.fstatSync(descriptor, { bigint: true });
+      const current = fs2.lstatSync(gitFile, { bigint: true });
       if (!current.isFile() || !sameFileIdentity(held, current)) {
         throw new Error(`cached .git identity anchor no longer matches the selected checkout: ${gitFile}`);
       }
@@ -13497,7 +13592,7 @@ function openGitWorktreeGenerationAnchor(worktreeRoot) {
       if (disposed)
         return;
       disposed = true;
-      fs.closeSync(descriptor);
+      fs2.closeSync(descriptor);
     }
   };
   try {
@@ -13611,84 +13706,84 @@ var init_worktree_git_runner = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/shared/worktree-root.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 function pathFromPointer(contents, prefix, base) {
   if (!contents.startsWith(prefix))
     return;
   const value2 = contents.slice(prefix.length).trim();
   if (!value2)
     return;
-  return path2.resolve(base, value2);
+  return path3.resolve(base, value2);
 }
 function readText(file) {
   try {
-    return fs2.readFileSync(file, "utf8");
+    return fs3.readFileSync(file, "utf8");
   } catch {
     return;
   }
 }
 function samePath(left, right) {
   try {
-    const a = fs2.realpathSync.native(left);
-    const b = fs2.realpathSync.native(right);
+    const a = fs3.realpathSync.native(left);
+    const b = fs3.realpathSync.native(right);
     return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
   } catch {
     return false;
   }
 }
 function findGitRoot(cwd) {
-  let current = path2.resolve(cwd);
+  let current = path3.resolve(cwd);
   try {
-    if (!fs2.statSync(current).isDirectory())
-      current = path2.dirname(current);
+    if (!fs3.statSync(current).isDirectory())
+      current = path3.dirname(current);
   } catch {
     return;
   }
   while (true) {
     try {
-      const entry = fs2.statSync(path2.join(current, ".git"));
+      const entry = fs3.statSync(path3.join(current, ".git"));
       if (entry.isDirectory() || entry.isFile())
         return current;
     } catch {}
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current)
       return;
     current = parent;
   }
 }
 function resolveMainRepoRoot(repoRoot) {
-  const gitEntry = path2.join(repoRoot, ".git");
+  const gitEntry = path3.join(repoRoot, ".git");
   let stats;
   try {
-    stats = fs2.statSync(gitEntry);
+    stats = fs3.statSync(gitEntry);
   } catch {
     return;
   }
   if (stats.isDirectory())
-    return path2.resolve(repoRoot);
+    return path3.resolve(repoRoot);
   if (!stats.isFile())
     return;
   const pointer = readText(gitEntry);
   if (pointer === undefined)
     return;
   const gitDir = pathFromPointer(pointer, "gitdir:", repoRoot);
-  if (gitDir === undefined || path2.basename(path2.dirname(gitDir)) !== "worktrees")
+  if (gitDir === undefined || path3.basename(path3.dirname(gitDir)) !== "worktrees")
     return;
-  const commonGitDir = path2.dirname(path2.dirname(gitDir));
-  if (path2.basename(commonGitDir) !== ".git")
+  const commonGitDir = path3.dirname(path3.dirname(gitDir));
+  if (path3.basename(commonGitDir) !== ".git")
     return;
-  const backPointer = readText(path2.join(gitDir, "gitdir"));
-  const commonPointer = readText(path2.join(gitDir, "commondir"));
+  const backPointer = readText(path3.join(gitDir, "gitdir"));
+  const commonPointer = readText(path3.join(gitDir, "commondir"));
   if (backPointer === undefined || commonPointer === undefined)
     return;
-  const linkedGitEntry = path2.resolve(gitDir, backPointer.trim());
-  const declaredCommonDir = path2.resolve(gitDir, commonPointer.trim());
+  const linkedGitEntry = path3.resolve(gitDir, backPointer.trim());
+  const declaredCommonDir = path3.resolve(gitDir, commonPointer.trim());
   if (!backPointer.trim() || !commonPointer.trim())
     return;
   if (!samePath(linkedGitEntry, gitEntry) || !samePath(declaredCommonDir, commonGitDir))
     return;
-  return path2.dirname(commonGitDir);
+  return path3.dirname(commonGitDir);
 }
 function findCanonicalGitRoot(cwd) {
   const repoRoot = findGitRoot(cwd);
@@ -13697,33 +13792,31 @@ function findCanonicalGitRoot(cwd) {
 var init_worktree_root = () => {};
 
 // dist/builtin/workflows/src/runs/shared/worktree-git.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-function gitWorktreeSetupCacheKey(options) {
-  const repoRoot = repositoryRootForGitWorktree(options.cwd);
-  const { logicalRepoRoot } = cwdWithinGitRepository(options.cwd, repoRoot);
-  const worktreeRoot = resolveGitWorktreePath(options.gitWorktreeDir, logicalRepoRoot);
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+function gitWorktreeSetupCacheKey(request) {
   return JSON.stringify([
-    comparableRealPath(gitCommonDirForWorktree(repoRoot)),
-    comparablePathThroughExistingAncestor(worktreeRoot)
+    comparablePathThroughExistingAncestor(request.options.cwd),
+    comparablePathThroughExistingAncestor(request.target)
   ]);
 }
-function createGitWorktreeSetupCache() {
+function createGitWorktreeSetupCache(ownerRunId) {
   const results = new Map;
   let disposed = false;
   return {
     get(options) {
       if (disposed)
         throw new Error("Git worktree setup cache is already disposed");
-      const key = gitWorktreeSetupCacheKey(options);
+      const request = resolveGitWorktreeSetupRequest(options);
+      const key = gitWorktreeSetupCacheKey(request);
       const cached = results.get(key);
       if (cached !== undefined) {
         assertCachedGitWorktreeIdentity(cached, options);
         return cached.result;
       }
-      const result = setupGitWorktree(options);
-      results.set(key, { result, identity: captureGitWorktreeIdentity(result) });
-      return result;
+      const setup = setupGitWorktreeFromRequest(request, ownerRunId);
+      results.set(key, { ...setup, identity: captureGitWorktreeIdentity(setup) });
+      return setup.result;
     },
     dispose() {
       if (disposed)
@@ -13755,10 +13848,10 @@ function worktreeRecoveryCommand(repositoryRoot, worktreeDir) {
   return `git -C ${quoteShellArg(repositoryRoot)} worktree remove --force ${quoteShellArg(worktreeDir)}`;
 }
 function hasGrandparent(value2) {
-  const parent = path3.dirname(value2);
+  const parent = path4.dirname(value2);
   if (parent === value2)
     return false;
-  const grandparent = path3.dirname(parent);
+  const grandparent = path4.dirname(parent);
   return grandparent !== parent;
 }
 function pathAncestors(value2) {
@@ -13766,7 +13859,7 @@ function pathAncestors(value2) {
   let current = value2;
   while (true) {
     ancestors.push(current);
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current)
       return ancestors;
     current = parent;
@@ -13775,89 +13868,167 @@ function pathAncestors(value2) {
 function shouldPreserveLogicalPath(logicalPath) {
   return pathAncestors(logicalPath).some((ancestor) => {
     try {
-      return fs3.lstatSync(ancestor).isSymbolicLink() && hasGrandparent(ancestor);
+      return fs4.lstatSync(ancestor).isSymbolicLink() && hasGrandparent(ancestor);
     } catch {
       return false;
     }
   });
 }
 function canonicalizePreservingSymlinks(value2) {
-  const logicalPath = path3.resolve(value2);
+  const logicalPath = path4.resolve(value2);
   const preserveLogicalPath = shouldPreserveLogicalPath(logicalPath);
   try {
-    const canonical = fs3.realpathSync.native(logicalPath);
+    const canonical = fs4.realpathSync.native(logicalPath);
     return preserveLogicalPath && canonical !== logicalPath ? logicalPath : canonical;
   } catch {
     return logicalPath;
   }
 }
-function resolveGitWorktreePath(value2, repoRoot) {
+function resolveGitWorktreePath(value2, baseDir) {
   const trimmed = value2.trim();
   if (!trimmed)
     throw new Error("gitWorktreeDir cannot be empty");
   if (trimmed.includes("\x00")) {
     throw new Error("gitWorktreeDir contains an unusable null byte; provide a valid path or omit gitWorktreeDir.");
   }
-  return canonicalizePreservingSymlinks(path3.isAbsolute(trimmed) ? trimmed : path3.resolve(repoRoot, trimmed));
+  return canonicalizePreservingSymlinks(path4.isAbsolute(trimmed) ? trimmed : path4.resolve(baseDir, trimmed));
 }
 function comparableRealPath(value2) {
-  const realpath = fs3.realpathSync.native(value2).replace(/\\/g, "/");
+  const realpath = fs4.realpathSync.native(value2).replace(/\\/g, "/");
   return process.platform === "win32" ? realpath.toLowerCase() : realpath;
 }
-function comparablePathThroughExistingAncestor(value2) {
-  let existing = path3.resolve(value2);
+function nearestExistingAncestor(value2) {
+  let existing = path4.resolve(value2);
   const missing = [];
   while (!pathExistsSync(existing)) {
-    const parent = path3.dirname(existing);
+    const parent = path4.dirname(existing);
     if (parent === existing)
       break;
-    missing.unshift(path3.basename(existing));
+    missing.unshift(path4.basename(existing));
     existing = parent;
   }
-  const resolved = path3.resolve(comparableRealPath(existing), ...missing).replace(/\\/g, "/");
+  return { existing, missing };
+}
+function comparablePathThroughExistingAncestor(value2) {
+  const { existing, missing } = nearestExistingAncestor(value2);
+  const resolved = path4.resolve(comparableRealPath(existing), ...missing).replace(/\\/g, "/");
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
+function isFileOrLink(value2) {
+  try {
+    const entry = fs4.lstatSync(value2);
+    return entry.isFile() || entry.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function isDirectory(value2) {
+  try {
+    return fs4.statSync(value2).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function looksLikeGitDirectory(directory) {
+  if (!isDirectory(directory))
+    return false;
+  if (path4.basename(directory) === ".git")
+    return true;
+  if (!isFileOrLink(path4.join(directory, "HEAD")))
+    return false;
+  if (isFileOrLink(path4.join(directory, "commondir")))
+    return true;
+  return isDirectory(path4.join(directory, "objects")) && isDirectory(path4.join(directory, "refs"));
+}
+function enclosingGitMetadataDirectory(target) {
+  const { existing } = nearestExistingAncestor(target);
+  let realExisting = existing;
+  try {
+    realExisting = fs4.realpathSync.native(existing);
+  } catch {}
+  for (const candidate of new Set([...pathAncestors(existing), ...pathAncestors(realExisting)])) {
+    if (looksLikeGitDirectory(candidate))
+      return candidate;
+  }
+  const insideGitDir = runGitReadOnlyProbe(existing, ["rev-parse", "--is-inside-git-dir"]);
+  if (insideGitDir.status !== 0 && isGitTimeoutResult(insideGitDir)) {
+    throw new Error(`Timed out while validating gitWorktreeDir ${target}. Git reported: ${gitFailureMessage(insideGitDir)}`);
+  }
+  return insideGitDir.status === 0 && insideGitDir.stdout.trim() === "true" ? existing : undefined;
+}
+function assertSafeGitWorktreeTarget(target, invokingRoot) {
+  const gitDirectory = enclosingGitMetadataDirectory(target);
+  if (gitDirectory !== undefined) {
+    throw new Error(`gitWorktreeDir must not be inside Git metadata: ${target} is inside the Git directory ${gitDirectory}. Choose a worktree root or a plain directory outside Git metadata.`);
+  }
+  if (invokingRoot !== undefined)
+    validateWorktreeOutsideInvokingCheckout(target, invokingRoot);
+  const { existing, missing } = nearestExistingAncestor(target);
+  const workingTree = gitTopLevel(existing);
+  if (workingTree === undefined)
+    return;
+  if (missing.length === 0 && comparableRealPath(target) === comparableRealPath(workingTree))
+    return;
+  throw new Error(`gitWorktreeDir must not be inside another Git working tree: ${target} is inside ${workingTree}. Pass that checkout's root to reuse it, or a path outside every Git checkout.`);
+}
 function validateWorktreeOutsideInvokingCheckout(worktreeRoot, repoRoot) {
   const repository = comparableRealPath(repoRoot);
   const candidate = comparablePathThroughExistingAncestor(worktreeRoot);
-  const relativePath = path3.relative(repository, candidate);
+  const relativePath = path4.relative(repository, candidate);
   if (relativePath === "") {
-    throw new Error("gitWorktreeDir must not resolve to the invoking checkout; provide a separate same-repository worktree path.");
+    throw new Error("gitWorktreeDir must not resolve to the invoking checkout; provide a separate worktree path outside it.");
   }
-  if (!relativePath.startsWith(`..${path3.sep}`) && relativePath !== ".." && !path3.isAbsolute(relativePath)) {
-    throw new Error("gitWorktreeDir must be outside the invoking checkout; provide a separate same-repository worktree path.");
+  if (!relativePath.startsWith(`..${path4.sep}`) && relativePath !== ".." && !path4.isAbsolute(relativePath)) {
+    throw new Error("gitWorktreeDir must be outside the invoking checkout; provide a separate worktree path outside it.");
   }
 }
 function gitPathFromOutput(value2, cwd) {
   const trimmed = value2.trim();
   if (!trimmed)
     return;
-  return path3.isAbsolute(trimmed) ? path3.resolve(trimmed) : path3.resolve(cwd, trimmed);
+  return path4.isAbsolute(trimmed) ? path4.resolve(trimmed) : path4.resolve(cwd, trimmed);
 }
 function pathExistsSync(value2) {
+  return pathStatSync(value2) !== undefined;
+}
+function pathStatSync(value2) {
   try {
-    fs3.statSync(value2);
-    return true;
+    return fs4.statSync(value2);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
     if (code === "ENOENT" || code === "ENOTDIR")
-      return false;
+      return;
     throw error;
   }
 }
-function repositoryRootForGitWorktree(cwd) {
+function probeInvokingRepository(cwd) {
   const result = runGitReadOnlyProbe(cwd, ["rev-parse", "--show-toplevel"]);
   if (result.status !== 0) {
     if (isGitTimeoutResult(result)) {
       throw new Error(`Timed out while checking the Git repository for gitWorktreeDir from ${cwd}. Git reported: ${gitFailureMessage(result)}`);
     }
-    throw new Error(`gitWorktreeDir requires the workflow to be invoked from inside a Git repository. Start from a Git checkout or omit gitWorktreeDir. Git reported: ${gitFailureMessage(result)}`);
+    return { failure: gitFailureMessage(result) };
   }
-  const normalized = gitPathFromOutput(result.stdout, cwd);
-  if (normalized === undefined) {
+  const root = gitPathFromOutput(result.stdout, cwd);
+  if (root === undefined) {
     throw new Error(`gitWorktreeDir could not resolve the repository top level from ${cwd}: git returned an empty path.`);
   }
-  return normalized;
+  return { repository: { root, ...cwdWithinGitRepository(cwd, root) } };
+}
+function resolveGitWorktreeSetupRequest(options) {
+  const probe = probeInvokingRepository(options.cwd);
+  if ("repository" in probe) {
+    return {
+      options,
+      repository: probe.repository,
+      target: resolveGitWorktreePath(options.gitWorktreeDir, probe.repository.logicalRoot)
+    };
+  }
+  return {
+    options,
+    repositoryProbeFailure: probe.failure,
+    target: resolveGitWorktreePath(options.gitWorktreeDir, canonicalizePreservingSymlinks(options.cwd))
+  };
 }
 function gitTopLevelFromResult(result, cwd, description) {
   if (result.status !== 0) {
@@ -13893,25 +14064,25 @@ function dirnameForEachRelativeComponent(base, relativePath) {
       continue;
     if (component === "..")
       return;
-    current = path3.dirname(current);
+    current = path4.dirname(current);
   }
   return current;
 }
 function cwdWithinGitRepository(cwd, repoRoot) {
-  const sourceCwd = fs3.realpathSync.native(cwd);
-  const sourceRepoRoot = fs3.realpathSync.native(repoRoot);
-  const relativeCwd = path3.relative(sourceRepoRoot, sourceCwd);
-  const safeRelativeCwd = relativeCwd === "" || relativeCwd.startsWith("..") || path3.isAbsolute(relativeCwd) ? "" : relativeCwd;
+  const sourceCwd = fs4.realpathSync.native(cwd);
+  const sourceRepoRoot = fs4.realpathSync.native(repoRoot);
+  const relativeCwd = path4.relative(sourceRepoRoot, sourceCwd);
+  const safeRelativeCwd = relativeCwd === "" || relativeCwd.startsWith("..") || path4.isAbsolute(relativeCwd) ? "" : relativeCwd;
   const logicalCwd = canonicalizePreservingSymlinks(cwd);
   return {
     relativeCwd: safeRelativeCwd,
-    logicalRepoRoot: dirnameForEachRelativeComponent(logicalCwd, safeRelativeCwd) ?? repoRoot
+    logicalRoot: dirnameForEachRelativeComponent(logicalCwd, safeRelativeCwd) ?? repoRoot
   };
 }
 function workspaceCwdForGitWorktreeRoot(worktreeRoot, relativeCwd) {
-  return relativeCwd === "" ? worktreeRoot : path3.join(worktreeRoot, relativeCwd);
+  return relativeCwd === "" ? worktreeRoot : path4.join(worktreeRoot, relativeCwd);
 }
-function validateExistingGitWorktreeRoot(worktreeRoot, repoRoot) {
+function validateGitWorktreeRoot(worktreeRoot) {
   const topLevel = gitTopLevel(worktreeRoot);
   if (topLevel === undefined) {
     throw new Error(`gitWorktreeDir already exists but is not a Git worktree: ${worktreeRoot}`);
@@ -13919,8 +14090,18 @@ function validateExistingGitWorktreeRoot(worktreeRoot, repoRoot) {
   if (comparableRealPath(worktreeRoot) !== comparableRealPath(topLevel)) {
     throw new Error(`gitWorktreeDir already exists but is not a Git worktree root: ${worktreeRoot}. Git top-level checkout is ${topLevel}`);
   }
-  if (comparableRealPath(gitCommonDirForWorktree(repoRoot)) !== comparableRealPath(gitCommonDirForWorktree(topLevel))) {
-    throw new Error(`gitWorktreeDir already exists but does not belong to the invoking Git repository: ${worktreeRoot}`);
+  return gitCommonDirForWorktree(topLevel);
+}
+function existingGitWorktreeCommonDir(directory) {
+  return gitTopLevel(directory) === undefined ? undefined : validateGitWorktreeRoot(directory);
+}
+function sameGitCommonDir(left, right) {
+  return comparableRealPath(left) === comparableRealPath(right);
+}
+function validateCreatedGitWorktree(worktreeRoot, repository) {
+  assertSafeGitWorktreeTarget(worktreeRoot, repository.root);
+  if (!sameGitCommonDir(validateGitWorktreeRoot(worktreeRoot), gitCommonDirForWorktree(repository.root))) {
+    throw new Error(`gitWorktreeDir does not belong to the invoking Git repository: ${worktreeRoot}`);
   }
 }
 function gitDirectoryForWorktree(cwd) {
@@ -13934,26 +14115,27 @@ function gitDirectoryForWorktree(cwd) {
   return gitDir;
 }
 function captureGitWorktreeIdentitySnapshot(setup) {
-  validateWorktreeOutsideInvokingCheckout(setup.worktreeRoot, setup.repositoryRoot);
-  validateExistingGitWorktreeRoot(setup.worktreeRoot, setup.repositoryRoot);
-  const stats = fs3.statSync(setup.worktreeRoot);
+  const { worktreeRoot, repositoryRoot } = setup.result;
+  assertSafeGitWorktreeTarget(worktreeRoot, setup.invokingRoot);
+  const commonDir = validateGitWorktreeRoot(worktreeRoot);
+  const stats = fs4.statSync(worktreeRoot);
   return {
-    worktreeRealPath: comparableRealPath(setup.worktreeRoot),
-    repositoryRealPath: comparableRealPath(setup.repositoryRoot),
-    gitDirRealPath: comparableRealPath(gitDirectoryForWorktree(setup.worktreeRoot)),
-    commonDirRealPath: comparableRealPath(gitCommonDirForWorktree(setup.worktreeRoot)),
+    worktreeRealPath: comparableRealPath(worktreeRoot),
+    repositoryRealPath: comparableRealPath(repositoryRoot),
+    gitDirRealPath: comparableRealPath(gitDirectoryForWorktree(worktreeRoot)),
+    commonDirRealPath: comparableRealPath(commonDir),
     device: stats.dev,
     inode: stats.ino
   };
 }
 function captureGitWorktreeIdentity(setup) {
   const snapshot = captureGitWorktreeIdentitySnapshot(setup);
-  return { ...snapshot, generation: openGitWorktreeGenerationAnchor(setup.worktreeRoot) };
+  return { ...snapshot, generation: openGitWorktreeGenerationAnchor(setup.result.worktreeRoot) };
 }
 function assertCachedGitWorktreeIdentity(cached, options) {
   let current;
   try {
-    current = captureGitWorktreeIdentitySnapshot(cached.result);
+    current = captureGitWorktreeIdentitySnapshot(cached);
     cached.identity.generation.assertCurrent();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -13961,34 +14143,58 @@ function assertCachedGitWorktreeIdentity(cached, options) {
   }
   const expected = cached.identity;
   if (current.worktreeRealPath !== expected.worktreeRealPath || current.repositoryRealPath !== expected.repositoryRealPath || current.gitDirRealPath !== expected.gitDirRealPath || current.commonDirRealPath !== expected.commonDirRealPath || current.device !== expected.device || current.inode !== expected.inode) {
-    throw new Error(`Cached gitWorktreeDir changed before reuse: ${options.gitWorktreeDir}. Start a new run with the intended same-repository worktree.`);
-  }
+    throw new Error(`Cached gitWorktreeDir changed before reuse: ${options.gitWorktreeDir}. Start a new run with the intended worktree.`);
+  }
+}
+function requireInvokingRepository(request, action) {
+  if (request.repository !== undefined)
+    return request.repository;
+  throw new Error([
+    `gitWorktreeDir requires the workflow to be invoked from inside a Git repository to ${action}.`,
+    "Start the workflow from a checkout of the repository the new worktree should come from, or set gitWorktreeDir to the root of an existing Git worktree to reuse it from any directory.",
+    `Git reported: ${request.repositoryProbeFailure ?? "no repository"}`
+  ].join(" "));
+}
+function setupGitWorktreeFromRequest(request, ownerRunId) {
+  const { repository, target } = request;
+  assertSafeGitWorktreeTarget(target, repository?.root);
+  const entry = pathStatSync(target);
+  if (entry === undefined)
+    return createGitWorktreeAtPath(request, false);
+  if (!entry.isDirectory())
+    throw new Error(`gitWorktreeDir already exists but is not a directory: ${target}`);
+  if (fs4.readdirSync(target).length === 0)
+    return createGitWorktreeAtPath(request, true);
+  const commonDir = existingGitWorktreeCommonDir(target);
+  if (commonDir === undefined)
+    return allocateGitWorktree(request, ownerRunId);
+  const sameRepository = repository !== undefined && sameGitCommonDir(commonDir, gitCommonDirForWorktree(repository.root));
+  return {
+    result: {
+      worktreeRoot: target,
+      cwd: sameRepository ? workspaceCwdForGitWorktreeRoot(target, repository.relativeCwd) : target,
+      repositoryRoot: sameRepository ? repository.root : target,
+      created: false
+    },
+    ...repository !== undefined ? { invokingRoot: repository.root } : {}
+  };
 }
-function setupGitWorktree(options) {
-  const repoRoot = repositoryRootForGitWorktree(options.cwd);
-  const mainRoot = findCanonicalGitRoot(repoRoot);
+function createGitWorktreeAtPath(request, existingEmptyDirectory) {
+  const { target: worktreeRoot } = request;
+  const repository = requireInvokingRepository(request, `create a new worktree at ${worktreeRoot}`);
+  const mainRoot = findCanonicalGitRoot(repository.root);
   if (mainRoot === undefined) {
-    throw new Error(`Unable to resolve the canonical main Git repository root from ${repoRoot}.`);
-  }
-  const { relativeCwd, logicalRepoRoot } = cwdWithinGitRepository(options.cwd, repoRoot);
-  const worktreeRoot = resolveGitWorktreePath(options.gitWorktreeDir, logicalRepoRoot);
-  validateWorktreeOutsideInvokingCheckout(worktreeRoot, repoRoot);
-  if (pathExistsSync(worktreeRoot)) {
-    validateExistingGitWorktreeRoot(worktreeRoot, repoRoot);
-    return {
-      worktreeRoot,
-      cwd: workspaceCwdForGitWorktreeRoot(worktreeRoot, relativeCwd),
-      repositoryRoot: repoRoot,
-      created: false
-    };
+    throw new Error(`Unable to resolve the canonical main Git repository root from ${repository.root}.`);
   }
-  try {
-    fs3.mkdirSync(path3.dirname(worktreeRoot), { recursive: true });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to create parent directory for requested gitWorktreeDir ${worktreeRoot}: ${message}`);
+  if (!existingEmptyDirectory) {
+    try {
+      fs4.mkdirSync(path4.dirname(worktreeRoot), { recursive: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to create parent directory for requested gitWorktreeDir ${worktreeRoot}: ${message}`);
+    }
   }
-  const baseRef = options.baseBranch?.trim() || "HEAD";
+  const baseRef = request.options.baseBranch?.trim() || "HEAD";
   const result = runGit(mainRoot, ["worktree", "add", "--detach", worktreeRoot, baseRef]);
   if (result.status !== 0) {
     throw new Error([
@@ -13998,30 +14204,127 @@ function setupGitWorktree(options) {
 `));
   }
   try {
-    validateWorktreeOutsideInvokingCheckout(worktreeRoot, repoRoot);
-    validateExistingGitWorktreeRoot(worktreeRoot, repoRoot);
+    validateCreatedGitWorktree(worktreeRoot, repository);
   } catch (error) {
     runGit(mainRoot, ["worktree", "remove", "--force", worktreeRoot]);
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Created gitWorktreeDir failed post-creation validation: ${message}`);
   }
   return {
-    worktreeRoot,
-    cwd: workspaceCwdForGitWorktreeRoot(worktreeRoot, relativeCwd),
-    repositoryRoot: repoRoot,
-    created: true
+    result: {
+      worktreeRoot,
+      cwd: workspaceCwdForGitWorktreeRoot(worktreeRoot, repository.relativeCwd),
+      repositoryRoot: repository.root,
+      created: true
+    },
+    invokingRoot: repository.root
+  };
+}
+function containedWorktreeCwd(checkout, relativeCwd) {
+  const cwd = workspaceCwdForGitWorktreeRoot(checkout, relativeCwd);
+  let resolved;
+  try {
+    resolved = fs4.realpathSync.native(cwd);
+  } catch {
+    resolved = "";
+  }
+  const relative2 = resolved === "" ? undefined : path4.relative(fs4.realpathSync.native(checkout), resolved);
+  if (relative2 === undefined || relative2 === ".." || relative2.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative2) || !fs4.statSync(resolved).isDirectory()) {
+    throw new Error(`The selected base does not contain a working directory ${relativeCwd || "."} inside the worktree ${checkout}.`);
+  }
+  return cwd;
+}
+function allocatedGitWorktreeSetup(checkout, repository, created) {
+  return {
+    result: {
+      worktreeRoot: checkout,
+      cwd: containedWorktreeCwd(checkout, repository.relativeCwd),
+      repositoryRoot: repository.root,
+      created
+    },
+    invokingRoot: repository.root
   };
 }
+function validateOwnedGitWorktree(checkout, repository) {
+  validateCreatedGitWorktree(checkout, repository);
+  const gitDir = gitDirectoryForWorktree(checkout);
+  if (sameGitCommonDir(gitDir, gitCommonDirForWorktree(checkout))) {
+    throw new Error(`${checkout} is not a linked worktree`);
+  }
+  const backlink = fs4.readFileSync(path4.join(gitDir, "gitdir"), "utf8").trim();
+  if (!backlink || comparableRealPath(path4.resolve(gitDir, backlink)) !== comparableRealPath(path4.join(checkout, ".git"))) {
+    throw new Error(`the Git directory of ${checkout} belongs to another checkout`);
+  }
+}
+function findOwnedGitWorktree(root, repository, ownerRunId) {
+  const [checkout] = findOwnedWorktreeCheckouts(root, path4.basename(repository.root), ownerRunId);
+  if (checkout === undefined)
+    return;
+  try {
+    validateOwnedGitWorktree(checkout, repository);
+    return allocatedGitWorktreeSetup(checkout, repository, false);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`The worktree this workflow run allocated under gitWorktreeDir ${root} can no longer be reused: ${checkout}. ${message}`);
+  }
+}
+function allocateGitWorktree(request, ownerRunId) {
+  const { target: root } = request;
+  const repository = requireInvokingRepository(request, `create a new worktree under ${root}`);
+  if (ownerRunId !== undefined) {
+    const owned = findOwnedGitWorktree(root, repository, ownerRunId);
+    if (owned !== undefined)
+      return owned;
+  }
+  const baseRef = request.options.baseBranch?.trim() || "HEAD";
+  const revision = runGit(repository.root, ["rev-parse", "--verify", "--end-of-options", `${baseRef}^{commit}`]);
+  const commit = revision.status === 0 ? revision.stdout.trim() : "";
+  if (commit === "") {
+    throw new Error(`Failed to resolve ${baseRef} to a commit for gitWorktreeDir ${root}. Git reported: ${gitFailureMessage(revision)}`);
+  }
+  const checkout = allocateWorktreeCheckoutPath(root, path4.basename(repository.root));
+  const add = runGit(repository.root, ["worktree", "add", "--detach", "--no-checkout", checkout, commit]);
+  if (add.status !== 0) {
+    removeEmptyWorktreeBucket(checkout);
+    throw new Error(`Failed to create git worktree at ${checkout} under gitWorktreeDir ${root} from ${baseRef}. Git reported: ${gitFailureMessage(add)}`);
+  }
+  try {
+    const gitDir = gitDirectoryForWorktree(checkout);
+    runGitOrThrow(checkout, ["config", "--file", path4.join(gitDir, "config.worktree"), "core.worktree", checkout]);
+    runGitOrThrow(checkout, ["--work-tree=.", "reset", "--hard", "--no-recurse-submodules", commit]);
+    validateCreatedGitWorktree(checkout, repository);
+    const setup = allocatedGitWorktreeSetup(checkout, repository, true);
+    if (ownerRunId !== undefined)
+      bindWorktreeOwner(gitDir, ownerRunId);
+    return setup;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const removal = runGit(repository.root, ["worktree", "remove", "--force", checkout]);
+    removeEmptyWorktreeBucket(checkout);
+    const rollback = removal.status === 0 ? "" : ` Rolling back the incomplete worktree also failed; remove it with: ${worktreeRecoveryCommand(repository.root, checkout)}`;
+    throw new Error(`Failed to set up git worktree at ${checkout} under gitWorktreeDir ${root}: ${message}${rollback}`);
+  }
+}
+function runGitOrThrow(cwd, args) {
+  const result = runGit(cwd, args);
+  if (result.status !== 0)
+    throw new Error(gitFailureMessage(result));
+}
+function setupGitWorktree(options) {
+  return setupGitWorktreeFromRequest(resolveGitWorktreeSetupRequest(options)).result;
+}
 var init_worktree_git = __esm(() => {
+  init_worktree_allocation();
   init_worktree_generation();
   init_worktree_git_runner();
   init_worktree_root();
+  init_worktree_allocation();
   init_worktree_git_runner();
 });
 
 // dist/builtin/workflows/src/runs/shared/worktree-cache-lifecycle.ts
-function createGitWorktreeSetupCacheOwner(suppliedCache) {
-  const cache = suppliedCache ?? createGitWorktreeSetupCache();
+function createGitWorktreeSetupCacheOwner(suppliedCache, ownerRunId) {
+  const cache = suppliedCache ?? createGitWorktreeSetupCache(ownerRunId);
   const ownsCache = suppliedCache === undefined;
   let released = false;
   return {
@@ -14042,20 +14345,20 @@ var init_worktree_cache_lifecycle = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/shared/worktree-diff.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 function safePatchAgentName(agent) {
   return agent.replace(/[^\w.-]/g, "_");
 }
 function removeSyntheticPath(worktree, syntheticPath) {
-  const resolved = path4.resolve(worktree.path, syntheticPath);
-  const relative = path4.relative(worktree.path, resolved);
-  if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative)) {
+  const resolved = path5.resolve(worktree.path, syntheticPath);
+  const relative = path5.relative(worktree.path, resolved);
+  if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path5.sep}`) || path5.isAbsolute(relative)) {
     return;
   }
   let stat;
   try {
-    stat = fs4.lstatSync(resolved);
+    stat = fs5.lstatSync(resolved);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
     if (code === "ENOENT")
@@ -14063,14 +14366,14 @@ function removeSyntheticPath(worktree, syntheticPath) {
     throw error;
   }
   if (stat.isSymbolicLink()) {
-    fs4.unlinkSync(resolved);
+    fs5.unlinkSync(resolved);
     return;
   }
   if (stat.isDirectory()) {
-    fs4.rmSync(resolved, { recursive: true, force: true });
+    fs5.rmSync(resolved, { recursive: true, force: true });
     return;
   }
-  fs4.rmSync(resolved, { force: true });
+  fs5.rmSync(resolved, { force: true });
 }
 function removeSyntheticPathsBeforeDiff(worktree) {
   if (worktree.syntheticPaths.length === 0)
@@ -14119,7 +14422,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
   const diffStat = runGitChecked(worktree.path, ["diff", "--cached", "--stat", setup.baseCommit]).trim();
   const patch = runGitChecked(worktree.path, ["diff", "--cached", setup.baseCommit]);
   const numstat = runGitChecked(worktree.path, ["diff", "--cached", "--numstat", setup.baseCommit]);
-  fs4.writeFileSync(patchPath, patch, "utf-8");
+  fs5.writeFileSync(patchPath, patch, "utf-8");
   if (!patch.trim()) {
     return emptyDiff(worktree.index, agent, worktree.branch, patchPath);
   }
@@ -14137,7 +14440,7 @@ function captureWorktreeDiff(setup, worktree, agent, patchPath) {
 }
 function writeEmptyPatch(patchPath) {
   try {
-    fs4.writeFileSync(patchPath, "", "utf-8");
+    fs5.writeFileSync(patchPath, "", "utf-8");
   } catch {}
 }
 function hasWorktreeChanges(diff) {
@@ -14145,7 +14448,7 @@ function hasWorktreeChanges(diff) {
 }
 function diffWorktrees(setup, agents, diffsDir) {
   try {
-    fs4.mkdirSync(diffsDir, { recursive: true });
+    fs5.mkdirSync(diffsDir, { recursive: true });
   } catch {
     return [];
   }
@@ -14153,7 +14456,7 @@ function diffWorktrees(setup, agents, diffsDir) {
   for (let index = 0;index < setup.worktrees.length; index++) {
     const worktree = setup.worktrees[index];
     const agent = agents[index] ?? `task-${index + 1}`;
-    const patchPath = path4.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
+    const patchPath = path5.join(diffsDir, `task-${index}-${safePatchAgentName(agent)}.patch`);
     try {
       diffs.push(captureWorktreeDiff(setup, worktree, agent, patchPath));
     } catch {
@@ -14175,7 +14478,7 @@ function formatWorktreeDiffSummary(diffs) {
     }
     lines.push("");
   }
-  const patchesDir = path4.dirname(changed[0].patchPath);
+  const patchesDir = path5.dirname(changed[0].patchPath);
   lines.push(`Full patches: ${patchesDir}`);
   return lines.join(`
 `).trimEnd();
@@ -14185,8 +14488,8 @@ var init_worktree_diff = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/shared/worktree-post-create.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 function tracked(repo, relativePath) {
   const result = runGit(repo, ["ls-files", "--error-unmatch", "--", relativePath]);
   return result.status === 0;
@@ -14206,12 +14509,12 @@ function hasTrackedPathComponent(repo, relativePath) {
   return false;
 }
 function copyUntrackedFile(mainRoot, worktreeRoot, relativePath) {
-  const source = path5.join(mainRoot, relativePath);
-  const destination = path5.join(worktreeRoot, relativePath);
-  if (!fs5.existsSync(source) || fs5.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath))
+  const source = path6.join(mainRoot, relativePath);
+  const destination = path6.join(worktreeRoot, relativePath);
+  if (!fs6.existsSync(source) || fs6.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath))
     return false;
-  fs5.mkdirSync(path5.dirname(destination), { recursive: true });
-  fs5.copyFileSync(source, destination);
+  fs6.mkdirSync(path6.dirname(destination), { recursive: true });
+  fs6.copyFileSync(source, destination);
   return true;
 }
 function propagateLocalSettings(mainRoot, worktreeRoot) {
@@ -14224,14 +14527,14 @@ function propagateLocalSettings(mainRoot, worktreeRoot) {
   return copied;
 }
 function populatedHooksDirectory(mainRoot) {
-  const husky = path5.join(mainRoot, ".husky");
+  const husky = path6.join(mainRoot, ".husky");
   try {
-    if (fs5.statSync(husky).isDirectory())
+    if (fs6.statSync(husky).isDirectory())
       return husky;
   } catch {}
-  const hooks = path5.join(mainRoot, ".git", "hooks");
+  const hooks = path6.join(mainRoot, ".git", "hooks");
   try {
-    const populated = fs5.readdirSync(hooks, { withFileTypes: true }).some((entry) => entry.isFile() && !entry.name.endsWith(".sample"));
+    const populated = fs6.readdirSync(hooks, { withFileTypes: true }).some((entry) => entry.isFile() && !entry.name.endsWith(".sample"));
     return populated ? hooks : undefined;
   } catch {
     return;
@@ -14242,7 +14545,7 @@ function configureSharedHooksPath(mainRoot) {
   if (desired === undefined)
     return;
   const current = runGitPlain(mainRoot, ["config", "--get", "core.hooksPath"]);
-  if (current.status === 0 && path5.resolve(mainRoot, current.stdout.trim()) === desired)
+  if (current.status === 0 && path6.resolve(mainRoot, current.stdout.trim()) === desired)
     return;
   const configured = runGitPlain(mainRoot, ["config", "core.hooksPath", desired]);
   if (configured.status !== 0) {
@@ -14251,10 +14554,10 @@ function configureSharedHooksPath(mainRoot) {
 }
 function normalizeSymlinkDirectory(value2) {
   const trimmed = value2.trim();
-  if (!trimmed || path5.isAbsolute(trimmed))
+  if (!trimmed || path6.isAbsolute(trimmed))
     return;
-  const normalized = path5.normalize(trimmed);
-  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path5.sep}`))
+  const normalized = path6.normalize(trimmed);
+  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path6.sep}`))
     return;
   return normalized;
 }
@@ -14264,20 +14567,20 @@ function symlinkConfiguredDirectories(mainRoot, worktreeRoot, directories) {
     const relativePath = normalizeSymlinkDirectory(rawDirectory);
     if (relativePath === undefined || synthetic.includes(relativePath))
       continue;
-    const source = path5.join(mainRoot, relativePath);
-    const destination = path5.join(worktreeRoot, relativePath);
-    if (!fs5.existsSync(source) || fs5.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath))
+    const source = path6.join(mainRoot, relativePath);
+    const destination = path6.join(worktreeRoot, relativePath);
+    if (!fs6.existsSync(source) || fs6.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath))
       continue;
-    fs5.mkdirSync(path5.dirname(destination), { recursive: true });
+    fs6.mkdirSync(path6.dirname(destination), { recursive: true });
     try {
-      fs5.symlinkSync(source, destination, process.platform === "win32" ? "junction" : undefined);
+      fs6.symlinkSync(source, destination, process.platform === "win32" ? "junction" : undefined);
       synthetic.push(relativePath);
     } catch {}
   }
   return synthetic;
 }
 function copyWorktreeIncludes(mainRoot, worktreeRoot) {
-  if (!fs5.existsSync(path5.join(mainRoot, ".worktreeinclude")))
+  if (!fs6.existsSync(path6.join(mainRoot, ".worktreeinclude")))
     return;
   const ignored = runGit(mainRoot, ["ls-files", "--others", "--ignored", "--exclude-standard"]);
   const included = runGit(mainRoot, ["ls-files", "--others", "--ignored", "--exclude-from=.worktreeinclude"]);
@@ -14287,13 +14590,13 @@ function copyWorktreeIncludes(mainRoot, worktreeRoot) {
   for (const relativePath of included.stdout.split(/\r?\n/).filter(Boolean)) {
     if (!ignoredPaths.has(relativePath) || hasTrackedPathComponent(worktreeRoot, relativePath))
       continue;
-    const source = path5.join(mainRoot, relativePath);
-    const destination = path5.join(worktreeRoot, relativePath);
+    const source = path6.join(mainRoot, relativePath);
+    const destination = path6.join(worktreeRoot, relativePath);
     try {
-      if (!fs5.statSync(source).isFile() || fs5.existsSync(destination))
+      if (!fs6.statSync(source).isFile() || fs6.existsSync(destination))
         continue;
-      fs5.mkdirSync(path5.dirname(destination), { recursive: true });
-      fs5.copyFileSync(source, destination);
+      fs6.mkdirSync(path6.dirname(destination), { recursive: true });
+      fs6.copyFileSync(source, destination);
     } catch {}
   }
 }
@@ -14310,9 +14613,9 @@ var init_worktree_post_create = __esm(() => {
 
 // dist/builtin/workflows/src/runs/shared/worktree-setup.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { createChildProcessEnvironment as createChildProcessEnvironment2 } from "@bastani/atomic";
 function originDefaultBranch(mainRoot) {
   const symbolic = runGit(mainRoot, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
@@ -14332,7 +14635,7 @@ function originDefaultBranch(mainRoot) {
 }
 function resolveRepoState(cwd, explicitBaseBranch) {
   const cwdRelative = resolveRepoCwdRelative(cwd);
-  const toplevel = path6.resolve(runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim());
+  const toplevel = path7.resolve(runGitChecked(cwd, ["rev-parse", "--show-toplevel"]).trim());
   const mainRoot = findCanonicalGitRoot(toplevel);
   if (mainRoot === undefined)
     throw new Error(`unable to resolve canonical main Git repository root from ${toplevel}`);
@@ -14345,9 +14648,9 @@ function resolveRepoState(cwd, explicitBaseBranch) {
   return { toplevel, mainRoot, cwdRelative, baseCommit, baseRef };
 }
 function normalizeComparableCwd(cwd) {
-  const resolved = path6.resolve(cwd);
+  const resolved = path7.resolve(cwd);
   try {
-    return fs6.realpathSync(resolved);
+    return fs7.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -14358,7 +14661,7 @@ function findWorktreeTaskCwdConflict(tasks, sharedCwd) {
     const task = tasks[index];
     if (!task.cwd)
       continue;
-    const taskCwd = path6.isAbsolute(task.cwd) ? task.cwd : path6.resolve(sharedCwd, task.cwd);
+    const taskCwd = path7.isAbsolute(task.cwd) ? task.cwd : path7.resolve(sharedCwd, task.cwd);
     if (normalizeComparableCwd(taskCwd) === normalizedSharedCwd)
       continue;
     return { index, agent: task.agent, cwd: task.cwd };
@@ -14375,12 +14678,12 @@ function buildWorktreeBranch(runId, index) {
   return `worktree-${flattenedWorktreeName(runId, index)}`;
 }
 function buildWorktreePath(mainRoot, runId, index) {
-  return path6.join(mainRoot, ".atomic", "worktrees", flattenedWorktreeName(runId, index));
+  return path7.join(mainRoot, ".atomic", "worktrees", flattenedWorktreeName(runId, index));
 }
 function ensureWorktreeIgnore(mainRoot) {
-  const worktreesRoot = path6.join(mainRoot, ".atomic", "worktrees");
-  fs6.mkdirSync(worktreesRoot, { recursive: true });
-  fs6.writeFileSync(path6.join(worktreesRoot, ".gitignore"), `*
+  const worktreesRoot = path7.join(mainRoot, ".atomic", "worktrees");
+  fs7.mkdirSync(worktreesRoot, { recursive: true });
+  fs7.writeFileSync(path7.join(worktreesRoot, ".gitignore"), `*
 `, "utf8");
 }
 function resolveRepoCwdRelative(cwd) {
@@ -14389,7 +14692,7 @@ function resolveRepoCwdRelative(cwd) {
     throw new Error("worktree isolation requires a git repository");
   }
   const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
-  const normalizedPrefix = rawPrefix ? path6.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
+  const normalizedPrefix = rawPrefix ? path7.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
   return normalizedPrefix === "." ? "" : normalizedPrefix;
 }
 function parseHookTimeout(timeoutMs) {
@@ -14407,19 +14710,19 @@ function resolveWorktreeSetupHook(repoRoot, config) {
   if (!hookPath) {
     throw new Error("worktree setup hook path cannot be empty");
   }
-  const expandedHookPath = hookPath.startsWith("~/") ? path6.join(os.homedir(), hookPath.slice(2)) : hookPath;
+  const expandedHookPath = hookPath.startsWith("~/") ? path7.join(os.homedir(), hookPath.slice(2)) : hookPath;
   let resolvedPath;
-  if (path6.isAbsolute(expandedHookPath)) {
+  if (path7.isAbsolute(expandedHookPath)) {
     resolvedPath = expandedHookPath;
   } else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\")) {
-    resolvedPath = path6.resolve(repoRoot, expandedHookPath);
+    resolvedPath = path7.resolve(repoRoot, expandedHookPath);
   } else {
     throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
   }
-  if (!fs6.existsSync(resolvedPath)) {
+  if (!fs7.existsSync(resolvedPath)) {
     throw new Error(`worktree setup hook not found: ${resolvedPath}`);
   }
-  if (fs6.statSync(resolvedPath).isDirectory()) {
+  if (fs7.statSync(resolvedPath).isDirectory()) {
     throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
   }
   return {
@@ -14431,17 +14734,17 @@ function normalizeSyntheticPath(worktreePath, rawPath) {
   const trimmed = rawPath.trim();
   if (!trimmed)
     throw new Error("synthetic path cannot be empty");
-  if (path6.isAbsolute(trimmed))
+  if (path7.isAbsolute(trimmed))
     throw new Error(`synthetic path must be relative: ${rawPath}`);
-  const resolved = path6.resolve(worktreePath, trimmed);
-  const relative = path6.relative(worktreePath, resolved);
+  const resolved = path7.resolve(worktreePath, trimmed);
+  const relative = path7.relative(worktreePath, resolved);
   if (!relative || relative === ".") {
     throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
   }
-  if (relative === ".." || relative.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative)) {
+  if (relative === ".." || relative.startsWith(`..${path7.sep}`) || path7.isAbsolute(relative)) {
     throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
   }
-  return path6.normalize(relative);
+  return path7.normalize(relative);
 }
 function hasTrackedEntries(worktreePath, relativePath) {
   const result = runGit(worktreePath, ["ls-files", "--", relativePath]);
@@ -14513,16 +14816,16 @@ function waitForGitLockRelease() {
 }
 function unlinkWorktreeLinks(worktreePath, relativePaths) {
   for (const relativePath of new Set(relativePaths)) {
-    const target = path6.resolve(worktreePath, relativePath);
-    const relative = path6.relative(worktreePath, target);
-    if (!relative || relative === ".." || relative.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative))
+    const target = path7.resolve(worktreePath, relativePath);
+    const relative = path7.relative(worktreePath, target);
+    if (!relative || relative === ".." || relative.startsWith(`..${path7.sep}`) || path7.isAbsolute(relative))
       continue;
     let current = worktreePath;
-    for (const component of relative.split(path6.sep)) {
-      current = path6.join(current, component);
+    for (const component of relative.split(path7.sep)) {
+      current = path7.join(current, component);
       let stat;
       try {
-        stat = fs6.lstatSync(current);
+        stat = fs7.lstatSync(current);
       } catch (error) {
         const code = error.code;
         if (code === "ENOENT" || code === "ENOTDIR")
@@ -14532,7 +14835,7 @@ function unlinkWorktreeLinks(worktreePath, relativePaths) {
       if (!stat.isSymbolicLink())
         continue;
       if (current === target)
-        fs6.unlinkSync(current);
+        fs7.unlinkSync(current);
       break;
     }
   }
@@ -14560,7 +14863,7 @@ function createSingleWorktree(mainRoot, cwdRelative, runId, index, baseRef, base
     cleanupSingleWorktree(mainRoot, { path: worktreePath, branch }, []);
     throw new Error(message);
   }
-  const agentCwd = cwdRelative ? path6.join(worktreePath, cwdRelative) : worktreePath;
+  const agentCwd = cwdRelative ? path7.join(worktreePath, cwdRelative) : worktreePath;
   const syntheticPaths = [];
   try {
     syntheticPaths.push(...performPostCreationSetup(mainRoot, worktreePath, symlinkDirectories));
@@ -14629,8 +14932,8 @@ var init_worktree = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/shared/worktree-cwd.ts
-import { lstatSync as lstatSync5, realpathSync as realpathSync4 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute6, relative as relative4, resolve as resolve6, sep as sep5 } from "node:path";
+import { lstatSync as lstatSync6, realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute6, relative as relative4, resolve as resolve7, sep as sep5 } from "node:path";
 function relativePathWithin(root, candidate) {
   const path = relative4(root, candidate);
   return path === ".." || path.startsWith(`..${sep5}`) || isAbsolute6(path) ? undefined : path;
@@ -14649,14 +14952,14 @@ function resolveWorktreeStageCwd(cwd, setup) {
   if (cwd === undefined || cwd.length === 0)
     return;
   const absoluteInput = isAbsolute6(cwd);
-  const candidate = absoluteInput ? cwd : resolve6(setup.cwd, cwd);
+  const candidate = absoluteInput ? cwd : resolve7(setup.cwd, cwd);
   if (!absoluteInput && relativePathWithin(setup.worktreeRoot, candidate) === undefined) {
     throw new Error(`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a cwd inside the worktree.`);
   }
   const candidateRealPath = existingRealPath(candidate, "cwd");
   const worktreeRelative = relativePathWithin(worktreeRoot, candidateRealPath);
   if (worktreeRelative !== undefined)
-    return resolve6(setup.worktreeRoot, worktreeRelative);
+    return resolve7(setup.worktreeRoot, worktreeRelative);
   if (!isAbsolute6(cwd)) {
     throw new Error(`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a path that remains inside the selected worktree.`);
   }
@@ -14665,9 +14968,9 @@ function resolveWorktreeStageCwd(cwd, setup) {
   }
   const repositoryRelative = absoluteInput ? relativePathWithin(repositoryRoot, candidateRealPath) : undefined;
   if (repositoryRelative === undefined) {
-    throw new Error(`atomic-workflows: cwd ${cwd} is outside gitWorktreeDir ${setup.worktreeRoot}; use a cwd inside the invoking repository so Atomic can remap it, or omit cwd.`);
+    throw new Error(repositoryRoot === worktreeRoot ? `atomic-workflows: cwd ${cwd} is outside gitWorktreeDir ${setup.worktreeRoot}, which belongs to a different repository than the invoking cwd; choose a cwd inside the worktree, or omit cwd.` : `atomic-workflows: cwd ${cwd} is outside gitWorktreeDir ${setup.worktreeRoot}; use a cwd inside the invoking repository so Atomic can remap it, or omit cwd.`);
   }
-  const mappedCwd = resolve6(setup.worktreeRoot, repositoryRelative);
+  const mappedCwd = resolve7(setup.worktreeRoot, repositoryRelative);
   const mappedRealPath = existingRealPath(mappedCwd, "remapped worktree cwd");
   if (relativePathWithin(worktreeRoot, mappedRealPath) === undefined) {
     throw new Error(`atomic-workflows: cwd ${cwd} remaps through a path that resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or omit cwd.`);
@@ -14678,7 +14981,7 @@ var init_worktree_cwd = () => {};
 
 // dist/builtin/workflows/src/runs/foreground/executor-task-prompts.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { isAbsolute as isAbsolute7, resolve as resolve7 } from "node:path";
+import { isAbsolute as isAbsolute7, resolve as resolve8 } from "node:path";
 function normalizeTaskContexts(previous) {
   if (previous === undefined)
     return [];
@@ -14731,7 +15034,7 @@ function taskPrevious(options) {
 function resolveWorkflowPath(filePath, baseDir) {
   if (isAbsolute7(filePath))
     return filePath;
-  return resolve7(baseDir ?? process.cwd(), filePath);
+  return resolve8(baseDir ?? process.cwd(), filePath);
 }
 function taskBaseDir(options) {
   if (typeof options.chainDir === "string" && options.chainDir.trim().length > 0) {
@@ -14886,7 +15189,7 @@ function taskWithSharedDefaults(taskOptions, options) {
 var init_executor_task_prompts = () => {};
 
 // dist/builtin/workflows/src/runs/foreground/executor-direct-helpers.ts
-import { isAbsolute as isAbsolute8, join as join11, resolve as resolve8 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join12, resolve as resolve9 } from "node:path";
 import { CONFIG_DIR_NAME } from "@bastani/atomic";
 function positiveConcurrency(value2) {
   if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 < 1)
@@ -15039,10 +15342,10 @@ function workflowInvocationMetadata(inputDefaults, workflowInvocationCwd, cache,
 function resolvedTaskCwd(cwd, workflowInvocationCwd) {
   if (cwd === undefined)
     return;
-  return isAbsolute8(cwd) ? cwd : resolve8(workflowInvocationCwd, cwd);
+  return isAbsolute8(cwd) ? cwd : resolve9(workflowInvocationCwd, cwd);
 }
 function taskWorktreeOutputsRoot(runId) {
-  return join11(workflowArtifactRunPath(runId), "task-outputs");
+  return join12(workflowArtifactRunPath(runId), "task-outputs");
 }
 function prepareTaskWorktrees(tasks, options, runId, scope, workflowInvocationCwd = process.cwd(), symlinkDirectories) {
   if (options.worktree !== true && !tasks.some((task) => task.worktree === true)) {
@@ -15052,7 +15355,7 @@ function prepareTaskWorktrees(tasks, options, runId, scope, workflowInvocationCw
     throw new Error("atomic-workflows: worktree and gitWorktreeDir are mutually exclusive; use gitWorktreeDir for a reusable worktree or worktree:true for temporary isolated worktrees.");
   }
   const explicitCwd = tasks.find((task) => typeof task.cwd === "string")?.cwd;
-  const sharedCwd = explicitCwd === undefined ? workflowInvocationCwd : isAbsolute8(explicitCwd) ? explicitCwd : resolve8(workflowInvocationCwd, explicitCwd);
+  const sharedCwd = explicitCwd === undefined ? workflowInvocationCwd : isAbsolute8(explicitCwd) ? explicitCwd : resolve9(workflowInvocationCwd, explicitCwd);
   const conflict = findWorktreeTaskCwdConflict(tasks.map((task) => ({ agent: task.name, cwd: resolvedTaskCwd(task.cwd, workflowInvocationCwd) })), sharedCwd);
   if (conflict !== undefined)
     throw new Error(formatWorktreeTaskCwdConflict(conflict, sharedCwd));
@@ -15067,9 +15370,9 @@ function prepareTaskWorktrees(tasks, options, runId, scope, workflowInvocationCw
     tasks: tasks.map((task, index) => ({ ...task, cwd: setup.worktrees[index].agentCwd })),
     setup,
     agents,
-    diffsDir: join11(setup.cwd, CONFIG_DIR_NAME, "workflows", "worktree-diffs", runId, scope),
+    diffsDir: join12(setup.cwd, CONFIG_DIR_NAME, "workflows", "worktree-diffs", runId, scope),
     outputIsolations: tasks.map((_, index) => ({
-      baseDir: join11(trustedRoot, runId, scope, String(index)),
+      baseDir: join12(trustedRoot, runId, scope, String(index)),
       trustedRoot
     }))
   };
@@ -16796,8 +17099,12 @@ function createStageControlRegistry() {
       }
       await disposeEntries(entries);
     },
-    async releaseIdle(runId) {
-      for (const [stageId, entry] of [..._byRun.get(runId) ?? []]) {
+    async releaseIdle(runId, only) {
+      const runMap = _byRun.get(runId);
+      const entries = only === undefined ? [...runMap ?? []] : [[only, runMap?.get(only)]];
+      for (const [stageId, entry] of entries) {
+        if (entry === undefined)
+          continue;
         try {
           await releaseIdleEntry(runId, stageId, entry);
         } catch (error) {
@@ -16858,8 +17165,8 @@ var init_possible_stages = __esm(() => {
 
 // dist/builtin/workflows/src/workers/pool-journal.ts
 import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename5, dirname as dirname9, join as join12, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename as basename5, dirname as dirname10, join as join13, resolve as resolve10 } from "node:path";
 import { storageSelectionKey as storageSelectionKey2 } from "@bastani/atomic/storage";
 function encodeOption(value2) {
   if (typeof value2 === "bigint")
@@ -16881,7 +17188,7 @@ function isReopenableSelection(selection) {
 }
 function encodeSelection(selection) {
   if (selection.kind === "sqlite")
-    return JSON.stringify({ ...selection, path: resolve9(selection.path) });
+    return JSON.stringify({ ...selection, path: resolve10(selection.path) });
   return JSON.stringify({
     ...selection,
     ...selection.options === undefined ? {} : {
@@ -16913,7 +17220,7 @@ function openDurableJournal(durable) {
   return openSelectedRunJournal(decodeSelection(durable.selection), durable.agentDir);
 }
 function poolStateDirectory(agentDir) {
-  return join12(dirname9(agentDir), "workflows", "pool");
+  return join13(dirname10(agentDir), "workflows", "pool");
 }
 function databaseIdentity(selection, agentDir) {
   return storageSelectionKey2(selection.kind === "adapter" ? { ...selection, secrets: undefined } : selection, agentDir);
@@ -16921,16 +17228,16 @@ function databaseIdentity(selection, agentDir) {
 function coordinationPath(durable) {
   const selection = decodeSelection(durable.selection);
   const identity = createHash3("sha256").update(databaseIdentity(selection, durable.agentDir)).digest("hex");
-  return join12(poolStateDirectory(durable.agentDir), `${identity.slice(0, 24)}.sqlite`);
+  return join13(poolStateDirectory(durable.agentDir), `${identity.slice(0, 24)}.sqlite`);
 }
 function coordinationDatabase(durable) {
   return basename5(coordinationPath(durable), ".sqlite");
 }
 function openCoordinationJournal(path) {
-  const file = resolve9(path);
+  const file = resolve10(path);
   let opened = coordinationJournals.get(file);
   if (opened === undefined) {
-    mkdirSync5(dirname9(file), { recursive: true });
+    mkdirSync6(dirname10(file), { recursive: true });
     opened = resolveRunJournal({ journal: { path: file } });
     coordinationJournals.set(file, opened);
     opened.catch(() => {
@@ -16947,20 +17254,20 @@ function poolJournalFor(journal) {
   return coordinations.get(journal) ?? journal;
 }
 function poolHostId(agentDir) {
-  const file = join12(poolStateDirectory(agentDir), "host-id");
+  const file = join13(poolStateDirectory(agentDir), "host-id");
   try {
-    const existing = readFileSync2(file, "utf8").trim();
+    const existing = readFileSync4(file, "utf8").trim();
     if (existing !== "")
       return existing;
   } catch {}
-  mkdirSync5(dirname9(file), { recursive: true });
+  mkdirSync6(dirname10(file), { recursive: true });
   const id = randomUUID6();
   try {
-    writeFileSync3(file, `${id}
+    writeFileSync4(file, `${id}
 `, { flag: "wx" });
     return id;
   } catch {
-    return readFileSync2(file, "utf8").trim();
+    return readFileSync4(file, "utf8").trim();
   }
 }
 var POOL_DURABLE_JOURNAL_ENV = "ATOMIC_POOL_DURABLE_JOURNAL", coordinationJournals, coordinations;
@@ -16975,7 +17282,7 @@ var init_pool_journal = __esm(() => {
 
 // dist/builtin/workflows/src/workers/admission-host.ts
 import { execFile, execFileSync } from "node:child_process";
-import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync5 } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { hostname } from "node:os";
 function admissionBootIdentity() {
@@ -17006,7 +17313,7 @@ function workerProcessExited(pid, final = false) {
     return true;
   if (process.platform === "linux") {
     try {
-      const stat = readFileSync3(`/proc/${pid}/stat`, "utf8");
+      const stat = readFileSync5(`/proc/${pid}/stat`, "utf8");
       return stat.slice(stat.lastIndexOf(")") + 2).startsWith("Z");
     } catch {
       return admissionProcessStopped(pid);
@@ -17026,7 +17333,7 @@ function scanProcessGroup(group) {
     let complete = true;
     let entries;
     try {
-      entries = readdirSync2("/proc");
+      entries = readdirSync4("/proc");
     } catch {
       return { members, complete: false };
     }
@@ -17035,7 +17342,7 @@ function scanProcessGroup(group) {
         continue;
       let stat;
       try {
-        stat = readFileSync3(`/proc/${entry}/stat`, "utf8");
+        stat = readFileSync5(`/proc/${entry}/stat`, "utf8");
       } catch {
         complete = false;
         continue;
@@ -17266,6 +17573,7 @@ class SqlResourceAdmission {
         epoch: this.options.attempt.epoch
       }) : null);
     });
+    let quarantinedSince;
     try {
       for (;; ) {
         signal?.throwIfAborted();
@@ -17275,7 +17583,9 @@ class SqlResourceAdmission {
         }
         const hostReason = this.hostReason();
         const pressure = this.stageStartPressure(kind, request?.delegated);
+        let quarantined = undefined;
         const granted = await this.storage.transaction(async (tx) => {
+          quarantined = undefined;
           await tx.run(`UPDATE ${this.owners} SET expires_at = CAST(unixepoch('subsec') * 1000 AS INTEGER) + ? WHERE id = ?`, OWNER_LEASE_MS, this.owner);
           const { root } = this.options;
           if (!await this.assertCurrentAttempt(tx)) {
@@ -17293,6 +17603,8 @@ class SqlResourceAdmission {
             if (control && control.state !== "running")
               reason ??= `root ${control.state}`;
           }
+          const held = [];
+          let blockedOtherwise = reason !== undefined;
           for (const scope of [`root:${root}`, "user"]) {
             const row = await tx.get(`SELECT config FROM ${this.configuration} WHERE scope = ?`, scope);
             const limit = row ? JSON.parse(String(row.config))[kind] : undefined;
@@ -17302,9 +17614,21 @@ class SqlResourceAdmission {
             const args = scope === "user" ? [kind] : [kind, root];
             const count = await tx.get(`SELECT COUNT(*) AS count FROM ${this.permits} WHERE kind = ? ${rootClause} AND state = 'granted'`, ...args);
             const older = await tx.get(`SELECT 1 AS waiting FROM ${this.permits} WHERE kind = ? ${rootClause} AND state = 'waiting' AND reason IS NOT ? AND ticket < (SELECT ticket FROM ${this.permits} WHERE operation = ?) LIMIT 1`, ...args, STAGE_START_PRESSURE_REASON, operation);
-            if (Number(count?.count) >= limit || older)
-              reason ??= `${scope} ${kind}`;
+            const used = Number(count?.count);
+            if (used < limit && !older)
+              continue;
+            reason ??= `${scope} ${kind}`;
+            const quarantinedPermits = kind === "process" && used >= limit ? await tx.all(`SELECT process_identity FROM ${this.permits} WHERE kind = ? ${rootClause} AND state = 'granted' AND reason = ?`, ...args, QUARANTINED_REASON) : [];
+            if (quarantinedPermits.length > 0 && used - quarantinedPermits.length < limit)
+              held.push({
+                limit: `${scope === "user" ? "admission.userLimits" : "admission.limits"}.${kind} (${limit})`,
+                groups: quarantinedPermits.flatMap(({ process_identity }) => process_identity === null ? [] : [JSON.parse(process_identity).id])
+              });
+            else
+              blockedOtherwise = true;
           }
+          if (!blockedOtherwise && held.length > 0)
+            quarantined = held;
           if (reason && request?.delegated)
             throw new Error(`Delegated session cannot be admitted without capacity headroom: ${reason}`);
           const stageStart = kind === "session" && request?.delegated !== true;
@@ -17317,6 +17641,14 @@ class SqlResourceAdmission {
           signal?.throwIfAborted();
           return release;
         }
+        if (quarantined === undefined)
+          quarantinedSince = undefined;
+        else {
+          const now = performance.now();
+          quarantinedSince ??= now;
+          if (now - quarantinedSince >= QUARANTINED_CAPACITY_WAIT_MS)
+            throw new QuarantinedCapacityError(quarantined, now - quarantinedSince);
+        }
         await delay(50 + Math.floor(Math.random() * 25), undefined, { signal });
       }
     } catch (error) {
@@ -17358,9 +17690,9 @@ class SqlResourceAdmission {
           await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'host reboot confirmed' WHERE owner = ? AND state = 'granted'`, owner.id);
         } else if (stopped) {
           await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'owner death confirmed' WHERE owner = ? AND kind = 'session' AND state = 'granted'`, owner.id);
-          await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE owner = ? AND kind = 'process' AND state = 'granted' AND reason IS NOT ?`, UNCONFIRMED_REASON, owner.id, UNCONFIRMED_REASON);
+          await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE owner = ? AND kind = 'process' AND state = 'granted' AND reason IS NOT ? AND reason IS NOT ?`, UNCONFIRMED_REASON, owner.id, UNCONFIRMED_REASON, QUARANTINED_REASON);
         } else {
-          await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE owner = ? AND state = 'granted' AND reason IS NOT ? AND EXISTS (SELECT 1 FROM ${this.owners} WHERE id = ? AND expires_at < ${NOW_MS})`, EXPIRED_REASON, owner.id, EXPIRED_REASON, owner.id);
+          await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE owner = ? AND state = 'granted' AND reason IS NOT ? AND reason IS NOT ? AND EXISTS (SELECT 1 FROM ${this.owners} WHERE id = ? AND expires_at < ${NOW_MS})`, EXPIRED_REASON, owner.id, EXPIRED_REASON, QUARANTINED_REASON, owner.id);
         }
         if (owner.host === admissionHost && process.platform !== "win32") {
           const processes = await tx.all(`SELECT * FROM ${this.permits} WHERE owner = ? AND state = 'granted' AND kind = 'process' AND process_identity IS NOT NULL`, owner.id);
@@ -17388,9 +17720,10 @@ class SqlResourceAdmission {
       return true;
     if (permit.state === "waiting")
       return stopped || !!permit.expired;
-    if (stopped && (permit.kind === "session" || permit.reason !== UNCONFIRMED_REASON))
+    const quarantined = permit.reason === QUARANTINED_REASON;
+    if (stopped && (permit.kind === "session" || permit.reason !== UNCONFIRMED_REASON && !quarantined))
       return true;
-    if (!stopped && permit.expired && permit.reason !== EXPIRED_REASON)
+    if (!stopped && permit.expired && permit.reason !== EXPIRED_REASON && !quarantined)
       return true;
     return permit.kind === "process" && permit.host === admissionHost && process.platform !== "win32" && permit.process_identity !== null && processGroupStopped(permit.process_identity);
   }
@@ -17401,7 +17734,9 @@ class SqlResourceAdmission {
     await this.reconcile();
     return this.storage.transaction(async (tx) => {
       await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'worker exit confirmed' WHERE root = ? AND holder = ? AND state IN ('waiting', 'granted') AND (kind = 'session' OR state = 'waiting')`, this.options.root, holder);
-      return (await tx.run(`UPDATE ${this.permits} SET reason = 'cleanup unconfirmed' WHERE root = ? AND holder = ? AND kind = 'process' AND state = 'granted'`, this.options.root, holder)).changes;
+      await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE root = ? AND holder = ? AND kind = 'process' AND state = 'granted' AND reason IS NOT ?`, UNCONFIRMED_REASON, this.options.root, holder, QUARANTINED_REASON);
+      const held = await tx.get(`SELECT COUNT(*) AS count FROM ${this.permits} WHERE root = ? AND holder = ? AND kind = 'process' AND state = 'granted'`, this.options.root, holder);
+      return Number(held?.count);
     });
   }
   async reapStoppedProcesses(holder) {
@@ -17448,10 +17783,13 @@ async function settleProcessGroups(storage, root, scope, reap) {
     survivors = await settle(REAP_KILL_GRACE_MS);
   }
   const confirmed = [...groups].flatMap(([group, operations]) => survivors.includes(group) ? [] : operations);
-  if (confirmed.length > 0)
+  const quarantined = reap ? survivors.flatMap((group) => groups.get(group) ?? []) : [];
+  if (confirmed.length > 0 || quarantined.length > 0)
     await storage.transaction(async (tx) => {
       for (const operation of confirmed)
         await tx.run(`UPDATE ${permits} SET state = 'released', reason = 'process group cleanup confirmed' WHERE operation = ? AND state = 'granted'`, operation);
+      for (const operation of quarantined)
+        await tx.run(`UPDATE ${permits} SET reason = ? WHERE operation = ? AND state = 'granted'`, QUARANTINED_REASON, operation);
     });
   return { survivors, unprobeable };
 }
@@ -17468,11 +17806,20 @@ async function reapProcessGroups(journal, root, scope) {
     return { survivors: [], unprobeable: [] };
   return settleProcessGroups(storage, root, scope, true);
 }
-var OWNER_LEASE_MS = 30000, REAP_TERM_GRACE_MS = 5000, REAP_KILL_GRACE_MS = 1e4, REAP_POLL_MS = 50, RELEASED_PERMIT_RETENTION = 256, RELEASED_PERMIT_PRUNE_BATCH = 1000, EXPIRED_REASON = "owner expired; cleanup unconfirmed", UNCONFIRMED_REASON = "cleanup unconfirmed", ANONYMOUS_REASON = "owner identity unavailable; cleanup unconfirmed", NOW_MS = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", LATE_ATTEMPT_POLL_MS = 100, LATE_ATTEMPT_REASON = "waiting for its attempt lease", STAGE_START_SPACING_MS = 5000, STAGE_START_PRESSURE_REASON = "paced for host load";
+var OWNER_LEASE_MS = 30000, REAP_TERM_GRACE_MS = 5000, REAP_KILL_GRACE_MS = 1e4, REAP_POLL_MS = 50, RELEASED_PERMIT_RETENTION = 256, RELEASED_PERMIT_PRUNE_BATCH = 1000, EXPIRED_REASON = "owner expired; cleanup unconfirmed", UNCONFIRMED_REASON = "cleanup unconfirmed", QUARANTINED_REASON = "cleanup unconfirmed; permit quarantined", ANONYMOUS_REASON = "owner identity unavailable; cleanup unconfirmed", QUARANTINED_CAPACITY_WAIT_MS, QuarantinedCapacityError, NOW_MS = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", LATE_ATTEMPT_POLL_MS = 100, LATE_ATTEMPT_REASON = "waiting for its attempt lease", STAGE_START_SPACING_MS = 5000, STAGE_START_PRESSURE_REASON = "paced for host load";
 var init_resource_admission = __esm(() => {
   init_internal();
   init_sql_run_journal();
+  init_workflow_infrastructure_error();
   init_admission_host();
+  QUARANTINED_CAPACITY_WAIT_MS = REAP_TERM_GRACE_MS + REAP_KILL_GRACE_MS;
+  QuarantinedCapacityError = class QuarantinedCapacityError extends WorkflowInfrastructureError {
+    constructor(capacity, waitedMs) {
+      const limits = capacity.map(({ limit }) => limit).join(" and ");
+      const groups = [...new Set(capacity.flatMap(({ groups }) => groups))].join(", ");
+      super("worker_cleanup_unconfirmed", `Local worker process cleanup unconfirmed; process permit refused after ${Math.round(waitedMs)} ms: ${limits} ${capacity.length === 1 ? "is" : "are"} held by quarantined permits of process groups ${groups} that survived SIGKILL`);
+    }
+  };
 });
 
 // dist/builtin/workflows/src/workers/admission-binding.ts
@@ -53774,10 +54121,10 @@ var init_verification_prompts = __esm(() => {
 // dist/builtin/workflows/builtin/pattern-artifact-root.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function stableArtifactRoot(ctx, workflowName) {
   const cwd = ctx.cwd ?? process.cwd();
-  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join13(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID9()}`));
+  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join14(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID9()}`));
   await mkdir2(artifactDir, { recursive: true });
   return artifactDir;
 }
@@ -53817,7 +54164,7 @@ function fold_usage(results) {
 
 // dist/builtin/workflows/builtin/adversarial-verification-runner.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { Type as Type4 } from "typebox";
 function isRecord3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -53912,8 +54259,8 @@ async function writeInvalid(path, stage) {
 }
 async function runAdversarialVerification(ctx) {
   const root = await stableArtifactRoot(ctx, "adversarial-verification");
-  const criteriaPath = join14(root, "criteria.md");
-  const candidatePath = join14(root, "candidate.md");
+  const criteriaPath = join15(root, "criteria.md");
+  const candidatePath = join15(root, "candidate.md");
   const resolvedCriteria = resolveCriteria(ctx.inputs.criteria);
   await writeFile(criteriaPath, renderCriteriaMarkdown(resolvedCriteria));
   await ctx.task("worker", { prompt: renderWorkerPrompt(ctx.inputs.task), context: "fresh", output: candidatePath, outputMode: "file-only" });
@@ -53945,7 +54292,7 @@ async function runAdversarialVerification(ctx) {
           criterion,
           verifierIndex: index + 1,
           name,
-          artifactPath: join14(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
+          artifactPath: join15(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
         });
       }
     }
@@ -53998,8 +54345,8 @@ async function runAdversarialVerification(ctx) {
     const decision = decide_verification(roundResult, { acceptMean, quorumFraction: QUORUM_FRACTION });
     finalDecision = decision;
     finalMean = meanScore(scoreReports);
-    scoreTablePath = join14(root, `verification-summary-${round}.json`);
-    reviewReportPath = join14(root, `review-${round}.json`);
+    scoreTablePath = join15(root, `verification-summary-${round}.json`);
+    reviewReportPath = join15(root, `review-${round}.json`);
     const summary = {
       scores: scoreReports,
       mean: finalMean,
@@ -54180,7 +54527,7 @@ var GROUNDED_REPORTING2 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/classify-and-act-runner.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { Type as Type6 } from "typebox";
 function safeName(value2) {
   const normalized = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -54220,7 +54567,7 @@ async function runClassifyAndAct(ctx) {
   const needsFallback = exactCategory === undefined || confidence < ctx.inputs.confidence_threshold;
   const fallback = needsFallback ? await resolveFallbackCategory(ctx, exactCategory) : undefined;
   const category = fallback?.category ?? exactCategory;
-  const classificationPath = join15(artifactDir, "classification.json");
+  const classificationPath = join16(artifactDir, "classification.json");
   await writeFile2(classificationPath, JSON.stringify({
     proposed_category: proposedCategory,
     selected_category: category,
@@ -54230,7 +54577,7 @@ async function runClassifyAndAct(ctx) {
     fallback_used: needsFallback,
     fallback_mode: fallback?.fallbackMode ?? "none"
   }, null, 2));
-  const actionPath = join15(artifactDir, `action-${safeName(category)}.md`);
+  const actionPath = join16(artifactDir, `action-${safeName(category)}.md`);
   const action = await ctx.task(`action-${safeName(category)}`, {
     tools: actionTools(category),
     prompt: actionPrompt({ prompt: ctx.inputs.prompt, category, classificationPath }),
@@ -54370,7 +54717,7 @@ var GROUNDED_REPORTING3 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/fan-out-and-synthesize-runner.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { Type as Type8 } from "typebox";
 function safeName2(value2, index) {
   const normalized = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -54401,9 +54748,9 @@ async function runFanOutAndSynthesize(ctx) {
     context: "fresh"
   });
   const partitions = parsedPartitions(plan.structured, ctx.inputs.max_branches, ctx.inputs.prompt);
-  const partitionPath = join16(artifactDir, "partition-plan.json");
+  const partitionPath = join17(artifactDir, "partition-plan.json");
   await writeFile3(partitionPath, JSON.stringify({ task: ctx.inputs.prompt, partitions }, null, 2));
-  const branchPaths = partitions.map((partition, index) => join16(artifactDir, `branch-${safeName2(partition.label, index)}.md`));
+  const branchPaths = partitions.map((partition, index) => join17(artifactDir, `branch-${safeName2(partition.label, index)}.md`));
   const steps = partitions.map((partition, index) => ({
     name: `branch-${safeName2(partition.label, index)}`,
     prompt: branchPrompt({ prompt: ctx.inputs.prompt, ...partition }),
@@ -54413,13 +54760,13 @@ async function runFanOutAndSynthesize(ctx) {
     outputMode: "file-only"
   }));
   await ctx.parallel(steps, { concurrency: Math.min(ctx.inputs.max_concurrency, partitions.length), failFast: false });
-  const manifestPath = join16(artifactDir, "manifest.json");
+  const manifestPath = join17(artifactDir, "manifest.json");
   await writeFile3(manifestPath, JSON.stringify({
     task: ctx.inputs.prompt,
     partition_plan: partitionPath,
     branches: partitions.map((partition, index) => ({ ...partition, artifact_path: branchPaths[index] }))
   }, null, 2));
-  const synthesisPath = join16(artifactDir, "synthesis.md");
+  const synthesisPath = join17(artifactDir, "synthesis.md");
   const synthesis = await ctx.task("synthesize", {
     prompt: synthesisPrompt(ctx.inputs.prompt, manifestPath),
     context: "fresh",
@@ -54584,7 +54931,7 @@ var init_generate_and_filter_prompts = __esm(() => {
 
 // dist/builtin/workflows/builtin/generate-and-filter-runner.ts
 import { readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { Type as Type10 } from "typebox";
 function isRecord4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -54603,7 +54950,7 @@ function judgeDecision(value2) {
 }
 async function runGenerateAndFilter(ctx) {
   const root = await stableArtifactRoot(ctx, "generate-and-filter");
-  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join17(root, `candidate-${index + 1}.md`));
+  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join18(root, `candidate-${index + 1}.md`));
   const shortlistLimit = Math.min(ctx.inputs.shortlist_size, ctx.inputs.num_candidates);
   await ctx.parallel(candidatePaths.map((path, index) => ({
     name: `generate-${index + 1}`,
@@ -54612,9 +54959,9 @@ async function runGenerateAndFilter(ctx) {
     output: path,
     outputMode: "file-only"
   })), { concurrency: ctx.inputs.max_concurrency, failFast: false });
-  const manifestPath = join17(root, "manifest.json");
+  const manifestPath = join18(root, "manifest.json");
   await writeFile4(manifestPath, JSON.stringify({ task: ctx.inputs.prompt, candidate_artifact_paths: candidatePaths }, null, 2));
-  const filterPath = join17(root, "filter.json");
+  const filterPath = join18(root, "filter.json");
   const filtered = await ctx.task("dedupe-and-filter", {
     prompt: renderFilterPrompt(ctx.inputs.prompt, candidatePaths, shortlistLimit),
     context: "fresh",
@@ -54631,7 +54978,7 @@ async function runGenerateAndFilter(ctx) {
   let judgePath = null;
   let decisionPath = filterPath;
   if (ctx.inputs.use_judge) {
-    judgePath = join17(root, "judge.json");
+    judgePath = join18(root, "judge.json");
     const judgeCandidates = await Promise.all(shortlist.map(async (path) => ({ path, body: await readFile3(path, "utf8") })));
     const judgePrompt = renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit, judgeCandidates);
     const judged = await ctx.task("judge", {
@@ -54647,7 +54994,7 @@ async function runGenerateAndFilter(ctx) {
     shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
     decisionPath = judgePath;
   }
-  const finalPath = join17(root, "shortlist.md");
+  const finalPath = join18(root, "shortlist.md");
   const finalShortlist = await ctx.task("final-shortlist", {
     prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath),
     context: "fresh",
@@ -55176,7 +55523,7 @@ var init_review_convergence = __esm(() => {
 
 // dist/builtin/workflows/builtin/goal-artifacts.ts
 import { writeFile as writeFile5 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function artifactSafeName(value2) {
   const safe = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return safe.length > 0 ? safe : "artifact";
@@ -55187,7 +55534,7 @@ function withoutTurn(value2) {
   return copy;
 }
 async function writeReviewArtifact(artifactDir, reviewer, decision, rawText, convergenceDecision) {
-  const artifactPath = join18(artifactDir, `review-${artifactSafeName(reviewer)}.json`);
+  const artifactPath = join19(artifactDir, `review-${artifactSafeName(reviewer)}.json`);
   await writeFile5(artifactPath, `${JSON.stringify({ reviewer, decision, convergence_decision: convergenceDecision, raw_text: rawText }, null, 2)}
 `, { encoding: "utf8" });
   return artifactPath;
@@ -55196,7 +55543,7 @@ async function writeReviewRoundArtifact(artifactDir, reviews, consolidatedFindin
   reviewer: review.reviewer,
   findings: review.findings
 }))), reverification = []) {
-  const artifactPath = join18(artifactDir, "review-round-latest.json");
+  const artifactPath = join19(artifactDir, "review-round-latest.json");
   const visibleReviews = reviews.map(withoutTurn);
   await writeFile5(artifactPath, `${JSON.stringify({ reviews: visibleReviews, consolidated_findings: consolidatedFindings, reverification }, null, 2)}
 `, { encoding: "utf8" });
@@ -55426,7 +55773,7 @@ var init_goal_review = __esm(() => {
 // dist/builtin/workflows/builtin/goal-ledger.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { readFile as readFile4, rename, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname10, join as join19 } from "node:path";
+import { dirname as dirname11, join as join20 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function withoutTurn2(value2) {
   const copy = { ...value2 };
@@ -55451,7 +55798,7 @@ function modelVisibleLedger(ledger) {
   };
 }
 function goalLedgerStatePath(ledgerPath) {
-  return join19(dirname10(ledgerPath), LEDGER_STATE_FILENAME);
+  return join20(dirname11(ledgerPath), LEDGER_STATE_FILENAME);
 }
 function appendLifecycleEvent(ledger, event, summary, turn = ledger.turns) {
   ledger.lifecycle.push({
@@ -55527,7 +55874,7 @@ function recoverLegacyExecutionInterruption(ledger) {
   return true;
 }
 async function createGoalLedger(objective, acceptanceCriteria, artifactDir) {
-  const ledgerPath = join19(artifactDir, LEDGER_FILENAME);
+  const ledgerPath = join20(artifactDir, LEDGER_FILENAME);
   const existing = await readExistingGoalLedger(ledgerPath);
   if (existing !== undefined) {
     if (recoverLegacyExecutionInterruption(existing))
@@ -56034,7 +56381,7 @@ var init_goal_orchestrator_prompts = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/goal-runner.ts
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function positiveInteger(value2, fallback) {
   if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 <= 0) {
     return fallback;
@@ -56085,7 +56432,7 @@ async function runGoalWorkflow(ctx, options) {
       appendLifecycleEvent(ledger, "work_turn_started", "Orchestrator started.", turn);
       await writeGoalLedger(ledgerPath, ledger);
     }
-    const orchestratorReceiptPath = join20(artifactDir, "orchestrator-receipt.md");
+    const orchestratorReceiptPath = join21(artifactDir, "orchestrator-receipt.md");
     const orchestratorForkOptions = forkContinuationOptions(previousOrchestratorSessionId);
     const orchestratorPrompt = orchestratorForkOptions.forkFromSessionId === undefined ? renderGoalOrchestratorPrompt({
       ledger,
@@ -56156,7 +56503,7 @@ async function runGoalWorkflow(ctx, options) {
       const reviewerName = result.name ?? result.stageName;
       const normalizedReviewerName = reviewerName.replace(/-\d+$/u, "");
       const parsed = reviewerContractError === undefined ? parsedReviewDecisionFromResult(result, reviewerName) : { decision: reviewerErrorDecision(reviewerContractError.message), parsed: false, diagnostics: [reviewerContractError.message] };
-      const reviewArtifactPath = join20(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
+      const reviewArtifactPath = join21(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
       const record = reviewDecisionToRecord({
         turn,
         reviewer: normalizedReviewerName,
@@ -56359,7 +56706,7 @@ var init_goal = __esm(() => {
       }),
       git_worktree_dir: Type15.String({
         default: "",
-        description: "Optional Git worktree path. Leave at the default unless the user explicitly requested worktree isolation — stages never create git worktrees on their own. Must start inside a Git repo; absolute paths are used as-is, relative paths resolve from the repo root, existing Git worktrees from the invoking repository are reused/shared as-is, and missing paths are created from base_branch."
+        description: "Optional Git worktree path. Leave at the default unless the user explicitly requested worktree isolation — stages never create git worktrees on their own. Absolute paths are used as-is; relative paths resolve from the invoking repo root (or the invoking cwd outside a Git repo). An existing Git worktree root of any repository is reused as-is, even from another repository or a non-Git cwd. Creating a worktree requires starting inside the source Git repo: a missing path or an empty directory becomes a new worktree from base_branch, and a non-empty non-Git directory is treated as a worktree root that gets this run's own <dir>/<4-hex>/<repo-name> checkout, reused on resume."
       }),
       create_pr: Type15.Boolean({
         default: false,
@@ -56477,7 +56824,7 @@ var GROUNDED_REPORTING5 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/loop-until-done-runner.ts
 import { mkdir as mkdir3, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import { Type as Type16 } from "typebox";
 function progressCurve(entries) {
   return entries.flatMap((entry) => entry.progress === undefined ? [] : [entry.progress.score]);
@@ -56560,18 +56907,18 @@ async function writeLedger(path, task, maxIterations, status, entries) {
 }
 async function runLoopUntilDone(ctx) {
   const artifactDir = await stableArtifactRoot(ctx, "loop-until-done");
-  const iterationsDir = join21(artifactDir, "iterations");
-  const evaluationsDir = join21(artifactDir, "evaluations");
+  const iterationsDir = join22(artifactDir, "iterations");
+  const evaluationsDir = join22(artifactDir, "evaluations");
   await mkdir3(iterationsDir, { recursive: true });
   await mkdir3(evaluationsDir, { recursive: true });
-  const ledgerPath = join21(artifactDir, "progress-ledger.json");
+  const ledgerPath = join22(artifactDir, "progress-ledger.json");
   const entries = [];
   const iterationArtifactPaths = [];
   const evaluationArtifactPaths = [];
   await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "active", entries);
   for (let iteration = 1;iteration <= ctx.inputs.max_iterations; iteration += 1) {
-    const iterationPath = join21(iterationsDir, `iteration-${iteration}.md`);
-    const evaluationPath = join21(evaluationsDir, `evaluation-${iteration}.json`);
+    const iterationPath = join22(iterationsDir, `iteration-${iteration}.md`);
+    const evaluationPath = join22(evaluationsDir, `evaluation-${iteration}.json`);
     iterationArtifactPaths.push(iterationPath);
     evaluationArtifactPaths.push(evaluationPath);
     await ctx.task(`iteration-${iteration}`, {
@@ -56620,7 +56967,7 @@ async function runLoopUntilDone(ctx) {
     await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, decision.done ? "complete" : "active", entries);
     if (decision.done) {
       const report = progressReport(entries);
-      const resultPath = join21(artifactDir, "result.md");
+      const resultPath = join22(artifactDir, "result.md");
       const final = await ctx.task("completion-summary", {
         prompt: renderCompletionPrompt({ task: ctx.inputs.prompt, ledgerPath, iterationPath }),
         context: "fresh",
@@ -56737,9 +57084,9 @@ var init_loop_until_done = __esm(() => {
 
 // dist/builtin/workflows/builtin/open-claude-design-utils.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { mkdirSync as mkdirSync6 } from "node:fs";
+import { mkdirSync as mkdirSync7 } from "node:fs";
 import { tmpdir, userInfo } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { Type as Type18 } from "typebox";
 import { createChildProcessEnvironment as createChildProcessEnvironment3 } from "@bastani/atomic";
 function taggedPrompt3(sections) {
@@ -56782,32 +57129,32 @@ function tmpArtifactBase() {
   try {
     user = userInfo().username.replace(/[^A-Za-z0-9._-]/g, "_") || "default";
   } catch {}
-  return join22(tmpdir(), `open-claude-design-${user}`);
+  return join23(tmpdir(), `open-claude-design-${user}`);
 }
 function prepareArtifactDir(cwd = process.cwd()) {
   const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
   const tmpCandidates = [
-    join22(tmpArtifactBase(), runId),
-    join22(tmpdir(), "open-claude-design", runId)
+    join23(tmpArtifactBase(), runId),
+    join23(tmpdir(), "open-claude-design", runId)
   ];
-  const candidates = process.env.NODE_ENV === "test" ? tmpCandidates : [join22(cwd, "specs", "design", runId), ...tmpCandidates];
+  const candidates = process.env.NODE_ENV === "test" ? tmpCandidates : [join23(cwd, "specs", "design", runId), ...tmpCandidates];
   for (const candidate of candidates) {
     try {
-      mkdirSync6(candidate, { recursive: true });
+      mkdirSync7(candidate, { recursive: true });
       return {
         runId,
         artifactDir: candidate,
-        previewPath: join22(candidate, "preview.html"),
-        specPath: join22(candidate, "spec.html")
+        previewPath: join23(candidate, "preview.html"),
+        specPath: join23(candidate, "spec.html")
       };
     } catch {}
   }
-  const fallback = join22(tmpArtifactBase(), runId);
+  const fallback = join23(tmpArtifactBase(), runId);
   return {
     runId,
     artifactDir: fallback,
-    previewPath: join22(fallback, "preview.html"),
-    specPath: join22(fallback, "spec.html")
+    previewPath: join23(fallback, "preview.html"),
+    specPath: join23(fallback, "spec.html")
   };
 }
 function ensureAgentBrowser() {
@@ -57141,8 +57488,8 @@ var init_open_claude_design_live_protocol = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/open-claude-design-setup.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join23 } from "node:path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join24 } from "node:path";
 function renderDiscoveryContext(discovery) {
   return [
     `Confirmed design brief: ${discovery.brief}`,
@@ -57207,10 +57554,10 @@ async function runDiscoveryAndInit(args) {
   };
 }
 function designContextPath(artifactDir) {
-  return join23(artifactDir, DESIGN_CONTEXT_FILENAME);
+  return join24(artifactDir, DESIGN_CONTEXT_FILENAME);
 }
 function referencesBriefPath(artifactDir) {
-  return join23(artifactDir, REFERENCES_BRIEF_FILENAME);
+  return join24(artifactDir, REFERENCES_BRIEF_FILENAME);
 }
 function buildReferenceDiscoveryPrompt(args) {
   const siteList = REFERENCE_DESIGN_SITES.map((site, index) => `${index + 1}. ${site.name} — ${site.url}`).join(`
@@ -57236,8 +57583,8 @@ function buildReferenceDiscoveryPrompt(args) {
       [
         "Use the agent-browser skill to open each gallery; if `agent-browser` reports a missing browser executable, follow the bootstrap rules and retry once.",
         "From each gallery, choose 1-3 fitting designs and CLICK INTO each actual live or project-detail page; do not capture only the grid or thumbnail.",
-        `Capture motion across the entire page: start \`agent-browser record start ${join23(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using repeated \`agent-browser scroll down 600\` or \`agent-browser mouse wheel 600\`) so animations fire and lazy content loads, then run \`agent-browser record stop\`.`,
-        `Also run \`agent-browser screenshot ${join23(args.artifactDir, "ref-<site>-<n>.png")} --full\`; this still is the minimum when video is unavailable.`,
+        `Capture motion across the entire page: start \`agent-browser record start ${join24(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using repeated \`agent-browser scroll down 600\` or \`agent-browser mouse wheel 600\`) so animations fire and lazy content loads, then run \`agent-browser record stop\`.`,
+        `Also run \`agent-browser screenshot ${join24(args.artifactDir, "ref-<site>-<n>.png")} --full\`; this still is the minimum when video is unavailable.`,
         "Record the actual destination URL, title, and author. For each reference, cite observed layout, typography, color, spacing, and motion traits rather than inferred traits.",
         "Assess fit against DESIGN.md, PRODUCT.md, and the ds-* discovery evidence in the design-context file; prefer on-brand references and flag departures.",
         "Use ask_user_question to ask which reference direction they prefer, offering 2-4 strongest options plus `None of these fit`. If none fit, ask them to provide a reference image, screenshot, URL, or local file path and record the answer.",
@@ -57262,8 +57609,8 @@ function buildReferenceDiscoveryPrompt(args) {
 }
 function writeRequiredContextArtifact(artifactDir, filePath, content, label) {
   try {
-    mkdirSync7(artifactDir, { recursive: true });
-    writeFileSync4(filePath, `${content}
+    mkdirSync8(artifactDir, { recursive: true });
+    writeFileSync5(filePath, `${content}
 `);
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -57814,7 +58161,7 @@ var init_ralph_review_gate = __esm(() => {
 
 // dist/builtin/workflows/builtin/ralph-core.ts
 import { mkdir as mkdir4, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname11, join as join24 } from "node:path";
+import { dirname as dirname12, join as join25 } from "node:path";
 import { Type as Type20 } from "typebox";
 function taggedPrompt4(sections) {
   return sections.map(([tag, content]) => {
@@ -57854,11 +58201,11 @@ function slugifyResearchTopic(prompt) {
 }
 function defaultResearchPath(prompt, now = new Date) {
   const date = now.toISOString().slice(0, 10);
-  return join24(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
+  return join25(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
 }
 async function createImplementationNotesFile(prompt, runId) {
   const notesDir = await createWorkflowArtifactDirectory(runId);
-  const notesPath = join24(notesDir, IMPLEMENTATION_NOTES_FILENAME);
+  const notesPath = join25(notesDir, IMPLEMENTATION_NOTES_FILENAME);
   const initialNotes = [
     "# Implementation Notes",
     "",
@@ -57879,7 +58226,7 @@ async function createImplementationNotesFile(prompt, runId) {
 }
 async function createQaEvidenceVideoPath(runId) {
   const qaDir = await createWorkflowArtifactDirectory(runId);
-  return join24(qaDir, QA_E2E_VIDEO_FILENAME);
+  return join25(qaDir, QA_E2E_VIDEO_FILENAME);
 }
 function renderQaE2eVideoGuidance(qaVideoPath) {
   return [
@@ -57945,7 +58292,7 @@ function artifactSafeName2(value2) {
   return safe.length > 0 ? safe : "artifact";
 }
 async function writeJsonArtifact(path, content) {
-  await mkdir4(dirname11(path), { recursive: true });
+  await mkdir4(dirname12(path), { recursive: true });
   await writeFile8(path, `${JSON.stringify(content, null, 2)}
 `, {
     encoding: "utf8"
@@ -58283,7 +58630,7 @@ var init_ralph_models = __esm(() => {
 
 // dist/builtin/workflows/builtin/ralph-runner.ts
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join25, resolve as resolve10 } from "node:path";
+import { join as join26, resolve as resolve11 } from "node:path";
 async function runRalphWorkflow(ctx, options) {
   const { prompt, acceptanceCriteria, maxLoops, comparisonBaseBranch, workflowStartCwd, createPr, runId } = options;
   let latestReviewReportPath;
@@ -58295,7 +58642,7 @@ async function runRalphWorkflow(ctx, options) {
   let finalPrReport;
   const workflowCwdContext = workflowCwdContextSection(workflowStartCwd);
   const workflowPrompt = prompt;
-  const workflowResearchPath = resolve10(workflowStartCwd, defaultResearchPath(workflowPrompt));
+  const workflowResearchPath = resolve11(workflowStartCwd, defaultResearchPath(workflowPrompt));
   const implementationNotesPath = await createImplementationNotesFile(workflowPrompt, runId);
   const qaVideoPath = await createQaEvidenceVideoPath(runId);
   const artifactDir = await createWorkflowArtifactDirectory(runId);
@@ -58344,7 +58691,7 @@ async function runRalphWorkflow(ctx, options) {
     const researchPath = workflowResearchPath;
     finalResearchPath = researchPath;
     finalPlanPath = researchPath;
-    const orchestratorReportPath = join25(artifactDir, "orchestrator-report.md");
+    const orchestratorReportPath = join26(artifactDir, "orchestrator-report.md");
     const orchestratorForkOptions = forkContinuationOptions3(previousOrchestratorSessionId);
     const orchestratorPrompt = orchestratorForkOptions.forkFromSessionId === undefined ? taggedPrompt4([
       ["acceptance_criteria", keepContext(acceptanceCriteria)],
@@ -58480,7 +58827,7 @@ Read it before implementation or delegation because it is the primary current im
         diagnostics: parsed.diagnostics,
         allowFinalActionRemaining: createPr
       });
-      const artifactPath = join25(artifactDir, `review-${artifactSafeName2(reviewer)}.json`);
+      const artifactPath = join26(artifactDir, `review-${artifactSafeName2(reviewer)}.json`);
       await writeJsonArtifact(artifactPath, {
         reviewer,
         decision: parsed.decision,
@@ -58536,7 +58883,7 @@ Read it before implementation or delegation because it is the primary current im
         usage: fold_usage([orchestrator, ...reviews, ...reverifyResults])
       }));
     }
-    latestReviewReportPath = await writeJsonArtifact(join25(artifactDir, "review-round-latest.json"), {
+    latestReviewReportPath = await writeJsonArtifact(join26(artifactDir, "review-round-latest.json"), {
       convergence_decision: roundConvergenceDecision,
       convergence: convergenceEntries,
       consolidated_findings: reverified.batch,
@@ -58685,7 +59032,7 @@ var init_ralph = __esm(() => {
       }),
       git_worktree_dir: Type21.String({
         default: "",
-        description: "Optional Git worktree path. Leave at the default unless the user explicitly requested worktree isolation — stages never create git worktrees on their own. Must start inside a Git repo; absolute paths are used as-is, relative paths resolve from the repo root, existing Git worktrees from the invoking repository are reused/shared as-is, and missing paths are created from base_branch."
+        description: "Optional Git worktree path. Leave at the default unless the user explicitly requested worktree isolation — stages never create git worktrees on their own. Absolute paths are used as-is; relative paths resolve from the invoking repo root (or the invoking cwd outside a Git repo). An existing Git worktree root of any repository is reused as-is, even from another repository or a non-Git cwd. Creating a worktree requires starting inside the source Git repo: a missing path or an empty directory becomes a new worktree from base_branch, and a non-empty non-Git directory is treated as a worktree root that gets this run's own <dir>/<4-hex>/<repo-name> checkout, reused on resume."
       }),
       create_pr: Type21.Boolean({
         default: false,
@@ -58905,7 +59252,7 @@ var init_tournament_prompts = __esm(() => {
 
 // dist/builtin/workflows/builtin/tournament-runner.ts
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join26, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve11 } from "node:path";
+import { join as join27, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve12 } from "node:path";
 import { Type as Type22 } from "typebox";
 function serializableObject2(value2) {
   if (value2 === null || Array.isArray(value2) || typeof value2 !== "object")
@@ -58942,8 +59289,8 @@ function criterionSlug(id) {
 }
 function judgeArtifactPath(judgesDir, job, criterionIndex) {
   const filename = `judge-${job.a}-${job.b}-c${criterionIndex}-${criterionSlug(job.criterionId)}-r${job.rep}.json`;
-  const root = resolve11(judgesDir);
-  const path = resolve11(judgesDir, filename);
+  const root = resolve12(judgesDir);
+  const path = resolve12(judgesDir, filename);
   const fromRoot = relative5(root, path);
   if (fromRoot.startsWith("..") || isAbsolute9(fromRoot)) {
     throw new Error(`tournament: judge artifact escaped its directory: ${path}`);
@@ -58994,16 +59341,16 @@ function combineUsage(totals) {
 }
 async function runTournament(ctx) {
   const artifactDir = await stableArtifactRoot(ctx, "tournament");
-  const attemptsDir = join26(artifactDir, "attempts");
+  const attemptsDir = join27(artifactDir, "attempts");
   const numAttempts = ctx.inputs.num_attempts ?? 4;
   const maxConcurrency = ctx.inputs.max_concurrency ?? 4;
   const nEvaluations = ctx.inputs.n_evaluations ?? 2;
   const pivotCount = ctx.inputs.pivots ?? 1;
   const seed = ctx.inputs.seed ?? 0;
-  const judgesDir = join26(artifactDir, "judges");
+  const judgesDir = join27(artifactDir, "judges");
   await mkdir5(attemptsDir, { recursive: true });
   await mkdir5(judgesDir, { recursive: true });
-  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join26(attemptsDir, `attempt-${index + 1}.md`));
+  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join27(attemptsDir, `attempt-${index + 1}.md`));
   const models = ctx.inputs.models;
   const attemptResults = await ctx.parallel(attemptArtifactPaths.map((path, index) => ({
     name: `attempt-${index + 1}`,
@@ -59168,7 +59515,7 @@ The previous report was invalid. Return the required JSON schema exactly once.`,
   const outputRanking = ranking.map(({ label, meanPreference }) => ({ label, meanPreference }));
   const budgetPivots = Math.min(pivotCount, entrants.length);
   const comparisonBudget = (entrants.length + budgetPivots * (entrants.length - budgetPivots) + budgetPivots * (budgetPivots - 1) / 2) * criteria.length * nEvaluations;
-  const comparisonPath = join26(artifactDir, "comparisons.json");
+  const comparisonPath = join27(artifactDir, "comparisons.json");
   const assignment = modelAssignment(entrants, models);
   const phaseUsage = {
     attempts: fold_usage(attemptResults),
@@ -59204,7 +59551,7 @@ The previous report was invalid. Return the required JSON schema exactly once.`,
   await writeLedger(fold_usage([]));
   const winner = ranking[0];
   const winnerEntrant = entrants[winner.index];
-  const resultPath = join26(artifactDir, "winner.md");
+  const resultPath = join27(artifactDir, "winner.md");
   const reducer = await ctx.task("comparisons-reducer", {
     prompt: renderComparisonsReducerPrompt({
       task: ctx.inputs.prompt,
@@ -60110,7 +60457,7 @@ class SqlPoolQueue {
             throw new Error("Stale pool coordinator authority", { cause: error });
           throw error;
         });
-        const row = await this.current(tx, lease, token);
+        const row = await this.current(tx, lease, token, true);
         if (row.epoch !== lease.epoch)
           throw new Error(STALE_WORK_LEASE);
         assertSession();
@@ -62344,7 +62691,7 @@ function isBrokerStatusReport(value2) {
 
 // dist/builtin/intercom/broker/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function getHomeDir() {
   if (process.platform === "win32") {
     if (process.env.USERPROFILE)
@@ -62361,7 +62708,7 @@ function expandTildePath(path) {
   if (path === "~")
     return getHomeDir();
   if (path.startsWith("~/") || process.platform === "win32" && path.startsWith("~\\")) {
-    return join27(getHomeDir(), path.slice(2));
+    return join28(getHomeDir(), path.slice(2));
   }
   return path;
 }
@@ -62372,31 +62719,31 @@ function getAgentDir5() {
   const piAgentDir = process.env.PI_CODING_AGENT_DIR;
   if (piAgentDir)
     return expandTildePath(piAgentDir);
-  return join27(getHomeDir(), ".atomic", "agent");
+  return join28(getHomeDir(), ".atomic", "agent");
 }
 function sanitizePipeSegment(value2) {
   return value2.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "default";
 }
 function getIntercomDirPath(agentDir = getAgentDir5()) {
-  return join27(agentDir, "intercom");
+  return join28(agentDir, "intercom");
 }
 function getBrokerPidPath(agentDir = getAgentDir5()) {
-  return join27(getIntercomDirPath(agentDir), "broker.pid");
+  return join28(getIntercomDirPath(agentDir), "broker.pid");
 }
 function getBrokerSpawnLockPath(agentDir = getAgentDir5()) {
-  return join27(getIntercomDirPath(agentDir), "broker.spawn.lock");
+  return join28(getIntercomDirPath(agentDir), "broker.spawn.lock");
 }
 function getBrokerLogPath(agentDir = getAgentDir5()) {
-  return join27(getIntercomDirPath(agentDir), "broker.log");
+  return join28(getIntercomDirPath(agentDir), "broker.log");
 }
 function getBrokerStartAnnouncementPath(agentDir = getAgentDir5()) {
-  return join27(getIntercomDirPath(agentDir), "broker.starting");
+  return join28(getIntercomDirPath(agentDir), "broker.starting");
 }
 function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir5()) {
   if (platform === "win32") {
     return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
   }
-  return join27(getIntercomDirPath(agentDir), "broker.sock");
+  return join28(getIntercomDirPath(agentDir), "broker.sock");
 }
 var BROKER_STORAGE_ENV = "ATOMIC_STORAGE";
 var init_paths = () => {};
@@ -64080,11 +64427,11 @@ var init_client = __esm(() => {
 var BROKER_READY_TIMEOUT_MS = 30000, MIN_BROKER_STARTUP_TIMEOUT_MS = 1000;
 
 // dist/builtin/intercom/broker/start-announcement.ts
-import { readFileSync as readFileSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 function readBrokerStartAnnouncement(announcement) {
   let text;
   try {
-    text = readFileSync4(announcement.path, "utf-8");
+    text = readFileSync6(announcement.path, "utf-8");
   } catch {
     return;
   }
@@ -64103,26 +64450,26 @@ var init_start_announcement = () => {};
 // dist/builtin/intercom/broker/spawn.ts
 import { spawn } from "child_process";
 import { randomUUID as randomUUID15 } from "crypto";
-import { appendFileSync, chmodSync, closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join28, dirname as dirname12 } from "path";
+import { appendFileSync, chmodSync, closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync9, openSync as openSync3, readFileSync as readFileSync7, readSync as readSync2, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "fs";
+import { join as join29, dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire as createRequire3 } from "module";
 import { createChildProcessEnvironment as createChildProcessEnvironment4, isBunBinary, processSharedStorageSelection } from "@bastani/atomic";
 function isIntercomPackageRoot(dir) {
-  return existsSync6(join28(dir, "package.json")) && existsSync6(join28(dir, "broker"));
+  return existsSync6(join29(dir, "package.json")) && existsSync6(join29(dir, "broker"));
 }
 function resolveIntercomPackageRoot(moduleHref) {
-  const here = dirname12(fileURLToPath4(moduleHref));
+  const here = dirname13(fileURLToPath4(moduleHref));
   if (isIntercomPackageRoot(here))
     return here;
-  return join28(here, "..");
+  return join29(here, "..");
 }
 function resolveBrokerEntrypoint(packageRoot) {
-  const bundled = join28(packageRoot, "broker", "broker.bundle.mjs");
-  return existsSync6(bundled) ? bundled : join28(packageRoot, "broker", "broker.ts");
+  const bundled = join29(packageRoot, "broker", "broker.bundle.mjs");
+  return existsSync6(bundled) ? bundled : join29(packageRoot, "broker", "broker.ts");
 }
 function ensurePrivateDirectory(path) {
-  mkdirSync8(path, { recursive: true, mode: 448 });
+  mkdirSync9(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
@@ -64135,14 +64482,14 @@ function getCurrentBrokerRuntime() {
   return isBunBinary ? "bun-binary" : "bun-source";
 }
 function requireFromExtensionDir(extensionDir) {
-  return createRequire3(join28(extensionDir, "package.json"));
+  return createRequire3(join29(extensionDir, "package.json"));
 }
 function getJitiCliPath(extensionDir = EXTENSION_DIR) {
   try {
     const jitiPackage = requireFromExtensionDir(extensionDir).resolve("jiti/package.json");
-    return join28(dirname12(jitiPackage), "lib", "jiti-cli.mjs");
+    return join29(dirname13(jitiPackage), "lib", "jiti-cli.mjs");
   } catch {
-    return join28(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
+    return join29(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
   }
 }
 function getDefaultBrokerRunnerPath(extensionDir) {
@@ -64164,7 +64511,7 @@ function quoteWindowsArg(value2) {
   return `"${value2.replace(/"/g, '""')}"`;
 }
 function getWindowsHiddenLauncherPath(intercomDir = INTERCOM_DIR) {
-  return join28(intercomDir, "broker-launch.vbs");
+  return join29(intercomDir, "broker-launch.vbs");
 }
 function usesDefaultBrokerCommand(brokerCommand, brokerArgs) {
   return brokerCommand === "npx" && brokerArgs.length === 2 && brokerArgs[0] === "--no-install" && brokerArgs[1] === "tsx";
@@ -64191,8 +64538,8 @@ function getWindowsHiddenLauncherScript(commandLine) {
 `);
 }
 function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
-  ensurePrivateDirectory(dirname12(launcherPath));
-  writeFileSync6(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
+  ensurePrivateDirectory(dirname13(launcherPath));
+  writeFileSync7(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
   return launcherPath;
 }
 function getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir = EXTENSION_DIR, platform = process.platform, intercomDir = INTERCOM_DIR, nodePath = process.execPath, runtime = getCurrentBrokerRuntime(), logPath = BROKER_LOG) {
@@ -64235,14 +64582,14 @@ function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore",
   };
 }
 function resetBrokerLog(logPath = BROKER_LOG) {
-  ensurePrivateDirectory(dirname12(logPath));
+  ensurePrivateDirectory(dirname13(logPath));
   try {
     const previous = readBrokerLogTail(logPath);
     closeSync3(openSync3(logPath, "w"));
     if (previous.length > 0) {
       try {
         const previousPath = `${logPath}.previous`;
-        writeFileSync6(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
+        writeFileSync7(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
         if (process.platform !== "win32")
           chmodSync(previousPath, 384);
       } catch {}
@@ -64386,7 +64733,7 @@ async function isBrokerRunning() {
   if (!existsSync6(BROKER_PID))
     return false;
   try {
-    const pid = parseInt(readFileSync5(BROKER_PID, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync7(BROKER_PID, "utf-8").trim(), 10);
     if (!Number.isFinite(pid))
       return false;
     process.kill(pid, 0);
@@ -64411,7 +64758,7 @@ function handSpawnLockToBroker(pid, owner) {
 }
 function ownsSpawnLock(owner, lockPath = BROKER_SPAWN_LOCK) {
   try {
-    return readFileSync5(lockPath, "utf-8").startsWith(owner);
+    return readFileSync7(lockPath, "utf-8").startsWith(owner);
   } catch {
     return false;
   }
@@ -64423,7 +64770,7 @@ function acquireSpawnLock() {
 ${Date.now()}
 `;
     try {
-      writeFileSync6(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
+      writeFileSync7(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
       return owner;
     } catch (error) {
       if (!(error instanceof Error) || error.code !== "EEXIST") {
@@ -64453,7 +64800,7 @@ function isSpawnLockStale(lockPath = BROKER_SPAWN_LOCK, nowMs = Date.now()) {
     return false;
   }
   try {
-    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync5(lockPath, "utf-8").trim().split(`
+    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync7(lockPath, "utf-8").trim().split(`
 `);
     const spawnerPid = Number.parseInt(spawnerLine, 10);
     const createdAt = Number.parseInt(createdAtLine, 10);
@@ -64531,14 +64878,14 @@ var init_reply_waiter = __esm(() => {
 });
 
 // dist/builtin/intercom/config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
 import { getAgentConfigPaths } from "@bastani/atomic";
 function loadConfig() {
   if (!existsSync7(CONFIG_PATH)) {
     return { ...defaults };
   }
   try {
-    const raw = readFileSync6(CONFIG_PATH, "utf-8");
+    const raw = readFileSync8(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       throw new Error("Config must be a JSON object");
@@ -65121,12 +65468,12 @@ var init_sql_pool_usage = __esm(() => {
 
 // dist/builtin/workflows/src/workers/pooled-watch-trace.ts
 import { appendFileSync as appendFileSync2 } from "node:fs";
-import { dirname as dirname13, join as join29, resolve as resolve12 } from "node:path";
+import { dirname as dirname14, join as join30, resolve as resolve13 } from "node:path";
 function configurePooledWatchTrace(journalPath, processRole) {
   if (setting === undefined || setting === "" || setting === "0")
     return;
   role = processRole;
-  file = setting === "1" ? join29(dirname13(resolve12(journalPath)), "pooled-watch-trace.jsonl") : resolve12(setting);
+  file = setting === "1" ? join30(dirname14(resolve13(journalPath)), "pooled-watch-trace.jsonl") : resolve13(setting);
 }
 function tracePooledWatch(step, detail) {
   if (file === undefined)
@@ -65320,7 +65667,7 @@ import { fork } from "node:child_process";
 import { randomUUID as randomUUID17 } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { appendFile, mkdir as mkdir6, rm as rm3, rmdir } from "node:fs/promises";
-import { dirname as dirname14, join as join30, resolve as resolve13 } from "node:path";
+import { dirname as dirname15, join as join31, resolve as resolve14 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 function isRootLeaseLost(error) {
   return error instanceof StaleLeaseError || error.message.startsWith("Stale lease for run ");
@@ -65329,7 +65676,7 @@ function unconfirmedCleanup(groups) {
   return new Error(`Local worker process cleanup unconfirmed; ${groups.length > 0 ? `process groups ${groups.join(", ")} still running after SIGKILL; ` : ""}permits quarantined`);
 }
 function workerLogDirectory(journalPath, root) {
-  return join30(dirname14(resolve13(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
+  return join31(dirname15(resolve14(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
 }
 function token(work) {
   return {
@@ -65517,6 +65864,7 @@ class PoolCoordinator {
   cleanups = new Set;
   controlAcks = new Map;
   lastHeard = new Map;
+  awaiting = new Map;
   pendingActivity = new Map;
   batches = new Map;
   publicationFailures = new Map;
@@ -66260,7 +66608,7 @@ class PoolCoordinator {
     this.slots.add(slot);
     let ready = false;
     let serial = Promise.resolve();
-    const logPath = join30(this.logDirectory, `${worker}.log`);
+    const logPath = join31(this.logDirectory, `${worker}.log`);
     this.logs.set(child, logPath);
     let logFailure;
     const log = createWriteStream(logPath, { flags: "a" });
@@ -66316,6 +66664,7 @@ class PoolCoordinator {
         this.readyWorkers.delete(worker);
         this.controlAcks.delete(worker);
         this.lastHeard.delete(worker);
+        this.awaiting.delete(worker);
         this.slots.delete(slot);
         this.endStageWatches((watch) => watch.slot === slot, "worker_exited");
         for (const settle of slot.stageCommands.values())
@@ -66573,8 +66922,19 @@ class PoolCoordinator {
           await this.sendResult(work.id);
         });
         const response = handled.then((value2) => routeReady ?? value2);
-        if (message.kind !== "delivery" && message.kind !== "delivery-ready")
-          serial = handled.then(() => {}, () => {});
+        if (message.kind !== "delivery" && message.kind !== "delivery-ready") {
+          this.awaiting.set(worker, (this.awaiting.get(worker) ?? 0) + 1);
+          const answered = () => {
+            const left = (this.awaiting.get(worker) ?? 1) - 1;
+            if (left > 0)
+              this.awaiting.set(worker, left);
+            else
+              this.awaiting.delete(worker);
+            if (this.incarnations.get(worker) === child)
+              this.lastHeard.set(worker, { at: performance.now(), stalled: this.stalledMs });
+          };
+          serial = handled.then(answered, answered);
+        }
         response.then((value2) => child.send({ id: message.id, value: value2 }, replied), (error) => {
           const rootLeaseLost = isRootLeaseLost(error);
           if (rootLeaseLost)
@@ -66644,7 +67004,10 @@ class PoolCoordinator {
         if (work.epoch < lease.epoch)
           await this.releaseRetained(work);
         else
-          await queue.expire(lease, work);
+          await queue.expire(lease, work).catch((error) => {
+            if (error.message !== STALE_WORK_LEASE)
+              throw error;
+          });
       }
     })().finally(() => {
       this.recovering = undefined;
@@ -66662,7 +67025,7 @@ class PoolCoordinator {
   isLive(worker, child) {
     this.observeResponsiveness();
     const heard = this.lastHeard.get(worker);
-    return child.exitCode === null && child.signalCode === null && child.connected && heard !== undefined && performance.now() - heard.at - (this.stalledMs - heard.stalled) < this.options.leaseMs;
+    return child.exitCode === null && child.signalCode === null && child.connected && heard !== undefined && ((this.awaiting.get(worker) ?? 0) > 0 || performance.now() - heard.at - (this.stalledMs - heard.stalled) < this.options.leaseMs);
   }
   async stop(child) {
     const pid = child.pid;
@@ -67014,7 +67377,7 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
   };
 }
 async function deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver, commit, recipient) {
-  const stickyEntries = stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, recipient);
+  const stickyEntries = stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, recipient, recipient?.receivedMessageIds);
   const candidateIds = new Set([
     ...activeStore.pendingStageMessagesFor(runId, stageId),
     ...activeStore.pendingStageMessagesFor(runId, stageName),
@@ -67070,7 +67433,7 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
     }
   }
 }
-function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, recipient) {
+function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, recipient, receivedByEndedStage = []) {
   const runs = activeStore.runs();
   const rootRunId = durableRootRunIdForRun(runs, runId);
   if (rootRunId === undefined)
@@ -67079,22 +67442,28 @@ function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageNam
   if (rootRun === undefined)
     return [];
   const stage = runs.find((run) => run.id === runId)?.stages.find((candidate) => candidate.id === stageId);
-  if (stage?.status === "completed" || stage?.status === "skipped")
+  const ended = stage?.status === "completed" || stage?.status === "skipped";
+  if (ended && receivedByEndedStage.length === 0)
     return [];
   const hops = workflowBoundaryHops(runs, runId);
   if (hops === undefined)
     return [];
   return (rootRun.pendingStageMessages ?? []).filter((entry) => {
-    if (entry.sticky !== true || entry.status !== "queued")
-      return false;
-    const parsed = entry.targetPath === undefined ? undefined : parseWorkflowStageTarget(entry.targetPath);
-    if (parsed === undefined || parsed.rootRunId !== rootRunId)
-      return false;
     if ((entry.deliveries ?? []).some((delivery) => delivery.runId === runId && delivery.stageId === stageId && (recipient === undefined || delivery.admission === "context" && delivery.sessionId === recipient.sessionId && (recipient.receivedMessageIds === undefined || recipient.receivedMessageIds.includes(entry.message.id)))))
       return false;
-    return stageMatchesPathPattern(parsed.segments, hops, [stageId, stageName]);
+    if (ended && !receivedByEndedStage.includes(entry.message.id))
+      return false;
+    return stickyEntryTargetsStage(entry, rootRunId, hops, stageId, stageName);
   });
 }
+function stickyEntryTargetsStage(entry, rootRunId, hops, stageId, stageName) {
+  if (entry.sticky !== true || entry.status !== "queued")
+    return false;
+  const parsed = entry.targetPath === undefined ? undefined : parseWorkflowStageTarget(entry.targetPath);
+  if (parsed === undefined || parsed.rootRunId !== rootRunId)
+    return false;
+  return stageMatchesPathPattern(parsed.segments, hops, [stageId, stageName]);
+}
 function claimPendingDelivery(store, runId, stageKey, messageId) {
   let claims = pendingDeliveryClaims.get(store);
   if (claims === undefined) {
@@ -67158,6 +67527,7 @@ class PoolStageHandoff {
   owners = new Map;
   publications = new Map;
   drains = new Map;
+  deliveryIssues = 0;
   constructor(backend, store, queue, lease, claimRun) {
     this.backend = backend;
     this.store = store;
@@ -67238,11 +67608,23 @@ class PoolStageHandoff {
     this.drains.set(stage, drain);
     try {
       await drain;
+    } catch (error) {
+      const current = this.attempts.get(work.id) === attempt && !attempt.fenced;
+      if (current && attempt.sessions.get(stage) === recipient.sessionId && error.message !== STALE)
+        this.recordDeliveryIssue(error);
+      throw error;
     } finally {
       if (this.drains.get(stage) === drain)
         this.drains.delete(stage);
     }
   }
+  recordDeliveryIssue(error) {
+    this.deliveryIssues++;
+    const drains = this.deliveryIssues === 1 ? "1 stage drain" : `${this.deliveryIssues} stage drains`;
+    this.store.recordRunExecutionState(this.lease.runId, {
+      intercomDeliveryIssue: `${drains} on local workers failed; undelivered messages stay queued and arrive live or on the stage's next drain (last: ${error.message})`
+    });
+  }
   async complete(work) {
     const root = this.lease.runId;
     const result = await this.queue.result(root, work.id);
@@ -68598,7 +68980,7 @@ var init_pooled_stage_registry = __esm(() => {
 // dist/builtin/workflows/src/workers/local-pool.ts
 import { fork as fork2 } from "node:child_process";
 import { randomUUID as randomUUID19 } from "node:crypto";
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import {
@@ -68832,7 +69214,7 @@ class LocalWorkerPool {
   async poolJournal() {
     const journal = this.backend.journal;
     if (this.options.durable === undefined) {
-      if (!(journal instanceof SqlRunJournal) || resolve14(this.options.journalPath) !== resolve14(journal.path) || sqlPoolStorage(journal)?.tables.runs !== "wf_runs")
+      if (!(journal instanceof SqlRunJournal) || resolve15(this.options.journalPath) !== resolve15(journal.path) || sqlPoolStorage(journal)?.tables.runs !== "wf_runs")
         throw new Error("Local workers require the same default-prefix SQLite journal");
       return journal;
     }
@@ -69859,7 +70241,7 @@ var init_local_pool = __esm(() => {
 var DEFAULT_POOLED_STAGE_START_MAX_LOAD_PER_CPU = 3;
 
 // dist/builtin/workflows/src/workers/public-pool.ts
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 async function restoreWorkerOptions(backend, options) {
   const source = options.continuation?.source.id ?? options.runId;
@@ -69909,16 +70291,16 @@ async function activatePublicPool(backend, options) {
     startupTimeoutMs: undefined,
     leaseMs: undefined,
     maxLoadPerCpu: undefined,
-    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve15(cwd, source.path) }))
+    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve16(cwd, source.path) }))
   };
   const admission = options.admission && {
     ...options.admission,
-    ...options.admission.userDatabase ? { userDatabase: resolve15(cwd, options.admission.userDatabase) } : {}
+    ...options.admission.userDatabase ? { userDatabase: resolve16(cwd, options.admission.userDatabase) } : {}
   };
   if (durable !== undefined && admission?.userLimits) {
-    if (admission.userDatabase !== undefined && admission.userDatabase !== resolve15(poolPath))
-      throw new Error(`admission.userDatabase must be omitted, or ${resolve15(poolPath)}, for a journal that is not a local SQLite file`);
-    admission.userDatabase = resolve15(poolPath);
+    if (admission.userDatabase !== undefined && admission.userDatabase !== resolve16(poolPath))
+      throw new Error(`admission.userDatabase must be omitted, or ${resolve16(poolPath)}, for a journal that is not a local SQLite file`);
+    admission.userDatabase = resolve16(poolPath);
   }
   const sources = localWorkers && await Promise.all(localWorkers.definitions.map(async (source) => ({ ...source, digest: await definitionDigest(source.path) })));
   const resources = JSON.parse(JSON.stringify({
@@ -70524,6 +70906,7 @@ function createTaskPrimitive(runtime) {
         }
       })();
       const stageMeta = stage.__modelFallbackMeta();
+      stage.__releaseIfIdle?.();
       return {
         name,
         stageName: name,
@@ -71322,7 +71705,7 @@ function hasUsableContentBlock(block) {
 
 // dist/builtin/workflows/src/shared/stage-session-store.ts
 import { randomUUID as randomUUID21 } from "node:crypto";
-import { dirname as dirname15, resolve as resolve16 } from "node:path";
+import { dirname as dirname16, resolve as resolve17 } from "node:path";
 import {
   JsonlSessionStore,
   resolveSessionStore,
@@ -71358,11 +71741,11 @@ async function forkStageSession(store, sessionId, cwd, options, destination = st
 async function migrateLegacyStageSession(store, sessionId, sessionFile) {
   if (sessionFile === undefined || await store.readHeader(sessionId) !== undefined)
     return;
-  const location = resolve16(sessionFile);
-  const legacy = await JsonlSessionStore.open(dirname15(location), { exactDirectory: true, scanExisting: false });
+  const location = resolve17(sessionFile);
+  const legacy = await JsonlSessionStore.open(dirname16(location), { exactDirectory: true, scanExisting: false });
   try {
     for await (const file of legacy.scanFiles()) {
-      if (resolve16(file.location) !== location || file.header.id !== sessionId)
+      if (resolve17(file.location) !== location || file.header.id !== sessionId)
         continue;
       const snapshot = await file.read();
       if (await store.readHeader(sessionId) === undefined)
@@ -74188,6 +74571,8 @@ function createTrackedStageCaller(input) {
         await runtime.releaseLiveHandle().catch(() => {});
       }
       runtime.state.sessionCheckpointed = finalizationError === undefined;
+      if (runtime.state.contextUnreachable)
+        runtime.stageRegistry.releaseIdle(runtime.runId, runtime.stageId);
       input.limiter.release();
       if (finalizationError !== undefined)
         throwFinalizationError(finalizationError.error);
@@ -74351,7 +74736,8 @@ function createStageContext(input) {
       recordStageNotice({ kind: "abort", to: "interrupted" });
       await innerCtx.abort();
     },
-    __modelFallbackMeta: () => innerCtx.__modelFallbackMeta()
+    __modelFallbackMeta: () => innerCtx.__modelFallbackMeta(),
+    __releaseIfIdle: () => runtime.stageRegistry.releaseIdle(runtime.runId, runtime.stageId)
   };
 }
 
@@ -76040,10 +76426,10 @@ function isRetryableSameCandidateFailure(error) {
     return isTransientExtensionStartupFailure(error);
   return isRetryableSameModelFailure(error);
 }
-function mayAdvanceToNextCandidate(error) {
+function mayAdvanceToNextCandidate(error, options) {
   if (isExtensionStartupFailure(error))
     return isTransientExtensionStartupFailure(error);
-  return isRetryableModelFailure(error);
+  return isRetryableModelFailure(error, options);
 }
 function hasMeaningfulUsage(usage) {
   if (usage === undefined)
@@ -76135,6 +76521,7 @@ class StageSessionController {
   structuredOutputExecutionFailureValue;
   structuredOutputCycleAttemptMark;
   unsubscribeTerminateWatcher;
+  unbindAbortSignal;
   sessionInternalRetries = 0;
   unresolvedContextOverflowMessage;
   generationSealed = false;
@@ -76624,6 +77011,8 @@ class StageSessionController {
     this.pendingListeners.clear();
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = undefined;
+    this.unbindAbortSignal?.();
+    this.unbindAbortSignal = undefined;
     this.terminatingToolCallIds.clear();
     this.messageAdmission.dispose();
     this.deliveryActivity.dispose();
@@ -76718,8 +77107,10 @@ class StageSessionController {
     };
     if (signal.aborted)
       onAbort();
-    else
+    else {
       signal.addEventListener("abort", onAbort, { once: true });
+      this.unbindAbortSignal = () => signal.removeEventListener("abort", onAbort);
+    }
   }
   markAbort(reason) {
     this.abortGeneration += 1;
@@ -76746,6 +77137,9 @@ class StageSessionController {
       state.controller.abort(reason);
     this.thrownErrorRetryStates.clear();
   }
+  fallbackFailureOptions() {
+    return { fallbackOnContentFilter: this.retrySettings()?.fallbackOnContentFilter !== false };
+  }
   retrySettings() {
     const managers = [
       this.sessionSettingsManager,
@@ -77020,7 +77414,7 @@ class StageSessionController {
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
-        const retryableFailure = isRetryableModelFailure(error);
+        const retryableFailure = isRetryableModelFailure(error, this.fallbackFailureOptions());
         const sameCandidateRetryable = isRetryableSameModelFailure(error) && !isUnresolvedContextOverflowFailure(error);
         recordProviderRateLimit(this.currentProvider(), error, modelIdForModel(this.currentModelValue()));
         if (this.hasExplicitModelFallbackConfig && isProviderRateLimit(error)) {
@@ -77645,7 +78039,7 @@ class StageSessionController {
       }
       throw new WorkflowPromptModelFailure(terminalFailure);
     } catch (err) {
-      if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
+      if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err, this.fallbackFailureOptions())) {
         this.artifactCapture.settleAttempt(true);
         const usage = this.takeAttemptUsage(resumedSession);
         this.modelAttempts.push({
@@ -77667,7 +78061,7 @@ class StageSessionController {
         ...usage === undefined ? {} : { usage },
         error: message
       });
-      if (this.opts.signal?.aborted || !isRetryableModelFailure(err)) {
+      if (this.opts.signal?.aborted || !isRetryableModelFailure(err, this.fallbackFailureOptions())) {
         this.modelWarnings.push(...this.pendingFallbackWarnings);
         this.pendingFallbackWarnings.length = 0;
         this.notifyModelFallbackMetaChange();
@@ -77716,7 +78110,7 @@ class StageSessionController {
       throw err;
     const message = errorMessage3(err);
     const terminalStageDelivery = isWorkflowPendingStageDeliveryFailure(err);
-    if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
+    if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err, this.fallbackFailureOptions())) {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
@@ -77733,7 +78127,7 @@ class StageSessionController {
     if (walk !== undefined) {
       this.recordCandidateFailure(walk, index, err, candidates);
       nextIndex = undefined;
-      if (!this.opts.signal?.aborted && !this.startupWait.signal.aborted && !terminalStageDelivery && mayAdvanceToNextCandidate(err)) {
+      if (!this.opts.signal?.aborted && !this.startupWait.signal.aborted && !terminalStageDelivery && mayAdvanceToNextCandidate(err, this.fallbackFailureOptions())) {
         try {
           nextIndex = await this.selectReadyCandidate(candidates, walk, index + 1);
         } catch (error) {
@@ -77746,7 +78140,7 @@ class StageSessionController {
         }
       }
     }
-    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !mayAdvanceToNextCandidate(err) || nextIndex === undefined) {
+    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !mayAdvanceToNextCandidate(err, this.fallbackFailureOptions()) || nextIndex === undefined) {
       await this.settleFailedCandidate();
       return "throw";
     }
@@ -77841,7 +78235,7 @@ var init_stage_runner_controller = __esm(() => {
 // dist/builtin/workflows/src/runs/foreground/stage-runner-output.ts
 import { createHash as createHash6 } from "node:crypto";
 import { mkdir as mkdir7, writeFile as writeFile10 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname16, isAbsolute as isAbsolute11, join as join31, resolve as resolve17 } from "node:path";
+import { basename as basename6, dirname as dirname17, isAbsolute as isAbsolute11, join as join32, resolve as resolve18 } from "node:path";
 function normalizeMaxOutput2(maxOutput) {
   return {
     bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
@@ -77904,7 +78298,7 @@ function formatByteSize(bytes) {
 }
 function transcriptPath(runId, outputPath) {
   const digest = createHash6("sha256").update(outputPath).digest("hex").slice(0, 16);
-  return join31(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename6(outputPath)}.transcript.md`);
+  return join32(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename6(outputPath)}.transcript.md`);
 }
 function appendContent(lines, content) {
   if (typeof content === "string") {
@@ -77949,7 +78343,7 @@ function renderTranscript(messages, fallbackOutput) {
 `);
 }
 function savedOutputReference(outputPath, fullOutput, transcriptPathValue, transcriptText, transcriptAvailable, warning) {
-  const absolutePath = resolve17(outputPath);
+  const absolutePath = resolve18(outputPath);
   const bytes = Buffer.byteLength(fullOutput, "utf8");
   const lines = countLines(fullOutput);
   const transcriptBytes = Buffer.byteLength(transcriptText, "utf8");
@@ -77964,8 +78358,8 @@ function resolveOutputPath(output, runtimeCwd, requestedCwd) {
     return;
   if (isAbsolute11(output))
     return output;
-  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve17(runtimeCwd, requestedCwd);
-  return resolve17(baseCwd, output);
+  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve18(runtimeCwd, requestedCwd);
+  return resolve18(baseCwd, output);
 }
 function degenerateWarning(fullOutput) {
   return fullOutput.trim().length === 0 ? "WARNING: the stage artifact is empty; search the companion transcript for this stage's work." : undefined;
@@ -78024,7 +78418,7 @@ async function finalizePromptOutput(fullOutput, outputOptions, runtimeCwd, runId
   const transcriptFile = transcriptPath(runId, outputPath);
   const transcript = renderTranscript(messages, fullOutput);
   try {
-    await mkdir7(dirname16(outputPath), { recursive: true });
+    await mkdir7(dirname17(outputPath), { recursive: true });
     await writeFile10(outputPath, fullOutput, "utf8");
   } catch (err) {
     return `${displayOutput}
@@ -78036,7 +78430,7 @@ ${err instanceof Error ? err.message : String(err)}`;
   let transcriptError;
   try {
     await ensureWorkflowArtifactRunDirectory(runId);
-    await mkdir7(dirname16(transcriptFile), { recursive: true });
+    await mkdir7(dirname17(transcriptFile), { recursive: true });
     await writeFile10(transcriptFile, transcript, "utf8");
     transcriptAvailable = true;
   } catch (err) {
@@ -78547,7 +78941,8 @@ function createWorkflowStageFactory(input) {
       stageFinalized: false,
       sessionCheckpointed: false,
       skippedForParallelFailFast: false,
-      stageControlDropped: false
+      stageControlDropped: false,
+      contextUnreachable: false
     };
     const activeAskUserQuestionCalls = new Set;
     const hasActiveAskUserQuestion = () => activeAskUserQuestionCalls.size > 0 || state.activeAskUserQuestionAnonymousCalls > 0;
@@ -78793,9 +79188,18 @@ function createWorkflowStageFactory(input) {
       hasContinuation: input.opts.continuation !== undefined,
       hasScopedParents: stageFailFastScope?.parentIds !== undefined
     });
-    return createStageContext({ runtime, runTrackedStageCall });
+    const context = createStageContext({ runtime, runTrackedStageCall });
+    unreachableStageContexts.register(context, releaseWhenUnreachable(state, input.stageRegistry, input.runId, stageId));
+    return context;
+  };
+}
+function releaseWhenUnreachable(state, registry, runId, stageId) {
+  return () => {
+    state.contextUnreachable = true;
+    registry.releaseIdle(runId, stageId);
   };
 }
+var unreachableStageContexts;
 var init_executor_stage_factory = __esm(() => {
   init_intercom_group();
   init_pending_stage_route_readiness();
@@ -78810,6 +79214,7 @@ var init_executor_stage_factory = __esm(() => {
   init_pending_stage_delivery2();
   init_stage_runner();
   init_stage_runner_session();
+  unreachableStageContexts = new FinalizationRegistry((release) => release());
 });
 
 // dist/builtin/workflows/src/engine/runtime.ts
@@ -79151,7 +79556,7 @@ async function executeRun(def, resolvedInputs, opts) {
   const ownsCancellationRegistration = opts.signal === undefined && opts.cancellation !== undefined;
   const tracker = new GraphFrontierTracker;
   const inputConcurrency = resolveInputConcurrency(def.inputs, resolvedInputs);
-  const inputRuntimeDefaults = resolveInputRuntimeDefaults(def, resolvedInputs), gitWorktreeSetupCacheOwner = createGitWorktreeSetupCacheOwner(opts.gitWorktreeSetupCache);
+  const inputRuntimeDefaults = resolveInputRuntimeDefaults(def, resolvedInputs), gitWorktreeSetupCacheOwner = createGitWorktreeSetupCacheOwner(opts.gitWorktreeSetupCache, runId);
   const gitWorktreeSetupCache = gitWorktreeSetupCacheOwner.cache;
   const workflowInvocationCwd = opts.cwd ?? process.cwd();
   let workflowCwd;