fix(cli): do not assume why a line was unreadable, and bound the retries

The previous commit caught ValueError from readline() and asserted it was a
limit overrun. It only knew an exception had been raised.

That mattered beyond the message. Skipping the line is safe only for the
overrun case, where readline() has already discarded the line and resumed the
transport before raising. readline() flattens LimitOverrunError into a bare
ValueError, so the two are indistinguishable at the call site, and any other
ValueError that consumes nothing would have spun the loop forever at 100% CPU
while still not draining the pipe. That is worse than the freeze being fixed.

Now: report the actual exception with repr() and no assumed cause, and bound
consecutive failures at MAX_CONSECUTIVE_READ_ERRORS (100). Past that, re-raise
so the outer handler reports that nothing is draining the child's stdout.

The outer try/except is load-bearing, not vestigial: it is the escalation path
for that re-raise, and it still covers console.print failures and non-ValueError
transport errors. It does not swallow cancellation, since CancelledError derives
from BaseException, so the auto-reload path that cancels these tasks is
unaffected (verified).

(cherry picked from commit 13fa1f5c28f1687f1f90469c22eba9bccf1bbc82)

Author: chakrris

src/agentex/lib/cli/handlers/run_handlers.py

@@ -28,6 +28,11 @@
 # echoed by validation errors), so give the reader room before it has to drop one.
 SUBPROCESS_STREAM_LIMIT = 8 * 1024 * 1024
 
+# How many consecutive unreadable lines to skip before giving up on the stream.
+# Skipping is only known-safe for the limit-overrun case; this bounds the damage
+# if some other error repeats without consuming anything.
+MAX_CONSECUTIVE_READ_ERRORS = 100
+
 
 class RunError(Exception):
     """An error occurred during agent run"""
@@ -255,19 +260,31 @@ async def stream_process_output(process: asyncio.subprocess.Process, prefix: str
     try:
         if process.stdout is None:
             return
+        consecutive_read_errors = 0
         while True:
             try:
                 line = await process.stdout.readline()
             except ValueError as e:
-                # Line longer than the stream limit. readline() has already
-                # dropped it (or cleared the buffer) and resumed the transport,
-                # so continuing is safe and always makes progress.
+                # readline() raises ValueError when a line exceeds the stream limit.
+                # In *that* case it has already discarded the line and resumed the
+                # transport, so skipping it makes guaranteed progress. Any other
+                # ValueError carries no such guarantee, and retrying it forever would
+                # spin without draining. We cannot tell the two apart (readline
+                # flattens LimitOverrunError into a bare ValueError), so bound the
+                # retries and let the outer handler report the hang risk.
+                consecutive_read_errors += 1
+                if consecutive_read_errors > MAX_CONSECUTIVE_READ_ERRORS:
+                    raise
                 logger.warning(
-                    f"Dropped an oversized log line from {prefix} ({e}); "
-                    f"raise limit= on this process's create_subprocess_exec if it recurs."
+                    f"Skipping an unreadable line from {prefix}: {e!r} "
+                    f"(consecutive failure {consecutive_read_errors}/{MAX_CONSECUTIVE_READ_ERRORS}). "
+                    f"If this says the chunk exceeded the limit, raise limit= on this "
+                    f"process's create_subprocess_exec."
                 )
                 continue
 
+            consecutive_read_errors = 0
+
             if not line:
                 break