baro-ai 0.86.0 → 0.87.0

package/dist/cli.mjs

@@ -74788,6 +74788,86 @@ function extractPath2(item) {
   return null;
 }
 
+// ../baro-orchestrator/src/harness/cooperative-suspension.ts
+function laneQuiescenceWitness(backend) {
+  return backend === "openai" ? "self" : "process";
+}
+var CooperativeSuspension = class {
+  constructor(storyId, quiesce, timeoutMs) {
+    this.storyId = storyId;
+    this.quiesce = quiesce;
+    this.timeoutMs = timeoutMs;
+  }
+  blockId = null;
+  /** The accepted block this story is suspending for, if any. */
+  get acceptedBlockId() {
+    return this.blockId;
+  }
+  /** True once no further work may begin, which is what makes a witness one. */
+  get blocksNewWork() {
+    return this.blockId !== null;
+  }
+  /** How a settled suspension reads in the story's outcome. */
+  get outcomeText() {
+    return `suspended on dependency block ${this.blockId}`;
+  }
+  /**
+   * Record the request and wait for the lane's witness. Throws rather than
+   * returning a summary the host would read as a certificate: a refusal
+   * costs a retained worktree, a false certificate costs a silent write into
+   * a branch already snapshotted.
+   */
+  async request(blockId, summary) {
+    this.record(blockId);
+    if (!await this.quiesce(this.timeoutMs)) {
+      throw new Error(
+        `story ${this.storyId} quiescence could not be certified for dependency block ${blockId}`
+      );
+    }
+    return summary();
+  }
+  record(blockId) {
+    if (typeof blockId !== "string" || blockId.trim() !== blockId || !blockId) {
+      throw new TypeError(
+        "suspension blockId must be a non-empty trimmed string"
+      );
+    }
+    if (this.blockId !== null && this.blockId !== blockId) {
+      throw new Error(
+        `story ${this.storyId} is already suspending for block ${this.blockId}`
+      );
+    }
+    this.blockId ??= blockId;
+  }
+};
+async function settledWithinBound(inFlight, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  const awaited = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const pending = inFlight().filter((entry) => !awaited.has(entry));
+    if (pending.length === 0) return true;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return false;
+    if (!await raceBound(Promise.allSettled(pending), remaining)) {
+      return false;
+    }
+    for (const entry of pending) awaited.add(entry);
+  }
+}
+async function raceBound(work, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      work.then(() => true),
+      new Promise((resolve9) => {
+        timer = setTimeout(() => resolve9(false), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 // ../baro-orchestrator/src/harness/codex/stream-mapper.ts
 function mapCodexEvent(agentId, event) {
   const threadId = typeof event.thread_id === "string" ? event.thread_id : null;
@@ -75092,6 +75172,18 @@ var TurnMessageMailbox = class {
     this.queued.push(item);
     if (this.active) this.active(this.queued.shift());
   }
+  /**
+   * Everything waiting, without blocking for more. A backend that owns its
+   * own turn loop reads peer messages between inference rounds rather than
+   * only at the turn boundary, which is where `waitForNext` leaves them.
+   */
+  drainAll() {
+    return this.queued.splice(0, this.queued.length);
+  }
+  /** End an active wait now — a suspension must not sit out the quiet timeout. */
+  cancel() {
+    this.active?.(null);
+  }
   waitForNext(options) {
     if (this.queued.length > 0) return Promise.resolve(this.queued.shift());
     if (this.active) throw new Error("already waiting for the next turn message");
@@ -77678,6 +77770,20 @@ var OpenAIStoryAgent = class extends BaseObserver {
   done;
   turnMessages = new TurnMessageMailbox();
   turnReviews = new TurnReviewMailbox();
+  /**
+   * Tool invocations that have started and not yet settled.
+   *
+   * A CLI backend gets its quiescence proof from the operating system: the
+   * process is gone, so nothing of its can still be writing. In process
+   * there is no such witness, and aborting does not make one — the abort
+   * wins its race while the write it interrupted carries on. Owning the
+   * loop supplies a better witness than the process table ever did: no
+   * invocation can start once a suspension is requested, so an empty set is
+   * proof rather than inference.
+   */
+  inFlightTools = /* @__PURE__ */ new Set();
+  suspension;
+  attemptsMade = 0;
   constructor(spec, opts = {}) {
     super();
     this.spec = {
@@ -77708,6 +77814,10 @@ var OpenAIStoryAgent = class extends BaseObserver {
         0,
         Math.floor(opts.transportRetryDelayMs ?? 1e3)
       ),
+      suspensionQuiescenceTimeoutMs: Math.max(
+        0,
+        Math.floor(opts.suspensionQuiescenceTimeoutMs ?? 3e4)
+      ),
       baseUrl: opts.baseUrl ?? "",
       apiKey: opts.apiKey ?? "",
       runtimeReplanDecisionAuthority: opts.runtimeReplanDecisionAuthority ?? null,
@@ -77731,6 +77841,11 @@ var OpenAIStoryAgent = class extends BaseObserver {
       ...this.runtimeReplanEnabled() ? [createRuntimeReplanTool(this.runtimeGraphVersion)] : []
     ];
     setModelTools(this.model, this.tools);
+    this.suspension = new CooperativeSuspension(
+      this.spec.id,
+      (timeoutMs) => settledWithinBound(() => [...this.inFlightTools], timeoutMs),
+      this.opts.suspensionQuiescenceTimeoutMs
+    );
     this.done = new Promise((res) => {
       this.resolveDone = res;
     });
@@ -77800,6 +77915,7 @@ var OpenAIStoryAgent = class extends BaseObserver {
     }, this.spec.hardTimeoutSecs * 1e3) : null;
     for (let i2 = 0; i2 < maxAttempts; i2++) {
       if (this.abortController.signal.aborted) break;
+      if (this.suspension.blocksNewWork) break;
       if (i2 > 0) {
         this.transition("waiting", `retrying (attempt ${i2 + 1}/${maxAttempts})`);
         try {
@@ -77810,6 +77926,7 @@ var OpenAIStoryAgent = class extends BaseObserver {
         if (this.abortController.signal.aborted) break;
       }
       attempts += 1;
+      this.attemptsMade = attempts;
       try {
         const result = await this.runOneAttempt(attempts);
         if (this.currentPhase === "done") {
@@ -77833,6 +77950,11 @@ var OpenAIStoryAgent = class extends BaseObserver {
       lastError = this.abortReason ?? "story was aborted";
       lastFailure ??= this.abortFailure;
     }
+    if (this.suspension.blocksNewWork) {
+      lastError = this.suspension.outcomeText;
+      lastFailure = void 0;
+      this.transition("aborted", lastError);
+    }
     const durationSecs = this.startedAt ? Math.round((Date.now() - this.startedAt) / 1e3) : 0;
     const success = this.currentPhase === "done";
     this.envRef?.deliverSemanticEvent(
@@ -78172,6 +78294,16 @@ var OpenAIStoryAgent = class extends BaseObserver {
         }
         context = context.addContextItem(outItem);
       }
+      if (this.suspension.blocksNewWork) {
+        return {
+          context,
+          success: false,
+          assistantText,
+          usage,
+          error: this.suspension.outcomeText,
+          retryable: false
+        };
+      }
       if (controlPlaneOutcomeUnknown || this.abortController.signal.aborted) {
         return {
           context,
@@ -78286,7 +78418,36 @@ var OpenAIStoryAgent = class extends BaseObserver {
   }
   async runOrdinaryTool(call) {
     const tool = this.tools.find((candidate) => candidate.name === call.name);
-    return tool ? runToolSafely(tool, call.args, this.abortController.signal) : `Error: tool '${call.name}' not registered`;
+    if (!tool) return `Error: tool '${call.name}' not registered`;
+    if (this.suspension.blocksNewWork) return this.suspendedToolOutput();
+    const invocation = runToolSafely(
+      tool,
+      call.args,
+      this.abortController.signal
+    );
+    this.inFlightTools.add(invocation);
+    const settled = () => {
+      this.inFlightTools.delete(invocation);
+    };
+    invocation.then(settled, settled);
+    return invocation;
+  }
+  suspendedToolOutput() {
+    return "Error: this story is suspending on an accepted dependency block; no further tool calls will run in this session.";
+  }
+  /**
+   * Stop taking work and resolve only once nothing of this story's can still
+   * write, so the host may snapshot the worktree. Inference is left to end
+   * on its own bound — a model call touches no files, and killing it would
+   * buy nothing the witness does not already give.
+   */
+  async suspend(blockId) {
+    const pending = this.suspension.request(blockId, () => ({
+      attempts: this.attemptsMade,
+      durationSecs: this.startedAt ? Math.round((Date.now() - this.startedAt) / 1e3) : 0
+    }));
+    if (this.suspension.blocksNewWork) this.turnMessages.cancel();
+    return pending;
   }
   async proposeRuntimeReplan(call) {
     const parsed = parseRuntimeReplanArgs(call.args);
@@ -79652,7 +79813,7 @@ function failureSummary2(failure) {
 // ../baro-orchestrator/src/execution/story-executor.ts
 var LocalStoryExecutor = class {
   supportsCooperativeSuspend(route) {
-    return route.backend !== "openai" && PROCESS_TREE_CAPABILITIES.cooperativeQuiescenceObservation;
+    return laneQuiescenceWitness(route.backend) === "self" ? true : PROCESS_TREE_CAPABILITIES.cooperativeQuiescenceObservation;
   }
   start(req, route, cwd, env, opts) {
     if (opts.requireProcessQuiescenceCertification === true && route.backend !== "openai" && !PROCESS_TREE_CAPABILITIES.cooperativeQuiescenceObservation) {
@@ -82954,7 +83115,7 @@ var ContinuousGateRunner = class extends BaseObserver {
     if (result.commands.some((command) => wasKilled(command))) {
       throw new Error("a gate command was killed before it reported");
     }
-    return result.commands.map((command) => ({
+    return result.commands.filter((command) => command.status !== "skipped").map((command) => ({
       label: command.command,
       passed: command.status === "passed",
       detail: command.status === "passed" ? "" : command.tail ?? ""