piocloop 0.1.0__tar.gz → 0.1.1__tar.gz

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

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

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

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

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

@@ -319,7 +319,20 @@ class LoopEngine:
         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}")

{piocloop-0.1.0 → piocloop-0.1.1}/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.1}/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.1}/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: