baro-ai 0.23.3 → 0.23.5

package/dist/cli.mjs

@@ -9342,7 +9342,14 @@ var Finalizer = class extends Participant {
   startedAtMs = null;
   baseSha;
   branchName = null;
-  levels = [];
+  /**
+   * DAG levels keyed by their ordinal as emitted in
+   * LevelStartedItem. We use a Map rather than an array because
+   * Conductor's ordinals are 1-based and would otherwise leave a
+   * `levels[0] = undefined` hole that crashes any `for...of`
+   * iteration (it walks holes too).
+   */
+  levels = /* @__PURE__ */ new Map();
   stories = /* @__PURE__ */ new Map();
   /**
    * Resolves once finalize() has completed (or been short-circuited).
@@ -9374,7 +9381,7 @@ var Finalizer = class extends Participant {
       return;
     }
     if (item instanceof LevelStartedItem) {
-      this.levels[item.ordinal] = [...item.storyIds];
+      this.levels.set(item.ordinal, [...item.storyIds]);
       for (const id of item.storyIds) {
         if (!this.stories.has(id)) {
           this.stories.set(id, {
@@ -9408,11 +9415,22 @@ var Finalizer = class extends Participant {
       return;
     }
     if (item instanceof RunCompletedItem) {
-      this.finalizePromise = this.finalize(item);
+      this.finalizePromise = this.safeFinalize(item);
       await this.finalizePromise;
       return;
     }
   }
+  async safeFinalize(item) {
+    try {
+      await this.finalize(item);
+    } catch (e) {
+      const msg = e?.stack ?? String(e);
+      this.log(`[finalizer] internal error, skipping PR: ${msg.split("\n")[0]}`);
+      process.stderr.write(`[finalizer] crash: ${msg}
+`);
+      this.emit(new PrCreatedItem(null, this.branchName ?? "", ""));
+    }
+  }
   /**
    * Resolves once Finalizer has finished handling RunCompletedItem
    * (PR opened, skipped, or failed). Resolves immediately if no run
@@ -9502,14 +9520,17 @@ var Finalizer = class extends Participant {
   // ─── Story ordering & partitioning ──────────────────────────────
   /**
    * Stories returned in DAG order so the table reads top-down the same
-   * way the run executed: level 0 first, then level 1, etc. Within a
-   * level we sort by id (stable) to keep the table deterministic.
+   * way the run executed: lowest-ordinal level first. Within a level
+   * we sort by id (stable) to keep the table deterministic.
    */
   orderStories() {
     const seen = /* @__PURE__ */ new Set();
     const ordered = [];
-    for (const lvl of this.levels) {
-      const sorted = [...lvl].sort();
+    const ordinals = [...this.levels.keys()].sort((a, b) => a - b);
+    for (const ord of ordinals) {
+      const ids = this.levels.get(ord);
+      if (!ids) continue;
+      const sorted = [...ids].sort();
       for (const id of sorted) {
         const rec = this.stories.get(id);
         if (rec && !seen.has(id)) {
@@ -9632,13 +9653,14 @@ var Finalizer = class extends Participant {
       lines.push(prd.description.trim());
       lines.push("");
     }
-    if (this.levels.length > 0) {
+    if (this.levels.size > 0) {
       lines.push("## Plan");
       lines.push("");
       lines.push("```");
-      for (let i = 0; i < this.levels.length; i++) {
-        const ids = this.levels[i];
-        lines.push(`Level ${i} \u2500\u2500\u2500 ${ids.join(", ")}`);
+      const ordinals = [...this.levels.keys()].sort((a, b) => a - b);
+      for (const ord of ordinals) {
+        const ids = this.levels.get(ord) ?? [];
+        lines.push(`Level ${ord} \u2500\u2500\u2500 ${ids.join(", ")}`);
       }
       lines.push("```");
       lines.push("");