fix(claude-code): drain stderr in tutorial _spawn_claude to avoid deadlock [greptile]

All three claude-code tutorial spawn helpers pass --verbose and capture stderr
via asyncio.subprocess.PIPE but never read it. A non-trivial session can write
enough verbose output to fill the OS pipe buffer, at which point Claude Code
blocks on its stderr write while we block reading stdout — a hard deadlock.
Drain stderr in a concurrent background task (awaited after proc.wait()) so
stdout never stalls. Applied to 060_claude_code (sync), 130_claude_code
(async base), and 140_claude_code (temporal).

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

Author: declan-scale

examples/tutorials/00_sync/060_claude_code/project/acp.py

@@ -68,6 +68,17 @@ async def _spawn_claude(prompt: str) -> AsyncIterator[str]:
     proc.stdin.write(prompt.encode())
     proc.stdin.close()
 
+    # Drain stderr concurrently. With --verbose, Claude Code can write enough to
+    # stderr to fill the OS pipe buffer; if we only read stdout, the CLI blocks
+    # on its stderr write while we block reading stdout — a deadlock. A
+    # background task keeps stderr flowing so stdout never stalls.
+    async def _drain_stderr() -> None:
+        assert proc.stderr is not None
+        async for _ in proc.stderr:
+            pass
+
+    stderr_task = asyncio.create_task(_drain_stderr())
+
     buffer = ""
     async for chunk in proc.stdout:
         buffer += chunk.decode("utf-8", errors="replace")
@@ -81,6 +92,7 @@ async def _spawn_claude(prompt: str) -> AsyncIterator[str]:
         yield buffer.strip()
 
     await proc.wait()
+    await stderr_task
 
 
 @acp.on_message_send

examples/tutorials/10_async/00_base/130_claude_code/project/acp.py

@@ -69,6 +69,17 @@ async def _spawn_claude(prompt: str) -> AsyncIterator[str]:
     proc.stdin.write(prompt.encode())
     proc.stdin.close()
 
+    # Drain stderr concurrently. With --verbose, Claude Code can write enough to
+    # stderr to fill the OS pipe buffer; if we only read stdout, the CLI blocks
+    # on its stderr write while we block reading stdout — a deadlock. A
+    # background task keeps stderr flowing so stdout never stalls.
+    async def _drain_stderr() -> None:
+        assert proc.stderr is not None
+        async for _ in proc.stderr:
+            pass
+
+    stderr_task = asyncio.create_task(_drain_stderr())
+
     buffer = ""
     async for chunk in proc.stdout:
         buffer += chunk.decode("utf-8", errors="replace")
@@ -82,6 +93,7 @@ async def _spawn_claude(prompt: str) -> AsyncIterator[str]:
         yield buffer.strip()
 
     await proc.wait()
+    await stderr_task
 
 
 @acp.on_task_create

examples/tutorials/10_async/10_temporal/140_claude_code/project/workflow.py

@@ -86,6 +86,17 @@ async def _spawn_claude(prompt: str, session_id: str | None = None) -> AsyncIter
     proc.stdin.write(prompt.encode())
     proc.stdin.close()
 
+    # Drain stderr concurrently. With --verbose, Claude Code can write enough to
+    # stderr to fill the OS pipe buffer; if we only read stdout, the CLI blocks
+    # on its stderr write while we block reading stdout — a deadlock. A
+    # background task keeps stderr flowing so stdout never stalls.
+    async def _drain_stderr() -> None:
+        assert proc.stderr is not None
+        async for _ in proc.stderr:
+            pass
+
+    stderr_task = asyncio.create_task(_drain_stderr())
+
     buffer = ""
     async for chunk in proc.stdout:
         buffer += chunk.decode("utf-8", errors="replace")
@@ -99,6 +110,7 @@ async def _spawn_claude(prompt: str, session_id: str | None = None) -> AsyncIter
         yield buffer.strip()
 
     await proc.wait()
+    await stderr_task
 
 
 @workflow.defn(name=environment_variables.WORKFLOW_NAME)