baro-ai 0.44.1 → 0.45.0

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 = [];