chore: release v1.0.74 (#1990)

* fix: xml_text_overlap_lint.py clarify XML lint input flag error

AGENTS.md

@@ -10,9 +10,10 @@
 ## Build & Test
 
 ```bash
-make build          # Build (runs fetch_meta first)
-make unit-test      # Required before PR (runs with -race where supported, e.g. amd64/arm64)
-make test           # Full: vet + unit + integration
+make build             # Build (runs fetch_meta first)
+make unit-test         # Required before PR (runs with -race where supported, e.g. amd64/arm64)
+make live-skills-test  # Opt-in real Skills CLI tests; runs with isolated user directories
+make test              # Full: vet + unit + integration
 ```
 
 ## Notification Opt-Outs

CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to this project will be documented in this file.
 
+## [v1.0.74] - 2026-07-21
+
+### Features
+
+- **slides**: add history rollback shortcuts (#1714)
+- **base**: support per-record batch updates (#1889)
+
+### Bug Fixes
+
+- preserve slides schema issues
+- allow jq examples in quality gate dry-runs
+- **im**: warn when flag pagination is truncated (#1906)
+- **slides**: warn on text shape overflow
+- **slides**: exempt chart roundtrip attributes from lint
+- **slides**: detect image text occlusion
+- **slides**: clarify xml-text-overlap-lint error for positional argument (#1986)
+
+### Documentation
+
+- clarify drive upload overwrite guidance (#1982)
+
+### Tests
+
+- isolate unit tests from user state (#1883)
+
+### Refactoring
+
+- converge success output through a single Emitter that owns the write (#1899)
+
 ## [v1.0.73] - 2026-07-20
 
 ### Features
@@ -1579,6 +1608,7 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
+[v1.0.74]: https://github.com/larksuite/cli/releases/tag/v1.0.74
 [v1.0.73]: https://github.com/larksuite/cli/releases/tag/v1.0.73
 [v1.0.72]: https://github.com/larksuite/cli/releases/tag/v1.0.72
 [v1.0.71]: https://github.com/larksuite/cli/releases/tag/v1.0.71

Makefile

@@ -23,7 +23,7 @@ PREFIX   ?= /usr/local
 TEST_GOARCH := $(or $(GOARCH),$(shell go env GOARCH))
 RACE_FLAG := $(if $(filter riscv64,$(TEST_GOARCH)),,-race)
 
-.PHONY: all build vet fmt-check script-test test unit-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test
+.PHONY: all build vet fmt-check script-test test unit-test live-skills-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test
 
 all: test
 
@@ -58,6 +58,11 @@ unit-test: fetch_meta
 	go test $(RACE_FLAG) -gcflags="all=-N -l" -count=1 \
 		./cmd/... ./internal/... ./shortcuts/... ./extension/...
 
+live-skills-test: fetch_meta
+	LARKSUITE_CLI_RUN_LIVE_SKILLS_TESTS=1 \
+	go test -v -count=1 ./cmd/update \
+		-run '^TestUpdateCommand_(RealSkillsSyncRewritesState|SkillsSyncColdStart)$$'
+
 # examples-build keeps the shipped plugin-SDK examples compilable. If this
 # breaks, the plugin author guide's "go build ./..." path is broken.
 examples-build:

cmd/api/api.go

@@ -344,20 +344,18 @@ func apiPaginate(ctx context.Context, ac *client.APIClient, request client.RawAp
 
 	switch format {
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
-		pf := output.NewPaginatedFormatter(out, format)
+		emitter := output.NewEmitter(output.EmitterConfig{
+			Out:            out,
+			ErrOut:         errOut,
+			CommandPath:    commandPath,
+			Identity:       string(pagOpts.Identity),
+			NoticeProvider: output.GetNotice,
+		})
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {
 			// Streaming formats intentionally emit each page after that page has
 			// passed safety scanning. A later page may still fail, so callers
 			// must use the exit code to distinguish complete vs partial output.
-			scanResult := output.ScanForSafety(commandPath, items, errOut)
-			if scanResult.Blocked {
-				return scanResult.BlockErr
-			}
-			if scanResult.Alert != nil {
-				output.WriteAlertWarning(errOut, scanResult.Alert)
-			}
-			pf.FormatPage(items)
-			return nil
+			return emitter.StreamPage(items, output.StreamOptions{Format: format.String()})
 		}, pagOpts)
 		if err != nil {
 			return errs.MarkRaw(err)

cmd/api/api_paginate_test.go

@@ -0,0 +1,396 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/client"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/output"
+)
+
+type apiFailOnWriteWriter struct {
+	buf    bytes.Buffer
+	writes int
+	failAt int
+	err    error
+}
+
+func (w *apiFailOnWriteWriter) Write(p []byte) (int, error) {
+	w.writes++
+	if w.writes == w.failAt {
+		return 0, w.err
+	}
+	return w.buf.Write(p)
+}
+
+func newAPIPaginateTestHarness(t *testing.T) (*client.APIClient, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	previousNotice := output.PendingNotice
+	output.PendingNotice = nil
+	t.Cleanup(func() { output.PendingNotice = previousNotice })
+
+	config := &core.CliConfig{
+		AppID:     "test-app",
+		AppSecret: "test-secret",
+		Brand:     core.BrandFeishu,
+	}
+	f, out, errOut, reg := cmdutil.TestFactory(t, config)
+	ac, err := f.NewAPIClientWithConfig(config)
+	if err != nil {
+		t.Fatalf("NewAPIClientWithConfig() error = %v", err)
+	}
+	ac.ErrOut = io.Discard
+	return ac, out, errOut, reg
+}
+
+func apiPaginateRequest() client.RawApiRequest {
+	return client.RawApiRequest{
+		Method: "GET",
+		URL:    "/open-apis/test/v1/items",
+		As:     core.AsBot,
+	}
+}
+
+func assertAPIPaginateJSONBytes(t *testing.T, got []byte, want interface{}) {
+	t.Helper()
+	wantBytes, err := json.MarshalIndent(want, "", "  ")
+	if err != nil {
+		t.Fatalf("marshal expected JSON: %v", err)
+	}
+	wantBytes = append(wantBytes, '\n')
+	if !bytes.Equal(got, wantBytes) {
+		t.Fatalf("stdout bytes mismatch\ngot:\n%s\nwant:\n%s", got, wantBytes)
+	}
+}
+
+func TestAPIPaginate_DefaultAggregatesAllPages(t *testing.T) {
+	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
+	calls := 0
+	wantTokens := []string{"", "next-1", "next-2"}
+	for i, wantToken := range wantTokens {
+		page := i + 1
+		hasMore := page < len(wantTokens)
+		data := map[string]interface{}{
+			"items":    []interface{}{map[string]interface{}{"id": string(rune('0' + page))}},
+			"has_more": hasMore,
+		}
+		if hasMore {
+			data["page_token"] = wantTokens[page]
+		}
+		reg.Register(&httpmock.Stub{
+			URL: "/open-apis/test/v1/items",
+			OnMatch: func(req *http.Request) {
+				calls++
+				if got := req.URL.Query().Get("page_token"); got != wantToken {
+					t.Errorf("request %d page_token = %q, want %q", page, got, wantToken)
+				}
+			},
+			Body: map[string]interface{}{
+				"code": 0,
+				"msg":  "ok",
+				"data": data,
+			},
+		})
+	}
+
+	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+		output.FormatJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{
+			PageLimit: 10,
+			PageDelay: -1,
+		})
+
+	if err != nil {
+		t.Fatalf("apiPaginate() error = %v, want nil", err)
+	}
+	if calls != 3 {
+		t.Fatalf("pagination requests = %d, want 3", calls)
+	}
+	assertAPIPaginateJSONBytes(t, out.Bytes(), output.Envelope{
+		OK:       true,
+		Identity: "bot",
+		Data: map[string]interface{}{
+			"items": []interface{}{
+				map[string]interface{}{"id": "1"},
+				map[string]interface{}{"id": "2"},
+				map[string]interface{}{"id": "3"},
+			},
+			"has_more": false,
+		},
+	})
+	if got := errOut.String(); got != "" {
+		t.Fatalf("stderr bytes = %q, want empty", got)
+	}
+}
+
+func TestAPIPaginate_StreamingFormatsEmitExactMultiPageBytes(t *testing.T) {
+	tests := []struct {
+		name   string
+		format output.Format
+		want   string
+	}{
+		{
+			name:   "ndjson",
+			format: output.FormatNDJSON,
+			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Carol\",\"page_only\":\"ignored\"}\n",
+		},
+		{
+			name:   "table",
+			format: output.FormatTable,
+			want:   "id  name \n──  ─────\n1   Alice\n2   Carol\n",
+		},
+		{
+			name:   "csv",
+			format: output.FormatCSV,
+			want:   "id,name\n1,Alice\n2,Carol\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ac, out, errOut, reg := newAPIPaginateTestHarness(t)
+			reg.Register(&httpmock.Stub{
+				URL: "/open-apis/test/v1/items",
+				Body: map[string]interface{}{
+					"code": 0,
+					"msg":  "ok",
+					"data": map[string]interface{}{
+						"items": []interface{}{
+							map[string]interface{}{"id": "1", "name": "Alice"},
+						},
+						"has_more":   true,
+						"page_token": "next-1",
+					},
+				},
+			})
+			reg.Register(&httpmock.Stub{
+				URL: "/open-apis/test/v1/items",
+				Body: map[string]interface{}{
+					"code": 0,
+					"msg":  "ok",
+					"data": map[string]interface{}{
+						"items": []interface{}{
+							map[string]interface{}{"id": "2", "name": "Carol", "page_only": "ignored"},
+						},
+						"has_more": false,
+					},
+				},
+			})
+
+			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+				tt.format, "", out, errOut, "lark-cli api GET", client.PaginationOptions{
+					PageLimit: 10,
+					PageDelay: -1,
+				})
+
+			if err != nil {
+				t.Fatalf("apiPaginate() error = %v, want nil", err)
+			}
+			if got := out.String(); got != tt.want {
+				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+		})
+	}
+}
+
+func TestAPIPaginate_StreamingWriteFailureStopsFurtherPages(t *testing.T) {
+	ac, _, errOut, reg := newAPIPaginateTestHarness(t)
+	sentinel := errors.New("page write failed")
+	out := &apiFailOnWriteWriter{failAt: 2, err: sentinel}
+	calls := 0
+	for page := 1; page <= 2; page++ {
+		hasMore := true
+		data := map[string]interface{}{
+			"items":    []interface{}{map[string]interface{}{"id": page}},
+			"has_more": hasMore,
+		}
+		if hasMore {
+			data["page_token"] = fmt.Sprintf("next-%d", page)
+		}
+		reg.Register(&httpmock.Stub{
+			URL: "/open-apis/test/v1/items",
+			OnMatch: func(*http.Request) {
+				calls++
+			},
+			Body: map[string]interface{}{
+				"code": 0,
+				"msg":  "ok",
+				"data": data,
+			},
+		})
+	}
+
+	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+		output.FormatNDJSON, "", out, errOut, "lark-cli api GET",
+		client.PaginationOptions{PageLimit: 10, PageDelay: -1})
+
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("apiPaginate() error = %v, want preserved writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("apiPaginate() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	if calls != 2 {
+		t.Fatalf("pagination requests = %d, want 2", calls)
+	}
+	if got, want := out.buf.String(), "{\"id\":1}\n"; got != want {
+		t.Fatalf("stdout bytes = %q, want %q", got, want)
+	}
+}
+
+func TestAPIPaginate_StreamingFormatFallsBackToJSONWithoutList(t *testing.T) {
+	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/test/v1/items",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"name":    "Test User",
+				"user_id": "u123",
+			},
+		},
+	})
+
+	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+		output.FormatNDJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
+
+	if err != nil {
+		t.Fatalf("apiPaginate() error = %v, want nil", err)
+	}
+	assertAPIPaginateJSONBytes(t, out.Bytes(), output.Envelope{
+		OK:       true,
+		Identity: "bot",
+		Data: map[string]interface{}{
+			"name":    "Test User",
+			"user_id": "u123",
+		},
+	})
+	wantWarning := "warning: this API does not return a list, format \"ndjson\" is not supported, falling back to json\n"
+	if got := errOut.String(); got != wantWarning {
+		t.Fatalf("stderr bytes = %q, want %q", got, wantWarning)
+	}
+}
+
+func TestAPIPaginate_BusinessErrorsWriteRawAndAreMarkedRaw(t *testing.T) {
+	businessResponse := map[string]interface{}{
+		"code": 123456,
+		"msg":  "fixture business error",
+		"data": map[string]interface{}{"detail": "business failed"},
+	}
+	tests := []struct {
+		name   string
+		format output.Format
+		jqExpr string
+	}{
+		{name: "jq", format: output.FormatJSON, jqExpr: ".data.items"},
+		{name: "default_json", format: output.FormatJSON},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ac, out, errOut, reg := newAPIPaginateTestHarness(t)
+			reg.Register(&httpmock.Stub{
+				URL:  "/open-apis/test/v1/items",
+				Body: businessResponse,
+			})
+
+			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+				tt.format, tt.jqExpr, out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
+
+			if err == nil {
+				t.Fatal("apiPaginate() error = nil, want business error")
+			}
+			if !errs.IsRaw(err) {
+				t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
+			}
+			assertAPIPaginateJSONBytes(t, out.Bytes(), businessResponse)
+			if bytes.Contains(out.Bytes(), []byte(`"ok": true`)) {
+				t.Fatalf("business-error stdout contains a success envelope:\n%s", out.Bytes())
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+		})
+	}
+}
+
+func TestAPIPaginate_TransportErrorsAreMarkedRaw(t *testing.T) {
+	tests := []struct {
+		name   string
+		format output.Format
+		jqExpr string
+	}{
+		{name: "jq_paginate_all", format: output.FormatJSON, jqExpr: ".data.items"},
+		{name: "stream_pages", format: output.FormatNDJSON},
+		{name: "default_paginate_all", format: output.FormatJSON},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ac, out, errOut, _ := newAPIPaginateTestHarness(t)
+
+			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+				tt.format, tt.jqExpr, out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
+
+			if err == nil {
+				t.Fatal("apiPaginate() error = nil, want transport error")
+			}
+			if !errs.IsRaw(err) {
+				t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
+			}
+			if got := out.String(); got != "" {
+				t.Fatalf("stdout bytes = %q, want empty", got)
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+		})
+	}
+}
+
+func TestAPIPaginate_StreamBusinessErrorIsMarkedRaw(t *testing.T) {
+	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/test/v1/items",
+		Body: map[string]interface{}{
+			"code": 123456,
+			"msg":  "fixture business error",
+			"data": map[string]interface{}{},
+		},
+	})
+
+	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
+		output.FormatNDJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
+
+	if err == nil {
+		t.Fatal("apiPaginate() error = nil, want business error")
+	}
+	if !errs.IsRaw(err) {
+		t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
+	}
+	if got := out.String(); got != "" {
+		t.Fatalf("stdout bytes = %q, want empty", got)
+	}
+	if got := errOut.String(); got != "" {
+		t.Fatalf("stderr bytes = %q, want empty", got)
+	}
+}

cmd/api/api_test.go

@@ -352,6 +352,9 @@ func TestApiCmd_OutputAndPageAllConflict(t *testing.T) {
 }
 
 func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
+	dir := t.TempDir()
+	cmdutil.TestChdir(t, dir)
+
 	f, stdout, stderr, reg := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app-bin", AppSecret: "test-secret-bin", Brand: core.BrandFeishu,
 	})
@@ -371,8 +374,33 @@ func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
 	if !strings.Contains(stderr.String(), "binary response detected") {
 		t.Error("expected binary response hint in stderr")
 	}
-	if !strings.Contains(stdout.String(), "saved_path") {
-		t.Error("expected saved_path in output")
+	var got map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatalf("stdout is not JSON: %v\nstdout:\n%s", err, stdout.String())
+	}
+	savedPath, _ := got["saved_path"].(string)
+	if savedPath == "" {
+		t.Fatalf("saved_path missing from output: %#v", got)
+	}
+	// The file must land inside the temporary cwd — this pins the isolation
+	// contract: rolling back TestChdir would leave download.bin in the repo.
+	wantDir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	gotDir, err := filepath.EvalSymlinks(filepath.Dir(savedPath))
+	if err != nil {
+		t.Fatalf("saved_path %q dir not resolvable: %v", savedPath, err)
+	}
+	if gotDir != wantDir {
+		t.Errorf("saved_path %q is outside temp cwd %q", savedPath, wantDir)
+	}
+	content, err := os.ReadFile(savedPath)
+	if err != nil {
+		t.Fatalf("read saved file: %v", err)
+	}
+	if string(content) != "fake-binary-content" {
+		t.Errorf("saved file content = %q, want %q", content, "fake-binary-content")
 	}
 }
 

cmd/auth/testmain_test.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package auth
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/larksuite/cli/internal/registry/registrytest"
+)
+
+// TestMain isolates auth command tests from the host machine: config, logs
+// and the registry cache are redirected to a temp dir, then the registry is
+// seeded from the tracked fixture and initialized eagerly. Domain-completion
+// tests read the registry, so without seeding a clean checkout would either
+// fail or trigger a remote metadata fetch.
+//
+// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
+// m.Run before exiting.
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-cmd-auth-test-*")
+	if err != nil {
+		println("cmd/auth test setup: MkdirTemp failed:", err.Error())
+		os.Exit(2)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
+		println("cmd/auth test setup: Setenv failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_LOG_DIR", filepath.Join(root, "logs")); err != nil {
+		println("cmd/auth test setup: Setenv failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	if err := registrytest.Seed(root); err != nil {
+		println("cmd/auth test setup: registrytest.Seed failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	code := m.Run()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

cmd/root_integration_test.go

@@ -371,10 +371,11 @@ func TestIntegration_StrictModeUser_ProfileOverride_ShortcutExplicitBotReturnsEn
 
 func TestIntegration_StrictModeBot_ProfileOverride_ServiceExplicitUserReturnsEnvelope(t *testing.T) {
 	f, stdout, stderr := newStrictModeDefaultFactory(t, "target", core.StrictModeBot)
-	rootCmd := buildStrictModeIntegrationRootCmd(t, f)
+	catalog := strictModeFixtureCatalog()
+	rootCmd := buildStrictModeIntegrationRootCmdWithCatalog(t, f, &catalog)
 
 	code := executeRootIntegration(t, f, rootCmd, []string{
-		"im", "chats", "get", "--params", `{"chat_id":"oc_test"}`, "--as", "user", "--dry-run",
+		"fixture", "things", "create", "--data", `{"name":"probe"}`, "--as", "user", "--dry-run",
 	})
 
 	if code != output.ExitValidation {

cmd/service/service.go

@@ -707,20 +707,18 @@ func servicePaginate(ctx context.Context, ac *client.APIClient, request client.R
 
 	switch format {
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
-		pf := output.NewPaginatedFormatter(out, format)
+		emitter := output.NewEmitter(output.EmitterConfig{
+			Out:            out,
+			ErrOut:         errOut,
+			CommandPath:    commandPath,
+			Identity:       string(pagOpts.Identity),
+			NoticeProvider: output.GetNotice,
+		})
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {
 			// Streaming formats intentionally emit each page after that page has
 			// passed safety scanning. A later page may still fail, so callers
 			// must use the exit code to distinguish complete vs partial output.
-			scanResult := output.ScanForSafety(commandPath, items, errOut)
-			if scanResult.Blocked {
-				return scanResult.BlockErr
-			}
-			if scanResult.Alert != nil {
-				output.WriteAlertWarning(errOut, scanResult.Alert)
-			}
-			pf.FormatPage(items)
-			return nil
+			return emitter.StreamPage(items, output.StreamOptions{Format: format.String()})
 		}, pagOpts)
 		if err != nil {
 			return err

cmd/service/service_paginate_test.go

@@ -0,0 +1,400 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package service
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/client"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/output"
+)
+
+type serviceFailOnWriteWriter struct {
+	buf    bytes.Buffer
+	writes int
+	failAt int
+	err    error
+}
+
+func (w *serviceFailOnWriteWriter) Write(p []byte) (int, error) {
+	w.writes++
+	if w.writes == w.failAt {
+		return 0, w.err
+	}
+	return w.buf.Write(p)
+}
+
+func newServicePaginateTestHarness(t *testing.T) (*client.APIClient, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	previousNotice := output.PendingNotice
+	output.PendingNotice = nil
+	t.Cleanup(func() { output.PendingNotice = previousNotice })
+
+	config := &core.CliConfig{
+		AppID:     "test-app",
+		AppSecret: "test-secret",
+		Brand:     core.BrandFeishu,
+	}
+	f, out, errOut, reg := cmdutil.TestFactory(t, config)
+	ac, err := f.NewAPIClientWithConfig(config)
+	if err != nil {
+		t.Fatalf("NewAPIClientWithConfig() error = %v", err)
+	}
+	ac.ErrOut = io.Discard
+	return ac, out, errOut, reg
+}
+
+func servicePaginateRequest() client.RawApiRequest {
+	return client.RawApiRequest{
+		Method: "GET",
+		URL:    "/open-apis/test/v1/items",
+		As:     core.AsBot,
+	}
+}
+
+func assertServicePaginateJSONBytes(t *testing.T, got []byte, want interface{}) {
+	t.Helper()
+	wantBytes, err := json.MarshalIndent(want, "", "  ")
+	if err != nil {
+		t.Fatalf("marshal expected JSON: %v", err)
+	}
+	wantBytes = append(wantBytes, '\n')
+	if !bytes.Equal(got, wantBytes) {
+		t.Fatalf("stdout bytes mismatch\ngot:\n%s\nwant:\n%s", got, wantBytes)
+	}
+}
+
+func TestServicePaginate_DefaultAggregatesAllPages(t *testing.T) {
+	ac, out, errOut, reg := newServicePaginateTestHarness(t)
+	calls := 0
+	wantTokens := []string{"", "next-1", "next-2"}
+	for i, wantToken := range wantTokens {
+		page := i + 1
+		hasMore := page < len(wantTokens)
+		data := map[string]interface{}{
+			"items":    []interface{}{map[string]interface{}{"id": string(rune('0' + page))}},
+			"has_more": hasMore,
+		}
+		if hasMore {
+			data["page_token"] = wantTokens[page]
+		}
+		reg.Register(&httpmock.Stub{
+			URL: "/open-apis/test/v1/items",
+			OnMatch: func(req *http.Request) {
+				calls++
+				if got := req.URL.Query().Get("page_token"); got != wantToken {
+					t.Errorf("request %d page_token = %q, want %q", page, got, wantToken)
+				}
+			},
+			Body: map[string]interface{}{
+				"code": 0,
+				"msg":  "ok",
+				"data": data,
+			},
+		})
+	}
+
+	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+		output.FormatJSON, "", out, errOut, "lark-cli test items list", client.PaginationOptions{
+			PageLimit: 10,
+			PageDelay: -1,
+		}, ac.CheckResponse)
+
+	if err != nil {
+		t.Fatalf("servicePaginate() error = %v, want nil", err)
+	}
+	if calls != 3 {
+		t.Fatalf("pagination requests = %d, want 3", calls)
+	}
+	assertServicePaginateJSONBytes(t, out.Bytes(), output.Envelope{
+		OK:       true,
+		Identity: "bot",
+		Data: map[string]interface{}{
+			"items": []interface{}{
+				map[string]interface{}{"id": "1"},
+				map[string]interface{}{"id": "2"},
+				map[string]interface{}{"id": "3"},
+			},
+			"has_more": false,
+		},
+	})
+	if got := errOut.String(); got != "" {
+		t.Fatalf("stderr bytes = %q, want empty", got)
+	}
+}
+
+func TestServicePaginate_StreamingFormatsEmitExactMultiPageBytes(t *testing.T) {
+	tests := []struct {
+		name   string
+		format output.Format
+		want   string
+	}{
+		{
+			name:   "ndjson",
+			format: output.FormatNDJSON,
+			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Carol\",\"page_only\":\"ignored\"}\n",
+		},
+		{
+			name:   "table",
+			format: output.FormatTable,
+			want:   "id  name \n──  ─────\n1   Alice\n2   Carol\n",
+		},
+		{
+			name:   "csv",
+			format: output.FormatCSV,
+			want:   "id,name\n1,Alice\n2,Carol\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ac, out, errOut, reg := newServicePaginateTestHarness(t)
+			reg.Register(&httpmock.Stub{
+				URL: "/open-apis/test/v1/items",
+				Body: map[string]interface{}{
+					"code": 0,
+					"msg":  "ok",
+					"data": map[string]interface{}{
+						"items": []interface{}{
+							map[string]interface{}{"id": "1", "name": "Alice"},
+						},
+						"has_more":   true,
+						"page_token": "next-1",
+					},
+				},
+			})
+			reg.Register(&httpmock.Stub{
+				URL: "/open-apis/test/v1/items",
+				Body: map[string]interface{}{
+					"code": 0,
+					"msg":  "ok",
+					"data": map[string]interface{}{
+						"items": []interface{}{
+							map[string]interface{}{"id": "2", "name": "Carol", "page_only": "ignored"},
+						},
+						"has_more": false,
+					},
+				},
+			})
+
+			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+				tt.format, "", out, errOut, "lark-cli test items list", client.PaginationOptions{
+					PageLimit: 10,
+					PageDelay: -1,
+				}, ac.CheckResponse)
+
+			if err != nil {
+				t.Fatalf("servicePaginate() error = %v, want nil", err)
+			}
+			if got := out.String(); got != tt.want {
+				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+		})
+	}
+}
+
+func TestServicePaginate_StreamingWriteFailureStopsFurtherPages(t *testing.T) {
+	ac, _, errOut, reg := newServicePaginateTestHarness(t)
+	sentinel := errors.New("page write failed")
+	out := &serviceFailOnWriteWriter{failAt: 2, err: sentinel}
+	calls := 0
+	for page := 1; page <= 2; page++ {
+		hasMore := true
+		data := map[string]interface{}{
+			"items":    []interface{}{map[string]interface{}{"id": page}},
+			"has_more": hasMore,
+		}
+		if hasMore {
+			data["page_token"] = fmt.Sprintf("next-%d", page)
+		}
+		reg.Register(&httpmock.Stub{
+			URL: "/open-apis/test/v1/items",
+			OnMatch: func(*http.Request) {
+				calls++
+			},
+			Body: map[string]interface{}{
+				"code": 0,
+				"msg":  "ok",
+				"data": data,
+			},
+		})
+	}
+
+	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+		output.FormatNDJSON, "", out, errOut, "lark-cli test items list",
+		client.PaginationOptions{PageLimit: 10, PageDelay: -1}, ac.CheckResponse)
+
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("servicePaginate() error = %v, want preserved writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("servicePaginate() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	if calls != 2 {
+		t.Fatalf("pagination requests = %d, want 2", calls)
+	}
+	if got, want := out.buf.String(), "{\"id\":1}\n"; got != want {
+		t.Fatalf("stdout bytes = %q, want %q", got, want)
+	}
+}
+
+func TestServicePaginate_StreamingFormatFallsBackToJSONWithoutList(t *testing.T) {
+	ac, out, errOut, reg := newServicePaginateTestHarness(t)
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/test/v1/items",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"name":    "Test User",
+				"user_id": "u123",
+			},
+		},
+	})
+
+	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+		output.FormatNDJSON, "", out, errOut, "lark-cli test items get",
+		client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
+
+	if err != nil {
+		t.Fatalf("servicePaginate() error = %v, want nil", err)
+	}
+	assertServicePaginateJSONBytes(t, out.Bytes(), output.Envelope{
+		OK:       true,
+		Identity: "bot",
+		Data: map[string]interface{}{
+			"name":    "Test User",
+			"user_id": "u123",
+		},
+	})
+	wantWarning := "warning: this API does not return a list, format \"ndjson\" is not supported, falling back to json\n"
+	if got := errOut.String(); got != wantWarning {
+		t.Fatalf("stderr bytes = %q, want %q", got, wantWarning)
+	}
+}
+
+func TestServicePaginate_BusinessErrorsWriteRawAndRemainUnmarked(t *testing.T) {
+	businessResponse := map[string]interface{}{
+		"code": 123456,
+		"msg":  "fixture business error",
+		"data": map[string]interface{}{"detail": "business failed"},
+	}
+	tests := []struct {
+		name   string
+		format output.Format
+		jqExpr string
+	}{
+		{name: "jq", format: output.FormatJSON, jqExpr: ".data.items"},
+		{name: "default_json", format: output.FormatJSON},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ac, out, errOut, reg := newServicePaginateTestHarness(t)
+			reg.Register(&httpmock.Stub{
+				URL:  "/open-apis/test/v1/items",
+				Body: businessResponse,
+			})
+
+			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+				tt.format, tt.jqExpr, out, errOut, "lark-cli test items list",
+				client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
+
+			if err == nil {
+				t.Fatal("servicePaginate() error = nil, want business error")
+			}
+			if errs.IsRaw(err) {
+				t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
+			}
+			assertServicePaginateJSONBytes(t, out.Bytes(), businessResponse)
+			if bytes.Contains(out.Bytes(), []byte(`"ok": true`)) {
+				t.Fatalf("business-error stdout contains a success envelope:\n%s", out.Bytes())
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+		})
+	}
+}
+
+func TestServicePaginate_TransportErrorsRemainUnmarked(t *testing.T) {
+	tests := []struct {
+		name   string
+		format output.Format
+		jqExpr string
+	}{
+		{name: "jq_paginate_all", format: output.FormatJSON, jqExpr: ".data.items"},
+		{name: "stream_pages", format: output.FormatNDJSON},
+		{name: "default_paginate_all", format: output.FormatJSON},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ac, out, errOut, _ := newServicePaginateTestHarness(t)
+
+			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+				tt.format, tt.jqExpr, out, errOut, "lark-cli test items list",
+				client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
+
+			if err == nil {
+				t.Fatal("servicePaginate() error = nil, want transport error")
+			}
+			if errs.IsRaw(err) {
+				t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
+			}
+			if got := out.String(); got != "" {
+				t.Fatalf("stdout bytes = %q, want empty", got)
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+		})
+	}
+}
+
+func TestServicePaginate_StreamBusinessErrorRemainsUnmarked(t *testing.T) {
+	ac, out, errOut, reg := newServicePaginateTestHarness(t)
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/test/v1/items",
+		Body: map[string]interface{}{
+			"code": 123456,
+			"msg":  "fixture business error",
+			"data": map[string]interface{}{},
+		},
+	})
+
+	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
+		output.FormatNDJSON, "", out, errOut, "lark-cli test items list",
+		client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
+
+	if err == nil {
+		t.Fatal("servicePaginate() error = nil, want business error")
+	}
+	if errs.IsRaw(err) {
+		t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
+	}
+	if got := out.String(); got != "" {
+		t.Fatalf("stdout bytes = %q, want empty", got)
+	}
+	if got := errOut.String(); got != "" {
+		t.Fatalf("stderr bytes = %q, want empty", got)
+	}
+}

cmd/service/testmain_test.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package service
+
+import (
+	"os"
+	"testing"
+
+	"github.com/larksuite/cli/internal/registry/registrytest"
+)
+
+// TestMain isolates service command tests from the host machine: config (and
+// the registry cache under it) is redirected to a temp dir, then the registry
+// is seeded from the tracked fixture and initialized eagerly. Tests pass on a
+// clean checkout with no network, no `make fetch_meta`, and no user cache.
+//
+// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
+// m.Run before exiting.
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-cmd-service-test-*")
+	if err != nil {
+		println("cmd/service test setup: MkdirTemp failed:", err.Error())
+		os.Exit(2)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", root); err != nil {
+		println("cmd/service test setup: Setenv failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	if err := registrytest.Seed(root); err != nil {
+		println("cmd/service test setup: registrytest.Seed failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	code := m.Run()
+	os.RemoveAll(root)
+	os.Exit(code)
+}

cmd/startup_brand_test.go

@@ -5,6 +5,7 @@ package cmd
 
 import (
 	"context"
+	"flag"
 	"fmt"
 	"os"
 	"os/exec"
@@ -12,11 +13,34 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/google/uuid"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/registry"
 )
 
+const startupBrandHelperEnv = "GO_TEST_STARTUP_BRAND_HELPER"
+
+var _ = flag.String("startup-brand-helper", "", "internal startup brand test helper nonce")
+
+func isStartupBrandHelper() bool {
+	return startupBrandHelperEnabled(os.Getenv(startupBrandHelperEnv), startupBrandHelperNonce(os.Args))
+}
+
+func startupBrandHelperEnabled(envNonce, argNonce string) bool {
+	return envNonce != "" && envNonce == argNonce
+}
+
+func startupBrandHelperNonce(args []string) string {
+	const prefix = "-startup-brand-helper="
+	for _, arg := range args {
+		if strings.HasPrefix(arg, prefix) {
+			return strings.TrimPrefix(arg, prefix)
+		}
+	}
+	return ""
+}
+
 func TestResolveStartupBrand_Precedence(t *testing.T) {
 	tmp := t.TempDir()
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
@@ -54,7 +78,7 @@ func TestResolveStartupBrand_Precedence(t *testing.T) {
 // sync.Once, so the brand must be injected before the first catalog access.
 // It runs in a subprocess because the registry is process-global.
 func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
-	if os.Getenv("GO_TEST_STARTUP_BRAND_HELPER") == "1" {
+	if isStartupBrandHelper() {
 		// Helper: replicate Execute()'s build wiring with a lark config.
 		buildInternal(
 			context.Background(), cmdutil.InvocationContext{},
@@ -71,9 +95,11 @@ func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	nonce := uuid.NewString()
+	t.Setenv(startupBrandHelperEnv, nonce)
 	cmd := exec.Command(os.Args[0], "-test.run", "TestStartupBrandReachesRegistry_RealStartupOrder")
+	cmd.Args = append(cmd.Args, "-startup-brand-helper="+nonce)
 	cmd.Env = append(os.Environ(),
-		"GO_TEST_STARTUP_BRAND_HELPER=1",
 		"LARKSUITE_CLI_CONFIG_DIR="+tmp,
 		"LARKSUITE_CLI_REMOTE_META=off", // no network during the subprocess build
 	)
@@ -85,3 +111,33 @@ func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
 		t.Errorf("registry brand after real startup order = %s, want lark", out)
 	}
 }
+
+func TestStartupBrandHelperRequiresMatchingCommandNonce(t *testing.T) {
+	for _, tt := range []struct {
+		name     string
+		envNonce string
+		argNonce string
+		want     bool
+	}{
+		{name: "neither set"},
+		{name: "ambient environment only", envNonce: "ambient"},
+		{name: "command argument only", argNonce: "command"},
+		{name: "mismatch", envNonce: "ambient", argNonce: "command"},
+		{name: "matching", envNonce: "nonce", argNonce: "nonce", want: true},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := startupBrandHelperEnabled(tt.envNonce, tt.argNonce); got != tt.want {
+				t.Fatalf("startupBrandHelperEnabled() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestStartupBrandHelperNonce(t *testing.T) {
+	if got := startupBrandHelperNonce([]string{"test", "-test.run", "brand"}); got != "" {
+		t.Fatalf("startupBrandHelperNonce() = %q, want empty", got)
+	}
+	if got := startupBrandHelperNonce([]string{"test", "-startup-brand-helper=nonce"}); got != "nonce" {
+		t.Fatalf("startupBrandHelperNonce() = %q, want nonce", got)
+	}
+}

cmd/testmain_test.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"os"
+	"testing"
+
+	"github.com/larksuite/cli/internal/registry/registrytest"
+)
+
+// TestMain isolates command-tree tests from the host machine: config (and the
+// registry cache under it) is redirected to a temp dir, then the registry is
+// seeded from the tracked fixture and initialized eagerly. Tests pass on a
+// clean checkout with no network, no `make fetch_meta`, and no user cache.
+//
+// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
+// m.Run before exiting.
+func TestMain(m *testing.M) {
+	if isStartupBrandHelper() {
+		// Re-exec helper subprocess (startup_brand_test.go): the parent test
+		// already provides an isolated config dir and disables remote metadata,
+		// and the helper must own the first registry Init to prove the startup
+		// order — do not seed or eagerly initialize here.
+		os.Exit(m.Run())
+	}
+	root, err := os.MkdirTemp("", "lark-cli-cmd-test-*")
+	if err != nil {
+		println("cmd test setup: MkdirTemp failed:", err.Error())
+		os.Exit(2)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", root); err != nil {
+		println("cmd test setup: Setenv failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	if err := registrytest.Seed(root); err != nil {
+		println("cmd test setup: registrytest.Seed failed:", err.Error())
+		os.RemoveAll(root)
+		os.Exit(2)
+	}
+	code := m.Run()
+	os.RemoveAll(root)
+	os.Exit(code)
+}

cmd/update/testmain_test.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdupdate
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-update-test-*")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
+		panic(err)
+	}
+	code := m.Run()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

cmd/update/update_test.go

@@ -24,6 +24,8 @@ import (
 	"github.com/larksuite/cli/internal/skillscheck"
 )
 
+const runLiveSkillsTestsEnv = "LARKSUITE_CLI_RUN_LIVE_SKILLS_TESTS"
+
 // newTestFactory creates a test factory with minimal config.
 func newTestFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffer) {
 	t.Helper()
@@ -31,13 +33,17 @@ func newTestFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffe
 	return f, stdout, stderr
 }
 
-// mockDetect sets up newUpdater to return an Updater with the given DetectResult.
+// mockDetect sets up newUpdater to return an Updater with the given DetectResult
+// and fully mocked skills operations. Tests that only care about install-method
+// detection must never fall through to the real npx skills CLI.
 func mockDetect(t *testing.T, result selfupdate.DetectResult) {
 	t.Helper()
 	origNew := newUpdater
 	newUpdater = func() *selfupdate.Updater {
 		u := selfupdate.New()
 		u.DetectOverride = func() selfupdate.DetectResult { return result }
+		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
+		u.SkillsCommandOverride = successfulSkillsCommand()
 		return u
 	}
 	t.Cleanup(func() { newUpdater = origNew })
@@ -104,6 +110,18 @@ func successfulSkillsCommand() func(args ...string) *selfupdate.NpmResult {
 	}
 }
 
+func mockSkillsSync(t *testing.T) {
+	t.Helper()
+	origNew := newUpdater
+	newUpdater = func() *selfupdate.Updater {
+		u := selfupdate.New()
+		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
+		u.SkillsCommandOverride = successfulSkillsCommand()
+		return u
+	}
+	t.Cleanup(func() { newUpdater = origNew })
+}
+
 func TestUpdatePnpm_JSON(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _ := newTestFactory(t)
@@ -228,6 +246,9 @@ func TestNormalizeVersion(t *testing.T) {
 }
 
 func TestUpdateAlreadyUpToDate_JSON(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	mockSkillsSync(t)
+
 	f, stdout, _ := newTestFactory(t)
 
 	cmd := NewCmdUpdate(f)
@@ -256,6 +277,9 @@ func TestUpdateAlreadyUpToDate_JSON(t *testing.T) {
 }
 
 func TestUpdateAlreadyUpToDate_Human(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	mockSkillsSync(t)
+
 	f, _, stderr := newTestFactory(t)
 
 	cmd := NewCmdUpdate(f)
@@ -281,6 +305,7 @@ func TestUpdateAlreadyUpToDate_Human(t *testing.T) {
 }
 
 func TestUpdateManual_JSON(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _ := newTestFactory(t)
 	cmd := NewCmdUpdate(f)
 	cmd.SetArgs([]string{"--json"})
@@ -312,6 +337,7 @@ func TestUpdateManual_JSON(t *testing.T) {
 }
 
 func TestUpdateManual_Human(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, _, stderr := newTestFactory(t)
 	cmd := NewCmdUpdate(f)
 	cmd.SetArgs([]string{})
@@ -1161,6 +1187,7 @@ func TestRunSkillsAndState_DedupForceBypass(t *testing.T) {
 	}
 	called := false
 	updater := &selfupdate.Updater{
+		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
 		SkillsCommandOverride: func(args ...string) *selfupdate.NpmResult {
 			called = true
 			return successfulSkillsCommand()(args...)
@@ -1177,7 +1204,10 @@ func TestRunSkillsAndState_DedupForceBypass(t *testing.T) {
 
 func TestRunSkillsAndState_SuccessWritesState(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	updater := &selfupdate.Updater{SkillsCommandOverride: successfulSkillsCommand()}
+	updater := &selfupdate.Updater{
+		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
+		SkillsCommandOverride:    successfulSkillsCommand(),
+	}
 	got := runSkillsAndState(updater, newTestIO(), "1.0.21", false)
 	if got == nil || got.Err != nil {
 		t.Fatalf("runSkillsAndState() = %+v, want non-nil with nil Err", got)
@@ -1197,6 +1227,7 @@ func TestRunSkillsAndState_FailureKeepsOldState(t *testing.T) {
 		t.Fatal(err)
 	}
 	updater := &selfupdate.Updater{
+		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
 		SkillsCommandOverride: func(args ...string) *selfupdate.NpmResult {
 			r := &selfupdate.NpmResult{}
 			r.Err = fmt.Errorf("npx failed")
@@ -1513,28 +1544,133 @@ func TestEmitSkillsTextHints_Success(t *testing.T) {
 	}
 }
 
-// TestUpdateCommand_RealSkillsSyncRewritesState is a live integration test that
-// verifies "lark-cli update" correctly triggers skills sync and rewrites the
-// state file. It calls the real npx skills CLI, so the test is skipped when
-// npx or the skills registry is unavailable (e.g. no network or fork PRs).
-func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
-	// Phase 1: Verify the real npx skills CLI is available; skip otherwise.
-	if _, err := exec.LookPath("npx"); err != nil {
-		t.Skipf("npx not found in PATH: %v", err)
+// liveSkillsIsolationEnv is the single source of truth for the user-state
+// directories a live skills test must redirect under the temporary home. It
+// covers the CLI's own config, the agent homes the skills CLI installs into,
+// the XDG dirs it derives paths from (XDG_STATE_HOME holds its global
+// .skill-lock.json), and the npm/npx overrides that take precedence over
+// HOME-derived defaults (both cases: npm reads npm_config_* case-insensitively).
+func liveSkillsIsolationEnv(home string) map[string]string {
+	return map[string]string{
+		"HOME":                     home,
+		"USERPROFILE":              home,
+		"APPDATA":                  filepath.Join(home, "AppData", "Roaming"),
+		"LOCALAPPDATA":             filepath.Join(home, "AppData", "Local"),
+		"XDG_CONFIG_HOME":          filepath.Join(home, ".config"),
+		"XDG_DATA_HOME":            filepath.Join(home, ".local", "share"),
+		"XDG_STATE_HOME":           filepath.Join(home, ".local", "state"),
+		"CODEX_HOME":               filepath.Join(home, ".codex"),
+		"CLAUDE_CONFIG_DIR":        filepath.Join(home, ".claude"),
+		"LARKSUITE_CLI_CONFIG_DIR": filepath.Join(home, ".lark-cli"),
+		"npm_config_cache":         filepath.Join(home, ".npm-cache"),
+		"NPM_CONFIG_CACHE":         filepath.Join(home, ".npm-cache"),
+		"npm_config_prefix":        filepath.Join(home, ".npm-global"),
+		"NPM_CONFIG_PREFIX":        filepath.Join(home, ".npm-global"),
+		"npm_config_userconfig":    filepath.Join(home, ".npmrc"),
+		"NPM_CONFIG_USERCONFIG":    filepath.Join(home, ".npmrc"),
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
+}
+
+func prepareLiveSkillsIntegration(t *testing.T) string {
+	t.Helper()
+	if os.Getenv(runLiveSkillsTestsEnv) != "1" {
+		t.Skipf("live skills integration test disabled; set %s=1 to run", runLiveSkillsTestsEnv)
+	}
+
+	home := t.TempDir()
+	for key, value := range liveSkillsIsolationEnv(home) {
+		t.Setenv(key, value)
+	}
+	return home
+}
+
+func TestPrepareLiveSkillsIntegration(t *testing.T) {
+	reachedAfterGate := false
+	t.Run("requires explicit opt-in", func(t *testing.T) {
+		t.Setenv(runLiveSkillsTestsEnv, "")
+		prepareLiveSkillsIntegration(t)
+		reachedAfterGate = true
+	})
+	if reachedAfterGate {
+		t.Fatal("prepareLiveSkillsIntegration continued without explicit opt-in")
+	}
+
+	t.Run("isolates user directories", func(t *testing.T) {
+		t.Setenv(runLiveSkillsTestsEnv, "1")
+		home := prepareLiveSkillsIntegration(t)
+		// Pin the isolation contract by key: removing a variable from
+		// liveSkillsIsolationEnv must fail this list, and every redirected
+		// value must live under the temporary home.
+		required := []string{
+			"HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA",
+			"XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME",
+			"CODEX_HOME", "CLAUDE_CONFIG_DIR", "LARKSUITE_CLI_CONFIG_DIR",
+			"npm_config_cache", "NPM_CONFIG_CACHE",
+			"npm_config_prefix", "NPM_CONFIG_PREFIX",
+			"npm_config_userconfig", "NPM_CONFIG_USERCONFIG",
+		}
+		env := liveSkillsIsolationEnv(home)
+		for _, key := range required {
+			expected, ok := env[key]
+			if !ok {
+				t.Errorf("liveSkillsIsolationEnv dropped required key %s", key)
+				continue
+			}
+			if !strings.HasPrefix(expected, home) {
+				t.Errorf("%s = %q escapes temporary home %q", key, expected, home)
+			}
+			if got := os.Getenv(key); got != expected {
+				t.Errorf("%s = %q, want %q", key, got, expected)
+			}
+		}
+	})
+}
+
+// seedLiveSkillsGlobal verifies the real npx skills CLI is reachable, installs
+// lark-calendar into the isolated global skills dir, and returns the parsed
+// global skills list. The caller opted in explicitly, so every missing
+// precondition is a hard failure — skipping would report "nothing verified"
+// as a green run.
+func seedLiveSkillsGlobal(t *testing.T) []string {
+	t.Helper()
+	if _, err := exec.LookPath("npx"); err != nil {
+		t.Fatalf("live skills tests opted in but npx not found in PATH: %v", err)
+	}
+	// Three sequential npx runs against a cold cache (the isolated home starts
+	// empty) can be slow; with Fatal-on-timeout semantics the budget errs on
+	// the generous side.
+	ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
 	defer cancel()
 	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "--list").Run(); err != nil {
-		t.Skipf("real skills CLI unavailable: %v", err)
+		t.Fatalf("live skills tests opted in but real skills CLI unavailable: %v", err)
+	}
+	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "-s", "lark-calendar", "-g", "-y").Run(); err != nil {
+		t.Fatalf("failed to seed isolated global skills: %v", err)
 	}
 	globalOut, err := exec.CommandContext(ctx, "npx", "-y", "skills", "ls", "-g").Output()
 	if err != nil {
-		t.Skipf("real global skills CLI unavailable: %v", err)
+		t.Fatalf("real global skills CLI unavailable: %v", err)
 	}
 	localSkills := skillscheck.ParseSkillsList(string(globalOut))
-	if err := ctx.Err(); err != nil {
-		t.Skipf("real skills CLI availability check timed out: %v", err)
+	if len(localSkills) == 0 {
+		t.Fatal("seeded lark-calendar but global skills list is empty")
 	}
+	if err := ctx.Err(); err != nil {
+		t.Fatalf("real skills CLI availability check timed out: %v", err)
+	}
+	return localSkills
+}
+
+// TestUpdateCommand_RealSkillsSyncRewritesState is a live integration test that
+// verifies "lark-cli update" correctly triggers skills sync and rewrites the
+// state file. It calls the real npx skills CLI and only runs with explicit
+// opt-in. All user directories are redirected to a temporary home.
+func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
+	prepareLiveSkillsIntegration(t)
+
+	// Phase 1: Verify the real npx skills CLI is available and seed the
+	// isolated global skills install.
+	localSkills := seedLiveSkillsGlobal(t)
 
 	// Phase 2: Seed a previous sync state simulating an upgrade from v1.0.19.
 	// lark-doc and lark-mail are recorded as skipped/deleted, meaning the user
@@ -1630,26 +1766,17 @@ func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
 // not exist (cold start), the update command installs all official skills and
 // writes a fresh state file. No skill should appear in SkippedDeletedSkills
 // because there is no previous state to preserve user deletions from.
-// This is a live integration test that calls the real npx skills CLI; it is
-// skipped when npx or the skills registry is unavailable.
+// This is a live integration test that calls the real npx skills CLI and only
+// runs with explicit opt-in. All user directories are redirected to a temporary
+// home.
 func TestUpdateCommand_SkillsSyncColdStart(t *testing.T) {
-	// Phase 1: Verify the real npx skills CLI is available; skip otherwise.
-	if _, err := exec.LookPath("npx"); err != nil {
-		t.Skipf("npx not found in PATH: %v", err)
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
-	defer cancel()
-	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "--list").Run(); err != nil {
-		t.Skipf("real skills CLI unavailable: %v", err)
-	}
-	globalOut, err := exec.CommandContext(ctx, "npx", "-y", "skills", "ls", "-g").Output()
-	if err != nil {
-		t.Skipf("real global skills CLI unavailable: %v", err)
-	}
-	localSkills := skillscheck.ParseSkillsList(string(globalOut))
-	if err := ctx.Err(); err != nil {
-		t.Skipf("real skills CLI availability check timed out: %v", err)
-	}
+	prepareLiveSkillsIntegration(t)
+
+	// Phase 1: Verify the real npx skills CLI is available and seed one known
+	// official skill into the isolated global install. Cold start means no
+	// skills-state.json — locally installed skills may still exist, and seeding
+	// one keeps the Phase 4 per-skill assertions from running zero times.
+	localSkills := seedLiveSkillsGlobal(t)
 
 	// Phase 2: Use an isolated config dir with no pre-existing skills-state.json.
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())

internal/auth/testmain_test.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package auth
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-internal-auth-test-*")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_LOG_DIR", filepath.Join(root, "logs")); err != nil {
+		panic(err)
+	}
+	code := m.Run()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

internal/client/response.go

@@ -132,16 +132,14 @@ func HandleResponse(resp *larkcore.ApiResp, opts ResponseOptions) error {
 			})
 		}
 
-		// Content safety scanning for non-JSON presentation formats.
-		scanResult := output.ScanForSafety(opts.CommandPath, result, opts.ErrOut)
-		if scanResult.Blocked {
-			return scanResult.BlockErr
-		}
-		if scanResult.Alert != nil {
-			output.WriteAlertWarning(opts.ErrOut, scanResult.Alert)
-		}
-		output.FormatValue(opts.Out, result, opts.Format)
-		return nil
+		emitter := output.NewEmitter(output.EmitterConfig{
+			Out:            opts.Out,
+			ErrOut:         opts.ErrOut,
+			CommandPath:    opts.CommandPath,
+			Identity:       string(identity),
+			NoticeProvider: output.GetNotice,
+		})
+		return emitter.Success(result, output.EmitOptions{Format: opts.Format.String()})
 	}
 
 	// Non-JSON (binary) responses.

internal/client/response_test.go

@@ -18,6 +18,7 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/vfs/localfileio"
 )
@@ -239,6 +240,87 @@ func TestHandleResponse_JSON(t *testing.T) {
 	}
 }
 
+func TestHandleResponse_NonJSONFormatsEmitExactStructuredResponseBytes(t *testing.T) {
+	tests := []struct {
+		name   string
+		format output.Format
+		want   string
+	}{
+		{
+			name:   "ndjson",
+			format: output.FormatNDJSON,
+			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Bob\"}\n",
+		},
+		{
+			name:   "table",
+			format: output.FormatTable,
+			want:   "id  name \n──  ─────\n1   Alice\n2   Bob  \n",
+		},
+		{
+			name:   "csv",
+			format: output.FormatCSV,
+			want:   "id,name\n1,Alice\n2,Bob\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+			reg := &httpmock.Registry{}
+			reg.Register(&httpmock.Stub{
+				Method: http.MethodGet,
+				URL:    "/open-apis/test/v1/items",
+				Body: map[string]interface{}{
+					"code": 0,
+					"msg":  "ok",
+					"data": map[string]interface{}{
+						"items": []interface{}{
+							map[string]interface{}{"id": "1", "name": "Alice"},
+							map[string]interface{}{"id": "2", "name": "Bob"},
+						},
+						"has_more": false,
+					},
+				},
+			})
+
+			httpResp, err := httpmock.NewClient(reg).Get("https://open.feishu.cn/open-apis/test/v1/items")
+			if err != nil {
+				t.Fatalf("fixture request failed: %v", err)
+			}
+			body, err := io.ReadAll(httpResp.Body)
+			_ = httpResp.Body.Close()
+			if err != nil {
+				t.Fatalf("read fixture response: %v", err)
+			}
+			resp := &larkcore.ApiResp{
+				StatusCode: httpResp.StatusCode,
+				Header:     httpResp.Header.Clone(),
+				RawBody:    body,
+			}
+
+			var out bytes.Buffer
+			var errOut bytes.Buffer
+			err = HandleResponse(resp, ResponseOptions{
+				Format:      tt.format,
+				Identity:    core.AsBot,
+				Out:         &out,
+				ErrOut:      &errOut,
+				CommandPath: "lark-cli api GET",
+			})
+			if err != nil {
+				t.Fatalf("HandleResponse() error = %v, want nil", err)
+			}
+			if got := out.String(); got != tt.want {
+				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
+			}
+			if got := errOut.String(); got != "" {
+				t.Fatalf("stderr bytes = %q, want empty", got)
+			}
+			reg.Verify(t)
+		})
+	}
+}
+
 func TestHandleResponse_JSONWithJqUsesSuccessEnvelope(t *testing.T) {
 	body := []byte(`{"code":0,"msg":"ok","data":{"id":"1"}}`)
 	resp := newApiResp(body, map[string]string{"Content-Type": "application/json"})

internal/cmdutil/testmain_test.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	// Default-factory tests initialize the registry and resolve config. Keep
+	// them deterministic: never read the developer's real ~/.lark-cli and
+	// prevent background remote-metadata refreshes from touching user state.
+	root, err := os.MkdirTemp("", "lark-cli-cmdutil-test-*")
+	if err != nil {
+		println("internal/cmdutil test setup: MkdirTemp failed:", err.Error())
+		os.Exit(2)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
+		panic(err)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_REMOTE_META", "off"); err != nil {
+		panic(err)
+	}
+	code := m.Run()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

internal/event/testmain_test.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package event
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-event-test-*")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
+		panic(err)
+	}
+	code := m.Run()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

internal/keychain/testmain_test.go

@@ -0,0 +1,28 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package keychain
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-keychain-test-*")
+	if err != nil {
+		panic(err)
+	}
+	for key, value := range map[string]string{
+		"LARKSUITE_CLI_DATA_DIR": filepath.Join(root, "data"),
+		"LARKSUITE_CLI_LOG_DIR":  filepath.Join(root, "logs"),
+	} {
+		if err := os.Setenv(key, value); err != nil {
+			panic(err)
+		}
+	}
+	code := m.Run()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

internal/output/csv.go

@@ -7,70 +7,91 @@ import (
 	"encoding/csv"
 	"fmt"
 	"io"
-	"os"
 )
 
 // FormatAsCSV formats data as CSV (with header) and writes it to w.
 func FormatAsCSV(w io.Writer, data interface{}) {
-	FormatAsCSVPaginated(w, data, true)
+	// Match the other legacy wrappers: surface only a marshal failure (as the
+	// JSON fallback historically did); plain write failures stay swallowed.
+	if err := WriteCSV(w, data); isOutputMarshalError(err) {
+		legacyStderrf("json marshal error: %v\n", err)
+	}
+}
+
+// WriteCSV formats data as CSV and returns marshal or write errors.
+func WriteCSV(w io.Writer, data interface{}) error {
+	return WriteCSVPaginated(w, data, true)
 }
 
 // FormatAsCSVPaginated formats data as CSV with pagination awareness.
 // When isFirstPage is true, outputs the header row; otherwise only data rows.
 func FormatAsCSVPaginated(w io.Writer, data interface{}, isFirstPage bool) {
+	if err := WriteCSVPaginated(w, data, isFirstPage); isOutputMarshalError(err) {
+		legacyStderrf("json marshal error: %v\n", err)
+	}
+}
+
+// WriteCSVPaginated formats data as CSV and returns marshal or write errors.
+func WriteCSVPaginated(w io.Writer, data interface{}, isFirstPage bool) error {
 	rows, cols, isList := prepareRows(data)
 	if cols == nil {
 		if isList {
-			fmt.Fprintln(w, "(empty)")
+			_, err := fmt.Fprintln(w, "(empty)")
+			return err
 		} else {
-			PrintJson(w, data)
+			return WriteJSON(w, data)
 		}
-		return
 	}
 
 	if len(rows) == 0 {
 		if isFirstPage {
-			fmt.Fprintln(w, "(empty)")
+			_, err := fmt.Fprintln(w, "(empty)")
+			return err
 		}
-		return
+		return nil
 	}
 
 	if !isList {
 		// Single object: key,value rows
 		cw := csv.NewWriter(w)
 		if isFirstPage {
-			cw.Write([]string{"key", "value"})
+			if err := cw.Write([]string{"key", "value"}); err != nil {
+				return err
+			}
 		}
 		for _, col := range cols {
-			cw.Write([]string{col, rows[0][col]})
+			if err := cw.Write([]string{col, rows[0][col]}); err != nil {
+				return err
+			}
 		}
-		flushCSV(cw)
-		return
+		return flushCSV(cw)
 	}
 
-	writeCSVRows(w, rows, cols, isFirstPage)
+	return writeCSVRows(w, rows, cols, isFirstPage)
 }
 
 // writeCSVRows writes CSV data rows (and optionally header) using the given columns.
-func writeCSVRows(w io.Writer, rows []map[string]string, cols []string, writeHeader bool) {
+func writeCSVRows(w io.Writer, rows []map[string]string, cols []string, writeHeader bool) error {
 	cw := csv.NewWriter(w)
 	if writeHeader {
-		cw.Write(cols)
+		if err := cw.Write(cols); err != nil {
+			return err
+		}
 	}
 	for _, row := range rows {
 		record := make([]string, len(cols))
 		for i, col := range cols {
 			record[i] = row[col]
 		}
-		cw.Write(record)
+		if err := cw.Write(record); err != nil {
+			return err
+		}
 	}
-	flushCSV(cw)
+	return flushCSV(cw)
 }
 
-// flushCSV flushes the csv.Writer and reports any write error to stderr.
-func flushCSV(cw *csv.Writer) {
+// flushCSV flushes the csv.Writer and returns any write error.
+func flushCSV(cw *csv.Writer) error {
 	cw.Flush()
-	if err := cw.Error(); err != nil {
-		fmt.Fprintf(os.Stderr, "csv write error: %v\n", err)
-	}
+	return cw.Error()
 }

internal/output/emit.go

@@ -50,10 +50,11 @@ func wrapBlockError(alert *extcs.Alert) error {
 
 // WriteAlertWarning writes a human-readable content-safety warning to w.
 // Used by non-JSON output paths (pretty, table, csv) in warn mode.
-func WriteAlertWarning(w io.Writer, alert *extcs.Alert) {
+func WriteAlertWarning(w io.Writer, alert *extcs.Alert) error {
 	if alert == nil {
-		return
+		return nil
 	}
-	fmt.Fprintf(w, "warning: content safety alert from %s (rules: %s)\n",
+	_, err := fmt.Fprintf(w, "warning: content safety alert from %s (rules: %s)\n",
 		alert.Provider, strings.Join(alert.MatchedRules, ", "))
+	return err
 }

internal/output/emitter.go

@@ -0,0 +1,336 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package output
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"maps"
+
+	"github.com/larksuite/cli/errs"
+)
+
+// NoticeProvider supplies the notice attached to a structured envelope.
+// The provider is captured by an Emitter so emission never reads the global
+// PendingNotice hook implicitly.
+type NoticeProvider func() map[string]interface{}
+
+// PrettyRenderer writes the human-readable representation of one result.
+// colorEnabled is the terminal capability captured when the Emitter is built.
+type PrettyRenderer func(w io.Writer, colorEnabled bool) error
+
+// EmitterConfig contains command-scoped dependencies. A command constructs one
+// Emitter and reuses it for its success result or streamed pages.
+type EmitterConfig struct {
+	Out            io.Writer
+	ErrOut         io.Writer
+	CommandPath    string
+	Identity       string
+	ColorEnabled   bool
+	NoticeProvider NoticeProvider
+}
+
+// EmitOptions describes one result's wire representation.
+//
+// The format contract is explicit: JSON (including the empty default) uses an
+// Envelope; pretty, table, csv, and ndjson render naked business data. JQ takes
+// precedence over Format and filters the JSON Envelope. Raw affects only JSON
+// envelope encoding and jq's complex-value encoding.
+//
+// JQSafetyWarning preserves the legacy difference between RuntimeContext.emit
+// (false) and WriteSuccessEnvelope (true) until their callers are migrated.
+type EmitOptions struct {
+	Raw             bool
+	Meta            *Meta
+	Format          string
+	JQ              string
+	DryRun          bool
+	Pretty          PrettyRenderer
+	JQSafetyWarning bool
+}
+
+// StreamOptions describes one streamed page's wire representation. Streaming
+// carries page items directly, so it deliberately exposes only the fields that
+// affect a single page: the format and, for pretty, its renderer. It has no
+// OK/Meta/DryRun/JQ — an ok:false envelope, metadata, dry-run, and jq all need
+// the aggregated result, which the caller's pagination layer owns before it
+// streams pages.
+type StreamOptions struct {
+	Format string
+	Pretty PrettyRenderer
+}
+
+// Emitter owns all command-scoped output dependencies and pagination state.
+// It deliberately has no dependency on client or cmdutil.
+type Emitter struct {
+	out            io.Writer
+	errOut         io.Writer
+	commandPath    string
+	identity       string
+	colorEnabled   bool
+	noticeProvider NoticeProvider
+
+	streamFormat    string
+	streamFormatter *PaginatedFormatter
+}
+
+// NewEmitter constructs a command-scoped output emitter.
+func NewEmitter(config EmitterConfig) *Emitter {
+	errOut := config.ErrOut
+	if errOut == nil {
+		errOut = io.Discard
+	}
+	return &Emitter{
+		out:            config.Out,
+		errOut:         errOut,
+		commandPath:    config.CommandPath,
+		identity:       config.Identity,
+		colorEnabled:   config.ColorEnabled,
+		noticeProvider: config.NoticeProvider,
+	}
+}
+
+// Success scans and emits one command result by composing the package's leaf
+// primitives. JSON and jq use the standard envelope; pretty, table, csv, and
+// ndjson render the business value directly.
+func (e *Emitter) Success(data interface{}, opts EmitOptions) error {
+	if err := e.requireOutput(); err != nil {
+		return err
+	}
+
+	if opts.JQ != "" {
+		return e.emitEnvelope(data, true, opts)
+	}
+
+	switch opts.Format {
+	case "", "json":
+		return e.emitEnvelope(data, true, opts)
+	case "pretty":
+		return e.emitPretty(data, opts)
+	default:
+		return e.emitFormatted(data, opts.Format)
+	}
+}
+
+// PartialFailure emits a multi-status result whose envelope honestly reports
+// ok:false. It is the typed counterpart to Success for batch operations where
+// some items failed but the per-item outcomes are the primary stdout output.
+// Like the legacy OutPartialFailure it produces only the JSON/jq envelope; the
+// caller owns the non-zero exit signal, keeping the Emitter free of exit
+// semantics.
+func (e *Emitter) PartialFailure(data interface{}, opts EmitOptions) error {
+	if err := e.requireOutput(); err != nil {
+		return err
+	}
+	return e.emitEnvelope(data, false, opts)
+}
+
+// StreamPage scans and emits one page while retaining table/csv columns from
+// the first page. Streamed output carries page items directly, so it takes a
+// StreamOptions (format + optional pretty renderer) rather than the full
+// EmitOptions: ok/meta/dry-run/jq all need the aggregated result and are the
+// caller's pagination-layer responsibility, not a per-page concern. Excluding
+// jq from the type makes "jq requires aggregated output" a compile-time fact
+// instead of a runtime rejection.
+func (e *Emitter) StreamPage(data interface{}, opts StreamOptions) error {
+	if err := e.requireOutput(); err != nil {
+		return err
+	}
+
+	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
+	if scanResult.Blocked {
+		return scanResult.BlockErr
+	}
+	if scanResult.Alert != nil {
+		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
+			return wrapOutputError("write", err)
+		}
+	}
+
+	if opts.Format == "pretty" {
+		if opts.Pretty == nil {
+			return errs.NewInternalError(errs.SubtypeUnknown,
+				"pretty output requires a renderer")
+		}
+		return e.emit(func(w io.Writer) error {
+			return opts.Pretty(w, e.colorEnabled)
+		})
+	}
+
+	format, known := ParseFormat(opts.Format)
+	if !known && e.streamFormatter == nil && e.errOut != nil {
+		fmt.Fprintf(e.errOut, "warning: unknown format %q, falling back to json\n", opts.Format)
+	}
+	if e.streamFormatter == nil {
+		e.streamFormat = opts.Format
+		e.streamFormatter = NewPaginatedFormatter(nil, format)
+	} else if opts.Format != e.streamFormat {
+		return errs.NewInternalError(errs.SubtypeUnknown,
+			"stream output format changed from %q to %q", e.streamFormat, opts.Format)
+	}
+
+	return e.emit(func(w io.Writer) error {
+		e.streamFormatter.W = w
+		return e.streamFormatter.WritePage(data)
+	})
+}
+
+func (e *Emitter) emitEnvelope(data interface{}, ok bool, opts EmitOptions) error {
+	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
+	if scanResult.Blocked {
+		return scanResult.BlockErr
+	}
+
+	env := Envelope{
+		OK:       ok,
+		Identity: e.identity,
+		DryRun:   opts.DryRun,
+		Data:     data,
+		Meta:     opts.Meta,
+		Notice:   e.notice(),
+	}
+	if scanResult.Alert != nil {
+		env.ContentSafetyAlert = scanResult.Alert
+	}
+
+	if opts.JQ != "" {
+		if scanResult.Alert != nil && opts.JQSafetyWarning {
+			if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
+				return wrapOutputError("write", err)
+			}
+		}
+		// Buffer the jq output manually so jq's own typed error (a validation
+		// error for a bad expression, an api error for a runtime failure) is
+		// returned unchanged; only a genuine stdout write failure is wrapped as
+		// an internal output error.
+		var buf bytes.Buffer
+		var jqErr error
+		if opts.Raw {
+			jqErr = JqFilterRaw(&buf, env, opts.JQ)
+		} else {
+			jqErr = JqFilter(&buf, env, opts.JQ)
+		}
+		if jqErr != nil {
+			return jqErr
+		}
+		if _, err := io.Copy(e.out, &buf); err != nil {
+			return wrapOutputError("write", err)
+		}
+		return nil
+	}
+
+	return e.emit(func(w io.Writer) error {
+		if opts.Raw {
+			enc := json.NewEncoder(w)
+			enc.SetEscapeHTML(false)
+			enc.SetIndent("", "  ")
+			return enc.Encode(env)
+		}
+		return WriteJSON(w, env)
+	})
+}
+
+func (e *Emitter) emitPretty(data interface{}, opts EmitOptions) error {
+	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
+	if scanResult.Blocked {
+		return scanResult.BlockErr
+	}
+	if scanResult.Alert != nil {
+		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
+			return wrapOutputError("write", err)
+		}
+	}
+	if opts.Pretty != nil {
+		return e.emit(func(w io.Writer) error {
+			return opts.Pretty(w, e.colorEnabled)
+		})
+	}
+
+	// RuntimeContext.outFormat falls back through Out/OutRaw when no pretty
+	// renderer is supplied. Keep that second scan visible in the leaf contract
+	// until production callers are migrated and the legacy behavior is removed.
+	return e.emitEnvelope(data, true, opts)
+}
+
+func (e *Emitter) emitFormatted(data interface{}, rawFormat string) error {
+	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
+	if scanResult.Blocked {
+		return scanResult.BlockErr
+	}
+	if scanResult.Alert != nil {
+		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
+			return wrapOutputError("write", err)
+		}
+	}
+
+	format, known := ParseFormat(rawFormat)
+	if !known && e.errOut != nil {
+		fmt.Fprintf(e.errOut, "warning: unknown format %q, falling back to json\n", rawFormat)
+	}
+	if format == FormatJSON {
+		return e.printLegacyDataJSON(data)
+	}
+	return e.emit(func(w io.Writer) error {
+		return WriteFormatted(w, data, format)
+	})
+}
+
+type emitterDataMap map[string]interface{}
+
+// printLegacyDataJSON matches FormatValue's JSON branch while sourcing notice
+// data from this Emitter instead of PrintJson's global PendingNotice hook.
+func (e *Emitter) printLegacyDataJSON(data interface{}) error {
+	// Normalise structs / named maps to plain generic types first, exactly as
+	// FormatValue does, so a struct or named-map payload still matches the map
+	// case below and keeps its injected _notice on the unknown-format fallback.
+	data = toGeneric(data)
+	if m, ok := data.(map[string]interface{}); ok {
+		if _, isEnvelope := m["ok"]; isEnvelope {
+			if notice := e.notice(); notice != nil {
+				m = maps.Clone(m)
+				m["_notice"] = notice
+			}
+		}
+		// The named map retains identical JSON bytes while preventing PrintJson
+		// from consulting its legacy global notice hook a second time.
+		return e.emit(func(w io.Writer) error {
+			return WriteJSON(w, emitterDataMap(m))
+		})
+	}
+	return e.emit(func(w io.Writer) error {
+		return WriteJSON(w, data)
+	})
+}
+
+func (e *Emitter) emit(render func(io.Writer) error) error {
+	var buf bytes.Buffer
+	if err := render(&buf); err != nil {
+		return wrapOutputError("render", err)
+	}
+	if _, err := io.Copy(e.out, &buf); err != nil {
+		return wrapOutputError("write", err)
+	}
+	return nil
+}
+
+func wrapOutputError(op string, err error) error {
+	return errs.NewInternalError(errs.SubtypeUnknown, "failed to %s command output", op).WithCause(err)
+}
+
+func (e *Emitter) notice() map[string]interface{} {
+	if e.noticeProvider == nil {
+		return nil
+	}
+	return e.noticeProvider()
+}
+
+func (e *Emitter) requireOutput() error {
+	if e == nil || e.out == nil {
+		return errs.NewInternalError(errs.SubtypeUnknown,
+			"success output writer is not configured")
+	}
+	return nil
+}

internal/output/emitter_contract_test.go

@@ -0,0 +1,350 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package output_test
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	extcs "github.com/larksuite/cli/extension/contentsafety"
+	"github.com/larksuite/cli/internal/output"
+)
+
+type contractFailingWriter struct {
+	err error
+}
+
+func (w contractFailingWriter) Write([]byte) (int, error) {
+	return 0, w.err
+}
+
+type contractSafetyProvider struct {
+	alert *extcs.Alert
+}
+
+func (p *contractSafetyProvider) Name() string {
+	return "emitter-contract"
+}
+
+func (p *contractSafetyProvider) Scan(context.Context, extcs.ScanRequest) (*extcs.Alert, error) {
+	return p.alert, nil
+}
+
+func TestEmitterSuccessWritesAllBytes(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+		Identity:    "bot",
+	})
+	data := map[string]interface{}{"id": "1"}
+
+	err := emitter.Success(data, output.EmitOptions{Format: "json"})
+	if err != nil {
+		t.Fatalf("Emitter.Success() error = %v", err)
+	}
+	want, marshalErr := json.MarshalIndent(output.Envelope{OK: true, Identity: "bot", Data: data}, "", "  ")
+	if marshalErr != nil {
+		t.Fatalf("marshal expected envelope: %v", marshalErr)
+	}
+	want = append(want, '\n')
+	if !bytes.Equal(stdout.Bytes(), want) {
+		t.Fatalf("stdout bytes = %q, want %q", stdout.Bytes(), want)
+	}
+}
+
+func TestEmitterMarshalFailureReturnsTypedErrorWithoutOutput(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+	})
+
+	err := emitter.Success(map[string]interface{}{"unsupported": func() {}}, output.EmitOptions{Format: "json"})
+	if err == nil {
+		t.Fatal("Emitter.Success() error = nil, want marshal failure")
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	var unsupported *json.UnsupportedTypeError
+	if !errors.As(err, &unsupported) {
+		t.Fatalf("Emitter.Success() error = %v, want json.UnsupportedTypeError cause", err)
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("Emitter.Success() stdout = %q, want empty", stdout.String())
+	}
+}
+
+func TestEmitterWriterFailurePreservesCause(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	sentinel := errors.New("write failed")
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         contractFailingWriter{err: sentinel},
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+	})
+
+	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{Format: "json"})
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("Emitter.Success() error = %v, want preserved writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+}
+
+func TestEmitterPrettyRendererFailurePreservesCause(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	sentinel := errors.New("pretty render failed")
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+	})
+
+	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
+		Format: "pretty",
+		Pretty: func(io.Writer, bool) error {
+			return sentinel
+		},
+	})
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("Emitter.Success() error = %v, want preserved renderer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("Emitter.Success() stdout = %q, want empty", stdout.String())
+	}
+}
+
+func TestEmitterAlertWarningFailurePreservesCause(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
+	extcs.Register(&contractSafetyProvider{alert: &extcs.Alert{
+		Provider:     "emitter-contract",
+		MatchedRules: []string{"fixture-rule"},
+	}})
+	t.Cleanup(func() { extcs.Register(nil) })
+	sentinel := errors.New("warning write failed")
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      contractFailingWriter{err: sentinel},
+		CommandPath: "lark-cli fixture +emit",
+	})
+
+	err := emitter.Success([]interface{}{map[string]interface{}{"id": "1"}}, output.EmitOptions{Format: "table"})
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("Emitter.Success() error = %v, want preserved warning writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("Emitter.Success() stdout = %q, want empty", stdout.String())
+	}
+}
+
+func TestNewEmitterDefaultsNilErrOutToDiscard(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
+	extcs.Register(&contractSafetyProvider{alert: &extcs.Alert{
+		Provider:     "emitter-contract",
+		MatchedRules: []string{"fixture-rule"},
+	}})
+	t.Cleanup(func() { extcs.Register(nil) })
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		CommandPath: "lark-cli fixture +emit",
+	})
+
+	if err := emitter.Success([]interface{}{map[string]interface{}{"id": "1"}}, output.EmitOptions{Format: "table"}); err != nil {
+		t.Fatalf("Emitter.Success() error = %v", err)
+	}
+	if stdout.Len() == 0 {
+		t.Fatal("Emitter.Success() stdout is empty")
+	}
+}
+
+func TestEmitterDoesNotMutateCallerMap(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	data := map[string]interface{}{"ok": true, "value": "fixture"}
+	want := map[string]interface{}{"ok": true, "value": "fixture"}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         &bytes.Buffer{},
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+		NoticeProvider: func() map[string]interface{} {
+			return map[string]interface{}{"update": "available"}
+		},
+	})
+
+	if err := emitter.Success(data, output.EmitOptions{Format: "yaml"}); err != nil {
+		t.Fatalf("Emitter.Success() error = %v", err)
+	}
+	if !reflect.DeepEqual(data, want) {
+		t.Fatalf("caller map = %#v, want unchanged %#v", data, want)
+	}
+}
+
+func TestEmitterDoesNotOverwriteCallerNotice(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	existing := map[string]interface{}{"source": "caller"}
+	data := map[string]interface{}{"ok": true, "_notice": existing}
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+		NoticeProvider: func() map[string]interface{} {
+			return map[string]interface{}{"source": "provider"}
+		},
+	})
+
+	if err := emitter.Success(data, output.EmitOptions{Format: "yaml"}); err != nil {
+		t.Fatalf("Emitter.Success() error = %v", err)
+	}
+	if got := data["_notice"]; !reflect.DeepEqual(got, existing) {
+		t.Fatalf("caller _notice = %#v, want unchanged %#v", got, existing)
+	}
+	var emitted map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &emitted); err != nil {
+		t.Fatalf("decode stdout: %v", err)
+	}
+	if got := emitted["_notice"]; !reflect.DeepEqual(got, map[string]interface{}{"source": "provider"}) {
+		t.Fatalf("emitted _notice = %#v, want provider notice", got)
+	}
+}
+
+func TestEmitterReadsNoticeProviderAtMostOncePerEmission(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	calls := 0
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         &bytes.Buffer{},
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+		NoticeProvider: func() map[string]interface{} {
+			calls++
+			return map[string]interface{}{"source": "provider"}
+		},
+	})
+
+	if err := emitter.Success(map[string]interface{}{"ok": true}, output.EmitOptions{Format: "yaml"}); err != nil {
+		t.Fatalf("Emitter.Success() error = %v", err)
+	}
+	if calls != 1 {
+		t.Fatalf("notice provider calls = %d, want 1", calls)
+	}
+}
+
+func TestEmitterRawJSONPropagatesWriteError(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	sentinel := errors.New("write failed")
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         contractFailingWriter{err: sentinel},
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+	})
+	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
+		Raw: true, Format: "json",
+	})
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("Emitter.Success() error = %v, want preserved writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+}
+
+func TestEmitterInvalidJQReturnsErrorWithoutStderr(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	stderr := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         &bytes.Buffer{},
+		ErrOut:      stderr,
+		CommandPath: "lark-cli fixture +emit",
+	})
+	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
+		Format: "json",
+		JQ:     "this is not valid jq (((",
+	})
+	if err == nil {
+		t.Fatal("Success() with invalid jq = nil, want error")
+	}
+	if stderr.Len() != 0 {
+		t.Fatalf("Success() with invalid jq wrote stderr %q, want empty", stderr.String())
+	}
+}
+
+func TestEmitterJQRuntimeErrorPreservesTypedError(t *testing.T) {
+	// A valid expression that fails at runtime must surface jq's own typed error
+	// (an api error), not a wrapped internal output error, and must emit no
+	// partial stdout.
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+	})
+	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
+		Format: "json",
+		JQ:     `error("boom")`,
+	})
+	if err == nil {
+		t.Fatal("Success() with a runtime jq error = nil, want error")
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category == errs.CategoryInternal {
+		t.Fatalf("Success() jq runtime error problem = %#v, %v; want jq's own typed error, not internal", problem, ok)
+	}
+	if !strings.Contains(err.Error(), "jq error") {
+		t.Fatalf("Success() jq runtime error = %v, want jq's own error message preserved", err)
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("Success() jq runtime error wrote stdout %q, want empty", stdout.String())
+	}
+}
+
+func TestEmitterUnknownFormatStructKeepsNotice(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	type payload struct {
+		OK    bool   `json:"ok"`
+		Value string `json:"value"`
+	}
+	stdout := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+		NoticeProvider: func() map[string]interface{} {
+			return map[string]interface{}{"update": map[string]interface{}{"latest": "9.9.9"}}
+		},
+	})
+	if err := emitter.Success(payload{OK: true, Value: "fixture"}, output.EmitOptions{Format: "yaml"}); err != nil {
+		t.Fatalf("Success() error = %v", err)
+	}
+	if !strings.Contains(stdout.String(), "_notice") {
+		t.Fatalf("struct payload on unknown-format fallback dropped _notice:\n%s", stdout.String())
+	}
+}

internal/output/emitter_legacy_compat_test.go

@@ -0,0 +1,827 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Legacy oracle fixtures are frozen at base SHA 4a56748bfa941ff0ee0bfec92e65acac427732b0.
+// Golden regeneration is allowed only from that base, never from the current system under test.
+
+package output_test
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	extcs "github.com/larksuite/cli/extension/contentsafety"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+type emitterCapture struct {
+	stdout string
+	stderr string
+	err    error
+}
+
+type emitterSafetyProvider struct {
+	alert *extcs.Alert
+	err   error
+}
+
+func (p *emitterSafetyProvider) Name() string { return "emitter-oracle" }
+
+func (p *emitterSafetyProvider) Scan(context.Context, extcs.ScanRequest) (*extcs.Alert, error) {
+	return p.alert, p.err
+}
+
+const (
+	runtimeContextLegacyGoldenPath       = "testdata/runtime_context_legacy.golden.json"
+	writeSuccessEnvelopeLegacyGoldenPath = "testdata/write_success_envelope_legacy.golden.json"
+)
+
+type runtimeContextOracleCase struct {
+	name        string
+	data        func() interface{}
+	raw         bool
+	ok          bool
+	meta        *output.Meta
+	jq          string
+	format      string
+	useFormat   bool
+	pretty      bool
+	notice      map[string]interface{}
+	safetyMode  string
+	safetyAlert *extcs.Alert
+	safetyErr   error
+}
+
+type runtimeContextLegacyGolden struct {
+	Cases map[string]emitterCaptureGolden `json:"cases"`
+}
+
+type writeSuccessEnvelopeOracleCase struct {
+	name        string
+	data        func() interface{}
+	dryRun      bool
+	jq          string
+	notice      map[string]interface{}
+	safetyMode  string
+	safetyAlert *extcs.Alert
+}
+
+type writeSuccessEnvelopeLegacyGolden struct {
+	Cases map[string]emitterCaptureGolden `json:"cases"`
+}
+
+type emitterCaptureGolden struct {
+	Stdout string              `json:"stdout"`
+	Stderr string              `json:"stderr"`
+	Error  *emitterErrorGolden `json:"error,omitempty"`
+}
+
+type emitterErrorGolden struct {
+	GoType   string          `json:"go_type"`
+	JSON     json.RawMessage `json:"json"`
+	Message  string          `json:"message"`
+	ExitCode int             `json:"exit_code"`
+}
+
+func TestEmitterMatchesRuntimeContextLegacyOracle(t *testing.T) {
+	previousNotice := output.PendingNotice
+	t.Cleanup(func() {
+		output.PendingNotice = previousNotice
+		extcs.Register(nil)
+	})
+
+	cases := []runtimeContextOracleCase{
+		{
+			name: "json_object",
+			data: func() interface{} {
+				return map[string]interface{}{"id": "1", "enabled": true}
+			},
+			ok: true,
+		},
+		{
+			name: "raw_json_preserves_html",
+			data: func() interface{} {
+				return map[string]interface{}{"html": "<p>a&b</p>"}
+			},
+			raw: true,
+			ok:  true,
+		},
+		{
+			name: "format_raw_json_preserves_html",
+			data: func() interface{} {
+				return map[string]interface{}{"html": "<p>a&b</p>"}
+			},
+			raw:       true,
+			ok:        true,
+			format:    "json",
+			useFormat: true,
+		},
+		{
+			name: "partial_failure_ok_false",
+			data: func() interface{} {
+				return map[string]interface{}{"succeeded": 1, "failed": 1}
+			},
+			ok: false,
+		},
+		{
+			name: "metadata",
+			data: func() interface{} {
+				return []interface{}{map[string]interface{}{"id": "1"}}
+			},
+			ok:   true,
+			meta: &output.Meta{Count: 1, Rollback: "lark-cli fixture rollback"},
+		},
+		{
+			name: "jq_scalar",
+			data: func() interface{} {
+				return map[string]interface{}{"name": "Alice", "age": 30}
+			},
+			ok: true,
+			jq: ".data.name",
+		},
+		{
+			name: "raw_jq_complex",
+			data: func() interface{} {
+				return map[string]interface{}{"document": map[string]interface{}{"html": "<p>a&b</p>"}}
+			},
+			raw: true,
+			ok:  true,
+			jq:  ".data.document",
+		},
+		{
+			name: "jq_invalid_expression",
+			data: func() interface{} {
+				return map[string]interface{}{"id": "1"}
+			},
+			ok: false,
+			jq: "invalid[",
+		},
+		{
+			name: "notice",
+			data: func() interface{} {
+				return map[string]interface{}{"id": "1"}
+			},
+			ok:     true,
+			notice: map[string]interface{}{"update": map[string]interface{}{"latest": "9.9.9"}},
+		},
+		{
+			name: "pretty",
+			data: func() interface{} {
+				return map[string]interface{}{"name": "Alice"}
+			},
+			ok:        true,
+			format:    "pretty",
+			useFormat: true,
+			pretty:    true,
+		},
+		{
+			name: "pretty_without_renderer",
+			data: func() interface{} {
+				return map[string]interface{}{"name": "Alice"}
+			},
+			ok:        true,
+			format:    "pretty",
+			useFormat: true,
+		},
+		{
+			name: "ndjson",
+			data: func() interface{} {
+				return map[string]interface{}{"items": []interface{}{
+					map[string]interface{}{"id": "1"},
+					map[string]interface{}{"id": "2"},
+				}}
+			},
+			ok:        true,
+			format:    "ndjson",
+			useFormat: true,
+		},
+		{
+			name: "table_with_safety_warning",
+			data: func() interface{} {
+				return []interface{}{map[string]interface{}{"id": "1", "name": "Alice"}}
+			},
+			ok:         true,
+			format:     "table",
+			useFormat:  true,
+			safetyMode: "warn",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+		{
+			name: "csv",
+			data: func() interface{} {
+				return []interface{}{
+					map[string]interface{}{"id": "1", "name": "Alice"},
+					map[string]interface{}{"id": "2", "name": "Bob"},
+				}
+			},
+			ok:        true,
+			format:    "csv",
+			useFormat: true,
+		},
+		{
+			name: "jq_safety_alert_without_stderr_warning",
+			data: func() interface{} {
+				return map[string]interface{}{"id": "1"}
+			},
+			ok:         true,
+			jq:         ".data.id",
+			safetyMode: "warn",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+		{
+			name: "scanner_error_fails_open",
+			data: func() interface{} {
+				return map[string]interface{}{"id": "1"}
+			},
+			ok:         true,
+			safetyMode: "warn",
+			safetyErr:  errors.New("scanner unavailable"),
+		},
+		{
+			name: "scanner_block",
+			data: func() interface{} {
+				return map[string]interface{}{"id": "blocked"}
+			},
+			ok:         false,
+			safetyMode: "block",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+		{
+			name: "unknown_format_data_envelope_notice",
+			data: func() interface{} {
+				return map[string]interface{}{"ok": true, "value": "fixture"}
+			},
+			ok:        true,
+			format:    "yaml",
+			useFormat: true,
+			notice:    map[string]interface{}{"skills": map[string]interface{}{"current": "1.0.0"}},
+		},
+	}
+
+	golden := loadRuntimeContextLegacyGolden(t)
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			mode := tc.safetyMode
+			if mode == "" {
+				mode = "off"
+			}
+			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", mode)
+			extcs.Register(&emitterSafetyProvider{alert: tc.safetyAlert, err: tc.safetyErr})
+			t.Cleanup(func() { extcs.Register(nil) })
+
+			notice := tc.notice
+			output.PendingNotice = func() map[string]interface{} { return notice }
+
+			want, ok := golden.Cases[tc.name]
+			if !ok {
+				t.Fatalf("frozen golden case %q is missing", tc.name)
+			}
+
+			opts := runtimeOracleOptions{
+				raw:       tc.raw,
+				ok:        tc.ok,
+				meta:      tc.meta,
+				jq:        tc.jq,
+				format:    tc.format,
+				useFormat: tc.useFormat,
+				pretty:    tc.pretty,
+			}
+			current := runEmitterWithRuntimeContextContract(tc.data(), output.EmitterConfig{
+				CommandPath:    "lark-cli fixture +emit",
+				Identity:       "bot",
+				NoticeProvider: func() map[string]interface{} { return notice },
+			}, tc.ok, output.EmitOptions{
+				Raw:    tc.raw,
+				Meta:   tc.meta,
+				Format: tc.format,
+				JQ:     tc.jq,
+				Pretty: emitterPrettyRenderer(tc.pretty),
+			})
+
+			assertEmitterGolden(t, want, current)
+
+			integrated := runRuntimeContextOracle(t, tc.data(), opts)
+			assertEmitterGolden(t, want, integrated)
+			if tc.safetyMode == "block" {
+				var safetyErr *errs.ContentSafetyError
+				if !errors.As(current.err, &safetyErr) {
+					t.Fatalf("Emitter.Success() error = %T, want *errs.ContentSafetyError", current.err)
+				}
+			}
+		})
+	}
+
+	if len(golden.Cases) != len(cases) {
+		t.Fatalf("golden case count = %d, want %d", len(golden.Cases), len(cases))
+	}
+
+	jqFailure := golden.Cases["jq_invalid_expression"]
+	if !strings.HasPrefix(jqFailure.Stderr, "error: ") || !strings.HasSuffix(jqFailure.Stderr, "\n") {
+		t.Fatalf("invalid jq golden stderr = %q, want error line ending in newline", jqFailure.Stderr)
+	}
+	if jqFailure.Error == nil || jqFailure.Error.ExitCode != output.ExitValidation {
+		t.Fatalf("invalid jq golden exit = %#v, want %d", jqFailure.Error, output.ExitValidation)
+	}
+}
+
+func loadRuntimeContextLegacyGolden(t *testing.T) runtimeContextLegacyGolden {
+	t.Helper()
+	contents, err := os.ReadFile(runtimeContextLegacyGoldenPath)
+	if err != nil {
+		t.Fatalf("read RuntimeContext legacy golden: %v", err)
+	}
+	var golden runtimeContextLegacyGolden
+	if err := json.Unmarshal(contents, &golden); err != nil {
+		t.Fatalf("decode RuntimeContext legacy golden: %v", err)
+	}
+	return golden
+}
+
+func captureEmitterGolden(t *testing.T, capture emitterCapture) emitterCaptureGolden {
+	t.Helper()
+	golden := emitterCaptureGolden{Stdout: capture.stdout, Stderr: capture.stderr}
+	if capture.err == nil {
+		return golden
+	}
+	errorJSON, err := json.Marshal(capture.err)
+	if err != nil {
+		t.Fatalf("marshal captured error %T: %v", capture.err, err)
+	}
+	golden.Error = &emitterErrorGolden{
+		GoType:   fmt.Sprintf("%T", capture.err),
+		JSON:     errorJSON,
+		Message:  capture.err.Error(),
+		ExitCode: output.ExitCodeOf(capture.err),
+	}
+	return golden
+}
+
+type runtimeOracleOptions struct {
+	raw       bool
+	ok        bool
+	meta      *output.Meta
+	jq        string
+	format    string
+	useFormat bool
+	pretty    bool
+}
+
+func runRuntimeContextOracle(t *testing.T, data interface{}, opts runtimeOracleOptions) emitterCapture {
+	t.Helper()
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	parent := &cobra.Command{Use: "lark-cli"}
+	cmd := &cobra.Command{Use: "fixture"}
+	leaf := &cobra.Command{Use: "+emit"}
+	parent.AddCommand(cmd)
+	cmd.AddCommand(leaf)
+
+	factory := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{Out: stdout, ErrOut: stderr}}
+	runtime := common.TestNewRuntimeContextForAPI(
+		context.Background(), leaf, &core.CliConfig{Brand: core.BrandFeishu}, factory, core.AsBot,
+	)
+	runtime.Format = opts.format
+	runtime.JqExpr = opts.jq
+
+	pretty := func(w io.Writer) {
+		fmt.Fprintln(w, "pretty:fixture")
+	}
+	if !opts.pretty {
+		pretty = nil
+	}
+
+	var err error
+	switch {
+	case opts.useFormat && opts.raw:
+		runtime.OutFormatRaw(data, opts.meta, pretty)
+	case opts.useFormat:
+		runtime.OutFormat(data, opts.meta, pretty)
+	case !opts.ok:
+		err = runtime.OutPartialFailure(data, opts.meta)
+	case opts.raw:
+		runtime.OutRaw(data, opts.meta)
+	default:
+		runtime.Out(data, opts.meta)
+	}
+
+	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: err}
+}
+
+func runEmitterSuccess(data interface{}, config output.EmitterConfig, ok bool, opts output.EmitOptions) emitterCapture {
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	config.Out = stdout
+	config.ErrOut = stderr
+	emitter := output.NewEmitter(config)
+	var err error
+	if ok {
+		err = emitter.Success(data, opts)
+	} else {
+		err = emitter.PartialFailure(data, opts)
+	}
+	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: err}
+}
+
+func runEmitterWithRuntimeContextContract(data interface{}, config output.EmitterConfig, ok bool, opts output.EmitOptions) emitterCapture {
+	capture := runEmitterSuccess(data, config, ok, opts)
+	if capture.err != nil {
+		var safetyErr *errs.ContentSafetyError
+		if errors.As(capture.err, &safetyErr) {
+			return capture
+		}
+		if opts.JQ != "" {
+			capture.stderr += fmt.Sprintf("error: %v\n", capture.err)
+			return capture
+		}
+		capture.err = nil
+	}
+	if !ok {
+		capture.err = output.PartialFailure(output.ExitAPI)
+	}
+	return capture
+}
+
+func emitterPrettyRenderer(enabled bool) output.PrettyRenderer {
+	if !enabled {
+		return nil
+	}
+	return func(w io.Writer, _ bool) error {
+		_, err := fmt.Fprintln(w, "pretty:fixture")
+		return err
+	}
+}
+
+func TestEmitterMatchesWriteSuccessEnvelopeLegacyOracle(t *testing.T) {
+	previousNotice := output.PendingNotice
+	t.Cleanup(func() {
+		output.PendingNotice = previousNotice
+		extcs.Register(nil)
+	})
+
+	cases := []writeSuccessEnvelopeOracleCase{
+		{
+			name: "json",
+			data: func() interface{} { return map[string]interface{}{"id": "1"} },
+		},
+		{
+			name:   "dry_run",
+			data:   func() interface{} { return map[string]interface{}{"api": []interface{}{}} },
+			dryRun: true,
+		},
+		{
+			name: "jq",
+			data: func() interface{} { return map[string]interface{}{"id": "1"} },
+			jq:   ".data.id",
+		},
+		{
+			name:   "notice",
+			data:   func() interface{} { return map[string]interface{}{"id": "1"} },
+			notice: map[string]interface{}{"update": map[string]interface{}{"latest": "9.9.9"}},
+		},
+		{
+			name:       "jq_safety_warning",
+			data:       func() interface{} { return map[string]interface{}{"id": "1"} },
+			jq:         ".data.id",
+			safetyMode: "warn",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+		{
+			name:       "scanner_block",
+			data:       func() interface{} { return map[string]interface{}{"id": "blocked"} },
+			safetyMode: "block",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+	}
+	golden := loadWriteSuccessEnvelopeLegacyGolden(t)
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			mode := tc.safetyMode
+			if mode == "" {
+				mode = "off"
+			}
+			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", mode)
+			extcs.Register(&emitterSafetyProvider{alert: tc.safetyAlert})
+			t.Cleanup(func() { extcs.Register(nil) })
+			notice := tc.notice
+			output.PendingNotice = func() map[string]interface{} { return notice }
+
+			want, ok := golden.Cases[tc.name]
+			if !ok {
+				t.Fatalf("frozen golden case %q is missing", tc.name)
+			}
+
+			current := runEmitterSuccess(tc.data(), output.EmitterConfig{
+				CommandPath:    "lark-cli fixture +emit",
+				Identity:       "bot",
+				NoticeProvider: func() map[string]interface{} { return notice },
+			}, true, output.EmitOptions{
+				Format:          "",
+				Raw:             false,
+				JQ:              tc.jq,
+				DryRun:          tc.dryRun,
+				JQSafetyWarning: true,
+			})
+			assertEmitterGolden(t, want, current)
+
+			integrated := runWriteSuccessEnvelopeOracle(tc.data(), tc.dryRun, tc.jq)
+			assertEmitterGolden(t, want, integrated)
+		})
+	}
+
+	if len(golden.Cases) != len(cases) {
+		t.Fatalf("golden case count = %d, want %d", len(golden.Cases), len(cases))
+	}
+}
+
+func loadWriteSuccessEnvelopeLegacyGolden(t *testing.T) writeSuccessEnvelopeLegacyGolden {
+	t.Helper()
+	contents, err := os.ReadFile(writeSuccessEnvelopeLegacyGoldenPath)
+	if err != nil {
+		t.Fatalf("read WriteSuccessEnvelope legacy golden: %v", err)
+	}
+	var golden writeSuccessEnvelopeLegacyGolden
+	if err := json.Unmarshal(contents, &golden); err != nil {
+		t.Fatalf("decode WriteSuccessEnvelope legacy golden: %v", err)
+	}
+	return golden
+}
+
+func runWriteSuccessEnvelopeOracle(data interface{}, dryRun bool, jq string) emitterCapture {
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	err := output.WriteSuccessEnvelope(data, output.SuccessEnvelopeOptions{
+		CommandPath: "lark-cli fixture +emit",
+		Identity:    "bot",
+		DryRun:      dryRun,
+		JqExpr:      jq,
+		Out:         stdout,
+		ErrOut:      stderr,
+	})
+	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: err}
+}
+
+func TestEmitterStreamPageMatchesPaginationLegacyOracle(t *testing.T) {
+	t.Cleanup(func() { extcs.Register(nil) })
+
+	type oracleCase struct {
+		name        string
+		format      output.Format
+		safetyMode  string
+		safetyAlert *extcs.Alert
+	}
+	cases := []oracleCase{
+		{name: "ndjson", format: output.FormatNDJSON},
+		{name: "table", format: output.FormatTable},
+		{name: "csv", format: output.FormatCSV},
+		{
+			name:       "warn",
+			format:     output.FormatNDJSON,
+			safetyMode: "warn",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+		{
+			name:       "block",
+			format:     output.FormatTable,
+			safetyMode: "block",
+			safetyAlert: &extcs.Alert{
+				Provider:     "emitter-oracle",
+				MatchedRules: []string{"fixture-rule"},
+			},
+		},
+	}
+
+	pages := []interface{}{
+		[]interface{}{map[string]interface{}{"id": "1", "name": "Alice"}},
+		[]interface{}{map[string]interface{}{"id": "2", "name": "Bob", "ignored": true}},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			mode := tc.safetyMode
+			if mode == "" {
+				mode = "off"
+			}
+			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", mode)
+			extcs.Register(&emitterSafetyProvider{alert: tc.safetyAlert})
+			t.Cleanup(func() { extcs.Register(nil) })
+
+			legacy := runPaginationOracle(pages, tc.format)
+			current := runEmitterStreamPages(pages, tc.format.String())
+
+			assertEmitterBytes(t, legacy, current)
+			assertEquivalentError(t, legacy.err, current.err)
+		})
+	}
+}
+
+func runPaginationOracle(pages []interface{}, format output.Format) emitterCapture {
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	formatter := output.NewPaginatedFormatter(stdout, format)
+	var emitErr error
+	for _, page := range pages {
+		scanResult := output.ScanForSafety("lark-cli fixture +emit", page, stderr)
+		if scanResult.Blocked {
+			emitErr = scanResult.BlockErr
+			break
+		}
+		if scanResult.Alert != nil {
+			output.WriteAlertWarning(stderr, scanResult.Alert)
+		}
+		formatter.FormatPage(page)
+	}
+	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: emitErr}
+}
+
+func runEmitterStreamPages(pages []interface{}, format string) emitterCapture {
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         stdout,
+		ErrOut:      stderr,
+		CommandPath: "lark-cli fixture +emit",
+		Identity:    "bot",
+	})
+	var emitErr error
+	for _, page := range pages {
+		if emitErr = emitter.StreamPage(page, output.StreamOptions{Format: format}); emitErr != nil {
+			break
+		}
+	}
+	return emitterCapture{stdout: stdout.String(), stderr: stderr.String(), err: emitErr}
+}
+
+func TestEmitterCapturesNoticeAndColorDependencies(t *testing.T) {
+	previousNotice := output.PendingNotice
+	output.PendingNotice = func() map[string]interface{} {
+		return map[string]interface{}{"source": "global"}
+	}
+	t.Cleanup(func() { output.PendingNotice = previousNotice })
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	colorSeen := false
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:          stdout,
+		ErrOut:       stderr,
+		CommandPath:  "lark-cli fixture +emit",
+		Identity:     "bot",
+		ColorEnabled: true,
+		NoticeProvider: func() map[string]interface{} {
+			return map[string]interface{}{"source": "captured"}
+		},
+	})
+	if err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{Format: "json"}); err != nil {
+		t.Fatalf("Emitter.Success() error = %v", err)
+	}
+	if strings.Contains(stdout.String(), "global") || !strings.Contains(stdout.String(), "captured") {
+		t.Fatalf("notice source was not captured by Emitter:\n%s", stdout.String())
+	}
+
+	stdout.Reset()
+	if err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{Format: "pretty",
+		Pretty: func(w io.Writer, colorEnabled bool) error {
+			colorSeen = colorEnabled
+			_, err := fmt.Fprintln(w, "pretty")
+			return err
+		},
+	}); err != nil {
+		t.Fatalf("Emitter.Success(pretty) error = %v", err)
+	}
+	if !colorSeen {
+		t.Fatal("PrettyRenderer did not receive captured ColorEnabled value")
+	}
+
+	stdout.Reset()
+	if err := emitter.Success(map[string]interface{}{"ok": true, "id": "1"}, output.EmitOptions{Format: "yaml"}); err != nil {
+		t.Fatalf("Emitter.Success(unknown format) error = %v", err)
+	}
+	if strings.Contains(stdout.String(), "global") || !strings.Contains(stdout.String(), "captured") {
+		t.Fatalf("legacy JSON fallback consulted global notice:\n%s", stdout.String())
+	}
+}
+
+type failingEmitterWriter struct {
+	err error
+}
+
+func (w failingEmitterWriter) Write([]byte) (int, error) { return 0, w.err }
+
+func TestEmitterPropagatesOutputError(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
+	sentinel := errors.New("write failed")
+	emitter := output.NewEmitter(output.EmitterConfig{
+		Out:         failingEmitterWriter{err: sentinel},
+		ErrOut:      io.Discard,
+		CommandPath: "lark-cli fixture +emit",
+	})
+	err := emitter.Success(map[string]interface{}{"id": "1"}, output.EmitOptions{
+		Raw: true, Format: "json",
+		JQ: ".data",
+	})
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("Emitter.Success() error = %v, want preserved writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("Emitter.Success() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+}
+
+func assertEmitterBytes(t *testing.T, legacy, current emitterCapture) {
+	t.Helper()
+	if legacy.stdout != current.stdout {
+		t.Fatalf("stdout byte mismatch\nlegacy (%d bytes):\n%q\nEmitter (%d bytes):\n%q",
+			len(legacy.stdout), legacy.stdout, len(current.stdout), current.stdout)
+	}
+	if legacy.stderr != current.stderr {
+		t.Fatalf("stderr byte mismatch\nlegacy (%d bytes):\n%q\nEmitter (%d bytes):\n%q",
+			len(legacy.stderr), legacy.stderr, len(current.stderr), current.stderr)
+	}
+}
+
+func assertEmitterGolden(t *testing.T, want emitterCaptureGolden, current emitterCapture) {
+	t.Helper()
+	if want.Stdout != current.stdout {
+		t.Fatalf("stdout byte mismatch\ngolden (%d bytes):\n%q\ncurrent (%d bytes):\n%q",
+			len(want.Stdout), want.Stdout, len(current.stdout), current.stdout)
+	}
+	if want.Stderr != current.stderr {
+		t.Fatalf("stderr byte mismatch\ngolden (%d bytes):\n%q\ncurrent (%d bytes):\n%q",
+			len(want.Stderr), want.Stderr, len(current.stderr), current.stderr)
+	}
+	got := captureEmitterGolden(t, current)
+	if (want.Error == nil) != (got.Error == nil) {
+		t.Fatalf("error presence mismatch: golden=%#v current=%#v", want.Error, got.Error)
+	}
+	if want.Error == nil {
+		return
+	}
+	if want.Error.GoType != got.Error.GoType || want.Error.Message != got.Error.Message || want.Error.ExitCode != got.Error.ExitCode {
+		t.Fatalf("error mismatch:\ngolden: %#v\ncurrent: %#v", want.Error, got.Error)
+	}
+	var wantJSON interface{}
+	if err := json.Unmarshal(want.Error.JSON, &wantJSON); err != nil {
+		t.Fatalf("decode golden error JSON: %v", err)
+	}
+	var gotJSON interface{}
+	if err := json.Unmarshal(got.Error.JSON, &gotJSON); err != nil {
+		t.Fatalf("decode current error JSON: %v", err)
+	}
+	if !reflect.DeepEqual(wantJSON, gotJSON) {
+		t.Fatalf("error JSON mismatch:\ngolden: %s\ncurrent: %s", want.Error.JSON, got.Error.JSON)
+	}
+}
+
+func assertEquivalentError(t *testing.T, legacy, current error) {
+	t.Helper()
+	if (legacy == nil) != (current == nil) {
+		t.Fatalf("error presence mismatch: legacy=%v Emitter=%v", legacy, current)
+	}
+	if legacy == nil {
+		return
+	}
+	legacyProblem, legacyOK := errs.ProblemOf(legacy)
+	currentProblem, currentOK := errs.ProblemOf(current)
+	if legacyOK != currentOK {
+		t.Fatalf("typed error mismatch: legacy=%T Emitter=%T", legacy, current)
+	}
+	if legacyOK && !reflect.DeepEqual(legacyProblem, currentProblem) {
+		t.Fatalf("problem mismatch:\nlegacy: %#v\nEmitter: %#v", legacyProblem, currentProblem)
+	}
+}

internal/output/envelope_success.go

@@ -34,27 +34,17 @@ func SuccessEnvelopeData(result interface{}) interface{} {
 // JSON output carries content-safety alerts inside the envelope. When jq is
 // applied, the alert may be filtered away, so warn mode also writes stderr.
 func WriteSuccessEnvelope(data interface{}, opts SuccessEnvelopeOptions) error {
-	scanResult := ScanForSafety(opts.CommandPath, data, opts.ErrOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-
-	env := Envelope{
-		OK:       true,
-		Identity: opts.Identity,
-		DryRun:   opts.DryRun,
-		Data:     data,
-		Notice:   GetNotice(),
-	}
-	if scanResult.Alert != nil {
-		env.ContentSafetyAlert = scanResult.Alert
-	}
-	if opts.JqExpr != "" {
-		if scanResult.Alert != nil && opts.ErrOut != nil {
-			WriteAlertWarning(opts.ErrOut, scanResult.Alert)
-		}
-		return JqFilter(opts.Out, env, opts.JqExpr)
-	}
-	PrintJson(opts.Out, env)
-	return nil
+	return NewEmitter(EmitterConfig{
+		Out:            opts.Out,
+		ErrOut:         opts.ErrOut,
+		CommandPath:    opts.CommandPath,
+		Identity:       opts.Identity,
+		NoticeProvider: GetNotice,
+	}).Success(data, EmitOptions{
+		Format:          "",
+		Raw:             false,
+		JQ:              opts.JqExpr,
+		DryRun:          opts.DryRun,
+		JQSafetyWarning: true,
+	})
 }

internal/output/format.go

@@ -101,34 +101,44 @@ func ExtractItems(data interface{}) []interface{} {
 
 // FormatValue formats a single response and writes it to w.
 func FormatValue(w io.Writer, data interface{}, format Format) {
+	err := WriteFormatted(w, data, format)
+	switch {
+	case err == nil:
+		return
+	case isOutputMarshalError(err) && format == FormatNDJSON:
+		legacyStderrf("ndjson marshal error: %v\n", err)
+	case isOutputMarshalError(err):
+		legacyStderrf("json marshal error: %v\n", err)
+	}
+}
+
+// WriteFormatted formats a single response and returns marshal or write errors.
+func WriteFormatted(w io.Writer, data interface{}, format Format) error {
 	data = toGeneric(data)
 	switch format {
 	case FormatNDJSON:
 		items := ExtractItems(data)
 		if items != nil {
-			PrintNdjson(w, items)
-		} else {
-			PrintNdjson(w, data)
+			return WriteNDJSON(w, items)
 		}
+		return WriteNDJSON(w, data)
 
 	case FormatTable:
 		items := ExtractItems(data)
 		if items != nil {
-			FormatAsTable(w, items)
-		} else {
-			FormatAsTable(w, data)
+			return WriteTable(w, items)
 		}
+		return WriteTable(w, data)
 
 	case FormatCSV:
 		items := ExtractItems(data)
 		if items != nil {
-			FormatAsCSV(w, items)
-		} else {
-			FormatAsCSV(w, data)
+			return WriteCSV(w, items)
 		}
+		return WriteCSV(w, data)
 
 	default: // FormatJSON
-		PrintJson(w, data)
+		return WriteJSON(w, data)
 	}
 }
 
@@ -148,49 +158,63 @@ func NewPaginatedFormatter(w io.Writer, format Format) *PaginatedFormatter {
 
 // FormatPage formats one page of items.
 func (pf *PaginatedFormatter) FormatPage(data interface{}) {
-	switch pf.Format {
-	case FormatJSON, FormatNDJSON:
-		if arr, ok := data.([]interface{}); ok {
-			PrintNdjson(pf.W, arr)
-		} else {
-			PrintNdjson(pf.W, data)
-		}
-
-	case FormatTable:
-		pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) {
-			widths := computeColumnWidths(rows, cols)
-			if isFirst {
-				writeHeader(w, cols, widths)
-			}
-			for _, row := range rows {
-				writeRow(w, row, cols, widths)
-			}
-		})
-
-	case FormatCSV:
-		pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) {
-			writeCSVRows(w, rows, cols, isFirst)
-		})
+	err := pf.WritePage(data)
+	if isOutputMarshalError(err) && (pf.Format == FormatJSON || pf.Format == FormatNDJSON) {
+		legacyStderrf("ndjson marshal error: %v\n", err)
 	}
 }
 
+// WritePage formats one page of items and returns marshal or write errors.
+func (pf *PaginatedFormatter) WritePage(data interface{}) error {
+	switch pf.Format {
+	case FormatJSON, FormatNDJSON:
+		if arr, ok := data.([]interface{}); ok {
+			return WriteNDJSON(pf.W, arr)
+		}
+		return WriteNDJSON(pf.W, data)
+
+	case FormatTable:
+		return pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) error {
+			widths := computeColumnWidths(rows, cols)
+			if isFirst {
+				if err := writeHeader(w, cols, widths); err != nil {
+					return err
+				}
+			}
+			for _, row := range rows {
+				if err := writeRow(w, row, cols, widths); err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+
+	case FormatCSV:
+		return pf.formatStructuredPage(data, func(w io.Writer, rows []map[string]string, cols []string, isFirst bool) error {
+			return writeCSVRows(w, rows, cols, isFirst)
+		})
+	}
+	return nil
+}
+
 // formatStructuredPage handles column-locking logic shared by table and csv.
-func (pf *PaginatedFormatter) formatStructuredPage(data interface{}, emit func(io.Writer, []map[string]string, []string, bool)) {
+func (pf *PaginatedFormatter) formatStructuredPage(data interface{}, emit func(io.Writer, []map[string]string, []string, bool) error) error {
 	rows, pageCols, isList := prepareRows(data)
 	if len(rows) == 0 {
 		if pf.isFirstPage && isList {
-			fmt.Fprintln(pf.W, "(empty)")
+			_, err := fmt.Fprintln(pf.W, "(empty)")
+			return err
 		}
-		return
+		return nil
 	}
 
 	if pf.isFirstPage {
 		// Lock columns from first page
 		pf.cols = pageCols
 		pf.isFirstPage = false
-		emit(pf.W, rows, pf.cols, true)
+		return emit(pf.W, rows, pf.cols, true)
 	} else {
 		// Reuse first page's columns — missing keys become empty, extra keys ignored
-		emit(pf.W, rows, pf.cols, false)
+		return emit(pf.W, rows, pf.cols, false)
 	}
 }

internal/output/print.go

@@ -5,6 +5,7 @@ package output
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -15,12 +16,44 @@ import (
 // PrintJson prints data as formatted JSON to w.
 func PrintJson(w io.Writer, data interface{}) {
 	injectNotice(data)
+	if err := WriteJSON(w, data); isOutputMarshalError(err) {
+		legacyStderrf("json marshal error: %v\n", err)
+	}
+}
+
+type outputMarshalError struct {
+	err error
+}
+
+func (e *outputMarshalError) Error() string {
+	return e.err.Error()
+}
+
+func (e *outputMarshalError) Unwrap() error {
+	return e.err
+}
+
+func isOutputMarshalError(err error) bool {
+	var marshalErr *outputMarshalError
+	return errors.As(err, &marshalErr)
+}
+
+// legacyStderrf reports a leaf-formatter marshal/format failure on os.Stderr,
+// preserving the pre-Emitter behavior for direct (unmigrated) callers of the
+// Print*/FormatAs* wrappers. The Emitter never uses this — it returns typed
+// errors instead. Removed once the remaining direct callers migrate.
+func legacyStderrf(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, format, args...) //nolint:forbidigo // legacy leaf-formatter stderr; removed in the output-ownership follow-up
+}
+
+// WriteJSON writes data as formatted JSON to w and returns marshal or write errors.
+func WriteJSON(w io.Writer, data interface{}) error {
 	b, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "json marshal error: %v\n", err)
-		return
+		return &outputMarshalError{err: err}
 	}
-	fmt.Fprintln(w, string(b))
+	_, err = fmt.Fprintln(w, string(b))
+	return err
 }
 
 // injectNotice adds a "_notice" field into CLI envelope maps.
@@ -50,21 +83,38 @@ func injectNotice(data interface{}) {
 
 // PrintNdjson prints data as NDJSON (Newline Delimited JSON) to w.
 func PrintNdjson(w io.Writer, data interface{}) {
-	emit := func(item interface{}) {
+	if arr, ok := data.([]interface{}); ok {
+		for _, item := range arr {
+			if err := WriteNDJSON(w, item); isOutputMarshalError(err) {
+				legacyStderrf("ndjson marshal error: %v\n", err)
+			}
+		}
+		return
+	}
+	if err := WriteNDJSON(w, data); isOutputMarshalError(err) {
+		legacyStderrf("ndjson marshal error: %v\n", err)
+	}
+}
+
+// WriteNDJSON writes data as NDJSON and returns marshal or write errors.
+func WriteNDJSON(w io.Writer, data interface{}) error {
+	emit := func(item interface{}) error {
 		b, err := json.Marshal(item)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "ndjson marshal error: %v\n", err)
-			return
+			return &outputMarshalError{err: err}
 		}
-		fmt.Fprintln(w, string(b))
+		_, err = fmt.Fprintln(w, string(b))
+		return err
 	}
 	if arr, ok := data.([]interface{}); ok {
 		for _, item := range arr {
-			emit(item)
+			if err := emit(item); err != nil {
+				return err
+			}
 		}
-	} else {
-		emit(data)
+		return nil
 	}
+	return emit(data)
 }
 
 func cellStr(val interface{}) string {

internal/output/table.go

@@ -16,50 +16,69 @@ const maxColWidth = 100
 //   - map[string]interface{} (single object) → key-value two-column table
 //   - empty array → "(empty)"
 func FormatAsTable(w io.Writer, data interface{}) {
-	FormatAsTablePaginated(w, data, true)
+	if err := WriteTable(w, data); isOutputMarshalError(err) {
+		legacyStderrf("json marshal error: %v\n", err)
+	}
+}
+
+// WriteTable formats data as a table and returns marshal or write errors.
+func WriteTable(w io.Writer, data interface{}) error {
+	return WriteTablePaginated(w, data, true)
 }
 
 // FormatAsTablePaginated formats data as a table with pagination awareness.
 // When isFirstPage is true, outputs the header; otherwise only data rows.
 func FormatAsTablePaginated(w io.Writer, data interface{}, isFirstPage bool) {
+	if err := WriteTablePaginated(w, data, isFirstPage); isOutputMarshalError(err) {
+		legacyStderrf("json marshal error: %v\n", err)
+	}
+}
+
+// WriteTablePaginated formats data as a table and returns marshal or write errors.
+func WriteTablePaginated(w io.Writer, data interface{}, isFirstPage bool) error {
 	rows, cols, isList := prepareRows(data)
 	if cols == nil {
 		if isList {
-			fmt.Fprintln(w, "(empty)")
+			_, err := fmt.Fprintln(w, "(empty)")
+			return err
 		} else {
 			// Not a list and not an object — print as JSON fallback
-			PrintJson(w, data)
+			return WriteJSON(w, data)
 		}
-		return
 	}
 
 	if len(rows) == 0 {
 		if isFirstPage {
-			fmt.Fprintln(w, "(empty)")
+			_, err := fmt.Fprintln(w, "(empty)")
+			return err
 		}
-		return
+		return nil
 	}
 
 	if !isList {
 		// Single object: key-value two-column format
-		formatKeyValueTable(w, rows[0], cols)
-		return
+		return formatKeyValueTable(w, rows[0], cols)
 	}
 
 	// Calculate column widths (clamped to maxColWidth)
 	widths := computeColumnWidths(rows, cols)
 
 	if isFirstPage {
-		writeHeader(w, cols, widths)
+		if err := writeHeader(w, cols, widths); err != nil {
+			return err
+		}
 	}
 
 	for _, row := range rows {
-		writeRow(w, row, cols, widths)
+		if err := writeRow(w, row, cols, widths); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 // formatKeyValueTable renders a single object as a two-column key-value table.
-func formatKeyValueTable(w io.Writer, row map[string]string, cols []string) {
+func formatKeyValueTable(w io.Writer, row map[string]string, cols []string) error {
 	maxKeyWidth := 0
 	for _, col := range cols {
 		kw := stringWidth(col)
@@ -71,8 +90,11 @@ func formatKeyValueTable(w io.Writer, row map[string]string, cols []string) {
 	for _, col := range cols {
 		val := row[col]
 		val = truncateToWidth(val, maxColWidth)
-		fmt.Fprintf(w, "%s  %s\n", padToWidth(col, maxKeyWidth), val)
+		if _, err := fmt.Fprintf(w, "%s  %s\n", padToWidth(col, maxKeyWidth), val); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 // computeColumnWidths returns display widths for each column, clamped to maxColWidth.
@@ -99,25 +121,29 @@ func computeColumnWidths(rows []map[string]string, cols []string) []int {
 }
 
 // writeHeader writes the header row and separator line.
-func writeHeader(w io.Writer, cols []string, widths []int) {
+func writeHeader(w io.Writer, cols []string, widths []int) error {
 	var header []string
 	var sep []string
 	for i, col := range cols {
 		header = append(header, padToWidth(col, widths[i]))
 		sep = append(sep, strings.Repeat("─", widths[i]))
 	}
-	fmt.Fprintln(w, strings.Join(header, "  "))
-	fmt.Fprintln(w, strings.Join(sep, "  "))
+	if _, err := fmt.Fprintln(w, strings.Join(header, "  ")); err != nil {
+		return err
+	}
+	_, err := fmt.Fprintln(w, strings.Join(sep, "  "))
+	return err
 }
 
 // writeRow writes a single data row.
-func writeRow(w io.Writer, row map[string]string, cols []string, widths []int) {
+func writeRow(w io.Writer, row map[string]string, cols []string, widths []int) error {
 	var cells []string
 	for i, col := range cols {
 		val := truncateToWidth(row[col], widths[i])
 		cells = append(cells, padToWidth(val, widths[i]))
 	}
-	fmt.Fprintln(w, strings.Join(cells, "  "))
+	_, err := fmt.Fprintln(w, strings.Join(cells, "  "))
+	return err
 }
 
 // padToWidth pads a string with spaces to reach the target display width.

internal/output/testdata/runtime_context_legacy.golden.json

@@ -0,0 +1,107 @@
+{
+  "cases": {
+    "csv": {
+      "stdout": "id,name\n1,Alice\n2,Bob\n",
+      "stderr": ""
+    },
+    "format_raw_json_preserves_html": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"html\": \"\u003cp\u003ea\u0026b\u003c/p\u003e\"\n  }\n}\n",
+      "stderr": ""
+    },
+    "jq_invalid_expression": {
+      "stdout": "",
+      "stderr": "error: invalid jq expression: unexpected EOF\n",
+      "error": {
+        "go_type": "*errs.ValidationError",
+        "json": {
+          "type": "validation",
+          "subtype": "invalid_argument",
+          "message": "invalid jq expression: unexpected EOF"
+        },
+        "message": "invalid jq expression: unexpected EOF",
+        "exit_code": 2
+      }
+    },
+    "jq_safety_alert_without_stderr_warning": {
+      "stdout": "1\n",
+      "stderr": ""
+    },
+    "jq_scalar": {
+      "stdout": "Alice\n",
+      "stderr": ""
+    },
+    "json_object": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"enabled\": true,\n    \"id\": \"1\"\n  }\n}\n",
+      "stderr": ""
+    },
+    "metadata": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": [\n    {\n      \"id\": \"1\"\n    }\n  ],\n  \"meta\": {\n    \"count\": 1,\n    \"rollback\": \"lark-cli fixture rollback\"\n  }\n}\n",
+      "stderr": ""
+    },
+    "ndjson": {
+      "stdout": "{\"id\":\"1\"}\n{\"id\":\"2\"}\n",
+      "stderr": ""
+    },
+    "notice": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  },\n  \"_notice\": {\n    \"update\": {\n      \"latest\": \"9.9.9\"\n    }\n  }\n}\n",
+      "stderr": ""
+    },
+    "partial_failure_ok_false": {
+      "stdout": "{\n  \"ok\": false,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"failed\": 1,\n    \"succeeded\": 1\n  }\n}\n",
+      "stderr": "",
+      "error": {
+        "go_type": "*output.PartialFailureError",
+        "json": {
+          "Code": 1
+        },
+        "message": "partial failure (exit 1)",
+        "exit_code": 1
+      }
+    },
+    "pretty": {
+      "stdout": "pretty:fixture\n",
+      "stderr": ""
+    },
+    "pretty_without_renderer": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"name\": \"Alice\"\n  }\n}\n",
+      "stderr": ""
+    },
+    "raw_jq_complex": {
+      "stdout": "{\n  \"html\": \"\u003cp\u003ea\u0026b\u003c/p\u003e\"\n}\n",
+      "stderr": ""
+    },
+    "raw_json_preserves_html": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"html\": \"\u003cp\u003ea\u0026b\u003c/p\u003e\"\n  }\n}\n",
+      "stderr": ""
+    },
+    "scanner_block": {
+      "stdout": "",
+      "stderr": "",
+      "error": {
+        "go_type": "*errs.ContentSafetyError",
+        "json": {
+          "type": "policy",
+          "subtype": "content_safety",
+          "message": "content safety violation detected (rules: fixture-rule)",
+          "rules": [
+            "fixture-rule"
+          ]
+        },
+        "message": "content safety violation detected (rules: fixture-rule)",
+        "exit_code": 6
+      }
+    },
+    "scanner_error_fails_open": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  }\n}\n",
+      "stderr": "warning: content safety scan error: scanner unavailable\n"
+    },
+    "table_with_safety_warning": {
+      "stdout": "id  name \n──  ─────\n1   Alice\n",
+      "stderr": "warning: content safety alert from emitter-oracle (rules: fixture-rule)\n"
+    },
+    "unknown_format_data_envelope_notice": {
+      "stdout": "{\n  \"_notice\": {\n    \"skills\": {\n      \"current\": \"1.0.0\"\n    }\n  },\n  \"ok\": true,\n  \"value\": \"fixture\"\n}\n",
+      "stderr": "warning: unknown format \"yaml\", falling back to json\n"
+    }
+  }
+}

internal/output/testdata/write_success_envelope_legacy.golden.json

@@ -0,0 +1,41 @@
+{
+  "cases": {
+    "dry_run": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"dry_run\": true,\n  \"data\": {\n    \"api\": []\n  }\n}\n",
+      "stderr": ""
+    },
+    "jq": {
+      "stdout": "1\n",
+      "stderr": ""
+    },
+    "jq_safety_warning": {
+      "stdout": "1\n",
+      "stderr": "warning: content safety alert from emitter-oracle (rules: fixture-rule)\n"
+    },
+    "json": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  }\n}\n",
+      "stderr": ""
+    },
+    "notice": {
+      "stdout": "{\n  \"ok\": true,\n  \"identity\": \"bot\",\n  \"data\": {\n    \"id\": \"1\"\n  },\n  \"_notice\": {\n    \"update\": {\n      \"latest\": \"9.9.9\"\n    }\n  }\n}\n",
+      "stderr": ""
+    },
+    "scanner_block": {
+      "stdout": "",
+      "stderr": "",
+      "error": {
+        "go_type": "*errs.ContentSafetyError",
+        "json": {
+          "type": "policy",
+          "subtype": "content_safety",
+          "message": "content safety violation detected (rules: fixture-rule)",
+          "rules": [
+            "fixture-rule"
+          ]
+        },
+        "message": "content safety violation detected (rules: fixture-rule)",
+        "exit_code": 6
+      }
+    }
+  }
+}

internal/qualitygate/rules/dryrun.go

@@ -16,6 +16,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/qualitygate/facts"
 	"github.com/larksuite/cli/internal/qualitygate/manifest"
 	"github.com/larksuite/cli/internal/qualitygate/report"
@@ -726,7 +727,11 @@ func appendDryRunArg(raw string) ([]string, error) {
 		return nil, fmt.Errorf("not a lark-cli command")
 	}
 	argv = truncateShellTail(argv)
-	argv = forceDryRunJSONFormat(argv)
+	var jqValid bool
+	argv, jqValid = stripDryRunJQFilter(argv)
+	if jqValid {
+		argv = forceDryRunJSONFormat(argv)
+	}
 	hasDryRunArg := false
 	dryRunEnabled := false
 	for _, arg := range argv[1:] {
@@ -775,6 +780,73 @@ func truncateShellTail(argv []string) []string {
 	return argv
 }
 
+// stripDryRunJQFilter removes valid output-only jq filters from the synthetic
+// dry-run invocation. Invalid jq syntax and incompatible output flags are left
+// untouched so the real CLI execution still rejects the documented command.
+// The bool reports whether other output normalization remains safe.
+func stripDryRunJQFilter(argv []string) ([]string, bool) {
+	jqExpr, outputPath, format, hasJQ, jqHasValue := dryRunOutputFlags(argv)
+	if !hasJQ {
+		return argv, true
+	}
+	if !jqHasValue || output.ValidateJqFlags(jqExpr, outputPath, format) != nil {
+		return argv, false
+	}
+
+	out := make([]string, 0, len(argv))
+	for i := 0; i < len(argv); i++ {
+		arg := argv[i]
+		switch {
+		case arg == "--":
+			return append(out, argv[i:]...), true
+		case arg == "--jq" || arg == "-q":
+			i++
+		case strings.HasPrefix(arg, "--jq=") || strings.HasPrefix(arg, "-q="):
+			continue
+		default:
+			out = append(out, arg)
+		}
+	}
+	return out, true
+}
+
+func dryRunOutputFlags(argv []string) (jqExpr, outputPath, format string, hasJQ, jqHasValue bool) {
+	for i := 1; i < len(argv); i++ {
+		arg := argv[i]
+		if arg == "--" {
+			break
+		}
+		switch {
+		case arg == "--jq" || arg == "-q":
+			hasJQ = true
+			jqHasValue = i+1 < len(argv)
+			if jqHasValue {
+				jqExpr = argv[i+1]
+				i++
+			}
+		case strings.HasPrefix(arg, "--jq=") || strings.HasPrefix(arg, "-q="):
+			hasJQ = true
+			jqHasValue = true
+			jqExpr = arg[strings.IndexByte(arg, '=')+1:]
+		case arg == "--output":
+			if i+1 < len(argv) {
+				outputPath = argv[i+1]
+				i++
+			}
+		case strings.HasPrefix(arg, "--output="):
+			outputPath = strings.TrimPrefix(arg, "--output=")
+		case arg == "--format":
+			if i+1 < len(argv) {
+				format = argv[i+1]
+				i++
+			}
+		case strings.HasPrefix(arg, "--format="):
+			format = strings.TrimPrefix(arg, "--format=")
+		}
+	}
+	return jqExpr, outputPath, format, hasJQ, jqHasValue
+}
+
 func dryRunFlagExplicitlyTrue(arg string) bool {
 	value, ok := strings.CutPrefix(arg, "--dry-run=")
 	if !ok {

internal/qualitygate/rules/dryrun_test.go

@@ -194,6 +194,38 @@ func TestRunDryRunsIgnoresTrailingShellComment(t *testing.T) {
 	}
 }
 
+func TestRunDryRunsIgnoresJQFilterWhenValidatingRequestPreview(t *testing.T) {
+	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/im/v1/flags"}]}`)
+	m := manifest.Manifest{Commands: []manifest.Command{{
+		Path:       "im +flag-list",
+		Runnable:   true,
+		Identities: []string{"user"},
+		Flags: []manifest.Flag{
+			{Name: "as", TakesValue: true},
+			{Name: "page-all"},
+			{Name: "jq", Shorthand: "q", TakesValue: true},
+			{Name: "dry-run"},
+		},
+	}}}
+	ex := skillscan.Example{
+		Raw:        `lark-cli im +flag-list --as user --page-all -q '.data.flag_items[-1]'`,
+		SourceFile: "skills/lark-im/references/lark-im-flag-list.md",
+		Line:       26,
+	}
+
+	diags, facts := RunDryRuns(context.Background(), cliBin, m, []skillscan.Example{ex})
+	if len(diags) != 0 {
+		t.Fatalf("RunDryRuns() diagnostics = %#v", diags)
+	}
+	if len(facts) != 1 || !facts[0].Executable || facts[0].SkipReason != "" {
+		t.Fatalf("jq example should remain executable: %#v", facts)
+	}
+	wantArgs := []string{"im", "+flag-list", "--as", "user", "--page-all", "--dry-run"}
+	if gotArgs := readArgs(t, argsPath); !reflect.DeepEqual(gotArgs, wantArgs) {
+		t.Fatalf("fake CLI args = %#v, want %#v", gotArgs, wantArgs)
+	}
+}
+
 func TestRunDryRunsMaterializesPlaceholdersInsideJSONFlags(t *testing.T) {
 	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/im/v1/messages","params":{"chat_id":"oc_test123","page_token":"page_test123"}}]}`)
 	m := manifest.Manifest{Commands: []manifest.Command{{
@@ -795,6 +827,72 @@ func TestAppendDryRunArgForcesInlineJSONFormat(t *testing.T) {
 	}
 }
 
+func TestAppendDryRunArgRemovesJQFilter(t *testing.T) {
+	tests := []struct {
+		name string
+		raw  string
+		want []string
+	}{
+		{
+			name: "short split",
+			raw:  `lark-cli im +flag-list --page-all -q '.data.flag_items[-1]'`,
+			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
+		},
+		{
+			name: "long split",
+			raw:  `lark-cli im +flag-list --jq '.data.flag_items[].item_id' --page-all`,
+			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
+		},
+		{
+			name: "short inline",
+			raw:  `lark-cli im +flag-list -q='.data.flag_items[-1]' --page-all`,
+			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
+		},
+		{
+			name: "long inline",
+			raw:  `lark-cli im +flag-list --jq='.data.flag_items[-1]' --page-all`,
+			want: []string{"im", "+flag-list", "--page-all", "--dry-run"},
+		},
+		{
+			name: "missing value remains invalid",
+			raw:  `lark-cli im +flag-list --page-all --jq`,
+			want: []string{"im", "+flag-list", "--page-all", "--jq", "--dry-run"},
+		},
+		{
+			name: "next flag is not accepted as jq expression",
+			raw:  `lark-cli im +flag-list --jq --page-all`,
+			want: []string{"im", "+flag-list", "--jq", "--page-all", "--dry-run"},
+		},
+		{
+			name: "invalid expression remains invalid",
+			raw:  `lark-cli im +flag-list --jq 'invalid[' --page-all`,
+			want: []string{"im", "+flag-list", "--jq", "invalid[", "--page-all", "--dry-run"},
+		},
+		{
+			name: "incompatible pretty format remains invalid",
+			raw:  `lark-cli im +flag-list --jq '.data' --format pretty`,
+			want: []string{"im", "+flag-list", "--jq", ".data", "--format", "pretty", "--dry-run"},
+		},
+		{
+			name: "compatible json format preserves request preview",
+			raw:  `lark-cli im +flag-list --jq '.data' --format json`,
+			want: []string{"im", "+flag-list", "--format", "json", "--dry-run"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := appendDryRunArg(tt.raw)
+			if err != nil {
+				t.Fatalf("appendDryRunArg() error = %v", err)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Fatalf("appendDryRunArg() = %#v, want %#v", got, tt.want)
+			}
+		})
+	}
+}
+
 func TestAppendDryRunArgPreservesNonPrettyFormat(t *testing.T) {
 	for _, raw := range []string{
 		"lark-cli mail +watch --format data --dry-run",

internal/registry/registry_test.go

@@ -101,6 +101,7 @@ func TestSelectRecommendedScope_Empty(t *testing.T) {
 }
 
 func TestComputeMinimumScopeSet(t *testing.T) {
+	ensureFreshRegistry(t)
 	minSet := ComputeMinimumScopeSet("user")
 	if len(minSet) == 0 {
 		if len(ListFromMetaProjects()) == 0 {

internal/registry/registrytest/fixture_meta.json

@@ -0,0 +1,72 @@
+{
+  "version": "0.0.1",
+  "services": [
+    {
+      "name": "calendar",
+      "version": "v4",
+      "title": "Calendar API",
+      "servicePath": "/open-apis/calendar/v4",
+      "resources": {
+        "events": {
+          "methods": {
+            "create": {
+              "path": "calendars/{calendar_id}/events",
+              "httpMethod": "POST",
+              "risk": "write",
+              "scopes": [
+                "calendar:calendar.event:create"
+              ],
+              "parameters": {
+                "calendar_id": {
+                  "type": "string",
+                  "location": "path",
+                  "required": true
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "name": "im",
+      "version": "v1",
+      "title": "IM API",
+      "servicePath": "/open-apis/im/v1",
+      "resources": {
+        "chat.members": {
+          "methods": {
+            "create": {
+              "path": "chats/{chat_id}/members",
+              "httpMethod": "POST",
+              "risk": "write",
+              "scopes": [
+                "im:chat",
+                "im:chat.members:write_only"
+              ],
+              "parameters": {
+                "chat_id": {
+                  "type": "string",
+                  "location": "path",
+                  "required": true
+                },
+                "member_id_type": {
+                  "type": "string",
+                  "location": "query",
+                  "required": false
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "name": "task",
+      "version": "v2",
+      "title": "Task API",
+      "servicePath": "/open-apis/task/v2",
+      "resources": {}
+    }
+  ]
+}

internal/registry/registrytest/registrytest.go

@@ -0,0 +1,146 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package registrytest seeds the registry with a tracked metadata fixture so
+// command-tree tests pass on a clean checkout — no `make fetch_meta`, no
+// network, no user cache. TestMain funcs of packages that build service
+// commands call Seed after redirecting LARKSUITE_CLI_CONFIG_DIR.
+package registrytest
+
+import (
+	_ "embed"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/registry"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+// fixtureMetaJSON is a trimmed snapshot of the generated meta_data.json
+// holding only the calendar, im and task services that registry-backed tests
+// assert against. Its version is pinned to "0.0.1": newer than the empty
+// embedded stub ("0.0.0") so it wins on a clean checkout, older than any real
+// generated catalog ("1.0.0"+) so a `make fetch_meta` build keeps testing the
+// full embedded data.
+//
+//go:embed fixture_meta.json
+var fixtureMetaJSON []byte
+
+// Seed writes fixtureMetaJSON into the registry remote-meta cache under
+// LARKSUITE_CLI_CONFIG_DIR and eagerly initializes the registry. testRoot must
+// be the temporary root created by the caller's TestMain; Seed rejects a config
+// directory outside it before performing any write. The cache
+// meta is stamped fresh so Init never sync-fetches or background-refreshes
+// over the network. Eager Init pins the catalog for the whole test process before
+// any individual test can re-point LARKSUITE_CLI_CONFIG_DIR elsewhere.
+//
+// The caller's TestMain must set LARKSUITE_CLI_CONFIG_DIR beneath testRoot
+// first; Seed refuses unset, mismatched, or escaping paths so it can never
+// write into a developer's real ~/.lark-cli.
+func Seed(testRoot string) error {
+	configDir := os.Getenv("LARKSUITE_CLI_CONFIG_DIR")
+	if err := validateConfigDir(testRoot, configDir); err != nil {
+		return err
+	}
+
+	var fixture struct {
+		Version string `json:"version"`
+	}
+	if err := json.Unmarshal(fixtureMetaJSON, &fixture); err != nil {
+		return err
+	}
+
+	cacheDir := filepath.Join(configDir, "cache")
+	if err := vfs.MkdirAll(cacheDir, 0o700); err != nil {
+		return err
+	}
+	if err := vfs.WriteFile(filepath.Join(cacheDir, "remote_meta.json"), fixtureMetaJSON, 0o644); err != nil {
+		return err
+	}
+	cacheMeta, err := json.Marshal(registry.CacheMeta{
+		LastCheckAt: time.Now().Unix(),
+		Version:     fixture.Version,
+		Brand:       string(core.BrandFeishu),
+	})
+	if err != nil {
+		return err
+	}
+	if err := vfs.WriteFile(filepath.Join(cacheDir, "remote_meta.meta.json"), cacheMeta, 0o644); err != nil {
+		return err
+	}
+
+	// Neutralize ambient knobs that would defeat the seeding: an inherited
+	// LARKSUITE_CLI_REMOTE_META=off would stop Init from reading the seeded
+	// cache at all, and LARKSUITE_CLI_META_TTL=0 would expire the freshness
+	// stamp and start a background network refresh from inside unit tests.
+	if err := os.Unsetenv("LARKSUITE_CLI_REMOTE_META"); err != nil {
+		return err
+	}
+	if err := os.Unsetenv("LARKSUITE_CLI_META_TTL"); err != nil {
+		return err
+	}
+
+	registry.Init()
+
+	// Init is a sync.Once, so the seed is pinned for the whole test process.
+	// Turning remote metadata off afterwards cannot un-seed anything; it is a
+	// guard for any future post-Init code path that might consult the remote
+	// cache again after a test re-points LARKSUITE_CLI_CONFIG_DIR elsewhere.
+	if err := os.Setenv("LARKSUITE_CLI_REMOTE_META", "off"); err != nil {
+		return err
+	}
+
+	// Self-check: both the fixture and any real generated catalog contain the
+	// im service. If it is missing, the cache seeding silently stopped working
+	// (e.g. the registry cache file names or freshness semantics changed) and
+	// every registry-backed test would fail confusingly — fail loudly here
+	// instead, pointing at this package.
+	merged, ok := registry.ServiceTyped("im")
+	if !ok {
+		return errors.New("registrytest.Seed: registry has no im service after seeding — " +
+			"the remote-cache format in internal/registry/remote.go may have changed; update registrytest to match")
+	}
+
+	// Self-check: on a fetch_meta build the real embedded catalog must win over
+	// the 0.0.1 fixture. If the merged im service diverges from the embedded
+	// one, the version arbitration flipped (e.g. the generated catalog version
+	// stopped parsing as semver) and unit tests would silently run against the
+	// stale trimmed fixture instead of the fresh catalog.
+	for _, service := range registry.EmbeddedServicesTyped() {
+		if service.Name != "im" {
+			continue
+		}
+		if service.Version != merged.Version {
+			return errors.New("registrytest.Seed: the fixture shadowed the real embedded catalog — " +
+				"check the meta_data.json version against the fixture's \"0.0.1\" arbitration in this package")
+		}
+		break
+	}
+	return nil
+}
+
+// validateConfigDir guards the one real hazard: a TestMain wiring mistake
+// pointing LARKSUITE_CLI_CONFIG_DIR at a developer's real directory. Both
+// paths come from the caller's own MkdirTemp, so a plain containment check
+// is enough.
+func validateConfigDir(testRoot, configDir string) error {
+	if testRoot == "" || configDir == "" {
+		return errors.New("registrytest.Seed: test root and config dir must be set")
+	}
+	if !filepath.IsAbs(testRoot) || !filepath.IsAbs(configDir) {
+		return errors.New("registrytest.Seed: test root and config dir must be absolute")
+	}
+	rel, err := filepath.Rel(filepath.Clean(testRoot), filepath.Clean(configDir))
+	if err != nil {
+		return err
+	}
+	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return errors.New("registrytest.Seed: config dir must stay inside the test root")
+	}
+	return nil
+}

internal/registry/registrytest/registrytest_test.go

@@ -0,0 +1,229 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package registrytest
+
+import (
+	"net/http"
+	"os"
+	"path/filepath"
+	"slices"
+	"sort"
+	"testing"
+
+	"github.com/larksuite/cli/internal/meta"
+	"github.com/larksuite/cli/internal/registry"
+)
+
+func TestValidateConfigDir(t *testing.T) {
+	root := t.TempDir()
+	tests := []struct {
+		name      string
+		testRoot  string
+		configDir string
+		wantErr   bool
+	}{
+		{name: "equal", testRoot: root, configDir: root},
+		{name: "child", testRoot: root, configDir: filepath.Join(root, "config")},
+		{
+			name:      "sibling",
+			testRoot:  root,
+			configDir: filepath.Join(filepath.Dir(root), "outside"),
+			wantErr:   true,
+		},
+		{name: "empty root", configDir: root, wantErr: true},
+		{name: "empty config", testRoot: root, wantErr: true},
+		{name: "relative root", testRoot: "relative", configDir: root, wantErr: true},
+		{name: "relative config", testRoot: root, configDir: "relative", wantErr: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateConfigDir(tt.testRoot, tt.configDir)
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("validateConfigDir() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestFixtureContract(t *testing.T) {
+	if len(fixtureMetaJSON) > 20<<10 {
+		t.Fatalf("fixture size = %d, want <= %d", len(fixtureMetaJSON), 20<<10)
+	}
+	reg, err := meta.Parse(fixtureMetaJSON)
+	if err != nil {
+		t.Fatalf("meta.Parse() error = %v", err)
+	}
+	if reg.Version != "0.0.1" {
+		t.Fatalf("fixture version = %q, want 0.0.1", reg.Version)
+	}
+
+	gotNames := make([]string, 0, len(reg.Services))
+	for _, service := range reg.Services {
+		gotNames = append(gotNames, service.Name)
+	}
+	sort.Strings(gotNames)
+	if !slices.Equal(gotNames, []string{"calendar", "im", "task"}) {
+		t.Fatalf("fixture services = %v, want [calendar im task]", gotNames)
+	}
+
+	calendarCreate := fixtureMethod(t, reg, "calendar", "events", "create")
+	assertMethodContract(t, calendarCreate, "calendars/{calendar_id}/events", http.MethodPost)
+	calendarID, ok := calendarCreate.Parameters["calendar_id"]
+	if !ok || calendarID.Location != "path" || !calendarID.Required {
+		t.Fatalf("calendar_id = %+v, want required path parameter", calendarID)
+	}
+	if !slices.Contains(calendarCreate.Scopes, "calendar:calendar.event:create") {
+		t.Fatalf("calendar create scopes = %v, want calendar:calendar.event:create", calendarCreate.Scopes)
+	}
+
+	imCreate := fixtureMethod(t, reg, "im", "chat.members", "create")
+	assertMethodContract(t, imCreate, "chats/{chat_id}/members", http.MethodPost)
+	chatID, ok := imCreate.Parameters["chat_id"]
+	if !ok || chatID.Location != "path" || !chatID.Required {
+		t.Fatalf("chat_id = %+v, want required path parameter", chatID)
+	}
+	memberIDType, ok := imCreate.Parameters["member_id_type"]
+	if !ok || memberIDType.Location != "query" || memberIDType.Required {
+		t.Fatalf("member_id_type = %+v, want optional query parameter", memberIDType)
+	}
+	if imCreate.Risk != "write" {
+		t.Fatalf("im create risk = %q, want write", imCreate.Risk)
+	}
+	for _, scope := range []string{"im:chat", "im:chat.members:write_only"} {
+		if !slices.Contains(imCreate.Scopes, scope) {
+			t.Fatalf("im create scopes = %v, want %s", imCreate.Scopes, scope)
+		}
+	}
+}
+
+func fixtureMethod(t *testing.T, reg meta.Registry, serviceName, resourceName, methodName string) meta.Method {
+	t.Helper()
+	for _, service := range reg.Services {
+		if service.Name != serviceName {
+			continue
+		}
+		resource, ok := service.Resource(resourceName)
+		if !ok {
+			t.Fatalf("fixture service %s has no resource %s", serviceName, resourceName)
+		}
+		method, ok := resource.Method(methodName)
+		if !ok {
+			t.Fatalf("fixture resource %s.%s has no method %s", serviceName, resourceName, methodName)
+		}
+		return method
+	}
+	t.Fatalf("fixture has no service %s", serviceName)
+	return meta.Method{}
+}
+
+func assertMethodContract(t *testing.T, method meta.Method, path, httpMethod string) {
+	t.Helper()
+	if method.Path != path || method.HTTPMethod != httpMethod {
+		t.Fatalf("method = %s %s, want %s %s", method.HTTPMethod, method.Path, httpMethod, path)
+	}
+}
+
+// TestSeedRejectsUnsafeConfigDir pins Seed's guard: it must return before
+// writing anything when LARKSUITE_CLI_CONFIG_DIR is unset or escapes the
+// caller's test root, so a TestMain wiring mistake can never touch a
+// developer's real ~/.lark-cli.
+func TestSeedRejectsUnsafeConfigDir(t *testing.T) {
+	root := t.TempDir()
+
+	t.Run("unset config dir", func(t *testing.T) {
+		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", "")
+		if err := Seed(root); err == nil {
+			t.Fatal("Seed() error = nil, want unset config dir rejection")
+		}
+	})
+
+	t.Run("config dir outside test root", func(t *testing.T) {
+		outside := t.TempDir()
+		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", outside)
+		if err := Seed(root); err == nil {
+			t.Fatal("Seed() error = nil, want containment rejection")
+		}
+		if _, err := os.Stat(filepath.Join(outside, "cache")); err == nil {
+			t.Fatal("Seed wrote into the rejected config dir")
+		}
+	})
+}
+
+// TestSeedWritesFixtureAndInitializesRegistry covers the seeding happy path:
+// cache files land under the config dir, the registry initializes from them,
+// and both self-checks pass.
+func TestSeedWritesFixtureAndInitializesRegistry(t *testing.T) {
+	root := t.TempDir()
+	configDir := filepath.Join(root, "config")
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+
+	if err := Seed(root); err != nil {
+		t.Fatalf("Seed() error = %v, want nil", err)
+	}
+	for _, name := range []string{"remote_meta.json", "remote_meta.meta.json"} {
+		if _, err := os.Stat(filepath.Join(configDir, "cache", name)); err != nil {
+			t.Errorf("cache file %s: %v", name, err)
+		}
+	}
+	if got := os.Getenv("LARKSUITE_CLI_REMOTE_META"); got != "off" {
+		t.Errorf("LARKSUITE_CLI_REMOTE_META = %q, want off after seeding", got)
+	}
+	for _, service := range []string{"calendar", "im", "task"} {
+		if _, ok := registry.ServiceTyped(service); !ok {
+			t.Errorf("registry missing service %s after seeding", service)
+		}
+	}
+}
+
+// TestSeedPropagatesCacheSetupFailures pins that filesystem failures while
+// materializing the cache surface as errors instead of leaving the registry
+// silently unseeded. Each obstacle is a same-named file/directory in the
+// way, which fails on every platform without permission tricks.
+func TestSeedPropagatesCacheSetupFailures(t *testing.T) {
+	seedWith := func(t *testing.T, prepare func(root, configDir string)) error {
+		t.Helper()
+		root := t.TempDir()
+		configDir := filepath.Join(root, "config")
+		prepare(root, configDir)
+		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+		return Seed(root)
+	}
+
+	t.Run("cache dir creation fails", func(t *testing.T) {
+		err := seedWith(t, func(root, configDir string) {
+			// config is a regular file, so MkdirAll(config/cache) fails.
+			if err := os.WriteFile(configDir, nil, 0o600); err != nil {
+				t.Fatal(err)
+			}
+		})
+		if err == nil {
+			t.Fatal("Seed() error = nil, want cache dir creation failure")
+		}
+	})
+
+	t.Run("fixture write fails", func(t *testing.T) {
+		err := seedWith(t, func(root, configDir string) {
+			// remote_meta.json is a directory, so WriteFile fails.
+			if err := os.MkdirAll(filepath.Join(configDir, "cache", "remote_meta.json"), 0o700); err != nil {
+				t.Fatal(err)
+			}
+		})
+		if err == nil {
+			t.Fatal("Seed() error = nil, want fixture write failure")
+		}
+	})
+
+	t.Run("cache meta write fails", func(t *testing.T) {
+		err := seedWith(t, func(root, configDir string) {
+			// remote_meta.meta.json is a directory, so WriteFile fails.
+			if err := os.MkdirAll(filepath.Join(configDir, "cache", "remote_meta.meta.json"), 0o700); err != nil {
+				t.Fatal(err)
+			}
+		})
+		if err == nil {
+			t.Fatal("Seed() error = nil, want cache meta write failure")
+		}
+	})
+}

internal/registry/testmain_test.go

@@ -0,0 +1,27 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package registry
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	root, err := os.MkdirTemp("", "lark-cli-registry-test-*")
+	if err != nil {
+		panic(err)
+	}
+	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
+		panic(err)
+	}
+	code := m.Run()
+	// A test that ran Init without a trailing resetInit can leave a background
+	// refresh goroutine alive; removing the temp root while it writes would
+	// let it recreate the directory after cleanup. Wait it out first.
+	waitBackgroundRefresh()
+	_ = os.RemoveAll(root)
+	os.Exit(code)
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/cli",
-  "version": "1.0.73",
+  "version": "1.0.74",
   "description": "The official CLI for Lark/Feishu open platform",
   "bin": {
     "lark-cli": "scripts/run.js"

shortcuts/base/base_execute_test.go

@@ -2014,16 +2014,14 @@ func TestBaseRecordExecuteReadCreateDelete(t *testing.T) {
 			Body: map[string]interface{}{
 				"code": 0,
 				"data": map[string]interface{}{
-					"has_more":       false,
-					"record_id_list": []interface{}{"rec_1"},
-					"update":         map[string]interface{}{"Status": "Done"},
+					"ignored_fields": []interface{}{"Formula"},
 				},
 			},
 		})
-		if err := runShortcut(t, BaseRecordBatchUpdate, []string{"+record-batch-update", "--base-token", "app_x", "--table-id", "tbl_x", "--json", `{"record_id_list":["rec_1"],"patch":{"Status":"Done"}}`}, factory, stdout); err != nil {
+		if err := runShortcut(t, BaseRecordBatchUpdate, []string{"+record-batch-update", "--base-token", "app_x", "--table-id", "tbl_x", "--json", `{"update_records":{"rec_1":{"Status":["Done"]}}}`}, factory, stdout); err != nil {
 			t.Fatalf("err=%v", err)
 		}
-		if got := stdout.String(); !strings.Contains(got, `"record_id_list"`) || !strings.Contains(got, `"update"`) || !strings.Contains(got, `"Done"`) {
+		if got := stdout.String(); !strings.Contains(got, `"ignored_fields"`) || !strings.Contains(got, `"Formula"`) {
 			t.Fatalf("stdout=%s", got)
 		}
 	})
@@ -2035,20 +2033,16 @@ func TestBaseRecordExecuteReadCreateDelete(t *testing.T) {
 			URL:    "/open-apis/base/v3/bases/app_x/tables/tbl_x/records/batch_update",
 			Body: map[string]interface{}{
 				"code": 0,
-				"data": map[string]interface{}{
-					"record_id_list": []interface{}{"rec_1"},
-				},
+				"data": map[string]interface{}{},
 			},
 		}
 		reg.Register(updateStub)
-		if err := runShortcut(t, BaseRecordBatchUpdate, []string{"+record-batch-update", "--base-token", "app_x", "--table-id", "tbl_x", "--json", `{"record_id_list":["rec_1"],"patch":{"Name":"Alice","Status":"Done"}}`}, factory, stdout); err != nil {
+		input := `{"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}}`
+		if err := runShortcut(t, BaseRecordBatchUpdate, []string{"+record-batch-update", "--base-token", "app_x", "--table-id", "tbl_x", "--json", input}, factory, stdout); err != nil {
 			t.Fatalf("err=%v", err)
 		}
-		if got := stdout.String(); !strings.Contains(got, `"record_id_list"`) || !strings.Contains(got, `"rec_1"`) {
-			t.Fatalf("stdout=%s", got)
-		}
 		body := string(updateStub.CapturedBody)
-		if !strings.Contains(body, `"record_id_list":["rec_1"]`) || !strings.Contains(body, `"patch":{"Name":"Alice","Status":"Done"}`) {
+		if !strings.Contains(body, `"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}`) {
 			t.Fatalf("request body=%s", body)
 		}
 	})

shortcuts/base/base_shortcuts_test.go

@@ -786,7 +786,8 @@ func TestBaseJSONExamplesLiveInFlagDescriptions(t *testing.T) {
 			name:     "record batch update json",
 			shortcut: BaseRecordBatchUpdate,
 			wantHelp: []string{
-				`batch update JSON object, e.g. {"record_id_list":["rec_xxx"],"patch":{"Status":"Done"}}; same patch applies to all records`,
+				"update_records maps each record ID to its field map",
+				`{"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}}`,
 			},
 		},
 	}
@@ -854,9 +855,11 @@ func TestBaseRecordWriteHelpGuidesAgents(t *testing.T) {
 			name:     "record batch update",
 			shortcut: BaseRecordBatchUpdate,
 			wantTips: []string{
-				"Happy path fields: record_id_list is the target record IDs",
-				"patch is a field map applied unchanged to every target record",
-				"Do not use +record-batch-update for per-row different values",
+				"Happy path field: update_records",
+				"update_records maps each record ID to its own field map",
+				`{"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}}`,
+				"contains only optional ignored_fields",
+				"does not check whether record IDs exist",
 				"use +field-list to confirm real writable fields",
 				"Batch update supports max 200 records per call",
 				"CellValue happy path: text/phone/url",

shortcuts/base/record_batch_update.go

@@ -12,18 +12,19 @@ import (
 var BaseRecordBatchUpdate = common.Shortcut{
 	Service:     "base",
 	Command:     "+record-batch-update",
-	Description: "Batch update records",
+	Description: "Batch update records with record-specific fields",
 	Risk:        "write",
 	Scopes:      []string{"base:record:update"},
 	AuthTypes:   authTypes(),
 	Flags: []common.Flag{
 		baseTokenFlag(true),
 		tableRefFlag(true),
-		{Name: "json", Desc: `batch update JSON object, e.g. {"record_id_list":["rec_xxx"],"patch":{"Status":"Done"}}; same patch applies to all records`, Required: true},
+		{Name: "json", Desc: `batch update JSON object; update_records maps each record ID to its field map, e.g. {"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}}`, Required: true},
 	},
 	Tips: append([]string{
-		"Happy path fields: record_id_list is the target record IDs; patch is a field map applied unchanged to every target record.",
-		"Do not use +record-batch-update for per-row different values; call +record-upsert per record or use another supported flow.",
+		"Happy path field: update_records maps each record ID to its own field map.",
+		`Example: {"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}}.`,
+		"The response contains only optional ignored_fields and does not check whether record IDs exist; read records back when confirmation is required.",
 		"Before writing, use +field-list to confirm real writable fields; do not write system fields, formula, lookup, or attachment fields as normal CellValue.",
 		"Batch update supports max 200 records per call; use the record-batch-update guide for command limits and edge cases.",
 	}, recordCellValueHappyPathTips...),

shortcuts/common/runner.go

@@ -665,16 +665,59 @@ func (ctx *RuntimeContext) ValidatePath(path string) error {
 
 // ── Output helpers ──
 
+func (ctx *RuntimeContext) newEmitter() *output.Emitter {
+	streams := ctx.IO()
+	return output.NewEmitter(output.EmitterConfig{
+		Out:            streams.Out,
+		ErrOut:         streams.ErrOut,
+		CommandPath:    ctx.Cmd.CommandPath(),
+		Identity:       string(ctx.As()),
+		ColorEnabled:   streams.OutIsTerminal,
+		NoticeProvider: output.GetNotice,
+	})
+}
+
+func (ctx *RuntimeContext) handleEmitterError(err error) {
+	if err == nil {
+		return
+	}
+	var cs *errs.ContentSafetyError
+	if ctx.JqExpr != "" && !errors.As(err, &cs) {
+		fmt.Fprintf(ctx.IO().ErrOut, "error: %v\n", err)
+	}
+	ctx.outputErrOnce.Do(func() { ctx.outputErr = err })
+}
+
+func wrapLegacyPrettyRenderer(prettyFn func(w io.Writer)) output.PrettyRenderer {
+	if prettyFn == nil {
+		return nil
+	}
+	return func(w io.Writer, _ bool) error {
+		prettyFn(w)
+		return nil
+	}
+}
+
 // Out prints a success JSON envelope to stdout.
 func (ctx *RuntimeContext) Out(data interface{}, meta *output.Meta) {
-	ctx.emit(data, meta, false, true)
+	ctx.handleEmitterError(ctx.newEmitter().Success(data, output.EmitOptions{
+		Format: "",
+		Raw:    false,
+		JQ:     ctx.JqExpr,
+		Meta:   meta,
+	}))
 }
 
 // OutRaw prints a success JSON envelope to stdout with HTML escaping disabled.
 // Use this instead of Out when the data contains XML/HTML content (e.g. document bodies)
 // that should be preserved as-is in JSON output.
 func (ctx *RuntimeContext) OutRaw(data interface{}, meta *output.Meta) {
-	ctx.emit(data, meta, true, true)
+	ctx.handleEmitterError(ctx.newEmitter().Success(data, output.EmitOptions{
+		Format: "",
+		Raw:    true,
+		JQ:     ctx.JqExpr,
+		Meta:   meta,
+	}))
 }
 
 // OutPartialFailure writes an ok:false multi-status result envelope to stdout
@@ -688,112 +731,42 @@ func (ctx *RuntimeContext) OutRaw(data interface{}, meta *output.Meta) {
 // ok:true, and the exit signal is distinct from ErrBare (the
 // stdout-carries-the-answer silent-exit signal).
 func (ctx *RuntimeContext) OutPartialFailure(data interface{}, meta *output.Meta) error {
-	ctx.emit(data, meta, false, false)
+	ctx.handleEmitterError(ctx.newEmitter().PartialFailure(data, output.EmitOptions{
+		Format: "",
+		Raw:    false,
+		JQ:     ctx.JqExpr,
+		Meta:   meta,
+	}))
 	if ctx.outputErr != nil {
 		return ctx.outputErr
 	}
 	return output.PartialFailure(output.ExitAPI)
 }
 
-// emit is the shared stdout envelope emitter; ok sets the envelope's ok field
-// (true for success, false for a partial-failure result). raw=true disables JSON
-// HTML escaping so XML/HTML payloads (e.g. DocxXML bodies) are preserved
-// verbatim; otherwise behavior
-// is identical — content-safety scanning and race-safe first-error capture via
-// outputErrOnce apply in both modes.
-func (ctx *RuntimeContext) emit(data interface{}, meta *output.Meta, raw, ok bool) {
-	scanResult := output.ScanForSafety(ctx.Cmd.CommandPath(), data, ctx.IO().ErrOut)
-	if scanResult.Blocked {
-		ctx.outputErrOnce.Do(func() { ctx.outputErr = scanResult.BlockErr })
-		return
-	}
-
-	env := output.Envelope{OK: ok, Identity: string(ctx.As()), Data: data, Meta: meta, Notice: output.GetNotice()}
-	if scanResult.Alert != nil {
-		env.ContentSafetyAlert = scanResult.Alert
-	}
-
-	if ctx.JqExpr != "" {
-		filter := output.JqFilter
-		if raw {
-			filter = output.JqFilterRaw
-		}
-		if err := filter(ctx.IO().Out, env, ctx.JqExpr); err != nil {
-			fmt.Fprintf(ctx.IO().ErrOut, "error: %v\n", err)
-			ctx.outputErrOnce.Do(func() { ctx.outputErr = err })
-		}
-		return
-	}
-
-	if raw {
-		enc := json.NewEncoder(ctx.IO().Out)
-		enc.SetEscapeHTML(false)
-		enc.SetIndent("", "  ")
-		_ = enc.Encode(env)
-		return
-	}
-	b, _ := json.MarshalIndent(env, "", "  ")
-	fmt.Fprintln(ctx.IO().Out, string(b))
-}
-
 // OutFormat prints output based on --format flag.
 // "json" (default) outputs JSON envelope; "pretty" calls prettyFn; others delegate to FormatValue.
-// When JqExpr is set, routes through Out() regardless of format.
-// For json/"" and jq paths, Out() handles content safety scanning.
-// For pretty/table/csv/ndjson, scanning is done here and the alert is written to stderr.
+// When JqExpr is set, envelope filtering takes precedence over format.
+// The Emitter handles content safety scanning for every format.
 func (ctx *RuntimeContext) OutFormat(data interface{}, meta *output.Meta, prettyFn func(w io.Writer)) {
-	ctx.outFormat(data, meta, prettyFn, false)
+	ctx.handleEmitterError(ctx.newEmitter().Success(data, output.EmitOptions{
+		Format: ctx.Format,
+		Raw:    false,
+		JQ:     ctx.JqExpr,
+		Meta:   meta,
+		Pretty: wrapLegacyPrettyRenderer(prettyFn),
+	}))
 }
 
 // OutFormatRaw is like OutFormat but with HTML escaping disabled in JSON output.
 // Use this when the data contains XML/HTML content that should be preserved as-is.
 func (ctx *RuntimeContext) OutFormatRaw(data interface{}, meta *output.Meta, prettyFn func(w io.Writer)) {
-	ctx.outFormat(data, meta, prettyFn, true)
-}
-
-func (ctx *RuntimeContext) outFormat(data interface{}, meta *output.Meta, prettyFn func(w io.Writer), raw bool) {
-	outFn := ctx.Out
-	if raw {
-		outFn = ctx.OutRaw
-	}
-	if ctx.JqExpr != "" {
-		outFn(data, meta)
-		return
-	}
-	switch ctx.Format {
-	case "pretty":
-		scanResult := output.ScanForSafety(ctx.Cmd.CommandPath(), data, ctx.IO().ErrOut)
-		if scanResult.Blocked {
-			ctx.outputErrOnce.Do(func() { ctx.outputErr = scanResult.BlockErr })
-			return
-		}
-		if scanResult.Alert != nil {
-			output.WriteAlertWarning(ctx.IO().ErrOut, scanResult.Alert)
-		}
-		if prettyFn != nil {
-			prettyFn(ctx.IO().Out)
-		} else {
-			outFn(data, meta)
-		}
-	case "json", "":
-		outFn(data, meta)
-	default:
-		// table, csv, ndjson — pass data directly; FormatValue handles both
-		// plain arrays and maps with array fields (e.g. {"members":[…]})
-		scanResult := output.ScanForSafety(ctx.Cmd.CommandPath(), data, ctx.IO().ErrOut)
-		if scanResult.Blocked {
-			ctx.outputErrOnce.Do(func() { ctx.outputErr = scanResult.BlockErr })
-			return
-		}
-		if scanResult.Alert != nil {
-			output.WriteAlertWarning(ctx.IO().ErrOut, scanResult.Alert)
-		}
-		format, formatOK := output.ParseFormat(ctx.Format)
-		if !formatOK {
-			fmt.Fprintf(ctx.IO().ErrOut, "warning: unknown format %q, falling back to json\n", ctx.Format)
-		}
-		output.FormatValue(ctx.IO().Out, data, format)
-	}
+	ctx.handleEmitterError(ctx.newEmitter().Success(data, output.EmitOptions{
+		Format: ctx.Format,
+		Raw:    true,
+		JQ:     ctx.JqExpr,
+		Meta:   meta,
+		Pretty: wrapLegacyPrettyRenderer(prettyFn),
+	}))
 }
 
 // ── Scope pre-check ──

shortcuts/common/runner_contentsafety_test.go

@@ -7,10 +7,12 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"testing"
 
 	"github.com/spf13/cobra"
 
+	"github.com/larksuite/cli/errs"
 	extcs "github.com/larksuite/cli/extension/contentsafety"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
@@ -71,7 +73,7 @@ func TestOut_ContentSafetyBlock(t *testing.T) {
 	extcs.Register(&csTestProvider{alert: alert})
 	defer extcs.Register(nil)
 
-	rctx, stdout, _ := newCSTestContext(t)
+	rctx, stdout, stderr := newCSTestContext(t)
 	rctx.Out(map[string]any{"msg": "hello"}, nil)
 
 	if stdout.Len() > 0 {
@@ -80,6 +82,16 @@ func TestOut_ContentSafetyBlock(t *testing.T) {
 	if rctx.outputErr == nil {
 		t.Error("block mode should set outputErr")
 	}
+	if stderr.Len() != 0 {
+		t.Fatalf("block mode stderr = %q, want empty", stderr.String())
+	}
+	var safetyErr *errs.ContentSafetyError
+	if !errors.As(rctx.outputErr, &safetyErr) {
+		t.Fatalf("block mode output error = %T, want *errs.ContentSafetyError", rctx.outputErr)
+	}
+	if got := output.ExitCodeOf(rctx.outputErr); got != output.ExitContentSafety {
+		t.Fatalf("block mode exit code = %d, want %d", got, output.ExitContentSafety)
+	}
 }
 
 func TestOut_ContentSafetyOff(t *testing.T) {

shortcuts/common/runner_jq_test.go

@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"io"
 	"strings"
 	"testing"
@@ -14,6 +15,7 @@ import (
 	lark "github.com/larksuite/oapi-sdk-go/v3"
 	"github.com/spf13/cobra"
 
+	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/extension/fileio"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
@@ -102,6 +104,72 @@ func TestRuntimeContext_Out_WithJq_InvalidExpr_WritesStderr(t *testing.T) {
 	if !strings.Contains(stderr.String(), "error") {
 		t.Errorf("expected error on stderr for runtime jq error, got: %s", stderr.String())
 	}
+	problem, ok := errs.ProblemOf(rctx.outputErr)
+	if !ok || problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("output error problem = %#v, %v; want validation/invalid_argument", problem, ok)
+	}
+	if got := output.ExitCodeOf(rctx.outputErr); got != output.ExitValidation {
+		t.Fatalf("output error exit code = %d, want %d", got, output.ExitValidation)
+	}
+}
+
+type failingRuntimeOutputWriter struct {
+	err error
+}
+
+func (w failingRuntimeOutputWriter) Write([]byte) (int, error) {
+	return 0, w.err
+}
+
+func TestRuntimeContext_OutRaw_PropagatesWriteError(t *testing.T) {
+	rctx, _, stderr := newJqTestContext("", "")
+	sentinel := errors.New("write failed")
+	rctx.Factory.IOStreams.Out = failingRuntimeOutputWriter{err: sentinel}
+
+	rctx.OutRaw(map[string]interface{}{"id": "1"}, nil)
+
+	if !errors.Is(rctx.outputErr, sentinel) {
+		t.Fatalf("OutRaw() output error = %v, want preserved writer cause", rctx.outputErr)
+	}
+	problem, ok := errs.ProblemOf(rctx.outputErr)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("OutRaw() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	if got := output.ExitCodeOf(rctx.outputErr); got != output.ExitInternal {
+		t.Fatalf("OutRaw() exit code = %d, want %d", got, output.ExitInternal)
+	}
+	if stderr.Len() != 0 {
+		t.Fatalf("OutRaw() stderr = %q, want empty", stderr.String())
+	}
+}
+
+func TestRunShortcut_OutRawWriteErrorPropagates(t *testing.T) {
+	sentinel := errors.New("write failed")
+	f := newTestFactory()
+	f.IOStreams.Out = failingRuntimeOutputWriter{err: sentinel}
+	s := &Shortcut{
+		Service:   "test",
+		Command:   "test-shortcut",
+		AuthTypes: []string{"bot"},
+		Execute: func(_ context.Context, rctx *RuntimeContext) error {
+			rctx.OutRaw(map[string]interface{}{"id": "1"}, nil)
+			return nil
+		},
+	}
+	cmd := newTestShortcutCmd(s, f)
+	cmd.Flags().Set("as", "bot")
+
+	err := runShortcut(cmd, f, s, true)
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("runShortcut() error = %v, want preserved writer cause", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal {
+		t.Fatalf("runShortcut() problem = %#v, %v; want internal typed error", problem, ok)
+	}
+	if got := output.ExitCodeOf(err); got != output.ExitInternal {
+		t.Fatalf("runShortcut() exit code = %d, want %d", got, output.ExitInternal)
+	}
 }
 
 type testResolvedFileIO struct{}

shortcuts/im/im_flag_list.go

@@ -27,8 +27,8 @@ var ImFlagList = common.Shortcut{
 	Flags: []common.Flag{
 		{Name: "page-size", Type: "int", Default: "50", Desc: "page size (1-50)"},
 		{Name: "page-token", Desc: "pagination token for next page"},
-		{Name: "page-all", Type: "bool", Desc: "automatically paginate through all pages"},
-		{Name: "page-limit", Type: "int", Default: "20", Desc: "max pages when auto-pagination is enabled (default 20, max 1000)"},
+		{Name: "page-all", Type: "bool", Desc: "automatically paginate, capped by --page-limit"},
+		{Name: "page-limit", Type: "int", Default: "20", Desc: "max pages with --page-all (default 20; configurable range 1-1000)"},
 		{Name: "enrich-feed-thread", Type: "bool", Default: "true", Desc: "fetch message content for feed-type thread entries (default true; may call messages/mget and require im:message.group_msg:get_as_user/im:message.p2p_msg:get_as_user; use --enrich-feed-thread=false to avoid extra scopes)"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -278,6 +278,10 @@ func executeListAllPages(rt *common.RuntimeContext) error {
 			fmt.Fprintf(rt.IO().ErrOut, "warning: page_token did not change, stopping pagination to avoid infinite loop\n")
 			break
 		}
+		if page+1 >= maxPages {
+			fmt.Fprintf(rt.IO().ErrOut, "[pagination] reached page limit (%d) while has_more=true; result is incomplete. Increase --page-limit up to 1000 or resume with the page_token returned in stdout.\n", maxPages)
+			break
+		}
 		prevPageToken = lastPageToken
 	}
 

shortcuts/im/im_flag_test.go

@@ -1536,6 +1536,9 @@ func TestExecuteListAllPages(t *testing.T) {
 	if callCount != 2 {
 		t.Fatalf("expected 2 API calls, got %d", callCount)
 	}
+	if stderr := rt.IO().ErrOut.(*bytes.Buffer).String(); strings.Contains(stderr, "reached page limit") {
+		t.Fatalf("natural pagination completion must not warn about a page limit, got %q", stderr)
+	}
 }
 
 func TestExecuteListAllPages_EnrichFeedThread(t *testing.T) {
@@ -1625,6 +1628,73 @@ func TestExecuteListAllPages_PageLimit(t *testing.T) {
 	if callCount != 3 {
 		t.Fatalf("expected 3 API calls (page limit), got %d", callCount)
 	}
+	stderr := rt.IO().ErrOut.(*bytes.Buffer).String()
+	for _, want := range []string{"reached page limit (3)", "has_more=true", "result is incomplete", "up to 1000", "page_token returned in stdout"} {
+		if !strings.Contains(stderr, want) {
+			t.Fatalf("stderr = %q, want %q", stderr, want)
+		}
+	}
+	if strings.Contains(stderr, "token_3") {
+		t.Fatalf("stderr must not expose the continuation token, got %q", stderr)
+	}
+
+	var envelope map[string]any
+	if err := json.Unmarshal(rt.IO().Out.(*bytes.Buffer).Bytes(), &envelope); err != nil {
+		t.Fatalf("decode stdout: %v", err)
+	}
+	data, _ := envelope["data"].(map[string]any)
+	if hasMore, _ := data["has_more"].(bool); !hasMore {
+		t.Fatalf("has_more = %#v, want true for an incomplete result", data["has_more"])
+	}
+	if pageToken, _ := data["page_token"].(string); pageToken != "token_3" {
+		t.Fatalf("page_token = %q, want token_3", pageToken)
+	}
+	if _, exists := data["truncated"]; exists {
+		t.Fatalf("output schema must remain unchanged; unexpected truncated field in %#v", data)
+	}
+}
+
+func TestExecuteListAllPages_RepeatedTokenDoesNotReportPageLimit(t *testing.T) {
+	callCount := 0
+	rt := newBotShortcutRuntime(t, shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		if strings.Contains(req.URL.Path, "/open-apis/im/v1/flags") {
+			callCount++
+			return shortcutJSONResponse(200, map[string]any{
+				"code": 0,
+				"data": map[string]any{
+					"flag_items":        []any{},
+					"delete_flag_items": []any{},
+					"messages":          []any{},
+					"has_more":          true,
+					"page_token":        "same_token",
+				},
+			}), nil
+		}
+		return nil, fmt.Errorf("unexpected request: %s", req.URL.Path)
+	}))
+
+	cmd := &cobra.Command{Use: "test"}
+	cmd.Flags().Int("page-size", 50, "")
+	cmd.Flags().Int("page-limit", 10, "")
+	cmd.Flags().Bool("enrich-feed-thread", false, "")
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("ParseFlags() error = %v", err)
+	}
+	setRuntimeField(t, rt, "Cmd", cmd)
+
+	if err := executeListAllPages(rt); err != nil {
+		t.Fatalf("executeListAllPages() error = %v", err)
+	}
+	if callCount != 2 {
+		t.Fatalf("API calls = %d, want 2 before repeated-token stop", callCount)
+	}
+	stderr := rt.IO().ErrOut.(*bytes.Buffer).String()
+	if !strings.Contains(stderr, "page_token did not change") {
+		t.Fatalf("stderr = %q, want non-advancing token warning", stderr)
+	}
+	if strings.Contains(stderr, "reached page limit") {
+		t.Fatalf("stderr = %q, repeated token must not be reported as a page-limit stop", stderr)
+	}
 }
 
 func TestExecuteListAllPages_APIError(t *testing.T) {

shortcuts/slides/shortcuts.go

@@ -14,5 +14,8 @@ func Shortcuts() []common.Shortcut {
 		SlidesReplacePages,
 		SlidesScreenshot,
 		SlidesXMLGet,
+		SlidesHistoryList,
+		SlidesHistoryRevert,
+		SlidesHistoryRevertStatus,
 	}
 }

shortcuts/slides/slides_create.go

@@ -154,6 +154,9 @@ var SlidesCreate = common.Shortcut{
 		if revisionID := common.GetFloat(data, "revision_id"); revisionID > 0 {
 			result["revision_id"] = int(revisionID)
 		}
+		if issues, ok := data["issues"]; ok {
+			result["issues"] = issues
+		}
 
 		// Step 2: Add slides if provided
 		if slidesStr != "" {
@@ -182,6 +185,7 @@ var SlidesCreate = common.Shortcut{
 				)
 
 				var slideIDs []string
+				var slideIssues []map[string]interface{}
 				for i, slideXML := range slides {
 					slideData, err := runtime.CallAPITyped(
 						"POST",
@@ -194,13 +198,24 @@ var SlidesCreate = common.Shortcut{
 					if err != nil {
 						return appendSlidesProgressHint(err, fmt.Sprintf("adding slide %d/%d failed; presentation %s was created, %d slide(s) added before failure", i+1, len(slides), presentationID, i))
 					}
-					if sid := common.GetString(slideData, "slide_id"); sid != "" {
+					sid := common.GetString(slideData, "slide_id")
+					if sid != "" {
 						slideIDs = append(slideIDs, sid)
 					}
+					if issues, ok := slideData["issues"]; ok {
+						slideIssues = append(slideIssues, map[string]interface{}{
+							"slide_index": i + 1,
+							"slide_id":    sid,
+							"issues":      issues,
+						})
+					}
 				}
 
 				result["slide_ids"] = slideIDs
 				result["slides_added"] = len(slideIDs)
+				if len(slideIssues) > 0 {
+					result["slide_issues"] = slideIssues
+				}
 			}
 		}
 

shortcuts/slides/slides_create_test.go

@@ -351,6 +351,56 @@ func TestSlidesCreateWithSlides(t *testing.T) {
 	}
 }
 
+func TestSlidesCreatePreservesSchemaIssues(t *testing.T) {
+	t.Parallel()
+
+	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/slides_ai/v1/xml_presentations",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"xml_presentation_id": "pres_issues",
+				"issues":              "presentation schema issue",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_issues/slide",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"slide_id": "slide_001",
+				"issues":   "slide schema issue",
+			},
+		},
+	})
+
+	err := runSlidesCreateShortcut(t, f, stdout, []string{
+		"+create",
+		"--slides", `["<slide xmlns=\"http://www.larkoffice.com/sml/2.0\"><data/></slide>"]`,
+		"--as", "user",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	data := decodeSlidesCreateEnvelope(t, stdout)
+	if data["issues"] != "presentation schema issue" {
+		t.Fatalf("issues = %v, want presentation schema issue", data["issues"])
+	}
+	slideIssues, ok := data["slide_issues"].([]interface{})
+	if !ok || len(slideIssues) != 1 {
+		t.Fatalf("slide_issues = %#v, want one entry", data["slide_issues"])
+	}
+	issue, _ := slideIssues[0].(map[string]interface{})
+	if issue["slide_index"] != float64(1) || issue["slide_id"] != "slide_001" || issue["issues"] != "slide schema issue" {
+		t.Fatalf("slide_issues[0] = %#v", issue)
+	}
+}
+
 // TestSlidesCreateWithSlidesPartialFailure verifies error reporting when a slide fails to create.
 func TestSlidesCreateWithSlidesPartialFailure(t *testing.T) {
 	t.Parallel()

shortcuts/slides/slides_history.go

@@ -0,0 +1,290 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package slides
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/validate"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+type slidesHistoryListSpec struct {
+	PageSize  int
+	PageToken string
+}
+
+type slidesHistoryRevertSpec struct {
+	HistoryVersionID string
+}
+
+type slidesHistoryRevertStatusSpec struct {
+	TaskID string
+}
+
+func parseSlidesHistoryPresentation(runtime *common.RuntimeContext) (presentationRef, error) {
+	ref, err := parsePresentationRef(runtime.Str("presentation"))
+	if err != nil {
+		return presentationRef{}, err
+	}
+	if ref.Kind == "wiki" {
+		if err := runtime.EnsureScopes([]string{"wiki:node:read"}); err != nil {
+			return presentationRef{}, err
+		}
+	}
+	return ref, nil
+}
+
+func validateSlidesHistoryPageSize(pageSize int) error {
+	if pageSize < 1 || pageSize > 20 {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --page-size %d: must be between 1 and 20", pageSize).WithParam("--page-size")
+	}
+	return nil
+}
+
+func validateSlidesHistoryVersionID(historyVersionID string) error {
+	version, err := strconv.ParseInt(strings.TrimSpace(historyVersionID), 10, 64)
+	if err != nil {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--history-version-id must be a positive integer string returned by slides +history-list").WithParam("--history-version-id").WithCause(err)
+	}
+	if version <= 0 {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--history-version-id must be a positive integer string returned by slides +history-list").WithParam("--history-version-id")
+	}
+	return nil
+}
+
+func slidesHistoryListParams(spec slidesHistoryListSpec) map[string]interface{} {
+	params := map[string]interface{}{
+		"page_size": spec.PageSize,
+	}
+	if spec.PageToken != "" {
+		params["page_token"] = spec.PageToken
+	}
+	return params
+}
+
+func slidesHistoryRevertBody(spec slidesHistoryRevertSpec) map[string]interface{} {
+	return map[string]interface{}{
+		"history_version_id": spec.HistoryVersionID,
+	}
+}
+
+func slidesHistoryStatusParams(spec slidesHistoryRevertStatusSpec) map[string]interface{} {
+	return map[string]interface{}{
+		"task_id": spec.TaskID,
+	}
+}
+
+func slidesHistoryAPIPath(presentationID, suffix string) string {
+	return fmt.Sprintf("/open-apis/slides_ai/v1/xml_presentations/%s/%s", validate.EncodePathSegment(presentationID), suffix)
+}
+
+func newSlidesHistoryDryRun(ref presentationRef, desc string) (*common.DryRunAPI, string) {
+	dry := common.NewDryRunAPI()
+	presentationID := ref.Token
+	if ref.Kind == "wiki" {
+		presentationID = "<resolved_slides_token>"
+		dry.Desc("2-step orchestration: resolve wiki then " + desc).
+			GET("/open-apis/wiki/v2/spaces/get_node").
+			Desc("[1] Resolve wiki node to slides presentation").
+			Params(map[string]interface{}{"token": ref.Token})
+	} else {
+		dry.Desc("OpenAPI: " + desc)
+	}
+	return dry, presentationID
+}
+
+// SlidesHistoryList lists history versions of a Slides XML presentation.
+var SlidesHistoryList = common.Shortcut{
+	Service:           "slides",
+	Command:           "+history-list",
+	Description:       "List Slides presentation history versions",
+	Risk:              "read",
+	Scopes:            []string{"slides:presentation:read"},
+	ConditionalScopes: []string{"wiki:node:read"},
+	AuthTypes:         []string{"user", "bot"},
+	Flags: []common.Flag{
+		{Name: "presentation", Desc: "xml_presentation_id, slides URL, or wiki URL that resolves to slides", Required: true},
+		{Name: "page-size", Type: "int", Default: "20", Desc: "history entries to return, range 1-20"},
+		{Name: "page-token", Desc: "pagination token from the previous page's page_token"},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		if _, err := parseSlidesHistoryPresentation(runtime); err != nil {
+			return err
+		}
+		return validateSlidesHistoryPageSize(runtime.Int("page-size"))
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		ref, err := parsePresentationRef(runtime.Str("presentation"))
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		spec := slidesHistoryListSpec{
+			PageSize:  runtime.Int("page-size"),
+			PageToken: strings.TrimSpace(runtime.Str("page-token")),
+		}
+		dry, presentationID := newSlidesHistoryDryRun(ref, "list Slides history versions")
+		return dry.
+			GET(slidesHistoryAPIPath(presentationID, "histories")).
+			Params(slidesHistoryListParams(spec)).
+			Set("xml_presentation_id", presentationID)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		ref, err := parsePresentationRef(runtime.Str("presentation"))
+		if err != nil {
+			return err
+		}
+		presentationID, err := resolvePresentationID(runtime, ref)
+		if err != nil {
+			return err
+		}
+		spec := slidesHistoryListSpec{
+			PageSize:  runtime.Int("page-size"),
+			PageToken: strings.TrimSpace(runtime.Str("page-token")),
+		}
+
+		data, err := runtime.CallAPITyped(
+			http.MethodGet,
+			slidesHistoryAPIPath(presentationID, "histories"),
+			slidesHistoryListParams(spec),
+			nil,
+		)
+		if err != nil {
+			return err
+		}
+		runtime.OutRaw(data, nil)
+		return nil
+	},
+}
+
+// SlidesHistoryRevert reverts a Slides XML presentation to a history version.
+var SlidesHistoryRevert = common.Shortcut{
+	Service:           "slides",
+	Command:           "+history-revert",
+	Description:       "Revert a Slides presentation to a historical version",
+	Risk:              "write",
+	Scopes:            []string{"slides:presentation:update", "slides:presentation:write_only"},
+	ConditionalScopes: []string{"wiki:node:read"},
+	AuthTypes:         []string{"user", "bot"},
+	Flags: []common.Flag{
+		{Name: "presentation", Desc: "xml_presentation_id, slides URL, or wiki URL that resolves to slides", Required: true},
+		{Name: "history-version-id", Desc: "history_version_id from slides +history-list to revert to", Required: true},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		if _, err := parseSlidesHistoryPresentation(runtime); err != nil {
+			return err
+		}
+		if err := validateSlidesHistoryVersionID(runtime.Str("history-version-id")); err != nil {
+			return err
+		}
+		return nil
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		ref, err := parsePresentationRef(runtime.Str("presentation"))
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		spec := slidesHistoryRevertSpec{
+			HistoryVersionID: strings.TrimSpace(runtime.Str("history-version-id")),
+		}
+		dry, presentationID := newSlidesHistoryDryRun(ref, "revert Slides history")
+		return dry.
+			POST(slidesHistoryAPIPath(presentationID, "history/revert")).
+			Body(slidesHistoryRevertBody(spec)).
+			Set("xml_presentation_id", presentationID)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		ref, err := parsePresentationRef(runtime.Str("presentation"))
+		if err != nil {
+			return err
+		}
+		presentationID, err := resolvePresentationID(runtime, ref)
+		if err != nil {
+			return err
+		}
+		spec := slidesHistoryRevertSpec{
+			HistoryVersionID: strings.TrimSpace(runtime.Str("history-version-id")),
+		}
+
+		data, err := runtime.CallAPITyped(
+			http.MethodPost,
+			slidesHistoryAPIPath(presentationID, "history/revert"),
+			nil,
+			slidesHistoryRevertBody(spec),
+		)
+		if err != nil {
+			return err
+		}
+		runtime.OutRaw(data, nil)
+		return nil
+	},
+}
+
+// SlidesHistoryRevertStatus gets the status of a Slides history revert task.
+var SlidesHistoryRevertStatus = common.Shortcut{
+	Service:           "slides",
+	Command:           "+history-revert-status",
+	Description:       "Get Slides history revert task status",
+	Risk:              "read",
+	Scopes:            []string{"slides:presentation:read"},
+	ConditionalScopes: []string{"wiki:node:read"},
+	AuthTypes:         []string{"user", "bot"},
+	Flags: []common.Flag{
+		{Name: "presentation", Desc: "xml_presentation_id, slides URL, or wiki URL that resolves to slides", Required: true},
+		{Name: "task-id", Desc: "task_id returned by slides +history-revert", Required: true},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		if _, err := parseSlidesHistoryPresentation(runtime); err != nil {
+			return err
+		}
+		if strings.TrimSpace(runtime.Str("task-id")) == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--task-id is required").WithParam("--task-id")
+		}
+		return nil
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		ref, err := parsePresentationRef(runtime.Str("presentation"))
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		spec := slidesHistoryRevertStatusSpec{
+			TaskID: strings.TrimSpace(runtime.Str("task-id")),
+		}
+		dry, presentationID := newSlidesHistoryDryRun(ref, "get Slides history revert status")
+		return dry.
+			GET(slidesHistoryAPIPath(presentationID, "history/revert_status")).
+			Params(slidesHistoryStatusParams(spec)).
+			Set("xml_presentation_id", presentationID)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		ref, err := parsePresentationRef(runtime.Str("presentation"))
+		if err != nil {
+			return err
+		}
+		presentationID, err := resolvePresentationID(runtime, ref)
+		if err != nil {
+			return err
+		}
+		spec := slidesHistoryRevertStatusSpec{
+			TaskID: strings.TrimSpace(runtime.Str("task-id")),
+		}
+
+		data, err := runtime.CallAPITyped(
+			http.MethodGet,
+			slidesHistoryAPIPath(presentationID, "history/revert_status"),
+			slidesHistoryStatusParams(spec),
+			nil,
+		)
+		if err != nil {
+			return err
+		}
+		runtime.OutRaw(data, nil)
+		return nil
+	},
+}

shortcuts/slides/slides_history_test.go

@@ -0,0 +1,443 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package slides
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+	"reflect"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/shortcuts/common"
+	"github.com/spf13/cobra"
+)
+
+func TestSlidesHistoryDeclaredScopes(t *testing.T) {
+	tests := []struct {
+		name     string
+		shortcut common.Shortcut
+		wantBase []string
+		wantFull []string
+	}{
+		{
+			name:     "list",
+			shortcut: SlidesHistoryList,
+			wantBase: []string{"slides:presentation:read"},
+			wantFull: []string{"slides:presentation:read", "wiki:node:read"},
+		},
+		{
+			name:     "revert",
+			shortcut: SlidesHistoryRevert,
+			wantBase: []string{"slides:presentation:update", "slides:presentation:write_only"},
+			wantFull: []string{"slides:presentation:update", "slides:presentation:write_only", "wiki:node:read"},
+		},
+		{
+			name:     "status",
+			shortcut: SlidesHistoryRevertStatus,
+			wantBase: []string{"slides:presentation:read"},
+			wantFull: []string{"slides:presentation:read", "wiki:node:read"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.shortcut.ScopesForIdentity("user"); !reflect.DeepEqual(got, tt.wantBase) {
+				t.Fatalf("user preflight scopes = %#v, want %#v", got, tt.wantBase)
+			}
+			if got := tt.shortcut.ScopesForIdentity("bot"); !reflect.DeepEqual(got, tt.wantBase) {
+				t.Fatalf("bot preflight scopes = %#v, want %#v", got, tt.wantBase)
+			}
+			if got := tt.shortcut.DeclaredScopesForIdentity("user"); !reflect.DeepEqual(got, tt.wantFull) {
+				t.Fatalf("declared scopes = %#v, want %#v", got, tt.wantFull)
+			}
+		})
+	}
+}
+
+func TestSlidesHistoryValidation(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		shortcut  common.Shortcut
+		args      []string
+		param     string
+		wantCause bool
+	}{
+		{
+			name:     "list rejects unsupported presentation input",
+			shortcut: SlidesHistoryList,
+			args:     []string{"+history-list", "--presentation", "tmp/wiki/wikcn123", "--as", "bot"},
+			param:    "--presentation",
+		},
+		{
+			name:     "list rejects invalid page size",
+			shortcut: SlidesHistoryList,
+			args:     []string{"+history-list", "--presentation", "presHistory", "--page-size", "0", "--as", "bot"},
+			param:    "--page-size",
+		},
+		{
+			name:      "revert rejects non-numeric history version id",
+			shortcut:  SlidesHistoryRevert,
+			args:      []string{"+history-revert", "--presentation", "presHistory", "--history-version-id", "abc", "--as", "bot"},
+			param:     "--history-version-id",
+			wantCause: true,
+		},
+		{
+			name:     "revert rejects non-positive history version id",
+			shortcut: SlidesHistoryRevert,
+			args:     []string{"+history-revert", "--presentation", "presHistory", "--history-version-id", "0", "--as", "bot"},
+			param:    "--history-version-id",
+		},
+		{
+			name:     "status rejects empty task id",
+			shortcut: SlidesHistoryRevertStatus,
+			args:     []string{"+history-revert-status", "--presentation", "presHistory", "--task-id", "", "--as", "bot"},
+			param:    "--task-id",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
+			err := runSlidesShortcut(t, f, stdout, tt.shortcut, tt.args)
+			if err == nil {
+				t.Fatal("expected validation error, got nil")
+			}
+			_, ok := errs.ProblemOf(err)
+			if !ok {
+				t.Fatalf("error is not typed: %T %v", err, err)
+			}
+			var validationErr *errs.ValidationError
+			if !errors.As(err, &validationErr) {
+				t.Fatalf("expected validation error, got %T: %v", err, err)
+			}
+			if validationErr.Param != tt.param {
+				t.Fatalf("param = %q, want %q (err: %v)", validationErr.Param, tt.param, err)
+			}
+			if tt.wantCause && errors.Unwrap(err) == nil {
+				t.Fatalf("expected wrapped cause, got nil (err: %v)", err)
+			}
+		})
+	}
+}
+
+func TestSlidesHistoryDryRun(t *testing.T) {
+	t.Parallel()
+
+	listCmd := newSlidesHistoryRuntimeCmd(t, SlidesHistoryList, map[string]string{
+		"presentation": "presHistoryDryRun",
+		"page-size":    "5",
+		"page-token":   "page_token_1",
+	})
+	listDry := decodeSlidesHistoryDryRun(t, SlidesHistoryList.DryRun(context.Background(), common.TestNewRuntimeContext(listCmd, nil)))
+	if got, want := listDry.API[0].URL, "/open-apis/slides_ai/v1/xml_presentations/presHistoryDryRun/histories"; got != want {
+		t.Fatalf("list dry-run URL = %q, want %q", got, want)
+	}
+	if got := int(listDry.API[0].Params["page_size"].(float64)); got != 5 {
+		t.Fatalf("list page_size = %d, want 5", got)
+	}
+	if got := listDry.API[0].Params["page_token"]; got != "page_token_1" {
+		t.Fatalf("list page_token = %#v, want page_token_1", got)
+	}
+
+	revertCmd := newSlidesHistoryRuntimeCmd(t, SlidesHistoryRevert, map[string]string{
+		"presentation":       "presHistoryDryRun",
+		"history-version-id": "42",
+	})
+	revertDry := decodeSlidesHistoryDryRun(t, SlidesHistoryRevert.DryRun(context.Background(), common.TestNewRuntimeContext(revertCmd, nil)))
+	if got, want := revertDry.API[0].URL, "/open-apis/slides_ai/v1/xml_presentations/presHistoryDryRun/history/revert"; got != want {
+		t.Fatalf("revert dry-run URL = %q, want %q", got, want)
+	}
+	if got := revertDry.API[0].Body["history_version_id"]; got != "42" {
+		t.Fatalf("revert history_version_id = %#v, want 42", got)
+	}
+	if _, ok := revertDry.API[0].Body["wait_timeout_ms"]; ok {
+		t.Fatal("revert body must not contain wait_timeout_ms")
+	}
+
+	statusCmd := newSlidesHistoryRuntimeCmd(t, SlidesHistoryRevertStatus, map[string]string{
+		"presentation": "presHistoryDryRun",
+		"task-id":      "task_1",
+	})
+	statusDry := decodeSlidesHistoryDryRun(t, SlidesHistoryRevertStatus.DryRun(context.Background(), common.TestNewRuntimeContext(statusCmd, nil)))
+	if got, want := statusDry.API[0].URL, "/open-apis/slides_ai/v1/xml_presentations/presHistoryDryRun/history/revert_status"; got != want {
+		t.Fatalf("status dry-run URL = %q, want %q", got, want)
+	}
+	if got := statusDry.API[0].Params["task_id"]; got != "task_1" {
+		t.Fatalf("status task_id = %#v, want task_1", got)
+	}
+}
+
+func TestSlidesHistoryDryRunWithWikiPresentation(t *testing.T) {
+	t.Parallel()
+
+	cmd := newSlidesHistoryRuntimeCmd(t, SlidesHistoryList, map[string]string{
+		"presentation": "https://example.feishu.cn/wiki/wikcn123",
+		"page-size":    "20",
+	})
+	dry := decodeSlidesHistoryDryRun(t, SlidesHistoryList.DryRun(context.Background(), common.TestNewRuntimeContext(cmd, nil)))
+	if len(dry.API) != 2 {
+		t.Fatalf("api calls = %d, want 2: %#v", len(dry.API), dry.API)
+	}
+	if got, want := dry.API[0].URL, "/open-apis/wiki/v2/spaces/get_node"; got != want {
+		t.Fatalf("wiki dry-run URL = %q, want %q", got, want)
+	}
+	if got := dry.API[0].Params["token"]; got != "wikcn123" {
+		t.Fatalf("wiki node parameter mismatch: got %#v, want placeholder node id", got)
+	}
+	if got, want := dry.API[1].URL, "/open-apis/slides_ai/v1/xml_presentations/%3Cresolved_slides_token%3E/histories"; got != want {
+		t.Fatalf("history dry-run URL = %q, want %q", got, want)
+	}
+}
+
+func TestSlidesHistoryExecuteList(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
+	var capturedQuery url.Values
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/slides_ai/v1/xml_presentations/presHistory/histories",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"entries": []interface{}{
+					map[string]interface{}{
+						"revision_id":        float64(42),
+						"history_version_id": "11",
+						"edit_time":          "2026-06-22T12:24:45Z",
+						"type":               float64(1),
+						"editor_ids":         []interface{}{"ou_1"},
+					},
+				},
+				"has_more":   true,
+				"page_token": "page_token_2",
+			},
+		},
+		OnMatch: func(req *http.Request) {
+			capturedQuery = req.URL.Query()
+		},
+	})
+
+	err := runSlidesShortcut(t, f, stdout, SlidesHistoryList, []string{
+		"+history-list",
+		"--presentation", "presHistory",
+		"--page-size", "5",
+		"--page-token", "page_token_1",
+		"--as", "bot",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if got := capturedQuery.Get("page_size"); got != "5" {
+		t.Fatalf("page_size query = %q, want 5", got)
+	}
+	if got := capturedQuery.Get("page_token"); got != "page_token_1" {
+		t.Fatalf("page_token query = %q, want page_token_1", got)
+	}
+
+	data := decodeSlidesHistoryEnvelope(t, stdout)
+	if got := data["page_token"]; got != "page_token_2" {
+		t.Fatalf("page_token = %#v, want page_token_2", got)
+	}
+	entries, _ := data["entries"].([]interface{})
+	if len(entries) != 1 {
+		t.Fatalf("entries = %#v, want one entry", data["entries"])
+	}
+}
+
+func TestSlidesHistoryExecuteRevert(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
+	stub := &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/slides_ai/v1/xml_presentations/presHistory/history/revert",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"task_id":            "task_1",
+				"status":             "running",
+				"history_version_id": "42",
+				"poll_after_ms":      float64(10000),
+			},
+		},
+	}
+	reg.Register(stub)
+
+	err := runSlidesShortcut(t, f, stdout, SlidesHistoryRevert, []string{
+		"+history-revert",
+		"--presentation", "presHistory",
+		"--history-version-id", "42",
+		"--as", "bot",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	var body map[string]interface{}
+	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
+		t.Fatalf("decode revert body: %v\nraw=%s", err, stub.CapturedBody)
+	}
+	if got := body["history_version_id"]; got != "42" {
+		t.Fatalf("history_version_id = %#v, want 42", got)
+	}
+	if _, ok := body["wait_timeout_ms"]; ok {
+		t.Fatal("revert body must not contain wait_timeout_ms")
+	}
+
+	data := decodeSlidesHistoryEnvelope(t, stdout)
+	if got := data["task_id"]; got != "task_1" {
+		t.Fatalf("task_id = %#v, want task_1", got)
+	}
+}
+
+func TestSlidesHistoryExecuteRevertStatus(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
+	var capturedQuery url.Values
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/slides_ai/v1/xml_presentations/presHistory/history/revert_status",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"status":             "done",
+				"history_version_id": "11",
+			},
+		},
+		OnMatch: func(req *http.Request) {
+			capturedQuery = req.URL.Query()
+		},
+	})
+
+	err := runSlidesShortcut(t, f, stdout, SlidesHistoryRevertStatus, []string{
+		"+history-revert-status",
+		"--presentation", "presHistory",
+		"--task-id", "task_1",
+		"--as", "bot",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if got := capturedQuery.Get("task_id"); got != "task_1" {
+		t.Fatalf("task_id query = %q, want task_1", got)
+	}
+	data := decodeSlidesHistoryEnvelope(t, stdout)
+	if got := data["status"]; got != "done" {
+		t.Fatalf("status = %#v, want done", got)
+	}
+	if got := data["history_version_id"]; got != "11" {
+		t.Fatalf("history_version_id = %#v, want 11", got)
+	}
+}
+
+func TestSlidesHistoryExecuteResolvesWikiPresentation(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{
+					"obj_type":  "slides",
+					"obj_token": "presReal",
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/slides_ai/v1/xml_presentations/presReal/histories",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"entries":    []interface{}{},
+				"has_more":   false,
+				"page_token": "",
+			},
+		},
+	})
+
+	err := runSlidesShortcut(t, f, stdout, SlidesHistoryList, []string{
+		"+history-list",
+		"--presentation", "https://example.feishu.cn/wiki/wikcn123",
+		"--as", "bot",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	data := decodeSlidesHistoryEnvelope(t, stdout)
+	if got := data["has_more"]; got != false {
+		t.Fatalf("has_more = %#v, want false", got)
+	}
+}
+
+type slidesHistoryDryRunOutput struct {
+	API []struct {
+		Method string                 `json:"method"`
+		URL    string                 `json:"url"`
+		Params map[string]interface{} `json:"params"`
+		Body   map[string]interface{} `json:"body"`
+	} `json:"api"`
+}
+
+func newSlidesHistoryRuntimeCmd(t *testing.T, shortcut common.Shortcut, values map[string]string) *cobra.Command {
+	t.Helper()
+
+	cmd := &cobra.Command{Use: shortcut.Command}
+	for _, flag := range shortcut.Flags {
+		switch flag.Type {
+		case "int":
+			cmd.Flags().Int(flag.Name, 0, flag.Desc)
+		default:
+			cmd.Flags().String(flag.Name, flag.Default, flag.Desc)
+		}
+	}
+	for name, value := range values {
+		if err := cmd.Flags().Set(name, value); err != nil {
+			t.Fatalf("set --%s: %v", name, err)
+		}
+	}
+	return cmd
+}
+
+func decodeSlidesHistoryDryRun(t *testing.T, dry *common.DryRunAPI) slidesHistoryDryRunOutput {
+	t.Helper()
+
+	raw, err := json.Marshal(dry)
+	if err != nil {
+		t.Fatalf("marshal dry-run: %v", err)
+	}
+	var out slidesHistoryDryRunOutput
+	if err := json.Unmarshal(raw, &out); err != nil {
+		t.Fatalf("decode dry-run: %v\nraw=%s", err, raw)
+	}
+	return out
+}
+
+func decodeSlidesHistoryEnvelope(t *testing.T, stdout *bytes.Buffer) map[string]interface{} {
+	t.Helper()
+
+	var envelope map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
+		t.Fatalf("decode envelope: %v\nraw=%s", err, stdout.String())
+	}
+	data, _ := envelope["data"].(map[string]interface{})
+	if data == nil {
+		t.Fatalf("missing data in envelope: %#v", envelope)
+	}
+	return data
+}

shortcuts/slides/slides_replace_pages.go

@@ -139,6 +139,7 @@ type replacePageResult struct {
 	NewSlideID string
 	Status     string
 	Error      string
+	Issues     interface{}
 	RevisionID *int
 }
 
@@ -330,6 +331,9 @@ func replaceOnePage(runtime *common.RuntimeContext, presentationID string, item
 		return result, err
 	}
 	result.NewSlideID = newSlideID
+	if issues, ok := createData["issues"]; ok {
+		result.Issues = issues
+	}
 	if rev, ok := revisionFromData(createData); ok {
 		revisionID = rev
 		result.RevisionID = &rev
@@ -389,6 +393,9 @@ func replacePageResultsOutput(results []replacePageResult) []map[string]interfac
 		if result.Error != "" {
 			m["error"] = result.Error
 		}
+		if result.Issues != nil {
+			m["issues"] = result.Issues
+		}
 		if result.RevisionID != nil {
 			m["revision_id"] = *result.RevisionID
 		}

shortcuts/slides/slides_replace_pages_test.go

@@ -42,7 +42,7 @@ func TestReplacePagesCreatesBeforeThenDeletesOld(t *testing.T) {
 		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_abc/slide",
 		Body: map[string]interface{}{
 			"code": 0,
-			"data": map[string]interface{}{"slide_id": "new2", "revision_id": 11},
+			"data": map[string]interface{}{"slide_id": "new2", "revision_id": 11, "issues": "slide schema issue"},
 		},
 		OnMatch: func(req *http.Request) {
 			requestOrder = append(requestOrder, req.Method)
@@ -123,6 +123,9 @@ func TestReplacePagesCreatesBeforeThenDeletesOld(t *testing.T) {
 	if first["old_slide_id"] != "old2" || first["new_slide_id"] != "new2" || first["status"] != "replaced" {
 		t.Fatalf("result = %#v", first)
 	}
+	if first["issues"] != "slide schema issue" {
+		t.Fatalf("result.issues = %v, want slide schema issue", first["issues"])
+	}
 }
 
 func TestReplacePagesContinueOnErrorReturnsPartialFailure(t *testing.T) {

skills/lark-base/SKILL.md

@@ -112,7 +112,7 @@ metadata:
 - 表名、字段名、视图名、workflow 配置中的名称必须来自真实返回；跨表场景还要读取目标表结构。
 - 删除、角色更新、字段更新等高风险操作遵循 CLI 的 confirmation gate；目标不明确时先用 get/list 消歧。
 - 批量写入单批最多 200 条；连续写同一表时串行执行，遇到 `1254291` 按短暂等待后重试处理。
-- `+record-batch-update` 是“同值批量更新”：同一份 patch 应用到全部 `record_id_list`，不要拿它做逐行不同值映射。
+- `+record-batch-update` 使用 `update_records`，按 `record_id -> fields` 映射逐条提交字段值。
 - select/multiselect 写入未知选项可能触发平台新增选项；不是要新增时，先用 `+field-list` 或 `+field-search-options` 确认可选值。
 
 ## 表单与视图细节

skills/lark-base/references/lark-base-cell-value.md

@@ -9,7 +9,7 @@
 - `--json` 必须是 JSON 对象。
 - `+record-upsert`：顶层直接传字段映射：`{"字段名或字段ID": CellValue}`。
 - `+record-batch-create`：`rows` 是 `CellValue[][]`，列顺序由 `fields` 决定。
-- `+record-batch-update`：`patch` 是 `Map<FieldNameOrID, CellValue>`，同一份 `patch` 会应用到所有 `record_id_list`。
+- `+record-batch-update`：使用 `update_records`，其每个 value 都是 `Map<FieldNameOrID, CellValue>`。
 - 一次 payload 里同一字段只用一种 key（字段名或字段 ID），不要重复。
 - 写入前先 `+field-list` 获取字段 `type/style/multiple`，再构造值。
 - 需要清空字段时优先传 `null`（字段允许清空时）。

skills/lark-base/references/lark-base-record-batch-update.md

@@ -2,13 +2,13 @@
 
 > **前置条件：** 先阅读 [`../lark-shared/SKILL.md`](../../lark-shared/SKILL.md) 了解认证、全局参数和安全规则。
 
-批量更新记录（将同一份 `patch` 批量应用到一批 `record_id_list`）。
+通过 `update_records` 为每条记录提交字段值。
 
 ## 推荐命令
 
 ```bash
 lark-cli base +record-batch-update --base-token <base_token> --table-id <table_id> \
-  --json '{"record_id_list":["<record_id>"],"patch":{"状态":"完成"}}'
+  --json '{"update_records":{"<record_id_a>":{"状态":["完成"]},"<record_id_b>":{"分数":20}}}'
 
 lark-cli base +record-batch-update --base-token <base_token> --table-id <table_id> --json @batch-update.json
 ```
@@ -29,23 +29,25 @@ lark-cli base +record-batch-update --base-token <base_token> --table-id <table_i
 
 本节只说明 `+record-batch-update` 的外层 JSON 形状；CellValue 统一看 [lark-base-cell-value.md](lark-base-cell-value.md)。
 
-对象形态：`{"record_id_list":[...],"patch":{...}}`。
+对象形态：
+
+```json
+{"update_records":{"recA":{"状态":["完成"]},"recB":{"分数":20}}}
+```
 
 | 字段 | 类型 | 必填 | 说明 |
 |------|------|------|------|
-| `record_id_list` | `string[]` | 是 | 要更新的记录 ID 列表（单次最多 200 条） |
-| `patch` | `Map<FieldNameOrID, CellValue>` | 是 | 字段更新对象；key 是字段名或字段 ID，value 是 `CellValue`；同一份 `patch` 会应用到 `record_id_list` 内所有记录 |
+| `update_records` | `Map<RecordID, Map<FieldNameOrID, CellValue>>` | 是 | record ID 到字段更新对象的映射（单次最多 200 条） |
 
 ## 返回重点
 
-返回 `record_id_list`、`update`，可选返回 `ignored_fields`；`update` 可能为空对象。
+成功响应只包含可选的 `ignored_fields`；没有忽略字段时 `data` 为空对象。请求不会预先校验 record ID 是否存在，因此需要确认实际写入结果时，应再用 `+record-get` 读回目标记录。
 
 ## 坑点
 
-- 这是“同值批量更新”：所有 `record_id_list` 都应用同一份 `patch`。
-- `record_id_list` 最大 200 条，超过会被接口校验拒绝。
+- 单次最多更新 200 条记录，超过会被接口校验拒绝。
 - 命令不会自动做字段/行映射转换，传什么就发什么。
-- 如果 `patch` 包含只读字段，返回里可能出现 `ignored_fields`；这些字段不会被更新。
+- 如果字段映射包含只读字段，返回里可能出现 `ignored_fields`；这些字段不会被更新。
 
 ## 参考
 

skills/lark-drive/SKILL.md

@@ -135,7 +135,7 @@ Shortcut 是对常用操作的高级封装（`lark-cli drive +<verb> [flags]`）
 | Shortcut | 说明 |
 |----------|----------|
 | [`+search`](references/lark-drive-search.md) | 搜索文档、Wiki、表格、文件夹等云空间对象；支持 `--edited-since`、`--created-by-me`、`--mine`、`--doc-types` 等扁平 flag；区分 original creator 与 owner 语义。 |
-| [`+upload`](references/lark-drive-upload.md) | 上传本地文件到 Drive 文件夹或 wiki 节点。 |
+| [`+upload`](references/lark-drive-upload.md) | 上传本地文件到 Drive 文件夹或 wiki 节点；修改/重写/更新已有文件时优先覆盖上传，而不是直接上传一个新文件。 |
 | [`+create-folder`](references/lark-drive-create-folder.md) | 新建 Drive 文件夹，支持父文件夹与 bot 创建后自动授权。 |
 | [`+download`](references/lark-drive-download.md) | 下载 Drive 文件到本地。 |
 | [`+preview`](references/lark-drive-preview.md) | 查看或下载文件的 PDF / HTML / 文本 / 图片等预览产物。 |

skills/lark-drive/references/lark-drive-upload.md

@@ -7,6 +7,7 @@
 
 ## 快速决策
 - 用户要在 Drive 里上传、创建、读取、局部 patch 或覆盖更新**原生 `.md` 文件**（不是导入成 docx），切到 [`lark-markdown`](../../lark-markdown/SKILL.md)。
+- 用户在修改/重写/更新已有普通文件时，优先使用覆盖上传方式，而不是直接上传一个新文件。
 
 ## 命令
 

skills/lark-im/SKILL.md

@@ -117,7 +117,7 @@ Shortcut 是对常用操作的高级封装（`lark-cli im +<verb> [flags]`）。
 | [`+threads-messages-list`](references/lark-im-threads-messages-list.md) | List messages in a thread; user/bot; accepts om_/omt_ input, resolves message IDs to thread_id, supports sort/pagination |
 | [`+flag-create`](references/lark-im-flag-create.md) | Create a bookmark on a message; user-only; defaults to message-layer flag; use --flag-type feed for feed-layer flag (item_type auto-detected from chat mode) |
 | [`+flag-cancel`](references/lark-im-flag-cancel.md) | Cancel (remove) a bookmark. When no --flag-type is given, best-effort double-cancel: removes message layer and (when chat_type is determinable) feed layer |
-| [`+flag-list`](references/lark-im-flag-list.md) | List bookmarks; user-only; auto-enriches feed-type thread entries with message content; supports `--page-all` auto-pagination |
+| [`+flag-list`](references/lark-im-flag-list.md) | List bookmarks; user-only; auto-enriches feed-type thread entries with message content; `--page-all` is capped by `--page-limit` (default 20, max 1000), and `has_more=true` means the result is incomplete |
 | [`+feed-shortcut-create`](references/lark-im-feed-shortcut-create.md) | Add chats to the user's feed shortcuts; user-only; oc_xxx chat IDs only; batch up to 10 per call; `--head`/`--tail` controls insertion order; partial failures return an `ok:false` ledger |
 | [`+feed-shortcut-remove`](references/lark-im-feed-shortcut-remove.md) | Remove chats from the user's feed shortcuts; user-only; batch up to 10 per call; removing an absent shortcut is idempotent success; real per-item failures return an `ok:false` ledger |
 | [`+feed-shortcut-list`](references/lark-im-feed-shortcut-list.md) | List one page of the user's feed shortcuts; user-only; omit `--page-token` for the first page; default output enriches CHAT entries under `detail`; pass `--no-detail` to skip the extra lookup and `im:chat:read` scope |

skills/lark-im/references/lark-im-flag-list.md

@@ -6,9 +6,9 @@ This skill maps to shortcut: `lark-cli im +flag-list`. Underlying API: `GET /ope
 
 ## Sorting Rules (Important)
 
-The API returns data sorted by `update_time` in **ascending order**, meaning **oldest first, newest last**. When `has_more=true`, you cannot simply take the first page's items as the latest flags — you must paginate through all pages and take the last item on the last page as the newest.
+The API returns data sorted by `update_time` in **ascending order**, meaning **oldest first, newest last**. When `has_more=true`, continue pagination until `has_more=false`; only then is the last item in the merged result authoritative as the newest flag. If pagination stops while `has_more=true`, the last item is only the newest observed flag.
 
-Recommended: use `--page-all` for auto-pagination to get the complete list, then use `-q '.data.flag_items[-1]'` to get the latest item.
+`--page-all` enables automatic pagination but is still capped by `--page-limit`. The default cap is 20 pages; **20 is not the hard maximum**. Set `--page-limit` between 1 and 1000 when a larger scan is required. A response with `has_more=true` is incomplete, even when `flag_items` is empty; increase the limit or resume from the returned `page_token` before reporting an authoritative latest item or count.
 
 ## Commands
 
@@ -19,7 +19,7 @@ lark-cli im +flag-list --as user
 # Manual pagination with custom page size
 lark-cli im +flag-list --as user --page-size 30 --page-token <page_token>
 
-# Auto-paginate to get all flags (recommended)
+# Auto-paginate, capped at the default 20 pages
 lark-cli im +flag-list --as user --page-all
 
 # Auto-paginate + get the latest flag
@@ -31,8 +31,8 @@ lark-cli im +flag-list --as user --page-all -q '.data.flag_items[].item_id'
 # Disable auto-enrichment of message content (enabled by default)
 lark-cli im +flag-list --as user --page-all --enrich-feed-thread=false
 
-# Limit max pages (default 20, max 1000)
-lark-cli im +flag-list --as user --page-all --page-limit 10
+# Use the largest supported page limit for a broader scan
+lark-cli im +flag-list --as user --page-all --page-limit 1000
 ```
 
 ## Parameters
@@ -41,8 +41,8 @@ lark-cli im +flag-list --as user --page-all --page-limit 10
 |------|------|------|
 | `--page-size <n>` | 50 | Range 1-50 (server max is 50) |
 | `--page-token <token>` | empty | Pagination token from previous page; empty string must still be provided |
-| `--page-all` | false | Auto-paginate to fetch all pages and merge results |
-| `--page-limit <n>` | 20 | Max pages in `--page-all` mode (max 1000) |
+| `--page-all` | false | Auto-paginate and merge results, capped by `--page-limit` |
+| `--page-limit <n>` | 20 | Max pages in `--page-all` mode; configurable range 1-1000 (20 is only the default) |
 | `--enrich-feed-thread` | true | Auto-enrich feed-layer thread entries with message content (calls `im.messages.mget`) |
 | `--as user` | Required | Currently only supports user identity |
 
@@ -62,6 +62,7 @@ Note: `(thread, feed)` / `(msg_thread, feed)` entries are automatically enriched
 
 ## Limitations
 
+- **Auto-pagination is bounded**: `--page-all` fetches at most 20 pages by default. If the response still has `has_more=true`, the result is incomplete; increase `--page-limit` up to 1000 or resume with `page_token`. Never interpret `flag_items: []` as an authoritative zero while more pages remain. Historical `delete_flag_items` may occupy early pages and push active flags to later pages.
 - **delete_flag_items are not enriched**: Message content is only fetched for active flags (`flag_items`), not canceled flags (`delete_flag_items`). If you need message content for a canceled flag, query the message separately using `+messages-mget --message-ids <item_id>`.
 
 ## Response Example (Sanitized)

skills/lark-slides/SKILL.md

@@ -81,6 +81,7 @@ metadata:
 | 用户要求使用模板 | 将模板导入为 Slides 再编辑 | `lark-slides-pptx-template-workflows.md` |
 | 编辑单个标题、文本块、图片或局部元素 | 优先块级替换/插入，不改页序 | `slides +replace-slide`、`lark-slides-replace-slide.md` |
 | 读取或分析已有 PPT | 解析 slides/wiki token，用 shortcut 回读全文 XML 或读取单页 XML，保存 `xml_presentation_id`、`slide_id`、`revision_id` | `slides +xml-get`、`xml_presentation.slide.get`、`lark-slides-xml-presentations-get.md` |
+| 查看或回滚历史版本 | 先用 `+history-list` 找 `history_version_id`，再 `+history-revert`，必要时 `+history-revert-status` 轮询 | [`lark-slides-history.md`](references/lark-slides-history.md) |
 | 获取幻灯片页面截图 | 用 `slide_id` 或页号指定页面，一次不超过 10 页 | `slides +screenshot`、`lark-slides-screenshot.md` |
 | 上传或使用图片 | 先上传为 `file_token`，禁止直接写 http(s) 外链 | `slides +media-upload`、`lark-slides-media-upload.md`，或 `+create --slides` 的 `@./path` 占位符 |
 | 绘制图表 | 原生图表（柱状、条形、折线、面积、饼（环）、雷达、组合图）用 `<chart>`，其他（漏斗图、金字塔图、象限图、矩阵图等）用 `<shape>` + `<line>` 模拟 | `xml-schema-quick-ref.md`、`slides_chart_demo.xml` |
@@ -90,6 +91,8 @@ metadata:
 
 **CRITICAL — 开始前 MUST 先用 Read 工具读取 [`../lark-shared/SKILL.md`](../lark-shared/SKILL.md)，认证、权限和全局参数均以 lark-shared 为准。**
 
+**CRITICAL — 查看或回滚历史版本前，MUST 先读取 [`lark-slides-history.md`](references/lark-slides-history.md)。回滚接口只接受 `history_version_id`，不要把 `revision_id` 直接传给 `+history-revert`。**
+
 **CRITICAL — 生成任何 XML 之前，MUST 先用 Read 工具读取 [xml-schema-quick-ref.md](references/xml-schema-quick-ref.md)，禁止凭记忆猜测 XML 结构。**
 
 **CRITICAL — 新建演示文稿或大幅改写页面时，MUST 先生成 `.lark-slides/plan/<deck-or-task-id>/slide_plan.json`，再生成 XML。先创建对应目录，规划层规则和中间产物生命周期见 [planning-layer.md](references/planning-layer.md)。仅替换一个标题、插入一个块等小型已有页编辑可豁免。**
@@ -143,6 +146,7 @@ lark-cli auth login --domain slides
 - 创建：[`lark-slides-create.md`](references/lark-slides-create.md)
 - 阅读：[`lark-slides-xml-presentations-get.md`](references/lark-slides-xml-presentations-get.md)
 - 编辑：[`lark-slides-edit-workflows.md`](references/lark-slides-edit-workflows.md)、[`lark-slides-replace-slide.md`](references/lark-slides-replace-slide.md)、[`lark-slides-replace-pages.md`](references/lark-slides-replace-pages.md)
+- 历史版本：[`lark-slides-history.md`](references/lark-slides-history.md)
 - 截图：[`lark-slides-screenshot.md`](references/lark-slides-screenshot.md)
 - 图片：[`lark-slides-media-upload.md`](references/lark-slides-media-upload.md)
 - 图表：[`slides_chart_demo.xml`](references/slides_chart_demo.xml)

skills/lark-slides/references/lark-slides-history.md

@@ -0,0 +1,132 @@
+# slides history（历史版本与回滚）
+
+用于查看 Slides XML presentation 历史版本、按 `history_version_id` 回滚，以及查询回滚任务状态。
+
+`entries[].edit_time` 是 UTC RFC3339 时间字符串（例如 `2026-06-22T12:24:45Z`）。按时间匹配时先将其解析为时间值，再比较先后关系或时间差。
+
+## 安全流程
+
+1. 先用分页接口 `+history-list` 找到目标版本的 `history_version_id`。
+2. 如果用户指定的是 `revision_id`，不要假设它唯一，也不要把 `revision_id` 直接传给 `+history-revert`。先拉一页并在 `entries[]` 中筛选 `revision_id` 相同的候选；如果未匹配到且 `has_more=true`，继续用 `page_token` 翻页；如果已匹配到候选，最多额外再拉一页补齐可能跨页的相邻候选。最终优先根据用户目标时间与 `edit_time` 的接近程度选择最合适的一条，取同一条的 `history_version_id`；如果没有目标时间，或多个候选无法可靠区分，再向用户展示候选版本（`history_version_id`、`revision_id`、`edit_time`、`name/description`）并确认后回滚。
+3. 如果用户指定的是某一时刻但没有指定 `revision_id`，按 `entries[].edit_time` 匹配；优先选择不晚于目标时刻的最近一条历史记录，无法明确匹配时先向用户确认候选版本。
+4. 使用 `+history-revert` 发起回滚。接口会立即返回 `task_id`，回滚任务在服务端异步执行。
+5. 如果返回 `status: running`，保存 `task_id`，按照返回的 `poll_after_ms` 等待后调用 `+history-revert-status`。任务创建成功后，不得因为状态查询失败而重新发起回滚。
+6. 状态变为 `done`、`partial_failed` 或 `failed` 后停止轮询；达到整体轮询上限时也停止轮询，并向用户返回 `task_id` 和当前状态。
+7. 回滚完成后，用 `slides +xml-get` 或 `slides xml_presentations get` 读取演示文稿确认内容。
+
+## 按 revision_id 或时间点回滚
+
+当用户说“回滚到 revision_id=42”“恢复到昨天下午 3 点的版本”这类需求时，流程是：
+
+1. 执行 `slides +history-list --presentation <presentation>` 获取第一页历史记录；`+history-list` 是分页接口，只有 `has_more=true` 且还需要更多候选时才继续传 `--page-token` 翻页。
+2. 如果用户给出 `revision_id`：先筛选当前页中 `entries[].revision_id == 用户给出的 revision_id`。如果未命中且 `has_more=true`，继续拉下一页；如果已经命中候选，最多额外再拉一页，补齐同一个 `revision_id` 可能跨页出现的相邻 `history_version_id`。若用户同时给出目标时间，在候选里选择 `edit_time` 与目标时间最接近的一条；若未给目标时间但候选只有一条，可直接使用；若多个候选无法可靠区分，不要自行取第一条，向用户展示候选并确认。
+3. 如果用户只给出时间：用 `entries[].edit_time` 匹配，选择目标时刻之前最近的一条；如果用户表达的是“最接近某时刻”，则选择绝对时间差最小的一条。
+4. 从最终匹配条目读取 `history_version_id`。`history_version_id` 对应服务端 `minor_history.version`，这是回滚接口需要的 ID。
+5. 执行 `slides +history-revert --presentation <presentation> --history-version-id <history_version_id>`。
+
+候选确认时使用类似格式：
+
+```text
+同一个 revision_id 命中多个历史版本，请确认要回滚哪一条：
+- history_version_id=11 revision_id=42 edit_time=2026-06-22T12:24:45Z name=...
+- history_version_id=12 revision_id=42 edit_time=2026-06-22T12:25:14Z name=...
+```
+
+## 命令
+
+```bash
+# 列出历史版本
+lark-cli slides +history-list --presentation "<slides_url_or_token>" --page-size 20
+
+# 翻页
+lark-cli slides +history-list --presentation "<slides_url_or_token>" --page-size 20 --page-token "<page_token>"
+
+# 发起回滚任务，立即返回 task_id
+lark-cli slides +history-revert --presentation "<slides_url_or_token>" --history-version-id 42
+
+# 查询回滚任务状态
+lark-cli slides +history-revert-status --presentation "<slides_url_or_token>" --task-id "<task_id>"
+```
+
+## 参数
+
+| 命令 | 参数 | 必填 | 说明 |
+|-|-|-|-|
+| `+history-list` | `--presentation` | 是 | `xml_presentation_id`、Slides URL，或可解析为 Slides 的 wiki URL |
+| `+history-list` | `--page-size` | 否 | 返回条数，范围 `1-20`，默认 `20` |
+| `+history-list` | `--page-token` | 否 | 上一页返回的 `page_token` |
+| `+history-revert` | `--presentation` | 是 | 同一个演示文稿 |
+| `+history-revert` | `--history-version-id` | 是 | `+history-list` 返回的 `history_version_id`，必须大于 0 |
+| `+history-revert-status` | `--presentation` | 是 | 同一个演示文稿 |
+| `+history-revert-status` | `--task-id` | 是 | `+history-revert` 返回的 `task_id` |
+
+## 异步轮询策略
+
+1. `+history-revert` 返回 `task_id` 后，认为回滚任务已经成功创建。
+2. 如果 `status` 不是 `running`，不再调用状态接口。
+3. 如果 `status` 是 `running`，等待响应中的 `poll_after_ms` 后调用 `+history-revert-status`；`poll_after_ms` 缺失、为 `0` 或非法时，默认等待 10 秒。
+4. 状态查询返回 `running` 时继续轮询；返回 `done`、`partial_failed` 或 `failed` 时停止。
+5. 除非用户另有要求，默认最多轮询 5 分钟。达到上限后停止轮询，向用户说明任务仍在运行并返回 `task_id`，不得将其描述为回滚失败。
+6. 状态查询出现临时错误时，按相同间隔最多连续重试 3 次；只重试 `+history-revert-status`，不得重新调用 `+history-revert`。
+7. `done` 后读取当前演示文稿内容进行验证。
+8. `partial_failed` 或 `failed` 时展示 `failed_block_tokens`；除非用户明确确认，不得自动再次发起回滚。
+
+## 返回值要点
+
+`+history-list` 返回：
+
+```json
+{
+  "entries": [
+    {
+      "revision_id": 42,
+      "history_version_id": "11",
+      "edit_time": "2026-06-22T12:24:45Z",
+      "type": 1,
+      "name": "版本名",
+      "description": "版本说明",
+      "editor_ids": ["ou_xxx"]
+    }
+  ],
+  "has_more": true,
+  "page_token": "page_token"
+}
+```
+
+`+history-revert` 返回：
+
+```json
+{
+  "task_id": "task_xxx",
+  "status": "running",
+  "history_version_id": "11",
+  "poll_after_ms": 10000
+}
+```
+
+`+history-revert-status` 返回：
+
+```json
+{
+  "status": "partial_failed",
+  "history_version_id": "11",
+  "failed_block_tokens": ["blk_xxx"]
+}
+```
+
+`status` 可能是 `running`、`done`、`partial_failed`、`failed`。当状态是 `partial_failed` 或 `failed` 时，优先检查 `failed_block_tokens`。
+
+## 回滚后验证
+
+回滚成功后必须读取一次当前内容确认：
+
+```bash
+lark-cli slides +xml-get --presentation "<slides_url_or_token>" --output ./presentation.xml
+```
+
+如果只需要快速检查返回结构，也可以走 raw OpenAPI：
+
+```bash
+lark-cli api get "/open-apis/slides_ai/v1/xml_presentations/<xml_presentation_id>" \
+  --params '{"revision_id":-1}'
+```

skills/lark-slides/references/xml-schema-quick-ref.md

@@ -17,7 +17,7 @@
   <slide>
     <data>
       <shape type="text" topLeftX="80" topLeftY="80" width="800" height="120">
-        <content textType="title">
+        <content autoFit="normal-auto-fit" wrap="true" textType="title">
           <p>标题</p>
         </content>
       </shape>
@@ -133,7 +133,7 @@ XSD 中的 `title`、`headline`、`sub-headline`、`body`、`caption` 主要出
 示例：
 
 ```xml
-<content textType="body" textAlign="left">
+<content autoFit="normal-auto-fit" textType="body" textAlign="left">
   <p>正文内容 <strong>加粗</strong> <em>斜体</em> <a href="https://example.com">链接</a></p>
   <ul>
     <li><p>列表项 1</p></li>
@@ -351,7 +351,7 @@ XSD 中的 `title`、`headline`、`sub-headline`、`body`、`caption` 主要出
 
 ```xml
 <note>
-  <content textType="body">
+  <content autoFit="normal-auto-fit" textType="body">
     <p>这是演讲者备注。</p>
   </content>
 </note>

skills/lark-slides/scripts/xml_text_overlap_lint.py

@@ -38,6 +38,10 @@ SXSD_ATTR_ALIASES = {
     "fontColor": "color",
 }
 SERVER_FILLED_SXSD_ATTRS = {"id"}
+ROUNDTRIP_SXSD_ATTRS = {
+    ("chart", "updated"),
+    ("chartData", "isStaticData"),
+}
 DEFAULT_TABLE_COLUMN_WIDTH = 110
 DEFAULT_TABLE_ROW_HEIGHT = 37
 _SXSD_TAG_ATTRIBUTES_CACHE: dict[str, set[str]] | None = None
@@ -62,7 +66,7 @@ def parse_args(argv: list[str]) -> dict[str, Any]:
     while index < len(argv):
         token = argv[index]
         if not token.startswith("--"):
-            fail(f"unexpected argument: {token}")
+            fail(f"unexpected argument: {token}, need --input")
         key = token[2:]
         next_token = argv[index + 1] if index + 1 < len(argv) else None
         if next_token is None or next_token.startswith("--"):
@@ -168,8 +172,10 @@ def solve_weighted_min_layout(
     return {"final_sizes": final_sizes, "actual_size": sum_sizes(final_sizes), "ratio": ratio}
 
 
-def strip_xml(value: str) -> str:
+def strip_xml(value: str, preserve_line_breaks: bool = False) -> str:
     stripped = re.sub(r"<!\[CDATA\[([\s\S]*?)\]\]>", r"\1", value)
+    if preserve_line_breaks:
+        stripped = re.sub(r"<br\b[^>]*>", "\n", stripped)
     stripped = re.sub(r"<[^>]+>", " ", stripped)
     stripped = stripped.replace("&nbsp;", " ")
     stripped = stripped.replace("&amp;", "&")
@@ -177,14 +183,46 @@ def strip_xml(value: str) -> str:
     stripped = stripped.replace("&gt;", ">")
     stripped = stripped.replace("&quot;", '"')
     stripped = stripped.replace("&#39;", "'")
+    if preserve_line_breaks:
+        return "\n".join(re.sub(r"\s+", " ", line).strip() for line in stripped.split("\n"))
     return re.sub(r"\s+", " ", stripped).strip()
 
 
 def strip_xml_paragraphs(value: str) -> str:
     paragraphs = re.findall(r"<p\b[^>]*>([\s\S]*?)</p\s*>", value)
     if paragraphs:
-        return "\n".join(strip_xml(paragraph) for paragraph in paragraphs)
-    return strip_xml(value)
+        return "\n".join(strip_xml(paragraph, preserve_line_breaks=True) for paragraph in paragraphs)
+    return strip_xml(value, preserve_line_breaks=True)
+
+
+def extract_text_paragraphs(value: str, default_font_size: int | float) -> list[dict[str, Any]]:
+    paragraphs = []
+    for attrs, body in re.findall(r"<p\b([^>]*)>([\s\S]*?)</p\s*>", value):
+        paragraphs.append(
+            {
+                "text": strip_xml(body, preserve_line_breaks=True),
+                "fontSize": extract_max_span_font_size(body, default_font_size),
+                "textAlign": extract_attribute(attrs, "textAlign"),
+                "lineSpacing": extract_attribute(attrs, "lineSpacing"),
+                "beforeLineSpacing": extract_attribute(attrs, "beforeLineSpacing"),
+                "afterLineSpacing": extract_attribute(attrs, "afterLineSpacing"),
+            }
+        )
+    return paragraphs
+
+
+def extract_max_span_font_size(value: str, default_font_size: int | float) -> int | float:
+    font_sizes = [
+        font_size
+        for attrs in re.findall(r"<span\b([^>]*)>", value)
+        if (font_size := extract_numeric_attribute(attrs, "fontSize")) is not None
+    ]
+    return max([default_font_size, *font_sizes])
+
+
+def extract_tag_attributes(value: str, tag: str) -> str:
+    match = re.search(fr"<{re.escape(tag)}\b([^>]*)>", value)
+    return match.group(1) if match else ""
 
 
 def xml_local_name(tag: str) -> str:
@@ -319,8 +357,8 @@ def should_skip_sxsd_subtree(element: ET.Element, ancestors: list[str]) -> bool:
     return "whiteboard" in ancestors and xml_namespace(element.tag) == SVG_NS
 
 
-def should_skip_sxsd_attribute(attr_name: str) -> bool:
-    return attr_name in SERVER_FILLED_SXSD_ATTRS
+def should_skip_sxsd_attribute(tag_name: str, attr_name: str) -> bool:
+    return attr_name in SERVER_FILLED_SXSD_ATTRS or (tag_name, attr_name) in ROUNDTRIP_SXSD_ATTRS
 
 
 def validate_sxsd_tag_attributes(root: ET.Element) -> list[dict[str, Any]]:
@@ -352,7 +390,7 @@ def validate_sxsd_tag_attributes(root: ET.Element) -> list[dict[str, Any]]:
                 if raw_attr_name.startswith(XML_NS):
                     continue
                 attr_name = xml_local_name(raw_attr_name)
-                if should_skip_sxsd_attribute(attr_name):
+                if should_skip_sxsd_attribute(tag_name, attr_name):
                     continue
                 if attr_name in allowed_attrs:
                     continue
@@ -606,6 +644,7 @@ def extract_elements(slide_xml: str) -> list[dict[str, Any]]:
         width = extract_numeric_attribute(attrs, "width")
         height = extract_numeric_attribute(attrs, "height")
         rotation = extract_numeric_attribute(attrs, "rotation") or 0
+        alpha = extract_numeric_attribute(attrs, "alpha")
         table_layouts: dict[str, dict[str, Any] | None] = {}
         if kind == "table":
             width, table_layouts["width"] = resolve_table_dimension(
@@ -624,6 +663,7 @@ def extract_elements(slide_xml: str) -> list[dict[str, Any]]:
                 "width": width,
                 "height": height,
                 "rotation": rotation,
+                "alpha": alpha if alpha is not None else 1,
                 "order": len(elements),
             }
             if kind == "table":
@@ -635,15 +675,28 @@ def extract_elements(slide_xml: str) -> list[dict[str, Any]]:
                     }
                 )
             if kind == "shape":
+                content_attrs = extract_tag_attributes(content, "content")
+                font_size = extract_numeric_attribute(content_attrs, "fontSize")
+                if font_size is None:
+                    font_size = extract_numeric_attribute(attrs, "fontSize")
                 element.update(
                     {
-                        "textType": extract_attribute(content, "textType"),
-                        "textAlign": extract_attribute(content, "textAlign"),
-                        "autoFit": extract_attribute(content, "autoFit"),
-                        "fontSize": float(
-                            extract_attribute(content, "fontSize") or extract_attribute(attrs, "fontSize") or 16
-                        ),
+                        "textType": extract_attribute(content_attrs, "textType"),
+                        "textAlign": extract_attribute(content_attrs, "textAlign"),
+                        "verticalAlign": extract_attribute(content_attrs, "verticalAlign") or "middle",
+                        "vert": extract_attribute(attrs, "vert") or "horz",
+                        "autoFit": extract_attribute(content_attrs, "autoFit"),
+                        "wrap": extract_attribute(content_attrs, "wrap"),
+                        "lineSpacing": extract_attribute(content_attrs, "lineSpacing"),
+                        "beforeLineSpacing": extract_attribute(content_attrs, "beforeLineSpacing"),
+                        "afterLineSpacing": extract_attribute(content_attrs, "afterLineSpacing"),
+                        "paddingTop": extract_numeric_attribute(content_attrs, "paddingTop") or 0,
+                        "paddingRight": extract_numeric_attribute(content_attrs, "paddingRight") or 0,
+                        "paddingBottom": extract_numeric_attribute(content_attrs, "paddingBottom") or 0,
+                        "paddingLeft": extract_numeric_attribute(content_attrs, "paddingLeft") or 0,
+                        "fontSize": font_size if font_size is not None else 16,
                         "text": strip_xml_paragraphs(content),
+                        "paragraphs": extract_text_paragraphs(content, font_size if font_size is not None else 16),
                     }
                 )
             elements.append(element)
@@ -671,6 +724,40 @@ def has_text_content(element: dict[str, Any]) -> bool:
     return bool(element.get("text"))
 
 
+def is_vertical_text(element: dict[str, Any]) -> bool:
+    return element.get("vert") in {"vert", "vert270", "word-art-vert", "word-art-vert-rtl", "ea-vert"}
+
+
+def detect_image_text_occlusions(elements: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    issues: list[dict[str, Any]] = []
+    text_elements = [element for element in elements if is_text_element(element) and has_text_content(element)]
+    image_elements = [element for element in elements if element["kind"] == "img" and element["alpha"] > 0]
+    for text_element in text_elements:
+        for image_element in image_elements:
+            if image_element["order"] <= text_element["order"]:
+                continue
+            if is_vertical_text(text_element):
+                if intersects(image_element, text_element):
+                    issues.append({
+                        "level": "info",
+                        "code": "image_may_cover_vertical_text",
+                        "elements": [image_element["id"], text_element["id"]],
+                        "message": f'image {image_element["id"]} may cover vertical text shape {text_element["id"]}',
+                        "hint": "Inspect the rendered slide because vertical text layout is not statically modeled.",
+                    })
+                continue
+            text_visual_bbox = estimate_text_visual_bbox(text_element)
+            if text_visual_bbox is not None and intersects(image_element, text_visual_bbox):
+                issues.append({
+                    "level": "error",
+                    "code": "image_covers_text",
+                    "elements": [image_element["id"], text_element["id"]],
+                    "message": f'image {image_element["id"]} covers text shape {text_element["id"]}',
+                    "hint": "Move the image before the text shape in XML order, or adjust the image and text shape coordinates or dimensions.",
+                })
+    return issues
+
+
 def is_decorative_text(element: dict[str, Any]) -> bool:
     text = element.get("text") or ""
     return bool(text) and re.search(r"[A-Za-z0-9\u4e00-\u9fff]", text) is None
@@ -708,27 +795,135 @@ def is_similar_text_overlay(left: dict[str, Any], right: dict[str, Any]) -> bool
     return SequenceMatcher(None, left_text, right_text).ratio() >= 0.75
 
 
-def estimate_text_line_count(element: dict[str, Any]) -> int:
+def estimate_text_line_count_for_text(element: dict[str, Any], text: str) -> int:
     font_size = element["fontSize"] if isinstance(element["fontSize"], (int, float)) else 16
-    paragraphs = [paragraph for paragraph in re.split(r"\n+", element["text"]) if paragraph]
+    hard_lines = text.split("\n")
+    if not text:
+        return 0
     line_count = 0
-    for paragraph in paragraphs:
-        logical_width = max(estimate_text_width(paragraph, font_size), 1)
+    for hard_line in hard_lines:
+        if element.get("wrap") in {"false", "0"}:
+            line_count += 1
+            continue
+        logical_width = max(estimate_text_width(hard_line, font_size), 1)
         line_count += max(1, math.ceil(logical_width / max(element["width"], 1)))
-    return max(line_count, 1)
+    return line_count
+
+
+def estimate_text_line_count(element: dict[str, Any]) -> int:
+    return max(estimate_text_line_count_for_text(element, element["text"]), 1)
+
+
+def estimate_text_line_height(element: dict[str, Any], line_spacing: str | None = None) -> int | float | None:
+    font_size = element["fontSize"] if isinstance(element["fontSize"], (int, float)) else 16
+    line_spacing = line_spacing or "multiple:1.5"
+    match = re.fullmatch(r"(multiple|fixed):([0-9]+(?:\.[0-9]+)?)", line_spacing)
+    if match is None:
+        return None
+    spacing_type, value = match.groups()
+    return font_size * float(value) if spacing_type == "multiple" else float(value)
+
+
+def detect_text_may_overflow_shapes(elements: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    issues: list[dict[str, Any]] = []
+    for element in elements:
+        if not is_text_element(element) or not has_text_content(element):
+            continue
+        if element.get("autoFit") in {"normal-auto-fit", "shape-auto-fit"}:
+            continue
+
+        font_size = element["fontSize"] if isinstance(element["fontSize"], (int, float)) else 16
+        paragraphs = element.get("paragraphs") or [
+            {
+                "text": element["text"],
+                "lineSpacing": None,
+                "beforeLineSpacing": None,
+                "afterLineSpacing": None,
+            }
+        ]
+        line_count = 0
+        estimated_height = 0.0
+        line_heights: list[int | float] = []
+        for paragraph in paragraphs:
+            paragraph_line_count = estimate_text_line_count_for_text(element, paragraph["text"])
+            if paragraph_line_count == 0:
+                continue
+            line_height = estimate_text_line_height(element, paragraph["lineSpacing"] or element["lineSpacing"])
+            before_spacing = estimate_text_line_height(
+                element, paragraph["beforeLineSpacing"] or element["beforeLineSpacing"] or "fixed:0"
+            )
+            after_spacing = estimate_text_line_height(
+                element, paragraph["afterLineSpacing"] or element["afterLineSpacing"] or "fixed:0"
+            )
+            if line_height is None or before_spacing is None or after_spacing is None:
+                line_count = 0
+                break
+            first_line_height = font_size if line_count == 0 else line_height
+            line_count += paragraph_line_count
+            line_heights.append(line_height)
+            estimated_height += (
+                before_spacing + first_line_height + max(paragraph_line_count - 1, 0) * line_height + after_spacing
+            )
+        if line_count == 0:
+            continue
+        available_height = max(element["height"] - element["paddingTop"] - element["paddingBottom"], 0)
+        overflow = estimated_height - available_height
+        if overflow <= 0:
+            continue
+
+        issues.append(
+            {
+                "level": "warning",
+                "code": "text_may_overflow_shape",
+                "elements": [element["id"]],
+                "line_count": line_count,
+                "line_height": max(line_heights),
+                "estimated_height": estimated_height,
+                "available_height": available_height,
+                "overflow": overflow,
+                "message": (
+                    f'text shape {element["id"]} may overflow its own content box '
+                    f'(estimated {estimated_height:g}px, available {available_height:g}px); '
+                    'consider setting content wrap="true" autoFit="normal-auto-fit"'
+                ),
+                "hint": (
+                    "Increase shape.height, reduce the text, or set content wrap=\"true\" "
+                    "autoFit=\"normal-auto-fit\". "
+                    "This is an estimate based on font size, line spacing, and wrapped line count."
+                ),
+            }
+        )
+    return issues
 
 
 def estimate_text_visual_bbox(element: dict[str, Any]) -> dict[str, int | float] | None:
     if not is_text_element(element) or not has_text_content(element) or is_decorative_text(element):
         return None
 
+    padding_left = element.get("paddingLeft", 0)
+    padding_right = element.get("paddingRight", 0)
+    padding_top = element.get("paddingTop", 0)
+    padding_bottom = element.get("paddingBottom", 0)
+    content_width = max(element["width"] - padding_left - padding_right, 0)
+    content_height = max(element["height"] - padding_top - padding_bottom, 0)
     font_size = element["fontSize"] if isinstance(element["fontSize"], (int, float)) else 16
     line_count = estimate_text_line_count(element)
-    visual_width = min(element["width"], max(1, estimate_text_max_line_width(element)))
-    visual_height = min(element["height"], max(1, line_count * font_size * 1.2))
+    estimated_width = max(1, estimate_text_max_line_width(element))
+    visual_width = estimated_width if element.get("wrap") in {"false", "0"} else min(content_width, estimated_width)
+    visual_height = min(content_height, max(1, line_count * font_size * 1.2))
+    x = element["x"] + padding_left
+    if element.get("textAlign") == "center":
+        x += (content_width - visual_width) / 2
+    elif element.get("textAlign") == "right":
+        x += content_width - visual_width
+    y = element["y"] + padding_top
+    if element.get("verticalAlign") == "middle":
+        y += (content_height - visual_height) / 2
+    elif element.get("verticalAlign") == "bottom":
+        y += content_height - visual_height
     return {
-        "x": element["x"],
-        "y": element["y"],
+        "x": x,
+        "y": y,
         "width": visual_width,
         "height": visual_height,
     }
@@ -818,6 +1013,10 @@ def should_flag_horizontal_text_overflow(left: dict[str, Any], right: dict[str,
     source, target = sorted([left, right], key=lambda element: element["x"])
     if source["x"] == target["x"]:
         return False
+    wrap_enabled = source.get("wrap") not in {"false", "0"}
+    has_horizontal_gap = source["x"] + source["width"] <= target["x"]
+    if wrap_enabled and has_horizontal_gap:
+        return False
     if source.get("autoFit") == "normal-auto-fit":
         return False
     if source.get("textAlign") in {"center", "right"}:
@@ -1116,6 +1315,8 @@ def lint_slide(
         *detect_whiteboard_external_overlaps(elements, slide_width, slide_height),
         *detect_elements_out_of_canvas(elements, slide_width, slide_height),
         *detect_table_layout_size_mismatches(elements),
+        *detect_text_may_overflow_shapes(elements),
+        *detect_image_text_occlusions(elements),
     ]
 
     for index, left in enumerate(elements):

skills/lark-slides/scripts/xml_text_overlap_lint_test.py

@@ -34,6 +34,24 @@ class XmlTextOverlapLintTest(unittest.TestCase):
             f"{sample_name} has XML text overlap lint warnings:\n" + "\n".join(issue_summaries),
         )
 
+    def test_cli_suggests_input_flag_for_positional_argument(self) -> None:
+        script_path = Path(xml_text_overlap_lint.__file__).resolve()
+        input_path = "/sandboxdata/workspace/file/full_presentation.xml"
+
+        completed = subprocess.run(
+            [sys.executable, str(script_path), input_path],
+            capture_output=True,
+            check=False,
+            text=True,
+        )
+
+        self.assertEqual(completed.returncode, 1)
+        self.assertEqual(completed.stdout, "")
+        self.assertEqual(
+            completed.stderr,
+            f"xml-text-overlap-lint error: unexpected argument: {input_path}，need --input\n",
+        )
+
     def test_xml_text_overlap_lint_accepts_inline_fixture_xml_samples(self) -> None:
         samples = {
             "image-led-cover": """
@@ -311,6 +329,42 @@ class XmlTextOverlapLintTest(unittest.TestCase):
         self.assertEqual(issue["tag"], "fill")
         self.assertEqual(issue["attr"], "unexpected")
 
+    def test_lint_xml_ignores_chart_roundtrip_attrs(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0">
+              <data>
+                <chart updated="true" topLeftX="80" topLeftY="80" width="300" height="160">
+                  <chartData isStaticData="true"/>
+                </chart>
+              </data>
+            </slide>
+            """
+        )
+
+        self.assertEqual(result["summary"]["error_count"], 0)
+        self.assertNotIn("issues", result)
+
+    def test_lint_xml_limits_chart_roundtrip_attrs_to_matching_tags(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0">
+              <data>
+                <chart isStaticData="true" topLeftX="80" topLeftY="80" width="300" height="160">
+                  <chartData updated="true"/>
+                </chart>
+              </data>
+            </slide>
+            """
+        )
+
+        self.assertEqual(result["summary"]["error_count"], 2)
+        self.assertEqual(
+            {(issue["tag"], issue["attr"]) for issue in result["issues"]},
+            {("chart", "isStaticData"), ("chartData", "updated")},
+        )
+        self.assertTrue(all(issue["code"] == "sxsd_unsupported_attr" for issue in result["issues"]))
+
     def test_lint_xml_reports_gradient_shorthand_attrs_on_fill_color(self) -> None:
         result = xml_text_overlap_lint.lint_xml(
             """
@@ -468,43 +522,6 @@ class XmlTextOverlapLintTest(unittest.TestCase):
         self.assertIn("iconpark-index.json", issue["hint"])
         self.assertIn("iconpark/Base/setting.svg", issue["hint"])
 
-    def test_lint_xml_allows_namespaced_svg_inside_whiteboard(self) -> None:
-        result = xml_text_overlap_lint.lint_xml(
-            """
-            <slide xmlns="http://www.larkoffice.com/sml/2.0">
-              <data>
-                <whiteboard id="wb" topLeftX="80" topLeftY="80" width="300" height="180">
-                  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 300 180">
-                    <rect x="10" y="10" width="120" height="60"/>
-                  </svg>
-                </whiteboard>
-              </data>
-            </slide>
-            """
-        )
-        self.assertEqual(result["summary"]["error_count"], 0)
-        self.assertNotIn("issues", result)
-
-    def test_lint_xml_reports_unqualified_svg_inside_whiteboard_with_namespace_hint(self) -> None:
-        result = xml_text_overlap_lint.lint_xml(
-            """
-            <slide xmlns="http://www.larkoffice.com/sml/2.0">
-              <data>
-                <whiteboard id="wb" topLeftX="80" topLeftY="80" width="300" height="180">
-                  <svg viewBox="0 0 300 180">
-                    <rect x="10" y="10" width="120" height="60"/>
-                  </svg>
-                </whiteboard>
-              </data>
-            </slide>
-            """
-        )
-        issue = result["issues"][0]
-        self.assertEqual(result["summary"]["error_count"], 1)
-        self.assertEqual(issue["code"], "sxsd_unsupported_tag")
-        self.assertEqual(issue["tag"], "svg")
-        self.assertIn('xmlns="http://www.w3.org/2000/svg"', issue["hint"])
-
     def test_lint_xml_detects_overlapping_text_boxes(self) -> None:
         result = xml_text_overlap_lint.lint_xml(
             """
@@ -523,6 +540,7 @@ class XmlTextOverlapLintTest(unittest.TestCase):
             """
         )
         self.assertEqual(result["summary"]["error_count"], 1)
+        self.assertEqual(result["summary"]["warning_count"], 0)
         self.assertEqual(result["slides"][0]["issues"][0]["code"], "bbox_overlap")
 
     def test_lint_xml_detects_current_itinerary_cjk_caption_occlusion(self) -> None:
@@ -589,7 +607,7 @@ class XmlTextOverlapLintTest(unittest.TestCase):
             <slide xmlns="http://www.larkoffice.com/sml/2.0">
               <data>
                 <shape id="source" type="text" topLeftX="80" topLeftY="100" width="160" height="40">
-                  <content fontSize="18"><p>这是一个足够长的中文文本用于检测跨越间隙的横向溢出</p></content>
+                  <content fontSize="18" wrap="false"><p>这是一个足够长的中文文本用于检测跨越间隙的横向溢出</p></content>
                 </shape>
                 <shape id="target" type="text" topLeftX="260" topLeftY="100" width="160" height="40">
                   <content fontSize="18"><p>目标</p></content>
@@ -599,10 +617,31 @@ class XmlTextOverlapLintTest(unittest.TestCase):
             """
         )
         self.assertEqual(result["summary"]["error_count"], 1)
+        self.assertEqual(result["summary"]["warning_count"], 0)
         self.assertEqual(result["slides"][0]["issues"][0]["code"], "bbox_overlap")
         self.assertEqual(result["slides"][0]["issues"][0]["elements"], ["source", "target"])
 
-    def test_lint_xml_reports_text_out_of_canvas_but_not_text_height(self) -> None:
+    def test_lint_xml_allows_horizontal_text_with_default_wrap(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0">
+              <data>
+                <shape id="source" type="text" topLeftX="80" topLeftY="100" width="160" height="40">
+                  <content fontSize="18"><p>这是一个足够长的中文文本用于检测默认自动换行</p></content>
+                </shape>
+                <shape id="target" type="text" topLeftX="260" topLeftY="100" width="160" height="40">
+                  <content fontSize="18"><p>目标</p></content>
+                </shape>
+              </data>
+            </slide>
+            """
+        )
+        self.assertEqual(result["summary"]["error_count"], 0)
+        self.assertEqual(result["summary"]["warning_count"], 1)
+        self.assertEqual(result["slides"][0]["issues"][0]["code"], "text_may_overflow_shape")
+        self.assertEqual(result["slides"][0]["issues"][0]["elements"], ["source"])
+
+    def test_lint_xml_reports_text_out_of_canvas_and_warns_for_text_height(self) -> None:
         result = xml_text_overlap_lint.lint_xml(
             """
             <presentation xmlns="http://www.larkoffice.com/sml/2.0" width="960" height="540">
@@ -621,10 +660,98 @@ class XmlTextOverlapLintTest(unittest.TestCase):
         )
         issue = result["slides"][0]["issues"][0]
         self.assertEqual(result["summary"]["error_count"], 1)
-        self.assertEqual(result["summary"]["warning_count"], 0)
+        self.assertEqual(result["summary"]["warning_count"], 1)
         self.assertEqual(issue["code"], "shape_out_of_canvas")
         self.assertEqual(issue["overflow"], {"left": 0, "top": 0, "right": 160, "bottom": 40})
 
+    def test_lint_xml_warns_when_text_may_overflow_its_own_shape(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0">
+              <data>
+                <shape id="overflowing" type="text" topLeftX="80" topLeftY="80" width="360" height="80">
+                  <content fontSize="20" lineSpacing="multiple:1.5">
+                    <p>第一段</p><p>第二段</p><p>第三段</p><p>第四段</p>
+                  </content>
+                </shape>
+                <shape id="fitting" type="text" topLeftX="480" topLeftY="80" width="360" height="120">
+                  <content fontSize="20" lineSpacing="multiple:1.5">
+                    <p>第一段</p><p>第二段</p><p>第三段</p><p>第四段</p>
+                  </content>
+                </shape>
+                <shape id="auto-fit" type="text" topLeftX="80" topLeftY="240" width="360" height="80">
+                  <content fontSize="20" lineSpacing="multiple:1.5" autoFit="normal-auto-fit">
+                    <p>第一段</p><p>第二段</p><p>第三段</p><p>第四段</p>
+                  </content>
+                </shape>
+              </data>
+            </slide>
+            """
+        )
+        issues = result["slides"][0]["issues"]
+        self.assertEqual(result["summary"]["error_count"], 0)
+        self.assertEqual(result["summary"]["warning_count"], 1)
+        self.assertEqual(issues[0]["code"], "text_may_overflow_shape")
+        self.assertEqual(issues[0]["elements"], ["overflowing"])
+        self.assertEqual(issues[0]["line_count"], 4)
+        self.assertEqual(issues[0]["estimated_height"], 110)
+        self.assertEqual(issues[0]["available_height"], 80)
+        self.assertEqual(issues[0]["overflow"], 30)
+        self.assertIn('wrap="true" autoFit="normal-auto-fit"', issues[0]["message"])
+
+    def test_lint_xml_uses_fixed_line_spacing_for_text_height_warning(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0">
+              <data>
+                <shape id="fixed-overflow" type="text" topLeftX="80" topLeftY="80" width="360" height="50">
+                  <content fontSize="20" lineSpacing="fixed:20">
+                    <p>第一段</p><p>第二段</p><p>第三段</p>
+                  </content>
+                </shape>
+              </data>
+            </slide>
+            """
+        )
+        issue = result["slides"][0]["issues"][0]
+        self.assertEqual(result["summary"]["warning_count"], 1)
+        self.assertEqual(issue["line_height"], 20)
+        self.assertEqual(issue["estimated_height"], 60)
+        self.assertEqual(issue["overflow"], 10)
+
+    def test_lint_xml_uses_paragraph_spacing_overrides_for_text_height_warning(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0">
+              <data>
+                <shape id="paragraph-overflow" type="text" topLeftX="80" topLeftY="80" width="360" height="35">
+                  <content fontSize="20" lineSpacing="multiple:1.5">
+                    <p lineSpacing="fixed:10" beforeLineSpacing="fixed:5" afterLineSpacing="fixed:5">第一行<br/>第二行</p>
+                  </content>
+                </shape>
+                <shape id="paragraph-fitting" type="text" topLeftX="480" topLeftY="80" width="360" height="40">
+                  <content fontSize="20" lineSpacing="multiple:1.5">
+                    <p lineSpacing="fixed:10">第一行<br/>第二行<br/>第三行</p>
+                  </content>
+                </shape>
+              </data>
+            </slide>
+            """
+        )
+        issues = result["slides"][0]["issues"]
+        self.assertEqual(result["summary"]["warning_count"], 1)
+        self.assertEqual(issues[0]["elements"], ["paragraph-overflow"])
+        self.assertEqual(issues[0]["line_count"], 2)
+        self.assertEqual(issues[0]["line_height"], 10)
+        self.assertEqual(issues[0]["estimated_height"], 40)
+        self.assertEqual(issues[0]["overflow"], 5)
+
+    def test_strip_xml_paragraphs_preserves_br_as_hard_line_break(self) -> None:
+        self.assertEqual(
+            xml_text_overlap_lint.strip_xml_paragraphs("<p>第一行<br/>第二行<br />第三行</p>"),
+            "第一行\n第二行\n第三行",
+        )
+
     def test_lint_xml_allows_template_style_bleed_and_text_over_images(self) -> None:
         result = xml_text_overlap_lint.lint_xml(
             """
@@ -730,7 +857,6 @@ class XmlTextOverlapLintTest(unittest.TestCase):
                   <shape id="outside-shape" type="text" topLeftX="-10" topLeftY="40" width="50" height="50"/>
                   <img id="outside-img" src="token" topLeftX="120" topLeftY="-20" width="50" height="50"/>
                   <chart id="outside-chart" topLeftX="900" topLeftY="100" width="100" height="100"/>
-                  <whiteboard id="outside-whiteboard" topLeftX="100" topLeftY="500" width="100" height="100"/>
                 </data>
               </slide>
             </presentation>
@@ -1054,89 +1180,6 @@ class XmlTextOverlapLintTest(unittest.TestCase):
                         result["slides"][0]["issues"],
                     )
 
-    def test_lint_xml_warns_for_whiteboard_external_boundary_overlap(self) -> None:
-        result = xml_text_overlap_lint.lint_xml(
-            """
-            <presentation xmlns="http://www.larkoffice.com/sml/2.0" width="960" height="540">
-              <slide xmlns="http://www.larkoffice.com/sml/2.0">
-                <data>
-                  <whiteboard id="wb" topLeftX="50" topLeftY="140" width="860" height="360"/>
-                  <shape id="card" type="rect" topLeftX="50" topLeftY="450" width="200" height="60">
-                    <fill><fillColor color="rgba(232, 186, 176, 0.2)"/></fill>
-                    <content/>
-                  </shape>
-                  <shape id="label" type="text" topLeftX="65" topLeftY="460" width="170" height="20">
-                    <content fontSize="12"><p>基础保障</p></content>
-                  </shape>
-                </data>
-              </slide>
-            </presentation>
-            """
-        )
-        issues = result["slides"][0]["issues"]
-        self.assertEqual(result["summary"]["error_count"], 0)
-        self.assertEqual(result["summary"]["warning_count"], 1)
-        self.assertEqual(issues[0]["code"], "whiteboard_external_overlap")
-        self.assertIn("static whiteboard container-bbox risk", issues[0]["hint"])
-        self.assertIn("screenshot QA", issues[0]["hint"])
-        self.assertEqual(issues[0]["elements"], ["wb", "card"])
-        self.assertEqual(issues[0]["overlaps"][0]["overlap_height"], 50)
-
-    def test_lint_xml_allows_whiteboard_internal_labels(self) -> None:
-        result = xml_text_overlap_lint.lint_xml(
-            """
-            <presentation xmlns="http://www.larkoffice.com/sml/2.0" width="960" height="540">
-              <slide xmlns="http://www.larkoffice.com/sml/2.0">
-                <data>
-                  <whiteboard id="wb" topLeftX="100" topLeftY="120" width="420" height="260"/>
-                  <shape id="label" type="text" topLeftX="150" topLeftY="180" width="180" height="40">
-                    <content fontSize="14"><p>内部标注</p></content>
-                  </shape>
-                </data>
-              </slide>
-            </presentation>
-            """
-        )
-        self.assertEqual(result["summary"]["error_count"], 0)
-        self.assertEqual(result["summary"]["warning_count"], 0)
-
-    def test_lint_xml_allows_bottom_layer_full_slide_whiteboard_background(self) -> None:
-        result = xml_text_overlap_lint.lint_xml(
-            """
-            <presentation xmlns="http://www.larkoffice.com/sml/2.0" width="960" height="540">
-              <slide xmlns="http://www.larkoffice.com/sml/2.0">
-                <data>
-                  <whiteboard id="background" topLeftX="0" topLeftY="0" width="960" height="540"/>
-                  <shape id="title" type="text" topLeftX="80" topLeftY="80" width="420" height="80">
-                    <content textType="title" fontSize="36"><p>Title</p></content>
-                  </shape>
-                </data>
-              </slide>
-            </presentation>
-            """
-        )
-        self.assertEqual(result["summary"]["error_count"], 0)
-        self.assertEqual(result["summary"]["warning_count"], 0)
-
-    def test_lint_xml_allows_whiteboard_inside_background_panel(self) -> None:
-        result = xml_text_overlap_lint.lint_xml(
-            """
-            <presentation xmlns="http://www.larkoffice.com/sml/2.0" width="960" height="540">
-              <slide xmlns="http://www.larkoffice.com/sml/2.0">
-                <data>
-                  <shape id="panel" type="rect" topLeftX="40" topLeftY="100" width="880" height="340">
-                    <fill><fillColor color="rgba(232, 186, 176, 0.2)"/></fill>
-                    <content/>
-                  </shape>
-                  <whiteboard id="wb" topLeftX="60" topLeftY="120" width="840" height="300"/>
-                </data>
-              </slide>
-            </presentation>
-            """
-        )
-        self.assertEqual(result["summary"]["error_count"], 0)
-        self.assertEqual(result["summary"]["warning_count"], 0)
-
     def test_lint_xml_detects_invalid_template_text_stack_overlap(self) -> None:
         cases = [
             (
@@ -1166,5 +1209,21 @@ class XmlTextOverlapLintTest(unittest.TestCase):
                 self.assertEqual(result["slides"][0]["issues"][0]["code"], "bbox_overlap")
 
 
+    def test_lint_xml_reports_vertical_text_image_overlap_as_info(self) -> None:
+        result = xml_text_overlap_lint.lint_xml(
+            """
+            <slide xmlns="http://www.larkoffice.com/sml/2.0"><data>
+              <shape id="text" type="text" vert="vert" topLeftX="100" topLeftY="100" width="100" height="100">
+                <content><p>Vertical</p></content>
+              </shape>
+              <img id="image" src="token" topLeftX="120" topLeftY="120" width="20" height="20"/>
+            </data></slide>
+            """
+        )
+        issue = next(issue for issue in result["slides"][0]["issues"] if issue["code"] == "image_may_cover_vertical_text")
+        self.assertEqual(issue["level"], "info")
+        self.assertEqual(result["summary"]["error_count"], 0)
+
+
 if __name__ == "__main__":
     unittest.main()

tests/cli_e2e/base/base_record_batch_update_dryrun_test.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package base
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	clie2e "github.com/larksuite/cli/tests/cli_e2e"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBaseRecordBatchUpdatePerRecordDryRun(t *testing.T) {
+	setBaseDryRunConfigEnv(t)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	t.Cleanup(cancel)
+
+	result, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"base", "+record-batch-update",
+			"--base-token", "app_x",
+			"--table-id", "tbl_x",
+			"--json", `{"update_records":{"recA":{"Status":["Done"]},"recB":{"Score":20}}}`,
+			"--dry-run",
+		},
+		DefaultAs: "bot",
+	})
+	require.NoError(t, err)
+	result.AssertExitCode(t, 0)
+
+	out := result.Stdout
+	require.Equal(t, "/open-apis/base/v3/bases/app_x/tables/tbl_x/records/batch_update", clie2e.DryRunGet(out, "api.0.url").String(), out)
+	require.Equal(t, "POST", clie2e.DryRunGet(out, "api.0.method").String(), out)
+	require.Equal(t, "Done", clie2e.DryRunGet(out, "api.0.body.update_records.recA.Status.0").String(), out)
+	require.Equal(t, int64(20), clie2e.DryRunGet(out, "api.0.body.update_records.recB.Score").Int(), out)
+}

tests/cli_e2e/base/base_record_batch_update_workflow_test.go

@@ -0,0 +1,111 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package base
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	clie2e "github.com/larksuite/cli/tests/cli_e2e"
+	"github.com/stretchr/testify/require"
+	"github.com/tidwall/gjson"
+)
+
+func TestBaseRecordBatchUpdatePerRecordWorkflow(t *testing.T) {
+	parentT := t
+	ctx, cancel := context.WithTimeout(context.Background(), 4*time.Minute)
+	t.Cleanup(cancel)
+
+	baseToken := createBaseWithRetry(t, ctx, "lark-cli-e2e-batch-update-"+clie2e.GenerateSuffix())
+	tableID, _, _ := createTableWithRetry(
+		t,
+		parentT,
+		ctx,
+		baseToken,
+		"Batch Update "+clie2e.GenerateSuffix(),
+		`[{"name":"Name","type":"text"},{"name":"Status","type":"select","multiple":false,"options":[{"name":"Open"},{"name":"Done"}]},{"name":"Score","type":"number"}]`,
+		`{"name":"Main","type":"grid"}`,
+	)
+
+	createResult, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"base", "+record-batch-create",
+			"--base-token", baseToken,
+			"--table-id", tableID,
+			"--json", `{"fields":["Name","Status","Score"],"rows":[["alpha","Open",10],["beta","Open",15]]}`,
+		},
+		DefaultAs: "bot",
+	})
+	require.NoError(t, err)
+	createResult.AssertExitCode(t, 0)
+	createResult.AssertStdoutStatus(t, true)
+
+	firstRecordID := gjson.Get(createResult.Stdout, "data.record_id_list.0").String()
+	secondRecordID := gjson.Get(createResult.Stdout, "data.record_id_list.1").String()
+	require.NotEmpty(t, firstRecordID, "stdout:\n%s", createResult.Stdout)
+	require.NotEmpty(t, secondRecordID, "stdout:\n%s", createResult.Stdout)
+
+	updateBody, err := json.Marshal(map[string]map[string]map[string]any{
+		"update_records": {
+			firstRecordID:  {"Status": []string{"Done"}},
+			secondRecordID: {"Score": 20},
+		},
+	})
+	require.NoError(t, err)
+
+	updateResult, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"base", "+record-batch-update",
+			"--base-token", baseToken,
+			"--table-id", tableID,
+			"--json", string(updateBody),
+		},
+		DefaultAs: "bot",
+	})
+	require.NoError(t, err)
+	updateResult.AssertExitCode(t, 0)
+	updateResult.AssertStdoutStatus(t, true)
+
+	assertRecordFields := func(recordID, expectedStatus string, expectedScore int64) {
+		t.Helper()
+		result, runErr := clie2e.RunCmd(ctx, clie2e.Request{
+			Args: []string{
+				"base", "+record-get",
+				"--base-token", baseToken,
+				"--table-id", tableID,
+				"--record-id", recordID,
+				"--field-id", "Status",
+				"--field-id", "Score",
+				"--format", "json",
+			},
+			DefaultAs: "bot",
+		})
+		require.NoError(t, runErr)
+		result.AssertExitCode(t, 0)
+		result.AssertStdoutStatus(t, true)
+		require.Equal(t, recordID, gjson.Get(result.Stdout, "data.record_id_list.0").String(), result.Stdout)
+		require.Equal(t, "Status", gjson.Get(result.Stdout, "data.fields.0").String(), result.Stdout)
+		require.Equal(t, "Score", gjson.Get(result.Stdout, "data.fields.1").String(), result.Stdout)
+		require.Equal(t, expectedStatus, gjson.Get(result.Stdout, "data.data.0.0.0").String(), result.Stdout)
+		require.Equal(t, expectedScore, gjson.Get(result.Stdout, "data.data.0.1").Int(), result.Stdout)
+	}
+
+	assertRecordFields(firstRecordID, "Done", 10)
+	assertRecordFields(secondRecordID, "Open", 20)
+
+	missingResult, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"base", "+record-batch-update",
+			"--base-token", baseToken,
+			"--table-id", tableID,
+			"--json", `{"update_records":{"recZZZZZZZZZZZ":{"Name":"missing-record"}}}`,
+		},
+		DefaultAs: "bot",
+	})
+	require.NoError(t, err)
+	missingResult.AssertExitCode(t, 0)
+	missingResult.AssertStdoutStatus(t, true)
+}

tests/cli_e2e/base/coverage.md

@@ -2,16 +2,18 @@
 
 ## Metrics
 - Denominator: 78 leaf commands
-- Covered: 19
-- Coverage: 24.4%
+- Covered: 22
+- Coverage: 28.2%
 
 ## Summary
 - TestBase_BasicWorkflow: proves `+base-create`, `+base-get`, `+table-create`, `+table-get`, and `+table-list`; key `t.Run(...)` proof points are `get base as bot`, `get table as bot`, and `list tables and find created table as bot`.
 - TestBaseBlockDryRun: proves the five `+base-block-*` shortcuts request shapes without touching live data.
 - TestBaseFieldCreateDryRunArrayCompat: proves `+field-create` dry-run request shape for the internal JSON-array compatibility path.
+- TestBaseRecordBatchUpdatePerRecordDryRun: proves `+record-batch-update` preserves the per-record `update_records` request shape.
+- TestBaseRecordBatchUpdatePerRecordWorkflow: creates two records, updates different field types in one request, asserts the minimal response contract, reads both records back, verifies a missing record ID is not prevalidated, and cleans up the temporary Base.
 - TestBase_RoleWorkflow: proves `+advperm-enable`, `+role-create`, `+role-list`, `+role-get`, and `+role-update`; key `t.Run(...)` proof points are `list as bot`, `get as bot`, and `update as bot`.
 - Cleanup note: `+table-delete` and `+role-delete` only run in cleanup and are intentionally left uncovered.
-- Blocked area: dashboard, field, form, record, view, and workflow operations still lack deterministic create/read/update workflows in this suite.
+- Blocked area: dashboard, field, most record operations, form, view, and workflow operations still lack deterministic create/read/update workflows in this suite.
 
 ## Command Table
 
@@ -54,10 +56,10 @@
 | ✕ | base +form-questions-list | shortcut |  | none | form workflows not covered |
 | ✕ | base +form-questions-update | shortcut |  | none | form workflows not covered |
 | ✕ | base +form-update | shortcut |  | none | form workflows not covered |
-| ✕ | base +record-batch-create | shortcut |  | none | record workflows not covered |
-| ✕ | base +record-batch-update | shortcut |  | none | record workflows not covered |
+| ✓ | base +record-batch-create | shortcut | base_record_batch_update_workflow_test.go::TestBaseRecordBatchUpdatePerRecordWorkflow | `--base-token`; `--table-id`; `--json.fields`; `--json.rows` | seeds heterogeneous live workflow records |
+| ✓ | base +record-batch-update | shortcut | base_record_batch_update_dryrun_test.go::TestBaseRecordBatchUpdatePerRecordDryRun; base_record_batch_update_workflow_test.go::TestBaseRecordBatchUpdatePerRecordWorkflow | `--base-token`; `--table-id`; `--json.update_records`; dry-run + live | heterogeneous select/number update with write-back verification |
 | ✕ | base +record-delete | shortcut |  | none | record workflows not covered |
-| ✕ | base +record-get | shortcut |  | none | record workflows not covered |
+| ✓ | base +record-get | shortcut | base_record_batch_update_workflow_test.go::TestBaseRecordBatchUpdatePerRecordWorkflow | `--record-id`; repeated `--field-id`; `--format json` | reads back select and number values after batch update |
 | ✕ | base +record-history-list | shortcut |  | none | record workflows not covered |
 | ✕ | base +record-list | shortcut |  | none | record workflows not covered |
 | ✕ | base +record-search | shortcut |  | none | record workflows not covered |

tests/cli_e2e/im/flag_workflow_test.go

@@ -240,6 +240,9 @@ func TestIM_FlagListPaginationAsUser(t *testing.T) {
 		require.NoError(t, err)
 		result.AssertExitCode(t, 0)
 		result.AssertStdoutStatus(t, true)
+		if gjson.Get(result.Stdout, "data.has_more").Bool() {
+			require.Contains(t, result.Stderr, "reached page limit (3)", "stderr:\n%s", result.Stderr)
+		}
 	})
 }
 
@@ -302,4 +305,20 @@ func TestIM_FlagDryRun(t *testing.T) {
 		require.Contains(t, result.Stdout, "/open-apis/im/v1/flags")
 		require.Contains(t, result.Stdout, "page_size")
 	})
+
+	t.Run("list flag dry-run accepts hard maximum page limit", func(t *testing.T) {
+		result, err := clie2e.RunCmd(ctx, clie2e.Request{
+			Args: []string{
+				"im", "+flag-list",
+				"--page-all",
+				"--page-limit", "1000",
+				"--dry-run",
+			},
+			DefaultAs: "user",
+		})
+		require.NoError(t, err)
+		result.AssertExitCode(t, 0)
+		result.AssertStdoutStatus(t, true)
+		require.Contains(t, result.Stdout, "/open-apis/im/v1/flags")
+	})
 }

tests/cli_e2e/slides/slides_history_dryrun_test.go

@@ -0,0 +1,98 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package slides
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	clie2e "github.com/larksuite/cli/tests/cli_e2e"
+	"github.com/stretchr/testify/require"
+	"github.com/tidwall/gjson"
+)
+
+func TestSlidesHistoryDryRunE2E(t *testing.T) {
+	setSlidesDryRunEnv(t)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	t.Cleanup(cancel)
+
+	tests := []struct {
+		name      string
+		args      []string
+		wantURL   string
+		wantVerb  string
+		assertion func(t *testing.T, stdout string)
+	}{
+		{
+			name: "list",
+			args: []string{
+				"slides", "+history-list",
+				"--presentation", "presHistoryDryRun",
+				"--page-size", "5",
+				"--page-token", "page_token_1",
+				"--dry-run",
+			},
+			wantURL:  "/open-apis/slides_ai/v1/xml_presentations/presHistoryDryRun/histories",
+			wantVerb: "GET",
+			assertion: func(t *testing.T, stdout string) {
+				require.Equal(t, int64(5), gjson.Get(stdout, "data.api.0.params.page_size").Int(), stdout)
+				require.Equal(t, "page_token_1", gjson.Get(stdout, "data.api.0.params.page_token").String(), stdout)
+			},
+		},
+		{
+			name: "revert",
+			args: []string{
+				"slides", "+history-revert",
+				"--presentation", "presHistoryDryRun",
+				"--history-version-id", "42",
+				"--dry-run",
+			},
+			wantURL:  "/open-apis/slides_ai/v1/xml_presentations/presHistoryDryRun/history/revert",
+			wantVerb: "POST",
+			assertion: func(t *testing.T, stdout string) {
+				require.Equal(t, "42", gjson.Get(stdout, "data.api.0.body.history_version_id").String(), stdout)
+				require.False(t, gjson.Get(stdout, "data.api.0.body.wait_timeout_ms").Exists(), stdout)
+			},
+		},
+		{
+			name: "status",
+			args: []string{
+				"slides", "+history-revert-status",
+				"--presentation", "presHistoryDryRun",
+				"--task-id", "task_1",
+				"--dry-run",
+			},
+			wantURL:  "/open-apis/slides_ai/v1/xml_presentations/presHistoryDryRun/history/revert_status",
+			wantVerb: "GET",
+			assertion: func(t *testing.T, stdout string) {
+				require.Equal(t, "task_1", gjson.Get(stdout, "data.api.0.params.task_id").String(), stdout)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := clie2e.RunCmd(ctx, clie2e.Request{
+				Args:      tt.args,
+				DefaultAs: "bot",
+			})
+			require.NoError(t, err)
+			result.AssertExitCode(t, 0)
+
+			require.Equal(t, tt.wantVerb, gjson.Get(result.Stdout, "data.api.0.method").String(), "stdout:\n%s", result.Stdout)
+			require.Equal(t, tt.wantURL, gjson.Get(result.Stdout, "data.api.0.url").String(), "stdout:\n%s", result.Stdout)
+			tt.assertion(t, result.Stdout)
+		})
+	}
+}
+
+func setSlidesDryRunEnv(t *testing.T) {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	t.Setenv("LARKSUITE_CLI_APP_ID", "slides_dryrun_test")
+	t.Setenv("LARKSUITE_CLI_APP_SECRET", "slides_dryrun_secret")
+	t.Setenv("LARKSUITE_CLI_BRAND", "feishu")
+}

tests/cli_e2e/slides/slides_history_workflow_test.go

@@ -0,0 +1,227 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package slides
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	clie2e "github.com/larksuite/cli/tests/cli_e2e"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/tidwall/gjson"
+)
+
+func TestSlides_HistoryWorkflow(t *testing.T) {
+	if os.Getenv("LARK_SLIDES_HISTORY_E2E") != "1" {
+		t.Skip("set LARK_SLIDES_HISTORY_E2E=1 to run slides history live workflow")
+	}
+	clie2e.SkipWithoutUserToken(t)
+
+	parentT := t
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+	t.Cleanup(cancel)
+
+	suffix := clie2e.GenerateSuffix()
+	title := "lark-cli-e2e-slides-history-" + suffix
+	originalMarker := "original history marker " + suffix
+	updatedMarker := "updated history marker " + suffix
+	const defaultAs = "user"
+
+	originalSlideXML := slidesHistoryWorkflowSlideXML(title, originalMarker)
+	updatedSlideXML := slidesHistoryWorkflowSlideXML(title, updatedMarker)
+	slidesJSON := mustMarshalSlidesJSON(t, []string{originalSlideXML})
+
+	var presentationID string
+	var slideID string
+	createResult, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"slides", "+create",
+			"--title", title,
+			"--slides", slidesJSON,
+		},
+		DefaultAs: defaultAs,
+	})
+	require.NoError(t, err)
+	createResult.AssertExitCode(t, 0)
+	createResult.AssertStdoutStatus(t, true)
+
+	presentationID = gjson.Get(createResult.Stdout, "data.xml_presentation_id").String()
+	require.NotEmpty(t, presentationID, "stdout:\n%s", createResult.Stdout)
+	slideID = gjson.Get(createResult.Stdout, "data.slide_ids.0").String()
+	require.NotEmpty(t, slideID, "stdout:\n%s", createResult.Stdout)
+	parentT.Cleanup(func() {
+		cleanupCtx, cleanupCancel := clie2e.CleanupContext()
+		defer cleanupCancel()
+
+		deleteResult, deleteErr := clie2e.RunCmd(cleanupCtx, clie2e.Request{
+			Args: []string{
+				"drive", "+delete",
+				"--file-token", presentationID,
+				"--type", "slides",
+				"--yes",
+			},
+			DefaultAs: defaultAs,
+		})
+		clie2e.ReportCleanupFailure(parentT, "delete presentation "+presentationID, deleteResult, deleteErr)
+	})
+
+	fetchOriginal, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args:      []string{"api", "get", "/open-apis/slides_ai/v1/xml_presentations/" + presentationID},
+		DefaultAs: defaultAs,
+		Params:    map[string]any{"revision_id": -1},
+	})
+	require.NoError(t, err)
+	fetchOriginal.AssertExitCode(t, 0)
+	fetchOriginal.AssertStdoutStatus(t, true)
+	originalContent := gjson.Get(fetchOriginal.Stdout, "data.xml_presentation.content").String()
+	assert.Contains(t, originalContent, originalMarker, "stdout:\n%s", fetchOriginal.Stdout)
+	originalRevision := gjson.Get(fetchOriginal.Stdout, "data.xml_presentation.revision_id").Int()
+	require.Greater(t, originalRevision, int64(0), "stdout:\n%s", fetchOriginal.Stdout)
+
+	pagesJSON := mustMarshalPagesJSON(t, []slidesHistoryWorkflowPage{
+		{SlideID: slideID, Content: updatedSlideXML},
+	})
+	updateResult, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"slides", "+replace-pages",
+			"--presentation", presentationID,
+			"--pages", pagesJSON,
+		},
+		DefaultAs: defaultAs,
+	})
+	require.NoError(t, err)
+	updateResult.AssertExitCode(t, 0)
+	updateResult.AssertStdoutStatus(t, true)
+
+	fetchUpdated, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args:      []string{"api", "get", "/open-apis/slides_ai/v1/xml_presentations/" + presentationID},
+		DefaultAs: defaultAs,
+		Params:    map[string]any{"revision_id": -1},
+	})
+	require.NoError(t, err)
+	fetchUpdated.AssertExitCode(t, 0)
+	fetchUpdated.AssertStdoutStatus(t, true)
+	updatedContent := gjson.Get(fetchUpdated.Stdout, "data.xml_presentation.content").String()
+	assert.Contains(t, updatedContent, updatedMarker, "stdout:\n%s", fetchUpdated.Stdout)
+	assert.NotContains(t, updatedContent, originalMarker, "stdout:\n%s", fetchUpdated.Stdout)
+	currentRevision := gjson.Get(fetchUpdated.Stdout, "data.xml_presentation.revision_id").Int()
+	require.Greater(t, currentRevision, originalRevision, "stdout:\n%s", fetchUpdated.Stdout)
+
+	var revertHistoryVersionID string
+	require.Eventually(t, func() bool {
+		listResult, listErr := clie2e.RunCmd(ctx, clie2e.Request{
+			Args: []string{
+				"slides", "+history-list",
+				"--presentation", presentationID,
+				"--page-size", "20",
+			},
+			DefaultAs: defaultAs,
+		})
+		if listErr != nil || listResult.ExitCode != 0 {
+			return false
+		}
+		for _, entry := range gjson.Get(listResult.Stdout, "data.entries").Array() {
+			revisionID := entry.Get("revision_id").Int()
+			historyVersionID := entry.Get("history_version_id").String()
+			if revisionID == originalRevision && historyVersionID != "" {
+				revertHistoryVersionID = historyVersionID
+				return true
+			}
+		}
+		return false
+	}, 45*time.Second, 3*time.Second, "history list did not expose original revision %d", originalRevision)
+	require.NotEmpty(t, revertHistoryVersionID)
+
+	revertResult, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args: []string{
+			"slides", "+history-revert",
+			"--presentation", presentationID,
+			"--history-version-id", revertHistoryVersionID,
+		},
+		DefaultAs: defaultAs,
+	})
+	require.NoError(t, err)
+	revertResult.AssertExitCode(t, 0)
+	revertResult.AssertStdoutStatus(t, true)
+
+	status := gjson.Get(revertResult.Stdout, "data.status").String()
+	taskID := gjson.Get(revertResult.Stdout, "data.task_id").String()
+	if status == "running" {
+		require.NotEmpty(t, taskID, "stdout:\n%s", revertResult.Stdout)
+		require.Eventually(t, func() bool {
+			statusResult, statusErr := clie2e.RunCmd(ctx, clie2e.Request{
+				Args: []string{
+					"slides", "+history-revert-status",
+					"--presentation", presentationID,
+					"--task-id", taskID,
+				},
+				DefaultAs: defaultAs,
+			})
+			if statusErr != nil || statusResult.ExitCode != 0 {
+				return false
+			}
+			status = gjson.Get(statusResult.Stdout, "data.status").String()
+			return status != "" && status != "running"
+		}, 60*time.Second, 5*time.Second, "history revert task did not finish")
+	}
+	require.Equal(t, "done", status, "revert stdout:\n%s", revertResult.Stdout)
+
+	fetchReverted, err := clie2e.RunCmd(ctx, clie2e.Request{
+		Args:      []string{"api", "get", "/open-apis/slides_ai/v1/xml_presentations/" + presentationID},
+		DefaultAs: defaultAs,
+		Params:    map[string]any{"revision_id": -1},
+	})
+	require.NoError(t, err)
+	fetchReverted.AssertExitCode(t, 0)
+	fetchReverted.AssertStdoutStatus(t, true)
+	revertedContent := gjson.Get(fetchReverted.Stdout, "data.xml_presentation.content").String()
+	assert.Contains(t, revertedContent, originalMarker, "stdout:\n%s", fetchReverted.Stdout)
+	assert.NotContains(t, revertedContent, updatedMarker, "stdout:\n%s", fetchReverted.Stdout)
+}
+
+type slidesHistoryWorkflowPage struct {
+	SlideID string `json:"slide_id"`
+	Content string `json:"content"`
+}
+
+func slidesHistoryWorkflowSlideXML(title, marker string) string {
+	return `<slide xmlns="http://www.larkoffice.com/sml/2.0"><data>` +
+		`<shape type="text" topLeftX="80" topLeftY="80" width="800" height="120"><content textType="title"><p>` + slidesHistoryWorkflowXMLEscape(title) + `</p></content></shape>` +
+		`<shape type="text" topLeftX="80" topLeftY="220" width="800" height="180"><content textType="body"><p>` + slidesHistoryWorkflowXMLEscape(marker) + `</p></content></shape>` +
+		`</data></slide>`
+}
+
+func slidesHistoryWorkflowXMLEscape(s string) string {
+	replacer := strings.NewReplacer(
+		"&", "&amp;",
+		"<", "&lt;",
+		">", "&gt;",
+		`"`, "&quot;",
+		"'", "&apos;",
+	)
+	return replacer.Replace(s)
+}
+
+func mustMarshalSlidesJSON(t *testing.T, slides []string) string {
+	t.Helper()
+	raw, err := json.Marshal(slides)
+	if err != nil {
+		t.Fatalf("marshal slides JSON: %v", err)
+	}
+	return string(raw)
+}
+
+func mustMarshalPagesJSON(t *testing.T, pages []slidesHistoryWorkflowPage) string {
+	t.Helper()
+	raw, err := json.Marshal(pages)
+	if err != nil {
+		t.Fatalf("marshal pages JSON: %v", err)
+	}
+	return strings.TrimSpace(string(raw))
+}