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

In a multi-bundle flow, signing a bundle off as iterate-plan left it stuck at
UNPLANNED: the attempt was archived to iteration-v1/, but the re-plan + rebuild never
ran. Single-issue flow() is fine (its for-max_iters loop re-plans the re-opened
bundle); only the batch `_drive_and_act` loop was affected.

Root cause: decisions are recorded apply_now=False, so an iterate-plan becomes
ITERATE_PLAN and the archive→UNPLANNED happens in the NEXT pass's build-all — but the
plan pre-pass runs before the archive, so that pass ends with the bundle freshly
UNPLANNED and nothing awaiting sign-off. `if not pending: break` then exited before the
pass that would re-plan it.

Break only when the band made NO progress this pass: snapshot bundle states before
build-all and, when nothing is pending, `continue` if any state changed (e.g. the
iterate-plan re-open) and `break` only if all states held (genuinely terminal, or the
planner declined an UNPLANNED bundle). Bounded by max_passes.

Test: test_batch_iterate_plan_then_complete — a batch member iterate-plans, then both
reach COMPLETE with the first attempt preserved in iteration-v1/. Full suite: 170 OK.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Eduard Ralph <15236434+eduralph@users.noreply.github.com>

Author: eduralph

template/src/pdca_harness/flow.py

@@ -361,6 +361,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 —
@@ -369,7 +370,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

@@ -190,6 +190,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