@pippit-dev/cli 1.0.51 → 1.0.53

package/cmd/watermark.go

@@ -0,0 +1,38 @@
+package cmd
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/Pippit-dev/pippit-cli/internal/commandnames"
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+	"github.com/spf13/cobra"
+)
+
+func newWatermarkCommand(stdout, stderr io.Writer, runner *common.Runner) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:       commandnames.Watermark + " [on|off]",
+		Short:     "Query or set the current account's AIGC watermark",
+		Long:      "Without arguments, query the current account's AIGC watermark setting. Use on to retain it or off to remove it from saved content. This changes a persistent account setting; team selection does not change its scope. Final downloads remain subject to server policies.",
+		Args:      cobra.MaximumNArgs(1),
+		ValidArgs: []string{"on", "off"},
+		RunE: withErrorLog(commandnames.Watermark, nil, func(cmd *cobra.Command, args []string) error {
+			var enabled *bool
+			if len(args) > 0 {
+				if args[0] != "on" && args[0] != "off" {
+					return fmt.Errorf("水印状态只支持 on 或 off")
+				}
+				value := args[0] == "on"
+				enabled = &value
+			}
+			result, err := common.Watermark(cmd.Context(), runner, enabled)
+			if err != nil {
+				return err
+			}
+			return common.WriteJSON(stdout, result)
+		}),
+	}
+	cmd.SetOut(stdout)
+	cmd.SetErr(stderr)
+	return cmd
+}

package/dist/checksums.txt

@@ -1,6 +1,6 @@
-95c1a5b68a1df337ef3869de5cd00172b766c9324975f2a7358631d92b843137  pippit-tool-cli-1.0.51-darwin-amd64.tar.gz
-05a617b10aa6768f1a0d51c82d5f1bbf7a3ed6196db17247dfaad7cd1f46f957  pippit-tool-cli-1.0.51-darwin-arm64.tar.gz
-fb1edb92514aa2941b8c83ca1b806f76cdd1a0e19610b6ac9af38e415b9e060e  pippit-tool-cli-1.0.51-linux-amd64.tar.gz
-45b57561a0f190d32e4f05cc2aef6e9d2421263f7cec4cacd1e0151d5b1898aa  pippit-tool-cli-1.0.51-linux-arm64.tar.gz
-0f727048f4e3915a3f58e7c3b0b4df6d3fcd4214a17881cdb37f2958c417d86a  pippit-tool-cli-1.0.51-windows-amd64.zip
-1b05ef17e005e405997cf78622afbdc6d161f20c855347fabc5a0a46cf00399d  pippit-tool-cli-1.0.51-windows-arm64.zip
+08e0f157a05bdcbbb4c7a53eeeee3374d5be4bf86ec31139c5d42328c8cc781e  pippit-tool-cli-1.0.53-darwin-amd64.tar.gz
+fa1b79ed862a997d7ec8117895158f1914d2fcaa30792b303fd924d2856a834f  pippit-tool-cli-1.0.53-darwin-arm64.tar.gz
+e0d30c4edf201108587da2bd1ce97f9e7a30721e41700c50e7ddb57cc4c2474a  pippit-tool-cli-1.0.53-linux-amd64.tar.gz
+b60c817d9b58659838baf9954e5cc110ddc92ed2736e5512047dc2b20a9dfde8  pippit-tool-cli-1.0.53-linux-arm64.tar.gz
+b890470552424b37fbd98d8a0e202d66526f7f575233cfb860599dadbc802be2  pippit-tool-cli-1.0.53-windows-amd64.zip
+cf549f5b6e7d929d7b8b48b0a1a3df467ad921c23b4a93361799d7723b023bde  pippit-tool-cli-1.0.53-windows-arm64.zip

package/internal/commandnames/names.go

@@ -10,5 +10,6 @@ const (
 	Completion     = "completion"
 	Help           = "help"
 	Model          = "model"
+	Watermark      = "watermark"
 	DownloadResult = "download-result"
 )

package/internal/common/get_thread.go

@@ -18,8 +18,13 @@ type GetThreadOptions struct {
 }
 
 // GetThreadResult is the parsed get_thread response used by `pippit-tool-cli get-thread`.
+// A business error may return both a result and an error so structured callers
+// can still inspect the returned Run. Callers must continue to handle the error.
 type GetThreadResult struct {
 	ReadableText string `json:"readable_text"`
+	Ret          string `json:"-"`
+	Errmsg       string `json:"-"`
+	LogID        string `json:"-"`
 	RawData      []byte `json:"-"`
 }
 
@@ -49,11 +54,12 @@ func GetThread(ctx context.Context, opts *GetThreadOptions, runner *Runner) (*Ge
 	if err := runner.Client.SendRequest(ctx, getThreadPath(runner), body, &resp); err != nil {
 		return nil, fmt.Errorf("获取线程请求失败: %w", err)
 	}
+	result := &GetThreadResult{Ret: resp.Ret, Errmsg: resp.Errmsg, LogID: resp.LogID, RawData: resp.Data}
 	if resp.Ret != "0" {
 		if resp.Errmsg == "" {
 			resp.Errmsg = "未知错误"
 		}
-		return nil, NewLogIDError(fmt.Sprintf("获取线程请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
+		return result, NewLogIDError(fmt.Sprintf("获取线程请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
 	}
 	if len(resp.Data) == 0 {
 		return nil, fmt.Errorf("get_thread 响应缺少 data")
@@ -68,10 +74,8 @@ func GetThread(ctx context.Context, opts *GetThreadOptions, runner *Runner) (*Ge
 		}
 	}
 
-	return &GetThreadResult{
-		ReadableText: readable.ReadableText,
-		RawData:      resp.Data,
-	}, nil
+	result.ReadableText = readable.ReadableText
+	return result, nil
 }
 
 func getThreadPath(runner *Runner) string {

package/internal/common/get_thread_test.go

@@ -57,6 +57,21 @@ func TestGetThreadRequiresRetZero(t *testing.T) {
 	}
 }
 
+func TestGetThreadPreservesDataOnBusinessError(t *testing.T) {
+	result, err := GetThread(context.Background(), &GetThreadOptions{
+		ThreadID: "thread_123",
+		RunID:    "run_456",
+	}, &Runner{
+		Client: getThreadFakeClient{response: `{"ret":"2","errmsg":"模拟接口错误","log_id":"fixture-log","data":{"thread":{"thread_id":"thread_123","run_list":[{"run_id":"run_456","state":4}]}}}`},
+	})
+	if err == nil || !strings.Contains(err.Error(), "ret=2") || !strings.Contains(err.Error(), "fixture-log") {
+		t.Fatalf("error = %v, want business error with log ID", err)
+	}
+	if result == nil || !strings.Contains(string(result.RawData), `"run_456"`) {
+		t.Fatalf("result = %#v, want response data alongside business error", result)
+	}
+}
+
 func TestGetThreadV2RequiresReadableText(t *testing.T) {
 	_, err := GetThread(context.Background(), &GetThreadOptions{
 		ThreadID: "thread_123",
@@ -72,3 +87,24 @@ func TestGetThreadV2RequiresReadableText(t *testing.T) {
 		t.Fatalf("error = %q, want readable_text validation", err)
 	}
 }
+
+func TestGetThreadPreservesEnvelope(t *testing.T) {
+	for _, ret := range []string{"0", "1", "2", "5", "1015", "16019", "987654"} {
+		t.Run(ret, func(t *testing.T) {
+			result, err := GetThread(context.Background(), &GetThreadOptions{ThreadID: "thread", RunID: "run"}, &Runner{Client: getThreadFakeClient{response: `{"ret":"` + ret + `","errmsg":"server message","log_id":"server-log","data":null}`}})
+			if (err != nil) != (ret != "0") {
+				t.Fatalf("err=%v ret=%s", err, ret)
+			}
+			if result == nil || result.Ret != ret || result.Errmsg != "server message" || result.LogID != "server-log" || string(result.RawData) != "null" {
+				t.Fatalf("envelope lost: %#v", result)
+			}
+			raw, marshalErr := sonic.Marshal(result)
+			if marshalErr != nil {
+				t.Fatal(marshalErr)
+			}
+			if strings.Contains(string(raw), "server-log") || strings.Contains(string(raw), "server message") {
+				t.Fatalf("internal envelope leaked: %s", raw)
+			}
+		})
+	}
+}

package/internal/common/watermark.go

@@ -0,0 +1,54 @@
+package common
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/Pippit-dev/pippit-cli/internal/config"
+)
+
+type WatermarkResult struct {
+	Enabled bool `json:"enabled"`
+}
+
+type watermarkResponse struct {
+	Ret    string `json:"ret"`
+	Errmsg string `json:"errmsg"`
+	LogID  string `json:"log_id"`
+	Data   *struct {
+		Enabled *bool `json:"enabled"`
+	} `json:"data"`
+}
+
+// Watermark queries when enabled is nil; updates return the server's readback in the same request.
+func Watermark(ctx context.Context, runner *Runner, enabled *bool) (*WatermarkResult, error) {
+	if runner == nil || runner.Client == nil {
+		return nil, fmt.Errorf("水印设置运行器客户端缺失")
+	}
+	path := config.GetWatermarkSettingPath
+	var body any = struct{}{}
+	if enabled != nil {
+		path = config.UpdateWatermarkSettingPath
+		body = struct {
+			Enabled bool `json:"enabled"`
+		}{Enabled: *enabled}
+	}
+
+	var resp watermarkResponse
+	if err := runner.Client.SendRequest(ctx, path, body, &resp); err != nil {
+		if enabled != nil {
+			return nil, fmt.Errorf("设置水印请求失败，结果可能已生效，请运行 watermark 查询确认: %w", err)
+		}
+		return nil, fmt.Errorf("查询水印设置请求失败: %w", err)
+	}
+	if resp.Ret != "0" {
+		if resp.Errmsg == "" {
+			resp.Errmsg = "未知错误"
+		}
+		return nil, NewLogIDError(fmt.Sprintf("水印设置请求返回失败: ret=%s errmsg=%s", resp.Ret, resp.Errmsg), resp.LogID)
+	}
+	if resp.Data == nil || resp.Data.Enabled == nil {
+		return nil, NewLogIDError("水印设置响应缺少 data.enabled；请查询确认当前状态", resp.LogID)
+	}
+	return &WatermarkResult{Enabled: *resp.Data.Enabled}, nil
+}

package/internal/config/config.go

@@ -21,6 +21,8 @@ const (
 	SubmitMarketingRunPath       = "/api/biz/v1/agent/submit_marketing_run"
 	QueryGenerateVideoResultPath = "/api/biz/v1/agent/query_generate_video_result"
 	GetCreditBalancePath         = "/api/biz/v1/skill/get_credit_balance"
+	GetWatermarkSettingPath      = "/api/biz/v1/skill/mget_user_setting"
+	UpdateWatermarkSettingPath   = "/api/biz/v1/skill/update_user_setting"
 	GetLiteTeamListPath          = "/api/biz/v1/skill/get_lite_team_list"
 	GetAvailableModelListPath    = "/api/biz/v1/skill/get_available_model_list"
 	GetThreadPath                = "/api/biz/v1/skill/get_thread"

package/internal/generate_video/query_result.go

@@ -14,19 +14,22 @@ import (
 )
 
 const (
-	successRunState  = 3
-	failedRunState   = 4
-	canceledRunState = 5
+	successRunState     = 3
+	failedRunState      = 4
+	canceledRunState    = 5
+	interruptedRunState = 9
 )
 
 // Query-result status values. "completed" stays a terminal flag; "status"
 // carries the machine-readable result so integrators need not parse text.
 const (
-	statusRunning   = "running"
-	statusSucceeded = "succeeded"
-	statusFailed    = "failed"
-	statusCanceled  = "canceled"
-	statusUnknown   = "unknown"
+	statusRunning       = "running"
+	statusSucceeded     = "succeeded"
+	statusFailed        = "failed"
+	statusCanceled      = "canceled"
+	statusUnknown       = "unknown"
+	statusInputRequired = "input_required"
+	statusInterrupted   = "interrupted"
 )
 
 // runStateStatus maps the server-side run state (0-9) to the user-facing
@@ -38,16 +41,17 @@ var runStateStatus = map[int]string{
 	3: statusSucceeded,
 	4: statusFailed,
 	5: statusCanceled,
-	6: statusUnknown, // InputRequired
-	7: statusRunning, // Generating
-	8: statusRunning, // Interrupt
-	9: statusUnknown, // HITL_Interrupt
+	6: statusInputRequired,
+	7: statusRunning,     // Generating
+	8: statusRunning,     // Interrupt
+	9: statusInterrupted, // HITL_Interrupt is terminal, unlike Interrupt (8).
 }
 
 var terminalRunStates = map[int]struct{}{
-	successRunState:  {},
-	failedRunState:   {},
-	canceledRunState: {},
+	successRunState:     {},
+	failedRunState:      {},
+	canceledRunState:    {},
+	interruptedRunState: {},
 }
 
 func statusForRunState(state int) string {
@@ -100,12 +104,18 @@ type queryThread struct {
 }
 
 type queryRun struct {
-	RunID        string       `json:"run_id"`
-	State        int          `json:"state"`
-	ErrorMessage string       `json:"error_message"`
-	ErrorMsg     string       `json:"error_msg"`
-	Errmsg       string       `json:"errmsg"`
-	EntryList    []queryEntry `json:"entry_list"`
+	RunID        string           `json:"run_id"`
+	State        int              `json:"state"`
+	ErrorMessage string           `json:"error_message"`
+	ErrorMsg     string           `json:"error_msg"`
+	Errmsg       string           `json:"errmsg"`
+	FailReason   *queryFailReason `json:"fail_reason"`
+	EntryList    []queryEntry     `json:"entry_list"`
+}
+
+type queryFailReason struct {
+	Message string          `json:"message"`
+	Code    json.RawMessage `json:"code"`
 }
 
 type queryEntry struct {
@@ -152,34 +162,41 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		return nil, err
 	}
 
-	threadResult, err := common.GetThread(ctx, &common.GetThreadOptions{
+	threadResult, queryErr := common.GetThread(ctx, &common.GetThreadOptions{
 		ThreadID: opts.ThreadID,
 		RunID:    opts.RunID,
 	}, runner)
-	if err != nil {
-		return nil, queryResultQueryError(err)
-	}
-
 	thread, err := parseQueryThread(threadResult)
 	if err != nil {
+		if queryErr != nil {
+			return queryResultWithoutRun(threadResult, queryErr, opts)
+		}
 		return nil, fmt.Errorf("查询失败：%w", err)
 	}
 
 	run, ok := findQueryRun(thread, opts.RunID)
 	if !ok {
+		if queryErr != nil {
+			return queryResultWithoutRun(threadResult, queryErr, opts)
+		}
 		return nil, fmt.Errorf("查询失败：未找到 run_id=%s 对应的 Run", opts.RunID)
 	}
+	logResolvedQueryError(queryErr, opts)
+	result := &QueryResultResult{
+		Status:    statusForRunState(run.State),
+		Completed: isTerminalRunState(run.State),
+		ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
+		RunID:     opts.RunID,
+		Videos:    []QueryResultVideo{},
+		Images:    []QueryResultImage{},
+	}
 	if run.State != successRunState {
-		result := &QueryResultResult{
-			Status:    statusForRunState(run.State),
-			Completed: isTerminalRunState(run.State),
-			ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
-			RunID:     opts.RunID,
-			Videos:    []QueryResultVideo{},
-			Images:    []QueryResultImage{},
-		}
 		if run.State == failedRunState {
-			result.ErrorMessage = firstNonEmpty(extractQueryErrorMessage(run), "Run 失败")
+			message := extractQueryErrorMessage(run)
+			if message == "" && queryErr != nil {
+				message = queryResultQueryError(queryErr).Error()
+			}
+			result.ErrorMessage = firstNonEmpty(message, "Run 失败")
 		}
 		return result, nil
 	}
@@ -187,20 +204,19 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 	videos := extractQueryVideos(run)
 	images := extractQueryImages(run)
 	if len(videos) == 0 && len(images) == 0 {
-		return nil, fmt.Errorf("下载失败：未找到可下载的产物")
+		return result, fmt.Errorf("下载失败：未找到可下载的产物")
 	}
 
 	downloadDir, err := common.ExpandPath(opts.DownloadDir)
 	if err != nil {
-		return nil, fmt.Errorf("下载失败：解析下载目录失败：%w", err)
+		return result, fmt.Errorf("下载失败：解析下载目录失败：%w", err)
 	}
 
 	usedNames := make(map[string]int, len(videos)+len(images))
 
-	resultVideos := make([]QueryResultVideo, 0, len(videos))
 	for i, video := range videos {
 		if strings.TrimSpace(video.DownloadURL) == "" {
-			return nil, fmt.Errorf("下载失败：第 %d 个视频产物 download_url 为空", i+1)
+			return result, fmt.Errorf("下载失败：第 %d 个视频产物 download_url 为空", i+1)
 		}
 		outputPath := filepath.Join(downloadDir, uniqueQueryResultFileName(videoFileName(video, i+1), usedNames))
 		download, err := common.DownloadResult(ctx, common.DownloadResultOptions{
@@ -209,7 +225,7 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 			Workers:    5,
 		}, runner)
 		if err != nil {
-			return nil, fmt.Errorf("下载失败：%w", err)
+			return result, fmt.Errorf("下载失败：%w", err)
 		}
 		actualOutputPath := outputPath
 		if len(download.Downloaded) > 0 {
@@ -217,7 +233,7 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		} else if len(download.AlreadyExist) > 0 {
 			actualOutputPath = download.AlreadyExist[0]
 		}
-		resultVideos = append(resultVideos, QueryResultVideo{
+		result.Videos = append(result.Videos, QueryResultVideo{
 			DownloadURL: video.DownloadURL,
 			OutputPath:  actualOutputPath,
 			Draft:       video.Draft,
@@ -225,10 +241,9 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		})
 	}
 
-	resultImages := make([]QueryResultImage, 0, len(images))
 	for i, image := range images {
 		if strings.TrimSpace(image.DownloadURL) == "" {
-			return nil, fmt.Errorf("下载失败：第 %d 个图片产物 download_url 为空", i+1)
+			return result, fmt.Errorf("下载失败：第 %d 个图片产物 download_url 为空", i+1)
 		}
 		outputPath := filepath.Join(downloadDir, uniqueQueryResultFileName(imageFileName(image, i+1), usedNames))
 		download, err := common.DownloadResult(ctx, common.DownloadResultOptions{
@@ -237,7 +252,7 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 			Workers:    5,
 		}, runner)
 		if err != nil {
-			return nil, fmt.Errorf("下载失败：%w", err)
+			return result, fmt.Errorf("下载失败：%w", err)
 		}
 		actualOutputPath := outputPath
 		if len(download.Downloaded) > 0 {
@@ -245,25 +260,52 @@ func QueryResult(ctx context.Context, opts *QueryResultOptions, runner *common.R
 		} else if len(download.AlreadyExist) > 0 {
 			actualOutputPath = download.AlreadyExist[0]
 		}
-		resultImages = append(resultImages, QueryResultImage{
+		result.Images = append(result.Images, QueryResultImage{
 			DownloadURL: image.DownloadURL,
 			OutputPath:  actualOutputPath,
 		})
 	}
 
-	return &QueryResultResult{
-		Status:    statusSucceeded,
-		Completed: true,
-		ThreadID:  firstNonEmpty(thread.ThreadID, opts.ThreadID),
-		RunID:     opts.RunID,
-		Videos:    resultVideos,
-		Images:    resultImages,
-	}, nil
+	return result, nil
 }
 
-// queryResultQueryError converts a get_thread failure into a Go error while
-// keeping a clean, customer-facing message. The command layer maps it to
-// status=unknown; the technical envelope stays in the local error log.
+// The legacy endpoint omits data for Failed/Canceled. Only these exact
+// endpoint-specific responses prove a terminal Run; other errors (including
+// ret=5 "获取会话信息失败") describe a failed query, not a failed Run.
+func queryResultWithoutRun(threadResult *common.GetThreadResult, queryErr error, opts *QueryResultOptions) (*QueryResultResult, error) {
+	status := statusUnknown
+	if threadResult != nil && threadResult.Ret == "5" {
+		message := strings.TrimSpace(threadResult.Errmsg)
+		switch {
+		case message == "创作失败" || strings.HasPrefix(message, "创作失败："):
+			status = statusFailed
+		case message == "创作已取消":
+			status = statusCanceled
+		}
+	}
+	if status == statusUnknown {
+		return nil, queryResultQueryError(queryErr)
+	}
+	logResolvedQueryError(queryErr, opts)
+	result := NewQueryResultError(queryResultQueryError(queryErr), opts)
+	result.Status = status
+	result.Completed = true
+	return result, nil
+}
+
+// The command logs returned errors. Errors consumed by a resolved Run must
+// also retain their original ret/errmsg/log_id for diagnosis.
+func logResolvedQueryError(err error, opts *QueryResultOptions) {
+	if err != nil {
+		_ = common.AppendDailyErrorLog("query-result", err, map[string]string{
+			"thread_id": opts.ThreadID,
+			"run_id":    opts.RunID,
+		})
+	}
+}
+
+// queryResultQueryError extracts a customer-facing get_thread error. It is used
+// when no target Run can be resolved, or as the failed Run's fallback reason.
 func queryResultQueryError(err error) error {
 	var logErr *common.LogIDError
 	if errors.As(err, &logErr) {
@@ -279,9 +321,8 @@ func queryResultQueryError(err error) error {
 	return fmt.Errorf("查询失败：%w", err)
 }
 
-// NewQueryResultError builds the user-facing result for a failed query. A
-// failed call never produces a run status, so it reports unknown rather than
-// guessing; the concrete cause stays in error_message.
+// NewQueryResultError builds the user-facing result when no Run could be
+// resolved. The concrete cause stays in error_message.
 func NewQueryResultError(err error, opts *QueryResultOptions) *QueryResultResult {
 	result := &QueryResultResult{
 		Status:       statusUnknown,
@@ -418,6 +459,16 @@ func extractQueryImages(run queryRun) []queryImage {
 }
 
 func extractQueryErrorMessage(run queryRun) string {
+	if run.FailReason != nil {
+		message := strings.TrimSpace(run.FailReason.Message)
+		code := rawMessageString(run.FailReason.Code)
+		if message != "" {
+			if code != "" && code != "0" {
+				return fmt.Sprintf("%s (error_code=%s)", message, code)
+			}
+			return message
+		}
+	}
 	if message := firstNonEmpty(run.ErrorMessage, run.ErrorMsg, run.Errmsg); message != "" {
 		return message
 	}
@@ -435,6 +486,11 @@ func extractQueryErrorMessage(run queryRun) string {
 			}
 		}
 	}
+	if run.FailReason != nil {
+		if code := rawMessageString(run.FailReason.Code); code != "" && code != "0" {
+			return "error_code=" + code
+		}
+	}
 	return ""
 }
 

package/internal/generate_video/query_result_branches_test.go

@@ -0,0 +1,63 @@
+package generate_video
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/Pippit-dev/pippit-cli/internal/common"
+)
+
+func TestQueryFailureReasons(t *testing.T) {
+	for _, tt := range []struct{ name, run, want string }{
+		{"real fail reason", `{"fail_reason":{"message":"视频可能不合规，请修改后重试","code":12023}}`, "视频可能不合规，请修改后重试 (error_code=12023)"},
+		{"message only", `{"fail_reason":{"message":"reason"}}`, "reason"},
+		{"zero code", `{"fail_reason":{"message":"reason","code":0}}`, "reason"},
+		{"code only", `{"fail_reason":{"code":12023}}`, "error_code=12023"},
+		{"empty reason", `{"fail_reason":{"message":" ","code":0}}`, ""},
+		{"null reason", `{"fail_reason":null}`, ""},
+		{"structured reason wins", `{"fail_reason":{"message":"real reason","code":12023},"error_message":"legacy"}`, "real reason (error_code=12023)"},
+		{"legacy message fallback", `{"fail_reason":{"code":12023},"error_message":"legacy"}`, "legacy"},
+		{"error_msg fallback", `{"error_msg":"legacy"}`, "legacy"},
+		{"errmsg fallback", `{"errmsg":"legacy"}`, "legacy"},
+		{"artifact reason", `{"entry_list":[{"artifact":{"content":[{"data":{"error_message":"artifact reason","error_code":99}}]}}]}`, "artifact reason (error_code=99)"},
+		{"artifact code only", `{"entry_list":[{"artifact":{"content":[{"data":{"error_code":"99"}}]}}]}`, "error_code=99"},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			var run queryRun
+			if err := json.Unmarshal([]byte(tt.run), &run); err != nil {
+				t.Fatal(err)
+			}
+			if got := extractQueryErrorMessage(run); got != tt.want {
+				t.Fatalf("got %q want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+type queryErrorClient struct{ err error }
+
+func (c queryErrorClient) SendRequest(context.Context, string, any, any) error { return c.err }
+func (c queryErrorClient) SendRequestWithHeaders(context.Context, string, any, map[string]string, any) error {
+	return c.err
+}
+func (c queryErrorClient) SendMultipartRequest(context.Context, string, map[string]string, common.MultipartFile, any) error {
+	return c.err
+}
+
+func TestQueryResultTransportFailure(t *testing.T) {
+	for _, cause := range []error{context.DeadlineExceeded, context.Canceled, errors.New("connection reset")} {
+		t.Run(cause.Error(), func(t *testing.T) {
+			opts := &QueryResultOptions{ThreadID: "thread", RunID: "run", DownloadDir: t.TempDir()}
+			result, err := QueryResult(context.Background(), opts, &common.Runner{Client: queryErrorClient{cause}})
+			if result != nil || !errors.Is(err, cause) {
+				t.Fatalf("result=%#v err=%v", result, err)
+			}
+			result = NewQueryResultError(err, opts)
+			if result.Status != "unknown" || result.Completed || result.ErrorMessage == "" {
+				t.Fatalf("result=%#v", result)
+			}
+		})
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pippit-dev/cli",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "Pippit CLI",
   "bin": {
     "pippit-tool-cli": "scripts/run.js"

package/skills/short-drama/SKILL.md

@@ -32,6 +32,7 @@ metadata:
 | 用户意图 | CLI | 必读文档 |
 | --- | --- | --- |
 | 查看登录、登录、退出或切换账号 | `status` / `login` / `logout` | [授权](commands/auth.md) |
+| 查询或修改当前账号的 AIGC 水印开关 | `watermark [on\|off]` | [账号水印设置](commands/watermark.md) |
 | 新建短剧、续写、改写、回复后端问题 | `short-drama +submit-run` | [提交任务](commands/submit-run.md) |
 | 上传本地参考剧本 | `short-drama +upload-file` | [上传文件](commands/upload-file.md) |
 | 查询角色、场景、外观、画布、分镜等业务内容 | 同一会话 `short-drama +submit-run`，再用 `get-thread` 获取回答 | [业务内容查询](workflows/creation.md#业务内容查询) |

package/skills/short-drama/commands/watermark.md

@@ -0,0 +1,15 @@
+# 账号 AIGC 水印设置
+
+先用 `pippit-tool-cli watermark --help` 检查命令。缺失时按[安装说明](../scripts/install.md)通过宿主升级，独立 CLI 可执行 `update`；改用升级后的绝对路径重查。
+
+```bash
+pippit-tool-cli watermark       # 查询
+pippit-tool-cli watermark off   # 关闭
+pippit-tool-cli watermark on    # 保留
+```
+
+返回 `{"enabled":true}` 或 `{"enabled":false}`，`true` 表示保留。设置后返回服务端回读状态。
+
+设置与 Web 同步，按当前账号持续生效，与团队选择无关。用户明确要求修改账号设置时才执行 `on/off`；只要求本次视频无水印时，先确认是否接受修改账号默认值。
+
+此开关控制 AIGC 水印，品牌水印与最终下载权益由服务端决定。修改报错或结果未知时先查询确认。

package/skills/xyq-nest-skill/SKILL.md

@@ -45,6 +45,7 @@ metadata:
 | 去除已有视频字幕 | `erase-video-subtitle` | [擦字幕](commands/erase-video-subtitle.md) |
 | 查询已有任务进度、下载生成结果 | `query-result` | [查询结果](commands/query-result.md) |
 | 查询当前空间积分余额、剩余 credits | `get-credit-balance` | [积分](commands/get-credit-balance.md) |
+| 查询或修改当前账号的 AIGC 水印开关 | `watermark [on\|off]` | [账号水印设置](commands/watermark.md) |
 
 - 普通生图、生视频也走对应生成命令，无需用户额外声明“模型直出”。
 - 明确要求修改现有画布或其中节点时优先走 Canvas；普通生图、生视频不自动创建画布。“修改节点提示词”只修改配置，不隐含生成；指定节点生成或导出须先确认当前命令目录有对应能力。