baro-ai 0.23.0 → 0.23.2

package/README.md

@@ -8,6 +8,17 @@ Give it a goal, it breaks it into stories, builds a dependency DAG, and runs the
 
 ![baro screenshot](assets/screenshot.png)
 
+> 📖 **Deep dive:** [Getting the Maximum Out of My Claude Code Subscription](https://jigjoy.ai/blog/getting-the-maximum-out-of-claude-code) — the story of why baro exists, how it pairs with Mozaik, and what it looks like in practice.
+
+## What's new (0.22–0.23)
+
+- **Opus as the default executor** — richer reasoning per story, still with routed Sonnet/Haiku available via `--model` or `.barorc`.
+- **Smaller-stories planner** — the planner now biases toward narrower, more independent stories that parallelize better on the DAG.
+- **Branch dedup** — reruns on the same goal reuse the existing `baro/<name>` branch instead of piling up duplicates.
+- **TUI: terminal-clear on tab switch** — cleaner transitions between story logs, DAG view, and stats.
+- **Audit log survives project resets** — JSONL event logs now live in `~/.baro/runs/` by default, so a wiped `node_modules` or a fresh clone doesn't lose history.
+- **Always-on audit + abnormal-exit banner** — every run is recorded, and the TUI surfaces an explicit banner when the orchestrator exits unexpectedly.
+
 ## Install
 
 ```
@@ -54,7 +65,7 @@ baro --cwd ~/projects/myapp "Add REST API"
 
 1. **Plan** — Claude (Opus) explores your codebase and generates a dependency graph of user stories
 2. **Review** — You review the plan, refine with feedback, accept or quit
-3. **Execute** — Stories run in parallel on a feature branch, each with its own Claude agent (Sonnet)
+3. **Execute** — Stories run in parallel on a feature branch, each with its own Claude agent (Opus by default in 0.23+; Sonnet/Haiku available via `--model` or `.barorc`)
 4. **Review Agent** — After each level, a review agent (Haiku) checks work against acceptance criteria and creates fix stories if needed
 5. **Finalize** — Runs build verification and creates a GitHub PR with full summary
 
@@ -62,24 +73,25 @@ baro --cwd ~/projects/myapp "Add REST API"
 
 - **Parallel execution** — independent stories run simultaneously, respecting dependency order
 - **DAG engine** — topological sort with level grouping, cycle detection
-- **Model routing** — Opus for planning, Sonnet for execution, Haiku for review (configurable)
+- **Model routing** — Opus for planning and execution (0.23+ default), Haiku for review (configurable)
 - **Live TUI** — dashboard with story status, live agent logs, DAG view, stats
 - **Review agent** — automated code review between levels with build detection and auto-fix
 - **Plan refinement** — press `r` on review screen to give feedback and regenerate the plan
 - **Build detection** — auto-detects project type (Cargo, npm, Go, Python, Make) and runs builds during review
 - **Git coordination** — mutex-protected commits, auto-push with retry, pull --rebase, conflict detection
-- **Branch per run** — creates `baro/<name>` branch, keeps main clean
+- **Branch per run** — creates `baro/<name>` branch, keeps main clean, reuses existing branches on rerun (0.23+)
 - **Dry run** — `--dry-run` generates plan and saves to `prd.json` without executing, then `--resume` to run it
 - **Resume** — detects `prd.json` and resumes incomplete executions
 - **PR creation** — creates GitHub PR with stories table, stats, time saved, and review summary
 - **Configurable parallelism** — `--parallel N` to limit concurrent story execution
-- **Story timeout** — `--timeout SECONDS` kills stuck agents (default: 10 minutes)
+- **Story timeout** — `--timeout SECONDS` kills stuck agents (default: 10 minutes, hard timeout disabled in 0.22+)
 - **Time saved** — shows parallel speedup vs sequential execution
 - **System notifications** — terminal bell + OS notification (macOS/Linux/Windows) when done
 - **Retry logic** — failed stories retry automatically (configurable per story)
 - **Interactive settings** — configure model, parallelism, timeout, context, and planner on the welcome screen with Tab/arrow keys
 - **Project config** — `.barorc` file in project root sets defaults (no CLI flags needed)
 - **Session lock** — prevents multiple baro instances from running in the same directory
+- **Audit log** — every bus event written to `~/.baro/runs/<run-id>.jsonl`
 
 ## Config file
 
@@ -207,16 +219,28 @@ Ten participants share that bus:
 | `StoryAgent`    | Runs one story via Claude CLI, with retries and timeout           |
 | `Librarian`     | Cross-agent memory — indexes outputs of exploration tools         |
 | `Sentry`        | Flags overlapping file writes across concurrent stories           |
-| `Critic`        | Per-turn acceptance-criteria evaluator (opt-in: `--with-critic`)  |
-| `Surgeon`       | Emits DAG replans when a story fails terminally (opt-in: `--with-surgeon`) |
+| `Critic`        | Per-turn acceptance-criteria evaluator (default ON, `--no-critic` to disable) |
+| `Surgeon`       | Emits DAG replans when a story fails terminally (default ON, `--no-surgeon` to disable) |
 | `Operator`      | Bridges external user commands (TUI, web UI) into bus events      |
-| `Auditor`       | JSONL log of every event on the bus                               |
+| `Auditor`       | JSONL log of every event on the bus (written to `~/.baro/runs/`)  |
 | `Cartographer`  | Translates bus events into UI frames for the Rust TUI             |
 
 The bus is open. New participants — CI deployers, Slack notifiers,
 external ticket triggers — are subscribers and emitters with no changes
 to the orchestrator.
 
+## Status & feedback
+
+baro is a work in progress. I'm actively adding things, testing ideas,
+and occasionally breaking them — if a run explodes, an [issue on
+GitHub](https://github.com/Lotus015/baro/issues) with the run's audit
+log from `~/.baro/runs/` is the fastest way to get it fixed.
+
+If you like the idea and want to help shape where it goes, PRs are
+welcome, and you can DM me on Twitter
+[@lotus_sbc](https://twitter.com/lotus_sbc) with ideas, use cases, or
+bug reports.
+
 ## License
 
 MIT

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();
@@ -7921,14 +7947,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 +7978,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 +8203,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 +8222,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 +8287,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 +8298,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");
@@ -9885,7 +9953,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, {
@@ -10303,14 +10372,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)}
 `);