fix(llm): unblock subprocess reads when a worker escapes the process group

internal/llm/subprocess.go

@@ -25,6 +25,14 @@ type LaunchedProcess struct {
 	processGroup *processGroup
 }
 
+// subprocessWaitDelay is the grace, after the process context ends (task
+// timeout, abort, or normal completion), before stdout/stderr are force-closed.
+// A claude worker that escapes the process group (it becomes its own group
+// leader) survives cmd.Cancel's group kill and keeps a pipe open; a consumer's
+// synchronous read then blocks forever and cmd.Wait never runs — the run wedges
+// at 0% CPU holding the ledger. A var (not const) so tests can shorten it.
+var subprocessWaitDelay = 10 * time.Second
+
 // LaunchProcess starts an adapter subprocess with shared cancellation, logging,
 // and platform-specific process-group handling.
 func LaunchProcess(ctx context.Context, command string, args []string, dir string, env []string, timeout time.Duration, logPath string, cleanup func() error, withStdin bool) (*LaunchedProcess, error) {
@@ -48,6 +56,9 @@ func LaunchProcess(ctx context.Context, command string, args []string, dir strin
 		return nil, err
 	}
 	cmd.Cancel = func() error { return procGroup.kill(cmd) }
+	// Backstop for cmd.Wait if the pipes are held open by a worker that escaped
+	// the group after the process exits.
+	cmd.WaitDelay = subprocessWaitDelay
 
 	var stdin io.WriteCloser
 	if withStdin {
@@ -102,6 +113,16 @@ func LaunchProcess(ctx context.Context, command string, args []string, dir strin
 		process.Abort(cleanup)
 		return nil, err
 	}
+	// If a worker escapes the process group and holds stdout/stderr open, a
+	// consumer's synchronous read blocks forever and cmd.Wait never runs. When
+	// the context ends, give the pipes a grace to EOF cleanly, then force them
+	// closed so any pending read unblocks and the task fails instead of wedging.
+	go func() {
+		<-procCtx.Done()
+		time.Sleep(subprocessWaitDelay)
+		_ = stdout.Close()
+		_ = stderr.Close()
+	}()
 	return process, nil
 }
 

internal/llm/subprocess_launch_unix_test.go

@@ -0,0 +1,62 @@
+//go:build !windows
+
+package llm
+
+import (
+	"bufio"
+	"context"
+	"io"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestLaunchProcessUnblocksReadOnCanceledContext reproduces the subprocess
+// wedge: a worker that escapes the process group (becomes its own group leader)
+// holds stdout open, so cmd.Cancel's group kill misses it and a consumer's
+// synchronous read of Stdout() never sees EOF. LaunchProcess must force the
+// pipes closed a grace after the context ends so the read unblocks. Without the
+// on-cancel pipe close this test times out.
+func TestLaunchProcessUnblocksReadOnCanceledContext(t *testing.T) {
+	if _, err := exec.LookPath("python3"); err != nil {
+		t.Skip("python3 required to spawn a process-group-escaping worker")
+	}
+	prev := subprocessWaitDelay
+	subprocessWaitDelay = 100 * time.Millisecond
+	defer func() { subprocessWaitDelay = prev }()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	// The worker os.setsid()s out of the process group, prints READY on the
+	// inherited stdout, then holds it open. Reading READY proves it has escaped
+	// and owns the pipe. The parent sleeps so it (and the group kill) can't
+	// close stdout on its own.
+	script := `python3 -c 'import os,sys,time; os.setsid(); print("READY"); sys.stdout.flush(); time.sleep(30)' & sleep 20`
+	logPath := filepath.Join(t.TempDir(), "subprocess.log")
+	p, err := LaunchProcess(ctx, "/bin/sh", []string{"-c", script}, "", nil, 0, logPath, func() error { return nil }, false)
+	if err != nil {
+		t.Fatalf("LaunchProcess: %v", err)
+	}
+
+	rd := bufio.NewReader(p.Stdout())
+	line, err := rd.ReadString('\n')
+	if err != nil || !strings.Contains(line, "READY") {
+		t.Fatalf("worker did not signal READY: %q err=%v", line, err)
+	}
+
+	cancel() // simulate task-timeout / abort; the escaped worker still holds stdout
+
+	done := make(chan struct{})
+	go func() {
+		_, _ = io.ReadAll(rd)
+		close(done)
+	}()
+	select {
+	case <-done:
+		// unblocked as expected
+	case <-time.After(5 * time.Second):
+		t.Fatal("stdout read wedged after context cancel: pipes were not force-closed")
+	}
+	_ = p.Command().Wait()
+}