fix(codex): drain-free stderr + UTF-8-safe stdout decode in tutorials [greptile]

Greptile flagged a deadlock: all three codex tutorials spawned `codex exec`
with stderr=PIPE but never read it, so once codex filled the OS pipe buffer
(~64 KB) the subprocess stalled and the agent hung. Redirect stderr to DEVNULL
(codex --json emits events on stdout; stderr is progress noise).

Also fix UTF-8 corruption in _process_stdout: decoding each 4 KB read
independently splits multibyte characters at chunk boundaries. Use an
incremental UTF-8 decoder so boundary-split characters decode correctly.

Applied to 00_sync, 10_async/00_base (acp.py) and 10_async/10_temporal
(activities.py).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: declan-scale

examples/tutorials/00_sync/harness_codex/project/acp.py

@@ -22,6 +22,7 @@
 
 import os
 import time
+import codecs
 import asyncio
 from typing import AsyncGenerator
 from collections.abc import AsyncIterator
@@ -87,25 +88,34 @@ async def _spawn_codex(model: str) -> asyncio.subprocess.Process:
         *cmd,
         stdin=asyncio.subprocess.PIPE,
         stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
+        # Discard stderr: codex --json writes events to stdout; its stderr is
+        # progress/debug noise. Capturing it with PIPE but never reading it
+        # would deadlock once codex fills the OS pipe buffer (~64 KB).
+        stderr=asyncio.subprocess.DEVNULL,
         env={**os.environ},
     )
 
 
 async def _process_stdout(process: asyncio.subprocess.Process) -> AsyncIterator[str]:
-    """Yield newline-delimited JSON lines from the process stdout."""
+    """Yield newline-delimited JSON lines from the process stdout.
+
+    Uses an incremental UTF-8 decoder so a multibyte character split across two
+    4 KB reads is decoded correctly instead of being corrupted at the boundary.
+    """
     assert process.stdout is not None
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
     buffer = ""
     while True:
         chunk = await process.stdout.read(4096)
         if not chunk:
             break
-        buffer += chunk.decode("utf-8", errors="replace")
+        buffer += decoder.decode(chunk)
         while "\n" in buffer:
             line, buffer = buffer.split("\n", 1)
             line = line.strip()
             if line:
                 yield line
+    buffer += decoder.decode(b"", final=True)
     if buffer.strip():
         yield buffer.strip()
 

examples/tutorials/10_async/00_base/harness_codex/project/acp.py

@@ -22,6 +22,7 @@
 
 import os
 import time
+import codecs
 import asyncio
 from collections.abc import AsyncIterator
 
@@ -102,25 +103,34 @@ async def _spawn_codex(
         *cmd,
         stdin=asyncio.subprocess.PIPE,
         stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
+        # Discard stderr: codex --json writes events to stdout; its stderr is
+        # progress/debug noise. Capturing it with PIPE but never reading it
+        # would deadlock once codex fills the OS pipe buffer (~64 KB).
+        stderr=asyncio.subprocess.DEVNULL,
         env={**os.environ},
     )
 
 
 async def _process_stdout(process: asyncio.subprocess.Process) -> AsyncIterator[str]:
-    """Yield newline-delimited JSON lines from the process stdout."""
+    """Yield newline-delimited JSON lines from the process stdout.
+
+    Uses an incremental UTF-8 decoder so a multibyte character split across two
+    4 KB reads is decoded correctly instead of being corrupted at the boundary.
+    """
     assert process.stdout is not None
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
     buffer = ""
     while True:
         chunk = await process.stdout.read(4096)
         if not chunk:
             break
-        buffer += chunk.decode("utf-8", errors="replace")
+        buffer += decoder.decode(chunk)
         while "\n" in buffer:
             line, buffer = buffer.split("\n", 1)
             line = line.strip()
             if line:
                 yield line
+    buffer += decoder.decode(b"", final=True)
     if buffer.strip():
         yield buffer.strip()
 

examples/tutorials/10_async/10_temporal/harness_codex/project/activities.py

@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import os
+import codecs
 import asyncio
 from typing import Any
 from datetime import datetime
@@ -82,25 +83,34 @@ async def _spawn_codex(
         *cmd,
         stdin=asyncio.subprocess.PIPE,
         stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
+        # Discard stderr: codex --json writes events to stdout; its stderr is
+        # progress/debug noise. Capturing it with PIPE but never reading it
+        # would deadlock once codex fills the OS pipe buffer (~64 KB).
+        stderr=asyncio.subprocess.DEVNULL,
         env={**os.environ},
     )
 
 
 async def _process_stdout(process: asyncio.subprocess.Process) -> AsyncIterator[str]:
-    """Yield newline-delimited JSON lines from the process stdout."""
+    """Yield newline-delimited JSON lines from the process stdout.
+
+    Uses an incremental UTF-8 decoder so a multibyte character split across two
+    4 KB reads is decoded correctly instead of being corrupted at the boundary.
+    """
     assert process.stdout is not None
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
     buffer = ""
     while True:
         chunk = await process.stdout.read(4096)
         if not chunk:
             break
-        buffer += chunk.decode("utf-8", errors="replace")
+        buffer += decoder.decode(chunk)
         while "\n" in buffer:
             line, buffer = buffer.split("\n", 1)
             line = line.strip()
             if line:
                 yield line
+    buffer += decoder.decode(b"", final=True)
     if buffer.strip():
         yield buffer.strip()