baro-ai 0.51.3 → 0.51.4

package/dist/cli.mjs

@@ -13750,8 +13750,8 @@ var require_jwa = __commonJS({
     }
     function typeError(template) {
       var args = [].slice.call(arguments, 1);
-      var errMsg = util.format.bind(util, template).apply(null, args);
-      return new TypeError(errMsg);
+      var errMsg2 = util.format.bind(util, template).apply(null, args);
+      return new TypeError(errMsg2);
     }
     function bufferOrString(obj) {
       return Buffer4.isBuffer(obj) || typeof obj === "string";
@@ -22243,9 +22243,9 @@ var require_websocket_server = __commonJS({
 
 // ../baro-memory/dist/vectra-store.js
 import { LocalIndex } from "vectra";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, renameSync, rmSync, readdirSync, statSync as statSync2, lstatSync } from "fs";
-import { join as join2 } from "path";
-import { tmpdir, homedir } from "os";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3, renameSync, rmSync as rmSync2, readdirSync, statSync as statSync2, lstatSync } from "fs";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir2, homedir } from "os";
 async function createMemoryStore(config) {
   const cfg = { ...DEFAULTS, ...config };
   if (cfg.defaultMinSimilarity < 0 || cfg.defaultMinSimilarity > 1) {
@@ -22257,23 +22257,23 @@ async function createMemoryStore(config) {
   if (cfg.disabled) {
     return new NoOpMemoryStore();
   }
-  const sessionPath = cfg.sessionPath || join2(tmpdir(), `baro-memory-${process.pid}-${Date.now()}`);
+  const sessionPath = cfg.sessionPath || join3(tmpdir2(), `baro-memory-${process.pid}-${Date.now()}`);
   validateSessionPath(sessionPath);
   mkdirSync2(sessionPath, { recursive: true });
-  const indexPath = join2(sessionPath, "index");
+  const indexPath = join3(sessionPath, "index");
   mkdirSync2(indexPath, { recursive: true });
   const index = new LocalIndex(indexPath);
   if (!await index.isIndexCreated()) {
     await index.createIndex({ version: 1 });
   }
   const transformers = await import("@xenova/transformers");
-  transformers.env.cacheDir = process.env.TRANSFORMERS_CACHE || join2(homedir(), ".baro", "models");
+  transformers.env.cacheDir = process.env.TRANSFORMERS_CACHE || join3(homedir(), ".baro", "models");
   const { pipeline: pipeline2 } = transformers;
   const extractor = await pipeline2("feature-extraction", cfg.embeddingModel);
   return new VectraMemoryStore(index, extractor, sessionPath, cfg);
 }
 function validateSessionPath(sessionPath) {
-  const resolved = join2(sessionPath);
+  const resolved = join3(sessionPath);
   if (resolved.includes("..")) {
     throw new Error(`Invalid session path (contains ..): ${resolved}`);
   }
@@ -22284,26 +22284,26 @@ function validateSessionPath(sessionPath) {
     }
   }
   const normalizedPath = resolved.toLowerCase();
-  const isSafe = ALLOWED_SESSION_PARENTS.some((p) => normalizedPath.includes(p)) || normalizedPath.startsWith(tmpdir().toLowerCase());
+  const isSafe = ALLOWED_SESSION_PARENTS.some((p) => normalizedPath.includes(p)) || normalizedPath.startsWith(tmpdir2().toLowerCase());
   if (!isSafe) {
     throw new Error(`Invalid session path (must be under ~/.baro, tmpdir, or contain 'baro-memory'): ${resolved}`);
   }
 }
 function pruneOldSessions(sessionsDir) {
   try {
-    if (!existsSync2(sessionsDir))
+    if (!existsSync3(sessionsDir))
       return;
     const now = Date.now();
     for (const entry of readdirSync(sessionsDir)) {
       if (!entry.startsWith("run-"))
         continue;
-      const entryPath = join2(sessionsDir, entry);
+      const entryPath = join3(sessionsDir, entry);
       try {
         const stat2 = lstatSync(entryPath);
         if (stat2.isSymbolicLink())
           continue;
         if (stat2.isDirectory() && now - stat2.mtimeMs > SESSION_TTL_MS) {
-          rmSync(entryPath, { recursive: true, force: true });
+          rmSync2(entryPath, { recursive: true, force: true });
         }
       } catch {
       }
@@ -22354,10 +22354,10 @@ var init_vectra_store = __esm({
         this.index = index;
         this.extractor = extractor;
         this.sessionPath = sessionPath;
-        this.indexPath = join2(sessionPath, "index");
-        this.indexFilePath = join2(this.indexPath, "index.json");
-        this.cachePath = join2(sessionPath, "cache.json");
-        this.lockPath = join2(sessionPath, "cache.lock");
+        this.indexPath = join3(sessionPath, "index");
+        this.indexFilePath = join3(this.indexPath, "index.json");
+        this.cachePath = join3(sessionPath, "cache.json");
+        this.lockPath = join3(sessionPath, "cache.lock");
         this.config = config;
       }
       /**
@@ -22381,7 +22381,7 @@ var init_vectra_store = __esm({
        */
       refreshIndexIfChanged() {
         try {
-          if (!existsSync2(this.indexFilePath))
+          if (!existsSync3(this.indexFilePath))
             return;
           const mtimeMs = statSync2(this.indexFilePath).mtimeMs;
           if (mtimeMs === this.lastIndexMtimeMs)
@@ -22556,7 +22556,7 @@ ${result.content}
       }
       async close() {
         try {
-          rmSync(this.lockPath, { force: true });
+          rmSync2(this.lockPath, { force: true });
         } catch {
         }
       }
@@ -22605,7 +22605,7 @@ ${result.content}
        */
       loadCache() {
         try {
-          if (existsSync2(this.cachePath)) {
+          if (existsSync3(this.cachePath)) {
             const raw = readFileSync3(this.cachePath, "utf-8");
             if (raw.trim()) {
               return JSON.parse(raw);
@@ -22633,8 +22633,8 @@ ${result.content}
           }
         } finally {
           try {
-            if (existsSync2(this.lockPath))
-              rmSync(this.lockPath);
+            if (existsSync3(this.lockPath))
+              rmSync2(this.lockPath);
           } catch {
           }
         }
@@ -22692,12 +22692,12 @@ var init_dist2 = __esm({
 });
 
 // ../baro-orchestrator/scripts/cli.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // ../baro-orchestrator/src/orchestrate.ts
 import { mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 
 // ../../node_modules/openai/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f3) {
@@ -39880,7 +39880,7 @@ async function safePullRebase(cwd, onLog, gate) {
     } catch {
     }
     try {
-      await exec("git", ["pull", "--rebase", "origin", branch], { cwd });
+      await exec("git", ["pull", "--rebase=merges", "origin", branch], { cwd });
       onLog?.("[git] pull ok");
     } catch {
       onLog?.("[git] pull conflict, continuing without pull");
@@ -39923,7 +39923,7 @@ async function gitPushWithRetry(gate, options) {
         `[git] push rejected (attempt ${attempt}/${max}), pulling and retrying...`
       );
       try {
-        await exec("git", ["pull", "--rebase", "origin", branch], {
+        await exec("git", ["pull", "--rebase=merges", "origin", branch], {
           cwd: options.cwd
         });
       } catch {
@@ -39991,6 +39991,316 @@ function extractStderr(e2) {
   return e2 instanceof Error ? e2.message : String(e2);
 }
 
+// ../baro-orchestrator/src/worktree.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync, rmSync, symlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify as promisify3 } from "util";
+var exec2 = promisify3(execFile2);
+var LINKED_DEP_DIRS = ["node_modules", ".venv", "vendor"];
+var WorktreeManager = class {
+  constructor(repoRoot, gate, runId, opts = {}) {
+    this.repoRoot = repoRoot;
+    this.gate = gate;
+    this.runId = runId;
+    this.baseDir = join(tmpdir(), "baro-worktrees", runId);
+    this.linkDepDirs = opts.linkDepDirs ?? true;
+    this.log = opts.onLog ?? ((line) => process.stderr.write(`[worktree] ${line}
+`));
+  }
+  paths = /* @__PURE__ */ new Map();
+  /** Stories whose merge-back failed: their branch is kept for recovery. */
+  preserved = /* @__PURE__ */ new Set();
+  baseDir;
+  linkDepDirs;
+  log;
+  branchOf(storyId) {
+    return `baro-wt/${this.runId}/${sanitize(storyId)}`;
+  }
+  pathOf(storyId) {
+    return join(this.baseDir, sanitize(storyId));
+  }
+  /**
+   * Create an isolated worktree for a story, branched off the current
+   * run-branch HEAD. Returns the worktree path, or null on any failure so
+   * the caller can fall back to the shared repo cwd (preserving the old
+   * behavior rather than failing the story).
+   */
+  async create(storyId) {
+    const release = await this.gate.acquire();
+    try {
+      const branch = this.branchOf(storyId);
+      const path6 = this.pathOf(storyId);
+      await this.removeWorktreeQuiet(path6);
+      await this.deleteBranchQuiet(branch);
+      await exec2(
+        "git",
+        ["worktree", "add", "-b", branch, path6, "HEAD"],
+        { cwd: this.repoRoot }
+      );
+      this.paths.set(storyId, path6);
+      if (this.linkDepDirs) this.symlinkDepDirs(path6);
+      this.log(`created ${branch} at ${path6}`);
+      return path6;
+    } catch (e2) {
+      this.log(
+        `could not create worktree for ${storyId} (${errMsg(e2)}); falling back to shared tree`
+      );
+      return null;
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Merge a passed story's branch onto the run branch. Returns true if a
+   * worktree merge happened, false if the story had no worktree (create()
+   * fell back to the shared tree). On any merge failure, retries once with
+   * `-X theirs` (the merging story wins). Throws — leaving the run branch
+   * clean (`merge --abort`) — only when even that can't resolve it; the
+   * caller must then preserve the branch rather than discard the work.
+   */
+  async mergeBack(storyId) {
+    const path6 = this.paths.get(storyId);
+    if (!path6) return false;
+    const branch = this.branchOf(storyId);
+    const release = await this.gate.acquire();
+    try {
+      await this.autoCommitLeftovers(storyId, path6);
+      const msg = `baro: merge story ${storyId}`;
+      try {
+        await exec2("git", ["merge", "--no-ff", "-m", msg, branch], {
+          cwd: this.repoRoot
+        });
+        return true;
+      } catch {
+        const conflicts = await this.conflictedPaths();
+        await this.abortMerge(storyId);
+        this.log(
+          `WARNING: story ${storyId} conflicts with already-merged work` + (conflicts.length ? ` on [${conflicts.join(", ")}]` : "") + `; auto-resolving with -X theirs (this story wins)`
+        );
+        try {
+          await exec2(
+            "git",
+            ["merge", "--no-ff", "-X", "theirs", "-m", msg, branch],
+            { cwd: this.repoRoot }
+          );
+          return true;
+        } catch (e2) {
+          await this.abortMerge(storyId);
+          this.preserved.add(storyId);
+          throw new Error(
+            `could not merge story ${storyId} even with -X theirs: ${errMsg(e2)}`
+          );
+        }
+      }
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Abort an in-progress merge, logging if the abort itself fails. A
+   * lingering MERGE_HEAD (e.g. a held index.lock) would otherwise make the
+   * NEXT story's merge fail and be misdiagnosed against the wrong story.
+   */
+  async abortMerge(storyId) {
+    try {
+      await exec2("git", ["merge", "--abort"], { cwd: this.repoRoot });
+    } catch (e2) {
+      this.log(
+        `WARNING: 'git merge --abort' failed after story ${storyId} (${errMsg(e2)}); run branch may have a lingering MERGE_HEAD`
+      );
+    }
+  }
+  /** Remove a story's worktree + branch (after merge-back, or on failure). */
+  async cleanup(storyId) {
+    const path6 = this.paths.get(storyId);
+    const branch = this.branchOf(storyId);
+    const release = await this.gate.acquire();
+    try {
+      if (path6) {
+        await this.removeWorktreeQuiet(path6);
+        this.paths.delete(storyId);
+      }
+      await this.deleteBranchQuiet(branch);
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Remove every worktree this manager created, plus its temp dir. Branches
+   * are deleted too — EXCEPT those marked preserved (an unresolvable
+   * merge-back): their worktree dir is freed but the branch ref is kept so
+   * the commits stay recoverable after the run.
+   */
+  async cleanupAll() {
+    const release = await this.gate.acquire();
+    try {
+      for (const [storyId, path6] of this.paths) {
+        await this.removeWorktreeQuiet(path6);
+        if (this.preserved.has(storyId)) {
+          this.log(
+            `kept branch ${this.branchOf(storyId)} for recovery (merge-back failed); inspect with: git log ${this.branchOf(storyId)}`
+          );
+        } else {
+          await this.deleteBranchQuiet(this.branchOf(storyId));
+        }
+      }
+      this.paths.clear();
+      await execQuiet("git", ["worktree", "prune"], this.repoRoot);
+      rmSyncQuiet(this.baseDir);
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Reclaim worktree admin entries whose dirs are already gone
+   * (`git worktree prune`) and delete any branches under THIS run id
+   * (defensive re-entrancy guard — ids are unique per process, so this
+   * does not touch a concurrent run's worktrees).
+   */
+  async cleanupStaleOnStart() {
+    const release = await this.gate.acquire();
+    try {
+      await execQuiet("git", ["worktree", "prune"], this.repoRoot);
+      const prefix = `baro-wt/${this.runId}/`;
+      let branches = [];
+      try {
+        const { stdout } = await exec2(
+          "git",
+          ["branch", "--list", `${prefix}*`, "--format=%(refname:short)"],
+          { cwd: this.repoRoot }
+        );
+        branches = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+      } catch {
+      }
+      for (const branch of branches) {
+        await this.deleteBranchQuiet(branch);
+      }
+    } finally {
+      release();
+    }
+  }
+  // ── internals ────────────────────────────────────────────────────
+  symlinkDepDirs(worktreePath) {
+    for (const dir of LINKED_DEP_DIRS) {
+      const src = join(this.repoRoot, dir);
+      const dest = join(worktreePath, dir);
+      if (!existsSync(src) || existsSync(dest)) continue;
+      try {
+        symlinkSync(src, dest, "dir");
+      } catch (e2) {
+        this.log(`could not symlink ${dir} into worktree (${errMsg(e2)})`);
+      }
+    }
+  }
+  /**
+   * Commit work the agent edited but didn't commit, so it isn't lost on
+   * cleanup (passing is signalled by the agent, not by a commit existing).
+   * Never commits the symlinked dep dirs, and surfaces a warning rather than
+   * silently dropping work if any git step fails.
+   */
+  async autoCommitLeftovers(storyId, worktreePath) {
+    let dirty = false;
+    try {
+      const { stdout } = await exec2("git", ["status", "--porcelain"], {
+        cwd: worktreePath
+      });
+      dirty = stdout.trim().length > 0;
+    } catch {
+      return;
+    }
+    if (!dirty) return;
+    try {
+      await exec2("git", ["add", "-A"], { cwd: worktreePath });
+    } catch (e2) {
+      this.log(
+        `WARNING: failed to stage story ${storyId}'s leftover work (${errMsg(e2)}); it will not be included in the merge`
+      );
+      return;
+    }
+    await execQuiet("git", ["reset", "-q", "--", ...LINKED_DEP_DIRS], worktreePath);
+    let staged = [];
+    let diffFailed = false;
+    try {
+      const { stdout } = await exec2("git", ["diff", "--cached", "--name-only"], {
+        cwd: worktreePath
+      });
+      staged = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+    } catch (e2) {
+      diffFailed = true;
+      this.log(
+        `WARNING: could not inspect staged changes for story ${storyId} (${errMsg(e2)}); committing whatever is staged`
+      );
+    }
+    const depStaged = staged.filter(
+      (p) => LINKED_DEP_DIRS.some((d) => p === d || p.startsWith(`${d}/`))
+    );
+    if (depStaged.length > 0) {
+      this.log(
+        `WARNING: could not keep dep dirs [${depStaged.join(", ")}] out of story ${storyId}'s auto-commit; skipping it to avoid committing symlinks`
+      );
+      await execQuiet("git", ["reset", "-q"], worktreePath);
+      return;
+    }
+    if (!diffFailed && staged.length === 0) return;
+    this.log(
+      `WARNING: story ${storyId} passed with uncommitted changes; auto-committing ${diffFailed ? "" : `${staged.length} path(s) `}before merge`
+    );
+    try {
+      await exec2(
+        "git",
+        ["commit", "-m", `baro: auto-commit uncommitted work for story ${storyId}`],
+        { cwd: worktreePath }
+      );
+    } catch (e2) {
+      this.log(
+        `WARNING: failed to auto-commit story ${storyId}'s leftover work (${errMsg(e2)}); it will not be included in the merge`
+      );
+    }
+  }
+  async conflictedPaths() {
+    try {
+      const { stdout } = await exec2(
+        "git",
+        ["diff", "--name-only", "--diff-filter=U"],
+        { cwd: this.repoRoot }
+      );
+      return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  async removeWorktreeQuiet(path6) {
+    await execQuiet("git", ["worktree", "remove", "--force", path6], this.repoRoot);
+    if (existsSync(path6)) {
+      rmSyncQuiet(path6);
+      await execQuiet("git", ["worktree", "prune"], this.repoRoot);
+    }
+  }
+  async deleteBranchQuiet(branch) {
+    await execQuiet("git", ["branch", "-D", branch], this.repoRoot);
+  }
+};
+function sanitize(storyId) {
+  return storyId.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+async function execQuiet(cmd, args, cwd) {
+  try {
+    await exec2(cmd, args, { cwd });
+  } catch {
+  }
+}
+function rmSyncQuiet(path6) {
+  try {
+    rmSync(path6, { recursive: true, force: true });
+  } catch {
+  }
+}
+function errMsg(e2) {
+  return e2?.message ?? String(e2);
+}
+
 // ../baro-orchestrator/src/dag.ts
 function buildDag(stories, options = {}) {
   const onlyIncomplete = options.onlyIncomplete ?? false;
@@ -40159,8 +40469,8 @@ var Auditor = class extends BaseObserver {
 };
 
 // ../baro-orchestrator/src/participants/conductor.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 
 // ../baro-orchestrator/src/prd.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -40345,6 +40655,14 @@ var Conductor = class extends BaseObserver {
   /** Resolved when the run terminates, exposed for callers that need it. */
   done;
   resolveDone;
+  /**
+   * Serializes event handling. Mozaik delivers events without awaiting the
+   * handler, so two StoryResults settling together could interleave — one
+   * spawning the next DAG level while another's `await onStoryPassed`
+   * (worktree merge-back, #50) is still in flight, leaving the dependent
+   * level without the merged work. Chaining handlers keeps them sequential.
+   */
+  handleChain = Promise.resolve();
   constructor(opts) {
     super();
     this.opts = {
@@ -40381,7 +40699,13 @@ var Conductor = class extends BaseObserver {
   async onExternalEvent(_source, event) {
     await this.handle(event);
   }
-  async handle(event) {
+  handle(event) {
+    const run = this.handleChain.then(() => this.handleEvent(event));
+    this.handleChain = run.catch(() => {
+    });
+    return run;
+  }
+  async handleEvent(event) {
     if (RunStartRequest.is(event)) {
       await this.handleRunStart();
       return;
@@ -40521,6 +40845,20 @@ var Conductor = class extends BaseObserver {
     } else {
       this.currentLevel.failed.push(item.storyId);
       this.addGlobalFailed(item.storyId);
+      if (this.opts.onStoryFailed) {
+        try {
+          await this.opts.onStoryFailed(item.storyId);
+        } catch (e2) {
+          this.emit(
+            ConductorState.create({
+              phase: "running_level",
+              detail: `onStoryFailed hook for ${item.storyId} failed: ${e2?.message ?? String(e2)}`,
+              currentLevel: this.currentLevel.ordinal,
+              totalLevels: this.currentLevel.totalLevelsHint
+            })
+          );
+        }
+      }
     }
     await this.fillSpawnSlots();
     if (this.currentLevel.pending.size === 0) {
@@ -40790,9 +41128,9 @@ ${prompt}`;
     return true;
   }
   resolvePrompt(story) {
-    const candidatePath = this.opts.promptTemplatePath ?? join(this.opts.cwd, "prompt.md");
+    const candidatePath = this.opts.promptTemplatePath ?? join2(this.opts.cwd, "prompt.md");
     let prompt;
-    if (existsSync(candidatePath)) {
+    if (existsSync2(candidatePath)) {
       const tpl = readFileSyncSafe(candidatePath);
       prompt = tpl ? applyTemplate(tpl, story) : buildDefaultStoryPrompt(story);
     } else {
@@ -40871,9 +41209,9 @@ function applyTemplate(tpl, story) {
 }
 
 // ../baro-orchestrator/src/participants/critic.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync = promisify3(execFile2);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync = promisify4(execFile3);
 var VERDICT_SYSTEM_PROMPT = `You are a strict acceptance-criteria evaluator. You will receive:
 1. A list of acceptance criteria that must ALL be satisfied.
 2. The output text produced by an agent.
@@ -42009,9 +42347,9 @@ ${userPrompt}`;
 };
 
 // ../baro-orchestrator/src/participants/finalizer.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify4 } from "util";
-var execFileAsync2 = promisify4(execFile3);
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execFileAsync2 = promisify5(execFile4);
 var Finalizer = class extends BaseObserver {
   opts;
   envRef = null;
@@ -42923,10 +43261,10 @@ function tokenizeHints(prompt) {
 
 // ../baro-orchestrator/src/participants/memory-librarian.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var DEBUG = process.env.BARO_DEBUG?.includes("memory") ?? false;
-var LOG_DIR = join3(process.env.HOME || "/tmp", ".baro", "runs");
-var LOG_FILE = join3(LOG_DIR, `memory-${Date.now()}.log`);
+var LOG_DIR = join4(process.env.HOME || "/tmp", ".baro", "runs");
+var LOG_FILE = join4(LOG_DIR, `memory-${Date.now()}.log`);
 try {
   mkdirSync3(LOG_DIR, { recursive: true });
 } catch {
@@ -46831,6 +47169,8 @@ var StoryFactory = class extends BaseObserver {
   // narrows to vanilla AgenticEnvironment.
   envRef = null;
   active = /* @__PURE__ */ new Map();
+  /** Story ids whose spawn is in progress (closes the await-create window). */
+  spawning = /* @__PURE__ */ new Set();
   setEnvironment(env) {
     this.envRef = env;
   }
@@ -46849,7 +47189,16 @@ var StoryFactory = class extends BaseObserver {
   }
   async spawn(req) {
     if (!this.envRef) return;
-    if (this.active.has(req.storyId)) return;
+    if (this.active.has(req.storyId) || this.spawning.has(req.storyId)) return;
+    this.spawning.add(req.storyId);
+    try {
+      await this.buildAndLaunch(req);
+    } finally {
+      this.spawning.delete(req.storyId);
+    }
+  }
+  async buildAndLaunch(req) {
+    if (!this.envRef) return;
     const route = resolveStoryRoute(req.model, {
       tierMap: this.opts.tierMap,
       fallbackBackend: this.opts.llm ?? "claude",
@@ -46861,24 +47210,25 @@ var StoryFactory = class extends BaseObserver {
     process.stderr.write(
       `[story-factory] ${req.storyId} \u2192 ${formatRoute(route)}` + (req.model ? ` (model="${req.model}")` : "") + "\n"
     );
+    const storyCwd = this.opts.worktrees ? await this.opts.worktrees.create(req.storyId) ?? this.opts.cwd : this.opts.cwd;
     const agent = route.backend === "pi" ? new PiStoryAgent({
       id: req.storyId,
       prompt: req.prompt,
-      cwd: this.opts.cwd,
+      cwd: storyCwd,
       model: route.model,
       retries: req.retries,
       timeoutSecs: req.timeoutSecs
     }) : route.backend === "opencode" ? new OpenCodeStoryAgent({
       id: req.storyId,
       prompt: req.prompt,
-      cwd: this.opts.cwd,
+      cwd: storyCwd,
       model: route.model,
       retries: req.retries,
       timeoutSecs: req.timeoutSecs
     }) : route.backend === "codex" ? new CodexStoryAgent({
       id: req.storyId,
       prompt: req.prompt,
-      cwd: this.opts.cwd,
+      cwd: storyCwd,
       // undefined → let Codex pick its account default.
       model: route.model,
       retries: req.retries,
@@ -46887,7 +47237,7 @@ var StoryFactory = class extends BaseObserver {
       {
         id: req.storyId,
         prompt: req.prompt,
-        cwd: this.opts.cwd,
+        cwd: storyCwd,
         model: route.model,
         retries: req.retries,
         timeoutSecs: req.timeoutSecs
@@ -46900,7 +47250,7 @@ var StoryFactory = class extends BaseObserver {
     ) : new StoryAgent({
       id: req.storyId,
       prompt: req.prompt,
-      cwd: this.opts.cwd,
+      cwd: storyCwd,
       // undefined → StoryAgent applies its own default.
       model: route.model,
       effort: this.opts.effort,
@@ -46918,9 +47268,9 @@ var StoryFactory = class extends BaseObserver {
 };
 
 // ../baro-orchestrator/src/participants/surgeon.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify5 } from "util";
-var execFileAsync3 = promisify5(execFile4);
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify6 } from "util";
+var execFileAsync3 = promisify6(execFile5);
 var SURGEON_SYSTEM_PROMPT = `You are the Surgeon \u2014 an autonomous planner that adapts a software-project
 DAG when stories fail. Given:
 1. A snapshot of the current PRD (project, story list with dependencies +
@@ -47574,11 +47924,19 @@ async function orchestrate(config) {
   const useGit = config.withGit ?? await isInsideGitRepo(config.cwd);
   const gitGate = new GitGate();
   let baseSha = null;
+  const runId = `run-${Date.now()}-${process.pid}`;
+  const worktreesEnabled = config.withWorktrees ?? !("BARO_NO_WORKTREES" in process.env);
+  const worktrees = useGit && worktreesEnabled ? new WorktreeManager(config.cwd, gitGate, runId, {
+    linkDepDirs: config.worktreeLinkDepDirs ?? true,
+    onLog: (line) => emitTui && emit({ type: "story_log", id: "_git", line })
+  }) : null;
+  const storyPushes = [];
+  let worktreePushNeeded = false;
   const useLibrarian = config.withLibrarian ?? true;
   const useSentry = config.withSentry ?? true;
   const useMemory = config.withMemory ?? true;
-  const sessionsDir = join5(process.env.HOME || "/tmp", ".baro", "sessions");
-  const memorySessionPath = useMemory ? join5(sessionsDir, `run-${Date.now()}-${process.pid}`, "memory") : void 0;
+  const sessionsDir = join6(process.env.HOME || "/tmp", ".baro", "sessions");
+  const memorySessionPath = useMemory ? join6(sessionsDir, runId, "memory") : void 0;
   if (useMemory) {
     try {
       const { pruneOldSessions: pruneOldSessions2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
@@ -47702,6 +48060,7 @@ async function orchestrate(config) {
           (line) => emitTui && emit({ type: "story_log", id: "_git", line })
         );
       }
+      await worktrees?.cleanupStaleOnStart();
     } : void 0,
     onBeforeStoryLaunch: librarian ? (storyId, story) => {
       const hints = [
@@ -47711,40 +48070,50 @@ async function orchestrate(config) {
       return librarian.gatherContext(storyId, hints);
     } : void 0,
     onStoryPassed: useGit ? async (storyId) => {
-      await safePullRebase(
-        config.cwd,
-        (line) => emitTui && emit({ type: "story_log", id: storyId, line }),
-        gitGate
-      );
-      try {
-        await gitPushWithRetry(gitGate, {
-          cwd: config.cwd,
-          onLog: (line) => emitTui && emit({ type: "story_log", id: storyId, line })
-        });
-        if (emitTui) {
-          emit({
-            type: "push_status",
-            id: storyId,
-            success: true,
-            error: null
-          });
+      const log2 = (line) => emitTui && emit({ type: "story_log", id: storyId, line });
+      if (worktrees) {
+        let merged = false;
+        try {
+          merged = await worktrees.mergeBack(storyId);
+        } catch (e2) {
+          log2(`[git] merge-back failed; worktree preserved for recovery: ${e2?.message ?? String(e2)}`);
+          if (emitTui) {
+            emit({ type: "push_status", id: storyId, success: false, error: e2?.message ?? String(e2) });
+          }
+          return;
         }
-      } catch (e2) {
-        if (emitTui) {
-          emit({
-            type: "push_status",
-            id: storyId,
-            success: false,
-            error: e2?.message ?? String(e2)
-          });
+        if (merged) {
+          await worktrees.cleanup(storyId);
+          worktreePushNeeded = true;
+          if (emitTui) {
+            emit({ type: "push_status", id: storyId, success: true, error: null });
+          }
+          return;
         }
       }
-    } : void 0
+      await safePullRebase(config.cwd, log2, gitGate);
+      storyPushes.push(
+        (async () => {
+          try {
+            await gitPushWithRetry(gitGate, { cwd: config.cwd, onLog: log2 });
+            if (emitTui) {
+              emit({ type: "push_status", id: storyId, success: true, error: null });
+            }
+          } catch (e2) {
+            if (emitTui) {
+              emit({ type: "push_status", id: storyId, success: false, error: e2?.message ?? String(e2) });
+            }
+          }
+        })()
+      );
+    } : void 0,
+    onStoryFailed: worktrees ? (storyId) => worktrees.cleanup(storyId) : void 0
   });
   conductor.setEnvironment(env);
   conductor.join(env);
   const storyFactory = new StoryFactory({
     cwd: config.cwd,
+    worktrees: worktrees ?? void 0,
     llm: storyLlm,
     openaiModel: config.storyModel ?? "gpt-5.5",
     storyModelOverride: config.storyModel,
@@ -47776,6 +48145,17 @@ async function orchestrate(config) {
     RunStartRequest.create({ reason: "orchestrate" })
   );
   const summary = await conductor.done;
+  await Promise.allSettled(storyPushes);
+  if (worktreePushNeeded) {
+    const log2 = (line) => emitTui && emit({ type: "story_log", id: "_git", line });
+    try {
+      await gitPushWithRetry(gitGate, { cwd: config.cwd, onLog: log2 });
+      if (emitTui) emit({ type: "push_status", id: "_git", success: true, error: null });
+    } catch (e2) {
+      if (emitTui) emit({ type: "push_status", id: "_git", success: false, error: e2?.message ?? String(e2) });
+    }
+  }
+  await worktrees?.cleanupAll();
   if (critic) await critic.idle();
   if (surgeon) await surgeon.idle();
   if (finalizer) await finalizer.complete();
@@ -48054,7 +48434,7 @@ async function main() {
   }
   const cwd = resolve3(args.cwd);
   const prdPath = resolve3(cwd, args.prd);
-  if (!existsSync5(prdPath)) {
+  if (!existsSync6(prdPath)) {
     process.stderr.write(`[cli] PRD not found: ${prdPath}
 `);
     process.exit(2);