baro-ai 0.70.15 → 0.72.0

package/dist/cli.mjs

@@ -40683,8 +40683,10 @@ var RunStarted = defineSemanticEvent("run_started");
 var LevelComputeRequest = defineSemanticEvent("level_compute_request");
 var LevelStarted = defineSemanticEvent("level_started");
 var LevelCompleted = defineSemanticEvent("level_completed");
+var RecoveryStarted = defineSemanticEvent("recovery_started");
 var StorySpawnRequest = defineSemanticEvent("story_spawn_request");
 var StorySpawned = defineSemanticEvent("story_spawned");
+var StoryRouted = defineSemanticEvent("story_routed");
 var FinalizeStarted = defineSemanticEvent("finalize_started");
 var PrCreated = defineSemanticEvent("pr_created");
 var RunCompleted = defineSemanticEvent("run_completed");
@@ -40942,6 +40944,8 @@ var Conductor = class extends BaseObserver {
    */
   recoveryAttempts = /* @__PURE__ */ new Map();
   maxRecoveryAttemptsPerStory = 1;
+  /** Recovery levels started in this run (1-based `attempt` for RecoveryStarted). */
+  recoveryLevelsStarted = 0;
   totalAttempts = 0;
   appliedReplans = 0;
   currentLevel = null;
@@ -41412,6 +41416,13 @@ ${prompt}`;
       failed: [],
       perStoryAttempts: /* @__PURE__ */ new Map()
     };
+    this.recoveryLevelsStarted += 1;
+    this.emit(
+      RecoveryStarted.create({
+        attempt: this.recoveryLevelsStarted,
+        storyIds: this.currentLevel.storyIds
+      })
+    );
     this.emit(
       LevelStarted.create({
         ordinal,
@@ -43201,10 +43212,35 @@ function matchCommit(story, commits) {
 }
 
 // ../baro-orchestrator/src/tui-protocol.ts
+import { stdin } from "process";
+import { createInterface } from "readline";
 function emit(event) {
   const line = JSON.stringify(event) + "\n";
   process.stdout.write(line);
 }
+function subscribeCommands(handler) {
+  const rl = createInterface({ input: stdin });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let cmd;
+    try {
+      cmd = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (!cmd || typeof cmd !== "object" || typeof cmd.type !== "string") {
+      return;
+    }
+    Promise.resolve(handler(cmd)).catch((err) => {
+      process.stderr.write(
+        `[tui-protocol] command handler error: ${err?.message ?? String(err)}
+`
+      );
+    });
+  });
+  return () => rl.close();
+}
 
 // ../baro-orchestrator/src/participants/git-coordinator.ts
 var GitCoordinator = class extends BaseObserver {
@@ -43423,6 +43459,13 @@ var CoordinationForwarder = class extends BaseObserver {
     }
   }
   handleIntervention(item) {
+    emit({
+      type: "intervention",
+      id: item.storyId,
+      source: item.source,
+      action: item.action,
+      reason: item.reason
+    });
     emit({
       type: "story_log",
       id: item.storyId,
@@ -43443,6 +43486,13 @@ var CoordinationForwarder = class extends BaseObserver {
     });
   }
   handleCritique(item) {
+    emit({
+      type: "critique",
+      id: item.agentId,
+      verdict: item.verdict,
+      reasoning: item.reasoning,
+      violated: [...item.violatedCriteria]
+    });
     emit({
       type: "story_log",
       id: item.agentId,
@@ -43451,6 +43501,67 @@ var CoordinationForwarder = class extends BaseObserver {
   }
 };
 
+// ../baro-orchestrator/src/participants/forwarders/dag.ts
+var DagForwarder = class extends BaseObserver {
+  async onExternalEvent(_source, event) {
+    if (Replan.is(event)) {
+      this.handleReplan(event.data);
+      return;
+    }
+    if (LevelStarted.is(event)) {
+      this.handleLevelStarted(event.data);
+      return;
+    }
+    if (LevelCompleted.is(event)) {
+      this.handleLevelCompleted(event.data);
+      return;
+    }
+    if (RecoveryStarted.is(event)) {
+      this.handleRecoveryStarted(event.data);
+      return;
+    }
+  }
+  handleReplan(item) {
+    emit({
+      type: "replan",
+      source: item.source,
+      reason: item.reason,
+      added: item.addedStories.map((s2) => ({
+        id: s2.id,
+        title: s2.title,
+        depends_on: [...s2.dependsOn]
+      })),
+      removed: [...item.removedStoryIds],
+      rewired: Object.entries(item.modifiedDeps).map(([id, deps]) => ({
+        id,
+        depends_on: [...deps]
+      }))
+    });
+  }
+  handleLevelStarted(item) {
+    emit({
+      type: "level_started",
+      ordinal: item.ordinal,
+      story_ids: [...item.storyIds]
+    });
+  }
+  handleLevelCompleted(item) {
+    emit({
+      type: "level_completed",
+      ordinal: item.ordinal,
+      passed: [...item.passed],
+      failed: [...item.failed]
+    });
+  }
+  handleRecoveryStarted(item) {
+    emit({
+      type: "recovery_started",
+      attempt: item.attempt,
+      story_ids: [...item.storyIds]
+    });
+  }
+};
+
 // ../baro-orchestrator/src/participants/forwarders/finalization.ts
 var FinalizationForwarder = class extends BaseObserver {
   async onExternalEvent(_source, event) {
@@ -43550,6 +43661,31 @@ var StoryLifecycleForwarder = class extends BaseObserver {
       this.handleStoryResult(event.data);
       return;
     }
+    if (StoryRouted.is(event)) {
+      emit({
+        type: "routed",
+        id: event.data.storyId,
+        backend: event.data.backend,
+        model: event.data.model
+      });
+      return;
+    }
+    if (StoryMerged.is(event)) {
+      emit({
+        type: "story_merged",
+        id: event.data.storyId,
+        mode: event.data.mode
+      });
+      return;
+    }
+    if (StoryMergeFailed.is(event)) {
+      emit({
+        type: "merge_failed",
+        id: event.data.storyId,
+        error: event.data.error
+      });
+      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
@@ -43721,6 +43857,7 @@ function joinBaroEventForwarders(env) {
     new TokenUsageForwarder(),
     new ProgressForwarder(),
     new CoordinationForwarder(),
+    new DagForwarder(),
     new FinalizationForwarder()
   ];
   for (const f3 of forwarders) f3.join(env);
@@ -44241,7 +44378,7 @@ var Operator = class extends BaseObserver {
           AgentTargetedMessage.create({
             recipientId: cmd.storyId,
             text: cmd.message,
-            metadata: { source: "operator" }
+            metadata: { source: cmd.source ?? "operator" }
           })
         );
         return;
@@ -47739,6 +47876,14 @@ var StoryFactory = class extends BaseObserver {
     process.stderr.write(
       `[story-factory] ${req.storyId} \u2192 ${formatRoute(route)}` + (req.model ? ` (model="${req.model}")` : "") + "\n"
     );
+    this.envRef.deliverSemanticEvent(
+      this,
+      StoryRouted.create({
+        storyId: req.storyId,
+        backend: route.backend,
+        model: route.model ?? "default"
+      })
+    );
     const storyCwd = this.opts.worktrees ? await this.opts.worktrees.create(req.storyId) ?? this.opts.cwd : this.opts.cwd;
     const exec3 = this.executor.start(req, route, storyCwd, this.envRef, {
       openaiModel: this.opts.openaiModel,
@@ -48594,6 +48739,7 @@ async function orchestrate(config) {
   const operator = new Operator(config.operatorHooks ?? {});
   operator.setEnvironment(env);
   operator.join(env);
+  config.onOperatorReady?.(operator);
   const useGit = config.withGit ?? await isInsideGitRepo(config.cwd);
   const gitGate = new GitGate();
   let baseSha = null;
@@ -48910,6 +49056,17 @@ function tokenizeForHints(text) {
   return out;
 }
 
+// ../baro-orchestrator/src/stdin-commands.ts
+function handleStdinCommand(cmd, ctx) {
+  if (cmd.type !== "agent_message") return;
+  const { id, text } = cmd;
+  if (typeof id !== "string" || !id || typeof text !== "string" || !text.trim()) return;
+  const operator = ctx.getOperator();
+  if (!operator) return;
+  operator.dispatch({ kind: "redirect", storyId: id, message: text, source: "user" });
+  (ctx.emitEvent ?? emit)({ type: "story_log", id, line: `[you \u2192 ${id}] ${text}` });
+}
+
 // ../baro-orchestrator/scripts/cli.ts
 function parseArgs2(argv) {
   const args = {
@@ -49167,9 +49324,16 @@ async function main() {
 `);
     process.exit(2);
   }
+  let operatorRef = null;
+  subscribeCommands((cmd) => {
+    handleStdinCommand(cmd, { getOperator: () => operatorRef });
+  });
   const config = {
     prdPath,
     cwd,
+    onOperatorReady: (operator) => {
+      operatorRef = operator;
+    },
     parallel: args.parallel,
     timeoutSecs: args.timeout,
     overrideModel: args.model ?? null,