Merge pull request #116 from eduralph/fix/105-batch-iterate-plan-stall

fix(flow): keep the batch sweep alive across an iterate-plan re-open

Author: eduralph

template/src/pdca_harness/flow.py

@@ -390,6 +390,7 @@ def _drive_and_act(
         # Each bundle is isolated — one that raises (a leaf left it half-written) is
         # skipped this pass, never crashing the sweep and losing the others' progress.
         # Serial by default; fans out across cfg.lanes lanes when configured (docs 09).
+        before = [state.state(d) for d in bundles]
         _build_all(cfg, bundles)
         # Sign-off, cheap-first, restricted to this batch. ONE interactive session
         # per chunk (≤ SIGNOFF_BATCH_SIZE) walks several bundles — like batch Plan —
@@ -398,7 +399,14 @@ def _drive_and_act(
         # build-all above applies all the iterations together.
         pending = [e.bundle for e in queue.awaiting_signoff(cfg) if e.bundle.name in names]
         if not pending:
-            break
+            # Break only when the band made NO progress this pass. iterate-plan archives
+            # a bundle back to UNPLANNED — a HALTED state that needs the Plan pre-pass on a
+            # LATER pass; on the pass where that archive happens nothing is awaiting
+            # sign-off, so a bare `break` stranded it at UNPLANNED (#105). A state change
+            # means progress (the re-open) — loop again so the next pass re-plans + rebuilds.
+            if [state.state(d) for d in bundles] == before:
+                break       # genuinely stuck (all terminal / planner declined an UNPLANNED)
+            continue        # progress — give the re-opened bundle its Plan pass
         for chunk in _chunks(pending, SIGNOFF_BATCH_SIZE):
             # The session writes a decision per bundle as it goes; a dropped session
             # still leaves the finished ones, applied below. Isolate it so a crashed

template/tests/test_flow_slice.py

@@ -195,6 +195,34 @@ def signoff_batch(cfg: Config, bundles: list[Path]) -> None:
         self.assertEqual(set(results), {"BATCH1", "BATCH2"})
         self.assertTrue(all(s == state.COMPLETE for s in results.values()))
 
+    def test_batch_iterate_plan_then_complete(self) -> None:
+        # iterate-plan re-opens a batch member to UNPLANNED (archiving its attempt to
+        # iteration-v1/); the sweep must keep looping so a LATER pass re-plans + rebuilds
+        # it, rather than break at UNPLANNED when nothing is awaiting sign-off (#105).
+        iterated = {"done": False}
+
+        def signoff_batch(cfg: Config, bundles: list[Path]) -> None:
+            for d in bundles:
+                summ = d / "SUMMARY.md"
+                if d.name == "issue_BATCH1" and not iterated["done"]:
+                    iterated["done"] = True
+                    (d / leaves.SIGNOFF_DECISION).write_text("iterate-plan\n", encoding="utf-8")
+                    continue
+                summ.write_text(summ.read_text().replace("- [ ]", "- [x]"), encoding="utf-8")
+                (d / leaves.SIGNOFF_DECISION).write_text("accept\n", encoding="utf-8")
+
+        orig = leaves.run_signoff_batch
+        leaves.run_signoff_batch = signoff_batch
+        try:
+            results = flow.flow_batch(self.cfg, today="2026-06-04", max_passes=6)
+        finally:
+            leaves.run_signoff_batch = orig
+        self.assertTrue(iterated["done"])
+        self.assertEqual(set(results), {"BATCH1", "BATCH2"})
+        self.assertTrue(all(s == state.COMPLETE for s in results.values()))
+        # the re-opened bundle re-planned, rebuilt, and preserved its first attempt
+        self.assertTrue((self.cfg.bundle("BATCH1") / "iteration-v1").is_dir())
+
     def test_batch_signoff_chunks_into_sessions(self) -> None:
         # The cheap-first queue is signed off in ONE session per chunk of
         # SIGNOFF_BATCH_SIZE (=5): six halted bundles → sessions of 5 then 1, all