baro-ai 0.70.2 → 0.70.4

package/dist/cli.mjs

@@ -47631,7 +47631,10 @@ var LocalStoryExecutor = class {
     });
     agent.join(env);
     void agent.run(env);
-    return { dispose: (e2) => agent.leave(e2) };
+    return {
+      dispose: (e2) => agent.leave(e2),
+      abort: () => agent.abort?.()
+    };
   }
 };
 
@@ -47664,6 +47667,18 @@ var StoryFactory = class extends BaseObserver {
       }
     }
   }
+  /**
+   * Abort a running story mid-flight (the Supervisor calls this on a detected
+   * stall). The agent settles with a failed StoryResult, which the Surgeon
+   * then reacts to (split/escalate). Returns false if the story isn't active
+   * or its executor doesn't support abort.
+   */
+  abort(storyId) {
+    const exec3 = this.active.get(storyId);
+    if (!exec3?.abort) return false;
+    exec3.abort();
+    return true;
+  }
   async spawn(req) {
     if (!this.envRef) return;
     if (this.active.has(req.storyId) || this.spawning.has(req.storyId)) return;
@@ -48281,6 +48296,87 @@ ${userPrompt}`;
   }
 };
 
+// ../baro-orchestrator/src/participants/supervisor.ts
+var WRITE_TOOLS2 = /* @__PURE__ */ new Set([
+  "write_file",
+  "edit_file",
+  "edit",
+  "create_file",
+  "apply_patch",
+  "str_replace",
+  "str_replace_editor",
+  "str_replace_based_edit_tool",
+  "multi_edit",
+  "write",
+  "patch"
+]);
+var Supervisor = class extends BaseObserver {
+  opts;
+  stories = /* @__PURE__ */ new Map();
+  interventions = 0;
+  constructor(opts) {
+    super();
+    this.opts = {
+      onStall: opts.onStall,
+      noProgressToolCalls: opts.noProgressToolCalls ?? 50,
+      repeatThreshold: opts.repeatThreshold ?? 6,
+      softCapMs: opts.softCapMs ?? 12 * 6e4,
+      maxInterventions: opts.maxInterventions ?? 25,
+      now: opts.now ?? (() => Date.now())
+    };
+  }
+  async onExternalFunctionCall(source, item) {
+    const id = source.agentId;
+    if (typeof id !== "string") return;
+    const st = this.ensure(id);
+    if (st.intervened) return;
+    st.toolCalls += 1;
+    if (WRITE_TOOLS2.has(item.name)) {
+      st.fileChanges += 1;
+      st.sinceLastChange = 0;
+    } else {
+      st.sinceLastChange += 1;
+    }
+    const sig = `${item.name}:${String(item.args ?? "").slice(0, 160)}`;
+    const repeats = (st.sigCounts.get(sig) ?? 0) + 1;
+    st.sigCounts.set(sig, repeats);
+    if (this.interventions >= this.opts.maxInterventions) return;
+    const reason = this.stallReason(st, repeats);
+    if (!reason) return;
+    st.intervened = true;
+    this.interventions += 1;
+    this.opts.onStall(id, `supervisor: ${reason}`);
+  }
+  stallReason(st, repeats) {
+    if (st.sinceLastChange >= this.opts.noProgressToolCalls) {
+      return `${st.sinceLastChange} tool calls with no file change \u2014 exploring, not converging`;
+    }
+    if (repeats >= this.opts.repeatThreshold) {
+      return `same tool call repeated ${repeats}\xD7 \u2014 stuck in a loop`;
+    }
+    const elapsed = this.opts.now() - st.startedAt;
+    if (elapsed >= this.opts.softCapMs && st.fileChanges === 0) {
+      return `${Math.round(elapsed / 6e4)} min elapsed with zero file changes`;
+    }
+    return null;
+  }
+  ensure(id) {
+    let st = this.stories.get(id);
+    if (!st) {
+      st = {
+        startedAt: this.opts.now(),
+        toolCalls: 0,
+        fileChanges: 0,
+        sinceLastChange: 0,
+        sigCounts: /* @__PURE__ */ new Map(),
+        intervened: false
+      };
+      this.stories.set(id, st);
+    }
+    return st;
+  }
+};
+
 // ../baro-orchestrator/src/orchestrate.ts
 function storyTimeoutSecs(configured, effort) {
   if (typeof configured === "number" && configured > 0) return configured;
@@ -48623,6 +48719,17 @@ async function orchestrate(config) {
   });
   storyFactory.setEnvironment(env);
   storyFactory.join(env);
+  if (config.withSupervisor) {
+    const supervisor = new Supervisor({
+      onStall: (storyId, reason) => {
+        const aborted = storyFactory.abort(storyId);
+        if (aborted && emitTui) {
+          emit({ type: "story_log", id: storyId, line: `\u26A0 ${reason} \u2014 aborting so it can be split/escalated` });
+        }
+      }
+    });
+    supervisor.join(env);
+  }
   if (emitTui) {
     const prd = loadPrd(config.prdPath);
     emit({
@@ -48728,8 +48835,12 @@ function parseArgs2(argv) {
     noLibrarian: false,
     noMemory: false,
     noSentry: false,
-    withSurgeon: false,
-    surgeonUseLlm: false,
+    // Self-healing on by default: the Supervisor catches a stuck story early
+    // and the Surgeon splits/escalates it, instead of failing the whole run.
+    // Disable with --no-surgeon / --no-supervisor.
+    withSurgeon: true,
+    surgeonUseLlm: true,
+    withSupervisor: true,
     endpointSpecs: [],
     llm: "claude",
     help: false
@@ -48789,6 +48900,15 @@ function parseArgs2(argv) {
       case "--surgeon-use-llm":
         args.surgeonUseLlm = true;
         break;
+      case "--no-surgeon":
+        args.withSurgeon = false;
+        break;
+      case "--no-supervisor":
+        args.withSupervisor = false;
+        break;
+      case "--with-supervisor":
+        args.withSupervisor = true;
+        break;
       case "--surgeon-model":
         args.surgeonModel = required(argv, ++i2, "--surgeon-model");
         break;
@@ -48975,6 +49095,7 @@ async function main() {
     withSentry: args.noSentry ? false : void 0,
     withSurgeon: args.withSurgeon,
     surgeonUseLlm: args.surgeonUseLlm,
+    withSupervisor: args.withSupervisor,
     surgeonModel: args.surgeonModel,
     intraLevelDelaySecs: args.intraLevelDelaySecs,
     llm: args.llm,