baro-ai 0.23.1 → 0.23.3

package/dist/cli.mjs

@@ -7414,32 +7414,53 @@ async function createOrCheckoutBranch(cwd, branchName, onLog) {
     );
   }
 }
-async function safePullRebase(cwd, onLog) {
-  if (!await hasRemoteOrigin(cwd)) {
-    onLog?.("[git] no remote, skipping pull");
-    return;
-  }
-  let branch;
-  try {
-    branch = await getCurrentBranch(cwd);
-  } catch {
-    onLog?.("[git] no branch, skipping pull");
-    return;
-  }
-  if (!await hasRemoteBranch(cwd, branch)) {
-    onLog?.("[git] remote branch not found, skipping pull");
-    return;
-  }
-  onLog?.("[git] pulling latest...");
-  await execSafe("git", ["stash", "--include-untracked"], { cwd });
+async function safePullRebase(cwd, onLog, gate) {
+  const release = gate ? await gate.acquire() : null;
   try {
-    await exec("git", ["pull", "--rebase", "origin", branch], { cwd });
-    onLog?.("[git] pull ok");
-  } catch {
-    onLog?.("[git] pull conflict, continuing without pull");
-    await execSafe("git", ["rebase", "--abort"], { cwd });
+    if (!await hasRemoteOrigin(cwd)) {
+      onLog?.("[git] no remote, skipping pull");
+      return;
+    }
+    let branch;
+    try {
+      branch = await getCurrentBranch(cwd);
+    } catch {
+      onLog?.("[git] no branch, skipping pull");
+      return;
+    }
+    if (!await hasRemoteBranch(cwd, branch)) {
+      onLog?.("[git] remote branch not found, skipping pull");
+      return;
+    }
+    onLog?.("[git] pulling latest...");
+    let stashSha = null;
+    try {
+      const { stdout } = await exec("git", ["stash", "create"], { cwd });
+      stashSha = stdout.trim() || null;
+      if (stashSha) {
+        await execSafe("git", ["reset", "--hard", "HEAD"], { cwd });
+      }
+    } catch {
+    }
+    try {
+      await exec("git", ["pull", "--rebase", "origin", branch], { cwd });
+      onLog?.("[git] pull ok");
+    } catch {
+      onLog?.("[git] pull conflict, continuing without pull");
+      await execSafe("git", ["rebase", "--abort"], { cwd });
+    }
+    if (stashSha) {
+      try {
+        await exec("git", ["stash", "apply", stashSha], { cwd });
+      } catch (e) {
+        onLog?.(
+          `[git] could not re-apply stashed edits (sha ${stashSha.slice(0, 8)}): ${e?.message ?? String(e)}`
+        );
+      }
+    }
+  } finally {
+    release?.();
   }
-  await execSafe("git", ["stash", "pop"], { cwd });
 }
 async function gitPushWithRetry(gate, options) {
   const release = await gate.acquire();
@@ -7451,8 +7472,8 @@ async function gitPushWithRetry(gate, options) {
     const branch = await getCurrentBranch(options.cwd);
     const max = options.maxAttempts ?? GIT_PUSH_MAX_ATTEMPTS;
     let lastError = "";
+    options.onLog?.("[git] pushing...");
     for (let attempt = 1; attempt <= max; attempt++) {
-      options.onLog?.("[git] pushing...");
       try {
         await exec("git", ["push", "origin", branch], { cwd: options.cwd });
         options.onLog?.("[git] push ok");
@@ -7461,7 +7482,9 @@ async function gitPushWithRetry(gate, options) {
         lastError = extractStderr(e);
       }
       if (attempt === max) break;
-      options.onLog?.("[git] push failed, pulling and retrying...");
+      options.onLog?.(
+        `[git] push rejected (attempt ${attempt}/${max}), pulling and retrying...`
+      );
       try {
         await exec("git", ["pull", "--rebase", "origin", branch], {
           cwd: options.cwd
@@ -7472,7 +7495,10 @@ async function gitPushWithRetry(gate, options) {
         throw new Error("Rebase conflict detected, push skipped");
       }
     }
-    options.onLog?.(`[git] push failed after ${max} attempts`);
+    const compactErr = lastError.split("\n")[0]?.trim() || lastError;
+    options.onLog?.(
+      `[git] push failed after ${max} attempts: ${compactErr}`
+    );
     throw new Error(`Push failed after ${max} attempts: ${lastError}`);
   } finally {
     release();
@@ -7892,6 +7918,33 @@ var StorySpawnedItem = class extends ContextItem {
     return { type: this.type, storyId: this.storyId };
   }
 };
+var FinalizeStartedItem = class extends ContextItem {
+  constructor(branch) {
+    super();
+    this.branch = branch;
+  }
+  type = "finalize_started";
+  toJSON() {
+    return { type: this.type, branch: this.branch };
+  }
+};
+var PrCreatedItem = class extends ContextItem {
+  constructor(url, branch, baseBranch) {
+    super();
+    this.url = url;
+    this.branch = branch;
+    this.baseBranch = baseBranch;
+  }
+  type = "pr_created";
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      branch: this.branch,
+      baseBranch: this.baseBranch
+    };
+  }
+};
 var RunCompletedItem = class extends ContextItem {
   constructor(success, completedStories, failedStories, totalDurationSecs, totalAttempts, abortReason = null) {
     super();
@@ -7921,14 +7974,26 @@ var Auditor = class extends Participant {
   path;
   skipStreamChunks;
   filter;
+  /**
+   * Flips to true the first time a write fails (e.g. EACCES because
+   * `~/.baro/runs/` is root-owned from a sudo install). Once disabled,
+   * subsequent items are dropped silently — losing the audit log is
+   * better than crashing the orchestrator on every bus event.
+   */
+  disabled = false;
   constructor(opts) {
     super();
     this.path = opts.path;
     this.skipStreamChunks = opts.skipStreamChunks ?? true;
     this.filter = opts.filter;
-    mkdirSync(dirname(this.path), { recursive: true });
+    try {
+      mkdirSync(dirname(this.path), { recursive: true });
+    } catch (e) {
+      this.disable(`mkdir failed: ${e?.message ?? String(e)}`);
+    }
   }
   async onContextItem(source, item) {
+    if (this.disabled) return;
     if (this.skipStreamChunks && item instanceof ClaudeStreamChunkItem) {
       return;
     }
@@ -7940,7 +8005,19 @@ var Auditor = class extends Participant {
       source: this.sourceLabel(source),
       item: item.toJSON()
     };
-    appendFileSync(this.path, JSON.stringify(entry) + "\n");
+    try {
+      appendFileSync(this.path, JSON.stringify(entry) + "\n");
+    } catch (e) {
+      this.disable(`append failed: ${e?.message ?? String(e)}`);
+    }
+  }
+  disable(reason) {
+    if (this.disabled) return;
+    this.disabled = true;
+    process.stderr.write(
+      `[auditor] cannot write audit log at ${this.path}: ${reason} \u2014 continuing without audit
+`
+    );
   }
   sourceLabel(source) {
     const ctor = source.constructor.name;
@@ -8153,7 +8230,7 @@ function stringifyToolResultContent(content) {
 }
 
 // ../baro-orchestrator/src/participants/claude-cli-participant.ts
-var ClaudeCliParticipant = class extends Participant {
+var ClaudeCliParticipant = class _ClaudeCliParticipant extends Participant {
   constructor(agentId, opts) {
     super();
     this.agentId = agentId;
@@ -8172,6 +8249,22 @@ var ClaudeCliParticipant = class extends Participant {
       this.resolveDone = res;
     });
   }
+  /**
+   * Process-wide registry of every Claude child currently running.
+   * Used by the orchestrator's SIGINT/SIGTERM handlers to nuke
+   * orphaned Claude processes so a killed baro doesn't leave a swarm
+   * of background agents burning quota.
+   */
+  static active = /* @__PURE__ */ new Set();
+  /** Send a signal to every active Claude child. Idempotent. */
+  static killAll(signal = "SIGTERM") {
+    for (const p of _ClaudeCliParticipant.active) {
+      try {
+        p.proc?.kill(signal);
+      } catch {
+      }
+    }
+  }
   options;
   proc = null;
   buffer = "";
@@ -8221,6 +8314,7 @@ var ClaudeCliParticipant = class extends Participant {
       return;
     }
     this.proc = proc;
+    _ClaudeCliParticipant.active.add(this);
     this.transition("starting");
     proc.stdout.setEncoding("utf8");
     proc.stderr.setEncoding("utf8");
@@ -8231,6 +8325,7 @@ var ClaudeCliParticipant = class extends Participant {
       this.rejectReady(err);
     });
     proc.on("exit", (code) => {
+      _ClaudeCliParticipant.active.delete(this);
       this.exitCode = code;
       const finalPhase = this.spawnError != null || code != null && code !== 0 ? "failed" : "done";
       this.transition(finalPhase, code != null ? `exit code ${code}` : "no exit code");
@@ -9237,6 +9332,427 @@ function extractVerdictJson(text) {
   throw new Error(`unbalanced JSON object in critic response: ${trimmed.slice(0, 200)}`);
 }
 
+// ../baro-orchestrator/src/participants/finalizer.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync2 = promisify3(execFile3);
+var Finalizer = class extends Participant {
+  opts;
+  envRef = null;
+  startedAtMs = null;
+  baseSha;
+  branchName = null;
+  levels = [];
+  stories = /* @__PURE__ */ new Map();
+  /**
+   * Resolves once finalize() has completed (or been short-circuited).
+   * Lets orchestrate.ts gate its TUI `done` event so the PR URL lands
+   * in the completion screen instead of after it.
+   */
+  finalizePromise = null;
+  constructor(opts) {
+    super();
+    this.opts = {
+      cwd: opts.cwd,
+      prdPath: opts.prdPath,
+      createPr: opts.createPr ?? true,
+      onLog: opts.onLog
+    };
+    this.baseSha = opts.baseSha ?? null;
+  }
+  setEnvironment(env) {
+    this.envRef = env;
+  }
+  async onContextItem(_source, item) {
+    if (item instanceof RunStartedItem) {
+      this.startedAtMs = Date.now();
+      if (this.baseSha == null) {
+        this.baseSha = await getHeadSha(this.opts.cwd);
+      }
+      const prd = this.safeLoadPrd();
+      this.branchName = prd?.branchName ?? null;
+      return;
+    }
+    if (item instanceof LevelStartedItem) {
+      this.levels[item.ordinal] = [...item.storyIds];
+      for (const id of item.storyIds) {
+        if (!this.stories.has(id)) {
+          this.stories.set(id, {
+            id,
+            title: "",
+            success: null,
+            durationSecs: null,
+            attempts: 0,
+            levelOrdinal: item.ordinal
+          });
+        } else {
+          const rec = this.stories.get(id);
+          rec.levelOrdinal = item.ordinal;
+        }
+      }
+      return;
+    }
+    if (item instanceof StoryResultItem) {
+      const existing = this.stories.get(item.storyId) ?? {
+        id: item.storyId,
+        title: "",
+        success: null,
+        durationSecs: null,
+        attempts: 0,
+        levelOrdinal: null
+      };
+      existing.success = item.success;
+      existing.durationSecs = item.durationSecs;
+      existing.attempts = item.attempts;
+      this.stories.set(item.storyId, existing);
+      return;
+    }
+    if (item instanceof RunCompletedItem) {
+      this.finalizePromise = this.finalize(item);
+      await this.finalizePromise;
+      return;
+    }
+  }
+  /**
+   * Resolves once Finalizer has finished handling RunCompletedItem
+   * (PR opened, skipped, or failed). Resolves immediately if no run
+   * has completed yet. Safe to call multiple times.
+   */
+  complete() {
+    return this.finalizePromise ?? Promise.resolve();
+  }
+  async finalize(run) {
+    if (!this.opts.createPr) return;
+    if (!run.success && run.completedStories.length === 0) {
+      this.log("[finalizer] run failed before producing any commits; skipping PR");
+      this.emit(new PrCreatedItem(null, this.branchName ?? "", ""));
+      return;
+    }
+    if (!await this.hasGhBinary()) {
+      this.log("[finalizer] `gh` not found on PATH; skipping PR creation");
+      this.emit(new PrCreatedItem(null, this.branchName ?? "", ""));
+      return;
+    }
+    const branch = this.branchName ?? await this.detectBranch();
+    if (!branch) {
+      this.log("[finalizer] could not determine branch; skipping PR");
+      this.emit(new PrCreatedItem(null, "", ""));
+      return;
+    }
+    const baseBranch = await this.detectDefaultBaseBranch();
+    if (!baseBranch) {
+      this.log("[finalizer] could not determine base branch; skipping PR");
+      this.emit(new PrCreatedItem(null, branch, ""));
+      return;
+    }
+    if (branch === baseBranch) {
+      this.log(
+        `[finalizer] branch '${branch}' matches base; skipping PR (run committed straight to main?)`
+      );
+      this.emit(new PrCreatedItem(null, branch, baseBranch));
+      return;
+    }
+    this.emit(new FinalizeStartedItem(branch));
+    const prd = this.safeLoadPrd();
+    if (prd) {
+      for (const s of prd.userStories) {
+        const rec = this.stories.get(s.id);
+        if (rec && !rec.title) rec.title = s.title;
+      }
+    }
+    const commits = await this.collectCommitsSinceBase();
+    const orderedStories = this.orderStories();
+    const { passed, failed } = this.partition(orderedStories);
+    const filesStats = await this.collectFileStats();
+    const totalSecs = run.totalDurationSecs;
+    const title = this.buildPrTitle(prd, passed.length, orderedStories.length);
+    const body = this.buildPrBody({
+      prd,
+      run,
+      orderedStories,
+      passed,
+      failed,
+      commits,
+      filesStats,
+      totalSecs,
+      sequentialSecs: this.sequentialSeconds()
+    });
+    this.log(`[finalizer] opening PR on ${baseBranch} \u2190 ${branch}`);
+    const url = await this.openPr({ title, body, baseBranch, branch });
+    if (url) {
+      this.log(`[finalizer] PR opened: ${url}`);
+    }
+    this.emit(new PrCreatedItem(url, branch, baseBranch));
+  }
+  // ─── Bus & env helpers ──────────────────────────────────────────
+  emit(item) {
+    this.envRef?.deliverContextItem(this, item);
+  }
+  log(line) {
+    this.opts.onLog?.(line);
+  }
+  // ─── PRD ────────────────────────────────────────────────────────
+  safeLoadPrd() {
+    try {
+      return loadPrd(this.opts.prdPath);
+    } catch {
+      return null;
+    }
+  }
+  // ─── Story ordering & partitioning ──────────────────────────────
+  /**
+   * Stories returned in DAG order so the table reads top-down the same
+   * way the run executed: level 0 first, then level 1, etc. Within a
+   * level we sort by id (stable) to keep the table deterministic.
+   */
+  orderStories() {
+    const seen = /* @__PURE__ */ new Set();
+    const ordered = [];
+    for (const lvl of this.levels) {
+      const sorted = [...lvl].sort();
+      for (const id of sorted) {
+        const rec = this.stories.get(id);
+        if (rec && !seen.has(id)) {
+          ordered.push(rec);
+          seen.add(id);
+        }
+      }
+    }
+    for (const [id, rec] of this.stories.entries()) {
+      if (!seen.has(id)) ordered.push(rec);
+    }
+    return ordered;
+  }
+  partition(stories) {
+    const passed = [];
+    const failed = [];
+    for (const s of stories) {
+      if (s.success === true) passed.push(s);
+      else if (s.success === false) failed.push(s);
+    }
+    return { passed, failed };
+  }
+  sequentialSeconds() {
+    let sum = 0;
+    for (const s of this.stories.values()) {
+      if (s.durationSecs && s.success !== false) sum += s.durationSecs;
+    }
+    return sum;
+  }
+  // ─── Git / commits / files ──────────────────────────────────────
+  async collectCommitsSinceBase() {
+    if (!this.baseSha) return [];
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["log", `${this.baseSha}..HEAD`, "--pretty=format:%H%x09%s"],
+        { cwd: this.opts.cwd }
+      );
+      return stdout.split("\n").filter((l) => l.includes("	")).map((l) => {
+        const [sha, ...rest] = l.split("	");
+        return { sha, subject: rest.join("	").trim() };
+      });
+    } catch {
+      return [];
+    }
+  }
+  async collectFileStats() {
+    if (!this.baseSha) return { created: 0, modified: 0 };
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["diff", "--name-status", this.baseSha, "HEAD"],
+        { cwd: this.opts.cwd }
+      );
+      let created = 0;
+      let modified = 0;
+      for (const line of stdout.split("\n")) {
+        const ch = line.charAt(0);
+        if (ch === "A") created++;
+        else if (ch === "M" || ch === "R") modified++;
+      }
+      return { created, modified };
+    } catch {
+      return { created: 0, modified: 0 };
+    }
+  }
+  async detectBranch() {
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["branch", "--show-current"],
+        { cwd: this.opts.cwd }
+      );
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  async detectDefaultBaseBranch() {
+    try {
+      const { stdout } = await execFileAsync2(
+        "gh",
+        ["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"],
+        { cwd: this.opts.cwd }
+      );
+      const name = stdout.trim();
+      if (name) return name;
+    } catch {
+    }
+    try {
+      const { stdout } = await execFileAsync2(
+        "git",
+        ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+        { cwd: this.opts.cwd }
+      );
+      const ref = stdout.trim();
+      if (ref.startsWith("origin/")) return ref.slice("origin/".length);
+    } catch {
+    }
+    return "main";
+  }
+  // ─── PR body composition ────────────────────────────────────────
+  buildPrTitle(prd, passed, total) {
+    const project = prd?.project ?? "baro run";
+    if (passed === total) {
+      return `${project} (${total} ${total === 1 ? "story" : "stories"})`;
+    }
+    return `${project} (${passed}/${total} stories)`;
+  }
+  buildPrBody(args) {
+    const { prd, run, orderedStories, passed, failed, commits, filesStats } = args;
+    const lines = [];
+    lines.push(
+      `> Opened by [baro](https://baro.rs) \u2014 Mozaik-orchestrated parallel coding agents.`
+    );
+    lines.push("");
+    if (prd?.description) {
+      lines.push("## Goal");
+      lines.push("");
+      lines.push(prd.description.trim());
+      lines.push("");
+    }
+    if (this.levels.length > 0) {
+      lines.push("## Plan");
+      lines.push("");
+      lines.push("```");
+      for (let i = 0; i < this.levels.length; i++) {
+        const ids = this.levels[i];
+        lines.push(`Level ${i} \u2500\u2500\u2500 ${ids.join(", ")}`);
+      }
+      lines.push("```");
+      lines.push("");
+    }
+    lines.push("## Stories");
+    lines.push("");
+    lines.push("| # | Story | Status | Duration | Commit |");
+    lines.push("|---|-------|--------|----------|--------|");
+    for (const s of orderedStories) {
+      const title = (s.title || s.id).replace(/\|/g, "\\|");
+      const status = s.success === true ? "\u2713" : s.success === false ? "\u2717" : "\u2014";
+      const dur = s.durationSecs != null ? formatDuration(s.durationSecs) : "\u2014";
+      const commit = matchCommit(s, commits);
+      lines.push(
+        `| ${s.id} | ${title} | ${status} | ${dur} | ${commit ? "`" + commit.slice(0, 7) + "`" : "\u2014"} |`
+      );
+    }
+    lines.push("");
+    lines.push("## Diff stats");
+    lines.push("");
+    lines.push(`- **Files created**: ${filesStats.created}`);
+    lines.push(`- **Files modified**: ${filesStats.modified}`);
+    lines.push(`- **Total commits**: ${commits.length}`);
+    lines.push("");
+    lines.push("## Run summary");
+    lines.push("");
+    const wall = formatDuration(args.totalSecs);
+    const seq = formatDuration(args.sequentialSecs);
+    const speedup = args.totalSecs > 0 ? (args.sequentialSecs / args.totalSecs).toFixed(2) + "\xD7" : "\u2014";
+    lines.push(`- **Wall time**: ${wall}`);
+    lines.push(`- **Sequential time**: ${seq}`);
+    lines.push(`- **Parallel speedup**: ${speedup}`);
+    lines.push(`- **Stories passed**: ${passed.length}/${orderedStories.length}`);
+    lines.push(`- **Stories failed**: ${failed.length}`);
+    lines.push(`- **Total story attempts**: ${run.totalAttempts}`);
+    if (run.abortReason) {
+      lines.push(`- **Abort reason**: ${run.abortReason}`);
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("\u{1F916} Plan. Parallelize. Review. Ship. \u2014 opened by baro");
+    return lines.join("\n");
+  }
+  async hasGhBinary() {
+    try {
+      await execFileAsync2("gh", ["--version"], { cwd: this.opts.cwd });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async openPr(args) {
+    try {
+      const { stdout } = await execFileAsync2(
+        "gh",
+        [
+          "pr",
+          "create",
+          "--base",
+          args.baseBranch,
+          "--head",
+          args.branch,
+          "--title",
+          args.title,
+          "--body",
+          args.body
+        ],
+        { cwd: this.opts.cwd }
+      );
+      const url = stdout.trim().split("\n").pop() ?? "";
+      return url || null;
+    } catch (e) {
+      const stderr = e?.stderr ?? "";
+      const existing = stderr.match(/https:\/\/github\.com\/\S+\/pull\/\d+/)?.[0];
+      if (existing) {
+        this.log(`[finalizer] PR already exists: ${existing}`);
+        return existing;
+      }
+      this.log(
+        `[finalizer] gh pr create failed: ${stderr.split("\n")[0]?.trim() || e.message}`
+      );
+      return null;
+    }
+  }
+};
+function formatDuration(secs) {
+  if (secs < 60) return `${Math.round(secs)}s`;
+  const m = Math.floor(secs / 60);
+  const s = Math.round(secs % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+function matchCommit(story, commits) {
+  if (commits.length === 0) return null;
+  const idPattern = new RegExp(`\\b${story.id}\\b`, "i");
+  for (const c of commits) {
+    if (idPattern.test(c.subject)) return c.sha;
+  }
+  if (!story.title) return null;
+  const keywords = story.title.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4);
+  if (keywords.length === 0) return null;
+  let bestSha = null;
+  let bestScore = 0;
+  for (const c of commits) {
+    const subj = c.subject.toLowerCase();
+    const hits = keywords.reduce((n, k) => subj.includes(k) ? n + 1 : n, 0);
+    if (hits > bestScore) {
+      bestScore = hits;
+      bestSha = c.sha;
+    }
+  }
+  return bestScore >= 2 ? bestSha : null;
+}
+
 // ../baro-orchestrator/src/participants/librarian.ts
 var EXPLORATION_TOOLS = /* @__PURE__ */ new Set([
   "Read",
@@ -9583,9 +10099,9 @@ var StoryFactory = class extends Participant {
 };
 
 // ../baro-orchestrator/src/participants/surgeon.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync2 = promisify3(execFile3);
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync3 = promisify4(execFile4);
 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 +
@@ -9697,7 +10213,7 @@ var Surgeon = class extends Participant {
     const snap = this.opts.snapshot();
     const prompt = buildSurgeonPrompt(snap, failure);
     try {
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         this.opts.claudeBin,
         [
           "--print",
@@ -9858,6 +10374,15 @@ async function orchestrate(config) {
     });
     critic.join(env);
   }
+  const finalizer = useGit ? new Finalizer({
+    cwd: config.cwd,
+    prdPath: config.prdPath,
+    onLog: (line) => emitTui && emit({ type: "story_log", id: "_finalizer", line })
+  }) : null;
+  if (finalizer) {
+    finalizer.setEnvironment(env);
+    finalizer.join(env);
+  }
   const conductor = new Conductor({
     prdPath: config.prdPath,
     cwd: config.cwd,
@@ -9885,7 +10410,8 @@ async function orchestrate(config) {
     onStoryPassed: useGit ? async (storyId) => {
       await safePullRebase(
         config.cwd,
-        (line) => emitTui && emit({ type: "story_log", id: storyId, line })
+        (line) => emitTui && emit({ type: "story_log", id: storyId, line }),
+        gitGate
       );
       try {
         await gitPushWithRetry(gitGate, {
@@ -9937,6 +10463,7 @@ async function orchestrate(config) {
   const summary = await conductor.done;
   if (critic) await critic.idle();
   if (surgeon) await surgeon.idle();
+  if (finalizer) await finalizer.complete();
   let filesCreated = 0;
   let filesModified = 0;
   if (useGit && baseSha) {
@@ -10012,6 +10539,14 @@ var BaroEventForwarder = class extends Participant {
       this.handleCritique(item);
       return;
     }
+    if (item instanceof FinalizeStartedItem) {
+      emit({ type: "finalize_start" });
+      return;
+    }
+    if (item instanceof PrCreatedItem) {
+      emit({ type: "finalize_complete", pr_url: item.url });
+      return;
+    }
   }
   handleCoordination(item) {
     emit({
@@ -10303,14 +10838,42 @@ process.on("unhandledRejection", (reason) => {
   const stack = reason?.stack ?? String(reason);
   process.stderr.write(`[cli] unhandledRejection: ${stack}
 `);
+  ClaudeCliParticipant.killAll("SIGTERM");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
   const stack = err?.stack ?? String(err);
   process.stderr.write(`[cli] uncaughtException: ${stack}
 `);
+  ClaudeCliParticipant.killAll("SIGTERM");
   process.exit(1);
 });
+var shuttingDown = false;
+function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  process.stderr.write(`[cli] received ${signal}, killing in-flight Claude children...
+`);
+  ClaudeCliParticipant.killAll("SIGTERM");
+  setTimeout(() => {
+    ClaudeCliParticipant.killAll("SIGKILL");
+    process.exit(signal === "SIGINT" ? 130 : 143);
+  }, 1500).unref();
+}
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+var initialPpid = process.ppid;
+var orphanWatchdog = setInterval(() => {
+  if (process.ppid !== initialPpid) {
+    process.stderr.write(
+      `[cli] parent died (ppid ${initialPpid} \u2192 ${process.ppid}), shutting down
+`
+    );
+    clearInterval(orphanWatchdog);
+    shutdown("SIGTERM");
+  }
+}, 1e3);
+orphanWatchdog.unref();
 main().catch((e) => {
   process.stderr.write(`[cli] unhandled: ${e?.stack ?? String(e)}
 `);