piocloop 0.1.1__tar.gz → 0.1.2__tar.gz

{piocloop-0.1.1 → piocloop-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: piocloop
-Version: 0.1.1
+Version: 0.1.2
 Summary: TUI loop harness that orchestrates the PI coding agent to execute tasks from a PLAN.md file iteratively
 Project-URL: Homepage, https://github.com/rbarzic/piocloop
 Project-URL: Repository, https://github.com/rbarzic/piocloop

{piocloop-0.1.1 → piocloop-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "piocloop"
-version = "0.1.1"
+version = "0.1.2"
 description = "TUI loop harness that orchestrates the PI coding agent to execute tasks from a PLAN.md file iteratively"
 readme = "README.md"
 license = { text = "MIT" }

{piocloop-0.1.1 → piocloop-0.1.2}/src/piocloop/loop.py

@@ -183,7 +183,18 @@ class LoopEngine:
         self.ui.log_line("warn", f"Restarting pi (respawn {self.respawns}/{self.config.max_respawns})")
         await self.shutdown()
         self._mapper = EventMapper(self.config.plan_file)
-        await self._spawn_client()
+        try:
+            await self._spawn_client()
+        except (PiError, OSError) as exc:
+            # shutdown() deliberately clears self.client before starting the
+            # replacement.  If readiness fails, keep that invariant explicit
+            # and turn the failure into an iteration error rather than letting
+            # the next retry reach _run_iteration with no client.
+            self.client = None
+            self.ui.log_line("error", f"Could not restart pi: {exc}")
+            if isinstance(exc, PiError):
+                raise
+            raise PiError(f"Could not restart pi: {exc}") from exc
 
     # ------------------------------------------------------------------
     # Events
@@ -274,6 +285,8 @@ class LoopEngine:
                     continue
 
                 try:
+                    if self.client is None:
+                        raise PiExited("pi client is unavailable")
                     await self._run_iteration()
                 except (PiError, PiExited, PiTimeout, OSError) as exc:
                     if self._stop_requested:
@@ -315,7 +328,8 @@ class LoopEngine:
             self.ui.log_line("info", "Loop stopped")
 
     async def _run_iteration(self) -> None:
-        assert self.client is not None
+        if self.client is None:
+            raise PiExited("pi client is unavailable")
         self._settled.clear()
         self._seen_agent_start = False
 
@@ -350,7 +364,8 @@ class LoopEngine:
 
     async def _await_settle(self) -> None:
         """Bounded wait for `agent_settled`. Cannot hang (DESIGN §4.2)."""
-        assert self.client is not None
+        if self.client is None:
+            raise PiExited("pi client is unavailable")
         cfg = self.config
         deadline = time.monotonic() + cfg.iteration_timeout
         idle_polls = 0

{piocloop-0.1.1 → piocloop-0.1.2}/tests/test_loop.py

@@ -24,6 +24,7 @@ from piocloop.loop import (
     LoopConfig,
     LoopEngine,
 )
+from piocloop.pi_client import PiTimeout
 
 FAKE_PI = str(Path(__file__).parent / "fake_pi.py")
 
@@ -92,6 +93,26 @@ async def wait_for_state(engine: LoopEngine, states: set[str], timeout: float =
     pytest.fail(f"engine stuck in {engine.state!r}, never reached {states}")
 
 
+class RespawnReadinessFailureClient:
+    """Minimal client sequence: first session fails, replacement never readies."""
+
+    def __init__(self, replacement: bool) -> None:
+        self.replacement = replacement
+        self.events: asyncio.Queue[dict] = asyncio.Queue()
+        self.exited = asyncio.Event()
+
+    async def start(self) -> None:
+        if self.replacement:
+            raise PiTimeout("no response to 'get_state' within deadline")
+
+    async def close(self) -> None:
+        self.exited.set()
+
+    async def new_session(self) -> dict:
+        raise PiTimeout("no response to 'new_session' within deadline")
+
+
+
 class EngineHarness:
     """Boot an engine, run it in the background, always clean it up."""
 
@@ -114,9 +135,38 @@ class EngineHarness:
         await self.engine.shutdown()
 
 
-# ---------------------------------------------------------------------------
-# Happy path
-# ---------------------------------------------------------------------------
+async def test_failed_respawn_readiness_is_a_controlled_retry_then_stop(workspace):
+    """A replacement that never becomes ready must not hit the client assert."""
+    created = 0
+
+    def factory() -> RespawnReadinessFailureClient:
+        nonlocal created
+        created += 1
+        return RespawnReadinessFailureClient(replacement=created > 1)
+
+    config = make_config(
+        workspace,
+        "normal",
+        max_respawns=1,
+        max_error_streak=2,
+        error_backoff_base=1.0,
+        max_stalls=0,
+    )
+    engine = LoopEngine(config, ui=RecordingUI(), client_factory=factory)
+    assert await engine.boot()
+    task = asyncio.create_task(engine.run(auto_start=True))
+    try:
+        await wait_for_state(engine, {STATE_ERROR}, timeout=5.0)
+        assert engine.client is None
+        assert engine.error_streak == 2
+    finally:
+        engine.request_stop()
+        await asyncio.wait_for(task, timeout=5.0)
+        await engine.shutdown()
+
+    assert engine.state == STATE_ERROR
+
+
 
 
 async def test_plan_runs_to_completion(workspace):