piocloop 0.1.0__tar.gz → 0.1.2__tar.gz

{piocloop-0.1.0 → piocloop-0.1.2}/.gitignore

@@ -49,3 +49,5 @@ Thumbs.db
 # Project-specific
 *.log
 .pi/
+.env.local
+.local.env

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: piocloop
-Version: 0.1.0
+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.0 → piocloop-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "piocloop"
-version = "0.1.0"
+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.0 → piocloop-0.1.2}/src/piocloop/cli.py

@@ -101,7 +101,10 @@ def run(
         help="How to answer blocking extension dialogs: cancel|allow|deny",
     ),
     session_dir: Optional[Path] = typer.Option(None, "--session-dir", help="Passed through to pi"),
-    no_session: bool = typer.Option(False, "--no-session", help="Do not persist pi sessions"),
+    no_session: bool = typer.Option(
+        True, "--no-session/--persist-sessions",
+        help="Use an ephemeral pi session (default); --persist-sessions enables session files",
+    ),
     tools: Optional[str] = typer.Option(None, "--tools", help="Comma-separated tool allowlist"),
     exclude_tools: Optional[str] = typer.Option(
         None, "--exclude-tools", help="Comma-separated tool denylist"

{piocloop-0.1.0 → 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,11 +328,25 @@ 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
 
-        await self.client.new_session()
+        try:
+            await self.client.new_session()
+        except (PiTimeout, PiExited) as exc:
+            # A session-switch timeout is not a recoverable iteration error:
+            # pi can have accepted the switch while losing its response, so
+            # retrying on the same process is unsafe and used to produce the
+            # characteristic three consecutive ``new_session`` failures.
+            # Replace the process, with start() performing a readiness
+            # handshake before the next iteration reaches this point.
+            self.ui.log_line("warn", f"new_session failed; restarting pi: {exc}")
+            if self.respawns >= self.config.max_respawns:
+                raise
+            await self._respawn_client()
+            raise
         self.iteration += 1
         self.iter_start_time = time.monotonic()
         self.ui.log_line("start", f"Iteration {self.iteration}")
@@ -337,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.0 → piocloop-0.1.2}/src/piocloop/pi_client.py

@@ -137,7 +137,17 @@ class PiClient:
     # Lifecycle
     # ------------------------------------------------------------------
 
-    async def start(self) -> None:
+    async def start(self, *, readiness_timeout: float = 60.0) -> None:
+        """Start pi and wait until its RPC session is usable.
+
+        ``create_subprocess_exec`` only means that the OS process exists.  Pi
+        still has to load its model catalogue, session and extensions before
+        it starts consuming RPC commands.  Sending ``new_session`` during
+        that window is particularly fragile with persistent sessions: the
+        command can sit unhandled until the caller's deadline expires.  A
+        bounded get_state handshake makes readiness explicit and also gives
+        respawned clients the same startup guarantee as the first client.
+        """
         if self._proc is not None:
             raise PiError("PiClient already started")
         try:
@@ -158,6 +168,12 @@ class PiClient:
             asyncio.create_task(self._read_stdout(), name="pi-stdout"),
             asyncio.create_task(self._read_stderr(), name="pi-stderr"),
         ]
+        try:
+            # Do not let callers race startup with the first session switch.
+            await self.request({"type": "get_state"}, timeout=readiness_timeout)
+        except Exception:
+            await self.close()
+            raise
 
     async def close(self, timeout: float = 5.0) -> None:
         """Shut the process down. Idempotent, and safe to call after a crash."""

{piocloop-0.1.0 → piocloop-0.1.2}/tests/fake_pi.py

@@ -17,6 +17,7 @@ import time
 # fallback cannot mistake a stuck run for a finished one.
 _PRETEND_STREAMING = {"busy", "wedged"}
 _streaming = False
+_ready = False
 
 
 def work_the_plan(message: str) -> None:
@@ -86,7 +87,7 @@ def settle() -> None:
 
 
 def main() -> int:
-    global _streaming
+    global _streaming, _ready
     scenario = sys.argv[1] if len(sys.argv) > 1 else "normal"
 
     while True:
@@ -116,11 +117,14 @@ def main() -> int:
             continue
 
         if ctype == "get_state":
+            _ready = True
             ok("get_state", rid,
                {"isStreaming": _streaming, "sessionId": "fake", "messageCount": 0})
             continue
 
         if ctype == "new_session":
+            if scenario == "readiness" and not _ready:
+                continue
             ok("new_session", rid, {"cancelled": False})
             continue
 

{piocloop-0.1.0 → 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):

{piocloop-0.1.0 → piocloop-0.1.2}/tests/test_pi_client.py

@@ -126,6 +126,12 @@ async def test_new_session_and_abort():
         await collect_until(client, "agent_settled")
 
 
+async def test_start_waits_for_rpc_readiness_before_new_session():
+    """Startup must complete before the first session replacement is sent."""
+    async with PiClient(fake_argv("readiness")) as client:
+        assert await client.new_session() == {"cancelled": False}
+
+
 async def test_concurrent_requests_are_correlated():
     """Interleaved commands must not cross-resolve each other's futures."""
     async with PiClient(fake_argv("normal")) as client: