@agentproto/worktree 0.12.0 → 0.14.0

package/dist/{chunk-EVHLUKC7.mjs → chunk-IEW2O3PF.mjs}

@@ -1,13 +1,14 @@
-import { provisionWorktreeTool, cleanupWorktreeTool, runGateTool, runScriptTool, startServiceTool, stopServiceTool, listServicesTool } from './chunk-EK5BH2YL.mjs';
+import { provisionWorktreeTool, cleanupWorktreeTool, runGateTool, runScriptTool, startServiceTool, stopServiceTool, listServicesTool } from './chunk-3FZWPMLF.mjs';
 import { implementTool, defineDriver } from '@agentproto/driver';
 import { randomUUID } from 'crypto';
-import { lstat, mkdir, symlink, appendFile, writeFile, copyFile, rename, readdir, stat, readFile } from 'fs/promises';
+import { lstat, mkdir, symlink, appendFile, writeFile, copyFile, readFile, rename, readdir, stat } from 'fs/promises';
 import { resolve, join, dirname, basename, posix, sep } from 'path';
 import { ToolError } from '@agentproto/tool';
 import { spawn } from 'child_process';
 import { z } from 'zod';
-import { homedir } from 'os';
-import { existsSync, mkdirSync, realpathSync, readdirSync } from 'fs';
+import { AsyncLocalStorage } from 'async_hooks';
+import { loadavg, cpus, homedir } from 'os';
+import { existsSync, mkdirSync, realpathSync, readFileSync, writeFileSync, rmSync, readdirSync } from 'fs';
 import { createServer } from 'net';
 
 /**
@@ -17,26 +18,81 @@ import { createServer } from 'net';
 function mergedEnv(extra) {
   return extra ? { ...process.env, ...extra } : process.env;
 }
+function abortReason(signal) {
+  const reason = signal.reason;
+  return reason instanceof Error ? reason : new Error("aborted");
+}
+function signalTree(child, sig) {
+  if (child.pid === void 0) return;
+  try {
+    if (process.platform === "win32") child.kill(sig);
+    else process.kill(-child.pid, sig);
+  } catch {
+  }
+}
+function killOnAbort(child, opts) {
+  const { signal } = opts;
+  if (!signal) return () => {
+  };
+  let escalation;
+  const onAbort = () => {
+    signalTree(child, "SIGTERM");
+    escalation = setTimeout(() => signalTree(child, "SIGKILL"), opts.killGraceMs ?? 5e3);
+    escalation.unref();
+  };
+  if (signal.aborted) onAbort();
+  else signal.addEventListener("abort", onAbort, { once: true });
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+    if (escalation && !signal.aborted) clearTimeout(escalation);
+  };
+}
 function execArgv(command, args, cwd, opts = {}) {
   return new Promise((resolvePromise, reject) => {
-    const child = spawn(command, args, { cwd, shell: false, env: mergedEnv(opts.env) });
+    if (opts.signal?.aborted) return reject(abortReason(opts.signal));
+    const child = spawn(command, args, {
+      cwd,
+      shell: false,
+      env: mergedEnv(opts.env),
+      detached: opts.signal !== void 0 && process.platform !== "win32"
+    });
+    const detach = killOnAbort(child, opts);
     let stdout = "";
     let stderr = "";
     child.stdout?.on("data", (d) => stdout += d.toString("utf8"));
     child.stderr?.on("data", (d) => stderr += d.toString("utf8"));
-    child.on("error", reject);
-    child.on("close", (code) => resolvePromise({ exitCode: code ?? -1, stdout, stderr }));
+    child.on("error", (err) => {
+      detach();
+      reject(err);
+    });
+    child.on("close", (code) => {
+      detach();
+      resolvePromise({ exitCode: code ?? -1, stdout, stderr });
+    });
   });
 }
 function execShell(cmd, cwd, opts = {}) {
   return new Promise((resolvePromise, reject) => {
-    const child = spawn(cmd, { cwd, shell: true, env: mergedEnv(opts.env) });
+    if (opts.signal?.aborted) return reject(abortReason(opts.signal));
+    const child = spawn(cmd, {
+      cwd,
+      shell: true,
+      env: mergedEnv(opts.env),
+      detached: opts.signal !== void 0 && process.platform !== "win32"
+    });
+    const detach = killOnAbort(child, opts);
     let stdout = "";
     let stderr = "";
     child.stdout?.on("data", (d) => stdout += d.toString("utf8"));
     child.stderr?.on("data", (d) => stderr += d.toString("utf8"));
-    child.on("error", reject);
-    child.on("close", (code) => resolvePromise({ exitCode: code ?? -1, stdout, stderr }));
+    child.on("error", (err) => {
+      detach();
+      reject(err);
+    });
+    child.on("close", (code) => {
+      detach();
+      resolvePromise({ exitCode: code ?? -1, stdout, stderr });
+    });
   });
 }
 async function execGit(repoRoot, args) {
@@ -106,6 +162,53 @@ async function expandGlob(root, pattern) {
   const candidates = await walk(root, base);
   return candidates.filter((rel) => regex.test(rel));
 }
+var GlobTraversalError = class extends Error {
+  constructor(pattern) {
+    super(`glob pattern '${pattern}' escapes the repo root (path traversal)`);
+    this.name = "GlobTraversalError";
+  }
+};
+function assertNoTraversal(pattern) {
+  if (pattern.startsWith("/")) throw new GlobTraversalError(pattern);
+  if (pattern.split("/").some((seg) => seg === "..")) throw new GlobTraversalError(pattern);
+}
+async function expandCloneGlob(root, pattern) {
+  assertNoTraversal(pattern);
+  const segments = pattern.split("/").filter((seg) => seg.length > 0);
+  if (segments.length === 0) return [];
+  if (segments.includes("**")) {
+    throw new Error(
+      `cloneGlobs pattern '${pattern}' uses '**', which is not supported \u2014 name each path segment explicitly so a directory match clones as one unit.`
+    );
+  }
+  async function walkMatch(dirRel, idx) {
+    const seg = segments[idx];
+    const isLast = idx === segments.length - 1;
+    const abs = dirRel ? join(root, dirRel) : root;
+    let entries;
+    try {
+      entries = await readdir(abs, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const regex = new RegExp(`^${escapeSegment(seg)}$`);
+    const out = [];
+    for (const entry of entries) {
+      if (entry.name === ".git") continue;
+      if (!regex.test(entry.name)) continue;
+      const rel = dirRel ? posix.join(dirRel, entry.name) : entry.name;
+      if (isLast) {
+        out.push(rel);
+        continue;
+      }
+      if (entry.isDirectory()) {
+        out.push(...await walkMatch(rel, idx + 1));
+      }
+    }
+    return out;
+  }
+  return walkMatch("", 0);
+}
 var CONFIG_FILENAME = "agentproto.json";
 var hookSchema = z.union([z.string(), z.array(z.string())]);
 var scriptSchema = z.object({
@@ -182,6 +285,280 @@ async function loadConfigFromBase(repoRoot, base = "origin/main") {
   }
   return parseConfig(result.stdout);
 }
+var LOCAL_WORKTREE_CONFIG_REL = ".agentproto/worktree.json";
+var localWriteFileEntrySchema = z.object({
+  path: z.string().min(1, "writeFiles[].path must be non-empty"),
+  content: z.string(),
+  mode: z.enum(["create", "append"]).optional()
+});
+var localWorktreeConfigSchema = z.object({
+  copyGlobs: z.array(z.string()).optional(),
+  /** Gitignored dirs/files cloned (copy-on-write where the filesystem
+   *  supports it) from the source checkout into the worktree before
+   *  `depsCmd` runs — see `clone.ts`. */
+  cloneGlobs: z.array(z.string()).optional(),
+  writeFiles: z.array(localWriteFileEntrySchema).optional(),
+  depsCmd: z.string().optional(),
+  linkPaths: z.array(z.string()).optional()
+});
+function parseLocalWorktreeConfig(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(
+      `${LOCAL_WORKTREE_CONFIG_REL} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const result = localWorktreeConfigSchema.safeParse(json);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+    throw new ConfigError(`${LOCAL_WORKTREE_CONFIG_REL} failed validation: ${issues}`);
+  }
+  return result.data;
+}
+async function loadLocalWorktreeConfig(workspace) {
+  const path = resolve(workspace, LOCAL_WORKTREE_CONFIG_REL);
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  return parseLocalWorktreeConfig(raw);
+}
+var SLUG_PLACEHOLDER = /\{slug\}/g;
+function applySlugPlaceholder(text, slug) {
+  return text.replace(SLUG_PLACEHOLDER, slug);
+}
+function resolveLocalWriteFiles(files, slug) {
+  return (files ?? []).map((file) => ({
+    ...file,
+    path: applySlugPlaceholder(file.path, slug),
+    content: applySlugPlaceholder(file.content, slug)
+  }));
+}
+var DEFAULT_PROVISION_CONCURRENCY = 2;
+var PROVISION_CONCURRENCY_ENV = "AGENTPROTO_WORKTREES_PROVISION_CONCURRENCY";
+var DEFAULT_PROVISION_LIMITS = Object.freeze({
+  concurrency: DEFAULT_PROVISION_CONCURRENCY,
+  perRepo: Object.freeze({}),
+  loadFactor: 0
+});
+function parseCap(raw) {
+  if (typeof raw === "string" && raw.trim() !== "") raw = Number(raw);
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) return void 0;
+  return raw === 0 ? Infinity : raw;
+}
+function normalizeRepoKey(key) {
+  const trimmed = key.trim();
+  if (trimmed.startsWith("~/")) return resolve(homedir(), trimmed.slice(2));
+  if (trimmed.includes("/") || trimmed.includes("\\")) return resolve(trimmed);
+  return trimmed;
+}
+function parseProvisionLimits(raw, env = process.env) {
+  const section = raw !== null && typeof raw === "object" ? raw : {};
+  const concurrency = parseCap(env[PROVISION_CONCURRENCY_ENV]) ?? parseCap(section["provisionConcurrency"]) ?? DEFAULT_PROVISION_CONCURRENCY;
+  const perRepo = {};
+  const byRepo = section["provisionConcurrencyByRepo"];
+  if (byRepo !== null && typeof byRepo === "object" && !Array.isArray(byRepo)) {
+    for (const [key, value] of Object.entries(byRepo)) {
+      const cap = parseCap(value);
+      if (cap !== void 0 && key.trim() !== "") perRepo[normalizeRepoKey(key)] = cap;
+    }
+  }
+  const factor = section["provisionLoadFactor"];
+  const loadFactor = typeof factor === "number" && Number.isFinite(factor) && factor > 0 ? factor : 0;
+  return { concurrency, perRepo, loadFactor };
+}
+var ProvisionCancelledError = class extends Error {
+  constructor(message = "worktree provisioning cancelled") {
+    super(message);
+    this.name = "ProvisionCancelledError";
+  }
+};
+var contextStore = new AsyncLocalStorage();
+function runWithProvisionContext(ctx, fn) {
+  return contextStore.run(ctx, fn);
+}
+function currentProvisionContext() {
+  return contextStore.getStore();
+}
+var ProvisionScheduler = class {
+  limits;
+  queue = [];
+  running = /* @__PURE__ */ new Set();
+  seq = 0;
+  loadTimer;
+  loadavg1;
+  cpuCount;
+  loadPollMs;
+  constructor(opts = {}) {
+    this.limits = opts.limits ?? DEFAULT_PROVISION_LIMITS;
+    this.loadavg1 = opts.loadavg1 ?? (() => loadavg()[0] ?? 0);
+    this.cpuCount = opts.cpuCount ?? (() => cpus().length || 1);
+    this.loadPollMs = opts.loadPollMs ?? 5e3;
+  }
+  /** Replace the limits (config is re-read per provision). Raising a cap
+   *  admits waiters immediately; lowering one never interrupts a running
+   *  segment, it just delays the next admission. */
+  configure(limits) {
+    this.limits = limits;
+    this.pump();
+  }
+  snapshot() {
+    return { running: this.running.size, queued: this.queue.length, limit: this.limits.concurrency };
+  }
+  /**
+   * Request a heavy-phase slot. Resolves with a lease once admitted; rejects
+   * with {@link ProvisionCancelledError} when `signal` aborts first (the
+   * queue entry is dropped, so a cancelled spawn never occupies a slot).
+   */
+  acquire(req) {
+    if (req.signal?.aborted) return Promise.reject(new ProvisionCancelledError());
+    return new Promise((resolvePromise, rejectPromise) => {
+      const waiter = {
+        seq: this.seq++,
+        repoKey: req.repoKey,
+        callerKey: req.callerKey ?? "anonymous",
+        signal: req.signal,
+        onQueued: req.onQueued,
+        lastPosition: 0,
+        grant: resolvePromise,
+        reject: rejectPromise,
+        detach: () => {
+        }
+      };
+      if (req.signal) {
+        const onAbort = () => {
+          const idx = this.queue.indexOf(waiter);
+          if (idx === -1) return;
+          this.queue.splice(idx, 1);
+          waiter.reject(new ProvisionCancelledError("worktree provisioning cancelled while queued"));
+          this.pump();
+        };
+        req.signal.addEventListener("abort", onAbort, { once: true });
+        waiter.detach = () => req.signal.removeEventListener("abort", onAbort);
+      }
+      this.queue.push(waiter);
+      this.pump();
+    });
+  }
+  repoCap(repoKey) {
+    const { perRepo } = this.limits;
+    const own = (key) => Object.hasOwn(perRepo, key) ? perRepo[key] : void 0;
+    return Math.min(own(repoKey) ?? own(basename(repoKey)) ?? Infinity, this.limits.concurrency);
+  }
+  runningFor(match) {
+    let n = 0;
+    for (const slot of this.running) if (match(slot)) n++;
+    return n;
+  }
+  /** Waiters in the order they would be admitted absent per-repo caps. */
+  projectedOrder() {
+    const held = /* @__PURE__ */ new Map();
+    for (const slot of this.running) held.set(slot.callerKey, (held.get(slot.callerKey) ?? 0) + 1);
+    const remaining = [...this.queue];
+    const ordered = [];
+    while (remaining.length > 0) {
+      let best = 0;
+      for (let i = 1; i < remaining.length; i++) {
+        if ((held.get(remaining[i].callerKey) ?? 0) < (held.get(remaining[best].callerKey) ?? 0)) best = i;
+      }
+      const [next] = remaining.splice(best, 1);
+      ordered.push(next);
+      held.set(next.callerKey, (held.get(next.callerKey) ?? 0) + 1);
+    }
+    return ordered;
+  }
+  loadGuardBlocks() {
+    const { loadFactor } = this.limits;
+    if (loadFactor <= 0) return false;
+    if (this.running.size === 0) return false;
+    return this.loadavg1() > this.cpuCount() * loadFactor;
+  }
+  pump() {
+    for (; ; ) {
+      if (this.queue.length === 0) break;
+      if (this.running.size >= this.limits.concurrency) break;
+      if (this.loadGuardBlocks()) {
+        this.armLoadTimer();
+        break;
+      }
+      const next = this.projectedOrder().find(
+        (w) => this.runningFor((s) => s.repoKey === w.repoKey) < this.repoCap(w.repoKey)
+      );
+      if (!next) break;
+      this.queue.splice(this.queue.indexOf(next), 1);
+      next.detach();
+      const slot = { repoKey: next.repoKey, callerKey: next.callerKey };
+      this.running.add(slot);
+      let released = false;
+      next.grant({
+        release: () => {
+          if (released) return;
+          released = true;
+          this.running.delete(slot);
+          this.pump();
+        }
+      });
+    }
+    this.notifyPositions();
+  }
+  notifyPositions() {
+    this.projectedOrder().forEach((waiter, idx) => {
+      const position = idx + 1;
+      if (position === waiter.lastPosition) return;
+      waiter.lastPosition = position;
+      try {
+        waiter.onQueued?.(position);
+      } catch {
+      }
+    });
+  }
+  armLoadTimer() {
+    if (this.loadTimer) return;
+    this.loadTimer = setTimeout(() => {
+      this.loadTimer = void 0;
+      this.pump();
+    }, this.loadPollMs);
+    this.loadTimer.unref();
+  }
+};
+var provisionScheduler = new ProvisionScheduler();
+
+// src/clone.ts
+async function cloneEntry(src, dest, signal) {
+  const execOpts = signal ? { signal } : {};
+  await mkdir(dirname(dest), { recursive: true });
+  const platform = process.platform;
+  const cloneArgs = platform === "darwin" ? ["-Rc", src, dest] : platform === "linux" ? ["-r", "--reflink=auto", src, dest] : null;
+  if (cloneArgs) {
+    const result = await execArgv("cp", cloneArgs, dirname(dest), execOpts);
+    if (result.exitCode === 0) return;
+    if (signal?.aborted) throw new ProvisionCancelledError();
+  }
+  const fallback = await execArgv("cp", ["-R", src, dest], dirname(dest), execOpts);
+  if (signal?.aborted) throw new ProvisionCancelledError();
+  if (fallback.exitCode !== 0) {
+    throw new Error(
+      `clone of '${src}' into '${dest}' failed: ${fallback.stderr || fallback.stdout}`
+    );
+  }
+}
+async function cloneEntries(repoRoot, cwd, patterns, signal) {
+  for (const pattern of patterns) {
+    const matches = await expandCloneGlob(repoRoot, pattern);
+    for (const rel of matches) {
+      if (signal?.aborted) throw new ProvisionCancelledError();
+      const dest = join(cwd, rel);
+      const existing = await lstat(dest).catch(() => null);
+      if (existing) continue;
+      await cloneEntry(join(repoRoot, rel), dest, signal);
+    }
+  }
+}
 var ENV_VARS = {
   /** Absolute path to the original repo checkout the worktree was cut from. */
   sourceCheckoutPath: "AGENTPROTO_SOURCE_CHECKOUT_PATH",
@@ -282,16 +659,20 @@ async function runSetup(config, ctx, opts = {}) {
   const commands = normalizeHook(config.worktree?.setup);
   const runs = [];
   const env = { ...hookEnv(ctx), TURBO_CACHE_DIR: resolveWorktreesTurboCacheDir() };
+  const execOpts = { env, ...opts.signal ? { signal: opts.signal } : {} };
   for (const command of commands) {
-    let result = await execShell(command, ctx.worktreePath, { env });
+    if (opts.signal?.aborted) throw new ProvisionCancelledError();
+    let result = await execShell(command, ctx.worktreePath, execOpts);
     let run = { command, result };
     runs.push(run);
     await appendHookLog(opts.logPath, command, result);
+    if (opts.signal?.aborted) throw new ProvisionCancelledError();
     if (result.exitCode !== 0 && opts.retryOnFailure) {
-      result = await execShell(command, ctx.worktreePath, { env });
+      result = await execShell(command, ctx.worktreePath, execOpts);
       run = { command, result };
       runs.push(run);
       await appendHookLog(opts.logPath, `${command} (retry 1/1)`, result);
+      if (opts.signal?.aborted) throw new ProvisionCancelledError();
     }
     if (result.exitCode !== 0) throw new HookError("setup", run, opts.logPath);
   }
@@ -308,6 +689,127 @@ async function runTeardown(config, ctx, opts = {}) {
   }
   return runs;
 }
+var WORKTREE_TRASH_DIRNAME = ".trash";
+var WORKTREE_TRASH_PIDFILE = ".deleting";
+var DELETER_SCRIPT = `trap 'rm -f "$1/.deleting"' EXIT; [ ! -e "$1/.deleting" ] || echo $$ > "$1/.deleting"; n=1; while [ "$n" -gt 0 ]; do n=0; for d in "$1"/*; do [ -e "$d" ] || continue; rm -rf "$d"; n=1; done; done`;
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function defaultSpawnDeleter(trashParent) {
+  const child = spawn("sh", ["-c", DELETER_SCRIPT, "_", trashParent], { detached: true, stdio: "ignore" });
+  child.unref();
+  return child.pid;
+}
+function ensureTrashDeleter(trashParent, spawnDeleter = defaultSpawnDeleter) {
+  const pidFile = join(trashParent, WORKTREE_TRASH_PIDFILE);
+  try {
+    const pid2 = Number.parseInt(readFileSync(pidFile, "utf8").trim(), 10);
+    if (Number.isInteger(pid2) && pid2 > 0 && isPidAlive(pid2)) return;
+  } catch {
+  }
+  let placeholder = false;
+  try {
+    writeFileSync(pidFile, String(process.pid));
+    placeholder = true;
+  } catch {
+  }
+  let pid;
+  try {
+    pid = spawnDeleter(trashParent);
+  } catch (err) {
+    if (placeholder) rmSync(pidFile, { force: true });
+    throw err;
+  }
+  if (pid === void 0 && placeholder) rmSync(pidFile, { force: true });
+}
+function realOrResolved(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+async function removeWorktreeFast(repoRoot, path, options = {}) {
+  const force = options.force === true;
+  if (!force) {
+    const status = await execArgv(
+      "git",
+      ["-C", path, "status", "--porcelain", "--untracked-files=normal", "--ignore-submodules=none"],
+      repoRoot
+    );
+    if (status.exitCode !== 0) {
+      throw new Error(
+        `git status failed in ${path} (exit ${status.exitCode}): ${status.stderr.trim() || status.stdout.trim()}`
+      );
+    }
+    if (status.stdout.trim().length > 0) {
+      throw new Error(
+        `git worktree remove failed (exit 128): '${path}' contains modified or untracked files, use --force to delete it`
+      );
+    }
+  }
+  const list = await execArgv("git", ["-C", repoRoot, "worktree", "list", "--porcelain"], repoRoot);
+  if (list.exitCode !== 0) {
+    throw new Error(
+      `git worktree list failed (exit ${list.exitCode}): ${list.stderr.trim() || list.stdout.trim()}`
+    );
+  }
+  const target = realOrResolved(path);
+  let found = false;
+  let locked = false;
+  for (const block of list.stdout.split(/\n\s*\n/)) {
+    const lines = block.split("\n");
+    const head = lines.find((line) => line.startsWith("worktree "));
+    if (!head || realOrResolved(head.slice("worktree ".length).trim()) !== target) continue;
+    found = true;
+    locked = lines.some((line) => line === "locked" || line.startsWith("locked "));
+    break;
+  }
+  if (!found) {
+    throw new Error(`not a linked worktree of ${repoRoot}: ${path}`);
+  }
+  if (locked) {
+    throw new Error(`git worktree remove failed (exit 128): '${path}' is locked; unlock it first`);
+  }
+  const poolDir = join(path, "..");
+  const stamp = (options.now ?? Date.now)();
+  const trashDir = join(poolDir, WORKTREE_TRASH_DIRNAME, `${basename(path)}-${stamp}`);
+  try {
+    if (!existsSync(join(poolDir, WORKTREE_TRASH_DIRNAME))) {
+      mkdirSync(join(poolDir, WORKTREE_TRASH_DIRNAME));
+    }
+    await rename(path, trashDir);
+  } catch {
+    await execGit(repoRoot, force ? ["worktree", "remove", "--force", path] : ["worktree", "remove", path]);
+    return;
+  }
+  await execGit(repoRoot, ["worktree", "prune"]);
+  if (options.spawnRemoval) {
+    options.spawnRemoval(trashDir);
+  } else {
+    ensureTrashDeleter(dirname(trashDir), options.spawnDeleter);
+  }
+}
+function sweepWorktreeTrash(root, options = {}) {
+  let names;
+  try {
+    names = readdirSync(join(root, WORKTREE_TRASH_DIRNAME));
+  } catch {
+    return;
+  }
+  names = names.filter((name) => name !== WORKTREE_TRASH_PIDFILE);
+  if (names.length === 0) return;
+  if (options.spawnRemoval) {
+    for (const name of names) options.spawnRemoval(join(root, WORKTREE_TRASH_DIRNAME, name));
+  } else {
+    ensureTrashDeleter(join(root, WORKTREE_TRASH_DIRNAME), options.spawnDeleter);
+  }
+}
 var SESSIONS_FILE_PATH = () => resolve(homedir(), ".agentproto", "sessions.json");
 var SESSIONS_BUCKETS_ROOT = () => resolve(homedir(), ".agentproto", "workspaces");
 var sessionRefSchema = z.object({
@@ -443,6 +945,12 @@ async function computeProvenance(repoRoot, worktreePath, options = {}) {
 }
 
 // src/provider/bodies/provision-worktree.body.ts
+async function discardCancelledWorktree(repoRoot, cwd, branch) {
+  await removeWorktreeFast(repoRoot, cwd, { force: true }).catch(() => {
+  });
+  await execGit(repoRoot, ["branch", "-D", branch]).catch(() => {
+  });
+}
 var provisionWorktreeBuiltin = implementTool(
   provisionWorktreeTool,
   async ({ input }) => {
@@ -455,8 +963,12 @@ var provisionWorktreeBuiltin = implementTool(
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     const config = input.runSetup !== false ? await loadConfigFromBase(input.repoRoot, base) : null;
-    const linkPaths = input.linkPaths ?? config?.worktree?.linkPaths ?? [];
-    const depsCmd = input.depsCmd ?? config?.worktree?.depsCmd;
+    const localConfig = input.runSetup !== false ? await loadLocalWorktreeConfig(input.repoRoot) : null;
+    const linkPaths = input.linkPaths ?? localConfig?.linkPaths ?? config?.worktree?.linkPaths ?? [];
+    const depsCmd = input.depsCmd ?? localConfig?.depsCmd ?? config?.worktree?.depsCmd;
+    const copyGlobs = input.copyGlobs ?? localConfig?.copyGlobs ?? [];
+    const cloneGlobs = input.cloneGlobs ?? localConfig?.cloneGlobs ?? [];
+    const writeFiles = input.writeFiles ?? resolveLocalWriteFiles(localConfig?.writeFiles, input.slug);
     for (const rel of linkPaths) {
       const target = resolve(input.repoRoot, rel);
       const dest = join(cwd, rel);
@@ -465,7 +977,7 @@ var provisionWorktreeBuiltin = implementTool(
       await mkdir(dirname(dest), { recursive: true });
       await symlink(target, dest, "dir");
     }
-    for (const file of input.writeFiles ?? []) {
+    for (const file of writeFiles) {
       const dest = join(cwd, file.path);
       await mkdir(dirname(dest), { recursive: true });
       if (file.mode === "append") {
@@ -478,146 +990,124 @@ var provisionWorktreeBuiltin = implementTool(
         await writeFile(dest, file.content);
       }
     }
-    if (depsCmd) {
-      const result = await execShell(depsCmd, cwd);
-      if (result.exitCode !== 0) {
-        throw new ToolError({
-          code: "execution_failed",
-          message: `depsCmd '${depsCmd}' failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`
-        });
+    const ctx = currentProvisionContext();
+    const signal = ctx?.signal;
+    const report = (progress) => {
+      try {
+        ctx?.onProgress?.(progress);
+      } catch {
       }
+    };
+    const hasSetup = config ? normalizeHook(config.worktree?.setup).length > 0 : false;
+    const firstHeavy = cloneGlobs.length > 0 ? "clone" : depsCmd ? "deps" : copyGlobs.length > 0 ? "copy" : hasSetup ? "setup" : null;
+    if (firstHeavy === null) {
+      report({ kind: "done", outcome: "ok" });
+      return { cwd, branch };
     }
-    for (const pattern of input.copyGlobs ?? []) {
-      const matches = await expandGlob(input.repoRoot, pattern);
-      for (const rel of matches) {
-        const dest = join(cwd, rel);
-        await mkdir(dirname(dest), { recursive: true });
-        await copyFile(join(input.repoRoot, rel), dest);
+    let phase = firstHeavy;
+    let lease;
+    try {
+      lease = await provisionScheduler.acquire({
+        repoKey: resolve(input.repoRoot),
+        ...ctx?.callerKey ? { callerKey: ctx.callerKey } : {},
+        ...signal ? { signal } : {},
+        onQueued: (position) => report({ kind: "queued", position, phase: firstHeavy })
+      });
+      if (signal?.aborted) throw new ProvisionCancelledError();
+      report({ kind: "started", phase });
+      if (cloneGlobs.length > 0) {
+        phase = "clone";
+        report({ kind: "phase", phase });
+        try {
+          await cloneEntries(input.repoRoot, cwd, cloneGlobs, signal);
+        } catch (err) {
+          if (err instanceof ProvisionCancelledError) throw err;
+          throw new ToolError({
+            code: "execution_failed",
+            message: `cloneGlobs failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
       }
-    }
-    if (config) {
-      try {
-        await runSetup(
-          config,
-          {
-            sourceCheckoutPath: input.repoRoot,
-            worktreePath: cwd,
-            branchName: branch
-          },
-          {
-            ...input.setupLogPath ? { logPath: input.setupLogPath } : {},
-            ...input.retrySetupOnFailure ? { retryOnFailure: true } : {}
+      if (depsCmd) {
+        phase = "deps";
+        report({ kind: "phase", phase });
+        const result = await execShell(depsCmd, cwd, signal ? { signal } : {});
+        if (signal?.aborted) throw new ProvisionCancelledError();
+        if (result.exitCode !== 0) {
+          throw new ToolError({
+            code: "execution_failed",
+            message: `depsCmd '${depsCmd}' failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`
+          });
+        }
+      }
+      if (copyGlobs.length > 0) {
+        phase = "copy";
+        report({ kind: "phase", phase });
+        for (const pattern of copyGlobs) {
+          const matches = await expandGlob(input.repoRoot, pattern);
+          for (const rel of matches) {
+            if (signal?.aborted) throw new ProvisionCancelledError();
+            const dest = join(cwd, rel);
+            await mkdir(dirname(dest), { recursive: true });
+            await copyFile(join(input.repoRoot, rel), dest);
           }
-        );
-      } catch (err) {
-        if (err instanceof HookError) {
-          throw new ToolError({ code: "execution_failed", message: err.message });
         }
-        throw err;
       }
+      if (config && hasSetup) {
+        phase = "setup";
+        report({ kind: "phase", phase });
+        try {
+          await runSetup(
+            config,
+            {
+              sourceCheckoutPath: input.repoRoot,
+              worktreePath: cwd,
+              branchName: branch
+            },
+            {
+              ...input.setupLogPath ? { logPath: input.setupLogPath } : {},
+              ...input.retrySetupOnFailure ? { retryOnFailure: true } : {},
+              ...signal ? { signal } : {}
+            }
+          );
+        } catch (err) {
+          if (err instanceof HookError) {
+            throw new ToolError({ code: "execution_failed", message: err.message });
+          }
+          throw err;
+        }
+      }
+    } catch (err) {
+      const cancelled = err instanceof ProvisionCancelledError;
+      report({ kind: "done", outcome: cancelled ? "cancelled" : "failed" });
+      if (cancelled) await discardCancelledWorktree(input.repoRoot, cwd, branch);
+      throw err;
+    } finally {
+      lease?.release();
     }
+    report({ kind: "done", outcome: "ok" });
     return { cwd, branch };
   }
 );
-var WORKTREE_TRASH_DIRNAME = ".trash";
-function realOrResolved(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
-}
-async function removeWorktreeFast(repoRoot, path, options = {}) {
-  const force = options.force === true;
-  if (!force) {
-    const status = await execArgv(
-      "git",
-      ["-C", path, "status", "--porcelain=v2", "--ignored=matching"],
-      repoRoot
-    );
-    if (status.exitCode !== 0) {
-      throw new Error(
-        `git status failed in ${path} (exit ${status.exitCode}): ${status.stderr.trim() || status.stdout.trim()}`
-      );
-    }
-    if (status.stdout.trim().length > 0) {
-      const probe = await execArgv("git", ["-C", repoRoot, "worktree", "remove", path], repoRoot);
-      if (probe.exitCode !== 0) {
-        throw new Error(
-          `git worktree remove failed (exit ${probe.exitCode}): ${probe.stderr.trim() || probe.stdout.trim()}`
-        );
-      }
-      await execGit(repoRoot, ["worktree", "prune"]);
-      return;
-    }
-  }
-  const list = await execArgv("git", ["-C", repoRoot, "worktree", "list", "--porcelain"], repoRoot);
-  if (list.exitCode !== 0) {
-    throw new Error(
-      `git worktree list failed (exit ${list.exitCode}): ${list.stderr.trim() || list.stdout.trim()}`
-    );
-  }
-  const registered = new Set(
-    list.stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim())
-  );
-  const registeredReal = new Set([...registered].map(realOrResolved));
-  if (!registeredReal.has(realOrResolved(path))) {
-    throw new Error(`not a linked worktree of ${repoRoot}: ${path}`);
-  }
-  const poolDir = join(path, "..");
-  const stamp = (options.now ?? Date.now)();
-  const trashDir = join(poolDir, WORKTREE_TRASH_DIRNAME, `${basename(path)}-${stamp}`);
-  try {
-    if (!existsSync(join(poolDir, WORKTREE_TRASH_DIRNAME))) {
-      mkdirSync(join(poolDir, WORKTREE_TRASH_DIRNAME));
-    }
-    await rename(path, trashDir);
-  } catch {
-    await execGit(repoRoot, force ? ["worktree", "remove", "--force", path] : ["worktree", "remove", path]);
-    return;
-  }
-  await execGit(repoRoot, ["worktree", "prune"]);
-  if (options.spawnRemoval) {
-    options.spawnRemoval(trashDir);
-  } else {
-    spawn("rm", ["-rf", trashDir], { detached: true, stdio: "ignore" }).unref();
-  }
-}
-function sweepWorktreeTrash(root, options = {}) {
-  let names;
-  try {
-    names = readdirSync(join(root, WORKTREE_TRASH_DIRNAME));
-  } catch {
-    return;
-  }
-  for (const name of names) {
-    const trashDir = join(root, WORKTREE_TRASH_DIRNAME, name);
-    if (options.spawnRemoval) {
-      options.spawnRemoval(trashDir);
-    } else {
-      spawn("rm", ["-rf", trashDir], { detached: true, stdio: "ignore" }).unref();
-    }
-  }
-}
 function isPortFree(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     const server = createServer();
-    server.once("error", () => resolve5(false));
+    server.once("error", () => resolve7(false));
     server.once("listening", () => {
-      server.close(() => resolve5(true));
+      server.close(() => resolve7(true));
     });
     server.listen(port, "127.0.0.1");
   });
 }
 function ephemeralPort() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     const server = createServer();
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
       if (address && typeof address === "object") {
         const port = address.port;
-        server.close(() => resolve5(port));
+        server.close(() => resolve7(port));
       } else {
         server.close(() => reject(new Error("could not determine an ephemeral port")));
       }
@@ -752,10 +1242,10 @@ var ServiceSupervisor = class _ServiceSupervisor {
     this.opts.proxyTable?.delete(t.runtime.hostname);
     const child = t.child;
     if (!child || t.status !== "running") return false;
-    return new Promise((resolve5) => {
+    return new Promise((resolve7) => {
       const done = () => {
         t.status = "exited";
-        resolve5(true);
+        resolve7(true);
       };
       child.once("exit", done);
       child.kill("SIGTERM");
@@ -1420,6 +1910,6 @@ var worktreeProvider = defineDriver({
   ]
 });
 
-export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, HookError, InMemoryVerdictMemoStore, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, WorktreeNotRemovableError, allocatePort, classify, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, normalizeHook, parseConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, removeWorktreeFast, repoLabel, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker };
-//# sourceMappingURL=chunk-EVHLUKC7.mjs.map
-//# sourceMappingURL=chunk-EVHLUKC7.mjs.map
+export { CONFIG_FILENAME, ConfigError, DEFAULT_PROVISION_CONCURRENCY, DEFAULT_PROVISION_LIMITS, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, GlobTraversalError, HookError, InMemoryVerdictMemoStore, LOCAL_WORKTREE_CONFIG_REL, PROVISION_CONCURRENCY_ENV, ProvisionCancelledError, ProvisionScheduler, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, WorktreeNotRemovableError, allocatePort, applySlugPlaceholder, classify, cloneEntries, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, currentProvisionContext, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandCloneGlob, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, loadLocalWorktreeConfig, normalizeHook, parseConfig, parseLocalWorktreeConfig, parseProvisionLimits, peerEnv, peerEnvKey, provisionScheduler, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, removeWorktreeFast, repoLabel, resolveLocalWriteFiles, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, runWithProvisionContext, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker };
+//# sourceMappingURL=chunk-IEW2O3PF.mjs.map
+//# sourceMappingURL=chunk-IEW2O3PF.mjs.map