baro-ai 0.47.5 → 0.47.7

package/dist/cli.mjs

@@ -39754,6 +39754,13 @@ var Conductor = class extends BaseObserver {
    * is true only when this list is empty.
    */
   globalDropped = [];
+  /**
+   * Extra end-of-run recovery attempts, separate from each StoryAgent's own
+   * retry loop. A story may exhaust its normal attempts, block the DAG, and
+   * still be recoverable after sibling stories have landed more context/code.
+   */
+  recoveryAttempts = /* @__PURE__ */ new Map();
+  maxRecoveryAttemptsPerStory = 1;
   totalAttempts = 0;
   appliedReplans = 0;
   currentLevel = null;
@@ -39860,10 +39867,23 @@ var Conductor = class extends BaseObserver {
   async handleLevelCompute() {
     if (this.phase !== "computing") return;
     if (!this.prd) return;
-    const levels = buildDag(this.prd.userStories, { onlyIncomplete: true });
+    const blockedStoryIds = this.computeBlockedStoryIds();
+    const failedIds = new Set(this.globalFailed);
+    const runnableStories = this.prd.userStories.filter(
+      (s2) => !s2.passes && !failedIds.has(s2.id) && !blockedStoryIds.has(s2.id)
+    );
+    const levels = buildDag(runnableStories);
     if (levels.length === 0) {
       const allPassed = this.prd.userStories.every((s2) => s2.passes) && this.globalDropped.length === 0;
-      this.terminateRun(allPassed, null);
+      if (!allPassed && this.globalFailed.length > 0) {
+        const recovered = await this.tryStartRecoveryLevel(
+          this.globalFailed,
+          blockedStoryIds.size > 0 ? `blocked dependencies: ${[...blockedStoryIds].join(", ")}` : "terminal failed stories"
+        );
+        if (recovered) return;
+      }
+      const abortReason = allPassed ? null : this.globalFailed.length > 0 ? blockedStoryIds.size > 0 ? `blocked by failed dependencies: failed ${this.globalFailed.join(", ")}; blocked ${[...blockedStoryIds].join(", ")}` : `stories failed: ${this.globalFailed.join(", ")}` : null;
+      this.terminateRun(allPassed, abortReason);
       return;
     }
     const level = levels[0];
@@ -39913,6 +39933,7 @@ var Conductor = class extends BaseObserver {
     if (item.success) {
       this.currentLevel.passed.push(item.storyId);
       this.globalCompleted.push(item.storyId);
+      this.removeGlobalFailed(item.storyId);
       if (this.prd) {
         this.prd = markStoryPassed(this.prd, item.storyId, item.durationSecs);
         savePrd(this.opts.prdPath, this.prd);
@@ -39933,7 +39954,7 @@ var Conductor = class extends BaseObserver {
       }
     } else {
       this.currentLevel.failed.push(item.storyId);
-      this.globalFailed.push(item.storyId);
+      this.addGlobalFailed(item.storyId);
     }
     await this.fillSpawnSlots();
     if (this.currentLevel.pending.size === 0) {
@@ -40017,6 +40038,16 @@ ${prompt}`;
     if (this.pendingReplans.length > 0 && this.prd) {
       const drained = this.pendingReplans.splice(0);
       for (const replan of drained) {
+        if (replan.removedStoryIds.length > 0 && replan.addedStories.length === 0) {
+          this.emit(
+            ConductorState.create({
+              phase: "running_level",
+              detail: `skip proposal deferred (source=${replan.source}, -${replan.removedStoryIds.length}): ${replan.reason}`,
+              currentLevel: lvl.ordinal
+            })
+          );
+          continue;
+        }
         this.prd = applyReplan(this.prd, replan);
         this.appliedReplans += 1;
         replannedThisLevel = true;
@@ -40049,6 +40080,11 @@ ${prompt}`;
     const anySuccess = lvl.passed.length > 0;
     const totalThisLevel = lvl.passed.length + lvl.failed.length;
     if (!anySuccess && totalThisLevel > 0 && !replannedThisLevel) {
+      const recovered = await this.tryStartRecoveryLevel(
+        lvl.failed,
+        "all stories in level failed"
+      );
+      if (recovered) return;
       this.terminateRun(
         false,
         "all stories in level failed; aborting remaining levels"
@@ -40094,6 +40130,99 @@ ${prompt}`;
     }
     this.resolveDone(summary);
   }
+  /**
+   * Stories whose dependency chain includes a terminally failed story cannot
+   * become runnable in this run. Keep them out of the remaining DAG so
+   * `buildDag` cannot silently promote them after the failed dependency is
+   * filtered out. Do NOT mark them passed/dropped here: this is a checkpoint,
+   * and the user may choose to rerun the failed prerequisite on resume.
+   */
+  computeBlockedStoryIds() {
+    if (!this.prd || this.globalFailed.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    const failed = new Set(this.globalFailed);
+    const blocked = /* @__PURE__ */ new Set();
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const story of this.prd.userStories) {
+        if (story.passes || failed.has(story.id) || blocked.has(story.id)) {
+          continue;
+        }
+        if ((story.dependsOn ?? []).some((id) => failed.has(id) || blocked.has(id))) {
+          blocked.add(story.id);
+          changed = true;
+        }
+      }
+    }
+    return blocked;
+  }
+  addGlobalFailed(storyId) {
+    if (!this.globalFailed.includes(storyId)) {
+      this.globalFailed.push(storyId);
+    }
+  }
+  removeGlobalFailed(storyId) {
+    for (let i2 = this.globalFailed.length - 1; i2 >= 0; i2--) {
+      if (this.globalFailed[i2] === storyId) {
+        this.globalFailed.splice(i2, 1);
+      }
+    }
+  }
+  async tryStartRecoveryLevel(candidateIds, reason) {
+    if (!this.prd) return false;
+    const seen = /* @__PURE__ */ new Set();
+    const stories = [];
+    for (const id of candidateIds) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const attempts = this.recoveryAttempts.get(id) ?? 0;
+      if (attempts >= this.maxRecoveryAttemptsPerStory) continue;
+      const story = this.prd.userStories.find((s2) => s2.id === id);
+      if (!story || story.passes) continue;
+      stories.push(story);
+    }
+    if (stories.length === 0) return false;
+    for (const story of stories) {
+      this.recoveryAttempts.set(
+        story.id,
+        (this.recoveryAttempts.get(story.id) ?? 0) + 1
+      );
+      this.removeGlobalFailed(story.id);
+    }
+    const ordinal = (this.currentLevel?.ordinal ?? 0) + 1;
+    const totalLevelsHint = ordinal;
+    this.currentLevel = {
+      ordinal,
+      totalLevelsHint,
+      storyIds: stories.map((s2) => s2.id),
+      pending: new Set(stories.map((s2) => s2.id)),
+      passed: [],
+      failed: [],
+      perStoryAttempts: /* @__PURE__ */ new Map()
+    };
+    this.emit(
+      LevelStarted.create({
+        ordinal,
+        totalLevelsHint,
+        storyIds: this.currentLevel.storyIds
+      })
+    );
+    this.emit(
+      ConductorState.create({
+        phase: "running_level",
+        detail: `auto-recovery retry for ${this.currentLevel.storyIds.join(", ")} (${reason})`,
+        currentLevel: ordinal,
+        totalLevels: totalLevelsHint,
+        storyIds: this.currentLevel.storyIds
+      })
+    );
+    this.phase = "running";
+    this.spawnQueue.push(...stories);
+    await this.fillSpawnSlots();
+    return true;
+  }
   resolvePrompt(story) {
     const candidatePath = this.opts.promptTemplatePath ?? join(this.opts.cwd, "prompt.md");
     let prompt;
@@ -40920,8 +41049,10 @@ var Finalizer = class extends BaseObserver {
   }
   async finalize(run) {
     if (!this.opts.createPr) return;
-    if (!run.success && run.completedStories.length === 0) {
-      this.log("[finalizer] run failed before producing any commits; skipping PR");
+    if (!run.success) {
+      this.log(
+        `[finalizer] run did not complete successfully (${run.abortReason ?? "no reason"}); skipping PR`
+      );
       this.emit(
         PrCreated.create({
           url: null,