test(dry-run): skip docker-state guard under act_runner

The no-side-effects assertion calls `docker network ls` and
`docker ps -a` to verify the dry run created nothing. Inside the
Gitea Actions job container, those exit non-zero against the
host-mounted docker socket — the same act_runner topology issue
that already excludes other integration tests from CI (see
docs/ci.md). The failure was silently swallowed under the default
check=False; the recent style sweep that added check=True surfaced
it.

Gate the docker-enumerating check on GITEA_ACTIONS so the JSON
contract — the more useful part of the test — keeps running on CI.
Consolidate the two count helpers into one that surfaces stderr in
the failure message instead of raising a context-free
CalledProcessError, so the next docker surprise is debuggable.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

tests/integration/test_dry_run_plan.py

@@ -28,8 +28,16 @@ class TestDryRunPlan(unittest.TestCase):
                 },
             }))
 
-            nets_before = self._count_claude_bottle_networks()
+            # Under act_runner with a host-mounted docker socket, the
-            ctrs_before = self._count_claude_bottle_containers()
+            # `docker network ls` / `docker ps -a` calls from inside the
+            # job container exit non-zero (see docs/ci.md for the same
+            # topology issue affecting other integration tests). Skip
+            # the side-effects guard there; locally the check still
+            # catches accidental docker resource creation by the dry
+            # run.
+            check_side_effects = os.environ.get("GITEA_ACTIONS") != "true"
+            nets_before = self._count_claude_bottle_networks() if check_side_effects else 0
+            ctrs_before = self._count_claude_bottle_containers() if check_side_effects else 0
 
             env = os.environ.copy()
             env["HOME"] = str(work_dir)
@@ -84,32 +92,38 @@ class TestDryRunPlan(unittest.TestCase):
             self.assertEqual(sorted(set(hosts)), hosts,
                              "hosts must be sorted and deduplicated")
 
-            # No Docker side effects.
+            # No Docker side effects (see the GITEA_ACTIONS skip note
-            self.assertEqual(nets_before, self._count_claude_bottle_networks(),
+            # above — this guard runs locally only).
-                             "no networks created")
+            if check_side_effects:
-            self.assertEqual(ctrs_before, self._count_claude_bottle_containers(),
+                self.assertEqual(nets_before, self._count_claude_bottle_networks(),
-                             "no containers created")
+                                 "no networks created")
+                self.assertEqual(ctrs_before, self._count_claude_bottle_containers(),
+                                 "no containers created")
         finally:
             import shutil
             shutil.rmtree(work_dir, ignore_errors=True)
 
     def _count_claude_bottle_networks(self) -> int:
-        result = subprocess.run(
+        return self._count_with_prefix(
-            ["docker", "network", "ls", "--format", "{{.Name}}"],
+            ["docker", "network", "ls", "--format", "{{.Name}}"], "claude-bottle"
-            capture_output=True,
-            text=True,
-            check=True,
         )
-        return sum(1 for n in result.stdout.splitlines() if n.startswith("claude-bottle"))
 
     def _count_claude_bottle_containers(self) -> int:
-        result = subprocess.run(
+        return self._count_with_prefix(
-            ["docker", "ps", "-a", "--format", "{{.Names}}"],
+            ["docker", "ps", "-a", "--format", "{{.Names}}"], "claude-bottle"
-            capture_output=True,
-            text=True,
-            check=True,
         )
-        return sum(1 for n in result.stdout.splitlines() if n.startswith("claude-bottle"))
+
+    def _count_with_prefix(self, cmd: list[str], prefix: str) -> int:
+        # capture_output + explicit returncode check so a docker
+        # failure surfaces its stderr in the test report instead of
+        # the bare CalledProcessError we used to get.
+        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        if result.returncode != 0:
+            self.fail(
+                f"{' '.join(cmd)!r} failed (exit {result.returncode}): "
+                f"stderr={result.stderr.strip()!r}"
+            )
+        return sum(1 for n in result.stdout.splitlines() if n.startswith(prefix))
 
 
 if __name__ == "__main__":