fix(pi): keep the cause in the ListModels error chain

Trail #193 finding 019fb4fa-0f6 (low): pi/models.go used %s instead of %w, so
runErr dropped out of the error chain entirely and callers could not ask
errors.Is(err, exec.ErrNotFound) — i.e. "is pi installed?" — programmatically.
Mine, from the same commit that moved ListModels off HandleTextGenResult.

Wrapping naively duplicated the text, because detail falls back to
runErr.Error() when the subprocess produced no output. When there is no output,
runErr is the whole story, so it is now wrapped alone rather than interpolated
and then wrapped again.

TestListModels_PreservesCauseAndStaysUntyped pins both halves and both
directions: the cause is reachable via errors.Is, it appears exactly once, and
the error is deliberately NOT an *agent.TextGenError — listing models is not
summary generation, and routing it through that surface would let a
model-listing failure render as "Pi failed to generate the summary".

Also rewrote the streamFailure doc comment in the present tense. Trail finding
019fb472-90c reported the streaming path as still returning bare fmt.Errorf,
citing "lines 100/148" — the pre-fix layout. Those returns were migrated in
6e5c089 and the finding's own location (line 174) landed inside the comment
describing the OLD behavior. The comment now states what the code does rather
than what it used to do, so it cannot be read as a description of current
behavior.

Verified: zero bare fmt.Errorf/errors.New failure returns remain in
generate_streaming.go; 8573 unit tests; lint 0 issues on a cleaned cache.

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

Author: peyton-alt

cmd/entire/cli/agent/claudecode/generate_streaming.go

@@ -172,14 +172,16 @@ func (c *ClaudeCodeAgent) GenerateTextStreaming(
 // path does — HTTP status on stderr, then Claude's auth-phrase fallback — and
 // attaches the captured evidence.
 //
-// Before this existed, nine of the ten failure returns in GenerateTextStreaming
-// were plain fmt.Errorf, so they reached the user through
-// formatCheckpointSummaryError's default branch as a raw Go error string with
-// no remediation row. That mattered more than it looked: TextGeneratorAdapter
-// prefers streaming, so this is the path `explain --generate` actually takes
-// for Claude. A stale key (claude exits 2, "Invalid API key" on stderr, no
-// envelope) got "claude stream failed: ... exit status 2" here while the
-// non-streaming fallback correctly said "Claude authentication failed".
+// EVERY failure return in GenerateTextStreaming goes through this or an
+// explicit *TextGenerationError — there are no bare fmt.Errorf failure returns
+// left in this file, and TestGenerateTextStreaming_ClassifiesStderrFailures
+// pins that for the auth-phrase, 401, 429 and 404 shapes.
+//
+// Why it matters: TextGeneratorAdapter prefers streaming, so this is the path
+// `explain --generate` actually takes for Claude. A stale key (claude exits 2,
+// "Invalid API key" on stderr, no envelope) must produce "Claude
+// authentication failed" with a remediation row, not a raw Go error string via
+// formatCheckpointSummaryError's default branch.
 func streamFailure(stderrBuf string, stdoutBytes int, exitCode int, cause error, fallbackMsg string) error {
 	stderrStr := strings.TrimSpace(stderrBuf)
 	msg := stderrStr

cmd/entire/cli/agent/pi/models.go

@@ -23,14 +23,19 @@ func (a *PiAgent) ListModels(ctx context.Context) ([]agent.ModelInfo, error) {
 	// Listing models is a different operation and gets a plain error.
 	res, runErr := agent.RunIsolatedTextGeneratorCLIRaw(ctx, a.CommandRunner, "pi", []string{"--list-models"}, "")
 	if runErr != nil {
+		// %w on runErr so callers can still reach the underlying error
+		// (exec.ErrNotFound in particular) via errors.Is/As — dropping the cause
+		// would make "is pi installed?" unanswerable programmatically. When the
+		// subprocess produced no output, runErr IS the whole story, so wrap it
+		// alone rather than interpolating its text and then wrapping it again.
 		detail := strings.TrimSpace(string(res.Stderr))
 		if detail == "" {
 			detail = strings.TrimSpace(string(res.Stdout))
 		}
 		if detail == "" {
-			detail = runErr.Error()
+			return nil, fmt.Errorf("pi --list-models: %w", runErr)
 		}
-		return nil, fmt.Errorf("pi --list-models: %s", agent.TruncateStderr(detail))
+		return nil, fmt.Errorf("pi --list-models: %s: %w", agent.TruncateStderr(detail), runErr)
 	}
 	out := strings.TrimSpace(string(res.Stdout))
 	if out == "" {

cmd/entire/cli/agent/pi/models_test.go

@@ -1,6 +1,14 @@
 package pi
 
-import "testing"
+import (
+	"context"
+	"errors"
+	"os/exec"
+	"strings"
+	"testing"
+
+	"github.com/entireio/cli/cmd/entire/cli/agent"
+)
 
 func TestParsePiModelList(t *testing.T) {
 	raw := "provider      model                       context  max-out  thinking  images\n" +
@@ -33,3 +41,38 @@ func TestParsePiModelList_HeaderAndBlanksSkipped(t *testing.T) {
 		t.Fatalf("expected no models, got %#v", got)
 	}
 }
+
+// TestListModels_PreservesCauseAndStaysUntyped pins two things about the
+// ListModels error path that are easy to get wrong in opposite directions.
+//
+//  1. The cause survives. It is wrapped with %w, not interpolated with %s, so
+//     callers can still ask errors.Is(err, exec.ErrNotFound) — i.e. "is pi
+//     installed?" — programmatically.
+//  2. It is NOT an *agent.TextGenError. Listing models is not summary
+//     generation; routing it through the summary classifier would let a
+//     model-listing failure render as "Pi failed to generate the summary" if it
+//     ever reached formatCheckpointSummaryError.
+func TestListModels_PreservesCauseAndStaysUntyped(t *testing.T) {
+	t.Parallel()
+	a := &PiAgent{CommandRunner: func(ctx context.Context, _ string, _ ...string) *exec.Cmd {
+		return exec.CommandContext(ctx, "definitely-no-such-binary-xyz")
+	}}
+	_, err := a.ListModels(context.Background())
+	if err == nil {
+		t.Fatal("expected an error")
+	}
+	if !errors.Is(err, exec.ErrNotFound) {
+		t.Errorf("errors.Is(exec.ErrNotFound) = false; the cause was dropped from the chain: %v", err)
+	}
+	var tge *agent.TextGenError
+	if errors.As(err, &tge) {
+		t.Error("ListModels must not return *agent.TextGenError; that is the summary-path error surface")
+	}
+	if !strings.Contains(err.Error(), "pi --list-models") {
+		t.Errorf("err = %v; want the operation named", err)
+	}
+	// The cause must appear once, not twice.
+	if strings.Count(err.Error(), "executable file not found") != 1 {
+		t.Errorf("err = %q; cause should appear exactly once", err.Error())
+	}
+}