cmd: preserve failure response in --wait, fix formatting

- Add ErrPollFailed sentinel that carries the full status response,
  so users see error details without a second API call
- Builder outputs failure response to stdout then returns exit 1
  (same pattern as ErrPaginationTruncated)
- --wait success passes nil columns (single object renders as
  key-value in --human, matching the get command)
- Remove stray blank line in root.go

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

Author: somanshreddy

cmd/heygen/builder.go

@@ -101,10 +101,22 @@ func buildCobraCommand(spec *command.Spec, ctx *cmdContext) *cobra.Command {
 						},
 					})
 					if err != nil {
+						var failErr *client.ErrPollFailed
+						if errors.As(err, &failErr) {
+							// Output the failure response (contains error details),
+							// then signal failure via CLIError for exit code 1.
+							if fmtErr := ctx.formatter.Data(failErr.Data, spec.DataField, nil); fmtErr != nil {
+								return fmtErr
+							}
+							return clierrors.New(failErr.Error())
+						}
 						return err
 					}
 
-					return ctx.formatter.Data(result, spec.DataField, defaultColumnsForSpec(spec))
+					// --wait result is a single resource from the GET endpoint.
+					// Columns are nil — HumanFormatter renders single objects as
+					// key-value pairs, not tables. This matches `heygen video get`.
+					return ctx.formatter.Data(result, spec.DataField, nil)
 				}
 			}
 

cmd/heygen/builder_test.go

@@ -348,6 +348,15 @@ func TestGenBuilder_VideoCreate_Wait_Failure(t *testing.T) {
 	if !strings.Contains(res.Stderr, "operation reached terminal failure state: failed") {
 		t.Fatalf("stderr = %s, want failure message", res.Stderr)
 	}
+	// Failure response should be output to stdout so users can see error details
+	var parsed map[string]any
+	if err := json.Unmarshal([]byte(res.Stdout), &parsed); err != nil {
+		t.Fatalf("stdout should contain failure response: %v\nstdout: %s", err, res.Stdout)
+	}
+	data := parsed["data"].(map[string]any)
+	if data["status"] != "failed" {
+		t.Fatalf("status = %v, want failed", data["status"])
+	}
 }
 
 func TestGenBuilder_VideoCreate_Wait_Timeout(t *testing.T) {

cmd/heygen/root.go

@@ -99,7 +99,6 @@ func registerGroups(root *cobra.Command, ctx *cmdContext, groups map[string][]*c
 	}
 }
 
-
 func registerSpecCommand(groupCmd *cobra.Command, spec *command.Spec, ctx *cmdContext) {
 	path := commandPathParts(spec)
 	if len(path) == 0 {

internal/client/executor.go

@@ -41,6 +41,18 @@ func (e *ErrPaginationTruncated) Error() string {
 	return fmt.Sprintf("pagination stopped at %d items (hard limit); results may be incomplete", e.Count)
 }
 
+// ErrPollFailed is returned when polling reaches a terminal failure state.
+// It carries the full status response so callers can output it (the response
+// often contains error details the user needs to diagnose the failure).
+type ErrPollFailed struct {
+	Data   json.RawMessage
+	Status string
+}
+
+func (e *ErrPollFailed) Error() string {
+	return fmt.Sprintf("operation reached terminal failure state: %s", e.Status)
+}
+
 // ExecuteAndPoll executes a create request, then polls a status endpoint until
 // the resource reaches a terminal state or the context is canceled.
 func (c *Client) ExecuteAndPoll(
@@ -108,7 +120,7 @@ func (c *Client) ExecuteAndPoll(
 			return statusResp, nil
 		}
 		if slices.Contains(spec.PollConfig.TerminalFail, status) {
-			return nil, clierrors.New(fmt.Sprintf("operation reached terminal failure state: %s", status))
+			return nil, &ErrPollFailed{Data: statusResp, Status: status}
 		}
 		if opts.OnStatus != nil {
 			opts.OnStatus(status, time.Since(start))

internal/client/executor_test.go

@@ -817,12 +817,16 @@ func TestExecuteAndPoll_FailureState(t *testing.T) {
 		t.Fatal("expected error, got nil")
 	}
 
-	var cliErr *clierrors.CLIError
-	if !errors.As(err, &cliErr) {
-		t.Fatalf("expected *CLIError, got %T", err)
+	var failErr *ErrPollFailed
+	if !errors.As(err, &failErr) {
+		t.Fatalf("expected *ErrPollFailed, got %T: %v", err, err)
+	}
+	if failErr.Status != "failed" {
+		t.Fatalf("status = %q, want %q", failErr.Status, "failed")
 	}
-	if cliErr.Message != "operation reached terminal failure state: failed" {
-		t.Fatalf("message = %q", cliErr.Message)
+	// Verify the full response is preserved
+	if !strings.Contains(string(failErr.Data), `"status":"failed"`) {
+		t.Fatalf("data = %s, want failure response", failErr.Data)
 	}
 }