baro-ai 0.44.0 → 0.45.0

package/README.md

@@ -69,7 +69,31 @@ flowchart LR
     F --> PR([Pull Request])
 ```
 
-Every story is one **Claude Code subprocess** (or one Mozaik-native OpenAI session) — auth inherits from your existing setup, no API key plumbing.
+Every story is one CLI subprocess — Claude Code, OpenAI Codex CLI, or a Mozaik-native OpenAI Responses session, depending on `--llm`. Auth inherits from whichever CLI you already have signed in, no API key plumbing.
+
+## Three LLM backends, one DAG
+
+```bash
+baro --llm claude  "Your goal"   # default — Claude Code on Anthropic Max subscription
+baro --llm codex   "Your goal"   # OpenAI Codex CLI on ChatGPT Pro/Plus subscription
+baro --llm openai  "Your goal"   # Mozaik-native OpenAI Responses (per-call API billing)
+baro --llm hybrid  "Your goal"   # Claude on Architect/Planner/Surgeon, Codex on Story/Critic
+```
+
+Same orchestration. Same DAG. Same prompts. The only thing that moves is which provider every agent talks to. `--llm hybrid` is the new default-recommendation for serious runs — Claude where the upstream plan matters, Codex for the parallel story+critic work that dominates the budget.
+
+Each phase has its own override flag if you want to mix it yourself:
+
+```bash
+baro --architect-llm claude \
+     --planner-llm  claude \
+     --story-llm    codex  \
+     --critic-llm   codex  \
+     --surgeon-llm  claude \
+     "Your goal"
+```
+
+Full breakdown at [docs.baro.rs/llm-providers](https://docs.baro.rs/llm-providers) — provider economics, per-phase routing, the side-by-side benchmark across three real tasks: [**I tested Claude Code vs OpenAI Codex in my parallel agent setup. Then I built a hybrid.**](https://jigjoy.ai/blog/claude-code-vs-codex-baro)
 
 ## Recent real run
 
@@ -82,7 +106,7 @@ Every story is one **Claude Code subprocess** (or one Mozaik-native OpenAI sessi
 | **Architect** | One Opus call before planning — emits a `DecisionDocument` that pins every cross-cutting design decision (file paths, schemas, API shapes, library choices) so 30 parallel agents don't each invent their own |
 | **Planner** | Decomposes the goal into a story DAG, with the DecisionDocument already pinned |
 | **Conductor** | State machine that drives the run by reacting to bus events |
-| **StoryAgent** | One Claude Code subprocess per story; multi-turn loop until story completes |
+| **StoryAgent** | One CLI subprocess per story (Claude Code / Codex / OpenAI Responses, picked by `--llm` or `--story-llm`); multi-turn loop until story completes |
 | **Critic** | Per-turn evaluator (Haiku). On fail verdict, injects corrective feedback as the agent's next turn |
 | **Sentry** | Flags overlapping Edit/Write tool calls across concurrent stories |
 | **Librarian** | Indexes one agent's Read/Grep findings so siblings don't redo the exploration |
@@ -96,16 +120,22 @@ Bus is open. CI deployers, Slack notifiers, ticket triggers — all new particip
 ```bash
 npm install -g baro-ai
 
-# Full run (default — Architect + Planner + parallel Story Agents)
+# Full run (default — Claude on every phase via Claude Code CLI)
 baro "Migrate the hardcoded category data to a backend dictionary"
 
 # Trivial goal — skip Architect + Critic + Surgeon, single story
 baro --quick "fix the typo on line 42 of README.md"
 
-# Route every phase through GPT-5.5 instead of Claude
+# Codex everywhere (ChatGPT Pro/Plus subscription, ~3-11× cheaper per run than Claude)
+baro --llm codex "Refactor the database layer"
+
+# Per-phase routing — Claude upstream (tight plans), Codex downstream (cheap writes)
+baro --llm hybrid "Add WebSocket support across api and frontend"
+
+# Route every phase through GPT-5.5 (Mozaik-native OpenAI API)
 OPENAI_API_KEY=sk-... baro --llm openai "Refactor the database layer"
 
-# Limit parallelism (Anthropic plan tiers cap concurrency)
+# Limit parallelism (plan-tier concurrency caps)
 baro --parallel 3 "Add unit tests for the auth module"
 
 # Dry-run first, execute later
@@ -134,7 +164,11 @@ For a deeper side-by-side on a real refactor, see [baro vs Claude Code `/goal`](
 
 ## Requirements
 
-- [Claude CLI](https://docs.anthropic.com/en/docs/claude-cli) authenticated (for `--llm claude`, the default) **or** `OPENAI_API_KEY` set (for `--llm openai`)
+- At least one of:
+  - [Claude CLI](https://docs.anthropic.com/en/docs/claude-cli) authenticated (for `--llm claude`, the default)
+  - [OpenAI Codex CLI](https://github.com/openai/codex) authenticated (for `--llm codex`)
+  - `OPENAI_API_KEY` set (for `--llm openai`)
+  - Both Claude CLI **and** Codex CLI authenticated (for `--llm hybrid`)
 - Node.js 20+
 - macOS (arm64/x64), Linux (x64/arm64), Windows (x64)
 - `gh` CLI (optional, for automatic PR creation)

package/dist/cli.mjs

@@ -9886,6 +9886,10 @@ function buildDag(stories, options = {}) {
   return levels;
 }
 
+// ../baro-orchestrator/src/participants/auditor.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+
 // ../baro-orchestrator/src/semantic-events.ts
 function defineSemanticEvent(type) {
   return {
@@ -9924,8 +9928,6 @@ var ConductorState = defineSemanticEvent("conductor_state");
 var StoryResult = defineSemanticEvent("story_result");
 
 // ../baro-orchestrator/src/participants/auditor.ts
-import { appendFileSync, mkdirSync } from "fs";
-import { dirname } from "path";
 var Auditor = class extends BaseObserver {
   path;
   skipStreamChunks;
@@ -11611,6 +11613,206 @@ function matchCommit(story, commits) {
   return bestScore >= 2 ? bestSha : null;
 }
 
+// ../baro-orchestrator/src/tui-protocol.ts
+function emit(event) {
+  const line = JSON.stringify(event) + "\n";
+  process.stdout.write(line);
+}
+
+// ../baro-orchestrator/src/participants/forwarders/agent-stream.ts
+var AgentStreamForwarder = class extends BaseObserver {
+  async onExternalModelMessage(source, item) {
+    const agentId = source.agentId;
+    if (typeof agentId !== "string") return;
+    const json = item.toJSON();
+    const text = json.content?.[0]?.text ?? "";
+    if (!text.trim()) return;
+    emitMultiline(agentId, text);
+  }
+  async onExternalFunctionCall(source, item) {
+    const agentId = source.agentId;
+    if (typeof agentId !== "string") return;
+    emitMultiline(agentId, `[tool_call] ${item.name} ${item.args}`);
+  }
+  async onExternalFunctionCallOutput(source, item) {
+    const agentId = source.agentId;
+    if (typeof agentId !== "string") return;
+    const json = item.toJSON();
+    const text = json.output?.[0]?.text ?? "";
+    emitMultiline(agentId, `[tool_result ${json.call_id}] ${text}`);
+  }
+};
+function emitMultiline(agentId, text) {
+  if (!text) return;
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (line.length === 0 && lines.length === 1) continue;
+    emit({ type: "story_log", id: agentId, line });
+  }
+}
+
+// ../baro-orchestrator/src/participants/forwarders/coordination.ts
+var CoordinationForwarder = class extends BaseObserver {
+  async onExternalEvent(_source, event) {
+    if (Coordination.is(event)) {
+      this.handleCoordination(event.data);
+      return;
+    }
+    if (Critique.is(event)) {
+      this.handleCritique(event.data);
+      return;
+    }
+  }
+  handleCoordination(item) {
+    emit({
+      type: "story_log",
+      id: item.recipientId,
+      line: `[sentry/${item.kind}] ${item.reason}`
+    });
+  }
+  handleCritique(item) {
+    emit({
+      type: "story_log",
+      id: item.agentId,
+      line: `[critic/${item.verdict}] ${item.reasoning}`
+    });
+  }
+};
+
+// ../baro-orchestrator/src/participants/forwarders/finalization.ts
+var FinalizationForwarder = class extends BaseObserver {
+  async onExternalEvent(_source, event) {
+    if (FinalizeStarted.is(event)) {
+      const _item = event.data;
+      emit({ type: "finalize_start" });
+      return;
+    }
+    if (PrCreated.is(event)) {
+      const item = event.data;
+      emit({ type: "finalize_complete", pr_url: item.url });
+      return;
+    }
+  }
+};
+
+// ../baro-orchestrator/src/participants/forwarders/progress.ts
+var ProgressForwarder = class extends BaseObserver {
+  async onExternalEvent(_source, event) {
+    if (!ConductorState.is(event)) return;
+    const item = event.data;
+    if (item.phase === "running_level" && item.currentLevel != null && item.totalLevels != null) {
+      emit({
+        type: "progress",
+        completed: item.currentLevel - 1,
+        total: item.totalLevels,
+        percentage: Math.round(
+          (item.currentLevel - 1) / Math.max(1, item.totalLevels) * 100
+        )
+      });
+    }
+  }
+};
+
+// ../baro-orchestrator/src/participants/forwarders/story-lifecycle.ts
+var StoryLifecycleForwarder = class extends BaseObserver {
+  startedStories = /* @__PURE__ */ new Set();
+  retryCounts = /* @__PURE__ */ new Map();
+  async onExternalEvent(_source, event) {
+    if (AgentState.is(event)) {
+      this.handleAgentState(event.data);
+      return;
+    }
+    if (StoryResult.is(event)) {
+      this.handleStoryResult(event.data);
+      return;
+    }
+  }
+  handleAgentState(item) {
+    if (item.phase === "running" && !this.startedStories.has(item.agentId)) {
+      this.startedStories.add(item.agentId);
+      emit({ type: "story_start", id: item.agentId, title: item.agentId });
+    }
+    if (item.phase === "waiting" && item.detail?.includes("retrying")) {
+      const count = (this.retryCounts.get(item.agentId) ?? 0) + 1;
+      this.retryCounts.set(item.agentId, count);
+      emit({ type: "story_retry", id: item.agentId, attempt: count });
+    }
+  }
+  handleStoryResult(item) {
+    if (item.success) {
+      emit({
+        type: "story_complete",
+        id: item.storyId,
+        duration_secs: item.durationSecs,
+        files_created: 0,
+        files_modified: 0
+      });
+    } else {
+      emit({
+        type: "story_error",
+        id: item.storyId,
+        error: item.error ?? "unknown error",
+        attempt: item.attempts,
+        max_retries: item.attempts
+      });
+    }
+  }
+};
+
+// ../baro-orchestrator/src/participants/forwarders/token-usage.ts
+var TokenUsageForwarder = class extends BaseObserver {
+  async onExternalEvent(_source, event) {
+    if (AgentResult.is(event)) {
+      this.handleClaudeResult(event.data);
+      return;
+    }
+    if (CodexTurnEvent.is(event)) {
+      this.handleCodexTurnEvent(event.data);
+      return;
+    }
+  }
+  handleClaudeResult(item) {
+    const usage = item.usage;
+    const inputTokens = typeof usage?.input_tokens === "number" ? usage.input_tokens : 0;
+    const outputTokens = typeof usage?.output_tokens === "number" ? usage.output_tokens : 0;
+    emit({
+      type: "token_usage",
+      id: item.agentId,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens
+    });
+  }
+  handleCodexTurnEvent(item) {
+    if (item.phase !== "completed") return;
+    const raw = item.raw;
+    const usage = raw.usage;
+    if (!usage) return;
+    const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+    const outputBase = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+    const reasoning = typeof usage.reasoning_output_tokens === "number" ? usage.reasoning_output_tokens : 0;
+    const outputTokens = outputBase + reasoning;
+    emit({
+      type: "token_usage",
+      id: item.agentId,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens
+    });
+  }
+};
+
+// ../baro-orchestrator/src/participants/forwarders/index.ts
+function joinBaroEventForwarders(env) {
+  const forwarders = [
+    new AgentStreamForwarder(),
+    new StoryLifecycleForwarder(),
+    new TokenUsageForwarder(),
+    new ProgressForwarder(),
+    new CoordinationForwarder(),
+    new FinalizationForwarder()
+  ];
+  for (const f of forwarders) f.join(env);
+}
+
 // ../baro-orchestrator/src/participants/librarian.ts
 var EXPLORATION_TOOLS = /* @__PURE__ */ new Set([
   "Read",
@@ -14456,12 +14658,6 @@ var SurgeonOpenAI = class extends BaseObserver {
   }
 };
 
-// ../baro-orchestrator/src/tui-protocol.ts
-function emit(event) {
-  const line = JSON.stringify(event) + "\n";
-  process.stdout.write(line);
-}
-
 // ../baro-orchestrator/src/orchestrate.ts
 async function orchestrate(config) {
   const env = new AgenticEnvironment();
@@ -14497,7 +14693,7 @@ async function orchestrate(config) {
     for (const p of config.extraParticipants) p.join(env);
   }
   if (emitTui) {
-    new BaroEventForwarder().join(env);
+    joinBaroEventForwarders(env);
   }
   const operator = new Operator(config.operatorHooks ?? {});
   operator.setEnvironment(env);
@@ -14698,198 +14894,6 @@ async function orchestrate(config) {
     storyAgents: /* @__PURE__ */ new Map()
   };
 }
-var BaroEventForwarder = class extends BaseObserver {
-  /** Story IDs that have already received a `story_start`. */
-  startedStories = /* @__PURE__ */ new Set();
-  /** Number of in-flight retry attempts per story (for `story_retry`). */
-  retryCounts = /* @__PURE__ */ new Map();
-  /** Token-usage tally per story (incrementally updated from results). */
-  tokensByStory = /* @__PURE__ */ new Map();
-  async onExternalModelMessage(source, item) {
-    this.handleModelMessage(source, item);
-  }
-  async onExternalFunctionCall(source, item) {
-    this.handleToolCall(source, item);
-  }
-  async onExternalFunctionCallOutput(source, item) {
-    this.handleToolResult(source, item);
-  }
-  async onExternalEvent(_source, event) {
-    if (ConductorState.is(event)) {
-      this.handleConductorState(event.data);
-      return;
-    }
-    if (StoryResult.is(event)) {
-      this.handleStoryResult(event.data);
-      return;
-    }
-    if (AgentResult.is(event)) {
-      this.handleClaudeResult(event.data);
-      return;
-    }
-    if (CodexTurnEvent.is(event)) {
-      this.handleCodexTurnEvent(event.data);
-      return;
-    }
-    if (AgentState.is(event)) {
-      this.handleAgentState(event.data);
-      return;
-    }
-    if (ClaudeSystem.is(event)) {
-      return;
-    }
-    if (Coordination.is(event)) {
-      this.handleCoordination(event.data);
-      return;
-    }
-    if (Critique.is(event)) {
-      this.handleCritique(event.data);
-      return;
-    }
-    if (FinalizeStarted.is(event)) {
-      emit({ type: "finalize_start" });
-      return;
-    }
-    if (PrCreated.is(event)) {
-      emit({ type: "finalize_complete", pr_url: event.data.url });
-      return;
-    }
-  }
-  handleCoordination(item) {
-    emit({
-      type: "story_log",
-      id: item.recipientId,
-      line: `[sentry/${item.kind}] ${item.reason}`
-    });
-  }
-  handleCritique(item) {
-    emit({
-      type: "story_log",
-      id: item.agentId,
-      line: `[critic/${item.verdict}] ${item.reasoning}`
-    });
-  }
-  handleConductorState(item) {
-    if (item.phase === "running_level" && item.currentLevel != null && item.totalLevels != null) {
-      emit({
-        type: "progress",
-        completed: item.currentLevel - 1,
-        total: item.totalLevels,
-        percentage: Math.round(
-          (item.currentLevel - 1) / Math.max(1, item.totalLevels) * 100
-        )
-      });
-    }
-  }
-  handleStoryResult(item) {
-    if (item.success) {
-      emit({
-        type: "story_complete",
-        id: item.storyId,
-        duration_secs: item.durationSecs,
-        files_created: 0,
-        files_modified: 0
-      });
-    } else {
-      emit({
-        type: "story_error",
-        id: item.storyId,
-        error: item.error ?? "unknown error",
-        attempt: item.attempts,
-        max_retries: item.attempts
-      });
-    }
-  }
-  handleClaudeResult(item) {
-    const usage = item.usage;
-    const inputTokens = typeof usage?.input_tokens === "number" ? usage.input_tokens : 0;
-    const outputTokens = typeof usage?.output_tokens === "number" ? usage.output_tokens : 0;
-    const tally = this.tokensByStory.get(item.agentId) ?? { input: 0, output: 0 };
-    tally.input += inputTokens;
-    tally.output += outputTokens;
-    this.tokensByStory.set(item.agentId, tally);
-    emit({
-      type: "token_usage",
-      id: item.agentId,
-      input_tokens: inputTokens,
-      output_tokens: outputTokens
-    });
-  }
-  /**
-   * Codex emits its usage stats inside `turn.completed` envelopes
-   * (shape: `{type:"turn.completed", usage:{input_tokens,
-   * cached_input_tokens, output_tokens, reasoning_output_tokens}}`).
-   * Translate to the same `token_usage` BaroEvent shape Claude uses
-   * so the TUI's existing counter works without backend-specific
-   * branching. `cached_input_tokens` is rolled into `input_tokens`
-   * (Codex reports both — Claude only reports the combined total —
-   * so we surface the same number here for parity). Reasoning
-   * tokens are billed as output tokens by OpenAI so we lump them
-   * with output_tokens.
-   */
-  handleCodexTurnEvent(item) {
-    if (item.phase !== "completed") return;
-    const raw = item.raw;
-    const usage = raw.usage;
-    if (!usage) return;
-    const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
-    const outputBase = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
-    const reasoning = typeof usage.reasoning_output_tokens === "number" ? usage.reasoning_output_tokens : 0;
-    const outputTokens = outputBase + reasoning;
-    const tally = this.tokensByStory.get(item.agentId) ?? {
-      input: 0,
-      output: 0
-    };
-    tally.input += inputTokens;
-    tally.output += outputTokens;
-    this.tokensByStory.set(item.agentId, tally);
-    emit({
-      type: "token_usage",
-      id: item.agentId,
-      input_tokens: inputTokens,
-      output_tokens: outputTokens
-    });
-  }
-  handleAgentState(item) {
-    if (item.phase === "running" && !this.startedStories.has(item.agentId)) {
-      this.startedStories.add(item.agentId);
-      emit({ type: "story_start", id: item.agentId, title: item.agentId });
-    }
-    if (item.phase === "waiting" && item.detail?.includes("retrying")) {
-      const count = (this.retryCounts.get(item.agentId) ?? 0) + 1;
-      this.retryCounts.set(item.agentId, count);
-      emit({ type: "story_retry", id: item.agentId, attempt: count });
-    }
-  }
-  handleModelMessage(source, item) {
-    const agentId = source.agentId;
-    if (typeof agentId !== "string") return;
-    const json = item.toJSON();
-    const text = json.content?.[0]?.text ?? "";
-    if (!text.trim()) return;
-    emitMultiline(agentId, text);
-  }
-  handleToolCall(source, item) {
-    const agentId = source.agentId;
-    if (typeof agentId !== "string") return;
-    emitMultiline(agentId, `[tool_call] ${item.name} ${item.args}`);
-  }
-  handleToolResult(source, item) {
-    const agentId = source.agentId;
-    if (typeof agentId !== "string") return;
-    const json = item.toJSON();
-    const text = json.output?.[0]?.text ?? "";
-    emitMultiline(agentId, `[tool_result ${json.call_id}] ${text}`);
-  }
-};
-function emitMultiline(agentId, text) {
-  if (!text) return;
-  const lines = text.split("\n");
-  for (const line of lines) {
-    if (line.length === 0 && lines.length === 1) continue;
-    emit({ type: "story_log", id: agentId, line });
-  }
-}
 function tokenizeForHints(text) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];