baro-ai 0.51.3 → 0.51.5

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;
@@ -40040,6 +40350,150 @@ function buildDag(stories, options = {}) {
   return levels;
 }
 
+// ../baro-orchestrator/src/routing.ts
+var BACKENDS = ["claude", "openai", "codex", "opencode", "pi"];
+function isBackend(s2) {
+  return BACKENDS.includes(s2);
+}
+var CLAUDE_TIER_RE = /^(opus|sonnet|haiku)\b/i;
+function isClaudeTierName(s2) {
+  return CLAUDE_TIER_RE.test(s2.trim());
+}
+function splitBackendModel(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  const idx = trimmed.indexOf(":");
+  if (idx > 0) {
+    const prefix = trimmed.slice(0, idx).toLowerCase();
+    if (isBackend(prefix)) {
+      const model = trimmed.slice(idx + 1).trim();
+      return { backend: prefix, model: model.length ? model : void 0 };
+    }
+  }
+  if (isBackend(trimmed.toLowerCase())) {
+    return { backend: trimmed.toLowerCase() };
+  }
+  return { model: trimmed };
+}
+function looksLikeUrl(s2) {
+  return /^https?:\/\//i.test(s2.trim());
+}
+function splitModelEndpoint(model) {
+  const at = model.indexOf("@");
+  if (at < 0) return { model };
+  const ref = model.slice(at + 1).trim();
+  return { model: model.slice(0, at).trim(), endpointRef: ref || void 0 };
+}
+function resolveEndpoint(ref, opts) {
+  if (looksLikeUrl(ref)) {
+    return { baseUrl: ref, apiKey: opts.defaultApiKey };
+  }
+  const ep = opts.endpoints?.[ref.toLowerCase()] ?? opts.endpoints?.[ref];
+  if (!ep) {
+    throw new Error(
+      `unknown OpenAI endpoint "${ref}" \u2014 define it with --openai-endpoint ${ref}=<url> or use an inline https:// URL`
+    );
+  }
+  return { baseUrl: ep.baseUrl, apiKey: ep.apiKey ?? opts.defaultApiKey };
+}
+function resolveStoryRoute(rawModel, opts) {
+  const raw = (opts.override ?? rawModel ?? "").trim();
+  if (!raw) return defaultRoute(opts.fallbackBackend, opts.openaiDefaultModel);
+  const direct = splitBackendModel(raw);
+  if (direct.backend === void 0 && opts.tierMap) {
+    const mapped = opts.tierMap[raw.toLowerCase()] ?? opts.tierMap[raw];
+    if (mapped) {
+      return resolveStoryRoute(mapped, {
+        ...opts,
+        override: void 0,
+        tierMap: void 0
+      });
+    }
+  }
+  if (direct.backend) {
+    if (direct.model) return buildRoute(direct.backend, direct.model, opts);
+    return defaultRoute(direct.backend, opts.openaiDefaultModel);
+  }
+  const backend = opts.fallbackBackend;
+  if (backend === "claude") {
+    return { backend, model: direct.model };
+  }
+  if (direct.model && !isClaudeTierName(direct.model)) {
+    return buildRoute(backend, direct.model, opts);
+  }
+  return defaultRoute(backend, opts.openaiDefaultModel);
+}
+function buildRoute(backend, model, opts) {
+  if (backend !== "openai") return { backend, model };
+  const { model: bareModel, endpointRef } = splitModelEndpoint(model);
+  if (!endpointRef) return { backend, model: bareModel };
+  const ep = resolveEndpoint(endpointRef, opts);
+  return { backend, model: bareModel, baseUrl: ep.baseUrl, apiKey: ep.apiKey };
+}
+function defaultRoute(backend, openaiDefaultModel) {
+  if (backend === "openai") return { backend, model: openaiDefaultModel };
+  return { backend };
+}
+function parseTierMap(spec) {
+  const map = {};
+  for (const part of spec.split(",")) {
+    const seg = part.trim();
+    if (!seg) continue;
+    const eq = seg.indexOf("=");
+    if (eq <= 0) {
+      throw new Error(
+        `bad --tier-map entry "${seg}" (expected tier=backend:model)`
+      );
+    }
+    const tier = seg.slice(0, eq).trim().toLowerCase();
+    const route = seg.slice(eq + 1).trim();
+    if (!tier || !route) {
+      throw new Error(
+        `bad --tier-map entry "${seg}" (expected tier=backend:model)`
+      );
+    }
+    const { backend } = splitBackendModel(route);
+    if (!backend) {
+      throw new Error(
+        `--tier-map route "${route}" for tier "${tier}" must name a backend (claude: | openai: | codex: | opencode: | pi:)`
+      );
+    }
+    map[tier] = route;
+  }
+  return map;
+}
+function parseEndpoints(specs, keyFor) {
+  const map = {};
+  for (const raw of specs) {
+    const spec = raw.trim();
+    if (!spec) continue;
+    const eq = spec.indexOf("=");
+    if (eq <= 0) {
+      throw new Error(
+        `bad --openai-endpoint "${spec}" (expected name=url)`
+      );
+    }
+    const name = spec.slice(0, eq).trim().toLowerCase();
+    const url = spec.slice(eq + 1).trim();
+    if (!name || !url) {
+      throw new Error(
+        `bad --openai-endpoint "${spec}" (expected name=url)`
+      );
+    }
+    if (!looksLikeUrl(url)) {
+      throw new Error(
+        `--openai-endpoint "${name}" url "${url}" must start with http:// or https://`
+      );
+    }
+    map[name] = { baseUrl: url, apiKey: keyFor?.(name) };
+  }
+  return map;
+}
+function formatRoute(route) {
+  const base = route.model ? `${route.backend}:${route.model}` : route.backend;
+  return route.baseUrl ? `${base}@${route.baseUrl}` : base;
+}
+
 // ../baro-orchestrator/src/participants/auditor.ts
 import { appendFileSync, mkdirSync } from "fs";
 import { dirname } from "path";
@@ -40159,8 +40613,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 +40799,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 +40843,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 +40989,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 +41272,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 +41353,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 +42491,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;
@@ -42576,9 +43058,16 @@ var ProgressForwarder = class extends BaseObserver {
 };
 
 // ../baro-orchestrator/src/participants/forwarders/story-lifecycle.ts
+var CREATE_TOOLS = /* @__PURE__ */ new Set(["Write", "write_file"]);
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "NotebookEdit", "edit_file"]);
 var StoryLifecycleForwarder = class extends BaseObserver {
   startedStories = /* @__PURE__ */ new Set();
   retryCounts = /* @__PURE__ */ new Map();
+  // storyId → (path → first-touch kind). Distinct paths per story, so a
+  // file touched many times counts once, classified by its first write.
+  // Reset on each retry so story_complete reflects only the winning
+  // attempt's touches, not files a failed attempt wrote and abandoned.
+  filesByStory = /* @__PURE__ */ new Map();
   async onExternalEvent(_source, event) {
     if (AgentState.is(event)) {
       this.handleAgentState(event.data);
@@ -42589,6 +43078,27 @@ var StoryLifecycleForwarder = class extends BaseObserver {
       return;
     }
   }
+  // Same signal the Sentry uses: a write/edit tool call from a story
+  // agent. We attribute the touched path to that agent's story and
+  // remember its first-touch kind so story_complete can report real
+  // per-story file counts instead of a hardcoded 0.
+  async onExternalFunctionCall(source, item) {
+    const isCreate = CREATE_TOOLS.has(item.name);
+    const isEdit = EDIT_TOOLS.has(item.name);
+    if (!isCreate && !isEdit) return;
+    const agentId = source.agentId;
+    if (typeof agentId !== "string") return;
+    const path6 = extractPath(item);
+    if (!path6) return;
+    let paths = this.filesByStory.get(agentId);
+    if (!paths) {
+      paths = /* @__PURE__ */ new Map();
+      this.filesByStory.set(agentId, paths);
+    }
+    if (!paths.has(path6)) {
+      paths.set(path6, isCreate ? "created" : "modified");
+    }
+  }
   handleAgentState(item) {
     if (item.phase === "running" && !this.startedStories.has(item.agentId)) {
       this.startedStories.add(item.agentId);
@@ -42597,19 +43107,31 @@ var StoryLifecycleForwarder = class extends BaseObserver {
     if (item.phase === "waiting" && item.detail?.includes("retrying")) {
       const count = (this.retryCounts.get(item.agentId) ?? 0) + 1;
       this.retryCounts.set(item.agentId, count);
+      this.filesByStory.delete(item.agentId);
       emit({ type: "story_retry", id: item.agentId, attempt: count });
     }
   }
   handleStoryResult(item) {
     if (item.success) {
+      const paths = this.filesByStory.get(item.storyId);
+      let created = 0;
+      let modified = 0;
+      if (paths) {
+        for (const kind of paths.values()) {
+          if (kind === "created") created++;
+          else modified++;
+        }
+      }
+      this.filesByStory.delete(item.storyId);
       emit({
         type: "story_complete",
         id: item.storyId,
         duration_secs: item.durationSecs,
-        files_created: 0,
-        files_modified: 0
+        files_created: created,
+        files_modified: modified
       });
     } else {
+      this.filesByStory.delete(item.storyId);
       emit({
         type: "story_error",
         id: item.storyId,
@@ -42620,6 +43142,19 @@ var StoryLifecycleForwarder = class extends BaseObserver {
     }
   }
 };
+function extractPath(item) {
+  let args;
+  try {
+    args = JSON.parse(item.args);
+  } catch {
+    return null;
+  }
+  for (const key of ["file_path", "path", "notebook_path"]) {
+    const v = args[key];
+    if (typeof v === "string") return v;
+  }
+  return null;
+}
 
 // ../baro-orchestrator/src/participants/forwarders/token-usage.ts
 var TokenUsageForwarder = class extends BaseObserver {
@@ -42923,10 +43458,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 {
@@ -43256,7 +43791,7 @@ var Sentry = class extends BaseObserver {
     if (!WRITE_TOOLS.has(item.name)) return;
     const agentId = source.agentId;
     if (typeof agentId !== "string") return;
-    const path6 = extractPath(item);
+    const path6 = extractPath2(item);
     if (!path6) return;
     const touch = {
       agentId,
@@ -43291,7 +43826,7 @@ var Sentry = class extends BaseObserver {
     }
   }
 };
-function extractPath(item) {
+function extractPath2(item) {
   let args;
   try {
     args = JSON.parse(item.args);
@@ -46676,150 +47211,6 @@ function raceWithTimeout4(p, ms, label) {
   ]);
 }
 
-// ../baro-orchestrator/src/routing.ts
-var BACKENDS = ["claude", "openai", "codex", "opencode", "pi"];
-function isBackend(s2) {
-  return BACKENDS.includes(s2);
-}
-var CLAUDE_TIER_RE = /^(opus|sonnet|haiku)\b/i;
-function isClaudeTierName(s2) {
-  return CLAUDE_TIER_RE.test(s2.trim());
-}
-function splitBackendModel(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return {};
-  const idx = trimmed.indexOf(":");
-  if (idx > 0) {
-    const prefix = trimmed.slice(0, idx).toLowerCase();
-    if (isBackend(prefix)) {
-      const model = trimmed.slice(idx + 1).trim();
-      return { backend: prefix, model: model.length ? model : void 0 };
-    }
-  }
-  if (isBackend(trimmed.toLowerCase())) {
-    return { backend: trimmed.toLowerCase() };
-  }
-  return { model: trimmed };
-}
-function looksLikeUrl(s2) {
-  return /^https?:\/\//i.test(s2.trim());
-}
-function splitModelEndpoint(model) {
-  const at = model.indexOf("@");
-  if (at < 0) return { model };
-  const ref = model.slice(at + 1).trim();
-  return { model: model.slice(0, at).trim(), endpointRef: ref || void 0 };
-}
-function resolveEndpoint(ref, opts) {
-  if (looksLikeUrl(ref)) {
-    return { baseUrl: ref, apiKey: opts.defaultApiKey };
-  }
-  const ep = opts.endpoints?.[ref.toLowerCase()] ?? opts.endpoints?.[ref];
-  if (!ep) {
-    throw new Error(
-      `unknown OpenAI endpoint "${ref}" \u2014 define it with --openai-endpoint ${ref}=<url> or use an inline https:// URL`
-    );
-  }
-  return { baseUrl: ep.baseUrl, apiKey: ep.apiKey ?? opts.defaultApiKey };
-}
-function resolveStoryRoute(rawModel, opts) {
-  const raw = (opts.override ?? rawModel ?? "").trim();
-  if (!raw) return defaultRoute(opts.fallbackBackend, opts.openaiDefaultModel);
-  const direct = splitBackendModel(raw);
-  if (direct.backend === void 0 && opts.tierMap) {
-    const mapped = opts.tierMap[raw.toLowerCase()] ?? opts.tierMap[raw];
-    if (mapped) {
-      return resolveStoryRoute(mapped, {
-        ...opts,
-        override: void 0,
-        tierMap: void 0
-      });
-    }
-  }
-  if (direct.backend) {
-    if (direct.model) return buildRoute(direct.backend, direct.model, opts);
-    return defaultRoute(direct.backend, opts.openaiDefaultModel);
-  }
-  const backend = opts.fallbackBackend;
-  if (backend === "claude") {
-    return { backend, model: direct.model };
-  }
-  if (direct.model && !isClaudeTierName(direct.model)) {
-    return buildRoute(backend, direct.model, opts);
-  }
-  return defaultRoute(backend, opts.openaiDefaultModel);
-}
-function buildRoute(backend, model, opts) {
-  if (backend !== "openai") return { backend, model };
-  const { model: bareModel, endpointRef } = splitModelEndpoint(model);
-  if (!endpointRef) return { backend, model: bareModel };
-  const ep = resolveEndpoint(endpointRef, opts);
-  return { backend, model: bareModel, baseUrl: ep.baseUrl, apiKey: ep.apiKey };
-}
-function defaultRoute(backend, openaiDefaultModel) {
-  if (backend === "openai") return { backend, model: openaiDefaultModel };
-  return { backend };
-}
-function parseTierMap(spec) {
-  const map = {};
-  for (const part of spec.split(",")) {
-    const seg = part.trim();
-    if (!seg) continue;
-    const eq = seg.indexOf("=");
-    if (eq <= 0) {
-      throw new Error(
-        `bad --tier-map entry "${seg}" (expected tier=backend:model)`
-      );
-    }
-    const tier = seg.slice(0, eq).trim().toLowerCase();
-    const route = seg.slice(eq + 1).trim();
-    if (!tier || !route) {
-      throw new Error(
-        `bad --tier-map entry "${seg}" (expected tier=backend:model)`
-      );
-    }
-    const { backend } = splitBackendModel(route);
-    if (!backend) {
-      throw new Error(
-        `--tier-map route "${route}" for tier "${tier}" must name a backend (claude: | openai: | codex: | opencode: | pi:)`
-      );
-    }
-    map[tier] = route;
-  }
-  return map;
-}
-function parseEndpoints(specs, keyFor) {
-  const map = {};
-  for (const raw of specs) {
-    const spec = raw.trim();
-    if (!spec) continue;
-    const eq = spec.indexOf("=");
-    if (eq <= 0) {
-      throw new Error(
-        `bad --openai-endpoint "${spec}" (expected name=url)`
-      );
-    }
-    const name = spec.slice(0, eq).trim().toLowerCase();
-    const url = spec.slice(eq + 1).trim();
-    if (!name || !url) {
-      throw new Error(
-        `bad --openai-endpoint "${spec}" (expected name=url)`
-      );
-    }
-    if (!looksLikeUrl(url)) {
-      throw new Error(
-        `--openai-endpoint "${name}" url "${url}" must start with http:// or https://`
-      );
-    }
-    map[name] = { baseUrl: url, apiKey: keyFor?.(name) };
-  }
-  return map;
-}
-function formatRoute(route) {
-  const base = route.model ? `${route.backend}:${route.model}` : route.backend;
-  return route.baseUrl ? `${base}@${route.baseUrl}` : base;
-}
-
 // ../baro-orchestrator/src/participants/story-factory.ts
 var StoryFactory = class extends BaseObserver {
   constructor(opts) {
@@ -46831,6 +47222,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 +47242,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 +47263,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 +47290,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 +47303,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 +47321,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 +
@@ -46997,7 +47400,8 @@ var Surgeon = class extends BaseObserver {
       maxReplans: opts.maxReplans ?? 10,
       claudeBin: opts.claudeBin ?? "claude",
       timeoutMs: opts.timeoutMs ?? 9e4,
-      snapshot: opts.snapshot
+      snapshot: opts.snapshot,
+      resolveRoute: opts.resolveRoute
     };
   }
   /** Resolves once every in-flight LLM evaluation has completed. */
@@ -47036,7 +47440,7 @@ var Surgeon = class extends BaseObserver {
    */
   async evaluateWithLlm(failure) {
     const snap = this.opts.snapshot();
-    const prompt = buildSurgeonPrompt(snap, failure);
+    const prompt = buildSurgeonPrompt(snap, failure, this.opts.resolveRoute);
     try {
       const { stdout } = await execFileAsync3(
         this.opts.claudeBin,
@@ -47086,11 +47490,12 @@ var Surgeon = class extends BaseObserver {
     }
   }
 };
-function buildSurgeonPrompt(snap, failure) {
+function buildSurgeonPrompt(snap, failure, resolveRoute) {
   const storyLines = snap.stories.map(
     (s2) => `  - ${s2.id} ${s2.passes ? "[passed]" : "[pending]"} ${s2.model ? `<tier:${s2.model}> ` : ""}"${s2.title}" deps=${JSON.stringify(s2.dependsOn)}`
   ).join("\n");
   const failureStory = snap.stories.find((s2) => s2.id === failure.storyId);
+  const ranOn = resolveRoute ? resolveRoute(failureStory?.model) : null;
   return [
     `# Project: ${snap.project}`,
     `Description: ${snap.description}`,
@@ -47103,6 +47508,9 @@ function buildSurgeonPrompt(snap, failure) {
     `Title: ${failureStory?.title ?? "(unknown)"}`,
     `Description: ${failureStory?.description ?? "(unknown)"}`,
     `Tier that just failed: ${failureStory?.model ?? "(default)"}`,
+    ...ranOn ? [
+      `Model that actually ran: ${ranOn}  (an override replaced the planner tier above; refer to THIS model in your reason, not the tier)`
+    ] : [],
     `Attempts: ${failure.attempts}`,
     `Error: ${failure.error ?? "(no reason captured)"}`,
     "",
@@ -47153,7 +47561,8 @@ var SurgeonCodex = class extends BaseObserver {
       maxReplans: opts.maxReplans ?? 10,
       codexBin: opts.codexBin ?? "codex",
       timeoutMs: opts.timeoutMs ?? 3e5,
-      snapshot: opts.snapshot
+      snapshot: opts.snapshot,
+      resolveRoute: opts.resolveRoute
     };
   }
   async idle() {
@@ -47177,7 +47586,7 @@ var SurgeonCodex = class extends BaseObserver {
   }
   async evaluateWithLlm(failure) {
     const snap = this.opts.snapshot();
-    const userPrompt = buildSurgeonPrompt(snap, failure);
+    const userPrompt = buildSurgeonPrompt(snap, failure, this.opts.resolveRoute);
     const prompt = `${SURGEON_SYSTEM_PROMPT}
 
 ${userPrompt}`;
@@ -47249,7 +47658,8 @@ var SurgeonOpenAI = class extends BaseObserver {
     this.opts = {
       maxReplans: opts.maxReplans ?? 10,
       model: opts.model ?? "gpt-5.5",
-      snapshot: opts.snapshot
+      snapshot: opts.snapshot,
+      resolveRoute: opts.resolveRoute
     };
     this.model = pickModel3(this.opts.model);
   }
@@ -47281,7 +47691,7 @@ var SurgeonOpenAI = class extends BaseObserver {
    */
   async evaluate(failure) {
     const snap = this.opts.snapshot();
-    const userPrompt = buildSurgeonPrompt(snap, failure);
+    const userPrompt = buildSurgeonPrompt(snap, failure, this.opts.resolveRoute);
     const context = ModelContext.create("surgeon").addContextItem(SystemMessageItem.create(SURGEON_SYSTEM_PROMPT)).addContextItem(UserMessageItem.create(userPrompt));
     try {
       const round = await runInferenceRound(context, this.model);
@@ -47338,7 +47748,8 @@ var SurgeonOpenCode = class extends BaseObserver {
       maxReplans: opts.maxReplans ?? 10,
       opencodeBin: opts.opencodeBin ?? "opencode",
       timeoutMs: opts.timeoutMs ?? 3e5,
-      snapshot: opts.snapshot
+      snapshot: opts.snapshot,
+      resolveRoute: opts.resolveRoute
     };
   }
   async idle() {
@@ -47362,7 +47773,7 @@ var SurgeonOpenCode = class extends BaseObserver {
   }
   async evaluateWithLlm(failure) {
     const snap = this.opts.snapshot();
-    const userPrompt = buildSurgeonPrompt(snap, failure);
+    const userPrompt = buildSurgeonPrompt(snap, failure, this.opts.resolveRoute);
     const prompt = `${SURGEON_SYSTEM_PROMPT}
 
 ${userPrompt}`;
@@ -47417,7 +47828,8 @@ var SurgeonPi = class extends BaseObserver {
       maxReplans: opts.maxReplans ?? 10,
       piBin: opts.piBin ?? "pi",
       timeoutMs: opts.timeoutMs ?? 3e5,
-      snapshot: opts.snapshot
+      snapshot: opts.snapshot,
+      resolveRoute: opts.resolveRoute
     };
   }
   async idle() {
@@ -47441,7 +47853,7 @@ var SurgeonPi = class extends BaseObserver {
   }
   async evaluateWithLlm(failure) {
     const snap = this.opts.snapshot();
-    const userPrompt = buildSurgeonPrompt(snap, failure);
+    const userPrompt = buildSurgeonPrompt(snap, failure, this.opts.resolveRoute);
     const prompt = `${SURGEON_SYSTEM_PROMPT}
 
 ${userPrompt}`;
@@ -47574,11 +47986,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));
@@ -47610,32 +48030,53 @@ async function orchestrate(config) {
         }))
       };
     };
+    const storyRouting = {
+      fallbackBackend: storyLlm,
+      openaiDefaultModel: config.storyModel ?? "gpt-5.5",
+      override: config.storyModel,
+      tierMap: config.tierMap,
+      endpoints: config.openaiEndpoints,
+      defaultApiKey: process.env.OPENAI_API_KEY
+    };
+    const routingOverridden = storyLlm !== "claude" || !!config.storyModel || !!config.tierMap;
+    const resolveRoute = routingOverridden ? (model) => {
+      try {
+        return formatRoute(resolveStoryRoute(model, storyRouting));
+      } catch {
+        return null;
+      }
+    } : void 0;
     if (surgeonLlm === "openai") {
       surgeon = new SurgeonOpenAI({
         snapshot,
+        resolveRoute,
         model: config.surgeonModel ?? "gpt-5.5"
       });
     } else if (surgeonLlm === "codex") {
       surgeon = new SurgeonCodex({
         snapshot,
+        resolveRoute,
         useLlm: config.surgeonUseLlm ?? true,
         model: config.surgeonModel
       });
     } else if (surgeonLlm === "opencode") {
       surgeon = new SurgeonOpenCode({
         snapshot,
+        resolveRoute,
         useLlm: config.surgeonUseLlm ?? true,
         model: config.surgeonModel
       });
     } else if (surgeonLlm === "pi") {
       surgeon = new SurgeonPi({
         snapshot,
+        resolveRoute,
         useLlm: config.surgeonUseLlm ?? true,
         model: config.surgeonModel
       });
     } else {
       surgeon = new Surgeon({
         snapshot,
+        resolveRoute,
         useLlm: config.surgeonUseLlm ?? false,
         model: config.surgeonModel ?? "opus"
       });
@@ -47702,6 +48143,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 +48153,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 +48228,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 +48517,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);