fix(publish): treat an empty patch.diff as a close, not a broken contribution (#95)

The close-disposition guard checked `patch.diff.is_file()` but not its
content. A verify-first close can leave a 0-byte (or whitespace-only)
patch.diff behind — `is_file()` let it past the guard, after which
`git apply` was a no-op and the commit failed with "nothing to commit",
aborting publish and leaving an empty local fix/ branch.

Fold an emptiness check into the existing guard so a present-but-empty
patch.diff short-circuits to the same non-fatal return 0 as a missing one.
Add a red->green regression over both empty shapes (0-byte and
whitespace-only), each of which the state machine reads as past-Do
(COMPLETE) and so reaches publish.

Closes #95.

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/publish.py

@@ -76,9 +76,16 @@ def publish(
     # patch.diff, so there is nothing to `git apply` / open a PR for. This is not a
     # failure — close the tracker item by hand. Return 0 so the continuous flow's
     # publish-on-accept doesn't error (mirrors skip_if_no_target).
-    if not (d / "patch.diff").is_file():
-        print(f"publish: {d.name} has no patch.diff (close / no-fix disposition) — "
-              "nothing to contribute; close the tracker item by hand.", file=sys.stderr)
+    #
+    # A 0-byte / whitespace-only patch.diff counts as "no patch" too (issue #95): a
+    # verify-first close can leave an empty patch.diff behind, and `is_file()` alone
+    # would let it past this guard — after which `git apply` is a no-op and the commit
+    # fails with "nothing to commit". Treat empty content the same as a missing file.
+    patch = d / "patch.diff"
+    if not patch.is_file() or not patch.read_text(encoding="utf-8").strip():
+        print(f"publish: {d.name} has no (non-empty) patch.diff (close / no-fix "
+              "disposition) — nothing to contribute; close the tracker item by hand.",
+              file=sys.stderr)
         return 0
 
     # Resolve the target from the brief (the contribution's where).

template/tests/test_publish_slice.py

@@ -130,6 +130,27 @@ def test_skip_if_no_target_is_nonfatal(self) -> None:
         # …but a standalone publish (no skip) treats the missing target as an error.
         self.assertEqual(publish.publish(self.cfg, "NOTGT", dry_run=True), 1)
 
+    def test_empty_patch_is_treated_as_close_disposition(self) -> None:
+        """Regression (#95): a 0-byte / whitespace-only patch.diff is a close, not a
+        broken contribution. `is_file()` alone let an empty patch past the guard, after
+        which `git apply` was a no-op and the commit failed with 'nothing to commit'.
+
+        The #95 shape is an *empty patch.diff present* — which the state machine reads
+        as past-Do, so the bundle is COMPLETE and reaches publish (unlike a missing
+        patch.diff + close marker, the issue #60 path). Both empty shapes must
+        short-circuit to a non-fatal 0 and plan nothing."""
+        for iid, content in (("CLOSE0", ""), ("CLOSE1", "\n  \n")):
+            d = _bundle(self.cfg, iid, brief_body=_FIX_BRIEF, accepted=True)
+            (d / "patch.diff").write_text(content, encoding="utf-8")
+            self.assertEqual(state.state(d), state.COMPLETE)  # empty patch ⇒ past-Do
+            buf = io.StringIO()
+            with redirect_stderr(buf):
+                self.assertEqual(publish.publish(self.cfg, iid, dry_run=True), 0)
+            self.assertIn("no (non-empty) patch.diff", buf.getvalue())
+            # the guard returns before any contribution is planned/recorded
+            self.assertFalse((d / "commit-msg.txt").exists())
+            self.assertFalse((d / "publish.json").exists())
+
     def test_commit_stages_patch_added_files(self) -> None:
         """Regression (#23a): the commit must stage patch-ADDED files (the new
         regression test), not only modified-tracked ones — `git apply` + `add --all`