feat(sheets): add chart data update shortcut

internal/cmdutil/resolve.go

@@ -7,12 +7,9 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/validate"
 )
 
 // ResolveInput resolves special input conventions for a raw flag value:
@@ -80,25 +77,7 @@ func ResolveInput(raw string, stdin io.Reader, fileIO fileio.FileIO) (string, er
 
 // ReadInputFile reads path through fileIO. Open/read failures are wrapped with
 // path context; fileio.ErrPathValidation remains matchable with errors.Is.
-// An absolute path under the system temp dir is read directly instead:
-// agents stage generated payloads (@/tmp/ops.json) there as a matter of
-// course, and the strict relative-to-cwd policy — load-bearing for uploads
-// and drive sync — only cost @file callers a python/stdin detour.
 func ReadInputFile(fileIO fileio.FileIO, path string) ([]byte, error) {
-	resolved, terr := validate.SafeTempAbsInputPath(path)
-	if terr == nil {
-		data, err := os.ReadFile(resolved) //nolint:forbidigo // resolved is confined to the system temp dir by SafeTempAbsInputPath
-		if err != nil {
-			return nil, wrapInputFileError(path, err)
-		}
-		return data, nil
-	}
-	if filepath.IsAbs(path) {
-		// Absolute but outside the temp dir: surface the prescriptive error
-		// (relative path / temp-dir path / stdin) instead of the generic
-		// relative-only message the strict validator below would produce.
-		return nil, fmt.Errorf("invalid file path %q: %w", path, terr)
-	}
 	if fileIO == nil {
 		return nil, fmt.Errorf("file input is not available in this context")
 	}

internal/validate/path.go

@@ -17,12 +17,6 @@ func SafeInputPath(path string) (string, error) {
 	return localfileio.SafeInputPath(path)
 }
 
-// SafeTempAbsInputPath accepts an absolute read path only when it resolves
-// under the system temp dir. Delegates to localfileio.SafeTempAbsInputPath.
-func SafeTempAbsInputPath(path string) (string, error) {
-	return localfileio.SafeTempAbsInputPath(path)
-}
-
 // SafeEnvDirPath validates an environment-provided application directory path.
 // Delegates to localfileio.SafeEnvDirPath.
 func SafeEnvDirPath(path, envName string) (string, error) {

internal/vfs/localfileio/path.go

@@ -5,7 +5,6 @@ package localfileio
 
 import (
 	"fmt"
-	"os"
 	"path/filepath"
 	"strings"
 
@@ -19,35 +18,10 @@ func SafeOutputPath(path string) (string, error) {
 }
 
 // SafeInputPath validates an upload/read source path for --file flags.
-// Deliberately strict (relative-to-cwd only): several callers — drive sync,
-// upload flags, the CI quality gates — treat "absolute paths rejected" as a
-// load-bearing invariant. The one deliberate exception is the @file payload
-// expansion, which layers SafeTempAbsInputPath on top (see cmdutil).
 func SafeInputPath(path string) (string, error) {
 	return safePath(path, "--file")
 }
 
-// SafeTempAbsInputPath accepts an absolute READ path only when it resolves
-// under the canonical system temp dir. Agents stage generated payloads
-// (batch operations JSON, CSV) in /tmp as a matter of course, and rejecting
-// @/tmp/ops.json only pushed them through an extra python/stdin round trip
-// (recurring friction cluster in eval traces). Reads under os.TempDir()
-// carry no write risk and no project-escape risk. Errors for anything else
-// (relative paths included) — callers fall back to SafeInputPath semantics.
-func SafeTempAbsInputPath(path string) (string, error) {
-	if err := charcheck.RejectControlChars(path, "--file"); err != nil {
-		return "", err
-	}
-	if !isAbsolutePath(path) {
-		return "", fmt.Errorf("--file %q is not an absolute path", path)
-	}
-	resolved, ok := absPathUnderTempDir(path)
-	if !ok {
-		return "", fmt.Errorf("--file must be a relative path within the current directory, or an absolute path under the system temp dir (%s), got %q (hint: use ./filename or a %s path; flags that support stdin can read any file via '-' instead)", os.TempDir(), path, os.TempDir())
-	}
-	return resolved, nil
-}
-
 // SafeLocalFlagPath validates a flag value as a local file path.
 // Empty values and http/https URLs are returned unchanged without validation.
 func SafeLocalFlagPath(flagName, value string) (string, error) {
@@ -122,26 +96,6 @@ func safePath(raw, flagName string) (string, error) {
 	return resolved, nil
 }
 
-// absPathUnderTempDir accepts an absolute path only when, after cleaning and
-// resolving symlinks (through the nearest existing ancestor for
-// not-yet-created files), it still lives under the canonical system temp dir.
-// A symlink inside the temp dir pointing outside it resolves outside and is
-// rejected.
-func absPathUnderTempDir(raw string) (string, bool) {
-	canonicalTmp, err := filepath.EvalSymlinks(os.TempDir())
-	if err != nil {
-		return "", false
-	}
-	resolved, err := resolveNearestAncestor(filepath.Clean(raw))
-	if err != nil {
-		return "", false
-	}
-	if !isUnderDir(resolved, canonicalTmp) || resolved == canonicalTmp {
-		return "", false
-	}
-	return resolved, true
-}
-
 func resolveNearestAncestor(path string) (string, error) {
 	var tail []string
 	cur := path

internal/vfs/localfileio/path_test.go

@@ -175,7 +175,7 @@ func TestSafeOutputPath_DeepNonExistentPathStaysInCWD(t *testing.T) {
 	}
 }
 
-func TestSafeUploadPath_RejectsTempFileAbsolutePath(t *testing.T) {
+func TestSafeUploadPath_AllowsTempFileAbsolutePath(t *testing.T) {
 	// GIVEN: a real temp file (absolute path under os.TempDir())
 	f, err := os.CreateTemp("", "upload-test-*.bin")
 	if err != nil {
@@ -185,67 +185,15 @@ func TestSafeUploadPath_RejectsTempFileAbsolutePath(t *testing.T) {
 	f.Close()
 	t.Cleanup(func() { os.Remove(tmpPath) })
 
-	// WHEN: SafeInputPath validates the absolute temp path
+	// WHEN: SafeUploadPath validates the absolute temp path
 	_, err = SafeInputPath(tmpPath)
 
-	// THEN: the strict validator rejects it — uploads / drive sync rely on
-	// relative-only; temp-dir reads go through SafeTempAbsInputPath instead
+	// THEN: absolute paths are rejected even in temp dir
 	if err == nil {
 		t.Fatal("expected error for absolute temp path, got nil")
 	}
 }
 
-func TestSafeTempAbsInputPath(t *testing.T) {
-	t.Run("accepts a file under the temp dir", func(t *testing.T) {
-		f, err := os.CreateTemp("", "payload-*.json")
-		if err != nil {
-			t.Fatalf("CreateTemp: %v", err)
-		}
-		tmpPath := f.Name()
-		f.Close()
-		t.Cleanup(func() { os.Remove(tmpPath) })
-
-		resolved, err := SafeTempAbsInputPath(tmpPath)
-		if err != nil {
-			t.Fatalf("expected temp path accepted, got %v", err)
-		}
-		canonical, err := filepath.EvalSymlinks(tmpPath)
-		if err != nil {
-			t.Fatalf("EvalSymlinks: %v", err)
-		}
-		if resolved != canonical {
-			t.Fatalf("resolved = %q, want %q", resolved, canonical)
-		}
-	})
-
-	t.Run("rejects relative paths", func(t *testing.T) {
-		if _, err := SafeTempAbsInputPath("./ops.json"); err == nil {
-			t.Fatal("expected error for relative path, got nil")
-		}
-	})
-
-	t.Run("rejects absolute paths outside the temp dir", func(t *testing.T) {
-		if _, err := SafeTempAbsInputPath("/etc/passwd"); err == nil {
-			t.Fatal("expected error for non-temp absolute path, got nil")
-		}
-	})
-
-	t.Run("rejects a temp-dir symlink escaping outside", func(t *testing.T) {
-		dir, err := os.MkdirTemp("", "escape-*")
-		if err != nil {
-			t.Fatalf("MkdirTemp: %v", err)
-		}
-		t.Cleanup(func() { os.RemoveAll(dir) })
-		link := filepath.Join(dir, "escape.json")
-		if err := os.Symlink("/etc/passwd", link); err != nil {
-			t.Skipf("symlink not supported: %v", err)
-		}
-		if _, err := SafeTempAbsInputPath(link); err == nil {
-			t.Fatal("expected error for symlink escaping the temp dir, got nil")
-		}
-	})
-}
-
 func TestSafeUploadPath_RejectsNonTempAbsolutePath(t *testing.T) {
 	for _, tt := range []struct {
 		name  string

shortcuts/sheets/batch_key_vocab_test.go

@@ -1,284 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"strings"
-	"testing"
-)
-
-// subOp builds a raw +batch-update sub-op for translateBatchOp tests.
-func subOp(shortcut string, input map[string]interface{}) map[string]interface{} {
-	return map[string]interface{}{"shortcut": shortcut, "input": input}
-}
-
-// TestBatchOp_UnknownInputKeyRejected pins the key-vocabulary guard: an
-// off-vocabulary sub-op input key must error with a did-you-mean instead of
-// being silently ignored (silent ignore surfaced as misleading "missing
-// required flag" errors — the top batch error cluster in eval traces).
-func TestBatchOp_UnknownInputKeyRejected(t *testing.T) {
-	t.Parallel()
-
-	t.Run("invented key errors with did-you-mean", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+cells-set", map[string]interface{}{
-			"sheet_name": "S1",
-			"rangee":     "A1:B2",
-			"cells":      []interface{}{[]interface{}{map[string]interface{}{"value": "x"}}},
-		}), testToken, 0)
-		ve := requireValidation(t, err, `unknown input key "rangee"`)
-		if !strings.Contains(ve.Message, `did you mean "range"`) {
-			t.Fatalf("message %q missing did-you-mean", ve.Message)
-		}
-		if !strings.Contains(ve.Hint, "input keys:") {
-			t.Fatalf("hint %q missing key contract", ve.Hint)
-		}
-	})
-
-	t.Run("system flag is not sub-op vocabulary", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+cells-clear", map[string]interface{}{
-			"sheet_name": "S1",
-			"range":      "A1:B2",
-			"dry_run":    true,
-		}), testToken, 0)
-		requireValidation(t, err, `unknown input key "dry_run"`)
-	})
-
-	t.Run("reserved locator in hyphen form still rejected", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+cells-clear", map[string]interface{}{
-			"sheet_name":        "S1",
-			"range":             "A1:B2",
-			"spreadsheet-token": "shtXXX",
-		}), testToken, 0)
-		requireValidation(t, err, "do not pass input.spreadsheet-token")
-	})
-}
-
-// TestBatchOp_HabitualKeysRewritten pins the silent rewrites: camelCase onto
-// the declared flag, and the commandFlagAliases table (size → width/height on
-// the resize pair — the pre-2026-07 vocabulary and the styles-protocol
-// spelling, the single largest sub-op error cluster).
-func TestBatchOp_HabitualKeysRewritten(t *testing.T) {
-	t.Parallel()
-
-	t.Run("camelCase sheetName resolves", func(t *testing.T) {
-		t.Parallel()
-		translated, err := translateBatchOp(subOp("+cells-clear", map[string]interface{}{
-			"sheetName": "S1",
-			"range":     "A1:B2",
-		}), testToken, 0)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := translated["input"].(map[string]interface{})
-		if input["sheet_name"] != "S1" {
-			t.Fatalf("sheet_name = %v, want S1", input["sheet_name"])
-		}
-	})
-
-	t.Run("size aliases to width on +cols-resize", func(t *testing.T) {
-		t.Parallel()
-		translated, err := translateBatchOp(subOp("+cols-resize", map[string]interface{}{
-			"sheet_name": "S1",
-			"range":      "A:C",
-			"type":       "pixel",
-			"size":       float64(120),
-		}), testToken, 0)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := translated["input"].(map[string]interface{})
-		width, _ := input["resize_width"].(map[string]interface{})
-		if width["value"] != 120 {
-			t.Fatalf("resize_width = %v, want value 120", input["resize_width"])
-		}
-	})
-
-	t.Run("size aliases to height on +rows-resize", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+rows-resize", map[string]interface{}{
-			"sheet_name": "S1",
-			"range":      "1:3",
-			"type":       "pixel",
-			"size":       float64(36),
-		}), testToken, 0)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-	})
-
-	t.Run("single-entry ranges unwraps onto range", func(t *testing.T) {
-		t.Parallel()
-		translated, err := translateBatchOp(subOp("+cells-clear", map[string]interface{}{
-			"sheet_name": "S1",
-			"ranges":     []interface{}{"A1:B2"},
-		}), testToken, 0)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := translated["input"].(map[string]interface{})
-		if input["range"] != "A1:B2" {
-			t.Fatalf("range = %v, want A1:B2", input["range"])
-		}
-	})
-
-	t.Run("multi-entry ranges prescribes a split", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+cells-clear", map[string]interface{}{
-			"sheet_name": "S1",
-			"ranges":     []interface{}{"A1:B2", "C1:D2"},
-		}), testToken, 0)
-		requireValidation(t, err, "split them into 2 sub-ops")
-	})
-}
-
-// TestBatchOperations_AggregatesValidationErrors pins the one-pass contract:
-// several invalid ops come back in a single error (each with its own
-// operations[i] context) instead of the first only — eval traces show
-// fix-one-resend loops of up to 7 round trips under first-error-only.
-func TestBatchOperations_AggregatesValidationErrors(t *testing.T) {
-	t.Parallel()
-
-	t.Run("two bad ops both reported", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOperations([]interface{}{
-			subOp("+cells-clear", map[string]interface{}{"range": "A1:B2"}),                     // missing sheet selector
-			subOp("+cells-set", map[string]interface{}{"sheet_name": "S1", "range": "A1"}),      // missing cells
-			subOp("+cells-clear", map[string]interface{}{"sheet_name": "S1", "range": "A1:B2"}), // valid
-		}, testToken)
-		ve := requireValidation(t, err, "2 of 3 operations failed validation")
-		for _, want := range []string{"operations[0] (+cells-clear)", "operations[1] (+cells-set)", "--cells is required"} {
-			if !strings.Contains(ve.Message, want) {
-				t.Fatalf("message %q missing %q", ve.Message, want)
-			}
-		}
-	})
-
-	t.Run("single bad op keeps the standalone-shaped error", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOperations([]interface{}{
-			subOp("+cells-set", map[string]interface{}{"sheet_name": "S1", "range": "A1"}),
-		}, testToken)
-		ve := requireValidation(t, err, "--cells is required")
-		if strings.Contains(ve.Message, "failed validation") {
-			t.Fatalf("single-error message must not use the aggregate wrapper: %q", ve.Message)
-		}
-	})
-}
-
-// TestCellsSetInput_MatrixPrecheck pins the local cells-vs-range guard that
-// front-runs the server's mid-batch "does not match range" failures.
-func TestCellsSetInput_MatrixPrecheck(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name         string
-		input        map[string]interface{}
-		wantContains string // "" = expect success
-	}{
-		{
-			"empty cells prescribes +cells-clear",
-			map[string]interface{}{"sheet_name": "S1", "range": "A1:B2", "cells": []interface{}{}},
-			"+cells-clear",
-		},
-		{
-			"row count mismatch",
-			map[string]interface{}{"sheet_name": "S1", "range": "A1:B3",
-				"cells": []interface{}{
-					[]interface{}{map[string]interface{}{"value": "a"}, map[string]interface{}{"value": "b"}},
-				}},
-			"has 1 rows but --range \"A1:B3\" spans 3 rows",
-		},
-		{
-			"column count mismatch",
-			map[string]interface{}{"sheet_name": "S1", "range": "A1:B1",
-				"cells": []interface{}{
-					[]interface{}{map[string]interface{}{"value": "a"}},
-				}},
-			"has 1 columns but --range \"A1:B1\" spans 2 columns",
-		},
-		{
-			"matching matrix passes",
-			map[string]interface{}{"sheet_name": "S1", "range": "A1:B2",
-				"cells": []interface{}{
-					[]interface{}{map[string]interface{}{"value": "a"}, map[string]interface{}{"value": "b"}},
-					[]interface{}{map[string]interface{}{"value": "c"}, map[string]interface{}{"value": "d"}},
-				}},
-			"",
-		},
-		{
-			"bare single-cell range enforces the 1x1 match (07-21: server rejects anchors too)",
-			map[string]interface{}{"sheet_name": "S1", "range": "A1",
-				"cells": []interface{}{
-					[]interface{}{map[string]interface{}{"value": "a"}, map[string]interface{}{"value": "b"}},
-				}},
-			"has 2 columns but --range \"A1\" spans 1 columns",
-		},
-		{
-			"single-cell range with a single cell passes",
-			map[string]interface{}{"sheet_name": "S1", "range": "B3",
-				"cells": []interface{}{
-					[]interface{}{map[string]interface{}{"value": "a"}},
-				}},
-			"",
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			_, err := translateBatchOp(subOp("+cells-set", tc.input), testToken, 0)
-			if tc.wantContains == "" {
-				if err != nil {
-					t.Fatalf("unexpected error: %v", err)
-				}
-				return
-			}
-			requireValidation(t, err, tc.wantContains)
-		})
-	}
-}
-
-// TestFlattenToolErrorMsg_PartialFailureRecovery pins the no-rollback recovery
-// prescription appended to server-side "N succeeded, M failed" errors.
-func TestFlattenToolErrorMsg_PartialFailureRecovery(t *testing.T) {
-	t.Parallel()
-
-	wrap := func(inner string) string {
-		return `{"error":` + jsonQuote(inner) + `}`
-	}
-
-	t.Run("single failure prescribes resend-from-index", func(t *testing.T) {
-		t.Parallel()
-		msg := flattenToolErrorMsg(wrap(`{"message":"batch_update: 4 succeeded, 1 failed","failures":[{"index":4,"tool_name":"set_cell_range","error":"cells is required"}]}`))
-		for _, want := range []string{"operations[4] (set_cell_range)", "no rollback", "resend only operations[4:]"} {
-			if !strings.Contains(msg, want) {
-				t.Fatalf("msg %q missing %q", msg, want)
-			}
-		}
-	})
-
-	t.Run("multiple failures prescribe failed-only resend", func(t *testing.T) {
-		t.Parallel()
-		msg := flattenToolErrorMsg(wrap(`{"message":"batch_update: 3 succeeded, 2 failed","failures":[{"index":1,"tool_name":"set_cell_range","error":"e1"},{"index":3,"tool_name":"resize_range","error":"e2"}]}`))
-		if !strings.Contains(msg, "resend only the failed operations") {
-			t.Fatalf("msg %q missing failed-only prescription", msg)
-		}
-	})
-
-	t.Run("zero succeeded gets no note", func(t *testing.T) {
-		t.Parallel()
-		msg := flattenToolErrorMsg(wrap(`{"message":"batch_update: 0 succeeded, 1 failed","failures":[{"index":0,"tool_name":"set_cell_range","error":"e"}]}`))
-		if strings.Contains(msg, "no rollback") {
-			t.Fatalf("msg %q must not carry the note when nothing was applied", msg)
-		}
-	})
-}
-
-// jsonQuote wraps s as a JSON string literal (escaping quotes), mirroring how
-// the server double-encodes the inner error payload.
-func jsonQuote(s string) string {
-	return `"` + strings.ReplaceAll(strings.ReplaceAll(s, `\`, `\\`), `"`, `\"`) + `"`
-}

shortcuts/sheets/batch_op_contract_test.go

@@ -223,6 +223,24 @@ func TestBatchOp_BodyMatchesStandalone(t *testing.T) {
 			args:     []string{"--sheet-id", "sh1", "--chart-id", "c1"},
 			subInput: `{"sheet-id":"sh1","chart-id":"c1"}`,
 		},
+		{
+			shortcut: "+chart-create-basic",
+			sc:       ChartCreateBasic,
+			args:     []string{"--sheet-id", "sh1", "--chart-type", "column", "--data-range", "A1:C10", "--title", "Sales", "--data-labels", "value", "--anchor-cell", "F2"},
+			subInput: `{"sheet-id":"sh1","chart-type":"column","data-range":"A1:C10","title":"Sales","data-labels":"value","anchor-cell":"F2"}`,
+		},
+		{
+			shortcut: "+chart-config-update",
+			sc:       ChartConfigUpdate,
+			args:     []string{"--sheet-id", "sh1", "--chart-id", "c1", "--title", "Updated", "--data-labels", "category", "--data-label-position", "top"},
+			subInput: `{"sheet-id":"sh1","chart-id":"c1","title":"Updated","data-labels":"category","data-label-position":"top"}`,
+		},
+		{
+			shortcut: "+chart-data-update",
+			sc:       ChartDataUpdate,
+			args:     []string{"--sheet-id", "sh1", "--chart-id", "c1", "--data-range", "'Sheet1'!A1:M6", "--data-direction", "column", "--dim1-index", "1", "--dim2-indexes", "4,8"},
+			subInput: `{"sheet-id":"sh1","chart-id":"c1","data-range":"'Sheet1'!A1:M6","data-direction":"column","dim1-index":1,"dim2-indexes":"4,8"}`,
+		},
 		{
 			shortcut: "+pivot-create",
 			sc:       PivotCreate,
@@ -424,6 +442,22 @@ func TestBatchOp_ErrorEquivalence(t *testing.T) {
 			subInput:     `{}`,
 			wantContains: "specify at least one of --sheet-id or --sheet-name",
 		},
+		{
+			name:         "+chart-data-update invalid dim1 index",
+			shortcut:     ChartDataUpdate,
+			args:         []string{"--sheet-id", "sh1", "--chart-id", "c1", "--data-range", "A1:C4", "--dim1-index", "0"},
+			subShortcut:  "+chart-data-update",
+			subInput:     `{"sheet-id":"sh1","chart-id":"c1","data-range":"A1:C4","dim1-index":0}`,
+			wantContains: "--dim1-index must be a positive 1-based index",
+		},
+		{
+			name:         "+chart-data-update dim1 and dim2 conflict",
+			shortcut:     ChartDataUpdate,
+			args:         []string{"--sheet-id", "sh1", "--chart-id", "c1", "--data-range", "A1:C4", "--dim1-index", "2", "--dim2-indexes", "2,3"},
+			subShortcut:  "+chart-data-update",
+			subInput:     `{"sheet-id":"sh1","chart-id":"c1","data-range":"A1:C4","dim1-index":2,"dim2-indexes":"2,3"}`,
+			wantContains: "--dim2-indexes must not contain the dim1 index 2",
+		},
 		{
 			name:         "+float-image-create both image-token and image-uri",
 			shortcut:     FloatImageCreate,
@@ -662,6 +696,18 @@ func TestBatchOp_RejectsBadSubOpInput(t *testing.T) {
 			`{"sheet-id":"sh1","properties":{"title":"T"}}`,
 			"--chart-id is required",
 		},
+		{
+			"+chart-data-update missing --chart-id",
+			"+chart-data-update",
+			`{"sheet-id":"sh1","data-range":"A1:C4"}`,
+			"--chart-id is required",
+		},
+		{
+			"+chart-data-update missing --data-range",
+			"+chart-data-update",
+			`{"sheet-id":"sh1","chart-id":"c1"}`,
+			"--data-range is required",
+		},
 		{
 			"+filter-create missing --range",
 			"+filter-create",
@@ -763,7 +809,7 @@ func TestBatchOp_SchemaValidatesSubOps(t *testing.T) {
 		{
 			"+pivot-create summarize_by out of enum",
 			"+pivot-create",
-			`{"target_sheet_id":"sh1","source":"Sheet1!A1:D100","properties":{"values":[{"field":"A","summarize_by":"BOGUS"}]}}`,
+			`{"sheet-id":"sh1","source":"Sheet1!A1:D100","properties":{"values":[{"field":"A","summarize_by":"BOGUS"}]}}`,
 			"summarize_by",
 		},
 		// +chart-create properties.position.row has minimum:0 — P0

shortcuts/sheets/batch_op_dispatch.go

@@ -4,11 +4,8 @@
 package sheets
 
 import (
-	"fmt"
 	"sort"
 	"strings"
-
-	"github.com/larksuite/cli/internal/suggest"
 )
 
 // ─── +batch-update sub-op dispatch ─────────────────────────────────────
@@ -87,14 +84,7 @@ func objDeleteTranslate(spec objectCRUDSpec) batchTranslateFn {
 // flag error is identical too (locked by TestBatchOp_ErrorEquivalence).
 var batchOpDispatch = map[string]batchOpMapping{
 	// ─── 单元格内容 ──────────────────────────────────────────────────
-	"+cells-set": {"set_cell_range", func(fv flagView, token, sid, sname string) (map[string]interface{}, error) {
-		// The --writes plural form expands into its own atomic batch and
-		// cannot nest; sub-ops carry one range+cells each.
-		if fv.Changed("writes") {
-			return nil, sheetsValidationForFlag("writes", `"writes" is not supported inside +batch-update (it expands into its own atomic batch); call +cells-set --writes standalone, or give each sub-op a single range + cells`)
-		}
-		return cellsSetInput(fv, token, sid, sname)
-	}},
+	"+cells-set":       {"set_cell_range", cellsSetInput},
 	"+cells-set-style": {"set_cell_range", cellsSetStyleInput},
 	"+cells-clear":     {"clear_cell_range", cellsClearInput},
 	"+cells-replace":   {"replace_data", replaceInput},
@@ -112,11 +102,6 @@ var batchOpDispatch = map[string]batchOpMapping{
 	// ─── 行列结构 (modify_sheet_structure, operation 区分) ──────────
 	"+dim-insert": {"modify_sheet_structure", dimInsertInput},
 	"+dim-delete": {"modify_sheet_structure", func(fv flagView, token, sid, sname string) (map[string]interface{}, error) {
-		// The --ranges plural form expands into its own atomic batch and
-		// cannot nest; sub-ops carry one range each.
-		if fv.Changed("ranges") {
-			return nil, sheetsValidationForFlag("ranges", `"ranges" is not supported inside +batch-update (it expands into its own atomic batch); call +dim-delete --ranges standalone, or give each sub-op a single "range"`)
-		}
 		return dimRangeOpInput(fv, token, sid, sname, "delete")
 	}},
 	"+dim-hide": {"modify_sheet_structure", func(fv flagView, token, sid, sname string) (map[string]interface{}, error) {
@@ -183,9 +168,12 @@ var batchOpDispatch = map[string]batchOpMapping{
 	}},
 
 	// ─── 对象族 CRUD (manage_*_object, operation 区分) ─────────────
-	"+chart-create": {"manage_chart_object", objCreateTranslate(chartSpec)},
-	"+chart-update": {"manage_chart_object", objUpdateTranslate(chartSpec)},
-	"+chart-delete": {"manage_chart_object", objDeleteTranslate(chartSpec)},
+	"+chart-create":        {"manage_chart_object", objCreateTranslate(chartSpec)},
+	"+chart-update":        {"manage_chart_object", objUpdateTranslate(chartSpec)},
+	"+chart-delete":        {"manage_chart_object", objDeleteTranslate(chartSpec)},
+	"+chart-create-basic":  {"manage_chart_object", chartCreateBasicInput},
+	"+chart-config-update": {"manage_chart_object", chartConfigUpdateInput},
+	"+chart-data-update":   {"manage_chart_object", chartDataUpdateInput},
 
 	"+pivot-create": {"manage_pivot_table_object", objCreateTranslate(pivotSpec)},
 	"+pivot-update": {"manage_pivot_table_object", objUpdateTranslate(pivotSpec)},
@@ -316,133 +304,6 @@ func sheetMoveBatchInput(fv flagView, token, sheetID, sheetName string) (map[str
 // +batch-update 顶层 --url/--token 统一提供（excel_id / spreadsheet_token / url）。
 var reservedSubOpKeys = []string{"excel_id", "spreadsheet_token", "url"}
 
-// wrappedSubOpInputKeys are nested MCP-body container keys that must never
-// appear at a sub-op input's top level — their presence means the caller
-// pasted a shortcut's structured *output* (e.g. a {"cell_styles":{…}} block)
-// where the flattened flag keys belong. None of the batch sub-op translators
-// read input under these names, so rejecting them is safe.
-var wrappedSubOpInputKeys = []string{"cell_styles", "cell_merges", "styles"}
-
-// subOpKeyVocabulary returns the set of hyphen-canonical flag names a sub-op
-// input may carry for `sc`: every non-system flag in flag-defs except the
-// spreadsheet locators (reserved for the batch top level). Nil when the
-// shortcut has no flag-defs entry (vocabulary checks are then skipped).
-func subOpKeyVocabulary(sc string) map[string]bool {
-	defs, _ := loadFlagDefs()
-	spec, ok := defs[sc]
-	if !ok {
-		return nil
-	}
-	vocab := make(map[string]bool, len(spec.Flags))
-	for _, df := range spec.Flags {
-		if df.Kind == "system" || df.Name == "url" || df.Name == "spreadsheet-token" {
-			continue
-		}
-		vocab[df.Name] = true
-	}
-	return vocab
-}
-
-// camelToKebab converts a lowerCamelCase key to its kebab form
-// (sheetName → sheet-name). Returns "" when the key carries no uppercase
-// letter (nothing to convert).
-func camelToKebab(key string) string {
-	if strings.ToLower(key) == key {
-		return ""
-	}
-	var b strings.Builder
-	for i, r := range key {
-		if r >= 'A' && r <= 'Z' {
-			if i > 0 {
-				b.WriteByte('-')
-			}
-			b.WriteRune(r + ('a' - 'A'))
-			continue
-		}
-		b.WriteRune(r)
-	}
-	return b.String()
-}
-
-// normalizeSubOpInputKeys validates every sub-op input key against the
-// shortcut's flag vocabulary, rewriting habitual spellings in place and
-// rejecting anything that matches nothing. Eval traces show unknown keys were
-// previously ignored silently, which turned "wrong key" (size for width,
-// camelCase sheetName, an invented styles object) into misleading
-// "missing required flag" errors downstream — the single largest batch error
-// cluster. Rewrites applied, in order:
-//
-//   - underscore ↔ hyphen forms of a declared flag (already tolerated by
-//     mapFlagView — accepted here as-is)
-//   - lowerCamelCase → the declared flag (sheetName → sheet_name)
-//   - the command's intuitive-alias table (size → width/height on the resize
-//     pair) — the same commandFlagAliases the cobra path applies
-//   - "ranges" with a single-entry array unwraps onto "range"; a multi-entry
-//     array gets a split-into-sub-ops prescription instead
-//
-// Anything else errors with a did-you-mean. Returns a bare error; the caller
-// wraps it with the operations[i] (<shortcut>) context and key contract.
-func normalizeSubOpInputKeys(sc string, input map[string]interface{}) error {
-	vocab := subOpKeyVocabulary(sc)
-	if vocab == nil {
-		return nil
-	}
-	keys := make([]string, 0, len(input))
-	for k := range input {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	aliases := commandFlagAliases[sc]
-	for _, k := range keys {
-		hv := strings.ReplaceAll(k, "_", "-")
-		if vocab[hv] {
-			continue
-		}
-		if kebab := camelToKebab(k); kebab != "" && vocab[kebab] {
-			input[strings.ReplaceAll(kebab, "-", "_")] = input[k]
-			delete(input, k)
-			continue
-		}
-		if target, ok := aliases[strings.ToLower(hv)]; ok && vocab[target] {
-			if _, taken := input[target]; !taken {
-				if _, taken := input[strings.ReplaceAll(target, "-", "_")]; !taken {
-					input[target] = input[k]
-					delete(input, k)
-					continue
-				}
-			}
-		}
-		if strings.ToLower(hv) == "ranges" && vocab["range"] && !vocab["ranges"] {
-			if arr, isArr := input[k].([]interface{}); isArr {
-				if len(arr) == 1 {
-					if s, isStr := arr[0].(string); isStr {
-						input["range"] = s
-						delete(input, k)
-						continue
-					}
-				}
-				return fmt.Errorf("%s takes a single \"range\" per sub-op, got %d entries in %q — split them into %d sub-ops (one per range)", sc, len(arr), k, len(arr)) //nolint:forbidigo // intermediate error; the batch dispatcher wraps it into a typed operations validation error
-			}
-			if s, isStr := input[k].(string); isStr {
-				input["range"] = s
-				delete(input, k)
-				continue
-			}
-		}
-		msg := fmt.Sprintf("unknown input key %q", k)
-		display := make([]string, 0, len(vocab))
-		for name := range vocab {
-			display = append(display, strings.ReplaceAll(name, "-", "_"))
-		}
-		sort.Strings(display)
-		if match := suggest.Closest(strings.ToLower(hv), display, 1); len(match) > 0 {
-			msg += fmt.Sprintf(" — did you mean %q?", match[0])
-		}
-		return fmt.Errorf("%s", msg) //nolint:forbidigo // intermediate error; the batch dispatcher wraps it into a typed operations validation error
-	}
-	return nil
-}
-
 // translateBatchOp 把一个 CLI 视角的 {shortcut, input} 翻成底层 MCP
 // batch_update 的 {tool_name, input}。`index` 用于错误信息定位。input 用
 // shortcut 的 CLI flag 名（连字符/下划线均可），经该 shortcut 的 standalone
@@ -454,7 +315,6 @@ func normalizeSubOpInputKeys(sc string, input map[string]interface{}) error {
 //   - input 不是 object
 //   - input 里手填了 operation（由 shortcut 名隐含，禁手填以防 mismatch）
 //   - input 里手填了 excel_id / spreadsheet_token / url
-//   - input 顶层出现 cell_styles / cell_merges / styles（误贴 MCP body 包裹结构）
 //   - 子操作的 translator 报错（如缺必填字段）
 func translateBatchOp(raw interface{}, token string, index int) (map[string]interface{}, error) {
 	op, ok := raw.(map[string]interface{})
@@ -478,7 +338,7 @@ func translateBatchOp(raw interface{}, token string, index int) (map[string]inte
 		return nil, sheetsValidationForFlag(
 			"operations",
 			"operations[%d]: shortcut %q not allowed in +batch-update "+
-				"(read ops / fan-out wrappers like +batch-update / +styles-put / +cells-batch-set-style / +cells-batch-clear / +dropdown-{update,delete} are excluded)",
+				"(read ops / fan-out wrappers like +batch-update / +cells-batch-set-style / +cells-batch-clear / +dropdown-{update,delete} are excluded)",
 			index, sc,
 		).WithHint("allowed shortcuts: %s", strings.Join(allowedBatchShortcuts(), ", "))
 	}
@@ -501,30 +361,11 @@ func translateBatchOp(raw interface{}, token string, index int) (map[string]inte
 		)
 	}
 	// 禁在 sub-op 重复填 spreadsheet 定位 —— 由 +batch-update 顶层 --url/--token 统一提供。
-	// 连字符 / 下划线两种写法都算命中（spreadsheet-token 与 spreadsheet_token 同罪）。
-	for userKey := range input {
-		normalized := strings.ReplaceAll(userKey, "-", "_")
-		for _, k := range reservedSubOpKeys {
-			if normalized == k {
-				return nil, sheetsValidationForFlag(
-					"operations",
-					"operations[%d] (%s): do not pass input.%s — it is already set from +batch-update top-level --url / --token",
-					index, sc, userKey,
-				)
-			}
-		}
-	}
-	// Reject a "wrapped structure" sub-op input: agents copy a shortcut's nested
-	// output container (e.g. +workbook-create --styles' {"cell_styles":{…}}) into
-	// the op input, but the op input is the shortcut's own flags flattened into
-	// JSON keys, not that wrapper. Left unflagged this surfaces far downstream as
-	// an unrelated "at least one style flag is required" (helpers.go), which never
-	// points at the real mistake.
-	for _, k := range wrappedSubOpInputKeys {
+	for _, k := range reservedSubOpKeys {
 		if _, has := input[k]; has {
 			return nil, sheetsValidationForFlag(
 				"operations",
-				`operations[%d] (%s): op input is the shortcut's flags flattened as JSON keys (e.g. "background_color": "#EBF1F8"); do not wrap in %s`,
+				"operations[%d] (%s): do not pass input.%s — it is already set from +batch-update top-level --url / --token",
 				index, sc, k,
 			)
 		}
@@ -535,16 +376,6 @@ func translateBatchOp(raw interface{}, token string, index int) (map[string]inte
 			return nil, sheetsValidationForFlag("operations", "operations[%d] (%s): unknown top-level key %q (expected only 'shortcut' and 'input')", index, sc, k)
 		}
 	}
-	// Reject / rewrite off-vocabulary input keys BEFORE any value reads: an
-	// unknown key silently ignored surfaces later as a misleading
-	// "missing required flag" error (the top batch error cluster in evals).
-	if err := normalizeSubOpInputKeys(sc, input); err != nil {
-		verr := sheetsValidationForFlag("operations", "operations[%d] (%s): %v", index, sc, err)
-		if contract := subOpInputContract(sc); contract != "" {
-			verr = verr.WithHint("%s input keys: %s", sc, contract)
-		}
-		return nil, verr
-	}
 	fv := newMapFlagViewForCommand(sc, input)
 	// operations is skipped by parse-time schema validation, so type-check the
 	// sub-op's scalar fields here before the translator reads them via
@@ -582,14 +413,7 @@ func translateBatchOp(raw interface{}, token string, index int) (map[string]inte
 // matrix, on the operations axis.
 const maxBatchOperations = 100
 
-// batchOpErrorDisplayLimit bounds how many per-op validation failures ride
-// on one aggregated --operations error, mirroring the schema validator's
-// display cap.
-const batchOpErrorDisplayLimit = 5
-
-// translateBatchOperations 翻译整个 ops 数组。逐 op 校验并**收集全部失败**
-// 一次性返回（不再 fail-fast）——agent 一轮就能修完所有坏 op，而不是
-// 修一个、重试、再撞下一个。cell 安全上限仍是全局判定，命中即返回。
+// translateBatchOperations 翻译整个 ops 数组；fail-fast，遇错立即返回。
 func translateBatchOperations(rawOps []interface{}, token string) ([]interface{}, error) {
 	if len(rawOps) == 0 {
 		return nil, sheetsValidationForFlag("operations", "--operations must be a non-empty JSON array")
@@ -601,15 +425,10 @@ func translateBatchOperations(rawOps []interface{}, token string) ([]interface{}
 	}
 	out := make([]interface{}, 0, len(rawOps))
 	var totalCells int64
-	var opErrs []error
 	for i, raw := range rawOps {
 		translated, err := translateBatchOp(raw, token, i)
 		if err != nil {
-			opErrs = append(opErrs, err)
-			continue
-		}
-		if len(opErrs) > 0 {
-			continue // already failing — keep scanning for more bad ops, skip cell math.
+			return nil, err
 		}
 		totalCells += translatedCellCount(translated)
 		if totalCells > maxStampMatrixCells {
@@ -619,27 +438,7 @@ func translateBatchOperations(rawOps []interface{}, token string) ([]interface{}
 		}
 		out = append(out, translated)
 	}
-	switch len(opErrs) {
-	case 0:
-		return out, nil
-	case 1:
-		return nil, opErrs[0] // single failure keeps the historical error byte-for-byte.
-	}
-	shown := opErrs
-	truncated := false
-	if len(shown) > batchOpErrorDisplayLimit {
-		shown = shown[:batchOpErrorDisplayLimit]
-		truncated = true
-	}
-	parts := make([]string, 0, len(shown))
-	for i, e := range shown {
-		parts = append(parts, fmt.Sprintf("%d) %s", i+1, e.Error()))
-	}
-	msg := fmt.Sprintf("%d of %d operations failed validation: %s", len(opErrs), len(rawOps), strings.Join(parts, "; "))
-	if truncated {
-		msg += fmt.Sprintf("; (%d more not shown — fix these first)", len(opErrs)-batchOpErrorDisplayLimit)
-	}
-	return nil, sheetsValidationForFlag("operations", "%s", msg).WithCause(opErrs[0])
+	return out, nil
 }
 
 func translatedCellCount(op map[string]interface{}) int64 {

shortcuts/sheets/cells_set_writes_test.go

@@ -1,113 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"strings"
-	"testing"
-)
-
-// TestCellsSetWrites pins the --writes plural form: scattered (cross-sheet)
-// regions fan into ONE atomic batch_update, each item self-carrying its
-// sheet selector (no top-level fallback — same convention as +batch-update
-// sub-ops and +styles-put items), with per-item errors aggregated.
-func TestCellsSetWrites(t *testing.T) {
-	t.Parallel()
-
-	writes := func(items string, extra ...string) (string, string, error) {
-		args := append([]string{
-			"--url", testURL, "--dry-run", "--writes", items,
-		}, extra...)
-		return runShortcutCapturingErr(t, CellsSet, args)
-	}
-
-	t.Run("cross-sheet items expand into one batch", func(t *testing.T) {
-		t.Parallel()
-		stdout, _, err := writes(`[
-			{"sheet_name":"明细","range":"D5","cells":[[{"formula":"=IFERROR(C5/B5,0)"}]]},
-			{"sheet_name":"汇总","range":"B3","cells":[[{"formula":"=SUM(C:C)"}]]}
-		]`)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		for _, want := range []string{"batch_update", "明细", "汇总", "IFERROR"} {
-			if !strings.Contains(stdout, want) {
-				t.Fatalf("dry-run body missing %q: %s", want, stdout[:min(len(stdout), 400)])
-			}
-		}
-	})
-
-	t.Run("item without sheet selector errors", func(t *testing.T) {
-		t.Parallel()
-		_, _, err := writes(`[{"range":"A1","cells":[[{"value":"x"}]]}]`)
-		requireValidation(t, err, "sheet-id or --sheet-name")
-	})
-
-	t.Run("top-level sheet selector rejected with prescription", func(t *testing.T) {
-		t.Parallel()
-		_, _, err := writes(`[{"sheet_name":"S1","range":"A1","cells":[[{"value":"x"}]]}]`,
-			"--sheet-name", "S1")
-		requireValidation(t, err, "put sheet_name (or sheet_id) inside each writes item")
-	})
-
-	t.Run("writes and range are mutually exclusive", func(t *testing.T) {
-		t.Parallel()
-		_, _, err := writes(`[{"sheet_name":"S1","range":"A1","cells":[[{"value":"x"}]]}]`,
-			"--range", "A1")
-		requireValidation(t, err, "mutually exclusive")
-	})
-
-	t.Run("per-item errors aggregate", func(t *testing.T) {
-		t.Parallel()
-		// Both items pass the --writes schema (range+cells present) but fail
-		// deeper: item 0 a matrix mismatch, item 1 a missing sheet selector.
-		_, _, err := writes(`[
-			{"sheet_name":"S1","range":"A1:B2","cells":[[{"value":"x"}]]},
-			{"range":"C1","cells":[[{"value":"y"}]]}
-		]`)
-		ve := requireValidation(t, err, "--writes has 2 issues")
-		for _, want := range []string{"--writes[0]", "--writes[1]", "sheet-name"} {
-			if !strings.Contains(ve.Message, want) {
-				t.Fatalf("message %q missing %q", ve.Message, want)
-			}
-		}
-	})
-
-	t.Run("item keys go through the vocabulary layer", func(t *testing.T) {
-		t.Parallel()
-		stdout, _, err := writes(`[{"sheetName":"S1","range":"A1","cells":[[{"value":"x"}]]}]`)
-		if err != nil {
-			t.Fatalf("camelCase sheetName must normalize: %v", err)
-		}
-		if !strings.Contains(stdout, "S1") {
-			t.Fatalf("normalized item missing sheet: %s", stdout[:min(len(stdout), 300)])
-		}
-	})
-
-	t.Run("cannot nest inside batch-update", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+cells-set", map[string]interface{}{
-			"writes": []interface{}{map[string]interface{}{
-				"sheet_name": "S1", "range": "A1", "cells": []interface{}{[]interface{}{map[string]interface{}{"value": "x"}}},
-			}},
-		}), testToken, 0)
-		requireValidation(t, err, "not supported inside +batch-update")
-	})
-
-	t.Run("styles flag gets the layering prescription", func(t *testing.T) {
-		t.Parallel()
-		// Ergonomics (FlagErrorFunc hints) mount via the registry, not the
-		// bare shortcut var — mirror the real CLI wiring.
-		sc := shortcutFromRegistry(t, "+cells-set")
-		_, _, err := runShortcutCapturingErr(t, sc, []string{
-			"--url", testURL, "--dry-run",
-			"--writes", `[{"sheet_name":"S1","range":"A1","cells":[[{"value":"x"}]]}]`,
-			"--styles", `{"styles":[]}`,
-		})
-		ve := requireValidation(t, err, "unknown flag")
-		if !strings.Contains(ve.Hint, "+styles-put") || !strings.Contains(ve.Hint, "cell_styles") {
-			t.Fatalf("want the styles-put layering hint, got hint=%q", ve.Hint)
-		}
-	})
-}

shortcuts/sheets/data/flag-defs.json

@@ -821,10 +821,12 @@
         "kind": "own",
         "type": "string",
         "required": "optional",
-        "desc": "Style inheritance for the new row/column: `before` (from the preceding row/column) / `after` (from the following row/column). Omit the flag to inherit the following row/column (same as `after`) — the backend cannot leave a new row/column unstyled; for a truly blank row/column, clear formats afterwards with +cells-clear --scope formats. Insertion always lands before `--position`; this only selects which side's style is copied.",
+        "desc": "Style inheritance for the new row/column: `before` (from preceding) / `after` (from following) / `none` (default)",
+        "default": "none",
         "enum": [
           "before",
-          "after"
+          "after",
+          "none"
         ]
       },
       {
@@ -885,19 +887,8 @@
         "name": "range",
         "kind": "own",
         "type": "string",
-        "required": "xor",
-        "desc": "Row/column closed range to delete; rows use 1-based numbers like `3:7` or `5` (single row), columns use letters like `C:F` or `C`. XOR with `--ranges`"
-      },
-      {
-        "name": "ranges",
-        "kind": "own",
-        "type": "string",
-        "required": "xor",
-        "desc": "Multiple row/column ranges to delete as a JSON array (up to 100 items, e.g. `[\"5:5\",\"8:8\",\"11:13\"]` or `[\"C:C\",\"F:G\"]`); rows and columns cannot be mixed, ranges must not overlap; XOR with `--range`. CLI sorts positions in DESCENDING order into one atomic batch delete — ascending deletion would shift later indexes as earlier rows/columns disappear; the CLI handles the ordering",
-        "input": [
-          "file",
-          "stdin"
-        ]
+        "required": "required",
+        "desc": "Row/column closed range to delete; rows use 1-based numbers like `3:7` or `5` (single row), columns use letters like `C:F` or `C`"
       },
       {
         "name": "yes",
@@ -1316,14 +1307,7 @@
         "kind": "own",
         "type": "bool",
         "required": "optional",
-        "desc": "Skip hidden or collapsed rows and columns. Default `false`; when `--skip-filter` is omitted, filtered-out rows follow this value for backward compatibility"
-      },
-      {
-        "name": "skip-filter",
-        "kind": "own",
-        "type": "bool",
-        "required": "optional",
-        "desc": "Skip filtered-out rows. When omitted, inherits `--skip-hidden`; explicitly set to `false` to keep filtered-out rows while skipping hidden rows and columns"
+        "desc": "Skip hidden rows and columns; default `false`"
       },
       {
         "name": "dry-run",
@@ -1416,8 +1400,8 @@
         "name": "range",
         "kind": "own",
         "type": "string",
-        "required": "optional",
-        "desc": "A1 range, e.g. `A1:F30` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet). Optional: when omitted the whole sheet is read (clipped to the actual grid bounds; actual_range in the response names what was read); pair with --max-chars / --output-path on large sheets"
+        "required": "required",
+        "desc": "A1 range, e.g. `A1:F30` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet)"
       },
       {
         "name": "max-chars",
@@ -1737,44 +1721,33 @@
         "kind": "public",
         "type": "string",
         "required": "xor",
-        "desc": "Sheet reference_id (XOR with `--sheet-name`); not accepted with `--writes` (each writes item carries its own sheet selector)"
+        "desc": "Sheet reference_id (XOR with `--sheet-name`)"
       },
       {
         "name": "sheet-name",
         "kind": "public",
         "type": "string",
         "required": "xor",
-        "desc": "Sheet name (XOR with `--sheet-id`); not accepted with `--writes` (each writes item carries its own sheet selector)"
+        "desc": "Sheet name (XOR with `--sheet-id`)"
       },
       {
         "name": "range",
         "kind": "own",
         "type": "string",
-        "required": "xor",
-        "desc": "Write range (A1 notation). XOR with `--writes` (single region: --range+--cells; multiple regions: --writes)"
+        "required": "required",
+        "desc": "Write range (A1 notation)"
       },
       {
         "name": "cells",
         "kind": "own",
         "type": "string",
-        "required": "xor",
+        "required": "required",
         "desc": "JSON 2D array `[[{cell},...],...]`, dimensions must match `--range`; each cell may carry `value` / `formula` / `cell_styles` / `note` / `rich_text` (incl. `type=\"embed-image\"` in-cell image); run `--print-schema` for full fields",
         "input": [
           "file",
           "stdin"
         ]
       },
-      {
-        "name": "writes",
-        "kind": "own",
-        "type": "string",
-        "required": "xor",
-        "desc": "Multi-region write as a JSON array (up to 100 items), each `{sheet_name|sheet_id, range, cells}` — the sheet selector LIVES IN EACH ITEM (same convention as +batch-update sub-ops and +styles-put items; the top-level --sheet-name is rejected). cells has the same shape as `--cells` (2D array; per-cell cell_styles/border_styles allowed). The whole array goes out as ONE atomic batched request, cross-sheet supported; typical use: fixing formulas scattered across ranges/sheets — do not assemble a +batch-update operations array for this. XOR with `--range`+`--cells`; range-level uniform styling stays with +styles-put afterwards",
-        "input": [
-          "file",
-          "stdin"
-        ]
-      },
       {
         "name": "allow-overwrite",
         "kind": "own",
@@ -2844,43 +2817,6 @@
       }
     ]
   },
-  "+styles-put": {
-    "risk": "write",
-    "flags": [
-      {
-        "name": "url",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet locator (target sheets are named inside --styles items)"
-      },
-      {
-        "name": "spreadsheet-token",
-        "kind": "public",
-        "type": "string",
-        "required": "xor",
-        "desc": "Spreadsheet token (XOR with `--url`)"
-      },
-      {
-        "name": "styles",
-        "kind": "own",
-        "type": "string",
-        "required": "required",
-        "desc": "Visual spec JSON applied to an EXISTING spreadsheet: top-level `{styles:[...]}`, one item per target sheet (`name` is the real sheet name), each giving at least one of `cell_styles` / `cell_merges` / `row_sizes` / `col_sizes` / `freeze`. The vocabulary is identical to `--styles` on `+workbook-create` / `+table-put` (cell_styles = A1 range + flat style fields, borders via the `border` shorthand {style,weight,color} applied to all four sides — border_styles only for per-side differences; row/col sizes = row/column range + size in px — type only for standard/auto; merges = cell range; freeze = `{rows:N, cols:N}`). The whole spec expands into one atomic batched request; ranges may target any region of the sheet",
-        "input": [
-          "file",
-          "stdin"
-        ]
-      },
-      {
-        "name": "dry-run",
-        "kind": "system",
-        "type": "bool",
-        "required": "optional",
-        "desc": "Print the batched request template for each expanded operation; no network side effects"
-      }
-    ]
-  },
   "+batch-update": {
     "risk": "high-risk-write",
     "flags": [
@@ -2903,7 +2839,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "JSON array: [{\"shortcut\":\"+xxx-yyy\",\"input\":{...}}, ...]. shortcut uses CLI names; input is that shortcut's flag set — it includes the per-operation sheet locator (sheet_id or sheet_name) but not the spreadsheet token/url (pass that once at the top level via --url/--spreadsheet-token; +batch-update has no top-level --sheet-id). input keys are the shortcut's flags flattened into JSON (e.g. \"range\":\"A11:B12\"), not another nested layer. For basic flags use lark-cli sheets <shortcut> --help; for composite JSON flags use --print-schema --flag-name <flag>. Do not pass an explicit operation field. Fail-fast by default: the first failure aborts the remaining operations and already-applied sub-operations are NOT rolled back (on \"N succeeded, M failed\" resend only the failed tail, not the whole batch); pass --continue-on-error to keep going past failures; no nesting; executed serially.",
+        "desc": "JSON array: [{\"shortcut\":\"+xxx-yyy\",\"input\":{...}}, ...]. shortcut uses CLI names; input is that shortcut's flag set — it includes the per-operation sheet locator (sheet_id or sheet_name) but not the spreadsheet token/url (pass that once at the top level via --url/--spreadsheet-token; +batch-update has no top-level --sheet-id). input keys are the shortcut's flags flattened into JSON (e.g. \"range\":\"A11:B12\"), not another nested layer. For basic flags use lark-cli sheets <shortcut> --help; for composite JSON flags use --print-schema --flag-name <flag>. Do not pass an explicit operation field. Strict transaction by default, pass --continue-on-error for soft batch; no nesting; executed serially.",
         "input": [
           "file",
           "stdin"
@@ -3313,6 +3249,559 @@
       }
     ]
   },
+  "+chart-create-basic": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token (XOR with `--url`)"
+      },
+      {
+        "name": "sheet-id",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet reference_id (XOR with `--sheet-name`)"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet name (XOR with `--sheet-id`)"
+      },
+      {
+        "name": "chart-type",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "Chart type",
+        "enum": [
+          "column",
+          "bar",
+          "line",
+          "area",
+          "pie",
+          "scatter",
+          "combo",
+          "radar"
+        ]
+      },
+      {
+        "name": "data-range",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "One contiguous A1 range including headers, or comma-separated same-sheet ranges; aligned non-overlapping ranges stay independent, otherwise they merge to the smallest enclosing rectangle"
+      },
+      {
+        "name": "data-direction",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Data series direction; column uses the first column as categories, row uses the first row",
+        "default": "column",
+        "enum": [
+          "column",
+          "row"
+        ]
+      },
+      {
+        "name": "title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Chart title"
+      },
+      {
+        "name": "subtitle",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Chart subtitle"
+      },
+      {
+        "name": "legend-position",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Legend position; hidden removes the legend",
+        "enum": [
+          "top",
+          "bottom",
+          "left",
+          "right",
+          "hidden"
+        ]
+      },
+      {
+        "name": "x-axis-title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "X-axis title"
+      },
+      {
+        "name": "y-axis-title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Left Y-axis title"
+      },
+      {
+        "name": "secondary-y-axis-title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Right Y-axis title"
+      },
+      {
+        "name": "x-axis-label-angle",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "X-axis label angle",
+        "enum": [
+          "-90",
+          "-45",
+          "0",
+          "45",
+          "90"
+        ]
+      },
+      {
+        "name": "y-axis-label-angle",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "Left Y-axis label angle",
+        "enum": [
+          "-90",
+          "-45",
+          "0",
+          "45",
+          "90"
+        ]
+      },
+      {
+        "name": "data-labels",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Data label content; none removes labels; category_percentage is normalized to value_percentage",
+        "enum": [
+          "none",
+          "value",
+          "percentage",
+          "value_percentage",
+          "category_percentage",
+          "category",
+          "series"
+        ]
+      },
+      {
+        "name": "data-label-position",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Data label position",
+        "enum": [
+          "auto",
+          "top",
+          "bottom",
+          "left",
+          "right",
+          "center",
+          "inside",
+          "outside"
+        ]
+      },
+      {
+        "name": "stack",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Stacking mode",
+        "enum": [
+          "none",
+          "normal",
+          "percent"
+        ]
+      },
+      {
+        "name": "stacked",
+        "kind": "own",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Compatibility alias for --stack normal",
+        "hidden": true
+      },
+      {
+        "name": "smooth",
+        "kind": "own",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Use smooth curves; accepts both --smooth=false and --smooth false"
+      },
+      {
+        "name": "color-palette",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Preset chart-level color palette; mutually exclusive with --colors",
+        "enum": [
+          "brandColorSeries@v2",
+          "rainbowColorSeries@v2",
+          "complementaryColorSeries@v2",
+          "converseColorSeries@v2",
+          "primaryColorSeries@v2",
+          "singleColorSeries-B-@v2",
+          "singleColorSeries-W-@v2",
+          "singleColorSeries-G-@v2",
+          "singleColorSeries-Y-@v2",
+          "singleColorSeries-O-@v2",
+          "singleColorSeries-R-@v2",
+          "singleColorSeries-D-@v2"
+        ]
+      },
+      {
+        "name": "colors",
+        "kind": "own",
+        "type": "string_slice",
+        "required": "optional",
+        "desc": "Custom chart-level series colors as a comma-separated list of at least two hex colors; mutually exclusive with --color-palette"
+      },
+      {
+        "name": "anchor-cell",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Optional chart anchor cell such as F2; defaults to the right of the data range"
+      },
+      {
+        "name": "width",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "Optional chart width; must be paired with --height"
+      },
+      {
+        "name": "height",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "Optional chart height; must be paired with --width"
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Print the request template; no side effects"
+      }
+    ]
+  },
+  "+chart-config-update": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token (XOR with `--url`)"
+      },
+      {
+        "name": "sheet-id",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet reference_id (XOR with `--sheet-name`)"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet name (XOR with `--sheet-id`)"
+      },
+      {
+        "name": "chart-id",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "Target chart reference_id"
+      },
+      {
+        "name": "title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Chart title"
+      },
+      {
+        "name": "subtitle",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Chart subtitle"
+      },
+      {
+        "name": "legend-position",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Legend position; hidden removes the legend",
+        "enum": [
+          "top",
+          "bottom",
+          "left",
+          "right",
+          "hidden"
+        ]
+      },
+      {
+        "name": "x-axis-title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "X-axis title"
+      },
+      {
+        "name": "y-axis-title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Left Y-axis title"
+      },
+      {
+        "name": "secondary-y-axis-title",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Right Y-axis title"
+      },
+      {
+        "name": "x-axis-label-angle",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "X-axis label angle",
+        "enum": [
+          "-90",
+          "-45",
+          "0",
+          "45",
+          "90"
+        ]
+      },
+      {
+        "name": "y-axis-label-angle",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "Left Y-axis label angle",
+        "enum": [
+          "-90",
+          "-45",
+          "0",
+          "45",
+          "90"
+        ]
+      },
+      {
+        "name": "data-labels",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Data label content; none removes labels; category_percentage is normalized to value_percentage",
+        "enum": [
+          "none",
+          "value",
+          "percentage",
+          "value_percentage",
+          "category_percentage",
+          "category",
+          "series"
+        ]
+      },
+      {
+        "name": "data-label-position",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Data label position",
+        "enum": [
+          "auto",
+          "top",
+          "bottom",
+          "left",
+          "right",
+          "center",
+          "inside",
+          "outside"
+        ]
+      },
+      {
+        "name": "stack",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Stacking mode",
+        "enum": [
+          "none",
+          "normal",
+          "percent"
+        ]
+      },
+      {
+        "name": "stacked",
+        "kind": "own",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Compatibility alias for --stack normal",
+        "hidden": true
+      },
+      {
+        "name": "smooth",
+        "kind": "own",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Use smooth curves; accepts both --smooth=false and --smooth false"
+      },
+      {
+        "name": "color-palette",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Preset chart-level color palette; mutually exclusive with --colors",
+        "enum": [
+          "brandColorSeries@v2",
+          "rainbowColorSeries@v2",
+          "complementaryColorSeries@v2",
+          "converseColorSeries@v2",
+          "primaryColorSeries@v2",
+          "singleColorSeries-B-@v2",
+          "singleColorSeries-W-@v2",
+          "singleColorSeries-G-@v2",
+          "singleColorSeries-Y-@v2",
+          "singleColorSeries-O-@v2",
+          "singleColorSeries-R-@v2",
+          "singleColorSeries-D-@v2"
+        ]
+      },
+      {
+        "name": "colors",
+        "kind": "own",
+        "type": "string_slice",
+        "required": "optional",
+        "desc": "Custom chart-level series colors as a comma-separated list of at least two hex colors; mutually exclusive with --color-palette"
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Print the request template; no side effects"
+      }
+    ]
+  },
+  "+chart-data-update": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token (XOR with `--url`)"
+      },
+      {
+        "name": "sheet-id",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet reference_id (XOR with `--sheet-name`)"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet name (XOR with `--sheet-id`)"
+      },
+      {
+        "name": "chart-id",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "Target chart reference_id"
+      },
+      {
+        "name": "data-range",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "New data range including headers; accepts comma-separated same-sheet ranges and normalizes misaligned or overlapping ranges"
+      },
+      {
+        "name": "data-direction",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Data series direction; defaults to the existing chart direction when omitted",
+        "enum": [
+          "column",
+          "row"
+        ]
+      },
+      {
+        "name": "dim1-index",
+        "kind": "own",
+        "type": "int",
+        "required": "optional",
+        "desc": "1-based category/X-axis dimension index within the data range; defaults to the first dimension"
+      },
+      {
+        "name": "dim2-indexes",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Comma-separated 1-based value/Y-axis series indexes within the data range; defaults to all dimensions except dim1"
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Print the request template; no side effects"
+      }
+    ]
+  },
   "+chart-create": {
     "risk": "write",
     "flags": [
@@ -3407,7 +3896,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "Full or sufficiently complete chart config JSON (read back with `+chart-list` first, then patch)",
+        "desc": "Chart config patch JSON; send changed fields only by default; omitted fields are preserved, objects merge recursively, and arrays replace as a whole",
         "input": [
           "file",
           "stdin"

shortcuts/sheets/flag_defs_gen.go

@@ -16,7 +16,7 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator (independent from per-operation sheet locator)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator (independent from per-operation sheet locator)"},
-			{Name: "operations", Kind: "own", Type: "string", Required: "required", Desc: "JSON array: [{\"shortcut\":\"+xxx-yyy\",\"input\":{...}}, ...]. shortcut uses CLI names; input is that shortcut's flag set — it includes the per-operation sheet locator (sheet_id or sheet_name) but not the spreadsheet token/url (pass that once at the top level via --url/--spreadsheet-token; +batch-update has no top-level --sheet-id). input keys are the shortcut's flags flattened into JSON (e.g. \"range\":\"A11:B12\"), not another nested layer. For basic flags use lark-cli sheets <shortcut> --help; for composite JSON flags use --print-schema --flag-name <flag>. Do not pass an explicit operation field. Fail-fast by default: the first failure aborts the remaining operations and already-applied sub-operations are NOT rolled back (on \"N succeeded, M failed\" resend only the failed tail, not the whole batch); pass --continue-on-error to keep going past failures; no nesting; executed serially.", Input: []string{"file", "stdin"}},
+			{Name: "operations", Kind: "own", Type: "string", Required: "required", Desc: "JSON array: [{\"shortcut\":\"+xxx-yyy\",\"input\":{...}}, ...]. shortcut uses CLI names; input is that shortcut's flag set — it includes the per-operation sheet locator (sheet_id or sheet_name) but not the spreadsheet token/url (pass that once at the top level via --url/--spreadsheet-token; +batch-update has no top-level --sheet-id). input keys are the shortcut's flags flattened into JSON (e.g. \"range\":\"A11:B12\"), not another nested layer. For basic flags use lark-cli sheets <shortcut> --help; for composite JSON flags use --print-schema --flag-name <flag>. Do not pass an explicit operation field. Strict transaction by default, pass --continue-on-error for soft batch; no nesting; executed serially.", Input: []string{"file", "stdin"}},
 			{Name: "continue-on-error", Kind: "own", Type: "bool", Required: "optional", Desc: "Continue with remaining operations when a sub-operation fails; default false (abort on first failure)"},
 			{Name: "yes", Kind: "system", Type: "bool", Required: "required", Desc: "Confirm high-risk write (exit code 10 without this flag)"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request template for each sub-operation; no network side effects"},
@@ -78,8 +78,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "include", Kind: "own", Type: "string_slice", Required: "optional", Desc: "Comma-separated info categories to include. `truncation` additionally estimates whether each cell's content is clipped (by row height / col width / font size / wrap) and returns `isRowTruncated` / `isColTruncated` (extra compute; enable only for layout checks or before adjusting row heights / column widths)", Enum: []string{"value", "formula", "style", "comment", "data_validation", "truncation"}},
 			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Max output chars per call; default 500000 (safety cap). For a full untruncated read, use --output-path to dump to a file (auto-unlimited); only lower it (e.g. 25000) when you want results inline without a file, paging via has_more.", Default: "500000"},
 			{Name: "output-path", Kind: "own", Type: "string", Required: "optional", Desc: "Write the full read result to a local path (e.g. `./out.json`); the file holds the data payload as JSON while stdout returns only a small confirmation (output_path, byte count). **When set, the char cap defaults to unlimited** (overriding the --max-chars default), so a large sheet can be dumped in full for later analysis without stdout being truncated by max_chars. Omit it to print to stdout as usual."},
-			{Name: "skip-hidden", Kind: "own", Type: "bool", Required: "optional", Desc: "Skip hidden or collapsed rows and columns. Default `false`; when `--skip-filter` is omitted, filtered-out rows follow this value for backward compatibility"},
-			{Name: "skip-filter", Kind: "own", Type: "bool", Required: "optional", Desc: "Skip filtered-out rows. When omitted, inherits `--skip-hidden`; explicitly set to `false` to keep filtered-out rows while skipping hidden rows and columns"},
+			{Name: "skip-hidden", Kind: "own", Type: "bool", Required: "optional", Desc: "Skip hidden rows and columns; default `false`"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -135,11 +134,10 @@ var flagDefs = map[string]commandDef{
 		Flags: []flagDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`); not accepted with `--writes` (each writes item carries its own sheet selector)"},
-			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`); not accepted with `--writes` (each writes item carries its own sheet selector)"},
-			{Name: "range", Kind: "own", Type: "string", Required: "xor", Desc: "Write range (A1 notation). XOR with `--writes` (single region: --range+--cells; multiple regions: --writes)"},
-			{Name: "cells", Kind: "own", Type: "string", Required: "xor", Desc: "JSON 2D array `[[{cell},...],...]`, dimensions must match `--range`; each cell may carry `value` / `formula` / `cell_styles` / `note` / `rich_text` (incl. `type=\"embed-image\"` in-cell image); run `--print-schema` for full fields", Input: []string{"file", "stdin"}},
-			{Name: "writes", Kind: "own", Type: "string", Required: "xor", Desc: "Multi-region write as a JSON array (up to 100 items), each `{sheet_name|sheet_id, range, cells}` — the sheet selector LIVES IN EACH ITEM (same convention as +batch-update sub-ops and +styles-put items; the top-level --sheet-name is rejected). cells has the same shape as `--cells` (2D array; per-cell cell_styles/border_styles allowed). The whole array goes out as ONE atomic batched request, cross-sheet supported; typical use: fixing formulas scattered across ranges/sheets — do not assemble a +batch-update operations array for this. XOR with `--range`+`--cells`; range-level uniform styling stays with +styles-put afterwards", Input: []string{"file", "stdin"}},
+			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
+			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
+			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "Write range (A1 notation)"},
+			{Name: "cells", Kind: "own", Type: "string", Required: "required", Desc: "JSON 2D array `[[{cell},...],...]`, dimensions must match `--range`; each cell may carry `value` / `formula` / `cell_styles` / `note` / `rich_text` (incl. `type=\"embed-image\"` in-cell image); run `--print-schema` for full fields", Input: []string{"file", "stdin"}},
 			{Name: "allow-overwrite", Kind: "own", Type: "bool", Required: "optional", Desc: "Allow overwriting non-empty cells (default true); set false to error if any target cell is non-empty", Default: "true"},
 			{Name: "max-cells", Kind: "own", Type: "int", Required: "optional", Desc: "Safety cap; default 50000", Default: "50000", Hidden: true},
 			{Name: "copy-to-range", Kind: "own", Type: "string", Required: "optional", Desc: "Copy-to range (A1 notation): replicate what --cells wrote into --range (values/formulas/styles, per the fields actually passed) to this range; formula refs auto-shift (C2=B2 -> C3=B3). Write a one-row/one-block template then fill a whole column/area. Supports full rows '3:6', full columns 'C:E', to-col-end 'D3:D', to-row-end 'D3:3', and comma-separated multiple targets like 'C1:D2,E5:F6'."},
@@ -202,6 +200,32 @@ var flagDefs = map[string]commandDef{
 			{Name: "end-revision", Kind: "own", Type: "int", Required: "optional", Desc: "End version (CS revision); defaults to the latest revision. Gap (end-start+1) must be <= 20", Default: "-1"},
 		},
 	},
+	"+chart-config-update": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
+			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
+			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
+			{Name: "chart-id", Kind: "own", Type: "string", Required: "required", Desc: "Target chart reference_id"},
+			{Name: "title", Kind: "own", Type: "string", Required: "optional", Desc: "Chart title"},
+			{Name: "subtitle", Kind: "own", Type: "string", Required: "optional", Desc: "Chart subtitle"},
+			{Name: "legend-position", Kind: "own", Type: "string", Required: "optional", Desc: "Legend position; hidden removes the legend", Enum: []string{"top", "bottom", "left", "right", "hidden"}},
+			{Name: "x-axis-title", Kind: "own", Type: "string", Required: "optional", Desc: "X-axis title"},
+			{Name: "y-axis-title", Kind: "own", Type: "string", Required: "optional", Desc: "Left Y-axis title"},
+			{Name: "secondary-y-axis-title", Kind: "own", Type: "string", Required: "optional", Desc: "Right Y-axis title"},
+			{Name: "x-axis-label-angle", Kind: "own", Type: "int", Required: "optional", Desc: "X-axis label angle", Enum: []string{"-90", "-45", "0", "45", "90"}},
+			{Name: "y-axis-label-angle", Kind: "own", Type: "int", Required: "optional", Desc: "Left Y-axis label angle", Enum: []string{"-90", "-45", "0", "45", "90"}},
+			{Name: "data-labels", Kind: "own", Type: "string", Required: "optional", Desc: "Data label content; none removes labels; category_percentage is normalized to value_percentage", Enum: []string{"none", "value", "percentage", "value_percentage", "category_percentage", "category", "series"}},
+			{Name: "data-label-position", Kind: "own", Type: "string", Required: "optional", Desc: "Data label position", Enum: []string{"auto", "top", "bottom", "left", "right", "center", "inside", "outside"}},
+			{Name: "stack", Kind: "own", Type: "string", Required: "optional", Desc: "Stacking mode", Enum: []string{"none", "normal", "percent"}},
+			{Name: "stacked", Kind: "own", Type: "bool", Required: "optional", Desc: "Compatibility alias for --stack normal", Hidden: true},
+			{Name: "smooth", Kind: "own", Type: "bool", Required: "optional", Desc: "Use smooth curves; accepts both --smooth=false and --smooth false"},
+			{Name: "color-palette", Kind: "own", Type: "string", Required: "optional", Desc: "Preset chart-level color palette; mutually exclusive with --colors", Enum: []string{"brandColorSeries@v2", "rainbowColorSeries@v2", "complementaryColorSeries@v2", "converseColorSeries@v2", "primaryColorSeries@v2", "singleColorSeries-B-@v2", "singleColorSeries-W-@v2", "singleColorSeries-G-@v2", "singleColorSeries-Y-@v2", "singleColorSeries-O-@v2", "singleColorSeries-R-@v2", "singleColorSeries-D-@v2"}},
+			{Name: "colors", Kind: "own", Type: "string_slice", Required: "optional", Desc: "Custom chart-level series colors as a comma-separated list of at least two hex colors; mutually exclusive with --color-palette"},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request template; no side effects"},
+		},
+	},
 	"+chart-create": {
 		Risk: "write",
 		Flags: []flagDef{
@@ -213,6 +237,52 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request template; no side effects"},
 		},
 	},
+	"+chart-create-basic": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
+			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
+			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
+			{Name: "chart-type", Kind: "own", Type: "string", Required: "required", Desc: "Chart type", Enum: []string{"column", "bar", "line", "area", "pie", "scatter", "combo", "radar"}},
+			{Name: "data-range", Kind: "own", Type: "string", Required: "required", Desc: "One contiguous A1 range including headers, or comma-separated same-sheet ranges; aligned non-overlapping ranges stay independent, otherwise they merge to the smallest enclosing rectangle"},
+			{Name: "data-direction", Kind: "own", Type: "string", Required: "optional", Desc: "Data series direction; column uses the first column as categories, row uses the first row", Default: "column", Enum: []string{"column", "row"}},
+			{Name: "title", Kind: "own", Type: "string", Required: "optional", Desc: "Chart title"},
+			{Name: "subtitle", Kind: "own", Type: "string", Required: "optional", Desc: "Chart subtitle"},
+			{Name: "legend-position", Kind: "own", Type: "string", Required: "optional", Desc: "Legend position; hidden removes the legend", Enum: []string{"top", "bottom", "left", "right", "hidden"}},
+			{Name: "x-axis-title", Kind: "own", Type: "string", Required: "optional", Desc: "X-axis title"},
+			{Name: "y-axis-title", Kind: "own", Type: "string", Required: "optional", Desc: "Left Y-axis title"},
+			{Name: "secondary-y-axis-title", Kind: "own", Type: "string", Required: "optional", Desc: "Right Y-axis title"},
+			{Name: "x-axis-label-angle", Kind: "own", Type: "int", Required: "optional", Desc: "X-axis label angle", Enum: []string{"-90", "-45", "0", "45", "90"}},
+			{Name: "y-axis-label-angle", Kind: "own", Type: "int", Required: "optional", Desc: "Left Y-axis label angle", Enum: []string{"-90", "-45", "0", "45", "90"}},
+			{Name: "data-labels", Kind: "own", Type: "string", Required: "optional", Desc: "Data label content; none removes labels; category_percentage is normalized to value_percentage", Enum: []string{"none", "value", "percentage", "value_percentage", "category_percentage", "category", "series"}},
+			{Name: "data-label-position", Kind: "own", Type: "string", Required: "optional", Desc: "Data label position", Enum: []string{"auto", "top", "bottom", "left", "right", "center", "inside", "outside"}},
+			{Name: "stack", Kind: "own", Type: "string", Required: "optional", Desc: "Stacking mode", Enum: []string{"none", "normal", "percent"}},
+			{Name: "stacked", Kind: "own", Type: "bool", Required: "optional", Desc: "Compatibility alias for --stack normal", Hidden: true},
+			{Name: "smooth", Kind: "own", Type: "bool", Required: "optional", Desc: "Use smooth curves; accepts both --smooth=false and --smooth false"},
+			{Name: "color-palette", Kind: "own", Type: "string", Required: "optional", Desc: "Preset chart-level color palette; mutually exclusive with --colors", Enum: []string{"brandColorSeries@v2", "rainbowColorSeries@v2", "complementaryColorSeries@v2", "converseColorSeries@v2", "primaryColorSeries@v2", "singleColorSeries-B-@v2", "singleColorSeries-W-@v2", "singleColorSeries-G-@v2", "singleColorSeries-Y-@v2", "singleColorSeries-O-@v2", "singleColorSeries-R-@v2", "singleColorSeries-D-@v2"}},
+			{Name: "colors", Kind: "own", Type: "string_slice", Required: "optional", Desc: "Custom chart-level series colors as a comma-separated list of at least two hex colors; mutually exclusive with --color-palette"},
+			{Name: "anchor-cell", Kind: "own", Type: "string", Required: "optional", Desc: "Optional chart anchor cell such as F2; defaults to the right of the data range"},
+			{Name: "width", Kind: "own", Type: "int", Required: "optional", Desc: "Optional chart width; must be paired with --height"},
+			{Name: "height", Kind: "own", Type: "int", Required: "optional", Desc: "Optional chart height; must be paired with --width"},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request template; no side effects"},
+		},
+	},
+	"+chart-data-update": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
+			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
+			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
+			{Name: "chart-id", Kind: "own", Type: "string", Required: "required", Desc: "Target chart reference_id"},
+			{Name: "data-range", Kind: "own", Type: "string", Required: "required", Desc: "New data range including headers; accepts comma-separated same-sheet ranges and normalizes misaligned or overlapping ranges"},
+			{Name: "data-direction", Kind: "own", Type: "string", Required: "optional", Desc: "Data series direction; defaults to the existing chart direction when omitted", Enum: []string{"column", "row"}},
+			{Name: "dim1-index", Kind: "own", Type: "int", Required: "optional", Desc: "1-based category/X-axis dimension index within the data range; defaults to the first dimension"},
+			{Name: "dim2-indexes", Kind: "own", Type: "string", Required: "optional", Desc: "Comma-separated 1-based value/Y-axis series indexes within the data range; defaults to all dimensions except dim1"},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request template; no side effects"},
+		},
+	},
 	"+chart-delete": {
 		Risk: "high-risk-write",
 		Flags: []flagDef{
@@ -244,7 +314,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
 			{Name: "chart-id", Kind: "own", Type: "string", Required: "required", Desc: "Target chart reference_id"},
-			{Name: "properties", Kind: "own", Type: "string", Required: "required", Desc: "Full or sufficiently complete chart config JSON (read back with `+chart-list` first, then patch)", Input: []string{"file", "stdin"}},
+			{Name: "properties", Kind: "own", Type: "string", Required: "required", Desc: "Chart config patch JSON; send changed fields only by default; omitted fields are preserved, objects merge recursively, and arrays replace as a whole", Input: []string{"file", "stdin"}},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -319,7 +389,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
-			{Name: "range", Kind: "own", Type: "string", Required: "optional", Desc: "A1 range, e.g. `A1:F30` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet). Optional: when omitted the whole sheet is read (clipped to the actual grid bounds; actual_range in the response names what was read); pair with --max-chars / --output-path on large sheets"},
+			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "A1 range, e.g. `A1:F30` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet)"},
 			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Max output chars per call; default 500000 (safety cap). For a full untruncated read, use --output-path to dump to a file (auto-unlimited); only lower it (e.g. 25000) when you want results inline without a file, paging via has_more.", Default: "500000"},
 			{Name: "output-path", Kind: "own", Type: "string", Required: "optional", Desc: "Write the full read result to a local path (e.g. `./out.json`); the file holds the data payload as JSON while stdout returns only a small confirmation (output_path, byte count). **When set, the char cap defaults to unlimited** (overriding the --max-chars default), so a large sheet can be dumped in full for later analysis without stdout being truncated by max_chars. Omit it to print to stdout as usual."},
 			{Name: "include-row-prefix", Kind: "own", Type: "bool", Required: "optional", Desc: "Whether to prefix each row with `[row=N]`; default `true`", Default: "true"},
@@ -348,8 +418,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
-			{Name: "range", Kind: "own", Type: "string", Required: "xor", Desc: "Row/column closed range to delete; rows use 1-based numbers like `3:7` or `5` (single row), columns use letters like `C:F` or `C`. XOR with `--ranges`"},
-			{Name: "ranges", Kind: "own", Type: "string", Required: "xor", Desc: "Multiple row/column ranges to delete as a JSON array (up to 100 items, e.g. `[\"5:5\",\"8:8\",\"11:13\"]` or `[\"C:C\",\"F:G\"]`); rows and columns cannot be mixed, ranges must not overlap; XOR with `--range`. CLI sorts positions in DESCENDING order into one atomic batch delete — ascending deletion would shift later indexes as earlier rows/columns disappear; the CLI handles the ordering", Input: []string{"file", "stdin"}},
+			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "Row/column closed range to delete; rows use 1-based numbers like `3:7` or `5` (single row), columns use letters like `C:F` or `C`"},
 			{Name: "yes", Kind: "system", Type: "bool", Required: "required", Desc: "Confirm destructive write (exit code 10 without this flag); row/column deletion is irreversible"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
@@ -397,7 +466,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
-			{Name: "inherit-style", Kind: "own", Type: "string", Required: "optional", Desc: "Style inheritance for the new row/column: `before` (from the preceding row/column) / `after` (from the following row/column). Omit the flag to inherit the following row/column (same as `after`) — the backend cannot leave a new row/column unstyled; for a truly blank row/column, clear formats afterwards with +cells-clear --scope formats. Insertion always lands before `--position`; this only selects which side's style is copied.", Enum: []string{"before", "after"}},
+			{Name: "inherit-style", Kind: "own", Type: "string", Required: "optional", Desc: "Style inheritance for the new row/column: `before` (from preceding) / `after` (from following) / `none` (default)", Default: "none", Enum: []string{"before", "after", "none"}},
 			{Name: "position", Kind: "own", Type: "string", Required: "required", Desc: "Insert position (1-based row number like `3` or column letter like `C`); new rows/columns are inserted *before* this position"},
 			{Name: "count", Kind: "own", Type: "int", Required: "required", Desc: "Number of rows/columns to insert (must be > 0)"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
@@ -980,15 +1049,6 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
-	"+styles-put": {
-		Risk: "write",
-		Flags: []flagDef{
-			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet locator (target sheets are named inside --styles items)"},
-			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
-			{Name: "styles", Kind: "own", Type: "string", Required: "required", Desc: "Visual spec JSON applied to an EXISTING spreadsheet: top-level `{styles:[...]}`, one item per target sheet (`name` is the real sheet name), each giving at least one of `cell_styles` / `cell_merges` / `row_sizes` / `col_sizes` / `freeze`. The vocabulary is identical to `--styles` on `+workbook-create` / `+table-put` (cell_styles = A1 range + flat style fields, borders via the `border` shorthand {style,weight,color} applied to all four sides — border_styles only for per-side differences; row/col sizes = row/column range + size in px — type only for standard/auto; merges = cell range; freeze = `{rows:N, cols:N}`). The whole spec expands into one atomic batched request; ranges may target any region of the sheet", Input: []string{"file", "stdin"}},
-			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the batched request template for each expanded operation; no network side effects"},
-		},
-	},
 	"+table-get": {
 		Risk: "read",
 		Flags: []flagDef{

shortcuts/sheets/flag_defs_test.go

@@ -52,7 +52,7 @@ func TestFlagsFor_MapsAllFields(t *testing.T) {
 
 	// enum + default
 	rt := byName("+dim-insert", "inherit-style")
-	if rt == nil || len(rt.Enum) != 2 || rt.Default != "" {
+	if rt == nil || len(rt.Enum) != 3 || rt.Default != "none" {
 		t.Errorf("+dim-insert --inherit-style not mapped: %+v", rt)
 	}
 	// required

shortcuts/sheets/flag_ergonomics.go

@@ -61,15 +61,11 @@ func withFlagErgonomics(prev func(cmd *cobra.Command)) func(cmd *cobra.Command)
 var commandFlagAliases = map[string]map[string]string{
 	"+csv-put":      {"file": "csv"},
 	"+sheet-create": {"name": "title"},
-	// size → width/height: the styles protocol (--styles row_sizes/col_sizes)
-	// spells the pixel dimension "size", and pre-2026-07 batches accepted it
-	// here too — the rename is the single largest sub-op error cluster in
-	// eval traces (15+ hits). Same pixel-count semantics, safe to rewrite.
-	"+cols-resize": {"cols": "range", "size": "width"},
-	"+rows-resize": {"rows": "range", "size": "height"},
-	"+range-fill":  {"source": "source-range", "target": "target-range"},
-	"+range-copy":  {"source": "source-range", "target": "target-range"},
-	"+range-move":  {"source": "source-range", "target": "target-range"},
+	"+cols-resize":  {"cols": "range"},
+	"+rows-resize":  {"rows": "range"},
+	"+range-fill":   {"source": "source-range", "target": "target-range"},
+	"+range-copy":   {"source": "source-range", "target": "target-range"},
+	"+range-move":   {"source": "source-range", "target": "target-range"},
 }
 
 // intuitiveFlagHints carries the prescription for habitual names whose fix
@@ -95,11 +91,6 @@ var intuitiveFlagHints = map[string]map[string]string{
 		"italic":    "use --font-style italic",
 		"underline": "use --font-line underline",
 	},
-	"+cells-set": {
-		// Predictable prior from +table-put --styles: models will try to
-		// attach range-level styling to a --writes call the same way.
-		"styles": `range-level styling goes through +styles-put (same {"styles":[...]} vocabulary); per-cell styles ride inside the cells objects as cell_styles`,
-	},
 	"+table-put": {
 		"start-cell": `anchor each sub-sheet via the "start_cell" field inside --sheets (e.g. {"sheets":[{"name":"Sheet1","start_cell":"B2",…}]}); to paste CSV at a cell use +csv-put --start-cell`,
 		"sheet-name": `+table-put has no sheet selector — each --sheets item carries its own "name" field ({"sheets":[{"name":"Sheet1",…}]})`,
@@ -145,19 +136,6 @@ func chainFlagAliases(cmd *cobra.Command) {
 // immediately.
 func sheetsFlagErrorFunc(c *cobra.Command, ferr error) error {
 	name, isUnknown := unknownFlagFromParseError(ferr)
-	// Targeted fix for a high-frequency agent mistake: +batch-update carries no
-	// top-level sheet locator (each sub-op names its own sheet inside its input),
-	// yet agents reach for --sheet-id / --sheet-name at the top level. An
-	// edit-distance suggestion would only mislead here, so skip it and name the
-	// real contract instead. Underscore spellings (--sheet_id) are matched too:
-	// the error message itself teaches the underscore key names, and sub-op
-	// inputs accept them, so agents mix the two styles.
-	locatorName := strings.ReplaceAll(name, "_", "-")
-	if isUnknown && c.Name() == "+batch-update" && (locatorName == "sheet-id" || locatorName == "sheet-name") {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"batch-update has no top-level sheet locator; put sheet_id/sheet_name inside each operation's input").
-			WithParams(errs.InvalidParam{Name: "--" + name, Reason: "unknown flag"})
-	}
 	if !isUnknown {
 		return common.ValidationErrorf("%s", ferr.Error()).
 			WithHint("run `%s --help` for valid flags", c.CommandPath())

shortcuts/sheets/flag_ergonomics_test.go

@@ -96,55 +96,6 @@ func TestSheetsFlagErrorFunc_TypoKeepsSuggestion(t *testing.T) {
 	}
 }
 
-// TestSheetsFlagErrorFunc_BatchUpdateSheetLocator pins the targeted fix: a
-// top-level --sheet-id / --sheet-name on +batch-update points the caller at
-// the per-op locator contract instead of offering a misleading fuzzy guess.
-func TestSheetsFlagErrorFunc_BatchUpdateSheetLocator(t *testing.T) {
-	t.Parallel()
-	for _, name := range []string{"sheet-id", "sheet-name", "sheet_id", "sheet_name"} {
-		name := name
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			c := &cobra.Command{Use: "+batch-update"}
-			c.Flags().String("operations", "", "")
-			err := sheetsFlagErrorFunc(c, errors.New("unknown flag: --"+name))
-			var verr *errs.ValidationError
-			if !errors.As(err, &verr) {
-				t.Fatalf("expected *errs.ValidationError, got %T", err)
-			}
-			if !strings.Contains(verr.Message, "put sheet_id/sheet_name inside each operation's input") {
-				t.Errorf("message should name the per-op locator contract, got %q", verr.Message)
-			}
-			if strings.Contains(verr.Hint, "did you mean") {
-				t.Errorf("must not offer a fuzzy guess here, got hint %q", verr.Hint)
-			}
-			if len(verr.Params) != 1 || verr.Params[0].Name != "--"+name {
-				t.Errorf("Params should carry the offending flag, got %v", verr.Params)
-			}
-			if len(verr.Params[0].Suggestions) != 0 {
-				t.Errorf("no suggestions expected, got %v", verr.Params[0].Suggestions)
-			}
-		})
-	}
-}
-
-// TestSheetsFlagErrorFunc_BatchUpdateOtherUnknownStillSuggests confirms the
-// special case is scoped to the two sheet-locator flags: any other unknown
-// flag on +batch-update keeps the normal did-you-mean behaviour.
-func TestSheetsFlagErrorFunc_BatchUpdateOtherUnknownStillSuggests(t *testing.T) {
-	t.Parallel()
-	c := &cobra.Command{Use: "+batch-update"}
-	c.Flags().String("operations", "", "")
-	err := sheetsFlagErrorFunc(c, errors.New("unknown flag: --operation"))
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	if strings.Contains(verr.Message, "no top-level sheet locator") {
-		t.Errorf("non-locator unknown flag must not hit the special case, got %q", verr.Message)
-	}
-}
-
 func TestSheetsFlagErrorFunc_OtherErrorStaysGeneric(t *testing.T) {
 	t.Parallel()
 	c := &cobra.Command{Use: "demo"}
@@ -423,39 +374,6 @@ func TestShortcuts_IntuitiveFlagAliases(t *testing.T) {
 		}
 	})
 
-	t.Run("cols-resize --size parses as --width", func(t *testing.T) {
-		t.Parallel()
-		sc := shortcutFromRegistry(t, "+cols-resize")
-		stdout, _, err := runShortcutCapturingErr(t, sc, []string{
-			"--url", testURL,
-			"--sheet-name", "s",
-			"--range", "A:C",
-			"--size", "120",
-			"--dry-run",
-		})
-		if err != nil {
-			t.Fatalf("--size should alias to --width (styles-protocol vocabulary), got: %v", err)
-		}
-		if !strings.Contains(stdout, "120") {
-			t.Errorf("dry-run body should carry the pixel width 120, got %q", stdout)
-		}
-	})
-
-	t.Run("rows-resize --size parses as --height", func(t *testing.T) {
-		t.Parallel()
-		sc := shortcutFromRegistry(t, "+rows-resize")
-		_, _, err := runShortcutCapturingErr(t, sc, []string{
-			"--url", testURL,
-			"--sheet-name", "s",
-			"--range", "1:3",
-			"--size", "36",
-			"--dry-run",
-		})
-		if err != nil {
-			t.Fatalf("--size should alias to --height (styles-protocol vocabulary), got: %v", err)
-		}
-	})
-
 	t.Run("alias never shadows a registered flag", func(t *testing.T) {
 		t.Parallel()
 		c := &cobra.Command{Use: "+csv-put"}

shortcuts/sheets/flag_schema.go

@@ -159,7 +159,7 @@ func splitSchemaPath(flagName string) (string, []string) {
 // sliceSchemaByPath walks a decoded JSON Schema along dotted path segments.
 // Each segment matches a key under "properties"; array levels are descended
 // implicitly through "items" (an explicit "items" segment also works), and
-// oneOf branches are searched for the first one carrying the key. A miss
+// oneOf / anyOf branches are searched for the first one carrying the key. A miss
 // errors with the keys actually available at that level so the caller can
 // re-issue the path without a full dump.
 func sliceSchemaByPath(schema interface{}, flagName string, path []string) (interface{}, error) {
@@ -179,7 +179,7 @@ func sliceSchemaByPath(schema interface{}, flagName string, path []string) (inte
 }
 
 // schemaChild resolves one path segment against a schema node, descending
-// through items / oneOf wrappers as needed.
+// through items / oneOf / anyOf wrappers as needed.
 func schemaChild(node interface{}, seg string) (interface{}, bool) {
 	for depth := 0; depth < 8; depth++ {
 		m, ok := node.(map[string]interface{})
@@ -207,13 +207,20 @@ func schemaChild(node interface{}, seg string) (interface{}, bool) {
 				}
 			}
 		}
+		if branches, ok := m["anyOf"].([]interface{}); ok {
+			for _, b := range branches {
+				if child, ok := schemaChild(b, seg); ok {
+					return child, true
+				}
+			}
+		}
 		return nil, false
 	}
 	return nil, false
 }
 
 // schemaChildKeys lists the property keys reachable at a schema node (through
-// items / oneOf wrappers), for the path-miss error.
+// items / oneOf / anyOf wrappers), for the path-miss error.
 func schemaChildKeys(node interface{}) []string {
 	seen := map[string]struct{}{}
 	var collect func(n interface{}, depth int)
@@ -240,6 +247,11 @@ func schemaChildKeys(node interface{}) []string {
 				collect(b, depth+1)
 			}
 		}
+		if branches, ok := m["anyOf"].([]interface{}); ok {
+			for _, b := range branches {
+				collect(b, depth+1)
+			}
+		}
 	}
 	collect(node, 0)
 	keys := make([]string, 0, len(seen))

shortcuts/sheets/flag_schema_validate.go

@@ -9,8 +9,6 @@ import (
 	"fmt"
 	"sort"
 	"strings"
-
-	"github.com/larksuite/cli/internal/suggest"
 )
 
 // ─── schema-driven flag validation ────────────────────────────────────
@@ -96,15 +94,7 @@ func validateValueAgainstSchema(fv flagView, name string, value interface{}) err
 	}
 	var schema schemaProperty
 	json.Unmarshal(raw, &schema)
-	c := &schemaErrorCollector{}
-	collectSchemaErrors(value, &schema, "", c)
-	if len(c.errs) == 0 {
-		return nil
-	}
-	vErr := c.errs[0]
-	if len(c.errs) == 1 {
-		// Single failure keeps the historical message byte-for-byte.
-		//
+	if vErr := validateAgainstSchema(value, &schema, ""); vErr != nil {
 		// Composite-JSON shape errors (e.g. +cells-set --cells, chart
 		// --properties) are the highest-frequency usage-layer failure for
 		// sheets, and agents often burn several retries guessing the shape.
@@ -117,63 +107,18 @@ func validateValueAgainstSchema(fv flagView, name string, value interface{}) err
 		// branch means entry[name] resolved a schema from the embedded
 		// index, so the suggested command is guaranteed to print it.
 		var tm *typeMismatchError
-		isTypeMismatch := errors.As(vErr, &tm)
-		if isTypeMismatch && pathDepth(tm.path) <= skeletonPathDepthLimit {
+		if errors.As(vErr, &tm) && pathDepth(tm.path) <= skeletonPathDepthLimit {
 			if sk := schemaSkeleton(&schema, skeletonMaxDepth); sk != "" {
 				return sheetsValidationForFlag(name,
 					"--%s: %s; expected shape: %s (run `lark-cli sheets %s --print-schema --flag-name %s` for the full JSON Schema)",
 					name, vErr.Error(), sk, command, name).WithCause(vErr)
 			}
 		}
-		// Deep type mismatches don't get a whole-shape skeleton (it wouldn't
-		// address the actual field), but if the field itself carries an enum /
-		// description, append that one line — same "fix on first retry" goal.
-		msg := vErr.Error()
-		if isTypeMismatch {
-			if suffix := tm.hintSuffix(); suffix != "" {
-				msg += "; " + suffix
-			}
-		}
 		return sheetsValidationForFlag(name,
 			"--%s: %s; run `lark-cli sheets %s --print-schema --flag-name %s` to see the expected JSON Schema",
-			name, msg, command, name).WithCause(vErr)
+			name, vErr.Error(), command, name).WithCause(vErr)
 	}
-	// Multiple failures: report them all at once (numbered, each with its
-	// own inline teaching hint) so the agent fixes the whole payload in one
-	// retry instead of the fail-fast "fix one, hit the next" loop.
-	return sheetsValidationForFlag(name,
-		"--%s: %s; run `lark-cli sheets %s --print-schema --flag-name %s` to see the expected JSON Schema",
-		name, formatSchemaErrorList(c.errs), command, name).WithCause(vErr)
-}
-
-// formatSchemaErrorList renders collected failures as a numbered one-line
-// list: "N validation errors: 1) …; 2) …". Type-mismatch entries carry
-// their enum/description suffix just like the single-error path. Entries
-// beyond schemaErrorDisplayLimit collapse into a "(more …)" tail — the
-// collector stops at cap, so the exact total is unknown by design.
-func formatSchemaErrorList(errs []error) string {
-	shown := errs
-	truncated := false
-	if len(shown) > schemaErrorDisplayLimit {
-		shown = shown[:schemaErrorDisplayLimit]
-		truncated = true
-	}
-	parts := make([]string, 0, len(shown))
-	for i, e := range shown {
-		msg := e.Error()
-		var tm *typeMismatchError
-		if errors.As(e, &tm) {
-			if suffix := tm.hintSuffix(); suffix != "" {
-				msg += "; " + suffix
-			}
-		}
-		parts = append(parts, fmt.Sprintf("%d) %s", i+1, msg))
-	}
-	out := fmt.Sprintf("%d validation errors: %s", len(shown), strings.Join(parts, "; "))
-	if truncated {
-		out = fmt.Sprintf("%d+ validation errors: %s; (more errors not shown — fix these first)", schemaErrorDisplayLimit, strings.Join(parts, "; "))
-	}
-	return out
+	return nil
 }
 
 // validateInputAgainstSchema validates input[flag] for every flag the
@@ -242,10 +187,8 @@ var inputSchemaSkip = map[string]struct{}{
 }
 
 // schemaProperty mirrors the JSON Schema subset used by
-// data/flag-schemas.json. Description is retained (not just documentation)
-// so a required-missing or type-mismatch error can inline the one-line
-// field doc — the agent then fixes the input without a --print-schema round
-// trip. Other unknown keys stay dropped.
+// data/flag-schemas.json. Unknown keys (description, …) are dropped —
+// they're documentation.
 //
 // Minimum / Maximum / MinItems / MaxItems use *float64 / *int because
 // 0 is a meaningful bound (e.g. chart row >= 0); nil distinguishes
@@ -261,7 +204,6 @@ var inputSchemaSkip = map[string]struct{}{
 //     map<string, array<string>> fields (groups / collapse).
 type schemaProperty struct {
 	Type                 string                     `json:"type"`
-	Description          string                     `json:"description"`
 	Nullable             bool                       `json:"nullable"`
 	Enum                 []interface{}              `json:"enum"`
 	Properties           map[string]*schemaProperty `json:"properties"`
@@ -300,66 +242,20 @@ func (a *additionalProps) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// schemaErrorCollector accumulates validation failures during one full
-// traversal so the caller can report every problem in a single reply
-// instead of the fail-fast "fix one, retry, hit the next" loop. Capacity
-// is bounded (collectSchemaErrorsCap) so a pathological payload — e.g. a
-// 5000-row --cells array where every cell is malformed — cannot balloon
-// the error message or the traversal cost: once full, collection
-// short-circuits everywhere via full().
-type schemaErrorCollector struct {
-	errs []error
-}
-
-// collectSchemaErrorsCap bounds how many errors one traversal gathers:
-// schemaErrorDisplayLimit entries are rendered; one extra is collected
-// only to know that truncation happened.
-const (
-	schemaErrorDisplayLimit = 5
-	collectSchemaErrorsCap  = schemaErrorDisplayLimit + 1
-)
-
-func (c *schemaErrorCollector) add(err error) {
-	if len(c.errs) < collectSchemaErrorsCap {
-		c.errs = append(c.errs, err)
-	}
-}
-
-func (c *schemaErrorCollector) full() bool { return len(c.errs) >= collectSchemaErrorsCap }
-
 // validateAgainstSchema recursively checks `value` against `schema`,
-// prefixing any failure with the JSON path navigated so far. It reports
-// only the first failure — callers that want the full list (the
-// error-as-teaching aggregate path) use collectSchemaErrors directly.
+// prefixing any failure with the JSON path navigated so far.
 func validateAgainstSchema(value interface{}, schema *schemaProperty, path string) error {
-	c := &schemaErrorCollector{}
-	collectSchemaErrors(value, schema, path, c)
-	if len(c.errs) == 0 {
-		return nil
-	}
-	return c.errs[0]
-}
-
-// collectSchemaErrors is the traversal engine behind validateAgainstSchema:
-// same checks, same messages, same deterministic order, but it keeps
-// walking after a failure and appends every problem to the collector
-// (until cap). Two deliberate exceptions to "keep walking":
-//   - a type mismatch stops descent into that node (its children would
-//     produce cascading nonsense against the wrong-typed value);
-//   - oneOf alternatives are probed with throwaway collectors (a failed
-//     alternative is not an error when a later one matches).
-func collectSchemaErrors(value interface{}, schema *schemaProperty, path string, c *schemaErrorCollector) {
-	if schema == nil || c.full() {
-		return
+	if schema == nil {
+		return nil // defensive — current callers always pass &schema, but
+		// keeps validator safe for future programmatic construction.
 	}
 	if value == nil && schema.Nullable {
-		return
+		return nil
 	}
 
 	if schema.Type != "" {
 		if !matchesJSONType(value, schema.Type) {
-			c.add(&typeMismatchError{path: path, expected: schema.Type, got: jsType(value), enum: schema.Enum, description: schema.Description})
-			return // wrong container type — descending would cascade nonsense.
+			return &typeMismatchError{path: path, expected: schema.Type, got: jsType(value)}
 		}
 	}
 
@@ -367,20 +263,20 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 	// already reported above). Apply to both `number` and `integer` types.
 	if num, ok := value.(float64); ok {
 		if schema.Minimum != nil && num < *schema.Minimum {
-			c.add(fmt.Errorf("%svalue %v is below minimum %v", pathPrefix(path), num, *schema.Minimum)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+			return fmt.Errorf("%svalue %v is below minimum %v", pathPrefix(path), num, *schema.Minimum) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 		}
 		if schema.Maximum != nil && num > *schema.Maximum {
-			c.add(fmt.Errorf("%svalue %v is above maximum %v", pathPrefix(path), num, *schema.Maximum)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+			return fmt.Errorf("%svalue %v is above maximum %v", pathPrefix(path), num, *schema.Maximum) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 		}
 	}
 
 	// Array length bounds — only checked when value is an array.
 	if arr, ok := value.([]interface{}); ok {
 		if schema.MinItems != nil && len(arr) < *schema.MinItems {
-			c.add(fmt.Errorf("%sarray has %d items, minimum is %d", pathPrefix(path), len(arr), *schema.MinItems)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+			return fmt.Errorf("%sarray has %d items, minimum is %d", pathPrefix(path), len(arr), *schema.MinItems) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 		}
 		if schema.MaxItems != nil && len(arr) > *schema.MaxItems {
-			c.add(fmt.Errorf("%sarray has %d items, maximum is %d", pathPrefix(path), len(arr), *schema.MaxItems)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+			return fmt.Errorf("%sarray has %d items, maximum is %d", pathPrefix(path), len(arr), *schema.MaxItems) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 		}
 	}
 
@@ -398,22 +294,20 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 			if hint := suggestEnumForError(value, schema.Enum); hint != "" {
 				msg += fmt.Sprintf(` (did you mean %q?)`, hint)
 			}
-			c.add(fmt.Errorf("%s", msg)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+			return fmt.Errorf("%s", msg) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 		}
 	}
 
 	if len(schema.OneOf) > 0 {
 		matched := false
 		for _, sub := range schema.OneOf {
-			probe := &schemaErrorCollector{}
-			collectSchemaErrors(value, sub, path, probe)
-			if len(probe.errs) == 0 {
+			if validateAgainstSchema(value, sub, path) == nil {
 				matched = true
 				break
 			}
 		}
 		if !matched {
-			c.add(fmt.Errorf("%svalue does not match any of oneOf alternatives", pathPrefix(path))) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+			return fmt.Errorf("%svalue does not match any of oneOf alternatives", pathPrefix(path)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 		}
 	}
 
@@ -422,18 +316,8 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 	// the schema also describes their per-key shape via `properties`.
 	if obj, ok := value.(map[string]interface{}); ok {
 		for _, key := range schema.Required {
-			if c.full() {
-				return
-			}
 			if _, present := obj[key]; !present {
-				msg := fmt.Sprintf("required property %q is missing at %s", key, pathOrRoot(path))
-				// Inline the missing field's type / one-line description / enum so
-				// the agent supplies a correctly-shaped value on the first retry
-				// instead of fetching the full schema.
-				if hint := schemaFieldHint(schema.Properties[key]); hint != "" {
-					msg += "; expected " + hint
-				}
-				c.add(fmt.Errorf("%s", msg)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
+				return fmt.Errorf("required property %q is missing at %s", key, pathOrRoot(path)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 			}
 		}
 		if schema.Properties != nil {
@@ -443,9 +327,6 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 			}
 			sort.Strings(keys)
 			for _, key := range keys {
-				if c.full() {
-					return
-				}
 				sub := schema.Properties[key]
 				v, present := obj[key]
 				if !present {
@@ -469,12 +350,14 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 				if path != "" {
 					child = path + "." + key
 				}
-				collectSchemaErrors(v, sub, child, c)
+				if err := validateAgainstSchema(v, sub, child); err != nil {
+					return err
+				}
 			}
 		}
 		// additionalProperties: enforce only when explicitly declared.
 		// Absent means lenient (matches the file header's stance). Sort
-		// extras so rejection order is deterministic across runs.
+		// extras so the first rejection is deterministic across runs.
 		if schema.AdditionalProperties != nil {
 			extras := make([]string, 0)
 			for key := range obj {
@@ -485,29 +368,17 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 			}
 			sort.Strings(extras)
 			for _, key := range extras {
-				if c.full() {
-					return
-				}
 				if schema.AdditionalProperties.Strict {
-					msg := fmt.Sprintf("%sunexpected property %q (not declared in schema)", pathPrefix(path), key)
-					// Inline the node's declared keys (and a did-you-mean when the
-					// unknown key is a near miss) so the agent renames it in one
-					// retry instead of a --print-schema round trip.
-					if legal := sortedSchemaPropertyKeys(schema.Properties); len(legal) > 0 {
-						if guess := suggest.Closest(key, legal, 1); len(guess) > 0 {
-							msg += fmt.Sprintf(` (did you mean %q?)`, guess[0])
-						}
-						msg += "; valid properties: " + formatPropertyKeyList(legal)
-					}
-					c.add(fmt.Errorf("%s", msg)) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
-					continue
+					return fmt.Errorf("%sunexpected property %q (not declared in schema)", pathPrefix(path), key) //nolint:forbidigo // intermediate error; validateFlagAgainstSchema wraps it into a typed flag validation error with a --print-schema hint
 				}
 				if schema.AdditionalProperties.Schema != nil {
 					child := key
 					if path != "" {
 						child = path + "." + key
 					}
-					collectSchemaErrors(obj[key], schema.AdditionalProperties.Schema, child, c)
+					if err := validateAgainstSchema(obj[key], schema.AdditionalProperties.Schema, child); err != nil {
+						return err
+					}
 				}
 			}
 		}
@@ -516,50 +387,33 @@ func collectSchemaErrors(value interface{}, schema *schemaProperty, path string,
 	if schema.Type == "array" && schema.Items != nil {
 		arr, ok := value.([]interface{})
 		if !ok {
-			return // type mismatch already reported above.
+			return nil // type mismatch already reported above.
 		}
 		for i, item := range arr {
-			if c.full() {
-				return
-			}
 			child := fmt.Sprintf("%s[%d]", path, i)
-			collectSchemaErrors(item, schema.Items, child, c)
+			if err := validateAgainstSchema(item, schema.Items, child); err != nil {
+				return err
+			}
 		}
 	}
+
+	return nil
 }
 
 // typeMismatchError is the type-check branch of validateAgainstSchema
 // as a typed error, so validateValueAgainstSchema can recognize shape
 // confusion (vs. deep value errors) and inline a skeleton of the
-// expected shape. Error() keeps the exact legacy wording; enum /
-// description ride alongside for the deep-mismatch hintSuffix, so they
-// never leak into the shallow-skeleton message.
+// expected shape. Error() keeps the exact legacy wording.
 type typeMismatchError struct {
-	path        string
-	expected    string
-	got         string
-	enum        []interface{}
-	description string
+	path     string
+	expected string
+	got      string
 }
 
 func (e *typeMismatchError) Error() string {
 	return fmt.Sprintf("%sexpected type %q, got %q", pathPrefix(e.path), e.expected, e.got)
 }
 
-// hintSuffix renders the field's description / enum as a one-line tail for
-// the deep type-mismatch fallback (type is already stated by Error()).
-// Empty when the field declares neither.
-func (e *typeMismatchError) hintSuffix() string {
-	var parts []string
-	if d := oneLineDescription(e.description); d != "" {
-		parts = append(parts, "description: "+d)
-	}
-	if len(e.enum) > 0 {
-		parts = append(parts, "one of "+formatEnum(e.enum))
-	}
-	return strings.Join(parts, ", ")
-}
-
 // pathDepth counts how many levels below the flag root a JSON path
 // points at: "" → 0, "[0]" → 1, "[0][3]" → 2, "[0][3].value" → 3,
 // "legend" → 1, "snapshot.axes" → 2. Every "[" and "." starts a new
@@ -751,70 +605,6 @@ func joinFormatted(values []interface{}) string {
 	return strings.Join(parts, ", ")
 }
 
-// schemaFieldHint renders a compact one-line "type X, description: …, one of
-// […]" sketch of a single field's schema, used to enrich a required-missing
-// error so the agent supplies a correctly-shaped value without --print-schema.
-// Empty when the field declares none of type / description / enum.
-func schemaFieldHint(s *schemaProperty) string {
-	if s == nil {
-		return ""
-	}
-	var parts []string
-	if s.Type != "" {
-		parts = append(parts, fmt.Sprintf("type %q", s.Type))
-	}
-	if d := oneLineDescription(s.Description); d != "" {
-		parts = append(parts, "description: "+d)
-	}
-	if len(s.Enum) > 0 {
-		parts = append(parts, "one of "+formatEnum(s.Enum))
-	}
-	return strings.Join(parts, ", ")
-}
-
-// sortedSchemaPropertyKeys returns the declared property names in a stable
-// (sorted) order so the valid-property list in a strict unexpected-property
-// error is deterministic across runs.
-func sortedSchemaPropertyKeys(props map[string]*schemaProperty) []string {
-	keys := make([]string, 0, len(props))
-	for k := range props {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// propertyKeyDisplayLimit caps how many declared property names ride inline on
-// a strict unexpected-property error, so a wide object doesn't bury the actual
-// error under a wall of keys. Overflow is summarised as "(N more)".
-const propertyKeyDisplayLimit = 15
-
-func formatPropertyKeyList(keys []string) string {
-	if len(keys) <= propertyKeyDisplayLimit {
-		return "[" + strings.Join(keys, ", ") + "]"
-	}
-	shown := keys[:propertyKeyDisplayLimit]
-	return fmt.Sprintf("[%s, … (%d more)]", strings.Join(shown, ", "), len(keys)-propertyKeyDisplayLimit)
-}
-
-// descriptionMaxLen bounds an inlined field description to one reasonable line;
-// schema descriptions can run several sentences, which would swamp the error.
-const descriptionMaxLen = 120
-
-// oneLineDescription collapses a (possibly multi-line) schema description into
-// a single whitespace-normalised line, truncated to descriptionMaxLen runes.
-// Returns "" for an empty / whitespace-only description.
-func oneLineDescription(s string) string {
-	collapsed := strings.Join(strings.Fields(s), " ")
-	if collapsed == "" {
-		return ""
-	}
-	if r := []rune(collapsed); len(r) > descriptionMaxLen {
-		return string(r[:descriptionMaxLen]) + "…"
-	}
-	return collapsed
-}
-
 // suggestEnumMatch returns the canonical enum entry when the user's
 // value unambiguously means one — casing ("SUM" vs "sum", "True" vs
 // "true") or a cross-vocabulary alias (CSS "center" for Lark's vertical

shortcuts/sheets/flag_schema_validate_test.go

@@ -5,8 +5,6 @@ package sheets
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
 	"strings"
 	"testing"
 )
@@ -440,373 +438,6 @@ func TestValidateValueAgainstSchema_ShapeSkeletonOnShallowTypeMismatch(t *testin
 	}
 }
 
-// TestValidateAgainstSchema_StrictUnexpectedPropertyListsKeys pins the strict
-// additionalProperties:false enhancement: the error lists the node's legal
-// property keys (sorted, capped at 15 with an "(N more)" overflow) and, when
-// the unknown key is a near miss, appends a did-you-mean.
-func TestValidateAgainstSchema_StrictUnexpectedPropertyListsKeys(t *testing.T) {
-	t.Parallel()
-
-	t.Run("lists legal keys and suggests a near miss", func(t *testing.T) {
-		t.Parallel()
-		schema := parseSchema(t, `{
-			"type":"object",
-			"additionalProperties":false,
-			"properties":{
-				"background_color":{"type":"string"},
-				"font_weight":{"type":"string"},
-				"font_size":{"type":"integer"}
-			}
-		}`)
-		err := validateAgainstSchema(map[string]interface{}{"background_colour": "#fff"}, schema, "")
-		if err == nil {
-			t.Fatal("unknown key under strict schema must fail")
-		}
-		msg := err.Error()
-		if !strings.Contains(msg, `unexpected property "background_colour"`) {
-			t.Errorf("want the offending key named; got %q", msg)
-		}
-		if !strings.Contains(msg, `did you mean "background_color"?`) {
-			t.Errorf("want a did-you-mean for the near miss; got %q", msg)
-		}
-		for _, want := range []string{"valid properties:", "background_color", "font_size", "font_weight"} {
-			if !strings.Contains(msg, want) {
-				t.Errorf("want valid-property list to contain %q; got %q", want, msg)
-			}
-		}
-	})
-
-	t.Run("no did-you-mean for an unrelated key", func(t *testing.T) {
-		t.Parallel()
-		schema := parseSchema(t, `{
-			"type":"object",
-			"additionalProperties":false,
-			"properties":{"background_color":{"type":"string"}}
-		}`)
-		err := validateAgainstSchema(map[string]interface{}{"zzzzzzzz": 1}, schema, "")
-		if err == nil {
-			t.Fatal("unknown key must fail")
-		}
-		if strings.Contains(err.Error(), "did you mean") {
-			t.Errorf("unrelated key should get no suggestion; got %q", err.Error())
-		}
-		if !strings.Contains(err.Error(), "valid properties: [background_color]") {
-			t.Errorf("want the valid-property list; got %q", err.Error())
-		}
-	})
-
-	t.Run("wide object truncates the key list with overflow", func(t *testing.T) {
-		t.Parallel()
-		props := make([]string, 0, 20)
-		for i := 0; i < 20; i++ {
-			props = append(props, fmt.Sprintf(`"k%02d":{"type":"string"}`, i))
-		}
-		schema := parseSchema(t, `{"type":"object","additionalProperties":false,"properties":{`+strings.Join(props, ",")+`}}`)
-		err := validateAgainstSchema(map[string]interface{}{"nope": 1}, schema, "")
-		if err == nil {
-			t.Fatal("unknown key must fail")
-		}
-		if !strings.Contains(err.Error(), "(5 more)") { // 20 keys, cap 15
-			t.Errorf("want overflow marker '(5 more)'; got %q", err.Error())
-		}
-	})
-}
-
-// TestValidateAgainstSchema_RequiredMissingInlinesFieldHint pins that a
-// required-property-missing error inlines the field's type / one-line
-// description / enum when the schema describes that field.
-func TestValidateAgainstSchema_RequiredMissingInlinesFieldHint(t *testing.T) {
-	t.Parallel()
-
-	schema := parseSchema(t, `{
-		"type":"object",
-		"required":["operation"],
-		"properties":{
-			"operation":{
-				"type":"string",
-				"description":"Which mutation to run.",
-				"enum":["insert","delete","move"]
-			}
-		}
-	}`)
-	err := validateAgainstSchema(map[string]interface{}{}, schema, "")
-	if err == nil {
-		t.Fatal("missing required property must fail")
-	}
-	msg := err.Error()
-	for _, want := range []string{
-		`required property "operation"`,
-		`type "string"`,
-		"description: Which mutation to run.",
-		`one of ["insert", "delete", "move"]`,
-	} {
-		if !strings.Contains(msg, want) {
-			t.Errorf("want %q in required-missing error; got %q", want, msg)
-		}
-	}
-}
-
-// TestValidateAgainstSchema_RequiredMissingNoSchemaStaysPlain pins that a
-// missing required key with no describing schema keeps the plain legacy
-// message (no trailing "expected ...").
-func TestValidateAgainstSchema_RequiredMissingNoSchemaStaysPlain(t *testing.T) {
-	t.Parallel()
-	schema := parseSchema(t, `{"type":"object","required":["a"]}`)
-	err := validateAgainstSchema(map[string]interface{}{}, schema, "")
-	if err == nil {
-		t.Fatal("missing required must fail")
-	}
-	if strings.Contains(err.Error(), "; expected") {
-		t.Errorf("no field schema → no inlined hint; got %q", err.Error())
-	}
-}
-
-// TestValidateValueAgainstSchema_DeepTypeMismatchAppendsEnum pins that a deep
-// type mismatch (past the skeleton depth limit) still gets no whole-shape
-// skeleton, but appends the field's enum / description one-liner.
-func TestValidateValueAgainstSchema_DeepTypeMismatchAppendsEnum(t *testing.T) {
-	t.Parallel()
-	// A wrong-typed value three levels deep where the field is an enum string.
-	schema := parseSchema(t, `{
-		"type":"array",
-		"items":{"type":"array","items":{"type":"object","properties":{
-			"align":{"type":"string","description":"Text alignment.","enum":["left","center","right"]}
-		}}}
-	}`)
-	deep := parseValue(t, `[[{"align":42}]]`)
-	err := validateAgainstSchema(deep, schema, "")
-	if err == nil {
-		t.Fatal("wrong type for align must fail")
-	}
-	var tm *typeMismatchError
-	if !errors.As(err, &tm) {
-		t.Fatalf("want *typeMismatchError, got %T", err)
-	}
-	suffix := tm.hintSuffix()
-	for _, want := range []string{"description: Text alignment.", `one of ["left", "center", "right"]`} {
-		if !strings.Contains(suffix, want) {
-			t.Errorf("want %q in hintSuffix; got %q", want, suffix)
-		}
-	}
-}
-
-// TestSchemaFieldHint covers the single-field sketch used by
-// required-missing errors: each of type / description / enum contributes
-// its own segment, absent parts are simply skipped, and a nil / empty
-// schema yields no hint at all.
-func TestSchemaFieldHint(t *testing.T) {
-	t.Parallel()
-	cases := []struct {
-		name   string
-		schema *schemaProperty
-		want   string
-	}{
-		{"nil schema", nil, ""},
-		{"empty schema", &schemaProperty{}, ""},
-		{"type only", &schemaProperty{Type: "string"}, `type "string"`},
-		{"description only", &schemaProperty{Description: "Cell note."}, "description: Cell note."},
-		{"enum only", &schemaProperty{Enum: []interface{}{"a", "b"}}, `one of ["a", "b"]`},
-		{
-			"all three",
-			&schemaProperty{Type: "string", Description: "段类型", Enum: []interface{}{"text", "link"}},
-			`type "string", description: 段类型, one of ["text", "link"]`,
-		},
-	}
-	for _, tc := range cases {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			if got := schemaFieldHint(tc.schema); got != tc.want {
-				t.Errorf("schemaFieldHint = %q, want %q", got, tc.want)
-			}
-		})
-	}
-}
-
-// TestFormatPropertyKeyList_Boundaries pins the display cap edges: exactly
-// at the cap nothing is folded, one past the cap folds into "(1 more)".
-func TestFormatPropertyKeyList_Boundaries(t *testing.T) {
-	t.Parallel()
-	keys := make([]string, 0, propertyKeyDisplayLimit+1)
-	for i := 0; i < propertyKeyDisplayLimit; i++ {
-		keys = append(keys, fmt.Sprintf("k%02d", i))
-	}
-	if got := formatPropertyKeyList(keys); strings.Contains(got, "more)") {
-		t.Errorf("exactly %d keys must not fold, got %q", propertyKeyDisplayLimit, got)
-	}
-	keys = append(keys, "overflow")
-	if got := formatPropertyKeyList(keys); !strings.Contains(got, "(1 more)") {
-		t.Errorf("%d keys should fold into '(1 more)', got %q", propertyKeyDisplayLimit+1, got)
-	}
-}
-
-// TestTypeMismatchHintSuffix_EmptyWhenUndeclared pins that a field with
-// neither enum nor description adds no suffix — the deep-mismatch fallback
-// message must stay byte-identical to the legacy wording in that case.
-func TestTypeMismatchHintSuffix_EmptyWhenUndeclared(t *testing.T) {
-	t.Parallel()
-	tm := &typeMismatchError{path: "a.b", expected: "string", got: "number"}
-	if got := tm.hintSuffix(); got != "" {
-		t.Errorf("no enum/description → empty suffix, got %q", got)
-	}
-}
-
-// TestValidateAgainstSchema_StrictUnexpectedProperty_CaseOnlyTypo pins the
-// did-you-mean for a key that differs from a legal one only in casing /
-// underscore style — a high-frequency LLM slip.
-func TestValidateAgainstSchema_StrictUnexpectedProperty_CaseOnlyTypo(t *testing.T) {
-	t.Parallel()
-	schema := parseSchema(t, `{
-		"type":"object",
-		"additionalProperties":false,
-		"properties":{"background_color":{"type":"string"}}
-	}`)
-	err := validateAgainstSchema(map[string]interface{}{"Background_Color": "#fff"}, schema, "")
-	if err == nil {
-		t.Fatal("case-typo key under strict schema must fail")
-	}
-	if !strings.Contains(err.Error(), `did you mean "background_color"?`) {
-		t.Errorf("want case-insensitive did-you-mean; got %q", err.Error())
-	}
-}
-
-// TestValidateValueAgainstSchema_RequiredMissingRealSchema replays 场景3
-// of the doubao case against the real embedded flag-schemas.json: a
-// rich_text segment without "type" must inline the field's type, enum and
-// description while keeping the --print-schema pointer.
-func TestValidateValueAgainstSchema_RequiredMissingRealSchema(t *testing.T) {
-	t.Parallel()
-	fv := mapFlagView{command: "+cells-set"}
-	value := parseValue(t, `[[{"rich_text":[{"text":"x"}]}]]`)
-	err := validateValueAgainstSchema(fv, "cells", value)
-	if err == nil {
-		t.Fatal("rich_text without type must fail against the embedded schema")
-	}
-	msg := err.Error()
-	for _, want := range []string{
-		`required property "type" is missing`,
-		`expected type "string"`,
-		"one of [",
-		`"text"`,
-		"--print-schema",
-	} {
-		if !strings.Contains(msg, want) {
-			t.Errorf("want %q in real-schema required-missing error; got %q", want, msg)
-		}
-	}
-}
-
-// TestValidateValueAgainstSchema_DeepMismatchRealSchema replays 场景4: a
-// numeric rich_text "type" three levels deep gets the field's enum inline
-// (no whole-shape skeleton), still with the --print-schema pointer.
-func TestValidateValueAgainstSchema_DeepMismatchRealSchema(t *testing.T) {
-	t.Parallel()
-	fv := mapFlagView{command: "+cells-set"}
-	value := parseValue(t, `[[{"rich_text":[{"type":42,"text":"x"}]}]]`)
-	err := validateValueAgainstSchema(fv, "cells", value)
-	if err == nil {
-		t.Fatal("numeric rich_text type must fail against the embedded schema")
-	}
-	msg := err.Error()
-	for _, want := range []string{
-		`expected type "string", got "number"`,
-		"one of [",
-		`"text"`,
-		"--print-schema",
-	} {
-		if !strings.Contains(msg, want) {
-			t.Errorf("want %q in real-schema deep-mismatch error; got %q", want, msg)
-		}
-	}
-	if strings.Contains(msg, "expected shape:") {
-		t.Errorf("deep mismatch must not inline a skeleton; got %q", msg)
-	}
-}
-
-// TestValidateValueAgainstSchema_AggregatesMultipleErrors pins the
-// aggregate path: a payload with several independent problems reports them
-// all in one numbered reply (each with its own teaching hint) instead of
-// the fail-fast fix-one-retry-hit-the-next loop.
-func TestValidateValueAgainstSchema_AggregatesMultipleErrors(t *testing.T) {
-	t.Parallel()
-	fv := mapFlagView{command: "+cells-set"}
-	// Two independent problems in one --cells payload: cell[0][0].rich_text[0]
-	// misses required "type"; cell[0][1].note has the wrong type.
-	value := parseValue(t, `[[{"rich_text":[{"text":"x"}]},{"note":12.5}]]`)
-	err := validateValueAgainstSchema(fv, "cells", value)
-	if err == nil {
-		t.Fatal("payload with two problems must fail")
-	}
-	msg := err.Error()
-	for _, want := range []string{
-		"2 validation errors:",
-		`1) required property "type" is missing`,
-		`one of ["text"`, // teaching hint rides along in aggregate mode too
-		`2) [0][1].note: expected type "string"`,
-		"--print-schema",
-	} {
-		if !strings.Contains(msg, want) {
-			t.Errorf("want %q in aggregated error; got %q", want, msg)
-		}
-	}
-}
-
-// TestValidateValueAgainstSchema_AggregateCapTruncates pins the display
-// cap: a pathological payload reports schemaErrorDisplayLimit entries and
-// an explicit truncation tail, never the full flood.
-func TestValidateValueAgainstSchema_AggregateCapTruncates(t *testing.T) {
-	t.Parallel()
-	fv := mapFlagView{command: "+cells-set"}
-	// Seven cells all missing required rich_text "type" → 7 independent errors.
-	row := make([]string, 0, 7)
-	for i := 0; i < 7; i++ {
-		row = append(row, `{"rich_text":[{"text":"x"}]}`)
-	}
-	value := parseValue(t, `[[`+strings.Join(row, ",")+`]]`)
-	err := validateValueAgainstSchema(fv, "cells", value)
-	if err == nil {
-		t.Fatal("payload with seven problems must fail")
-	}
-	msg := err.Error()
-	if !strings.Contains(msg, "5+ validation errors:") {
-		t.Errorf("want capped header '5+ validation errors:'; got %q", msg)
-	}
-	if !strings.Contains(msg, "more errors not shown") {
-		t.Errorf("want truncation tail; got %q", msg)
-	}
-	if strings.Contains(msg, "6)") {
-		t.Errorf("must not render entries beyond the display limit; got %q", msg)
-	}
-}
-
-// TestCollectSchemaErrors_OneOfProbeDoesNotLeak pins that failed oneOf
-// alternatives don't leak probe errors into the caller's collector when a
-// later alternative matches.
-func TestCollectSchemaErrors_OneOfProbeDoesNotLeak(t *testing.T) {
-	t.Parallel()
-	schema := parseSchema(t, `{"oneOf":[{"type":"string"},{"type":"number"}]}`)
-	c := &schemaErrorCollector{}
-	collectSchemaErrors(42.0, schema, "", c)
-	if len(c.errs) != 0 {
-		t.Errorf("number matches the second oneOf alternative; want no errors, got %v", c.errs)
-	}
-}
-
-func TestOneLineDescription(t *testing.T) {
-	t.Parallel()
-	if got := oneLineDescription("   "); got != "" {
-		t.Errorf("whitespace-only → empty, got %q", got)
-	}
-	if got := oneLineDescription("line one\n  line two"); got != "line one line two" {
-		t.Errorf("multi-line collapse = %q", got)
-	}
-	long := strings.Repeat("x", 200)
-	got := oneLineDescription(long)
-	if !strings.HasSuffix(got, "…") || len([]rune(got)) != descriptionMaxLen+1 {
-		t.Errorf("long description should truncate to %d runes + ellipsis, got %d", descriptionMaxLen, len([]rune(got)))
-	}
-}
-
 func TestPathDepth(t *testing.T) {
 	t.Parallel()
 	cases := []struct {

shortcuts/sheets/flag_schemas_gen.go

@@ -34,7 +34,6 @@ var commandsWithSchema = map[string]struct{}{
 	"+rows-resize":           {},
 	"+sparkline-create":      {},
 	"+sparkline-update":      {},
-	"+styles-put":            {},
 	"+table-put":             {},
 	"+workbook-create":       {},
 }

shortcuts/sheets/helpers.go

@@ -11,6 +11,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	neturl "net/url"
 	"strings"
 
@@ -540,3 +541,179 @@ func requireJSONArray(runtime flagView, name string) ([]interface{}, error) {
 	}
 	return a, nil
 }
+
+// ─── style flags (shared by +cells-set-style and +cells-batch-set-style) ─
+
+// buildCellStyleFromFlags reads the 12 flat style flags and returns the
+// cell_styles map expected by set_cell_range. Skips any flag the user
+// didn't set so partial styles work.
+func buildCellStyleFromFlags(runtime flagView) map[string]interface{} {
+	style := map[string]interface{}{}
+	if v := runtime.Str("background-color"); v != "" {
+		style["background_color"] = v
+	}
+	if v := runtime.Str("font-color"); v != "" {
+		style["font_color"] = v
+	}
+	if v := runtime.Str("font-family"); v != "" {
+		style["font_family"] = v
+	}
+	if runtime.Changed("font-size") && runtime.Float64("font-size") > 0 {
+		style["font_size"] = runtime.Float64("font-size")
+	}
+	if v := runtime.Str("font-style"); v != "" {
+		style["font_style"] = v
+	}
+	if v := runtime.Str("font-weight"); v != "" {
+		style["font_weight"] = v
+	}
+	if v := runtime.Str("font-line"); v != "" {
+		style["font_line"] = v
+	}
+	if v := runtime.Str("horizontal-alignment"); v != "" {
+		style["horizontal_alignment"] = v
+	}
+	if v := runtime.Str("vertical-alignment"); v != "" {
+		style["vertical_alignment"] = v
+	}
+	if v := runtime.Str("word-wrap"); v != "" {
+		style["word_wrap"] = v
+	}
+	if v := runtime.Str("number-format"); v != "" {
+		style["number_format"] = v
+	}
+	return style
+}
+
+// cellStyleAliases maps shorthand cell_styles field names that models commonly
+// hallucinate (Excel / openpyxl / CSS conventions) onto the canonical field
+// names the backend expects. Only the unambiguous alignment shorthands are
+// aliased — they are the high-frequency miss; ambiguous guesses (e.g. "color",
+// "bg_color", "text_align") are intentionally left out so a wrong guess still
+// surfaces as an error rather than being silently reinterpreted.
+var cellStyleAliases = []struct{ alias, canonical string }{
+	{"horizontal_align", "horizontal_alignment"},
+	{"halign", "horizontal_alignment"},
+	{"vertical_align", "vertical_alignment"},
+	{"valign", "vertical_alignment"},
+}
+
+// normalizeCellStyleAliases renames known shorthand keys in a single
+// cell_styles map to their canonical equivalents, in place, so a model that
+// writes e.g. "horizontal_align" instead of "horizontal_alignment" still
+// applies the style instead of hitting an "unsupported field" error (--styles)
+// or having the field silently dropped by the backend (typed --cells). If both
+// the shorthand and its canonical key are present it returns a validation error
+// rather than picking one. path labels the map for the error message.
+func normalizeCellStyleAliases(style map[string]interface{}, path string) error {
+	if len(style) == 0 {
+		return nil
+	}
+	for _, a := range cellStyleAliases {
+		v, ok := style[a.alias]
+		if !ok {
+			continue
+		}
+		if _, exists := style[a.canonical]; exists {
+			return common.ValidationErrorf("%s.%s conflicts with %s; pass only %s", path, a.alias, a.canonical, a.canonical)
+		}
+		style[a.canonical] = v
+		delete(style, a.alias)
+	}
+	return nil
+}
+
+// normalizeTypedCellsStyleAliases walks a typed --cells 2D array and applies
+// normalizeCellStyleAliases to every cell's inline cell_styles object, so the
+// alignment shorthands are accepted on +cells-set the same as on --styles.
+// It also expands the border "all" shorthand and intercepts border_styles
+// mis-nested inside cell_styles — both server-rejected shapes that eval
+// traces show surviving CLI validation and costing a full network round
+// trip. Structure is checked leniently to match the pass-through contract:
+// any element that isn't the expected shape is skipped, not rejected.
+func normalizeTypedCellsStyleAliases(cells []interface{}, path string) error {
+	for r, rowRaw := range cells {
+		row, ok := rowRaw.([]interface{})
+		if !ok {
+			continue
+		}
+		for c, cellRaw := range row {
+			cell, ok := cellRaw.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if bs, ok := cell["border_styles"].(map[string]interface{}); ok {
+				expandBorderAllShorthand(bs)
+			}
+			st, ok := cell["cell_styles"].(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if _, misNested := st["border_styles"]; misNested {
+				return common.ValidationErrorf(
+					"%s[%d][%d].cell_styles.border_styles is not valid — border_styles is a top-level cell field, a sibling of cell_styles; move it up one level",
+					path, r, c)
+			}
+			if err := normalizeCellStyleAliases(st, fmt.Sprintf("%s[%d][%d].cell_styles", path, r, c)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// expandBorderAllShorthand rewrites the "all" side shorthand — habitual from
+// Excel / openpyxl vocabulary, rejected by the backend — into the four
+// explicit sides, in place. An explicitly set side wins over the shorthand.
+// Applied on both the typed --cells path and the --styles path, so batch
+// sub-ops get the same rewrite as standalone calls.
+func expandBorderAllShorthand(border map[string]interface{}) {
+	all, ok := border["all"]
+	if !ok {
+		return
+	}
+	for _, side := range []string{"top", "bottom", "left", "right"} {
+		if _, exists := border[side]; !exists {
+			border[side] = all
+		}
+	}
+	delete(border, "all")
+}
+
+// borderStylesFromFlag parses --border-styles as a JSON object (top/bottom/
+// left/right with style sub-objects), expanding the "all" side shorthand the
+// same as the typed --cells and --styles paths so +cells-set-style /
+// +cells-batch-set-style don't ship {"all":…} for the backend to reject.
+// Returns nil when the flag is empty.
+func borderStylesFromFlag(runtime flagView) (map[string]interface{}, error) {
+	if runtime.Str("border-styles") == "" {
+		return nil, nil
+	}
+	v, err := parseJSONFlag(runtime, "border-styles")
+	if err != nil {
+		return nil, err
+	}
+	m, ok := v.(map[string]interface{})
+	if !ok {
+		return nil, sheetsValidationForFlag("border-styles", "--border-styles must be a JSON object")
+	}
+	expandBorderAllShorthand(m)
+	return m, nil
+}
+
+// requireAnyStyleFlag ensures at least one style-defining flag (style or
+// border) is set — otherwise the request would do nothing.
+func requireAnyStyleFlag(runtime flagView) error {
+	if len(buildCellStyleFromFlags(runtime)) > 0 {
+		return nil
+	}
+	if runtime.Str("border-styles") != "" {
+		return nil
+	}
+	return common.ValidationErrorf("at least one style flag is required (e.g. --background-color, --font-weight, --border-styles)").
+		WithParams(
+			sheetsInvalidParam("background-color", "required; specify at least one style flag"),
+			sheetsInvalidParam("font-weight", "required; specify at least one style flag"),
+			sheetsInvalidParam("border-styles", "required; specify at least one style flag"),
+		)
+}

shortcuts/sheets/lark_sheet_batch_update.go

@@ -5,7 +5,6 @@ package sheets
 
 import (
 	"context"
-	"fmt"
 	"strings"
 
 	"github.com/larksuite/cli/shortcuts/common"
@@ -30,14 +29,10 @@ import (
 // The tool's contract (post-translation):
 //   { excel_id, operations: [{tool_name, input}, ...], continue_on_error? }
 //
-// continue_on_error defaults to false (fail-fast): execution stops at the
-// first failing sub-op, but sub-ops already applied are NOT rolled back —
-// the server reports "N succeeded, M failed" and the N stay in the sheet
-// (verified against live batches; earlier docs wrongly promised a rollback,
-// which made agents resend whole batches and double-apply the successes).
-// CLI leaves the default in place for the fan-out shortcuts since they're
-// idempotent stamps; only +batch-update lets callers flip it via
-// --continue-on-error.
+// continue_on_error defaults to false (strict transaction): any failure
+// rolls back the whole batch. CLI leaves the default in place for the
+// three "fan-out" shortcuts since they're meant to be all-or-nothing;
+// only +batch-update lets callers flip it via --continue-on-error.
 
 // BatchUpdate accepts a CLI-shape operations array (each item
 // {shortcut, input}); on Validate / DryRun / Execute we translate each
@@ -47,7 +42,7 @@ import (
 var BatchUpdate = common.Shortcut{
 	Service:     "sheets",
 	Command:     "+batch-update",
-	Description: "Execute a batch of write shortcuts in one request; fail-fast on the first failing sub-op (already-applied sub-ops are NOT rolled back).",
+	Description: "Execute a batch of write shortcuts as a single atomic request (rolls back on failure by default).",
 	Risk:        "high-risk-write",
 	Scopes:      []string{"sheets:spreadsheet:write_only"},
 	AuthTypes:   []string{"user", "bot"},
@@ -69,11 +64,7 @@ var BatchUpdate = common.Shortcut{
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		token, _ := resolveSpreadsheetToken(runtime)
 		input, _ := batchUpdateInput(runtime, token)
-		dr := invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
-		if batchNeedsDimInsertBeforeStyleWarning(runtime) {
-			dr.Set("warning_message", dimInsertBeforeStyleWarning)
-		}
-		return dr
+		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		token, err := resolveSpreadsheetTokenExec(runtime)
@@ -84,9 +75,6 @@ var BatchUpdate = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		if batchNeedsDimInsertBeforeStyleWarning(runtime) {
-			fmt.Fprintln(runtime.IO().ErrOut, dimInsertBeforeStyleWarning)
-		}
 		out, err := callTool(ctx, runtime, token, ToolKindWrite, "batch_update", input)
 		if err != nil {
 			return err
@@ -96,7 +84,7 @@ var BatchUpdate = common.Shortcut{
 	},
 	Tips: []string{
 		"high-risk-write: always pass --yes (or --dry-run to preview) — without it the call exits 10 asking for confirmation.",
-		"Execution is fail-fast, NOT transactional: on \"N succeeded, M failed\" the succeeded sub-ops stay applied (no rollback) — fix the failure and resend ONLY the operations from the first failed index onward; resending the whole batch re-applies the succeeded ones. Pass --continue-on-error to keep going past failures instead.",
+		"Default is strict transaction — any sub-tool failure rolls the whole batch back. Pass --continue-on-error to keep partial successes.",
 		"Each sub-op is {shortcut, input}. Do NOT pass input.operation (implied by shortcut name) or input.excel_id / input.url (set at the +batch-update top level).",
 	},
 }
@@ -137,46 +125,6 @@ func batchUpdateInput(runtime *common.RuntimeContext, token string) (map[string]
 	return input, nil
 }
 
-// batchNeedsDimInsertBeforeStyleWarning reports whether any +dim-insert sub-op
-// requests --inherit-style before at the first row/column, where the
-// preceding-side style cannot be copied (no preceding row/column exists).
-func batchNeedsDimInsertBeforeStyleWarning(runtime *common.RuntimeContext) bool {
-	rawOps, err := parseBatchOperationsFlag(runtime)
-	if err != nil {
-		return false
-	}
-	for _, raw := range rawOps {
-		op, ok := raw.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		sc, _ := op["shortcut"].(string)
-		if sc != "+dim-insert" {
-			continue
-		}
-		input, _ := op["input"].(map[string]interface{})
-		isBefore := false
-		for _, key := range []string{"inherit-style", "inherit_style", "inheritStyle"} {
-			if v, _ := input[key].(string); strings.EqualFold(v, "before") {
-				isBefore = true
-				break
-			}
-		}
-		if !isBefore {
-			continue
-		}
-		posRaw, hasPos := input["position"]
-		if !hasPos {
-			continue
-		}
-		// Warn only at the first row/column (idx 0).
-		if _, idx, err := parseA1Position(strings.TrimSpace(fmt.Sprintf("%v", posRaw))); err == nil && idx == 0 {
-			return true
-		}
-	}
-	return false
-}
-
 // parseBatchOperationsFlag accepts --operations as either a JSON array (the
 // operations list directly) or an envelope object { operations, continue_on_error }
 // for back-compat with the legacy --data shape. Returns the operations array.
@@ -214,7 +162,6 @@ var CellsBatchSetStyle = common.Shortcut{
 	HasFormat:   true,
 	Flags:       flagsFor("+cells-batch-set-style"),
 	Tips: []string{
-		"DEPRECATED: superseded by +styles-put, whose one spec also covers merges, row/col sizes and freeze — prefer it for new work.",
 		`Example: lark-cli sheets +cells-batch-set-style --url <URL> --ranges '["Sheet1!A1:B2","汇总!C1:C9"]' --font-weight bold`,
 		"Every range carries its sheet-NAME prefix (Sheet1!A1:B2, not a sheet_id) — there is no --sheet-id / --sheet-name flag here.",
 	},
@@ -247,10 +194,6 @@ var CellsBatchSetStyle = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		// Phase-1 deprecation (docs already point at +styles-put): keep the
-		// command working, steer new usage to the superset in-band.
-		fmt.Fprintln(runtime.IO().ErrOut,
-			"note: +cells-batch-set-style is superseded by +styles-put (one spec covers styles + merges + row/col sizes + freeze); prefer +styles-put for new work")
 		out, err := callTool(ctx, runtime, token, ToolKindWrite, "batch_update", input)
 		if err != nil {
 			return err

shortcuts/sheets/lark_sheet_batch_update_test.go

@@ -58,39 +58,6 @@ func TestBatchUpdate_TranslatesShortcutToToolName(t *testing.T) {
 	}
 }
 
-func TestBatchUpdate_DimInsertInheritAfterCopiesFollowingStyle(t *testing.T) {
-	t.Parallel()
-
-	body := parseDryRunBody(t, BatchUpdate, []string{
-		"--url", testURL,
-		"--operations", `[
-		  {"shortcut":"+dim-insert","input":{"sheet_id":"sh1","position":"D","count":1,"inherit_style":"after"}}
-		]`,
-		"--yes",
-	})
-	input := decodeToolInput(t, body, "batch_update")
-	ops, _ := input["operations"].([]interface{})
-	if len(ops) != 1 {
-		t.Fatalf("operations length = %d, want 1", len(ops))
-	}
-	op := ops[0].(map[string]interface{})
-	if op["tool_name"] != "modify_sheet_structure" {
-		t.Fatalf("tool_name = %v, want modify_sheet_structure", op["tool_name"])
-	}
-	in, _ := op["input"].(map[string]interface{})
-	// inherit_style=after copies the following column's style via a plain
-	// before-insert at the same position (the backend anchors on the following
-	// column), so position stays D with side=before.
-	assertInputEquals(t, in, map[string]interface{}{
-		"excel_id":  testToken,
-		"sheet_id":  "sh1",
-		"operation": "insert",
-		"position":  "D",
-		"count":     float64(1),
-		"side":      "before",
-	})
-}
-
 func TestBatchUpdate_HighRiskWriteRequiresYes(t *testing.T) {
 	t.Parallel()
 	stdout, stderr, err := runShortcutCapturingErr(t, BatchUpdate, []string{
@@ -438,21 +405,6 @@ func TestBatchUpdate_TranslatorRejects(t *testing.T) {
 			opsJSON:   `[{"shortcut":"+cells-set","input":"not-an-object"}]`,
 			wantMatch: "'input' must be a JSON object",
 		},
-		{
-			name:      "wrapped cell_styles structure",
-			opsJSON:   `[{"shortcut":"+cells-set-style","input":{"sheet_name":"s","range":"A1","cell_styles":{"background_color":"#EBF1F8"}}}]`,
-			wantMatch: "do not wrap in cell_styles",
-		},
-		{
-			name:      "wrapped styles structure",
-			opsJSON:   `[{"shortcut":"+cells-set-style","input":{"sheet_name":"s","range":"A1","styles":{"font_weight":"bold"}}}]`,
-			wantMatch: "do not wrap in styles",
-		},
-		{
-			name:      "wrapped cell_merges structure",
-			opsJSON:   `[{"shortcut":"+cells-set-style","input":{"sheet_name":"s","range":"A1","cell_merges":[{"range":"A1:B1"}]}}]`,
-			wantMatch: "do not wrap in cell_merges",
-		},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -468,99 +420,6 @@ func TestBatchUpdate_TranslatorRejects(t *testing.T) {
 	}
 }
 
-// TestBatchUpdate_FlattenedStyleKeysNotMistakenForWrapper guards the
-// wrapped-structure rejection against overreach: the same style fields in
-// their correct flattened form must translate cleanly — only the wrapper
-// container keys (cell_styles / styles / cell_merges) are rejected.
-func TestBatchUpdate_FlattenedStyleKeysNotMistakenForWrapper(t *testing.T) {
-	t.Parallel()
-	got, err := translateBatchOp(map[string]interface{}{
-		"shortcut": "+cells-set-style",
-		"input": map[string]interface{}{
-			"sheet_name":       "s",
-			"range":            "A1",
-			"background_color": "#EBF1F8",
-			"font_weight":      "bold",
-		},
-	}, testToken, 0)
-	if err != nil {
-		t.Fatalf("flattened style keys must pass the wrapper check, got %v", err)
-	}
-	input := got["input"].(map[string]interface{})
-	cells := input["cells"].([][]interface{})
-	style := cells[0][0].(map[string]interface{})["cell_styles"].(map[string]interface{})
-	if style["background_color"] != "#EBF1F8" || style["font_weight"] != "bold" {
-		t.Fatalf("translated style = %#v", style)
-	}
-}
-
-// TestBatchUpdate_WrapperKeysDisjointFromSubOpFlags locks the static
-// assumption wrappedSubOpInputKeys relies on: no shortcut registered in
-// batchOpDispatch declares a flag named cell_styles / cell_merges / styles.
-// If a future dispatch-table addition (e.g. +table-put) carries one of these
-// flags, its legitimate input would be silently rejected by the wrapper
-// check — this test turns that silent breakage into a build-time failure.
-func TestBatchUpdate_WrapperKeysDisjointFromSubOpFlags(t *testing.T) {
-	t.Parallel()
-	wrapped := make(map[string]struct{}, len(wrappedSubOpInputKeys))
-	for _, k := range wrappedSubOpInputKeys {
-		wrapped[k] = struct{}{}
-	}
-	for shortcut := range batchOpDispatch {
-		for _, f := range flagsFor(shortcut) {
-			key := strings.ReplaceAll(f.Name, "-", "_")
-			if _, clash := wrapped[key]; clash {
-				t.Errorf("%s declares flag --%s which collides with wrappedSubOpInputKeys; "+
-					"exempt this shortcut from the wrapper check before adding it to batchOpDispatch",
-					shortcut, f.Name)
-			}
-		}
-	}
-}
-
-// TestBatchUpdate_AggregatesMultipleOpErrors pins op-level aggregation: when
-// several operations are invalid, one reply names them all (numbered, with
-// each op's own error) instead of failing on the first bad op only. A single
-// bad op keeps the historical single-error message (no aggregate wrapper).
-func TestBatchUpdate_AggregatesMultipleOpErrors(t *testing.T) {
-	t.Parallel()
-
-	t.Run("two bad ops reported together", func(t *testing.T) {
-		t.Parallel()
-		_, _, err := runShortcutCapturingErr(t, BatchUpdate, []string{
-			"--url", testURL,
-			"--operations", `[
-				{"shortcut":"+cells-set-magic","input":{}},
-				{"shortcut":"+cells-set","input":{"sheet_name":"s","range":"A1"}},
-				{"shortcut":"+cells-clear","input":{"sheet_name":"s","range":"A1"}}
-			]`,
-			"--yes", "--dry-run",
-		})
-		requireValidation(t, err, "2 of 3 operations failed validation")
-		for _, want := range []string{"1) ", "2) ", "operations[0]", "operations[1]"} {
-			if !strings.Contains(err.Error(), want) {
-				t.Errorf("aggregated op error should contain %q, got %q", want, err.Error())
-			}
-		}
-	})
-
-	t.Run("single bad op keeps plain message", func(t *testing.T) {
-		t.Parallel()
-		_, _, err := runShortcutCapturingErr(t, BatchUpdate, []string{
-			"--url", testURL,
-			"--operations", `[
-				{"shortcut":"+cells-set-magic","input":{}},
-				{"shortcut":"+cells-clear","input":{"sheet_name":"s","range":"A1"}}
-			]`,
-			"--yes", "--dry-run",
-		})
-		requireValidation(t, err, "not allowed in +batch-update")
-		if strings.Contains(err.Error(), "operations failed validation") {
-			t.Errorf("single bad op must not get the aggregate wrapper, got %q", err.Error())
-		}
-	})
-}
-
 // TestBatchUpdate_PrescriptiveHints pins the recovery hints that ride on the
 // highest-frequency batch failures, so an agent can repair its payload in a
 // single retry without --help / --print-schema round trips.

shortcuts/sheets/lark_sheet_chart.go

@@ -0,0 +1,605 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"context"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/larksuite/cli/shortcuts/common"
+	"github.com/spf13/cobra"
+)
+
+var chartHexColorPattern = regexp.MustCompile(`^#?[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$`)
+
+var chartSemanticConfigFlags = []string{
+	"title",
+	"subtitle",
+	"legend-position",
+	"x-axis-title",
+	"y-axis-title",
+	"secondary-y-axis-title",
+	"x-axis-label-angle",
+	"y-axis-label-angle",
+	"data-labels",
+	"data-label-position",
+	"stack",
+	"color-palette",
+}
+
+// ChartCreateBasic creates a complete server-side chart snapshot from a chart
+// type and a rectangular source range. The CLI only forwards semantic input;
+// it deliberately does not own or duplicate the full chart snapshot template.
+var ChartCreateBasic = common.Shortcut{
+	Service:     "sheets",
+	Command:     "+chart-create-basic",
+	Description: "Create a basic chart from a chart type and data range; the server builds and validates the full snapshot.",
+	Risk:        "write",
+	Scopes:      []string{"sheets:spreadsheet:write_only"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags:       flagsFor("+chart-create-basic"),
+	PostMount:   configureChartSemanticCommand,
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, err := resolveSpreadsheetToken(runtime)
+		if err != nil {
+			return err
+		}
+		sheetID, sheetName, err := resolveSheetSelector(runtime)
+		if err != nil {
+			return err
+		}
+		_, err = chartCreateBasicInput(runtime, token, sheetID, sheetName)
+		return err
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		token, _ := resolveSpreadsheetToken(runtime)
+		sheetID, sheetName, _ := resolveSheetSelector(runtime)
+		input, _ := chartCreateBasicInput(runtime, token, sheetID, sheetName)
+		return invokeToolDryRun(token, ToolKindWrite, "manage_chart_object", input)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, err := resolveSpreadsheetTokenExec(runtime)
+		if err != nil {
+			return err
+		}
+		sheetID, sheetName, err := resolveSheetSelector(runtime)
+		if err != nil {
+			return err
+		}
+		input, err := chartCreateBasicInput(runtime, token, sheetID, sheetName)
+		if err != nil {
+			return err
+		}
+		out, err := callTool(ctx, runtime, token, ToolKindWrite, "manage_chart_object", input)
+		if err != nil {
+			return err
+		}
+		runtime.Out(out, nil)
+		return nil
+	},
+}
+
+// ChartConfigUpdate updates the common chart settings that repeatedly caused
+// full-snapshot retries in eval traces. Advanced per-series and marker styling
+// remains on +chart-update --properties.
+var ChartConfigUpdate = common.Shortcut{
+	Service:     "sheets",
+	Command:     "+chart-config-update",
+	Description: "Update common chart titles, axes, legend, labels, stacking, smoothing, or chart-level colors without sending a snapshot.",
+	Risk:        "write",
+	Scopes:      []string{"sheets:spreadsheet:write_only"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags:       flagsFor("+chart-config-update"),
+	PostMount:   configureChartSemanticCommand,
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, err := resolveSpreadsheetToken(runtime)
+		if err != nil {
+			return err
+		}
+		sheetID, sheetName, err := resolveSheetSelector(runtime)
+		if err != nil {
+			return err
+		}
+		_, err = chartConfigUpdateInput(runtime, token, sheetID, sheetName)
+		return err
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		token, _ := resolveSpreadsheetToken(runtime)
+		sheetID, sheetName, _ := resolveSheetSelector(runtime)
+		input, _ := chartConfigUpdateInput(runtime, token, sheetID, sheetName)
+		return invokeToolDryRun(token, ToolKindWrite, "manage_chart_object", input)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, err := resolveSpreadsheetTokenExec(runtime)
+		if err != nil {
+			return err
+		}
+		sheetID, sheetName, err := resolveSheetSelector(runtime)
+		if err != nil {
+			return err
+		}
+		input, err := chartConfigUpdateInput(runtime, token, sheetID, sheetName)
+		if err != nil {
+			return err
+		}
+		out, err := callTool(ctx, runtime, token, ToolKindWrite, "manage_chart_object", input)
+		if err != nil {
+			return err
+		}
+		runtime.Out(out, nil)
+		return nil
+	},
+}
+
+// ChartDataUpdate rebinds an existing chart to a new source range. The server
+// reads the current snapshot, rebuilds its data mapping, and preserves the
+// chart's layout and visual configuration.
+var ChartDataUpdate = common.Shortcut{
+	Service:     "sheets",
+	Command:     "+chart-data-update",
+	Description: "Update an existing chart's data range or direction while preserving its layout and visual configuration.",
+	Risk:        "write",
+	Scopes:      []string{"sheets:spreadsheet:write_only"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags:       flagsFor("+chart-data-update"),
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, err := resolveSpreadsheetToken(runtime)
+		if err != nil {
+			return err
+		}
+		sheetID, sheetName, err := resolveSheetSelector(runtime)
+		if err != nil {
+			return err
+		}
+		_, err = chartDataUpdateInput(runtime, token, sheetID, sheetName)
+		return err
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		token, _ := resolveSpreadsheetToken(runtime)
+		sheetID, sheetName, _ := resolveSheetSelector(runtime)
+		input, _ := chartDataUpdateInput(runtime, token, sheetID, sheetName)
+		return invokeToolDryRun(token, ToolKindWrite, "manage_chart_object", input)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, err := resolveSpreadsheetTokenExec(runtime)
+		if err != nil {
+			return err
+		}
+		sheetID, sheetName, err := resolveSheetSelector(runtime)
+		if err != nil {
+			return err
+		}
+		input, err := chartDataUpdateInput(runtime, token, sheetID, sheetName)
+		if err != nil {
+			return err
+		}
+		out, err := callTool(ctx, runtime, token, ToolKindWrite, "manage_chart_object", input)
+		if err != nil {
+			return err
+		}
+		runtime.Out(out, nil)
+		return nil
+	},
+}
+
+func chartCreateBasicInput(rt flagView, token, sheetID, sheetName string) (map[string]interface{}, error) {
+	if err := requireSheetSelector(sheetID, sheetName); err != nil {
+		return nil, err
+	}
+	chartType := strings.TrimSpace(rt.Str("chart-type"))
+	if chartType == "" {
+		return nil, sheetsValidationForFlag("chart-type", "--chart-type is required")
+	}
+	dataRange := strings.TrimSpace(rt.Str("data-range"))
+	if dataRange == "" {
+		return nil, sheetsValidationForFlag("data-range", "--data-range is required")
+	}
+	direction := rt.Str("data-direction")
+	if direction == "" {
+		direction = "column"
+	}
+	normalizedDataRange, dimensionCount, dataPointCount, err := normalizeBasicChartDataRanges(dataRange, direction)
+	if err != nil {
+		return nil, err
+	}
+	if dimensionCount < 2 || dataPointCount < 2 {
+		return nil, sheetsValidationForFlag("data-range", "--data-range must provide at least 2 data points and 2 dimensions")
+	}
+	if chartType == "combo" && dimensionCount < 3 {
+		return nil, sheetsValidationForFlag("data-range", "combo chart requires at least 3 rows or columns along --data-direction")
+	}
+
+	basic := map[string]interface{}{
+		"chart_type": chartType,
+		"data_range": normalizedDataRange,
+	}
+	if rt.Changed("data-direction") {
+		basic["data_direction"] = rt.Str("data-direction")
+	}
+	if err := validateChartColorFlags(rt); err != nil {
+		return nil, err
+	}
+	if err := validateChartSemanticEnums(rt); err != nil {
+		return nil, err
+	}
+	addChartSemanticConfig(rt, basic)
+
+	if rt.Changed("anchor-cell") {
+		anchor := strings.TrimSpace(rt.Str("anchor-cell"))
+		_, row, ok := splitCellRef(anchor)
+		if !ok {
+			return nil, sheetsValidationForFlag("anchor-cell", "--anchor-cell must be a single A1 cell such as F2")
+		}
+		colEnd := 0
+		for colEnd < len(anchor) && ((anchor[colEnd] >= 'A' && anchor[colEnd] <= 'Z') || (anchor[colEnd] >= 'a' && anchor[colEnd] <= 'z')) {
+			colEnd++
+		}
+		basic["position"] = map[string]interface{}{"row": row, "col": strings.ToUpper(anchor[:colEnd])}
+	}
+	widthChanged := rt.Changed("width")
+	heightChanged := rt.Changed("height")
+	if widthChanged != heightChanged {
+		return nil, common.ValidationErrorf("--width and --height must be provided together").WithParams(
+			sheetsInvalidParam("width", "must be paired with --height"),
+			sheetsInvalidParam("height", "must be paired with --width"),
+		)
+	}
+	if widthChanged {
+		if rt.Int("width") < 10 || rt.Int("height") < 10 {
+			return nil, common.ValidationErrorf("--width and --height must be at least 10")
+		}
+		basic["size"] = map[string]interface{}{"width": rt.Int("width"), "height": rt.Int("height")}
+	}
+
+	input := map[string]interface{}{"excel_id": token, "operation": "create", "basic_chart": basic}
+	sheetSelectorForToolInput(input, sheetID, sheetName)
+	if err := validateInputAgainstSchema(rt, input); err != nil {
+		return nil, err
+	}
+	return input, nil
+}
+
+func chartConfigUpdateInput(rt flagView, token, sheetID, sheetName string) (map[string]interface{}, error) {
+	if err := requireSheetSelector(sheetID, sheetName); err != nil {
+		return nil, err
+	}
+	chartID := strings.TrimSpace(rt.Str("chart-id"))
+	if chartID == "" {
+		return nil, sheetsValidationForFlag("chart-id", "--chart-id is required")
+	}
+	updates := map[string]interface{}{}
+	if err := validateChartColorFlags(rt); err != nil {
+		return nil, err
+	}
+	if err := validateChartSemanticEnums(rt); err != nil {
+		return nil, err
+	}
+	addChartSemanticConfig(rt, updates)
+	if len(updates) == 0 {
+		return nil, common.ValidationErrorf("at least one chart configuration flag is required")
+	}
+	input := map[string]interface{}{
+		"excel_id":       token,
+		"operation":      "update",
+		"chart_id":       chartID,
+		"config_updates": updates,
+	}
+	sheetSelectorForToolInput(input, sheetID, sheetName)
+	if err := validateInputAgainstSchema(rt, input); err != nil {
+		return nil, err
+	}
+	return input, nil
+}
+
+func chartDataUpdateInput(rt flagView, token, sheetID, sheetName string) (map[string]interface{}, error) {
+	if err := requireSheetSelector(sheetID, sheetName); err != nil {
+		return nil, err
+	}
+	chartID := strings.TrimSpace(rt.Str("chart-id"))
+	if chartID == "" {
+		return nil, sheetsValidationForFlag("chart-id", "--chart-id is required")
+	}
+	dataRange := strings.TrimSpace(rt.Str("data-range"))
+	if dataRange == "" {
+		return nil, sheetsValidationForFlag("data-range", "--data-range is required")
+	}
+	ranges, err := splitChartDataRanges(dataRange)
+	if err != nil {
+		return nil, sheetsValidationForFlag("data-range", "invalid --data-range %q: %v", dataRange, err)
+	}
+	explicitSheet := ""
+	for _, value := range ranges {
+		item, parseErr := parseChartDataRange(value)
+		if parseErr != nil {
+			return nil, sheetsValidationForFlag("data-range", "invalid --data-range item %q: %v", value, parseErr)
+		}
+		if item.sheet != "" {
+			if explicitSheet != "" && item.sheet != explicitSheet {
+				return nil, sheetsValidationForFlag("data-range", "all --data-range items must belong to the same sheet")
+			}
+			explicitSheet = item.sheet
+		}
+	}
+
+	updates := map[string]interface{}{"data_range": dataRange}
+	if rt.Changed("data-direction") {
+		updates["data_direction"] = rt.Str("data-direction")
+	}
+	dim1Index := 1
+	if rt.Changed("dim1-index") {
+		dim1Index = rt.Int("dim1-index")
+		if dim1Index < 1 {
+			return nil, sheetsValidationForFlag("dim1-index", "--dim1-index must be a positive 1-based index")
+		}
+		updates["dim1_index"] = dim1Index
+	}
+	if rt.Changed("dim2-indexes") {
+		dim2Indexes, parseErr := parseChartDim2Indexes(rt.Str("dim2-indexes"))
+		if parseErr != nil {
+			return nil, sheetsValidationForFlag("dim2-indexes", "%v", parseErr)
+		}
+		for _, index := range dim2Indexes {
+			if index == dim1Index {
+				return nil, sheetsValidationForFlag(
+					"dim2-indexes",
+					"--dim2-indexes must not contain the dim1 index %d",
+					dim1Index,
+				)
+			}
+		}
+		updates["dim2_indexes"] = dim2Indexes
+	}
+	input := map[string]interface{}{
+		"excel_id":     token,
+		"operation":    "update",
+		"chart_id":     chartID,
+		"data_updates": updates,
+	}
+	sheetSelectorForToolInput(input, sheetID, sheetName)
+	if err := validateInputAgainstSchema(rt, input); err != nil {
+		return nil, err
+	}
+	return input, nil
+}
+
+func parseChartDim2Indexes(raw string) ([]int, error) {
+	parts := strings.Split(raw, ",")
+	indexes := make([]int, 0, len(parts))
+	seen := make(map[int]struct{}, len(parts))
+	for _, part := range parts {
+		value := strings.TrimSpace(part)
+		if value == "" {
+			return nil, common.ValidationErrorf("--dim2-indexes must be a comma-separated list of positive 1-based indexes")
+		}
+		index, err := strconv.Atoi(value)
+		if err != nil || index < 1 {
+			return nil, common.ValidationErrorf("--dim2-indexes must contain only positive 1-based indexes")
+		}
+		if _, exists := seen[index]; exists {
+			return nil, common.ValidationErrorf("--dim2-indexes must not contain duplicate index %d", index)
+		}
+		seen[index] = struct{}{}
+		indexes = append(indexes, index)
+	}
+	return indexes, nil
+}
+
+type chartDataRange struct {
+	sheet              string
+	row, col           int
+	rowCount, colCount int
+}
+
+func normalizeBasicChartDataRanges(dataRange, direction string) (normalized string, dimensionCount, dataPointCount int, err error) {
+	ranges, err := splitChartDataRanges(dataRange)
+	if err != nil {
+		return "", 0, 0, sheetsValidationForFlag("data-range", "invalid --data-range %q: %v", dataRange, err)
+	}
+	parsed := make([]chartDataRange, 0, len(ranges))
+	for _, value := range ranges {
+		item, parseErr := parseChartDataRange(value)
+		if parseErr != nil {
+			return "", 0, 0, sheetsValidationForFlag("data-range", "invalid --data-range item %q: %v", value, parseErr)
+		}
+		parsed = append(parsed, item)
+	}
+	first := parsed[0]
+	explicitSheet := ""
+	spans := make([][2]int, 0, len(parsed))
+	aligned := true
+	minRow, minCol := first.row, first.col
+	maxRow, maxCol := first.row+first.rowCount, first.col+first.colCount
+	for _, item := range parsed {
+		if item.sheet != "" {
+			if explicitSheet != "" && item.sheet != explicitSheet {
+				return "", 0, 0, sheetsValidationForFlag("data-range", "all --data-range items must belong to the same sheet")
+			}
+			explicitSheet = item.sheet
+		}
+		if direction == "row" {
+			if item.col != first.col || item.colCount != first.colCount {
+				aligned = false
+			}
+			dimensionCount += item.rowCount
+			spans = append(spans, [2]int{item.row, item.row + item.rowCount})
+		} else {
+			if item.row != first.row || item.rowCount != first.rowCount {
+				aligned = false
+			}
+			dimensionCount += item.colCount
+			spans = append(spans, [2]int{item.col, item.col + item.colCount})
+		}
+		minRow = min(minRow, item.row)
+		minCol = min(minCol, item.col)
+		maxRow = max(maxRow, item.row+item.rowCount)
+		maxCol = max(maxCol, item.col+item.colCount)
+	}
+	overlapping := false
+	for i, current := range spans {
+		for j := 0; j < i; j++ {
+			if current[0] < spans[j][1] && spans[j][0] < current[1] {
+				overlapping = true
+			}
+		}
+	}
+	normalized = strings.Join(ranges, ",")
+	if len(ranges) > 1 && (!aligned || overlapping) {
+		prefix := ""
+		if explicitSheet != "" {
+			prefix = explicitSheet + "!"
+		}
+		normalized = prefix + columnIndexToLetter(minCol) + strconv.Itoa(minRow+1) + ":" + columnIndexToLetter(maxCol-1) + strconv.Itoa(maxRow)
+		dimensionCount = maxCol - minCol
+		dataPointCount = maxRow - minRow
+		if direction == "row" {
+			dimensionCount, dataPointCount = dataPointCount, dimensionCount
+		}
+		return normalized, dimensionCount, dataPointCount, nil
+	}
+	if direction == "row" {
+		dataPointCount = first.colCount
+	} else {
+		dataPointCount = first.rowCount
+	}
+	return normalized, dimensionCount, dataPointCount, nil
+}
+
+func splitChartDataRanges(value string) ([]string, error) {
+	var ranges []string
+	start := 0
+	inQuote := false
+	for i := 0; i <= len(value); i++ {
+		if i < len(value) && value[i] == '\'' {
+			if inQuote && i+1 < len(value) && value[i+1] == '\'' {
+				i++
+			} else {
+				inQuote = !inQuote
+			}
+		}
+		if i == len(value) || (value[i] == ',' && !inQuote) {
+			part := strings.TrimSpace(value[start:i])
+			if part == "" {
+				return nil, common.ValidationErrorf("range list contains an empty item")
+			}
+			ranges = append(ranges, part)
+			start = i + 1
+		}
+	}
+	if inQuote {
+		return nil, common.ValidationErrorf("unterminated quoted sheet name")
+	}
+	return ranges, nil
+}
+
+func parseChartDataRange(value string) (chartDataRange, error) {
+	item := chartDataRange{}
+	ref := strings.TrimSpace(value)
+	if bang := strings.LastIndex(ref, "!"); bang >= 0 {
+		item.sheet = strings.TrimSpace(ref[:bang])
+		ref = strings.TrimSpace(ref[bang+1:])
+	}
+	parts := strings.SplitN(ref, ":", 2)
+	if len(parts) != 2 {
+		return item, common.ValidationErrorf("expected a rectangular A1 range such as A1:C10")
+	}
+	startCol, startRow, startOK := splitCellRef(parts[0])
+	endCol, endRow, endOK := splitCellRef(parts[1])
+	if !startOK || !endOK || endCol < startCol || endRow < startRow {
+		return item, common.ValidationErrorf("expected a rectangular A1 range such as A1:C10")
+	}
+	item.row, item.col = startRow, startCol
+	item.rowCount, item.colCount = endRow-startRow+1, endCol-startCol+1
+	return item, nil
+}
+
+func configureChartSemanticCommand(cmd *cobra.Command) {
+	if cmd.Flags().Lookup("stacked") == nil {
+		cmd.Flags().Bool("stacked", false, "compatibility alias for --stack normal")
+		_ = cmd.Flags().MarkHidden("stacked")
+	}
+	originalArgs := cmd.Args
+	cmd.Args = func(cmd *cobra.Command, args []string) error {
+		if len(args) == 1 && cmd.Flags().Changed("smooth") && (args[0] == "true" || args[0] == "false") {
+			return cmd.Flags().Set("smooth", args[0])
+		}
+		return originalArgs(cmd, args)
+	}
+	cmd.SetFlagErrorFunc(func(_ *cobra.Command, err error) error {
+		message := err.Error()
+		if strings.Contains(message, "unknown flag: --stacked") {
+			return sheetsValidationForFlag("stacked", "--stacked is not supported; use --stack normal (or --stack percent for 100%% stacking)")
+		}
+		return err
+	})
+}
+
+func addChartSemanticConfig(rt flagView, out map[string]interface{}) {
+	for _, flag := range chartSemanticConfigFlags {
+		if !rt.Changed(flag) {
+			continue
+		}
+		key := strings.ReplaceAll(flag, "-", "_")
+		if flag == "x-axis-label-angle" || flag == "y-axis-label-angle" {
+			out[key] = rt.Int(flag)
+		} else if flag == "data-labels" && rt.Str(flag) == "category_percentage" {
+			out[key] = "value_percentage"
+		} else {
+			out[key] = rt.Str(flag)
+		}
+	}
+	if rt.Changed("stacked") {
+		out["stack"] = "normal"
+	}
+	if rt.Changed("smooth") {
+		out["smooth"] = rt.Bool("smooth")
+	}
+	if rt.Changed("colors") {
+		out["colors"] = normalizedChartColors(rt)
+	}
+}
+
+func validateChartSemanticEnums(rt flagView) error {
+	if rt.Changed("stack") && rt.Changed("stacked") {
+		return common.ValidationErrorf("--stack and --stacked are mutually exclusive").WithParams(
+			sheetsInvalidParam("stack", "cannot be used with --stacked"),
+			sheetsInvalidParam("stacked", "cannot be used with --stack"),
+		)
+	}
+	return nil
+}
+
+func validateChartColorFlags(rt flagView) error {
+	if rt.Changed("color-palette") && rt.Changed("colors") {
+		return common.ValidationErrorf("--color-palette and --colors are mutually exclusive").WithParams(
+			sheetsInvalidParam("color-palette", "cannot be used with --colors"),
+			sheetsInvalidParam("colors", "cannot be used with --color-palette"),
+		)
+	}
+	if rt.Changed("colors") {
+		colors := normalizedChartColors(rt)
+		if len(colors) < 2 {
+			return sheetsValidationForFlag("colors", "--colors must contain at least two hex colors")
+		}
+		for _, color := range colors {
+			if !chartHexColorPattern.MatchString(color) {
+				return sheetsValidationForFlag("colors", "--colors contains invalid hex color %q", color)
+			}
+		}
+	}
+	return nil
+}
+
+func normalizedChartColors(rt flagView) []string {
+	raw := rt.StrSlice("colors")
+	colors := make([]string, len(raw))
+	for i := range raw {
+		colors[i] = strings.TrimSpace(raw[i])
+	}
+	return colors
+}

shortcuts/sheets/lark_sheet_chart_test.go

@@ -0,0 +1,346 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import "testing"
+
+func TestChartCreateBasic_AllTypes(t *testing.T) {
+	t.Parallel()
+
+	types := []string{"column", "bar", "line", "area", "pie", "scatter", "combo", "radar"}
+	for _, chartType := range types {
+		chartType := chartType
+		t.Run(chartType, func(t *testing.T) {
+			t.Parallel()
+			rangeValue := "A1:C4"
+			if chartType == "combo" {
+				rangeValue = "A1:D4"
+			}
+			body := parseDryRunBody(t, ChartCreateBasic, []string{
+				"--url", testURL,
+				"--sheet-id", testSheetID,
+				"--chart-type", chartType,
+				"--data-range", rangeValue,
+			})
+			input := decodeToolInput(t, body, "manage_chart_object")
+			if input["operation"] != "create" {
+				t.Fatalf("operation = %v, want create", input["operation"])
+			}
+			if _, ok := input["properties"]; ok {
+				t.Fatal("semantic create must not send properties")
+			}
+			basic, _ := input["basic_chart"].(map[string]interface{})
+			if basic["chart_type"] != chartType || basic["data_range"] != rangeValue {
+				t.Fatalf("basic_chart = %#v", basic)
+			}
+		})
+	}
+}
+
+func TestChartCreateBasic_ConfigAndPlacement(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartCreateBasic, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-type", "line",
+		"--data-range", "A1:C4",
+		"--anchor-cell", "f2",
+		"--width", "640",
+		"--height", "360",
+		"--title", "Trend",
+		"--legend-position", "bottom",
+		"--smooth=false",
+		"--data-direction", "row",
+		"--color-palette", "brandColorSeries@v2",
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	basic, _ := input["basic_chart"].(map[string]interface{})
+	position, _ := basic["position"].(map[string]interface{})
+	size, _ := basic["size"].(map[string]interface{})
+	if position["col"] != "F" || position["row"] != float64(1) {
+		t.Errorf("position = %#v, want F2 as zero-based row 1", position)
+	}
+	if size["width"] != float64(640) || size["height"] != float64(360) {
+		t.Errorf("size = %#v", size)
+	}
+	if basic["title"] != "Trend" || basic["legend_position"] != "bottom" || basic["smooth"] != false ||
+		basic["data_direction"] != "row" || basic["color_palette"] != "brandColorSeries@v2" {
+		t.Errorf("semantic config = %#v", basic)
+	}
+}
+
+func TestChartCreateBasic_MultipleAlignedRanges(t *testing.T) {
+	t.Parallel()
+	rangeValue := "'Data, 2026'!A1:A10,'Data, 2026'!K1:L10"
+	body := parseDryRunBody(t, ChartCreateBasic, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-type", "line",
+		"--data-range", rangeValue,
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	basic := input["basic_chart"].(map[string]interface{})
+	if basic["data_range"] != rangeValue {
+		t.Fatalf("basic_chart.data_range = %v, want %q", basic["data_range"], rangeValue)
+	}
+}
+
+func TestChartCreateBasic_MergesMisalignedOrOverlappingRanges(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{name: "separated rows", input: "'Sheet1'!A1:M1,'Sheet1'!A3:M3", expected: "'Sheet1'!A1:M3"},
+		{name: "overlapping columns", input: "A1:B10,B1:C10", expected: "A1:C10"},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			body := parseDryRunBody(t, ChartCreateBasic, []string{
+				"--url", testURL,
+				"--sheet-id", testSheetID,
+				"--chart-type", "line",
+				"--data-range", tt.input,
+			})
+			input := decodeToolInput(t, body, "manage_chart_object")
+			basic := input["basic_chart"].(map[string]interface{})
+			if basic["data_range"] != tt.expected {
+				t.Fatalf("basic_chart.data_range = %v, want %q", basic["data_range"], tt.expected)
+			}
+		})
+	}
+}
+
+func TestChartCreateBasic_RejectsCrossSheetRanges(t *testing.T) {
+	t.Parallel()
+	_, _, err := runShortcutCapturingErr(t, ChartCreateBasic, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-type", "line",
+		"--data-range", "'A'!A1:A10,'B'!C1:D10",
+	})
+	if err == nil {
+		t.Fatal("expected cross-sheet ranges to fail")
+	}
+}
+
+func TestChartSemanticShortcuts_InBatchUpdate(t *testing.T) {
+	body := parseDryRunBody(t, BatchUpdate, []string{
+		"--url", testURL,
+		"--operations", `[
+			{"shortcut":"+chart-create-basic","input":{"sheet-id":"sh1","chart-type":"column","data-range":"A1:C10","title":"Sales"}},
+			{"shortcut":"+chart-create-basic","input":{"sheet-id":"sh1","chart-type":"line","data-range":"E1:G10","title":"Trend"}}
+		]`,
+		"--yes",
+	})
+	input := decodeToolInput(t, body, "batch_update")
+	ops := input["operations"].([]interface{})
+	if len(ops) != 2 {
+		t.Fatalf("operations len = %d, want 2", len(ops))
+	}
+	for i, op := range ops {
+		item := op.(map[string]interface{})
+		if item["tool_name"] != "manage_chart_object" {
+			t.Fatalf("operations[%d].tool_name = %v", i, item["tool_name"])
+		}
+		chartInput := item["input"].(map[string]interface{})
+		if chartInput["operation"] != "create" {
+			t.Fatalf("operations[%d].input.operation = %v", i, chartInput["operation"])
+		}
+		if _, ok := chartInput["basic_chart"].(map[string]interface{}); !ok {
+			t.Fatalf("operations[%d].input.basic_chart = %#v", i, chartInput["basic_chart"])
+		}
+	}
+}
+
+func TestChartConfigUpdate_PartialFields(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartConfigUpdate, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-id", "chart-1",
+		"--y-axis-title", "Revenue",
+		"--stack", "percent",
+		"--smooth=false",
+		"--colors", "#112233,#445566",
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	if input["operation"] != "update" || input["chart_id"] != "chart-1" {
+		t.Fatalf("input = %#v", input)
+	}
+	if _, ok := input["properties"]; ok {
+		t.Fatal("semantic update must not send properties")
+	}
+	updates, _ := input["config_updates"].(map[string]interface{})
+	if updates["y_axis_title"] != "Revenue" || updates["stack"] != "percent" || updates["smooth"] != false {
+		t.Errorf("config_updates = %#v", updates)
+	}
+	colors, _ := updates["colors"].([]interface{})
+	if len(colors) != 2 || colors[0] != "#112233" || colors[1] != "#445566" {
+		t.Errorf("config_updates.colors = %#v", updates["colors"])
+	}
+}
+
+func TestChartConfigUpdate_SpacedSmoothBool(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartConfigUpdate, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-id", "chart-1",
+		"--smooth", "false",
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	updates := input["config_updates"].(map[string]interface{})
+	if updates["smooth"] != false {
+		t.Fatalf("config_updates.smooth = %v, want false", updates["smooth"])
+	}
+}
+
+func TestChartSemanticShortcuts_CompatibleAliases(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartConfigUpdate, []string{
+		"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1", "--stacked",
+	})
+	updates := decodeToolInput(t, body, "manage_chart_object")["config_updates"].(map[string]interface{})
+	if updates["stack"] != "normal" {
+		t.Fatalf("--stacked normalized stack = %v, want normal", updates["stack"])
+	}
+	body = parseDryRunBody(t, ChartConfigUpdate, []string{
+		"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1", "--data-labels", "category_percentage",
+	})
+	updates = decodeToolInput(t, body, "manage_chart_object")["config_updates"].(map[string]interface{})
+	if updates["data_labels"] != "value_percentage" {
+		t.Fatalf("data-labels normalized value = %v, want value_percentage", updates["data_labels"])
+	}
+}
+
+func TestChartSemanticShortcuts_CompatibleAliasesInBatch(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, BatchUpdate, []string{
+		"--url", testURL,
+		"--operations", `[{"shortcut":"+chart-config-update","input":{"sheet_id":"sh1","chart_id":"chart-1","stacked":true,"data_labels":"category_percentage","smooth":false}}]`,
+		"--yes",
+	})
+	input := decodeToolInput(t, body, "batch_update")
+	ops := input["operations"].([]interface{})
+	chartInput := ops[0].(map[string]interface{})["input"].(map[string]interface{})
+	updates := chartInput["config_updates"].(map[string]interface{})
+	if updates["stack"] != "normal" || updates["data_labels"] != "value_percentage" || updates["smooth"] != false {
+		t.Fatalf("batch config_updates = %#v", updates)
+	}
+}
+
+func TestChartDataUpdate_PreservesSnapshotServerSide(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartDataUpdate, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-id", "chart-1",
+		"--data-range", "'Sheet1'!A1:M6",
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	if input["operation"] != "update" || input["chart_id"] != "chart-1" {
+		t.Fatalf("input = %#v", input)
+	}
+	if _, ok := input["properties"]; ok {
+		t.Fatal("semantic data update must not send properties")
+	}
+	updates, _ := input["data_updates"].(map[string]interface{})
+	if updates["data_range"] != "'Sheet1'!A1:M6" {
+		t.Errorf("data_updates = %#v", updates)
+	}
+	if _, ok := updates["data_direction"]; ok {
+		t.Errorf("omitted --data-direction must preserve the server-side direction: %#v", updates)
+	}
+}
+
+func TestChartDataUpdate_ExplicitDirectionAndMultipleRanges(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartDataUpdate, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-id", "chart-1",
+		"--data-range", "'Sheet1'!A1:A10,'Sheet1'!K1:L10",
+		"--data-direction", "column",
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	updates := input["data_updates"].(map[string]interface{})
+	if updates["data_range"] != "'Sheet1'!A1:A10,'Sheet1'!K1:L10" || updates["data_direction"] != "column" {
+		t.Errorf("data_updates = %#v", updates)
+	}
+}
+
+func TestChartDataUpdate_ExplicitSeriesIndexes(t *testing.T) {
+	t.Parallel()
+	body := parseDryRunBody(t, ChartDataUpdate, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-id", "chart-1",
+		"--data-range", "'Sheet1'!A1:M6",
+		"--dim1-index", "1",
+		"--dim2-indexes", "4, 8",
+	})
+	input := decodeToolInput(t, body, "manage_chart_object")
+	updates := input["data_updates"].(map[string]interface{})
+	if updates["dim1_index"] != float64(1) {
+		t.Errorf("data_updates.dim1_index = %#v", updates["dim1_index"])
+	}
+	indexes, _ := updates["dim2_indexes"].([]interface{})
+	if len(indexes) != 2 || indexes[0] != float64(4) || indexes[1] != float64(8) {
+		t.Errorf("data_updates.dim2_indexes = %#v", updates["dim2_indexes"])
+	}
+}
+
+func TestChartSemanticShortcuts_Validation(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		args []string
+	}{
+		{name: "unsupported type", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "donut", "--data-range", "A1:C4"}},
+		{name: "invalid semantic enum", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "line", "--data-range", "A1:C4", "--legend-position", "diagonal"}},
+		{name: "range too small", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "line", "--data-range", "A1:A4"}},
+		{name: "combo needs two series", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "combo", "--data-range", "A1:B4"}},
+		{name: "invalid direction", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "line", "--data-range", "A1:C4", "--data-direction", "horizontal"}},
+		{name: "colors need two values", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "line", "--data-range", "A1:C4", "--colors", "#112233"}},
+		{name: "palette and colors are exclusive", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "line", "--data-range", "A1:C4", "--color-palette", "brandColorSeries@v2", "--colors", "#112233,#445566"}},
+		{name: "size must be paired", args: []string{"--url", testURL, "--sheet-id", testSheetID, "--chart-type", "line", "--data-range", "A1:C4", "--width", "640"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, _, err := runShortcutCapturingErr(t, ChartCreateBasic, tt.args)
+			if err == nil {
+				t.Fatal("expected validation error")
+			}
+		})
+	}
+
+	_, _, err := runShortcutCapturingErr(t, ChartConfigUpdate, []string{
+		"--url", testURL,
+		"--sheet-id", testSheetID,
+		"--chart-id", "chart-1",
+	})
+	if err == nil {
+		t.Fatal("expected config update with no changed field to fail")
+	}
+
+	for _, args := range [][]string{
+		{"--url", testURL, "--sheet-id", testSheetID, "--data-range", "A1:C4"},
+		{"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1"},
+		{"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1", "--data-range", "A1:C4", "--data-direction", "horizontal"},
+		{"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1", "--data-range", "A1:C4", "--dim1-index", "0"},
+		{"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1", "--data-range", "A1:C4", "--dim2-indexes", "2,2"},
+		{"--url", testURL, "--sheet-id", testSheetID, "--chart-id", "chart-1", "--data-range", "A1:C4", "--dim2-indexes", "1,2"},
+	} {
+		_, _, err = runShortcutCapturingErr(t, ChartDataUpdate, args)
+		if err == nil {
+			t.Fatalf("expected chart data update validation error for args %#v", args)
+		}
+	}
+}

shortcuts/sheets/lark_sheet_read_data.go

@@ -83,11 +83,6 @@ func cellsGetInput(runtime *common.RuntimeContext, token, sheetID, sheetName str
 	if runtime.Bool("skip-hidden") {
 		input["skip_hidden"] = true
 	}
-	// Preserve omission so the tool can keep the legacy fallback where
-	// skip_filter inherits skip_hidden. An explicit false must still be sent.
-	if runtime.Changed("skip-filter") {
-		input["skip_filter"] = runtime.Bool("skip-filter")
-	}
 	// --cell-limit was removed from the CLI surface; --max-chars is the single
 	// read cap. Pin cell_limit very high so the tool's own default never binds
 	// before max_chars.
@@ -148,6 +143,9 @@ var CsvGet = common.Shortcut{
 		if _, _, err := resolveSheetSelector(runtime); err != nil {
 			return err
 		}
+		if strings.TrimSpace(runtime.Str("range")) == "" {
+			return sheetsValidationForFlag("range", "--range is required")
+		}
 		return nil
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
@@ -175,21 +173,11 @@ var CsvGet = common.Shortcut{
 	},
 }
 
-// csvGetFullSheetRange is the range sent when --range is omitted: the tool
-// requires one, but clips anything past the grid bounds and reports the clip
-// in actual_range — so an over-wide whole-columns range reads the entire
-// sheet in one call, with no workbook-info pre-flight. Eval traces show
-// "read the whole sheet" as a recurring intent (--range was the single most
-// missed required flag once the rest of the surface was fixed).
-const csvGetFullSheetRange = "A:ZZZ"
-
 func csvGetInput(runtime *common.RuntimeContext, token, sheetID, sheetName string) map[string]interface{} {
 	input := map[string]interface{}{"excel_id": token}
 	sheetSelectorForToolInput(input, sheetID, sheetName)
 	if r := strings.TrimSpace(runtime.Str("range")); r != "" {
 		input["range"] = r
-	} else {
-		input["range"] = csvGetFullSheetRange
 	}
 	if runtime.Bool("skip-hidden") {
 		input["skip_hidden"] = true

shortcuts/sheets/lark_sheet_read_data_test.go

@@ -34,25 +34,6 @@ func TestReadDataShortcuts_DryRun(t *testing.T) {
 				"cell_limit":          float64(unboundedReadLimit), // pinned high; --max-chars is the only cap
 			},
 		},
-		{
-			name:     "+cells-get skip filtered rows only",
-			sc:       CellsGet,
-			args:     []string{"--url", testURL, "--sheet-id", testSheetID, "--range", "A1:B2", "--skip-filter"},
-			toolName: "get_cell_ranges",
-			wantInput: map[string]interface{}{
-				"skip_filter": true,
-			},
-		},
-		{
-			name:     "+cells-get skip hidden but keep filtered rows",
-			sc:       CellsGet,
-			args:     []string{"--url", testURL, "--sheet-id", testSheetID, "--range", "A1:B2", "--skip-hidden", "--skip-filter=false"},
-			toolName: "get_cell_ranges",
-			wantInput: map[string]interface{}{
-				"skip_hidden": true,
-				"skip_filter": false,
-			},
-		},
 		{
 			// --include truncation toggles include_truncation_info so the tool
 			// estimates and returns per-cell isRowTruncated / isColTruncated.
@@ -109,17 +90,6 @@ func TestReadDataShortcuts_DryRun(t *testing.T) {
 	}
 }
 
-func TestCellsGet_OmitsSkipFilterWhenUnset(t *testing.T) {
-	t.Parallel()
-	body := parseDryRunBody(t, CellsGet, []string{
-		"--url", testURL, "--sheet-id", testSheetID, "--range", "A1:B2",
-	})
-	got := decodeToolInput(t, body, "get_cell_ranges")
-	if _, ok := got["skip_filter"]; ok {
-		t.Fatalf("skip_filter must be omitted when --skip-filter is unset: %#v", got)
-	}
-}
-
 // TestDropdownGet_RequiresSheetSelector locks the +cells-get-style
 // selector contract: at least one of --sheet-id / --sheet-name must be
 // supplied. Before BUG-019 fix this shortcut required a "Sheet!A1"
@@ -138,9 +108,7 @@ func TestDropdownGet_RequiresSheetSelector(t *testing.T) {
 
 // TestReadData_RequiresRange covers the trim-based --range guard on the
 // single-range readers (--range "" slips past cobra's MarkFlagRequired but
-// must still be rejected by Validate). +csv-get is deliberately absent:
-// its --range is optional — omitted/blank means a whole-sheet read (see
-// TestCsvGet_RangeOptionalDefaultsToFullSheet).
+// must still be rejected by Validate).
 func TestReadData_RequiresRange(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
@@ -148,6 +116,7 @@ func TestReadData_RequiresRange(t *testing.T) {
 		sc   common.Shortcut
 	}{
 		{"+cells-get", CellsGet},
+		{"+csv-get", CsvGet},
 		{"+dropdown-get", DropdownGet},
 	}
 	for _, c := range cases {
@@ -161,23 +130,6 @@ func TestReadData_RequiresRange(t *testing.T) {
 	}
 }
 
-// TestCsvGet_RangeOptionalDefaultsToFullSheet pins the whole-sheet default:
-// with --range omitted the request carries the over-wide clip range, so a
-// full read needs no workbook-info pre-flight (eval: --range was the most
-// missed required flag on +csv-get once the rest of the surface settled).
-func TestCsvGet_RangeOptionalDefaultsToFullSheet(t *testing.T) {
-	t.Parallel()
-	stdout, _, err := runShortcutCapturingErr(t, CsvGet, []string{
-		"--url", testURL, "--sheet-id", testSheetID, "--dry-run",
-	})
-	if err != nil {
-		t.Fatalf("rangeless +csv-get must pass validation, got: %v", err)
-	}
-	if !strings.Contains(stdout, csvGetFullSheetRange) {
-		t.Fatalf("dry-run body should carry the full-sheet range %q, got %q", csvGetFullSheetRange, stdout)
-	}
-}
-
 // TestInfoTypeFromInclude exercises the fine-grained → coarse mapping
 // directly (white-box).
 func TestInfoTypeFromInclude(t *testing.T) {

shortcuts/sheets/lark_sheet_sheet_structure.go

@@ -6,7 +6,6 @@ package sheets
 import (
 	"context"
 	"fmt"
-	"sort"
 	"strconv"
 	"strings"
 
@@ -138,11 +137,7 @@ var DimInsert = common.Shortcut{
 		token, _ := resolveSpreadsheetToken(runtime)
 		sheetID, sheetName, _ := resolveSheetSelector(runtime)
 		input, _ := dimInsertInput(runtime, token, sheetID, sheetName)
-		dr := invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
-		if dimInsertNeedsBeforeStyleWarning(runtime) {
-			dr.Set("warning_message", dimInsertBeforeStyleWarning)
-		}
-		return dr
+		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		token, err := resolveSpreadsheetTokenExec(runtime)
@@ -157,9 +152,6 @@ var DimInsert = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		if dimInsertNeedsBeforeStyleWarning(runtime) {
-			fmt.Fprintln(runtime.IO().ErrOut, dimInsertBeforeStyleWarning)
-		}
 		out, err := callTool(ctx, runtime, token, ToolKindWrite, "modify_sheet_structure", input)
 		if err != nil {
 			return err
@@ -169,31 +161,8 @@ var DimInsert = common.Shortcut{
 	},
 }
 
-// dimInsertBeforeStyleWarning fires only when the preceding-side style cannot
-// be copied: --inherit-style before at the first row/column, where no
-// preceding row/column exists. The row/column is still inserted before
-// --position, just without style inheritance. (--inherit-style after has no
-// such edge — a plain before-insert always has a following row/column.)
-const dimInsertBeforeStyleWarning = "warning: --inherit-style before cannot copy the preceding row/column's style at the first row/column (no preceding row/column exists); inserting before --position without style inheritance. Copy styles separately if needed."
-
-func dimInsertNeedsBeforeStyleWarning(runtime flagView) bool {
-	if !runtime.Changed("inherit-style") || runtime.Str("inherit-style") != "before" {
-		return false
-	}
-	// Only the first row/column (idx 0) has no preceding row/column.
-	_, idx, err := parseA1Position(strings.TrimSpace(runtime.Str("position")))
-	return err == nil && idx == 0
-}
-
 // dimInsertInput passes --position (1-based row number "3" or column letter
-// "C") to the tool's `position` field; --count maps to `count`.
-//
-// +dim-insert's public contract is always "insert before --position";
-// --inherit-style only selects which side's style the new row/column copies,
-// never the insertion side. The sheet-ai tool always copies the *anchor*
-// column's style (the target passed as position), regardless of side — so
-// --inherit-style before is emulated by anchoring one unit earlier. See the
-// switch below.
+// "C") straight to the tool's `position` field; --count maps to `count`.
 func dimInsertInput(runtime flagView, token, sheetID, sheetName string) (map[string]interface{}, error) {
 	if err := requireSheetSelector(sheetID, sheetName); err != nil {
 		return nil, err
@@ -219,27 +188,11 @@ func dimInsertInput(runtime flagView, token, sheetID, sheetName string) (map[str
 		"count":     count,
 	}
 	sheetSelectorForToolInput(input, sheetID, sheetName)
-	// --inherit-style selects which side's style the blank row/column copies;
-	// the insertion always lands *before* --position. Empirically the addCol
-	// backend copies the *anchor* column's style (the target passed as
-	// position), regardless of side — side only decides whether the blank lands
-	// before or after that anchor (verified live, see
-	// TestDimInsertInheritStyleSideMapping):
-	//   after  → side=before at P: the blank lands at P and anchor P becomes the
-	//            *following* neighbour, so the blank copies it. Position unchanged.
-	//   before → side=after at P-1: the blank still lands at P (insert-after-(P-1)
-	//            == insert-before-P) and anchor P-1 becomes the *preceding*
-	//            neighbour, so the blank copies it.
 	switch runtime.Str("inherit-style") {
-	case "after":
-		input["side"] = "before"
 	case "before":
-		if prev, ok := a1PositionBefore(position); ok {
-			input["side"] = "after"
-			input["position"] = prev
-		}
-		// First row/column: no preceding row/column exists, so fall back to a
-		// plain before-insert (dimInsertNeedsBeforeStyleWarning surfaces this).
+		input["side"] = "before"
+	case "after":
+		input["side"] = "after"
 	}
 	return input, nil
 }
@@ -254,34 +207,10 @@ var DimDelete = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	HasFormat:   true,
 	Flags:       flagsFor("+dim-delete"),
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if runtime.Changed("ranges") {
-			if runtime.Changed("range") {
-				return sheetsValidationForFlag("ranges", "--range and --ranges are mutually exclusive; put every range into --ranges")
-			}
-			token, err := resolveSpreadsheetToken(runtime)
-			if err != nil {
-				return err
-			}
-			sheetID, sheetName, err := resolveSheetSelector(runtime)
-			if err != nil {
-				return err
-			}
-			_, err = dimDeleteRangesOps(runtime, token, sheetID, sheetName)
-			return err
-		}
-		return validateDimRangeOp("delete")(ctx, runtime)
-	},
+	Validate:    validateDimRangeOp("delete"),
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		token, _ := resolveSpreadsheetToken(runtime)
 		sheetID, sheetName, _ := resolveSheetSelector(runtime)
-		if runtime.Changed("ranges") {
-			ops, _ := dimDeleteRangesOps(runtime, token, sheetID, sheetName)
-			return invokeToolDryRun(token, ToolKindWrite, "batch_update", map[string]interface{}{
-				"excel_id":   token,
-				"operations": ops,
-			})
-		}
 		input, _ := dimRangeOpInput(runtime, token, sheetID, sheetName, "delete")
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
@@ -294,21 +223,6 @@ var DimDelete = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		if runtime.Changed("ranges") {
-			ops, err := dimDeleteRangesOps(runtime, token, sheetID, sheetName)
-			if err != nil {
-				return err
-			}
-			out, err := callTool(ctx, runtime, token, ToolKindWrite, "batch_update", map[string]interface{}{
-				"excel_id":   token,
-				"operations": ops,
-			})
-			if err != nil {
-				return err
-			}
-			runtime.Out(out, nil)
-			return nil
-		}
 		input, err := dimRangeOpInput(runtime, token, sheetID, sheetName, "delete")
 		if err != nil {
 			return err
@@ -322,76 +236,9 @@ var DimDelete = common.Shortcut{
 	},
 	Tips: []string{
 		"Row/column deletion is irreversible. Always preview with --dry-run first.",
-		`Scattered ranges: --ranges '["5:5","8:8","11:13"]' deletes them in one atomic call — the CLI orders positions descending, so indexes never shift under you.`,
 	},
 }
 
-// dimDeleteRangesOps parses --ranges into one atomic batch of
-// modify_sheet_structure delete ops, ordered DESCENDING by start position:
-// deleting an earlier row shifts every later index up, so ascending
-// execution deletes the wrong rows — the recurring failure of hand-built
-// dim-delete batches in eval traces. Same-dimension and non-overlap are
-// enforced up front.
-func dimDeleteRangesOps(runtime flagView, token, sheetID, sheetName string) ([]interface{}, error) {
-	if err := requireSheetSelector(sheetID, sheetName); err != nil {
-		return nil, err
-	}
-	raw, err := requireJSONArray(runtime, "ranges")
-	if err != nil {
-		return nil, err
-	}
-	if len(raw) == 0 {
-		return nil, sheetsValidationForFlag("ranges", "--ranges must be a non-empty JSON array")
-	}
-	if len(raw) > maxBatchRanges {
-		return nil, sheetsValidationForFlag("ranges", "--ranges accepts at most %d entries; got %d", maxBatchRanges, len(raw))
-	}
-	type span struct {
-		raw        string
-		start, end int
-	}
-	spans := make([]span, 0, len(raw))
-	dimension := ""
-	for i, v := range raw {
-		s, ok := v.(string)
-		if !ok {
-			return nil, sheetsValidationForFlag("ranges", "--ranges[%d] must be a string", i)
-		}
-		dim, start, end, err := parseA1Range(s)
-		if err != nil {
-			return nil, sheetsValidationForFlag("ranges", "--ranges[%d] %q: %v", i, s, err)
-		}
-		if dimension == "" {
-			dimension = dim
-		} else if dim != dimension {
-			return nil, sheetsValidationForFlag("ranges", "--ranges[%d] %q is a %s range but earlier entries are %s ranges; one call deletes rows OR columns, not both", i, s, dim, dimension)
-		}
-		spans = append(spans, span{raw: strings.TrimSpace(s), start: start, end: end})
-	}
-	sort.Slice(spans, func(i, j int) bool { return spans[i].start > spans[j].start })
-	for i := 1; i < len(spans); i++ {
-		// Descending order: spans[i-1] starts at or after spans[i]. Overlap
-		// (or duplicate) makes the later delete hit already-shifted positions.
-		if spans[i].end >= spans[i-1].start {
-			return nil, sheetsValidationForFlag("ranges", "--ranges entries %q and %q overlap; merge them into one range", spans[i].raw, spans[i-1].raw)
-		}
-	}
-	ops := make([]interface{}, 0, len(spans))
-	for _, sp := range spans {
-		input := map[string]interface{}{
-			"excel_id":  token,
-			"operation": "delete",
-			"range":     sp.raw,
-		}
-		sheetSelectorForToolInput(input, sheetID, sheetName)
-		ops = append(ops, map[string]interface{}{
-			"tool_name": "modify_sheet_structure",
-			"input":     input,
-		})
-	}
-	return ops, nil
-}
-
 // validateDimRangeOp returns a Validate closure that delegates to
 // dimRangeOpInput for shortcuts (delete/hide/unhide) whose builder takes an
 // extra `op` argument. Token check happens here; the rest is the builder.
@@ -717,23 +564,6 @@ func columnIndexToLetter(idx int) string {
 	return string(out)
 }
 
-// a1PositionBefore returns the A1 position one unit before s ("6" → "5",
-// "C" → "B"), preserving row/column form. ok is false when s is the first
-// row/column (row 1 / column A) — no earlier position — or is not a valid A1
-// position. Callers validate via parseA1Position first, so in practice ok is
-// false only at the first row/column.
-func a1PositionBefore(s string) (pos string, ok bool) {
-	dimension, idx, err := parseA1Position(s)
-	if err != nil || idx == 0 {
-		return "", false
-	}
-	if dimension == "row" {
-		// idx is 0-based; the 1-based number one row earlier is idx itself.
-		return strconv.Itoa(idx), true
-	}
-	return columnIndexToLetter(idx - 1), true
-}
-
 // ─── +dim-move (native v3 move_dimension, cli_status: cli-only) ──────
 //
 // Moves a contiguous block of rows or columns to a new index in the same

shortcuts/sheets/lark_sheet_sheet_structure_test.go

@@ -48,8 +48,6 @@ func TestSheetStructureShortcuts_DryRun(t *testing.T) {
 			},
 		},
 		{
-			// --inherit-style before copies the preceding row: anchor row 5 and
-			// insert after it (side=after), so the blank still lands before row 6.
 			name:     "+dim-insert row position=6 count=3 inherit-before",
 			sc:       DimInsert,
 			args:     []string{"--url", testURL, "--sheet-id", testSheetID, "--position", "6", "--count", "3", "--inherit-style", "before"},
@@ -58,9 +56,9 @@ func TestSheetStructureShortcuts_DryRun(t *testing.T) {
 				"excel_id":  testToken,
 				"operation": "insert",
 				"sheet_id":  testSheetID,
-				"position":  "5",
+				"position":  "6",
 				"count":     float64(3),
-				"side":      "after",
+				"side":      "before",
 			},
 		},
 		{
@@ -171,93 +169,6 @@ func TestSheetStructureShortcuts_DryRun(t *testing.T) {
 	}
 }
 
-func TestDimInsertInheritStyleSideMapping(t *testing.T) {
-	t.Parallel()
-
-	cases := []struct {
-		name         string
-		position     string
-		inherit      string
-		wantPosition string
-		wantSide     string
-		wantSideSet  bool
-	}{
-		{
-			name:         "after copies the following style with a plain before-insert, position unchanged",
-			position:     "D",
-			inherit:      "after",
-			wantPosition: "D",
-			wantSide:     "before",
-			wantSideSet:  true,
-		},
-		{
-			name:         "before anchors one column earlier (side=after) to copy the preceding style",
-			position:     "D",
-			inherit:      "before",
-			wantPosition: "C",
-			wantSide:     "after",
-			wantSideSet:  true,
-		},
-		{
-			name:         "before on a row anchors one row earlier",
-			position:     "6",
-			inherit:      "before",
-			wantPosition: "5",
-			wantSide:     "after",
-			wantSideSet:  true,
-		},
-		{
-			name:         "before at the first column falls back to a plain before-insert",
-			position:     "A",
-			inherit:      "before",
-			wantPosition: "A",
-			wantSideSet:  false,
-		},
-		{
-			name:         "after at the first column still works (before-insert anchors the following)",
-			position:     "A",
-			inherit:      "after",
-			wantPosition: "A",
-			wantSide:     "before",
-			wantSideSet:  true,
-		},
-		{
-			name:         "default (flag omitted) omits side, backend inherits the following row/column",
-			position:     "D",
-			wantPosition: "D",
-			wantSideSet:  false,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			args := []string{"--url", testURL, "--sheet-id", testSheetID, "--position", tc.position, "--count", "1"}
-			if tc.inherit != "" {
-				args = append(args, "--inherit-style", tc.inherit)
-			}
-			body := parseDryRunBody(t, DimInsert, args)
-			got := decodeToolInput(t, body, "modify_sheet_structure")
-			assertInputEquals(t, got, map[string]interface{}{
-				"excel_id":  testToken,
-				"operation": "insert",
-				"sheet_id":  testSheetID,
-				"position":  tc.wantPosition,
-				"count":     float64(1),
-			})
-
-			gv, ok := got["side"]
-			if ok != tc.wantSideSet {
-				t.Fatalf("side presence = %v, want %v (input=%#v)", ok, tc.wantSideSet, got)
-			}
-			if ok && gv != tc.wantSide {
-				t.Fatalf("side = %v, want %q", gv, tc.wantSide)
-			}
-		})
-	}
-}
-
 // TestDimRange_Validation covers the A1 range parser's edge cases routed
 // through +dim-hide (any --range shortcut works; we just need to exercise
 // the validator).

shortcuts/sheets/lark_sheet_styles_put.go

@@ -1,272 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// ─── +styles-put ──────────────────────────────────────────────────────
-//
-// Declarative visual spec for EXISTING spreadsheets. Eval attribution
-// showed ~73% of real +batch-update calls were pure formatting finishers
-// (style stamps + merges + resizes + freeze) hand-assembled as imperative
-// operations arrays — the top error surface. +styles-put replaces that
-// with the {styles:[...]} protocol already shared by +workbook-create /
-// +table-put --styles (identical vocabulary, parsed by the same
-// parseWorkbookCreateStyleItem), applied to a live workbook and expanded
-// client-side into ONE atomic batch_update.
-//
-// Per-sheet expansion order (server behavior verified live: style stamps
-// over merged regions are allowed — the top-left-only restriction applies
-// to value writes, not styles):
-//
-//	cell_merges → cell_styles → row_sizes → col_sizes → freeze
-var StylesPut = common.Shortcut{
-	Service:     "sheets",
-	Command:     "+styles-put",
-	Description: "Apply one declarative visual spec (styles/merges/row-col sizes/freeze) to existing sheets in one atomic batch.",
-	Risk:        "write",
-	Scopes:      []string{"sheets:spreadsheet:write_only"},
-	AuthTypes:   []string{"user", "bot"},
-	HasFormat:   true,
-	Flags:       flagsFor("+styles-put"),
-	Tips: []string{
-		`Example: lark-cli sheets +styles-put --url <URL> --styles '{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:F1","font_weight":"bold"}],"freeze":{"rows":1}}]}'`,
-		"Same --styles vocabulary as +workbook-create / +table-put; one item per target sheet, name = the real sheet name.",
-		"Style stamps are safe to re-run; the whole spec goes out as one atomic batch.",
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
-		if err != nil {
-			return err
-		}
-		_, err = stylesPutOperations(runtime, token)
-		return err
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		token, _ := resolveSpreadsheetToken(runtime)
-		ops, _ := stylesPutOperations(runtime, token)
-		return invokeToolDryRun(token, ToolKindWrite, "batch_update", map[string]interface{}{
-			"excel_id":   token,
-			"operations": ops,
-		})
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetTokenExec(runtime)
-		if err != nil {
-			return err
-		}
-		ops, err := stylesPutOperations(runtime, token)
-		if err != nil {
-			return err
-		}
-		out, err := callTool(ctx, runtime, token, ToolKindWrite, "batch_update", map[string]interface{}{
-			"excel_id":   token,
-			"operations": ops,
-		})
-		if err != nil {
-			return err
-		}
-		runtime.Out(out, nil)
-		return nil
-	},
-}
-
-// stylesPutOperations parses --styles ({styles:[...]}, one item per target
-// sheet) and expands it into the MCP batch_update operations array. Reuses
-// the shared workbook-create style item parser, so field validation, alias
-// normalization (border "all" shorthand, style vocabulary) and the
-// aggregate-all-issues error shape are identical across the three --styles
-// carriers.
-func stylesPutOperations(runtime flagView, token string) ([]interface{}, error) {
-	if strings.TrimSpace(runtime.Str("styles")) == "" {
-		return nil, sheetsValidationForFlag("styles", "--styles is required")
-	}
-	v, err := parseJSONFlag(runtime, "styles")
-	if err != nil {
-		return nil, err
-	}
-	items, err := parseWorkbookCreateStylesItems(v)
-	if err != nil {
-		return nil, err
-	}
-	if len(items) == 0 {
-		return nil, sheetsValidationForFlag("styles", "--styles.styles must be a non-empty array (one item per target sheet)")
-	}
-	var probs []error
-	type sheetSpec struct {
-		name    string
-		payload *workbookCreateStylePayload
-	}
-	specs := make([]sheetSpec, 0, len(items))
-	seenName := map[string]bool{}
-	for i, item := range items {
-		path := fmt.Sprintf("--styles.styles[%d]", i)
-		name, _ := item["name"].(string)
-		name = strings.TrimSpace(name)
-		if name == "" {
-			probs = append(probs, common.ValidationErrorf("%s.name is required (the real sheet name; check +workbook-info)", path))
-			continue
-		}
-		if seenName[name] {
-			probs = append(probs, common.ValidationErrorf("%s.name %q appears twice; merge the two items", path, name))
-			continue
-		}
-		seenName[name] = true
-		payload, itemProbs := parseWorkbookCreateStyleItem(item, path)
-		if len(itemProbs) > 0 {
-			probs = append(probs, itemProbs...)
-			continue
-		}
-		specs = append(specs, sheetSpec{name: name, payload: payload})
-	}
-	if err := joinStyleValidationErrors(probs); err != nil {
-		return nil, err
-	}
-
-	ops := make([]interface{}, 0, len(specs)*4)
-	var totalCells int64
-	appendVisual := func(name string, op workbookCreateStyleOp) {
-		input, toolName := workbookCreateVisualOpInput(token, "", name, op)
-		if toolName == "" {
-			return
-		}
-		ops = append(ops, map[string]interface{}{"tool_name": toolName, "input": input})
-	}
-	for _, spec := range specs {
-		// merges first so subsequent style stamps see the final grid.
-		for _, m := range spec.payload.CellMerges {
-			appendVisual(spec.name, workbookCreateStyleOp{Kind: "cell_merge", Range: m.Range, MergeType: m.MergeType})
-		}
-		for _, cs := range coalesceStyleStamps(spec.payload.CellStyles) {
-			rows, cols, err := rangeDimensions(cs.Range)
-			if err != nil {
-				return nil, sheetsValidationForFlag("styles", "cell_styles range %q: %v", cs.Range, err)
-			}
-			if err := checkStampMatrixBudget("styles", cs.Range, rows, cols); err != nil {
-				return nil, err
-			}
-			totalCells += int64(rows) * int64(cols)
-			if err := checkBatchStampBudget(totalCells); err != nil {
-				return nil, err
-			}
-			ops = append(ops, map[string]interface{}{
-				"tool_name": "set_cell_range",
-				"input": map[string]interface{}{
-					"excel_id":   token,
-					"sheet_name": spec.name,
-					"range":      stripSheetPrefix(cs.Range),
-					"cells":      fillCellsMatrix(rows, cols, cs.Style),
-				},
-			})
-		}
-		for _, rs := range spec.payload.RowSizes {
-			appendVisual(spec.name, workbookCreateStyleOp{Kind: "row_size", Range: rs.Range, ResizeType: rs.ResizeType, Size: rs.Size})
-		}
-		for _, csz := range spec.payload.ColSizes {
-			appendVisual(spec.name, workbookCreateStyleOp{Kind: "col_size", Range: csz.Range, ResizeType: csz.ResizeType, Size: csz.Size})
-		}
-		if f := spec.payload.Freeze; f != nil {
-			if f.Rows > 0 {
-				appendVisual(spec.name, workbookCreateStyleOp{Kind: "freeze_rows", Size: f.Rows})
-			}
-			if f.Cols > 0 {
-				appendVisual(spec.name, workbookCreateStyleOp{Kind: "freeze_cols", Size: f.Cols})
-			}
-		}
-	}
-	if len(ops) > maxBatchOperations {
-		return nil, sheetsValidationForFlag("styles",
-			"--styles expands to %d operations even after merging adjacent same-style ranges, over the %d cap; split the spec into several +styles-put calls — and for alternating-row banding or value-dependent coloring use +cond-format-create instead of per-row stamps",
-			len(ops), maxBatchOperations)
-	}
-	return ops, nil
-}
-
-// coalesceStyleStamps merges cell_styles entries that carry the IDENTICAL
-// style into larger rectangles: same column span + contiguous/overlapping
-// rows fuse vertically, same row span + contiguous columns fuse
-// horizontally, iterated to a fixpoint. Models routinely emit one entry per
-// row (07-21 rerun: specs expanding to 184/203/861 operations against the
-// 100-op cap); a declarative spec describes intent, so execution shape is
-// the CLI's to optimize. Entries with unparsable ranges pass through
-// untouched (the per-op validation reports them with proper context).
-func coalesceStyleStamps(ops []workbookCreateCellStyleOp) []workbookCreateCellStyleOp {
-	if len(ops) < 2 {
-		return ops
-	}
-	type rect struct{ c1, r1, c2, r2 int }
-	type group struct {
-		style map[string]interface{}
-		rects []rect
-	}
-	var order []string
-	groups := map[string]*group{}
-	out := make([]workbookCreateCellStyleOp, 0, len(ops))
-	for _, op := range ops {
-		c1, r1, c2, r2, err := workbookCreateStyleRangeBounds(op.Range)
-		key, jerr := json.Marshal(op.Style) // map keys marshal sorted → canonical
-		if err != nil || jerr != nil {
-			out = append(out, op)
-			continue
-		}
-		g, ok := groups[string(key)]
-		if !ok {
-			g = &group{style: op.Style}
-			groups[string(key)] = g
-			order = append(order, string(key))
-		}
-		g.rects = append(g.rects, rect{c1, r1, c2, r2})
-	}
-	for _, key := range order {
-		g := groups[key]
-		rects := g.rects
-		for changed := true; changed; {
-			changed = false
-			for i := 0; i < len(rects) && !changed; i++ {
-				for j := i + 1; j < len(rects); j++ {
-					a, b := rects[i], rects[j]
-					var merged rect
-					switch {
-					case a.c1 == b.c1 && a.c2 == b.c2 && b.r1 <= a.r2+1 && a.r1 <= b.r2+1:
-						merged = rect{a.c1, min(a.r1, b.r1), a.c2, max(a.r2, b.r2)}
-					case a.r1 == b.r1 && a.r2 == b.r2 && b.c1 <= a.c2+1 && a.c1 <= b.c2+1:
-						merged = rect{min(a.c1, b.c1), a.r1, max(a.c2, b.c2), a.r2}
-					default:
-						continue
-					}
-					rects[i] = merged
-					rects = append(rects[:j], rects[j+1:]...)
-					changed = true
-					break
-				}
-			}
-		}
-		for _, rc := range rects {
-			out = append(out, workbookCreateCellStyleOp{
-				Range: fmt.Sprintf("%s%d:%s%d",
-					columnIndexToLetter(rc.c1), rc.r1+1,
-					columnIndexToLetter(rc.c2), rc.r2+1),
-				Style: g.style,
-			})
-		}
-	}
-	return out
-}
-
-// stripSheetPrefix drops an optional "Sheet!"-style prefix from an A1 range:
-// the target sheet is already carried by the spec item's name, and the
-// batch sub-op input names the sheet separately.
-func stripSheetPrefix(rangeStr string) string {
-	if idx := strings.Index(rangeStr, "!"); idx >= 0 {
-		return strings.TrimSpace(rangeStr[idx+1:])
-	}
-	return strings.TrimSpace(rangeStr)
-}

shortcuts/sheets/lark_sheet_styles_put_test.go

@@ -1,347 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"strings"
-	"testing"
-)
-
-func stylesPutView(spec map[string]interface{}) mapFlagView {
-	return newMapFlagViewForCommand("+styles-put", map[string]interface{}{"styles": spec})
-}
-
-// TestStylesPutOperations_ExpansionOrder pins the per-sheet expansion:
-// cell_merges → cell_styles → row_sizes → col_sizes → freeze, all inside one
-// batch_update operations array (server-side order dependence verified live).
-func TestStylesPutOperations_ExpansionOrder(t *testing.T) {
-	t.Parallel()
-	ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-		"styles": []interface{}{map[string]interface{}{
-			"name":        "Sheet1",
-			"cell_merges": []interface{}{map[string]interface{}{"range": "A5:A8"}},
-			"cell_styles": []interface{}{map[string]interface{}{"range": "A1:B1", "font_weight": "bold"}},
-			"row_sizes":   []interface{}{map[string]interface{}{"range": "1:1", "type": "pixel", "size": float64(36)}},
-			"col_sizes":   []interface{}{map[string]interface{}{"range": "A:B", "type": "pixel", "size": float64(120)}},
-			"freeze":      map[string]interface{}{"rows": float64(1), "cols": float64(2)},
-		}},
-	}), testToken)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	wantTools := []string{"merge_cells", "set_cell_range", "resize_range", "resize_range", "modify_sheet_structure", "modify_sheet_structure"}
-	if len(ops) != len(wantTools) {
-		t.Fatalf("got %d ops, want %d", len(ops), len(wantTools))
-	}
-	for i, want := range wantTools {
-		op := ops[i].(map[string]interface{})
-		if op["tool_name"] != want {
-			t.Fatalf("ops[%d].tool_name = %v, want %s", i, op["tool_name"], want)
-		}
-		input := op["input"].(map[string]interface{})
-		if input["sheet_name"] != "Sheet1" {
-			t.Fatalf("ops[%d] missing sheet_name: %v", i, input)
-		}
-		if input["excel_id"] != testToken {
-			t.Fatalf("ops[%d] missing excel_id", i)
-		}
-	}
-	// The style stamp carries a cells matrix matching the range (1×2).
-	stamp := ops[1].(map[string]interface{})["input"].(map[string]interface{})
-	cells := stamp["cells"].([][]interface{})
-	if len(cells) != 1 || len(cells[0]) != 2 {
-		t.Fatalf("style stamp matrix = %dx%d, want 1x2", len(cells), len(cells[0]))
-	}
-	// Freeze ops carry the freeze counts.
-	fr := ops[4].(map[string]interface{})["input"].(map[string]interface{})
-	if fr["operation"] != "freeze" || fr["freeze_rows"] != 1 {
-		t.Fatalf("freeze rows op = %v", fr)
-	}
-	fc := ops[5].(map[string]interface{})["input"].(map[string]interface{})
-	if fc["freeze_columns"] != 2 {
-		t.Fatalf("freeze cols op = %v", fc)
-	}
-}
-
-// TestStylesPutOperations_Validation pins the aggregate error shape and the
-// section/name requirements.
-func TestStylesPutOperations_Validation(t *testing.T) {
-	t.Parallel()
-
-	t.Run("missing name and empty item aggregate", func(t *testing.T) {
-		t.Parallel()
-		_, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{
-				map[string]interface{}{"cell_styles": []interface{}{map[string]interface{}{"range": "A1", "font_weight": "bold"}}},
-				map[string]interface{}{"name": "S2"},
-			},
-		}), testToken)
-		ve := requireValidation(t, err, "name is required")
-		if !strings.Contains(ve.Message, "at least one of cell_styles/row_sizes/col_sizes/cell_merges/freeze") {
-			t.Fatalf("message %q missing empty-item issue", ve.Message)
-		}
-	})
-
-	t.Run("duplicate sheet name rejected", func(t *testing.T) {
-		t.Parallel()
-		item := map[string]interface{}{"name": "S1", "freeze": map[string]interface{}{"rows": float64(1)}}
-		item2 := map[string]interface{}{"name": "S1", "freeze": map[string]interface{}{"rows": float64(2)}}
-		_, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{item, item2},
-		}), testToken)
-		requireValidation(t, err, "appears twice")
-	})
-
-	t.Run("freeze-only item is valid", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{"name": "S1", "freeze": map[string]interface{}{"rows": float64(1)}}},
-		}), testToken)
-		if err != nil || len(ops) != 1 {
-			t.Fatalf("ops=%d err=%v", len(ops), err)
-		}
-	})
-
-	t.Run("all-zero freeze rejected", func(t *testing.T) {
-		t.Parallel()
-		_, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{"name": "S1", "freeze": map[string]interface{}{"rows": float64(0)}}},
-		}), testToken)
-		requireValidation(t, err, "at least one dimension")
-	})
-}
-
-// TestStylesPayloadVocabularyForgiveness pins the 07-20 rerun fixes: the
-// payload path (--styles cell_styles objects) accepts the same habitual
-// vocabulary the flag path already normalized — border family folding, wrap
-// aliases, and enum VALUE canonicalization (CSS center → Lark middle etc.).
-func TestStylesPayloadVocabularyForgiveness(t *testing.T) {
-	t.Parallel()
-
-	stamp := func(styleFields map[string]interface{}) ([]interface{}, error) {
-		item := map[string]interface{}{"range": "A1:B1"}
-		for k, v := range styleFields {
-			item[k] = v
-		}
-		return stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":        "S1",
-				"cell_styles": []interface{}{item},
-			}},
-		}), testToken)
-	}
-	cellProto := func(t *testing.T, ops []interface{}) map[string]interface{} {
-		t.Helper()
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		cells := input["cells"].([][]interface{})
-		return cells[0][0].(map[string]interface{})
-	}
-
-	t.Run("vertical_alignment center canonicalizes to middle", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stamp(map[string]interface{}{"vertical_alignment": "center", "font_weight": "BOLD"})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		cs := cellProto(t, ops)["cell_styles"].(map[string]interface{})
-		if cs["vertical_alignment"] != "middle" || cs["font_weight"] != "bold" {
-			t.Fatalf("cell_styles = %v, want middle/bold", cs)
-		}
-	})
-
-	t.Run("off-enum value rejected client-side with did-you-mean", func(t *testing.T) {
-		t.Parallel()
-		_, err := stamp(map[string]interface{}{"vertical_alignment": "botom"})
-		requireValidation(t, err, `did you mean "bottom"`)
-	})
-
-	t.Run("boolean wrap_text folds to word_wrap auto-wrap", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stamp(map[string]interface{}{"wrap_text": true})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		cs := cellProto(t, ops)["cell_styles"].(map[string]interface{})
-		if cs["word_wrap"] != "auto-wrap" {
-			t.Fatalf("word_wrap = %v, want auto-wrap", cs["word_wrap"])
-		}
-	})
-
-	t.Run("borders object folds into border_styles", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stamp(map[string]interface{}{
-			"borders": map[string]interface{}{"style": "solid", "color": "#000000"},
-		})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		bs := cellProto(t, ops)["border_styles"].(map[string]interface{})
-		top, _ := bs["top"].(map[string]interface{})
-		if top == nil || top["style"] != "solid" {
-			t.Fatalf("border_styles = %v, want all-sides solid", bs)
-		}
-	})
-
-	t.Run("flattened border_bottom and border_top_color fold per side", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stamp(map[string]interface{}{
-			"border_bottom":    map[string]interface{}{"style": "solid"},
-			"border_top_color": "#FF0000",
-		})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		bs := cellProto(t, ops)["border_styles"].(map[string]interface{})
-		bottom, _ := bs["bottom"].(map[string]interface{})
-		topSide, _ := bs["top"].(map[string]interface{})
-		if bottom["style"] != "solid" || topSide["color"] != "#FF0000" {
-			t.Fatalf("border_styles = %v", bs)
-		}
-	})
-
-	t.Run("border_style thin means thin solid line", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stamp(map[string]interface{}{"border_style": "thin"})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		bs := cellProto(t, ops)["border_styles"].(map[string]interface{})
-		top, _ := bs["top"].(map[string]interface{})
-		if top["weight"] != "thin" || top["style"] != "solid" {
-			t.Fatalf("border_styles.top = %v, want thin solid", top)
-		}
-	})
-
-	t.Run("fore_color prescribes instead of guessing", func(t *testing.T) {
-		t.Parallel()
-		_, err := stamp(map[string]interface{}{"fore_color": "#FF0000"})
-		requireValidation(t, err, "fore_color is ambiguous")
-	})
-
-	t.Run("bare string cell_merges accepted", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":        "S1",
-				"cell_merges": []interface{}{"A5:B6"},
-			}},
-		}), testToken)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		if input["range"] != "A5:B6" || input["merge_type"] != "all" {
-			t.Fatalf("merge op = %v", input)
-		}
-	})
-}
-
-// TestStylesResizeSizeAliases pins the one-way Excel-vocabulary aliases on
-// the shared styles resize parser: height in row_sizes / width in col_sizes
-// resolve to size silently; the wrong dimension's word is a targeted error.
-func TestStylesResizeSizeAliases(t *testing.T) {
-	t.Parallel()
-
-	t.Run("height aliases to size in row_sizes", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":      "S1",
-				"row_sizes": []interface{}{map[string]interface{}{"range": "1:1", "type": "pixel", "height": float64(36)}},
-			}},
-		}), testToken)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		block := input["resize_height"].(map[string]interface{})
-		if block["value"] != 36 {
-			t.Fatalf("resize_height = %v, want value 36", block)
-		}
-	})
-
-	t.Run("width aliases to size in col_sizes", func(t *testing.T) {
-		t.Parallel()
-		_, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":      "S1",
-				"col_sizes": []interface{}{map[string]interface{}{"range": "A:C", "type": "pixel", "width": float64(120)}},
-			}},
-		}), testToken)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-	})
-
-	t.Run("wrong-dimension word is a targeted error", func(t *testing.T) {
-		t.Parallel()
-		_, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":      "S1",
-				"row_sizes": []interface{}{map[string]interface{}{"range": "1:1", "type": "pixel", "width": float64(36)}},
-			}},
-		}), testToken)
-		requireValidation(t, err, "does not apply to this array")
-	})
-
-	t.Run("size plus alias together rejected", func(t *testing.T) {
-		t.Parallel()
-		_, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":      "S1",
-				"row_sizes": []interface{}{map[string]interface{}{"range": "1:1", "type": "pixel", "size": float64(36), "height": float64(40)}},
-			}},
-		}), testToken)
-		requireValidation(t, err, "either size or height")
-	})
-}
-
-// TestDimDeleteRangesOps pins the descending-order expansion and the
-// same-dimension / non-overlap guards.
-func TestDimDeleteRangesOps(t *testing.T) {
-	t.Parallel()
-
-	view := func(ranges ...interface{}) mapFlagView {
-		return newMapFlagViewForCommand("+dim-delete", map[string]interface{}{"ranges": ranges})
-	}
-
-	t.Run("rows execute descending", func(t *testing.T) {
-		t.Parallel()
-		ops, err := dimDeleteRangesOps(view("5:5", "11:13", "8:8"), testToken, "", "S1")
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		var got []string
-		for _, op := range ops {
-			got = append(got, op.(map[string]interface{})["input"].(map[string]interface{})["range"].(string))
-		}
-		want := []string{"11:13", "8:8", "5:5"}
-		for i := range want {
-			if got[i] != want[i] {
-				t.Fatalf("order = %v, want %v", got, want)
-			}
-		}
-	})
-
-	t.Run("mixed dimensions rejected", func(t *testing.T) {
-		t.Parallel()
-		_, err := dimDeleteRangesOps(view("5:5", "C:C"), testToken, "", "S1")
-		requireValidation(t, err, "rows OR columns")
-	})
-
-	t.Run("overlap rejected", func(t *testing.T) {
-		t.Parallel()
-		_, err := dimDeleteRangesOps(view("5:8", "7:9"), testToken, "", "S1")
-		requireValidation(t, err, "overlap")
-	})
-
-	t.Run("ranges cannot nest inside batch", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+dim-delete", map[string]interface{}{
-			"sheet_name": "S1",
-			"ranges":     []interface{}{"5:5", "8:8"},
-		}), testToken, 0)
-		requireValidation(t, err, "not supported inside +batch-update")
-	})
-}

shortcuts/sheets/lark_sheet_workbook.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/suggest"
 	"github.com/larksuite/cli/internal/util"
 	"github.com/larksuite/cli/shortcuts/common"
 	"github.com/larksuite/cli/shortcuts/drive"
@@ -919,14 +918,6 @@ type workbookCreateStylePayload struct {
 	RowSizes   []workbookCreateResizeOp
 	ColSizes   []workbookCreateResizeOp
 	CellMerges []workbookCreateMergeOp
-	Freeze     *workbookCreateFreezeOp
-}
-
-// workbookCreateFreezeOp freezes the first Rows rows / Cols columns.
-// Zero means "leave that dimension alone".
-type workbookCreateFreezeOp struct {
-	Rows int
-	Cols int
 }
 
 type workbookCreateCellStyleOp struct {
@@ -1082,52 +1073,15 @@ func parseWorkbookCreateStyleItem(item map[string]interface{}, path string) (*wo
 		payload.CellMerges, errsHere = parseWorkbookCreateMergeOps(raw, path+".cell_merges")
 		probs = append(probs, errsHere...)
 	}
-	if raw, ok := item["freeze"]; ok {
-		freeze, err := parseWorkbookCreateFreezeOp(raw, path+".freeze")
-		if err != nil {
-			probs = append(probs, err)
-		} else {
-			payload.Freeze = freeze
-		}
-	}
 	if len(probs) > 0 {
 		return nil, probs
 	}
-	if len(payload.CellStyles) == 0 && len(payload.RowSizes) == 0 && len(payload.ColSizes) == 0 && len(payload.CellMerges) == 0 && payload.Freeze == nil {
-		return nil, []error{common.ValidationErrorf("%s must include at least one of cell_styles/row_sizes/col_sizes/cell_merges/freeze", path)}
+	if len(payload.CellStyles) == 0 && len(payload.RowSizes) == 0 && len(payload.ColSizes) == 0 && len(payload.CellMerges) == 0 {
+		return nil, []error{common.ValidationErrorf("%s must include at least one of cell_styles/row_sizes/col_sizes/cell_merges", path)}
 	}
 	return payload, nil
 }
 
-// parseWorkbookCreateFreezeOp parses a {rows, cols} freeze section. At least
-// one dimension must be positive — an all-zero freeze is a no-op the caller
-// almost certainly didn't mean.
-func parseWorkbookCreateFreezeOp(raw interface{}, path string) (*workbookCreateFreezeOp, error) {
-	obj, ok := raw.(map[string]interface{})
-	if !ok {
-		return nil, common.ValidationErrorf("%s must be an object like {\"rows\":1} or {\"rows\":1,\"cols\":2}", path)
-	}
-	out := &workbookCreateFreezeOp{}
-	for k, v := range obj {
-		n, isNum := v.(float64)
-		if !isNum || n != float64(int(n)) || n < 0 {
-			return nil, common.ValidationErrorf("%s.%s must be a non-negative integer", path, k)
-		}
-		switch k {
-		case "rows":
-			out.Rows = int(n)
-		case "cols", "columns":
-			out.Cols = int(n)
-		default:
-			return nil, common.ValidationErrorf("%s.%s is not a supported field (want rows/cols)", path, k)
-		}
-	}
-	if out.Rows == 0 && out.Cols == 0 {
-		return nil, common.ValidationErrorf("%s must freeze at least one dimension (rows or cols > 0)", path)
-	}
-	return out, nil
-}
-
 // joinStyleValidationErrors folds the issues collected across one --styles
 // parse into a single typed error that lists them all, so the caller can fix
 // the whole payload in one retry instead of one error per round trip.
@@ -1221,11 +1175,6 @@ func parseWorkbookCreateMergeOps(v interface{}, path string) ([]workbookCreateMe
 }
 
 func parseWorkbookCreateMergeOp(raw interface{}, path string) (workbookCreateMergeOp, error) {
-	// A bare range string means {range: s, merge_type: all} — the only
-	// possible reading (07-20 eval hit).
-	if s, ok := raw.(string); ok && strings.TrimSpace(s) != "" {
-		raw = map[string]interface{}{"range": strings.TrimSpace(s)}
-	}
 	op, ok := raw.(map[string]interface{})
 	if !ok {
 		return workbookCreateMergeOp{}, common.ValidationErrorf("%s must be an object", path)
@@ -1329,59 +1278,32 @@ func parseWorkbookCreateResizeOp(raw interface{}, path, dimension string) (workb
 	}
 	resizeType, _ := op["type"].(string)
 	resizeType = strings.TrimSpace(resizeType)
-	if resizeType != "" {
-		if dimension == "column" && resizeType == "auto" {
-			return workbookCreateResizeOp{}, common.ValidationErrorf("%s.type auto is rows-only", path)
-		}
-		switch resizeType {
-		case "pixel", "standard", "auto":
-		default:
-			return workbookCreateResizeOp{}, common.ValidationErrorf("%s.type %q is invalid (want %s), e.g. %s", path, resizeType, typeHint, resizeOpExample(dimension))
-		}
+	if resizeType == "" {
+		return workbookCreateResizeOp{}, common.ValidationErrorf("%s.type is required (%s), e.g. %s", path, typeHint, resizeOpExample(dimension))
 	}
-	// size is the canonical dimension key (uniform across row_sizes and
-	// col_sizes — the array name already carries the dimension). The Excel-
-	// vocabulary alias (height on rows, width on columns) is accepted
-	// silently; the WRONG dimension's word is a targeted error, never a
-	// silent rewrite.
-	alias, wrongDim := "height", "width"
-	if dimension == "column" {
-		alias, wrongDim = "width", "height"
+	if dimension == "column" && resizeType == "auto" {
+		return workbookCreateResizeOp{}, common.ValidationErrorf("%s.type auto is rows-only", path)
 	}
-	if _, has := op[wrongDim]; has {
-		return workbookCreateResizeOp{}, common.ValidationErrorf("%s.%s does not apply to this array (the array name carries the dimension); use size, e.g. %s", path, wrongDim, resizeOpExample(dimension))
-	}
-	sizeRaw, hasSize := op["size"]
-	if aliasRaw, hasAlias := op[alias]; hasAlias {
-		if hasSize {
-			return workbookCreateResizeOp{}, common.ValidationErrorf("%s: give either size or %s, not both", path, alias)
-		}
-		sizeRaw, hasSize = aliasRaw, true
+	switch resizeType {
+	case "pixel", "standard", "auto":
+	default:
+		return workbookCreateResizeOp{}, common.ValidationErrorf("%s.type %q is invalid (want %s), e.g. %s", path, resizeType, typeHint, resizeOpExample(dimension))
 	}
 	size := 0
-	if hasSize {
-		n, ok := util.ToFloat64(sizeRaw)
+	if raw, ok := op["size"]; ok {
+		n, ok := util.ToFloat64(raw)
 		if !ok || n <= 0 {
 			return workbookCreateResizeOp{}, common.ValidationErrorf("%s.size must be a positive number", path)
 		}
 		size = int(n)
 	}
-	// type is optional ceremony when a pixel size is given: {range, size}
-	// means a pixel resize, exactly as --width/--height without --type does
-	// on the flag path. Explicit standard/auto still needs type.
-	if resizeType == "" {
-		if size <= 0 {
-			return workbookCreateResizeOp{}, common.ValidationErrorf("%s needs size (px) or type (%s), e.g. %s", path, typeHint, resizeOpExample(dimension))
-		}
-		resizeType = "pixel"
-	}
 	if resizeType == "pixel" && size <= 0 {
 		return workbookCreateResizeOp{}, common.ValidationErrorf("%s.type pixel requires size, e.g. %s", path, resizeOpExample(dimension))
 	}
 	if resizeType != "pixel" && size > 0 {
 		return workbookCreateResizeOp{}, common.ValidationErrorf("%s.size is only valid with type pixel", path)
 	}
-	if err := rejectUnexpectedWorkbookStyleFields(op, path, "range", "type", "size", alias); err != nil {
+	if err := rejectUnexpectedWorkbookStyleFields(op, path, "range", "type", "size"); err != nil {
 		return workbookCreateResizeOp{}, err
 	}
 	return workbookCreateResizeOp{Range: normalizeWorkbookResizeRange(rangeStr), ResizeType: resizeType, Size: size}, nil
@@ -1424,9 +1346,6 @@ func normalizeWorkbookCreateStyleObject(in map[string]interface{}, path string)
 	if len(in) == 0 {
 		return nil, nil
 	}
-	if err := foldBorderFamilyAliases(in, path); err != nil {
-		return nil, err
-	}
 	if err := normalizeCellStyleAliases(in, path); err != nil {
 		return nil, err
 	}
@@ -1447,20 +1366,10 @@ func normalizeWorkbookCreateStyleObject(in map[string]interface{}, path string)
 			}
 			out["border_styles"] = m
 		case "value", "formula", "rich_text", "multiple_values", "note", "data_validation":
-			return nil, common.ValidationErrorf("%s.%s is a content field — a styles spec carries no cell content; write values/formulas via +cells-set or +table-put", path, k)
+			return nil, common.ValidationErrorf("%s is for styles only; put content in --values or use --sheets for typed cell objects", path)
 		default:
 			if !workbookCreateCellStyleField(k) {
-				// Universal rejection with did-you-mean + the full field list:
-				// this is the mechanism that absorbs the infinite tail of
-				// spelling permutations at a fixed one-retry cost — silent
-				// aliases are reserved for high-frequency words from real
-				// external vocabularies (see the style_vocab.go contract).
-				msg := fmt.Sprintf("%s.%s is not a supported style field", path, k)
-				if match := suggest.Closest(strings.ToLower(k), workbookCreateCellStyleFieldList, 1); len(match) > 0 {
-					msg += fmt.Sprintf(" — did you mean %q?", match[0])
-				}
-				msg += "; supported: " + strings.Join(workbookCreateCellStyleFieldList, ", ")
-				return nil, common.ValidationErrorf("%s", msg)
+				return nil, common.ValidationErrorf("%s.%s is not a supported style field", path, k)
 			}
 			cellStyle[k] = v
 		}
@@ -1471,14 +1380,6 @@ func normalizeWorkbookCreateStyleObject(in map[string]interface{}, path string)
 	return out, nil
 }
 
-// workbookCreateCellStyleFieldList is the canonical style vocabulary plus the
-// two border carriers, in display order for the unknown-field hint.
-var workbookCreateCellStyleFieldList = []string{
-	"font_color", "font_family", "font_size", "font_weight", "font_style", "font_line",
-	"background_color", "horizontal_alignment", "vertical_alignment",
-	"number_format", "word_wrap", "border", "border_styles",
-}
-
 func workbookCreateCellStyleField(name string) bool {
 	switch name {
 	case "font_color", "font_family", "font_size", "font_weight", "font_style", "font_line",
@@ -1717,7 +1618,7 @@ func workbookCreateVisualOps(styles *workbookCreateStylePayload) []workbookCreat
 	if styles == nil {
 		return nil
 	}
-	ops := make([]workbookCreateStyleOp, 0, len(styles.CellMerges)+len(styles.RowSizes)+len(styles.ColSizes)+2)
+	ops := make([]workbookCreateStyleOp, 0, len(styles.CellMerges)+len(styles.RowSizes)+len(styles.ColSizes))
 	for _, op := range styles.CellMerges {
 		ops = append(ops, workbookCreateStyleOp{Kind: "cell_merge", Range: op.Range, MergeType: op.MergeType})
 	}
@@ -1727,14 +1628,6 @@ func workbookCreateVisualOps(styles *workbookCreateStylePayload) []workbookCreat
 	for _, op := range styles.ColSizes {
 		ops = append(ops, workbookCreateStyleOp{Kind: "col_size", Range: op.Range, ResizeType: op.ResizeType, Size: op.Size})
 	}
-	if styles.Freeze != nil {
-		if styles.Freeze.Rows > 0 {
-			ops = append(ops, workbookCreateStyleOp{Kind: "freeze_rows", Size: styles.Freeze.Rows})
-		}
-		if styles.Freeze.Cols > 0 {
-			ops = append(ops, workbookCreateStyleOp{Kind: "freeze_cols", Size: styles.Freeze.Cols})
-		}
-	}
 	return ops
 }
 
@@ -1773,18 +1666,6 @@ func workbookCreateVisualOpInput(token, sheetID, sheetName string, op workbookCr
 			input["resize_width"] = block
 		}
 		return input, "resize_range"
-	case "freeze_rows", "freeze_cols":
-		input := map[string]interface{}{
-			"excel_id":  token,
-			"operation": "freeze",
-		}
-		sheetSelectorForToolInput(input, sheetID, sheetName)
-		if op.Kind == "freeze_rows" {
-			input["freeze_rows"] = op.Size
-		} else {
-			input["freeze_columns"] = op.Size
-		}
-		return input, "modify_sheet_structure"
 	default:
 		return nil, ""
 	}

shortcuts/sheets/lark_sheet_write_cells.go

@@ -38,11 +38,7 @@ import (
 
 // CellsSet wraps set_cell_range: caller provides the cells matrix via --cells
 // (JSON), with an optional --copy-to-range to replicate the written block
-// across a larger area (formula refs auto-shift). The plural form --writes
-// ([{sheet_name, range, cells}, …]) fans scattered regions — cross-sheet
-// allowed — into ONE atomic batch_update: eval traces show "fix all broken
-// formulas across ranges/sheets" as the dominant homogeneous scenario still
-// hand-assembled as +batch-update operations arrays.
+// across a larger area (formula refs auto-shift).
 var CellsSet = common.Shortcut{
 	Service:     "sheets",
 	Command:     "+cells-set",
@@ -55,28 +51,10 @@ var CellsSet = common.Shortcut{
 	Tips: []string{
 		`Example: lark-cli sheets +cells-set --url <URL> --sheet-name Sheet1 --range A1:B1 --cells '[[{"value":"名称"},{"formula":"=SUM(B2:B9)"}]]'`,
 		`--cells is always a 2D array (rows × cells), even for one cell: [[{"value":…}]].`,
-		`Scattered regions (e.g. fixing formulas across ranges/sheets): --writes '[{"sheet_name":…,"range":…,"cells":[[…]]}, …]' — one atomic call, sheet selector inside each item.`,
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if runtime.Changed("writes") {
-			token, err := resolveSpreadsheetToken(runtime)
-			if err != nil {
-				return err
-			}
-			_, err = cellsSetWritesOps(runtime, token)
-			return err
-		}
-		return validateViaInput(cellsSetInput)(ctx, runtime)
 	},
+	Validate: validateViaInput(cellsSetInput),
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		token, _ := resolveSpreadsheetToken(runtime)
-		if runtime.Changed("writes") {
-			ops, _ := cellsSetWritesOps(runtime, token)
-			return invokeToolDryRun(token, ToolKindWrite, "batch_update", map[string]interface{}{
-				"excel_id":   token,
-				"operations": ops,
-			})
-		}
 		sheetID, sheetName, _ := resolveSheetSelector(runtime)
 		input, _ := cellsSetInput(runtime, token, sheetID, sheetName)
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
@@ -86,21 +64,6 @@ var CellsSet = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		if runtime.Changed("writes") {
-			ops, err := cellsSetWritesOps(runtime, token)
-			if err != nil {
-				return err
-			}
-			out, err := callTool(ctx, runtime, token, ToolKindWrite, "batch_update", map[string]interface{}{
-				"excel_id":   token,
-				"operations": ops,
-			})
-			if err != nil {
-				return err
-			}
-			runtime.Out(out, nil)
-			return nil
-		}
 		sheetID, sheetName, err := resolveSheetSelector(runtime)
 		if err != nil {
 			return err
@@ -118,108 +81,6 @@ var CellsSet = common.Shortcut{
 	},
 }
 
-// cellsSetWritesOps parses --writes ([{sheet_name|sheet_id, range, cells}, …])
-// and expands it into set_cell_range operations for ONE atomic batch_update.
-// Single source of truth per item: the sheet selector LIVES IN THE ITEM (same
-// convention as +batch-update sub-ops and +styles-put items — no top-level
-// fallback, no precedence table to remember). Every item runs through the
-// exact standalone pipeline (key vocabulary, style acceptance layer, matrix
-// precheck, schema validation) via a per-item flag view, and item errors are
-// aggregated so one retry fixes them all.
-func cellsSetWritesOps(runtime *common.RuntimeContext, token string) ([]interface{}, error) {
-	for _, conflicting := range []string{"range", "cells", "copy-to-range"} {
-		if runtime.Changed(conflicting) {
-			return nil, sheetsValidationForFlag("writes", "--writes and --%s are mutually exclusive: single region → --range + --cells; multiple regions → --writes alone", conflicting)
-		}
-	}
-	if strings.TrimSpace(runtime.Str("sheet-name")) != "" || strings.TrimSpace(runtime.Str("sheet-id")) != "" {
-		return nil, sheetsValidationForFlag("writes", "--writes does not accept a top-level sheet selector — put sheet_name (or sheet_id) inside each writes item, same as +batch-update sub-ops")
-	}
-	raw, err := requireJSONArray(runtime, "writes")
-	if err != nil {
-		return nil, err
-	}
-	if len(raw) == 0 {
-		return nil, sheetsValidationForFlag("writes", "--writes must be a non-empty JSON array of {sheet_name, range, cells} items")
-	}
-	if len(raw) > maxBatchOperations {
-		return nil, sheetsValidationForFlag("writes", "--writes accepts at most %d items; got %d — merge adjacent regions or split into several calls", maxBatchOperations, len(raw))
-	}
-	topLevelOverwrite := runtime.Bool("allow-overwrite")
-	ops := make([]interface{}, 0, len(raw))
-	var probs []error
-	var totalCells int64
-	for i, v := range raw {
-		item, ok := v.(map[string]interface{})
-		if !ok {
-			probs = append(probs, common.ValidationErrorf("--writes[%d] must be an object like {\"sheet_name\":…,\"range\":…,\"cells\":[[…]]}", i))
-			continue
-		}
-		if err := normalizeSubOpInputKeys("+cells-set", item); err != nil {
-			probs = append(probs, common.ValidationErrorf("--writes[%d]: %v", i, err))
-			continue
-		}
-		if topLevelOverwrite {
-			if _, has := item["allow_overwrite"]; !has {
-				item["allow_overwrite"] = true
-			}
-		}
-		fv := newMapFlagViewForCommand("+cells-set", item)
-		sheetID := strings.TrimSpace(fv.Str("sheet-id"))
-		sheetName := strings.TrimSpace(fv.Str("sheet-name"))
-		input, err := cellsSetInput(fv, token, sheetID, sheetName)
-		if err != nil {
-			probs = append(probs, common.ValidationErrorf("--writes[%d]: %v", i, err))
-			continue
-		}
-		if cells, ok := input["cells"].([]interface{}); ok {
-			for _, row := range cells {
-				if r, ok := row.([]interface{}); ok {
-					totalCells += int64(len(r))
-				}
-			}
-		}
-		if err := checkBatchStampBudget(totalCells); err != nil {
-			return nil, err
-		}
-		ops = append(ops, map[string]interface{}{
-			"tool_name": "set_cell_range",
-			"input":     input,
-		})
-	}
-	if err := joinWritesValidationErrors(probs); err != nil {
-		return nil, err
-	}
-	return ops, nil
-}
-
-// joinWritesValidationErrors mirrors joinStyleValidationErrors for --writes:
-// every item's first error in one message, so the whole payload is fixed in
-// a single retry.
-func joinWritesValidationErrors(probs []error) error {
-	switch len(probs) {
-	case 0:
-		return nil
-	case 1:
-		return probs[0]
-	}
-	const maxShown = 8
-	msgs := make([]string, 0, len(probs))
-	for _, e := range probs {
-		if p, ok := errs.ProblemOf(e); ok {
-			msgs = append(msgs, p.Message)
-			continue
-		}
-		msgs = append(msgs, e.Error())
-	}
-	suffix := ""
-	if len(msgs) > maxShown {
-		suffix = fmt.Sprintf(" (+%d more)", len(msgs)-maxShown)
-		msgs = msgs[:maxShown]
-	}
-	return common.ValidationErrorf("--writes has %d issues: %s%s", len(probs), strings.Join(msgs, " | "), suffix)
-}
-
 func cellsSetInput(runtime flagView, token, sheetID, sheetName string) (map[string]interface{}, error) {
 	if err := requireSheetSelector(sheetID, sheetName); err != nil {
 		return nil, err
@@ -234,13 +95,9 @@ func cellsSetInput(runtime flagView, token, sheetID, sheetName string) (map[stri
 	if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
 		return nil, err
 	}
-	rangeStr := strings.TrimSpace(runtime.Str("range"))
-	if err := checkCellsMatchRange(cells, rangeStr); err != nil {
-		return nil, err
-	}
 	input := map[string]interface{}{
 		"excel_id": token,
-		"range":    rangeStr,
+		"range":    strings.TrimSpace(runtime.Str("range")),
 		"cells":    cells,
 	}
 	sheetSelectorForToolInput(input, sheetID, sheetName)
@@ -776,43 +633,6 @@ func warnDropdownSourceRangeHighlight(runtime *common.RuntimeContext) {
 // and returns its row / column counts. Errors on non-rectangular forms like
 // "A:C" (whole-column) or "3:6" (whole-row) — those need a row/col total
 // from get_sheet_structure, outside the scope of pure local parsing.
-// checkCellsMatchRange rejects, before any network call, the cells-vs-range
-// mismatches the server would otherwise fail mid-batch ("cells row count (N)
-// does not match range row count (M)" — a recurring server-side error cluster
-// in eval traces, and the failure leaves earlier batch sub-ops applied).
-// Single-cell ranges are checked too: the server enforces the same strict
-// match on a bare "A1" (07-21 rerun, 12 rows against range row count 1) —
-// there is no anchor semantics on +cells-set. An unparsable range is the
-// range validator's job, not ours.
-func checkCellsMatchRange(cells []interface{}, rangeStr string) error {
-	if len(cells) == 0 {
-		return sheetsValidationForFlag("cells",
-			"--cells is empty; to clear values use +cells-clear --scope content (needs --yes), or pass a non-empty 2D array")
-	}
-	rows, cols, err := rangeDimensions(rangeStr)
-	if err != nil {
-		return nil //nolint:nilerr // an unparsable range is reported by the range validation path with proper context
-	}
-	if len(cells) != rows {
-		return sheetsValidationForFlag("cells",
-			"--cells has %d rows but --range %q spans %d rows; make them equal (e.g. write N rows to an N-row range)",
-			len(cells), rangeStr, rows)
-	}
-	for r, rowRaw := range cells {
-		row, ok := rowRaw.([]interface{})
-		if !ok {
-			return sheetsValidationForFlag("cells",
-				"--cells[%d] must be an array (one row of cells) — --cells is always a 2D array, a single cell is [[{…}]]", r)
-		}
-		if len(row) != cols {
-			return sheetsValidationForFlag("cells",
-				"--cells[%d] has %d columns but --range %q spans %d columns; every row must match the range width",
-				r, len(row), rangeStr, cols)
-		}
-	}
-	return nil
-}
-
 func rangeDimensions(rangeStr string) (rows, cols int, err error) {
 	if idx := strings.Index(rangeStr, "!"); idx >= 0 {
 		rangeStr = rangeStr[idx+1:]

shortcuts/sheets/sheet_ai_api.go

@@ -134,29 +134,10 @@ func flattenToolErrorMsg(msg string) string {
 			return detail.Message
 		}
 		parts := make([]string, 0, len(detail.Failures))
-		firstFailed := detail.Failures[0].Index
 		for _, f := range detail.Failures {
 			parts = append(parts, fmt.Sprintf("operations[%d] (%s): %s", f.Index, f.ToolName, f.Error))
-			if f.Index < firstFailed {
-				firstFailed = f.Index
-			}
 		}
-		out := detail.Message + " — " + strings.Join(parts, "; ")
-		// Partial failure is NOT rolled back server-side: the succeeded sub-ops
-		// stay applied. Spell out the recovery so agents don't resend the whole
-		// batch and double-apply the successes (observed in eval traces). With
-		// one failure (fail-fast) everything before it succeeded and nothing
-		// after it ran — resend from that index; with several (continue-on-error)
-		// only the listed failures need resending.
-		if strings.Contains(detail.Message, "succeeded") &&
-			!strings.Contains(detail.Message, " 0 succeeded") {
-			if len(detail.Failures) == 1 {
-				out += fmt.Sprintf("; note: succeeded operations stay applied (no rollback) — fix the failure and resend only operations[%d:] onward, do not resend the whole batch", firstFailed)
-			} else {
-				out += "; note: succeeded operations stay applied (no rollback) — fix and resend only the failed operations listed above, do not resend the whole batch"
-			}
-		}
-		return out
+		return detail.Message + " — " + strings.Join(parts, "; ")
 	}
 	return inner
 }

shortcuts/sheets/shortcuts.go

@@ -151,6 +151,7 @@ func shortcutList() []common.Shortcut {
 
 		// Object CRUD (3 per skill)
 		ChartCreate, ChartUpdate, ChartDelete,
+		ChartCreateBasic, ChartConfigUpdate, ChartDataUpdate,
 		PivotCreate, PivotUpdate, PivotDelete,
 		CondFormatCreate, CondFormatUpdate, CondFormatDelete,
 		FilterCreate, FilterUpdate, FilterDelete,
@@ -158,9 +159,6 @@ func shortcutList() []common.Shortcut {
 		SparklineCreate, SparklineUpdate, SparklineDelete,
 		FloatImageCreate, FloatImageUpdate, FloatImageDelete,
 
-		// lark_sheet_styles_put
-		StylesPut,
-
 		// lark_sheet_batch_update
 		BatchUpdate,
 		CellsBatchSetStyle,

shortcuts/sheets/style_vocab.go

@@ -1,456 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"fmt"
-	"slices"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// ─── style vocabulary acceptance layer ────────────────────────────────
-//
-// The single home for how the sheets domain ACCEPTS style vocabulary, across
-// all three carrier paths that end in set_cell_range bodies:
-//
-//   flag path       +cells-set-style / +cells-batch-set-style flat flags
-//   typed cells     +cells-set --cells cell objects (incl. batch sub-ops)
-//   styles payload  --styles on +workbook-create / +table-put / +styles-put
-//
-// Design contract (established in the 2026-07 batch-update overhaul; see the
-// acceptance tests in styles_acceptance_test.go):
-//
-//   - ONE canonical form, documented; a WIDE acceptance layer, undocumented.
-//     Model priors are divergent (one eval batch produced six different
-//     border spellings), so no canonical structure can make first tries
-//     succeed — acceptance is normalized here instead, never per-call-site.
-//   - Every rewrite must be unambiguous; ambiguous guesses (fore_color) get
-//     a targeted prescription, never a silent pick. Silent ignoring and
-//     bare rejection are both bugs.
-//   - SILENT-ALIAS ADMISSION BAR (2026-07-21): only words from REAL external
-//     vocabularies (Excel/openpyxl, CSS, Google Sheets API), recurring
-//     across batches or ≥3 tasks in one, with zero semantic ambiguity.
-//     Spelling/word-order permutations do NOT get aliases — they are
-//     absorbed by the universal did-you-mean rejection (one self-healing
-//     retry, zero per-variant code). Real vocabularies are a finite set;
-//     permutations are not. Earlier permutation aliases are grandfathered.
-//   - Closure is enforced by two test properties: vocabulary parity (every
-//     flag-path style must be accepted on the payload paths) and the prior
-//     corpus (every observed model spelling either normalizes or
-//     prescribes). New eval finding → corpus row → fix HERE → locked.
-
-// ─── style flags (shared by +cells-set-style and +cells-batch-set-style) ─
-
-// buildCellStyleFromFlags reads the 12 flat style flags and returns the
-// cell_styles map expected by set_cell_range. Skips any flag the user
-// didn't set so partial styles work.
-func buildCellStyleFromFlags(runtime flagView) map[string]interface{} {
-	style := map[string]interface{}{}
-	if v := runtime.Str("background-color"); v != "" {
-		style["background_color"] = v
-	}
-	if v := runtime.Str("font-color"); v != "" {
-		style["font_color"] = v
-	}
-	if v := runtime.Str("font-family"); v != "" {
-		style["font_family"] = v
-	}
-	if runtime.Changed("font-size") && runtime.Float64("font-size") > 0 {
-		style["font_size"] = runtime.Float64("font-size")
-	}
-	if v := runtime.Str("font-style"); v != "" {
-		style["font_style"] = v
-	}
-	if v := runtime.Str("font-weight"); v != "" {
-		style["font_weight"] = v
-	}
-	if v := runtime.Str("font-line"); v != "" {
-		style["font_line"] = v
-	}
-	if v := runtime.Str("horizontal-alignment"); v != "" {
-		style["horizontal_alignment"] = v
-	}
-	if v := runtime.Str("vertical-alignment"); v != "" {
-		style["vertical_alignment"] = v
-	}
-	if v := runtime.Str("word-wrap"); v != "" {
-		style["word_wrap"] = v
-	}
-	if v := runtime.Str("number-format"); v != "" {
-		style["number_format"] = v
-	}
-	return style
-}
-
-// cellStyleAliases maps shorthand cell_styles field names that models commonly
-// hallucinate (Excel / openpyxl / CSS conventions) onto the canonical field
-// names the backend expects. Only the unambiguous alignment shorthands are
-// aliased — they are the high-frequency miss; ambiguous guesses (e.g. "color",
-// "bg_color", "text_align") are intentionally left out so a wrong guess still
-// surfaces as an error rather than being silently reinterpreted.
-var cellStyleAliases = []struct{ alias, canonical string }{
-	{"horizontal_align", "horizontal_alignment"},
-	{"halign", "horizontal_alignment"},
-	{"vertical_align", "vertical_alignment"},
-	{"valign", "vertical_alignment"},
-	// wrap family: word_wrap is the sole wrap concept, no ambiguity. 07-20
-	// eval: wrap_text alone produced an 88-issue retry loop on --styles;
-	// wrap_strategy (the Google Sheets API word) followed on 07-21.
-	{"wrap_text", "word_wrap"},
-	{"text_wrap", "word_wrap"},
-	{"wrap_strategy", "word_wrap"},
-}
-
-// cellStyleEnumFields sources the enum vocabulary for enum-bearing
-// cell_styles fields from the +cells-set-style flag-defs, so the payload path
-// (--styles / typed --cells) validates and canonicalizes values the same way
-// the cobra flag path does. 07-20 eval: "vertical_alignment":"center" (CSS
-// vocabulary; Lark spells it "middle") passed the CLI and burned a
-// server-side round trip ~10 times — the flag path had normalized it since
-// round 2, the payload path never did.
-func cellStyleEnumFields() map[string][]string {
-	defs, err := loadFlagDefs()
-	if err != nil {
-		return nil
-	}
-	spec, ok := defs["+cells-set-style"]
-	if !ok {
-		return nil
-	}
-	out := map[string][]string{}
-	for _, df := range spec.Flags {
-		if df.Kind != "own" || df.Type != "string" || len(df.Enum) == 0 {
-			continue
-		}
-		out[strings.ReplaceAll(df.Name, "-", "_")] = df.Enum
-	}
-	return out
-}
-
-// normalizeCellStyleAliases renames known shorthand keys in a single
-// cell_styles map to their canonical equivalents, in place, so a model that
-// writes e.g. "horizontal_align" instead of "horizontal_alignment" still
-// applies the style instead of hitting an "unsupported field" error (--styles)
-// or having the field silently dropped by the backend (typed --cells). If both
-// the shorthand and its canonical key are present it returns a validation error
-// rather than picking one. It then canonicalizes enum VALUES (casing + known
-// cross-vocabulary aliases like CSS "center" → Lark "middle"; boolean
-// word_wrap → the enum) and rejects off-enum values client-side instead of
-// letting the server fail the whole batch. path labels the map for errors.
-func normalizeCellStyleAliases(style map[string]interface{}, path string) error {
-	if len(style) == 0 {
-		return nil
-	}
-	for _, a := range cellStyleAliases {
-		v, ok := style[a.alias]
-		if !ok {
-			continue
-		}
-		if _, exists := style[a.canonical]; exists {
-			return common.ValidationErrorf("%s.%s conflicts with %s; pass only %s", path, a.alias, a.canonical, a.canonical)
-		}
-		style[a.canonical] = v
-		delete(style, a.alias)
-	}
-	// fore_color is deliberately NOT aliased: in openpyxl vocabulary fgColor
-	// is the FILL color while a plain reading suggests the font color — a
-	// silent pick could color the wrong thing. Prescribe both options.
-	if _, has := style["fore_color"]; has {
-		return common.ValidationErrorf("%s.fore_color is ambiguous — use font_color for text color or background_color for the cell fill", path)
-	}
-	// Boolean wrap habit: true unambiguously means wrap on, false means off.
-	if b, isBool := style["word_wrap"].(bool); isBool {
-		if b {
-			style["word_wrap"] = "auto-wrap"
-		} else {
-			style["word_wrap"] = "overflow"
-		}
-	}
-	for field, enum := range cellStyleEnumFields() {
-		raw, has := style[field]
-		if !has {
-			continue
-		}
-		val, isStr := raw.(string)
-		if !isStr || val == "" || slices.Contains(enum, val) {
-			continue
-		}
-		if canon := canonicalEnumValue(val, enum); canon != "" {
-			style[field] = canon
-			continue
-		}
-		msg := fmt.Sprintf("%s.%s value %q is invalid (allowed: %s)", path, field, val, strings.Join(enum, ", "))
-		if match := closestEnumValue(val, enum); match != "" {
-			msg += fmt.Sprintf("; did you mean %q?", match)
-		}
-		return common.ValidationErrorf("%s", msg)
-	}
-	return nil
-}
-
-// normalizeTypedCellsStyleAliases walks a typed --cells 2D array and applies
-// normalizeCellStyleAliases to every cell's inline cell_styles object, so the
-// alignment shorthands are accepted on +cells-set the same as on --styles.
-// It also expands the border "all" shorthand and intercepts border_styles
-// mis-nested inside cell_styles — both server-rejected shapes that eval
-// traces show surviving CLI validation and costing a full network round
-// trip. Structure is checked leniently to match the pass-through contract:
-// any element that isn't the expected shape is skipped, not rejected.
-func normalizeTypedCellsStyleAliases(cells []interface{}, path string) error {
-	for r, rowRaw := range cells {
-		row, ok := rowRaw.([]interface{})
-		if !ok {
-			continue
-		}
-		for c, cellRaw := range row {
-			cell, ok := cellRaw.(map[string]interface{})
-			if !ok {
-				continue
-			}
-			// cells[][].style is the habitual spelling of cell_styles (recurring
-			// server-side 900015206 in eval traces) — rewrite when unambiguous.
-			if styleObj, isObj := cell["style"].(map[string]interface{}); isObj {
-				if _, has := cell["cell_styles"]; has {
-					return common.ValidationErrorf("%s[%d][%d].style conflicts with cell_styles; pass only cell_styles", path, r, c)
-				}
-				cell["cell_styles"] = styleObj
-				delete(cell, "style")
-			}
-			// cells[][].type is not a cell field; the value type is whatever the
-			// JSON value is. Reject with the fix instead of a server round trip.
-			if _, has := cell["type"]; has {
-				return common.ValidationErrorf("%s[%d][%d].type is not a cell field — the value type is inferred from the JSON value; control display format via cell_styles.number_format", path, r, c)
-			}
-			if bs, ok := cell["border_styles"].(map[string]interface{}); ok {
-				expandBorderAllShorthand(bs)
-			}
-			st, ok := cell["cell_styles"].(map[string]interface{})
-			if !ok {
-				continue
-			}
-			if _, misNested := st["border_styles"]; misNested {
-				return common.ValidationErrorf(
-					"%s[%d][%d].cell_styles.border_styles is not valid — border_styles is a top-level cell field, a sibling of cell_styles; move it up one level",
-					path, r, c)
-			}
-			if err := normalizeCellStyleAliases(st, fmt.Sprintf("%s[%d][%d].cell_styles", path, r, c)); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// expandBorderAllShorthand rewrites the "all" side shorthand — habitual from
-// Excel / openpyxl vocabulary, rejected by the backend — into the four
-// explicit sides, in place. An explicitly set side wins over the shorthand.
-// Applied on both the typed --cells path and the --styles path, so batch
-// sub-ops get the same rewrite as standalone calls.
-func expandBorderAllShorthand(border map[string]interface{}) {
-	if all, ok := border["all"]; ok {
-		for _, side := range []string{"top", "bottom", "left", "right"} {
-			if _, exists := border[side]; !exists {
-				border[side] = all
-			}
-		}
-		delete(border, "all")
-	}
-	// Weight vocabulary in the style slot ("thin"/"medium"/"thick" are the
-	// habitual Excel words; the largest residual styles cluster in the 07-21
-	// rerun wrote them into border_styles.<side>.style of the FULL nested
-	// form). A thin border always means a thin solid line: move the word to
-	// weight and default style to solid. Only when weight is absent — an
-	// explicit conflicting weight keeps the enum error path.
-	for _, raw := range border {
-		side, ok := raw.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		s, _ := side["style"].(string)
-		switch strings.ToLower(s) {
-		case "thin", "medium", "thick":
-			if _, hasWeight := side["weight"]; !hasWeight {
-				side["weight"] = strings.ToLower(s)
-				side["style"] = "solid"
-			}
-		}
-	}
-}
-
-// borderStylesFromFlag parses --border-styles as a JSON object (top/bottom/
-// left/right with style sub-objects), expanding the "all" side shorthand the
-// same as the typed --cells and --styles paths so +cells-set-style /
-// +cells-batch-set-style don't ship {"all":…} for the backend to reject.
-// Returns nil when the flag is empty.
-func borderStylesFromFlag(runtime flagView) (map[string]interface{}, error) {
-	if runtime.Str("border-styles") == "" {
-		return nil, nil
-	}
-	v, err := parseJSONFlag(runtime, "border-styles")
-	if err != nil {
-		return nil, err
-	}
-	m, ok := v.(map[string]interface{})
-	if !ok {
-		return nil, sheetsValidationForFlag("border-styles", "--border-styles must be a JSON object")
-	}
-	expandBorderAllShorthand(m)
-	return m, nil
-}
-
-// requireAnyStyleFlag ensures at least one style-defining flag (style or
-// border) is set — otherwise the request would do nothing.
-func requireAnyStyleFlag(runtime flagView) error {
-	if len(buildCellStyleFromFlags(runtime)) > 0 {
-		return nil
-	}
-	if runtime.Str("border-styles") != "" {
-		return nil
-	}
-	return common.ValidationErrorf("at least one style flag is required (e.g. --background-color, --font-weight, --border-styles)").
-		WithParams(
-			sheetsInvalidParam("background-color", "required; specify at least one style flag"),
-			sheetsInvalidParam("font-weight", "required; specify at least one style flag"),
-			sheetsInvalidParam("border-styles", "required; specify at least one style flag"),
-		)
-}
-
-// foldBorderFamilyAliases rewrites the habitual flattened border vocabulary
-// (Excel / openpyxl conventions) into the canonical nested border_styles
-// object, in place. 07-20 eval: the border family alone accounted for the
-// largest --styles error cluster (borders / border / border_bottom /
-// border_style / border_top_color / …), each burning a full payload retry.
-// Accepted rewrites, all unambiguous:
-//
-//	borders / border   (object) → border_styles (side-keyed) or border_styles.all (attr-keyed)
-//	border_top|bottom|left|right (object) → border_styles.<side>
-//	border_style|color|weight  (scalar)  → border_styles.all.<attr>
-//	border_<side>_<style|color|weight> (scalar) → border_styles.<side>.<attr>
-//
-// A border_style value from the WEIGHT vocabulary (thin/medium/thick — the
-// habitual Excel word) sets weight and defaults style to solid: a "thin
-// border" always means a thin solid line. Conflicts with an explicitly given
-// border_styles error out instead of picking a side.
-func foldBorderFamilyAliases(in map[string]interface{}, path string) error {
-	sides := map[string]bool{"top": true, "bottom": true, "left": true, "right": true, "all": true}
-	attrs := map[string]bool{"style": true, "color": true, "weight": true}
-	borderWeights := map[string]bool{"thin": true, "medium": true, "thick": true}
-
-	ensureBorder := func() map[string]interface{} {
-		bs, ok := in["border_styles"].(map[string]interface{})
-		if !ok {
-			bs = map[string]interface{}{}
-			in["border_styles"] = bs
-		}
-		return bs
-	}
-	setSideAttr := func(side, attr string, v interface{}, from string) error {
-		bs := ensureBorder()
-		sideObj, ok := bs[side].(map[string]interface{})
-		if !ok {
-			if _, exists := bs[side]; exists {
-				return common.ValidationErrorf("%s.%s conflicts with border_styles.%s; keep one form", path, from, side)
-			}
-			sideObj = map[string]interface{}{}
-			bs[side] = sideObj
-		}
-		if _, exists := sideObj[attr]; exists {
-			return common.ValidationErrorf("%s.%s conflicts with border_styles.%s.%s; keep one form", path, from, side, attr)
-		}
-		sideObj[attr] = v
-		return nil
-	}
-	setSide := func(side string, v interface{}, from string) error {
-		obj, ok := v.(map[string]interface{})
-		if !ok {
-			return common.ValidationErrorf("%s.%s must be an object like {\"style\":\"solid\",\"color\":\"#000000\"}", path, from)
-		}
-		for attr, av := range obj {
-			if !attrs[attr] {
-				return common.ValidationErrorf("%s.%s.%s is not a border attribute (want style/weight/color)", path, from, attr)
-			}
-			if err := setSideAttr(side, attr, av, from); err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-	// border_style with a weight-vocabulary value means "thin solid line".
-	setAllScalar := func(attr string, v interface{}, from string) error {
-		if attr == "style" {
-			if s, ok := v.(string); ok && borderWeights[strings.ToLower(s)] {
-				if err := setSideAttr("all", "weight", strings.ToLower(s), from); err != nil {
-					return err
-				}
-				return setSideAttr("all", "style", "solid", from)
-			}
-		}
-		return setSideAttr("all", attr, v, from)
-	}
-
-	for _, key := range []string{"borders", "border"} {
-		v, has := in[key]
-		if !has {
-			continue
-		}
-		obj, ok := v.(map[string]interface{})
-		if !ok {
-			return common.ValidationErrorf("%s.%s must be an object — either side-keyed ({\"top\":{…},\"bottom\":{…}} / {\"all\":{…}}) or attribute-keyed ({\"style\":\"solid\",\"color\":\"#000\"} = all four sides)", path, key)
-		}
-		sideKeyed := false
-		for k := range obj {
-			if sides[k] {
-				sideKeyed = true
-				break
-			}
-		}
-		if sideKeyed {
-			for side, sv := range obj {
-				if !sides[side] {
-					return common.ValidationErrorf("%s.%s.%s is not a valid side (want top/bottom/left/right/all)", path, key, side)
-				}
-				if err := setSide(side, sv, key); err != nil {
-					return err
-				}
-			}
-		} else if err := setSide("all", v, key); err != nil {
-			return err
-		}
-		delete(in, key)
-	}
-	for _, side := range []string{"top", "bottom", "left", "right"} {
-		// Both word orders appear in the wild: border_bottom (07-20 eval) and
-		// bottom_border (07-21), same for the flattened attribute triples.
-		for _, key := range []string{"border_" + side, side + "_border"} {
-			if v, has := in[key]; has {
-				if err := setSide(side, v, key); err != nil {
-					return err
-				}
-				delete(in, key)
-			}
-		}
-		for attr := range attrs {
-			for _, key := range []string{"border_" + side + "_" + attr, side + "_border_" + attr} {
-				if v, has := in[key]; has {
-					if err := setSideAttr(side, attr, v, key); err != nil {
-						return err
-					}
-					delete(in, key)
-				}
-			}
-		}
-	}
-	for attr := range attrs {
-		key := "border_" + attr
-		if v, has := in[key]; has {
-			if err := setAllScalar(attr, v, key); err != nil {
-				return err
-			}
-			delete(in, key)
-		}
-	}
-	return nil
-}

shortcuts/sheets/styles_acceptance_test.go

@@ -1,410 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package sheets
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-// ─── styles acceptance contract ───────────────────────────────────────
-//
-// Two closure properties that turn the --styles acceptance surface from
-// "endless patching" into a locked contract (07-20 rerun lesson: the
-// redesign moved traffic onto the payload path while the flag path's
-// forgiveness layers stayed behind):
-//
-//  1. Vocabulary parity — every style the flag path (+cells-set-style)
-//     can express must be accepted verbatim by the payload path.
-//  2. Prior corpus — every model spelling observed in eval traces must
-//     either normalize to the canonical form or produce a targeted
-//     prescription. Silent ignoring and bare rejection are both bugs.
-//     New eval finding → add a corpus row → fix → locked forever.
-
-// acceptStyleItem runs one cell_styles item through the styles-put pipeline
-// and returns the emitted cell prototype (cell_styles/border_styles) or the
-// error.
-func acceptStyleItem(t *testing.T, fields map[string]interface{}) (map[string]interface{}, error) {
-	t.Helper()
-	item := map[string]interface{}{"range": "A1:B2"}
-	for k, v := range fields {
-		item[k] = v
-	}
-	ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-		"styles": []interface{}{map[string]interface{}{
-			"name":        "S1",
-			"cell_styles": []interface{}{item},
-		}},
-	}), testToken)
-	if err != nil {
-		return nil, err
-	}
-	input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-	cells := input["cells"].([][]interface{})
-	return cells[0][0].(map[string]interface{}), nil
-}
-
-// TestStylesAcceptance_VocabularyParity locks property 1: iterate the
-// +cells-set-style flag vocabulary from flag-defs and assert the payload
-// path accepts each field with a valid value and emits it.
-func TestStylesAcceptance_VocabularyParity(t *testing.T) {
-	t.Parallel()
-	defs, err := loadFlagDefs()
-	if err != nil {
-		t.Fatalf("loadFlagDefs: %v", err)
-	}
-	spec, ok := defs["+cells-set-style"]
-	if !ok {
-		t.Fatal("no +cells-set-style flag defs")
-	}
-	sample := func(df flagDef) interface{} {
-		if len(df.Enum) > 0 {
-			return df.Enum[0]
-		}
-		switch df.Type {
-		case "float64", "int":
-			return float64(12)
-		}
-		switch df.Name {
-		case "font-family":
-			return "Arial"
-		case "number-format":
-			return "0.00"
-		default: // colors and any future string field
-			return "#112233"
-		}
-	}
-	for _, df := range spec.Flags {
-		if df.Kind != "own" || df.Name == "range" {
-			continue
-		}
-		df := df
-		t.Run(df.Name, func(t *testing.T) {
-			t.Parallel()
-			field := strings.ReplaceAll(df.Name, "-", "_")
-			var value interface{}
-			if df.Name == "border-styles" {
-				value = map[string]interface{}{"all": map[string]interface{}{"style": "solid"}}
-			} else {
-				value = sample(df)
-			}
-			proto, err := acceptStyleItem(t, map[string]interface{}{field: value})
-			if err != nil {
-				t.Fatalf("payload path rejects flag-path field %s: %v", field, err)
-			}
-			if df.Name == "border-styles" {
-				if _, ok := proto["border_styles"].(map[string]interface{}); !ok {
-					t.Fatalf("border_styles not emitted: %v", proto)
-				}
-				return
-			}
-			cs, _ := proto["cell_styles"].(map[string]interface{})
-			if cs == nil || cs[field] == nil {
-				t.Fatalf("field %s silently dropped: %v", field, proto)
-			}
-		})
-	}
-}
-
-// stylesPriorCorpus is the observed-model-spelling corpus (source: eval
-// batches 2026-07-08 → 07-20). Every row must either normalize (checked via
-// wantCell) or produce a targeted prescription (wantErr). Add a row for every
-// new spelling an eval surfaces — never let one be silently ignored.
-var stylesPriorCorpus = []struct {
-	name    string
-	fields  map[string]interface{}
-	wantErr string                                    // "" = must be accepted
-	check   func(proto map[string]interface{}) string // "" = ok, else failure detail
-}{
-	// border family (07-20: largest cluster)
-	{name: "borders attr-keyed means all sides",
-		fields: map[string]interface{}{"borders": map[string]interface{}{"style": "solid", "color": "#DDDDDD"}},
-		check:  wantBorder("top", "style", "solid")},
-	{name: "border side-keyed",
-		fields: map[string]interface{}{"border": map[string]interface{}{"top": map[string]interface{}{"style": "solid"}}},
-		check:  wantBorder("top", "style", "solid")},
-	{name: "border_bottom object",
-		fields: map[string]interface{}{"border_bottom": map[string]interface{}{"style": "solid"}},
-		check:  wantBorder("bottom", "style", "solid")},
-	{name: "border_style weight-vocabulary means thin solid",
-		fields: map[string]interface{}{"border_style": "thin"},
-		check:  wantBorder("top", "weight", "thin")},
-	{name: "border_style style-vocabulary",
-		fields: map[string]interface{}{"border_style": "dashed"},
-		check:  wantBorder("top", "style", "dashed")},
-	{name: "border_color scalar",
-		fields: map[string]interface{}{"border_color": "#FF0000"},
-		check:  wantBorder("top", "color", "#FF0000")},
-	{name: "border_top_color flattened",
-		fields: map[string]interface{}{"border_top_color": "#FF0000"},
-		check:  wantBorder("top", "color", "#FF0000")},
-	{name: "border_left_weight flattened",
-		fields: map[string]interface{}{"border_left_weight": "thin"},
-		check:  wantBorder("left", "weight", "thin")},
-	{name: "border_styles invalid side prescribed",
-		fields:  map[string]interface{}{"border_styles": map[string]interface{}{"outer": map[string]interface{}{"style": "solid"}}},
-		wantErr: "not a valid side"},
-	// wrap family
-	{name: "wrap_text boolean", fields: map[string]interface{}{"wrap_text": true}, check: wantStyle("word_wrap", "auto-wrap")},
-	{name: "text_wrap string", fields: map[string]interface{}{"text_wrap": "auto-wrap"}, check: wantStyle("word_wrap", "auto-wrap")},
-	{name: "word_wrap false", fields: map[string]interface{}{"word_wrap": false}, check: wantStyle("word_wrap", "overflow")},
-	// alignment family
-	{name: "horizontal_align shorthand", fields: map[string]interface{}{"horizontal_align": "center"}, check: wantStyle("horizontal_alignment", "center")},
-	{name: "valign shorthand", fields: map[string]interface{}{"valign": "top"}, check: wantStyle("vertical_alignment", "top")},
-	{name: "CSS center for vertical", fields: map[string]interface{}{"vertical_alignment": "center"}, check: wantStyle("vertical_alignment", "middle")},
-	{name: "casing normalized", fields: map[string]interface{}{"font_weight": "BOLD"}, check: wantStyle("font_weight", "bold")},
-	// weight vocabulary in the FULL nested form's style slot (07-21 rerun:
-	// the dominant residual — 8 tasks wrote border_styles.<side>.style:"thin")
-	{name: "full-form thin in style slot",
-		fields: map[string]interface{}{"border_styles": map[string]interface{}{"top": map[string]interface{}{"style": "thin"}}},
-		check:  wantBorder("top", "weight", "thin")},
-	{name: "full-form all-shorthand medium in style slot",
-		fields: map[string]interface{}{"border_styles": map[string]interface{}{"all": map[string]interface{}{"style": "medium"}}},
-		check:  wantBorder("bottom", "weight", "medium")},
-	// side-first word order + Google Sheets wrap word (07-21 evening batch)
-	{name: "side-first bottom_border object",
-		fields: map[string]interface{}{"bottom_border": map[string]interface{}{"style": "solid"}},
-		check:  wantBorder("bottom", "style", "solid")},
-	{name: "side-first bottom_border_style scalar",
-		fields: map[string]interface{}{"bottom_border_style": "solid"},
-		check:  wantBorder("bottom", "style", "solid")},
-	{name: "wrap_strategy aliases to word_wrap",
-		fields: map[string]interface{}{"wrap_strategy": "auto-wrap"},
-		check:  wantStyle("word_wrap", "auto-wrap")},
-	// prescriptions (ambiguous / unsupported / typo)
-	{name: "fore_color prescribed", fields: map[string]interface{}{"fore_color": "#F00"}, wantErr: "ambiguous"},
-	{name: "indent rejected not ignored", fields: map[string]interface{}{"indent": float64(2)}, wantErr: "not a supported style field"},
-	{name: "unknown field carries did-you-mean and the field list",
-		fields: map[string]interface{}{"fontcolor": "#000000"}, wantErr: `did you mean "font_color"`},
-	{name: "enum typo gets did-you-mean", fields: map[string]interface{}{"vertical_alignment": "botom"}, wantErr: "did you mean"},
-}
-
-func wantStyle(field, want string) func(map[string]interface{}) string {
-	return func(proto map[string]interface{}) string {
-		cs, _ := proto["cell_styles"].(map[string]interface{})
-		if cs == nil || cs[field] != want {
-			return fmt.Sprintf("cell_styles.%s = %v, want %q", field, cs[field], want)
-		}
-		return ""
-	}
-}
-
-func wantBorder(side, attr, want string) func(map[string]interface{}) string {
-	return func(proto map[string]interface{}) string {
-		bs, _ := proto["border_styles"].(map[string]interface{})
-		sideObj, _ := bs[side].(map[string]interface{})
-		if sideObj == nil || sideObj[attr] != want {
-			return fmt.Sprintf("border_styles.%s.%s = %v, want %q", side, attr, sideObj[attr], want)
-		}
-		return ""
-	}
-}
-
-func TestStylesAcceptance_PriorCorpus(t *testing.T) {
-	t.Parallel()
-	for _, tc := range stylesPriorCorpus {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			proto, err := acceptStyleItem(t, tc.fields)
-			if tc.wantErr != "" {
-				if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
-					t.Fatalf("want prescription containing %q, got err=%v", tc.wantErr, err)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("corpus spelling rejected: %v", err)
-			}
-			if detail := tc.check(proto); detail != "" {
-				t.Fatal(detail)
-			}
-		})
-	}
-}
-
-// TestStylesPut_CoalescesSameStyleRanges pins the declarative-spec
-// optimization: per-row entries with the identical style fuse into one
-// rectangle, so row-by-row specs (07-21 rerun: 184/203/861-op expansions
-// against the 100-op cap) no longer hit the cap.
-func TestStylesPut_CoalescesSameStyleRanges(t *testing.T) {
-	t.Parallel()
-
-	t.Run("150 same-style rows fuse into one stamp", func(t *testing.T) {
-		t.Parallel()
-		entries := make([]interface{}, 0, 150)
-		for r := 1; r <= 150; r++ {
-			entries = append(entries, map[string]interface{}{
-				"range": fmt.Sprintf("A%d:F%d", r, r), "font_weight": "bold",
-			})
-		}
-		ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{"name": "S1", "cell_styles": entries}},
-		}), testToken)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if len(ops) != 1 {
-			t.Fatalf("got %d ops, want 1 fused stamp", len(ops))
-		}
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		if input["range"] != "A1:F150" {
-			t.Fatalf("range = %v, want A1:F150", input["range"])
-		}
-	})
-
-	t.Run("different styles stay separate", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{"name": "S1", "cell_styles": []interface{}{
-				map[string]interface{}{"range": "A1:F1", "font_weight": "bold"},
-				map[string]interface{}{"range": "A2:F2", "background_color": "#EEEEEE"},
-			}}},
-		}), testToken)
-		if err != nil || len(ops) != 2 {
-			t.Fatalf("ops=%d err=%v, want 2", len(ops), err)
-		}
-	})
-
-	t.Run("horizontal fuse with same rows", func(t *testing.T) {
-		t.Parallel()
-		ops, err := stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{"name": "S1", "cell_styles": []interface{}{
-				map[string]interface{}{"range": "A1:C5", "font_weight": "bold"},
-				map[string]interface{}{"range": "D1:F5", "font_weight": "bold"},
-			}}},
-		}), testToken)
-		if err != nil || len(ops) != 1 {
-			t.Fatalf("ops=%d err=%v, want 1", len(ops), err)
-		}
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		if input["range"] != "A1:F5" {
-			t.Fatalf("range = %v, want A1:F5", input["range"])
-		}
-	})
-}
-
-// TestTypedCellsHabitualKeys pins the typed --cells cell-object fixes
-// (recurring server-side 900015206 across 07-20/07-21 reruns).
-func TestTypedCellsHabitualKeys(t *testing.T) {
-	t.Parallel()
-
-	t.Run("style object rewrites to cell_styles through batch", func(t *testing.T) {
-		t.Parallel()
-		translated, err := translateBatchOp(subOp("+cells-set", map[string]interface{}{
-			"sheet_name": "S1", "range": "A1",
-			"cells": []interface{}{[]interface{}{map[string]interface{}{
-				"value": "x", "style": map[string]interface{}{"font_weight": "bold"},
-			}}},
-		}), testToken, 0)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := translated["input"].(map[string]interface{})
-		cell := input["cells"].([]interface{})[0].([]interface{})[0].(map[string]interface{})
-		cs, _ := cell["cell_styles"].(map[string]interface{})
-		if cs == nil || cs["font_weight"] != "bold" {
-			t.Fatalf("cell = %v, want cell_styles.font_weight bold", cell)
-		}
-		if _, has := cell["style"]; has {
-			t.Fatalf("style key must be renamed, got %v", cell)
-		}
-	})
-
-	t.Run("type key gets a prescription", func(t *testing.T) {
-		t.Parallel()
-		_, err := translateBatchOp(subOp("+cells-set", map[string]interface{}{
-			"sheet_name": "S1", "range": "A1",
-			"cells": []interface{}{[]interface{}{map[string]interface{}{
-				"value": "x", "type": "text",
-			}}},
-		}), testToken, 0)
-		requireValidation(t, err, "not a cell field")
-	})
-}
-
-// TestStylesAcceptance_ResizeAndMergeCorpus extends the corpus to the
-// row/col_sizes and cell_merges sections.
-func TestStylesAcceptance_ResizeAndMergeCorpus(t *testing.T) {
-	t.Parallel()
-
-	runSection := func(section string, entry interface{}) ([]interface{}, error) {
-		return stylesPutOperations(stylesPutView(map[string]interface{}{
-			"styles": []interface{}{map[string]interface{}{
-				"name":  "S1",
-				section: []interface{}{entry},
-			}},
-		}), testToken)
-	}
-	pixelValue := func(t *testing.T, ops []interface{}, key string) interface{} {
-		t.Helper()
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		block, _ := input[key].(map[string]interface{})
-		if block == nil || block["type"] != "pixel" {
-			t.Fatalf("%s = %v, want pixel block", key, input[key])
-		}
-		return block["value"]
-	}
-
-	t.Run("size alone implies pixel", func(t *testing.T) {
-		t.Parallel()
-		ops, err := runSection("row_sizes", map[string]interface{}{"range": "1:1", "size": float64(36)})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if v := pixelValue(t, ops, "resize_height"); v != 36 {
-			t.Fatalf("value = %v, want 36", v)
-		}
-	})
-
-	t.Run("width alone implies pixel on col_sizes", func(t *testing.T) {
-		t.Parallel()
-		ops, err := runSection("col_sizes", map[string]interface{}{"range": "A:C", "width": float64(120)})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if v := pixelValue(t, ops, "resize_width"); v != 120 {
-			t.Fatalf("value = %v, want 120", v)
-		}
-	})
-
-	t.Run("type auto still works on rows", func(t *testing.T) {
-		t.Parallel()
-		if _, err := runSection("row_sizes", map[string]interface{}{"range": "1:1", "type": "auto"}); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-	})
-
-	t.Run("neither size nor type prescribed", func(t *testing.T) {
-		t.Parallel()
-		_, err := runSection("row_sizes", map[string]interface{}{"range": "1:1"})
-		requireValidation(t, err, "needs size (px) or type")
-	})
-
-	t.Run("wrong-dimension word prescribed", func(t *testing.T) {
-		t.Parallel()
-		_, err := runSection("col_sizes", map[string]interface{}{"range": "A:C", "height": float64(36)})
-		requireValidation(t, err, "does not apply")
-	})
-
-	t.Run("raw OpenAPI merge_type accepted", func(t *testing.T) {
-		t.Parallel()
-		ops, err := runSection("cell_merges", map[string]interface{}{"range": "A1:B2", "merge_type": "MERGE_ALL"})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		input := ops[0].(map[string]interface{})["input"].(map[string]interface{})
-		if input["merge_type"] != "all" {
-			t.Fatalf("merge_type = %v, want all", input["merge_type"])
-		}
-	})
-
-	t.Run("bare string merge accepted", func(t *testing.T) {
-		t.Parallel()
-		if _, err := runSection("cell_merges", "A1:B2"); err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-	})
-}

skills/lark-sheets/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lark-sheets
-version: 3.1.0
+version: 3.0.2
 description: "飞书电子表格：创建和操作电子表格。支持创建表格、管理工作表与行列结构（增删/合并/调整尺寸/隐藏/冻结）、读写单元格（值/公式/样式/批注/单元格图片）、查找替换、多操作原子批量更新，以及图表、透视表、条件格式、筛选器、迷你图、浮动图片等对象的创建与维护。当用户需要创建电子表格、管理工作表、批量读写或编辑数据、统计汇总与可视化、表格美化、公式计算（含 Excel 公式迁移）、金融/财务建模（DCF、三张表、预算、Sensitivity 等）等任务时使用。若用户是想按名称或关键词搜索云空间（云盘/云存储）里的表格文件，请改用 lark-drive 的 drive +search 先定位资源。当用户给出 doubao.com 的 /sheets/ URL/token 时，也应直接使用本 skill，不要因为域名不是飞书而回退到 WebFetch；路由依据是 URL 路径模式和 token，而不是域名。"
 metadata:
   requires:
@@ -35,11 +35,10 @@ metadata:
 3. **读全再写**：批量填充 / 补齐 / 修正类任务先确认真实数据末行再写，只探前 N 行会漏写表尾（确定末行流程见 `lark-sheets-read-data`）。
 4. **公式优先于硬编码**：能用公式表达的计算（总计 / 占比 / 提取 / 查找）一律写公式而非静态值——**凡可由表内其它单元格推导的派生值默认用公式，即使用户没说"联动"**；写公式前先读 `lark-sheets-formula-translation`，**公式落表后收尾必跑 `+formula-verify` 直到 `status='success'`**。
 5. **续写 / 扩展继承样式**：续写、补齐、复制区块、新增行列时禁止只读值只写值，必须连带 `cell_styles` + `border_styles` + 合并 + 行高一起继承（清单见 `lark-sheets-write-cells`，四边框最易漏）。
-6. **多步写入分流**：美化收尾（样式 / 合并 / 行高列宽 / 冻结的任意组合）→ 一次 `+styles-put` 声明式规格交付（见 `lark-sheets-styles-put`）；**同一个写操作**打多个区域 → 用该命令自身的复数形态（`--ranges` / map 入参）；只有**跨类型的原子操作链**（如插列 → 写表头 → 回填数据）才用 `+batch-update`（high-risk-write，**调用必带 `--yes`**，fail-fast 不回滚；语义见 `lark-sheets-batch-update`）。
+6. **多步写入合并 `+batch-update`**：多个连续写入、或同一工具对多区域重复调用，合并为单次原子 `+batch-update`（high-risk-write，**调用必带 `--yes`**；语义见 `lark-sheets-batch-update`）。
 7. **分组汇总用透视表**："按 X 统计 Y / 分组汇总 / 各类数量金额"用 `+pivot-{create|update|delete}`，禁止用 SUMIF / 本地脚本拼一张假透视表。
 8. **拆成可验证 checklist**：落地前把指令拆成所有"独立可验证子要点"，逐点 `assert` 全过才交付（多维排序每维一点、多目标每目标一点、范围类核起 / 末 / 边界）；只做第一个要点属违规。
 9. **全量处理前置断言条数**：翻译 / 打标 / 批量公式落地等逐条任务，先把预期条数硬编码再 `assert actual == expected`，禁止输出"已完成前 N 条，剩余继续"的半成品。
-10. **缺失值不编造**：补齐 / 扩展 / 按原表格式续填时，查不到或无法确定的值一律留空 + 备注注明（"暂未发布 / 未知 / 待核实"），禁止用推算值 / 估算值 / 凭空数据充数；原表若已示范缺失值写法（空值 + 备注），照抄该约定。宁可留空标注，不填不可靠的数。
 
 > 端到端工作流：了解结构（`+workbook-info`）→ 读数据 → 理解语义 → 原生工具优先 → 写入 → 回读验证；实操展开见下方「执行要点」。
 
@@ -49,12 +48,12 @@ metadata:
 
 | 你要做的事 | ✅ 正确写法 | 动手前读 | ❌ 不存在（会被 cobra 拒） |
 | --- | --- | --- | --- |
-| 读数据（纯值 / CSV） | `+csv-get`（`--range` 可省略 = 读整个子表，无需先探行列；限定范围才传） | `lark-sheets-read-data` | `+get-range`、`+range-get`、`+cells-read` |
+| 读数据（纯值 / CSV） | `+csv-get`（范围用 `--range`） | `lark-sheets-read-data` | `+get-range`、`+range-get`、`+cells-read` |
 | 读值 + 公式 / 样式 / 批注 | `+cells-get --include value,formula,style,comment,data_validation` | `lark-sheets-read-data` | `+get-cell`、`+cell-get`、`--with-styles`、`--with-merges`、`--include-merged-cells` |
 | 写纯文本值（整块 CSV 平铺；列里没有需字面保真的编号 / 点分日期） | `+csv-put`（定位用 `--start-cell` 左上角锚点格，也接受 `--range` 别名） | `lark-sheets-write-cells` | 把含点分日期(`12.10`)/编号(`001`)的列裸灌 `+csv-put`——会被数值化（`12.10`→`12.1`、`001`→`1`），改用 `+table-put` 声明 `dtypes:object` |
 | 写带类型的数据到**已有**表（列里有数字 / 金额 / 百分比 / 日期等**量值**——不看当下要不要排序求和，量值一律走这里） | `+table-put --sheets '{"sheets":[{"name":…,"columns":[…],"dtypes":{…},"formats":{…},"data":[[…]]}]}'`（不存在的 sheet 名自动建子表；同时美化加 `--styles` 一步带样式，详见 write-cells） | `lark-sheets-write-cells` | 在本地把数字拼成 `"$1,234"` / `"30.5%"` 字符串再 `+csv-put`（落成文本、丢计算能力，见下方 ⚠️） |
 | **新建**电子表格并写带类型的数据（类型保真需求同上，但目标表还不存在） | `+workbook-create --sheets`（协议与 `+table-put` 同构、一步建表 + typed 写入，无需先建空表再 `+table-put`；date / number 不丢；`--styles` 同样可在建表同一步带全套样式，详见 workbook） | `lark-sheets-workbook` | 用 `--values` 灌日期 / 数字（会落成文本、丢类型） |
-| 写公式 / 富写入（样式 · 批注 · 图片 · 富文本），或需精确矩形定位的值 | `+cells-set`（单区域 `--range`+`--cells`；**散布多处 / 跨表用 `--writes` 一次原子交付**，每项自带 sheet_name；公式落表后继续 `+formula-verify` 收尾） | `lark-sheets-write-cells` | — |
+| 写公式 / 富写入（样式 · 批注 · 图片 · 富文本），或需精确矩形定位的值 | `+cells-set`（定位用 `--range`；批注 / 图片 / 富文本只能用它，公式也可；**公式落表后继续 `+formula-verify` 收尾**） | `lark-sheets-write-cells` | — |
 | 插图：图片**绑定到某条记录**、随行走（凭证 / 证件照 / 商品图 / 头像 / 二维码 / 每行配图） | `+cells-set-image`（单格 `--range`，嵌入单元格内） | `lark-sheets-write-cells` | — |
 | 插图：**自由摆放、不绑数据**的装饰 / 标识（logo / 水印 / 封面大图 / banner） | `+float-image-create`（浮动图片，自由定位 + 尺寸 + 层级） | `lark-sheets-float-image` | — |
 | 查找 / 替换文本 | `+cells-search`（找，关键字用 `--find`）、`+cells-replace`（替换） | `lark-sheets-search-replace` | `+cells-find`、`+find`、`--query` |
@@ -65,19 +64,18 @@ metadata:
 | 导出 xlsx / 单表 csv | `+workbook-export` | `lark-sheets-workbook` | — |
 | 导入本地 xlsx/xls/csv 文件为飞书电子表格 | `+workbook-import --file ./x.xlsx`（仅要导成多维表格 bitable 时才用 `drive +import --type bitable`） | `lark-sheets-workbook` | `drive +import`（绕路）、本地读 .xlsx 再 `+workbook-create` 重灌（多此一举）、想并入**已有工作簿**却用它（import 只会另起新表，加子表走 `+sheet-copy` / `+sheet-create`） |
 | 参考某个**已有在线表**、把多份数据各作为一张子表**追加**进去 | 先 `+workbook-info` → `+sheet-copy` 复制模板子表（公式 / 合并 / 底色 / 列宽全继承）再 `+cells-*` 只改数据；无模板可继承时 `+sheet-create` + `+table-put --sheets/--styles` | `lark-sheets-workbook` | `+workbook-import` / `+workbook-create` 另起独立新表（这两条只产新表、不接受已有表定位） |
-| **已有**表美化收尾（样式 / 边框 / 合并 / 行高列宽 / 冻结的任意组合，单表或多表） | `+styles-put --styles '{"styles":[{"name":…,"cell_styles":[…],"cell_merges":[…],"row_sizes":[…],"col_sizes":[…],"freeze":{…}}]}'`（一份规格一次原子交付，词汇同 `+table-put --styles`） | `lark-sheets-styles-put` | 拼 `+batch-update` 的 `--operations` 子操作数组做美化、逐区域多次 `+cells-set-style` |
 | 清除内容 / 格式 | `+cells-clear --yes`（需确认；范围维度用 `--scope`，取值 content / formats / all） | `lark-sheets-range-operations` | `--type` |
 | 批量清除多区域 | `+cells-batch-clear --yes`（需确认；`--scope`） | `lark-sheets-batch-update` | `--target` |
-| 调整列宽 / 行高 | `+cols-resize` / `+rows-resize`（行、列是两个独立命令；连同样式一起调时并入 `+styles-put` 的 `row_sizes` / `col_sizes`） | `lark-sheets-range-operations` | `--dimension`（无此 flag） |
+| 调整列宽 / 行高 | `+cols-resize` / `+rows-resize`（行、列是两个独立命令） | `lark-sheets-range-operations` | `--dimension`（无此 flag） |
 | 分组汇总 / 透视 | `+pivot-create`（默认不传落点 flag → 自动新建子表，零覆盖） | `lark-sheets-pivot-table` | 用 SUMIF / 本地脚本拼一张假透视表 |
-| 画图表 / 可视化（柱 / 折线 / 饼 / 条 / 散点 / 组合…） | `+chart-create`（先 `+chart-create --print-example <column\|bar\|line\|pie\|combo…>` 本地拿最小可用 `--properties` 模板，改 refs / index 即可用） | `lark-sheets-chart` | matplotlib / 本地画图再贴图（原生图表可交互、随数据更新） |
+| 画图表 / 可视化（柱 / 折线 / 饼 / 条 / 散点 / 组合…） | 先读 `lark-sheets-chart`；普通图用 `+chart-create-basic`，多图用一次 `+batch-update --continue-on-error`，已有图的数据源用 `+chart-data-update`、常用配置用 `+chart-config-update`；只有单系列 / 单数据点 / 高级引擎字段才用完整 `+chart-create` / `+chart-update` snapshot | `lark-sheets-chart` | matplotlib / 本地画图再贴图（原生图表可交互、随数据更新） |
 | 条件高亮 / 数据条 / 色阶 / 重复值标记 | `+cond-format-create` | `lark-sheets-conditional-format` | `+highlight`、`+conditional-format`、逐格 `+cells-set-style` 硬凑 |
 | 筛选 / 只看符合条件的行 | `+filter-create` | `lark-sheets-filter` | pandas filter 后覆盖写回（会毁原数据；要保存多份筛选状态用 `+filter-view-create`） |
 
 > ⚠️ **动手前的触发式必读（按动作判定，不看主场景）**：动作里**含样式 / 美化**（底色 / 边框 / 字号 / 对齐 / 数字格式 / 配色 / 列宽行高）→ 先读 `lark-sheets-visual-standards`；**要写飞书公式** → 先读 `lark-sheets-formula-translation`，写完跑 `+formula-verify` 收尾（见 `lark-sheets-formula-verify`）。主任务是建表 / 录入也一样适用。
 > ⚠️ **两种图片别选错**：图**绑定某条记录、随行走**（凭证 / 证件照 / 每行配图）→ `+cells-set-image`；自由摆放的装饰（logo / 水印 / 封面）→ `+float-image-create`。别因「浮动图更熟」默认选浮动图。
 > ⚠️ **纯文本还是数值语义（看数据本质，不看当下用途）**：金额 / 百分比 / 日期 / 计数等**量值**一律数值写入——常规二维表用 `+table-put`（`dtypes` + `formats`），宽表 / 合并表头版式用 `+cells-set` 传数字（百分比传小数 `0.4`）+ `number_format`。只有编号 / 身份证等**标识符**才 `+csv-put` 平铺。"只是展示不用算 / 样式以后再刷"不构成把量值写成字符串的理由——类型不能后补。判据见 `lark-sheets-write-cells`「数字还是文本」。
-> ⚠️ **要新建子表 / 整表美化 → 别「`+csv-put` 写值再事后刷样式」**：`+table-put` / `+workbook-create` 的 `--styles` 在写数据**同一步**带全套样式（底色 / 边框 / 列宽行高 / 合并 / 冻结），payload 里不存在的 sheet 名自动建子表，纯文本表同样适用；比事后多次刷样式少好几次调用。存量表事后美化则一次 `+styles-put` 交付（同一份 `--styles` 词汇）。
+> ⚠️ **要新建子表 / 整表美化 → 别「`+csv-put` 写值再事后刷样式」**：`+table-put` / `+workbook-create` 的 `--styles` 在写数据**同一步**带全套样式（底色 / 边框 / 列宽行高 / 合并），payload 里不存在的 sheet 名自动建子表，纯文本表同样适用；比事后多次刷样式少好几次调用（冻结行列仍需 `+dim-freeze` 单独一步）。
 > ⚠️ **定位 flag**：`+cells-get` / `+cells-set` / `+csv-get` 用 `--range`；`+csv-put` 用 `--start-cell`（也接受 `--range` 别名，区间取左上角）。
 > ⚠️ **读取附加信息**一律走 `+cells-get --include …`（无 `--with-styles` 这类 flag）；**看合并单元格**用 `+sheet-info` 的 `merged_cells`。
 
@@ -86,9 +84,7 @@ metadata:
 ```bash
 lark-cli sheets +cells-set --url <U> --sheet-name S1 --range A1:B1 --cells '[[{"value":"名称"},{"formula":"=SUM(B2:B9)"}]]'  # --cells 恒为二维数组 [[…]]，单格也是 [[{…}]]
 lark-cli sheets +cells-set-style --url <U> --sheet-name S1 --range A1:D1 --font-weight bold --background-color "#F0F0F0" --horizontal-alignment center
-lark-cli sheets +styles-put --url <U> --styles - <<'JSON'
-{"styles":[{"name":"S1","cell_styles":[{"range":"A1:D1","font_weight":"bold","background_color":"#F0F0F0"}],"col_sizes":[{"range":"A:D","type":"pixel","size":120}],"freeze":{"rows":1}}]}
-JSON
+lark-cli sheets +cells-batch-set-style --url <U> --ranges '["S1!A1:B2","汇总!C1:C9"]' --font-weight bold  # range 带表名前缀，无 sheet 定位 flag
 lark-cli sheets +batch-update --url <U> --yes --operations - <<'JSON'
 [{"shortcut":"+cells-set","input":{"sheet_name":"S1","range":"A1","cells":[[{"value":"x"}]]}}]
 JSON
@@ -162,7 +158,6 @@ reference 分两组：先读**通用方法与规范**（横切所有任务的样
 | [Lark Sheet Search & Replace](references/lark-sheets-search-replace.md) | 在飞书表格中搜索和替换文本，支持限定范围、大小写匹配、精确匹配、正则表达式。当用户需要"查找"、"搜索"、"定位"某个值，或"替换"、"批量修改文本"、"把 A 改成 B"时使用。不要用于理解表格结构（应读取数据）、不要用于数据分析（应读取数据后计算）、不要把用户操作动作中的关键词（如"汇总金额""统计数量"）当作搜索词。 |
 | [Lark Sheet Write Cells](references/lark-sheets-write-cells.md) | 向飞书表格的指定区域批量写入值、公式、样式、批注或单元格图片。适用场景：填写数据、设置公式、修改格式、添加批注、嵌入单元格图片（如需操作浮动图片，请使用 lark-sheets-float-image）；若只需把一块 CSV 批量铺到表格上（值或公式，不带样式/批注），直接使用 `+csv-put` 更短更快。追加数据需先通过 lark-sheets-sheet-structure 插入行列。只要这次写入真实落了公式，收尾默认继续执行 `lark-sheets-formula-verify`。 |
 | [Lark Sheet Range Operations](references/lark-sheets-range-operations.md) | 对飞书表格中指定区域执行结构性操作（不涉及写入单元格数据值）。适用场景：清除内容或格式（"清空"、"删除内容"、"去掉格式"）、合并/取消合并单元格、调整行高列宽（"加宽列"、"自适应列宽"）、移动/复制/填充/排序数据（"移动数据"、"复制到"、"自动填充"、"按某列排序"）。写入单元格数据请使用 lark-sheets-write-cells。 |
-| [Lark Sheet Styles Put](references/lark-sheets-styles-put.md) | 把一份声明式视觉规格（样式/边框/合并/行高列宽/冻结）一次性应用到已有飞书表格的多个子表，整份规格原子提交。当任务是对存量表做美化收尾、批量刷样式、统一版式时使用。样式取值标准见 lark-sheets-visual-standards；建新表带样式走 lark-sheets-workbook（+workbook-create --styles）、写数据同步带样式走 lark-sheets-write-cells（+table-put --styles），三者共用同一份 --styles 词汇。仅针对飞书表格。 |
 | [Lark Sheet Batch Update](references/lark-sheets-batch-update.md) | 将多个飞书表格写入操作合并为一次批量执行，按顺序依次完成。适合需要连续执行多个写入操作的场景（如先修改结构再写入数据）。 |
 | [Lark Sheet Chart](references/lark-sheets-chart.md) | 管理飞书表格中的图表（柱形图、折线图、饼图、条形图、面积图、散点图、组合图、雷达图等）。当用户需要创建图表、修改图表样式或数据源、查看已有图表配置、删除图表时使用。也适用于用户提到"数据可视化"、"画个图"、"趋势分析"、"对比图"、"占比分析"、"做个图表"等数据可视化相关场景。 |
 | [Lark Sheet Pivot Table](references/lark-sheets-pivot-table.md) | 管理飞书表格中的数据透视表。当用户需要创建透视表、修改透视表的行列字段/聚合方式/筛选条件、查看已有透视表配置、删除透视表时使用。也适用于用户提到"分组汇总"、"交叉分析"、"按XXX统计"、"按字段分组"、"再分下组"、"多维分析"、"数据透视"等场景。 |
@@ -187,7 +182,7 @@ reference 分两组：先读**通用方法与规范**（横切所有任务的样
    - ⚠️ **不确定 sheet 名时禁止猜 `Sheet1`**：除非对话或上下文已出现具体值，第一步先 `+workbook-info` 拿 `sheets[].sheet_id/title` 再选——中文表的子表常叫"数据"/"工作表 1"/业务名，猜名大概率撞 `sheet not found`。
    - ⚠️ **`--range` 里的 `Sheet1!` 前缀不能替代 sheet 定位**：仍必须传 `--sheet-id` / `--sheet-name`。
    - ⚠️ **A1 引用含 `!` 时整段用单引号包裹**（`--range 'Sheet1!A1:B2'`，挡 bash history expansion；别用 `set +H`，sh/dash 下非法）。sheet 名含 `-`/空格需内层再包单引号时用 `'\''` 转义：`--source ''\''Sales-2025'\''!A1:D100'`。
-   - **例外**：徽章标 `_公共：URL/token（无 sheet 定位）…_` 的 shortcut（`+workbook-info` / `+workbook-export` / `+batch-update` / `+styles-put` / `+dropdown-update|delete` / `+cells-batch-clear` / `+sheet-create`）不接受 sheet 定位。`+pivot-create` 用 `--target-sheet-id/name`（XOR，可都不传）。
+   - **例外**：徽章标 `_公共：URL/token（无 sheet 定位）…_` 的 shortcut（`+workbook-info` / `+workbook-export` / `+batch-update` / `+dropdown-update|delete` / `+cells-batch-set-style` / `+cells-batch-clear` / `+sheet-create`）不接受 sheet 定位。`+pivot-create` 用 `--target-sheet-id/name`（XOR，可都不传）。
 
 ```bash
 # 统一调用范式：两组定位缺一不可（占位符别原样填；表名先 +workbook-info 查）
@@ -205,7 +200,7 @@ lark-cli sheets +csv-get --url "https://.../sheets/shtXXX" --sheet-name "<真实
 
 > ⚠️ **high-risk-write 命令清单（首次调用就带 `--yes`，别等 exit 10 再补；或先 `--dry-run` 预览）**：`+batch-update`、`+cells-clear`、`+cells-batch-clear`、`+sheet-delete`、`+dim-delete`、`+dropdown-delete`，以及各对象删除 `+chart-delete` / `+pivot-delete` / `+cond-format-delete` / `+filter-delete` / `+filter-view-delete` / `+sparkline-delete` / `+float-image-delete`。
 
-**Agent 使用提示**：写复合 JSON flag 前对结构不确定时，先 `--print-schema --flag-name <name>`（深层字段用点分路径切片）再构造 payload；图表直接 `+chart-create --print-example <type>` 拿最小可用模板改参。reference 的 `## Schemas` 段只给一层结构。
+**Agent 使用提示**：写复合 JSON flag 前对结构不确定时，先 `--print-schema --flag-name <name>`（深层字段用点分路径切片）再构造 payload。图表任务必须先读 `lark-sheets-chart`：能用 `+chart-create-basic` / `+chart-data-update` / `+chart-config-update` 的语义参数就不得探查 schema 或构造 snapshot，互不依赖的多图创建 / 更新用一次 `+batch-update --continue-on-error`；只有单系列、单数据点或高级引擎字段无语义参数时，才用 `+chart-create --print-example <type>` 或点分 schema 构造完整 snapshot。reference 的 `## Schemas` 段只给一层结构。
 
 ### flag 内容类型与输出约定（术语速记）
 

skills/lark-sheets/references/lark-sheets-batch-update.md

@@ -5,22 +5,26 @@
 `+batch-update` 把多次写入打包成单次请求，但每个子操作仍受编辑类任务硬性默认规则约束：
 
 1. **目标 range 必须落在用户授权范围内**：除用户明示要修改的区域外，子操作禁止扩张到无关单元格 / 列 / Sheet。规划 range 时先确认每个子操作的边界。
-2. **批次完成后必须回读校验**：整个 `+batch-update` 执行成功后，用 `+csv-get` 或 `+cells-get` 抽样回读受影响区域，至少校验 3-5 个代表性单元格（首 / 中 / 末），与本地脚本预先计算的预期值对照。
-3. **预期条数前置断言**：涉及"批量填充 N 行"或"对 M 个区域分别写入"时，先把 N、M 硬编码进代码，回读后断言实际等于预期；不一致就再发一轮 `+batch-update` 补齐，禁止交付半成品。
+2. **批次完成后必须回读校验**：整个 `+batch-update` 执行成功后，单元格写入用 `+csv-get` 或 `+cells-get` 抽样回读受影响区域，至少校验 3-5 个代表性单元格（首 / 中 / 末）；图表写入用一次 `+chart-list` 核对对象数量、类型、系列和范围。
+3. **预期条数前置断言**：涉及"批量填充 N 行"、"对 M 个区域分别写入"或“每个 / 每天 / 分别各建一张图”时，先从数据数出 N、M 并写进清单；图表场景要断言 operations 中的创建数 = 独立实体图数 + 汇总图数。回读后断言实际等于预期，禁止用一张多系列汇总图替代多张独立图，也禁止交付半成品。
 
-若本次 `+batch-update` 的任一子操作写入了公式、复制了公式模板、或导入了含公式的数据块，**回读校验之后还必须继续执行 `+formula-verify`**。`+batch-update` 只保证"写入动作按序执行了"，不保证整批公式运行结果 zero-error。
+若本次 `+batch-update` 的任一子操作写入了公式、复制了公式模板、或导入了含公式的数据块，**回读校验之后还必须继续执行 `+formula-verify`**。`+batch-update` 的原子提交只保证“写入动作都执行了”，不保证整批公式运行结果 zero-error。
 
 ## 使用场景
 
-写入。把**跨类型、有顺序依赖**的多个写入操作合并为一次请求按序执行（如插列 → 写表头 → 回填数据）。注意：不支持嵌套 `+batch-update`。
+写入。批量执行多个写入工具操作。将多个工具调用合并为一次请求，按顺序依次执行。适合需要连续执行多个写入操作的场景（如先修改结构再写入数据）。注意：不支持嵌套 `+batch-update`。
 
-**先分流再动手（按操作组合选入口）**：美化收尾（样式 / 合并 / 行高列宽 / 冻结的任意组合）→ 一次 `+styles-put`（声明式规格，见 `lark-sheets-styles-put`），不要拼 `--operations` 子操作数组；**同一个写操作**打多个区域 → 用该命令自身的复数形态（`+cells-set --writes` / `+cells-batch-clear` / `+dim-delete --ranges` / resize 的 map 形态等）；只有跨类型的原子操作链才用本命令。
+**不可放进 `--operations` 的写 shortcut**（`shortcut` 枚举不含它们，强行写入会被校验拒）：`+cells-set-image`（需本地上传图片）、`+dropdown-update` / `+dropdown-delete` / `+cells-batch-set-style` / `+cells-batch-clear`（自身已是批量入口，不可再嵌套）、`+dim-move`。这些操作需在 `+batch-update` 之外单独调用。
 
-**不可放进 `--operations` 的写 shortcut**（`shortcut` 枚举不含它们，强行写入会被校验拒）：`+cells-set-image`（需本地上传图片）、`+styles-put` / `+dropdown-update` / `+dropdown-delete` / `+cells-batch-clear`（自身已是批量入口，不可再嵌套）、`+dim-move`。这些操作需在 `+batch-update` 之外单独调用。
+**⚠️ 何时必须使用 `+batch-update`（硬性要求）**：
+- 需要对**多个**不同区域执行 `+cells-{merge|unmerge}` 时（如按分组合并多列相同内容）
+- 需要先插入行列再写入数据时（`+dim-{insert|delete|hide|unhide|freeze|group|ungroup}` + `+cells-set`）
+- 需要对多个区域执行不同写入操作时（多次 `+cells-set` + `+cells-clear` 等组合）
+- 需要创建多张基础图，或统一更新多张图的数据源、标题、坐标轴、图例、标签、堆叠和平滑配置时（多个 `+chart-create-basic` / `+chart-data-update` / `+chart-config-update`）
 
-**行高列宽批量不走这里**：多行 / 多列不同尺寸用 `+styles-put` 的 `row_sizes` / `col_sizes`（可与样式同批），或 `+rows-resize --heights` / `+cols-resize --widths` 的 map 形态（见 `lark-sheets-range-operations`）；map 形态不可作为 `--operations` 子操作嵌入（子操作里仍可用单区间形态 `range` + `height`/`width`）。
+**行高列宽批量不走这里**：多行 / 多列不同尺寸直接用 `+rows-resize --heights` / `+cols-resize --widths` 的 map 形态（如 `--widths '{"A":100,"C:E":120}'`，见 `lark-sheets-range-operations`），一次调用原子完成；map 形态不可作为 `--operations` 子操作嵌入（子操作里仍可用单区间形态 `range` + `height`/`width`）。
 
-**执行语义（fail-fast，不回滚）**：默认首个失败的子操作即中断剩余操作，但**已执行成功的子操作不回滚**——服务端报 "N succeeded, M failed" 时前 N 个已实际生效。修复失败项后**只重发失败起的剩余子集**，整批重发会把已成功的操作（如插行）重复应用。传 `--continue-on-error` 则遇失败仍继续执行剩余操作。正因如此，含结构变更（插删行列 / 移动）的批次失败后要先回读确认现状再续发。
+当同一工具需要对多个区域重复调用时，**必须**改用 `+batch-update` 合并为单次请求。存在依赖关系的操作保持默认严格事务（要么全成功要么整批回滚）；互不依赖的多图表创建/更新使用 `--continue-on-error`，保留成功图表并根据逐项错误只重试失败项。
 
 **公式相关批处理的默认闭环**：
 - 写前：先读 `lark-sheets-formula-translation`，把公式改写成飞书可执行语义。
@@ -34,6 +38,7 @@
 | Shortcut | Risk | 分组 |
 | --- | --- | --- |
 | `+batch-update` | high-risk-write | 批量 |
+| `+cells-batch-set-style` | write | 批量 |
 | `+dropdown-update` | write | 对象 |
 | `+dropdown-delete` | high-risk-write | 对象 |
 | `+cells-batch-clear` | high-risk-write | 批量 |
@@ -46,9 +51,29 @@ _公共：URL/token（无 sheet 定位） · 系统：`--yes`、`--dry-run`_
 
 | Flag | Type | 必填 | 说明 |
 | --- | --- | --- | --- |
-| `--operations` | string + File + Stdin（复合 JSON） | required | JSON 数组：[{"shortcut":"+xxx-yyy","input":{...}}, ...]。shortcut 用 CLI 名；input 是该 shortcut 的入参集——含子表定位 sheet_id（或 sheet_name），但不含 spreadsheet token/url（后者只在顶层 --url/--spreadsheet-token 给一次；+batch-update 顶层没有 --sheet-id）；input 的键是该 shortcut 的 flag 展平成 JSON（如 "range":"A11:B12"），不是再套一层嵌套。基础 flag 查 --help，复合 JSON flag 查 --print-schema --flag-name <flag>；不要手填 operation 字段（由 CLI 按 shortcut 自动注入）。默认 fail-fast：首个失败即中断剩余操作，**已执行的子操作不回滚**（服务端报 "N succeeded, M failed" 时 N 个已生效，修复后只重发失败起的剩余子集，不要整批重发）；传 --continue-on-error 遇失败仍继续；不支持嵌套；按数组顺序串行执行 |
+| `--operations` | string + File + Stdin（复合 JSON） | required | JSON 数组：[{"shortcut":"+xxx-yyy","input":{...}}, ...]。shortcut 用 CLI 名；input 是该 shortcut 的入参集——含子表定位 sheet_id（或 sheet_name），但不含 spreadsheet token/url（后者只在顶层 --url/--spreadsheet-token 给一次；+batch-update 顶层没有 --sheet-id）；input 的键是该 shortcut 的 flag 展平成 JSON（如 "range":"A11:B12"），不是再套一层嵌套。基础 flag 查 --help，复合 JSON flag 查 --print-schema --flag-name <flag>；不要手填 operation 字段（由 CLI 按 shortcut 自动注入）。默认严格事务（首个失败即整批中断），传 --continue-on-error 切换为软批量（遇失败仍继续）；不支持嵌套；按数组顺序串行执行 |
 | `--continue-on-error` | bool | optional | 遇子操作失败时继续执行剩余操作；默认 false（首个失败即整批中断） |
 
+### `+cells-batch-set-style`
+
+_公共：URL/token（无 sheet 定位） · 系统：`--dry-run`_
+
+| Flag | Type | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `--ranges` | string + File + Stdin（简单 JSON） | required | 目标范围 JSON 数组（最多 100 个），每项必须带 sheet 前缀（如 `["Sheet1!A1:B2","Sheet2!D1:D10"]`，前缀裸写不加引号）；前缀必须与 sheet 真实显示名完全一致（含大小写），不接受 sheet reference_id；支持跨 sheet；所有 range 应用同一组 style |
+| `--background-color` | string | optional | 背景颜色（十六进制，如 `#ffffff`） |
+| `--font-color` | string | optional | 字体颜色（十六进制，如 `#000000`） |
+| `--font-family` | string | optional | 字体名称（如 `Arial`、`微软雅黑`） |
+| `--font-size` | float64 | optional | 字体大小（px，例：10、12、14） |
+| `--font-style` | string | optional | 字体样式（可选值：`normal` / `italic`） |
+| `--font-weight` | string | optional | 字重（可选值：`normal` / `bold`） |
+| `--font-line` | string | optional | 字体线条样式（可选值：`none` / `underline` / `line-through`） |
+| `--horizontal-alignment` | string | optional | 水平对齐（可选值：`left` / `center` / `right`） |
+| `--vertical-alignment` | string | optional | 垂直对齐（可选值：`top` / `middle` / `bottom`） |
+| `--word-wrap` | string | optional | 换行策略（可选值：`overflow` / `auto-wrap` / `word-clip`） |
+| `--number-format` | string | optional | 数字格式（例：文本 `@`、数字 `0.00`、货币 `$#,##0.00`、日期 `mm/dd/yyyy`） |
+| `--border-styles` | string + File + Stdin（复合 JSON） | optional | 边框配置 JSON（结构同 +cells-set-style） |
+
 ### `+dropdown-update`
 
 _公共：URL/token（无 sheet 定位） · 系统：`--dry-run`_
@@ -88,9 +113,19 @@ _公共：URL/token（无 sheet 定位） · 系统：`--yes`、`--dry-run`_
 _要批量执行的 CLI shortcut 操作列表，按声明顺序串行执行；任一失败立即中断_
 
 **数组项**（类型 object）：
-- `shortcut` (enum) — CLI shortcut 名（不是底层 MCP tool 名） [+cells-set / +cells-set-style / +cells-clear / +cells-merge / +cells-unmerge / +cells-replace / +csv-put / +dropdown-set / +dim-insert / +dim-delete / +dim-hide / +dim-unhide / +dim-freeze / +dim-group / +dim-ungroup / +rows-resize / +cols-resize / +range-move / +range-copy / +range-fill / +range-sort / +sheet-create / +sheet-delete / +sheet-rename / +sheet-move / +sheet-copy / +sheet-hide / +sheet-unhide / +sheet-set-tab-color / +sheet-show-gridline / +sheet-hide-gridline / +chart-create / +chart-update / +chart-delete / +pivot-create / +pivot-update / +pivot-delete / +cond-format-create / +cond-format-update / +cond-format-delete / +filter-create / +filter-update / +filter-delete / +filter-view-create / +filter-view-update / +filter-view-delete / +sparkline-create / +sparkline-update / +sparkline-delete / +float-image-create / +float-image-update / +float-image-delete]
+- `shortcut` (enum) — CLI shortcut 名（不是底层 MCP tool 名） [+cells-set / +cells-set-style / +cells-clear / +cells-merge / +cells-unmerge / +cells-replace / +csv-put / +dropdown-set / +dim-insert / +dim-delete / +dim-hide / +dim-unhide / +dim-freeze / +dim-group / +dim-ungroup / +rows-resize / +cols-resize / +range-move / +range-copy / +range-fill / +range-sort / +sheet-create / +sheet-delete / +sheet-rename / +sheet-move / +sheet-copy / +sheet-hide / +sheet-unhide / +sheet-set-tab-color / +sheet-show-gridline / +sheet-hide-gridline / +chart-create / +chart-update / +chart-delete / +chart-create-basic / +chart-config-update / +chart-data-update / +pivot-create / +pivot-update / +pivot-delete / +cond-format-create / +cond-format-update / +cond-format-delete / +filter-create / +filter-update / +filter-delete / +filter-view-create / +filter-view-update / +filter-view-delete / +sparkline-create / +sparkline-update / +sparkline-delete / +float-image-create / +float-image-update / +float-image-delete]
 - `input` (object) — 该 shortcut 的入参集——含子表定位 sheet_id（或 sheet_name），但不含 spreadsheet token/url（后者只在顶层 …
 
+### `+cells-batch-set-style` `--border-styles`
+
+_单元格边框配置，含 top/bottom/left/right 四个方向，每个方向的结构相同（见 top）_
+
+**顶层字段**：
+- `top` (object?) { style?: enum, weight?: enum, color?: string }
+- `bottom` (object?) { style?: enum, weight?: enum, color?: string }
+- `left` (object?) { style?: enum, weight?: enum, color?: string }
+- `right` (object?) { style?: enum, weight?: enum, color?: string }
+
 ### `+dropdown-update` `--options`
 
 _列表选项_
@@ -135,6 +170,30 @@ lark-cli sheets +batch-update --url "https://example.feishu.cn/sheets/shtXXX" --
 > ]
 > ```
 
+> **多图表组合**：先完成全部辅助数据，再把每张图的完整语义输入放进同一个批次，并在顶层传 `--continue-on-error`；每项同时记录精确表头范围、数据方向和预期系列数。批次完成后，每个受影响的 sheet 各调用一次 `+chart-list`，不要每创建一张图就读取、调整数据后再删除重建。若数据范围或系列数不符，用 `+chart-data-update` 修正已有图表，不要删除后重建。
+>
+> ```json
+> [
+>   {"shortcut":"+chart-create-basic","input":{"sheet_name":"Sheet1","chart_type":"column","data_range":"'Sheet1'!A1:C10","title":"分类对比","anchor_cell":"F2"}},
+>   {"shortcut":"+chart-create-basic","input":{"sheet_name":"Sheet1","chart_type":"line","data_range":"'Sheet1'!E1:G10","title":"趋势变化","anchor_cell":"F18"}}
+> ]
+> ```
+>
+> ```bash
+> lark-cli sheets +batch-update --url "..." --operations @ops.json --continue-on-error --yes
+> ```
+
+### `+cells-batch-set-style`
+
+多 range 应用同一组 style（服务端走 `+batch-update` 原子事务）：
+
+```bash
+# 表头行 + 汇总行同时刷成蓝底白字
+lark-cli sheets +cells-batch-set-style --url "..." \
+  --ranges '["sheet1!A1:F1","sheet1!A30:F30"]' \
+  --background-color "#1E5BC6" --font-color "#FFFFFF" --font-weight bold
+```
+
 ### `+cells-batch-clear`
 
 多 range 一次性清除（服务端走 `+batch-update` 原子事务）；`--scope` 同 `+cells-clear`（`content` / `formats` / `all`，默认 `content`），`high-risk-write` 强制 `--yes`：
@@ -150,6 +209,6 @@ lark-cli sheets +cells-batch-clear --url "..." \
 
 ### Validate / DryRun / Execute 约束
 
-- `Validate`：`+batch-update` 的 `--operations` 必须合法 JSON，且为非空数组；逐个子操作 `shortcut` / `input` 字段必填校验，input 键必须在该 shortcut 的 flag 词汇表内（未知键报错并提示最近似键与完整键契约）；**校验错误聚合上报**——所有子操作的首错一次性返回，全部修完再重发一次即可；**禁止嵌套 `+batch-update`**。`+cells-batch-clear` 的 `--ranges` 必须 JSON 数组、每项带 sheet 前缀，`high-risk-write` 强制 `--yes` 或 `--dry-run`（`--scope` 默认 `content`）。
-- `DryRun`：按顺序输出每个子操作的目标 API + 请求 body 模板，不发起调用。
-- `Execute`：按声明顺序串行执行；默认 fail-fast——任一子操作失败即中断剩余操作，**已成功的子操作不回滚**，报错会注明已生效数量与「仅重发失败起的剩余子集」的续发方式。
+- `Validate`：`+batch-update` 的 `--operations` 必须合法 JSON，且为非空数组；逐个子操作 `shortcut` / `input` 字段必填校验；**禁止嵌套 `+batch-update`**。`+cells-batch-set-style` 的 `--ranges` 必须 JSON 数组、每项带 sheet 前缀；样式 flag 至少一个非空（或带 `--border-styles`）。`+cells-batch-clear` 的 `--ranges` 同样必须 JSON 数组、每项带 sheet 前缀，`high-risk-write` 强制 `--yes` 或 `--dry-run`（`--scope` 默认 `content`）。
+- `DryRun`：按顺序输出每个子操作的目标 API + 请求 body 模板；首个失败则整批 fail-fast（不实际执行任何后续）。
+- `Execute`：按声明顺序串行执行；任一子操作失败立即中断并回滚到该子操作前状态（具体回滚能力取决于子操作类型，沿用 `+batch-update` 的语义）。

skills/lark-sheets/references/lark-sheets-chart.md

@@ -2,18 +2,30 @@
 
 ## 真对象硬约束
 
-当用户要求"画个图 / 数据可视化 / 趋势图 / 对比图 / 占比图"时，**必须**通过 `+chart-{create|update|delete}` 创建真实的图表对象。**禁止**用本地脚本调 matplotlib / seaborn 生成图片再插入到表格代替——静态图片无法随源数据更新，且失去交互能力。判断标准：交付后 `+chart-list` 必须能返回该对象。
+当用户要求"画个图 / 数据可视化 / 趋势图 / 对比图 / 占比图"时，**必须**通过图表创建命令创建真实的图表对象。**禁止**用本地脚本调 matplotlib / seaborn 生成图片再插入到表格代替——静态图片无法随源数据更新，且失去交互能力。判断标准：交付后 `+chart-list` 必须能返回该对象。
 
 ## 使用场景
 
-读写图表对象。本 reference 覆盖 4 个 shortcut：
+读写图表对象。基础创建和常用更新优先用语义 shortcut，只在高级配置时使用原始 snapshot：
 
 | 操作需求 | 使用工具 | 说明 |
 |---------|---------|------|
 | 查看已有图表 | `+chart-list` | 获取图表的类型、数据源和样式配置 |
-| 创建/更新/删除图表 | `+chart-{create|update|delete}` | 对图表对象执行写入操作 |
+| 按类型和范围创建基础图 | `+chart-create-basic` | 支持 column/bar/line/area/pie/scatter/combo/radar、行/列方向与整图配色；无需构造 snapshot |
+| 修正已有图表的数据范围或方向 | `+chart-data-update` | 服务端重建数据映射，保留标题、样式、位置和尺寸 |
+| 批量创建或更新多个独立图表 | `+batch-update --continue-on-error` | 保留成功图表，并逐项返回失败原因；只重试失败项 |
+| 更新标题、轴、图例、标签、堆叠、平滑或整图配色 | `+chart-config-update` | 无需回写 snapshot，未传字段保持不变 |
+| 高级创建/更新、删除图表 | `+chart-{create|update|delete}` | 按系列/数据点精细设置等高级需求才使用原始 properties |
 
-典型工作流：先读取现有图表了解配置 → 执行创建/更新/删除 → 再次读取验证结果。
+典型工作流：先确认表头和精确数据范围，用 `+chart-create-basic` 一次创建并尽量在同次调用中带上已知标题/轴/标签要求；创建后用 `+chart-list` 验证。已有图表的数据范围或方向错误时用 `+chart-data-update`，常用配置修正用 `+chart-config-update`。只有用户要求单个系列、数据点或高级引擎字段时，才读取现有 snapshot 并调 `+chart-update --properties`。不要为了常用配置先输出整份 schema，也不要删除重建已经创建成功的图表。
+
+**多图表工作流**：先完成所有辅助数据和表头，列出每张目标图的类型、精确数据范围、标题和落点；确认清单后，用一次 `+batch-update --continue-on-error` 批量执行 `+chart-create-basic`。图表之间独立时允许部分成功：按返回的逐项结果定位失败图表，只重试失败项，不要重复创建成功图表。批次后每个受影响的 sheet 各调用一次 `+chart-list`，验证数量、类型、系列和范围。数据尚未稳定时不要提前创建图表；已经成功创建的图表有数据源差异时批量使用 `+chart-data-update`，有配置差异时批量使用 `+chart-config-update`，不要删除重建。
+
+**数量词必须展开**：用户说“每个 / 每天 / 分别 / 逐一 / 各一张图”时，先从数据中数出实体数 `N`，把这 `N` 张图逐项写进清单，再加上其它汇总图得到目标总数 `M`；一个包含全部实体的多系列图不能替代这 `N` 张独立图。批次前断言 operations 中恰有 `M` 个图表创建，批次后断言图表总数、逐图标题与实体集合一致。
+
+**范围与系列前置校验**：清单中同时记录每张图的表头范围、纳入列、明确排除列、数据方向和预期系列数。表头在首列时用默认 `--data-direction column`；表头在首行、每行代表一个系列时用 `--data-direction row`。创建前根据实际表头确认边界，不凭字母猜范围；创建后范围、方向或系列数不符时，使用 `+chart-data-update` 修正，服务端会重建 `refs` / `dim1` / `dim2.series` 并保留其它配置，不要删除后重建。批次跨多个 sheet 时，每个受影响的 sheet 各调用一次 `+chart-list`。
+
+**整图配色优先走语义参数**：只要求统一主题或一组系列颜色时，在创建时传 `--color-palette` 或 `--colors`，已有图表用 `+chart-config-update` 更新；二者互斥。只有指定某个系列或某个数据点的颜色时才使用原始 snapshot。
 
 ## 需求→图表类型映射（创建前必查）
 
@@ -29,6 +41,8 @@
 
 **`--properties` 结构锚点（构造前必读）**：`--properties` 顶层只有 `position` / `offset` / `size` / `snapshot` 四个字段，**没有**顶层 `data`，也没有再嵌一层 `properties`。图表数据配置全部挂在 `snapshot.data` 下——下文及示例里出现的 `refs` / `headerMode` / `dim1` / `dim2` / `nameRef` 一律指 `snapshot.data.refs` / `snapshot.data.headerMode` / `snapshot.data.dim1` / `snapshot.data.dim2`（及其下的 `serie.nameRef` / `series[].nameRef`）；样式 / 堆叠 / 数据标签等在 `snapshot.plotArea` 下。**构造起点优先用 `lark-cli sheets +chart-create --print-example <column|bar|line|area|pie|scatter|radar|combo>` 拿最小可用模板改参**（本地即时返回）；查深层字段用点分路径切片 `--print-schema --flag-name properties.snapshot.plotArea.axes`，别整篇 dump 翻页。完整结构以 `--print-schema --flag-name properties` 为准。
 
+**`+chart-update` 局部更新硬规则（更新前必读）**：默认只在 `--properties` 中传实际变化的字段，未传字段保持不变；不要复制并回写完整 snapshot。`snapshot` 内普通对象递归合并，`refs` / `axes` / `series` 等数组整体替换——修改数组中的一项时，应先读取当前数组、改好后只回写该完整数组，不需要携带 snapshot 的其它字段。`snapshot.data.isStaticData` 不能通过 update 改变；需要切换静态/非静态数据时删除后重建。
+
 **常见配置错误（必须注意）**：
 - **图表类型选择错误**：用户说"堆积柱形图/百分比堆积"时，应在 `properties.snapshot.plotArea.plot.extra.stack` 中配置堆叠；百分比堆叠需在该 stack 下设置 `percentage: true`。用户说"占比/比例"时，优先考虑饼图或百分比堆积图。注意区分 `column`（柱形图，纵向）与 `bar`（条形图，横向）是两个不同的 type 取值，"对比/各 XX" 类纵向柱默认用 `column`
 - **数据标签开关**：`plotArea.plot.labels` 对象的**存在性即开关**——
@@ -104,6 +118,9 @@
 | Shortcut | Risk | 分组 |
 | --- | --- | --- |
 | `+chart-list` | read | 对象 |
+| `+chart-create-basic` | write | 对象 |
+| `+chart-config-update` | write | 对象 |
+| `+chart-data-update` | write | 对象 |
 | `+chart-create` | write | 对象 |
 | `+chart-update` | write | 对象 |
 | `+chart-delete` | high-risk-write | 对象 |
@@ -118,6 +135,69 @@ _公共四件套 · 系统：`--dry-run`_
 | --- | --- | --- | --- |
 | `--chart-id` | string | optional | 指定单个图表 reference_id 过滤 |
 
+### `+chart-create-basic`
+
+_公共四件套 · 系统：`--dry-run`_
+
+| Flag | Type | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `--chart-type` | string | required | 图表类型（可选值：`column` / `bar` / `line` / `area` / `pie` / `scatter` / `combo` / `radar`） |
+| `--data-range` | string | required | 含表头的一个连续 A1 范围，或逗号分隔的同表多范围；对齐且不重叠时保留独立引用，否则合并为最小包围矩形 |
+| `--data-direction` | string | optional | 数据系列方向；column 表示首列为类别，row 表示首行为类别（可选值：`column` / `row`）（默认 `column`） |
+| `--title` | string | optional | 图表标题 |
+| `--subtitle` | string | optional | 图表副标题 |
+| `--legend-position` | string | optional | 图例位置；hidden 隐藏图例（可选值：`top` / `bottom` / `left` / `right` / `hidden`） |
+| `--x-axis-title` | string | optional | X 轴标题 |
+| `--y-axis-title` | string | optional | 左 Y 轴标题 |
+| `--secondary-y-axis-title` | string | optional | 右 Y 轴标题 |
+| `--x-axis-label-angle` | int | optional | X 轴标签旋转角度（可选值：`-90` / `-45` / `0` / `45` / `90`） |
+| `--y-axis-label-angle` | int | optional | 左 Y 轴标签旋转角度（可选值：`-90` / `-45` / `0` / `45` / `90`） |
+| `--data-labels` | string | optional | 数据标签内容；none 隐藏标签；兼容 category_percentage 并自动按 value_percentage 处理（可选值：`none` / `value` / `percentage` / `value_percentage` / `category_percentage` / `category` / `series`） |
+| `--data-label-position` | string | optional | 数据标签位置（可选值：`auto` / `top` / `bottom` / `left` / `right` / `center` / `inside` / `outside`） |
+| `--stack` | string | optional | 堆叠模式（可选值：`none` / `normal` / `percent`） |
+| `--stacked` | bool | optional | 兼容别名；等价于 --stack normal（隐藏 flag：不在 `--help` 列出，但可正常传入） |
+| `--smooth` | bool | optional | 是否使用平滑曲线；支持 --smooth=false 和 --smooth false |
+| `--color-palette` | string | optional | 预设整图配色主题；与 --colors 互斥（可选值：`brandColorSeries@v2` / `rainbowColorSeries@v2` / `complementaryColorSeries@v2` / `converseColorSeries@v2` / `primaryColorSeries@v2` / `singleColorSeries-B-@v2` / `singleColorSeries-W-@v2` / `singleColorSeries-G-@v2` / `singleColorSeries-Y-@v2` / `singleColorSeries-O-@v2` / `singleColorSeries-R-@v2` / `singleColorSeries-D-@v2`） |
+| `--colors` | string_slice | optional | 自定义整图系列颜色，逗号分隔且至少 2 个十六进制色值；与 --color-palette 互斥 |
+| `--anchor-cell` | string | optional | 可选图表锚点单元格，如 F2；省略时放到数据范围右侧 |
+| `--width` | int | optional | 可选图表宽度；必须与 --height 同时传 |
+| `--height` | int | optional | 可选图表高度；必须与 --width 同时传 |
+
+### `+chart-config-update`
+
+_公共四件套 · 系统：`--dry-run`_
+
+| Flag | Type | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `--chart-id` | string | required | 目标图表 reference_id |
+| `--title` | string | optional | 图表标题 |
+| `--subtitle` | string | optional | 图表副标题 |
+| `--legend-position` | string | optional | 图例位置；hidden 隐藏图例（可选值：`top` / `bottom` / `left` / `right` / `hidden`） |
+| `--x-axis-title` | string | optional | X 轴标题 |
+| `--y-axis-title` | string | optional | 左 Y 轴标题 |
+| `--secondary-y-axis-title` | string | optional | 右 Y 轴标题 |
+| `--x-axis-label-angle` | int | optional | X 轴标签旋转角度（可选值：`-90` / `-45` / `0` / `45` / `90`） |
+| `--y-axis-label-angle` | int | optional | 左 Y 轴标签旋转角度（可选值：`-90` / `-45` / `0` / `45` / `90`） |
+| `--data-labels` | string | optional | 数据标签内容；none 隐藏标签；兼容 category_percentage 并自动按 value_percentage 处理（可选值：`none` / `value` / `percentage` / `value_percentage` / `category_percentage` / `category` / `series`） |
+| `--data-label-position` | string | optional | 数据标签位置（可选值：`auto` / `top` / `bottom` / `left` / `right` / `center` / `inside` / `outside`） |
+| `--stack` | string | optional | 堆叠模式（可选值：`none` / `normal` / `percent`） |
+| `--stacked` | bool | optional | 兼容别名；等价于 --stack normal（隐藏 flag：不在 `--help` 列出，但可正常传入） |
+| `--smooth` | bool | optional | 是否使用平滑曲线；支持 --smooth=false 和 --smooth false |
+| `--color-palette` | string | optional | 预设整图配色主题；与 --colors 互斥（可选值：`brandColorSeries@v2` / `rainbowColorSeries@v2` / `complementaryColorSeries@v2` / `converseColorSeries@v2` / `primaryColorSeries@v2` / `singleColorSeries-B-@v2` / `singleColorSeries-W-@v2` / `singleColorSeries-G-@v2` / `singleColorSeries-Y-@v2` / `singleColorSeries-O-@v2` / `singleColorSeries-R-@v2` / `singleColorSeries-D-@v2`） |
+| `--colors` | string_slice | optional | 自定义整图系列颜色，逗号分隔且至少 2 个十六进制色值；与 --color-palette 互斥 |
+
+### `+chart-data-update`
+
+_公共四件套 · 系统：`--dry-run`_
+
+| Flag | Type | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `--chart-id` | string | required | 目标图表 reference_id |
+| `--data-range` | string | required | 新的含表头数据范围；支持逗号分隔的同表多范围，错位或重叠时自动合并 |
+| `--data-direction` | string | optional | 数据系列方向；省略时沿用现有图表方向（可选值：`column` / `row`） |
+| `--dim1-index` | int | optional | 类别/X 轴维度在数据范围中的 1-based 索引；省略时使用第 1 个维度 |
+| `--dim2-indexes` | string | optional | 值/Y 轴系列在数据范围中的 1-based 索引，逗号分隔；省略时使用除 dim1 外的全部维度 |
+
 ### `+chart-create`
 
 _公共四件套 · 系统：`--dry-run`_
@@ -133,7 +213,7 @@ _公共四件套 · 系统：`--dry-run`_
 | Flag | Type | 必填 | 说明 |
 | --- | --- | --- | --- |
 | `--chart-id` | string | required | 目标图表 reference_id |
-| `--properties` | string + File + Stdin（复合 JSON） | required | 完整或足够完整的图表配置 JSON（先 `+chart-list` 回读再 patch） |
+| `--properties` | string + File + Stdin（复合 JSON） | required | 图表配置补丁 JSON；默认只传变化字段，未传字段保持不变；普通对象递归合并，数组整体替换 |
 
 ### `+chart-delete`
 
@@ -155,7 +235,7 @@ _创建/更新的图表属性_
 - `position` (object?) — 必填 { row: number, col: string }
 - `offset` (object?) — 可选 { row_offset?: number, col_offset?: number }
 - `size` (object?) — 必填 { width: number, height: number }
-- `snapshot` (object?) — 图表快照配置 { title?: object, subTitle?: object, style?: object, legend?: oneOf, plotArea: object, …共 6 项 }
+- `snapshot` (oneOf?) — 图表快照配置
 
 ## Examples
 
@@ -165,6 +245,86 @@ _创建/更新的图表属性_
 
 输出契约：返回按工作表分组的图表列表，每个图表含 `chart_id` / `position` / `details.snapshot` 等。
 
+### `+chart-create-basic`
+
+首列自动作为维度，后续列作为数值系列。饼图只使用第二列数值；散点图以首列为 X、后续列为 Y；组合图以第二列为左轴柱，后续列为右轴折线。数据范围必须包含真实表头；如果类别列与数值列不连续，可以给 `--data-range` 传逗号分隔的多个范围，例如 `"'Sheet1'!A1:A10,'Sheet1'!K1:L10"`。对齐且不重叠的范围会保留为独立引用，不会把 B:J 的间隔列纳入图表；错行、错列或重叠的范围会自动合并为同一工作表内的最小包围矩形。跨工作表范围仍会拒绝。如果数据子集的表头在范围外，改用高级 `+chart-create` 的 detached 模式。
+
+```bash
+# 柱形图：默认放在数据范围右侧
+lark-cli sheets +chart-create-basic --url "..." --sheet-name "Sheet1" \
+  --chart-type column --data-range "'Sheet1'!A1:C10" \
+  --title "销售额对比" --x-axis-title "品类" --y-axis-title "销售额" \
+  --legend-position bottom --data-labels value --data-label-position top
+
+# 双轴组合图：首个数值列为左轴柱，其余数值列为右轴折线
+lark-cli sheets +chart-create-basic --url "..." --sheet-name "Sheet1" \
+  --chart-type combo --data-range "'Sheet1'!A1:D13" \
+  --title "价格与效率" --y-axis-title "价格" --secondary-y-axis-title "效率" \
+  --anchor-cell F2 --width 700 --height 400
+```
+
+多张基础图一次创建。先把所有数据准备完成，再生成 `ops.json`：
+
+```json
+[
+  {
+    "shortcut": "+chart-create-basic",
+    "input": {
+      "sheet_name": "Sheet1",
+      "chart_type": "column",
+      "data_range": "'Sheet1'!A1:C10",
+      "title": "分类对比",
+      "anchor_cell": "F2"
+    }
+  },
+  {
+    "shortcut": "+chart-create-basic",
+    "input": {
+      "sheet_name": "Sheet1",
+      "chart_type": "line",
+      "data_range": "'Sheet1'!E1:G10",
+      "title": "趋势变化",
+      "anchor_cell": "F18"
+    }
+  }
+]
+```
+
+```bash
+lark-cli sheets +batch-update --url "..." --operations @ops.json --continue-on-error --yes
+lark-cli sheets +chart-list --url "..." --sheet-name "Sheet1"
+```
+
+### `+chart-data-update`
+
+当创建后发现漏列、范围过宽、辅助分类列发生变化、系列选择错误或数据方向错误时，只更新数据源。`--data-direction` 省略时沿用现有图表方向；新范围必须包含表头。默认使用第 1 个维度作为 dim1、其余维度作为 dim2；需要精确选择时，用 1-based 的 `--dim1-index` 和逗号分隔的 `--dim2-indexes`。工具返回实际采用的 `normalized_data_ranges`，随后用 `+chart-list` 验证范围和系列数。
+
+```bash
+# 把遗漏的最后一列纳入原折线图，保留标题、配色、图例和落点
+lark-cli sheets +chart-data-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
+  --data-range "'Sheet1'!A1:M6"
+
+# 改用按行组织的数据源
+lark-cli sheets +chart-data-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
+  --data-range "'Sheet1'!A1:M6" --data-direction row
+
+# 第 1 列作为类别，只使用第 4、8 列作为数值系列
+lark-cli sheets +chart-data-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
+  --data-range "'Sheet1'!A1:M6" --dim1-index 1 --dim2-indexes "4,8"
+```
+
+### `+chart-config-update`
+
+只传需要改的字段。`--data-labels none` 会删除数据标签；`--legend-position hidden` 会隐藏图例；`--smooth=false` 和 `--smooth false` 都可显式关闭平滑曲线。为减少参数重试，`--stacked` 自动按 `--stack normal` 处理，`--data-labels category_percentage` 自动按 `value_percentage` 处理；新调用仍优先使用规范参数。
+
+```bash
+lark-cli sheets +chart-config-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
+  --title "新标题" --x-axis-label-angle -45 --legend-position right
+
+lark-cli sheets +chart-config-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
+  --data-labels value_percentage --data-label-position outside --stack percent
+```
+
 ### `+chart-create`
 
 > **`snapshot.data` 必填 `dim1.serie.index` 或 `dim2.series[].index` 之一**（1-based，对应 `refs.value` 范围内的列序）。schema 允许传空 `{}` 但 server 运行时强制：缺则被拒为 `snapshot.data.dim1.serie.index and dim2.series[].index are both missing; at least one must be set`，即便侥幸通过也只会渲染空图。
@@ -292,22 +452,23 @@ JSON
 
 ### `+chart-update`
 
-**Update 三步法**（缺一步会丢字段）：
-
-1. `+chart-list --chart-id <id>` 拿到完整 snapshot
-2. 在拿到的 snapshot 上**局部**修改要改的字段，其余保持不变
-3. 把**完整 snapshot** 整个回写到 `--properties.snapshot`
+默认提交**最小 patch**。例如只修改标题时，只传标题字段：
 
 ```bash
 lark-cli sheets +chart-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
   --properties '{
-    "position":{"row":0,"col":"A"},
-    "size":{"width":480,"height":320},
-    "snapshot": <完整快照（由 +chart-list 取回后局部修改）>
+    "snapshot":{"title":{"text":"新的图表标题"}}
   }'
 ```
 
-> 关键：**不能只提交局部 snapshot**，否则未传字段会被还原为默认值。`+chart-update` 的语义是 PUT（整体覆盖），不是 PATCH。
+只调整尺寸时，不需要传 `snapshot`：
+
+```bash
+lark-cli sheets +chart-update --url "..." --sheet-id "$SID" --chart-id "chrXXX" \
+  --properties '{"size":{"width":640,"height":360}}'
+```
+
+> 数组采用整体替换语义。比如只修改一个坐标轴时，先用 `+chart-list --chart-id <id>` 取得当前 `snapshot.plotArea.axes`，修改目标项后，仅回写 `{"snapshot":{"plotArea":{"axes":[...]}}}`；不要同时回写标题、数据源、图例等未变化字段。
 
 ### `+chart-delete`
 
@@ -325,8 +486,8 @@ lark-cli sheets +chart-delete --url "https://example.feishu.cn/sheets/shtXXX" --
 
 ### Validate / DryRun / Execute 约束
 
-- `Validate`：XOR 公共四件套；`+chart-create` / `+chart-update` 的 `--properties` 必须能解析为合法 JSON；`+chart-delete`（high-risk-write）校验 `--yes` 或 `--dry-run` 至少一个。
-- `DryRun`：`+chart-create` / `+chart-update` 输出"将要 POST 的 body 模板"；`+chart-delete` 输出"将要删除的 chart_id 及隶属 sheet"，零网络副作用。
+- `Validate`：XOR 公共四件套；`+chart-data-update` 要求 `--chart-id` 和 `--data-range`，并校验 `--dim1-index` / `--dim2-indexes` 是正整数索引；`+chart-create` / `+chart-update` 的 `--properties` 必须能解析为合法 JSON；`+chart-delete`（high-risk-write）校验 `--yes` 或 `--dry-run` 至少一个。
+- `DryRun`：`+chart-data-update` / `+chart-create` / `+chart-update` 输出"将要 POST 的 body 模板"；`+chart-delete` 输出"将要删除的 chart_id 及隶属 sheet"，零网络副作用。
 - `Execute`：写操作执行后不自动回读；如需确认，自行调用 `+chart-list` 比对结果。
 
 > `+chart-create` / `+chart-update` 是 write 级别，按需可用 `--dry-run` 预览，不要求 `--yes`。只有 `+chart-delete`（high-risk-write）必须 `--yes`。

skills/lark-sheets/references/lark-sheets-read-data.md

@@ -43,7 +43,7 @@
 注意：
 
 - `+csv-get` 和 `+cells-get` 支持分页/截断，注意检查 `has_more` / `truncated` 标志；两者在处理返回数据之前都必须先读 `warning_message`（上游 schema 要求先读它再用其它字段，内含定位与截断续读提示），`+cells-get` 还要用每个 range 的 `actual_range` / `row_indices` / `col_indices` 判断真实位置
-- `+cells-get` 可独立控制隐藏与筛选：`--skip-hidden` 只控制隐藏或分组折叠的行列，`--skip-filter` 只控制被筛选掉的行。两者都为 `false` 时返回完整数据；仅 `--skip-filter=true` 时保留隐藏行列但跳过筛选行；仅 `--skip-hidden=true --skip-filter=false` 时跳过隐藏行列但保留筛选行；两者都为 `true` 时只返回同时可见且未被筛选掉的数据。为兼容旧调用，未显式传 `--skip-filter` 时会继承 `--skip-hidden`。读取原语本身不标注哪些行列被隐藏：若要识别隐藏区间，用 `+sheet-info --include hidden_rows,hidden_cols` 取隐藏行列集合，再结合 `+cells-get` 返回的 `row_indices` / `col_indices` 判断真实位置
+- 隐藏行列默认包含在返回结果中（`--skip-hidden=false`），如需只看可见数据设为 `true`。读取原语本身不标注哪些行列被隐藏：若要识别隐藏区间（以决定是否过滤、或如何解读混入的隐藏数据），用 `+sheet-info --include hidden_rows,hidden_cols` 取隐藏行列集合，再结合 `+csv-get` / `+cells-get` 返回的 `row_indices` / `col_indices` 判断每行 / 每列是否隐藏
 - 要判断单元格内容是否被行高列宽挤到显示不全（排版检查、调整行高列宽前），给 `+cells-get` 加 `--include truncation`：会按字号 / 自动换行 / 行高列宽估算并返回被截断单元格的 `isRowTruncated` / `isColTruncated`（未返回视为未截断）。有额外计算开销，仅需要时才开
 
 **常见配置错误（必须注意）**：
@@ -54,7 +54,7 @@
   - 数据量大或会进入上下文上限时，分批读 + 本地处理 + 分批回写，不要一口气拉全表到上下文。
 - **`+cells-get` 滥用**：当只需要数据值时，使用 `+csv-get`（token 开销约为 `+cells-get` 的 1/5）。只有确实需要公式、样式或批注时才用 `+cells-get`
 - **忽略分页标志**：读取返回 `has_more=true` 时，说明还有更多数据。如果任务需要完整数据，必须继续分页读取，不能只处理第一页就开始写入
-- **直接按 `+cells-get` 返回二维数组下标推导真实位置**：`ranges[n].cells[i][j]` 里的 `i/j` 只是返回数组下标，不等于真实表格行列。定位真实行号必须用 `ranges[n].row_indices[i]`，定位真实列字母必须用 `ranges[n].col_indices[j]`；若 `--skip-hidden=true`、`--skip-filter=true`、请求范围越界被裁剪，或最后一行是部分返回，错误地自己数下标会立刻错位
+- **直接按 `+cells-get` 返回二维数组下标推导真实位置**：`ranges[n].cells[i][j]` 里的 `i/j` 只是返回数组下标，不等于真实表格行列。定位真实行号必须用 `ranges[n].row_indices[i]`，定位真实列字母必须用 `ranges[n].col_indices[j]`；若 `--skip-hidden=true`、请求范围越界被裁剪，或最后一行是部分返回，错误地自己数下标会立刻错位
 - **CSV 行号计数错误**：`+csv-get` 返回的 CSV 遵循 RFC 4180 标准，被双引号 `"..."` 包裹的字段中的换行符属于**字段内容的一部分**（即单元格内换行），不代表新的一行。计算行号时必须按**逻辑记录**计数，而非按物理换行符 `\n` 计数
 - **手动数列确定列号**：禁止通过在 CSV 表头中手动数逗号/字段来确定目标列的列字母。当列数超过 10 时，手动计数极易产生 off-by-one 偏移（例如把 W 列误判为 X 列）。**必须使用 `col_indices`**：先在 CSV 表头中找到目标字段名是第 j 个字段（0-based），再用 `col_indices[j]` 获取该列的实际列字母
 - **用数据列的值推导行号（常被巧合掩盖）**：CSV 中常见"序号 / ID / 编号 / No."等形似行号的列，其值与实际表格行号**没有任何绑定关系**——序号可能跳号（1,2,3,5,6...）、可能从非 1 开始、可能有重复或被中途重置。此规则适用于**所有需要行号的下游操作**：合并单元格、区间写入/清空/格式化、插入/删除行、条件格式范围、筛选器范围、图表数据源、透视表范围、搜索替换范围等等——**凡是要把行号填进任何工具参数的场景，行号一律从 `annotated_csv` 中目标行开头的 `[row=N]` 前缀直接读取**，禁止用"序号=行号"、"表头占 1 行所以数据从第 2 行开始"、"第 N 个序号就在第 N+1 行"等心算，也禁止先心算再"事后核对"。**危险特征**：前几十行中序号恰好等于表格行号（典型成因：表头 +1 与一次跳号 -1 的偏移互相抵消形成巧合），模型一旦把这个巧合当作规律，会在后续所有行沿用；而中间再出现跳号时，从该行起整块区域全部错位，且错位不自查很难发现。**正确工作流**：①在 `annotated_csv` 里定位目标逻辑行（按字段内容匹配）；②直接读取该行开头的 `[row=N]` 前缀得到真实表格行号；③把这个行号填进下游工具参数。区间操作时，起始行用 start 行的 `[row=N]`、结束行用 end 行的 `[row=N]`。**自检**：动手前，在 `annotated_csv` 靠后位置再抽 1~2 行，核对 `[row=N]` 是否与首列"序号"一致——不一致（典型：`[row=57] 58,...`）即说明有跳号/隐藏行，更要严格从 `[row=N]` 取值，不要被序号列迷惑
@@ -103,8 +103,7 @@ _公共四件套 · 系统：`--dry-run`_
 | `--include` | string_slice | optional | 要返回的信息类别，逗号分隔多个。`truncation` 会额外按行高列宽 / 字号 / 自动换行估算每个单元格是否被截断显示，返回 `isRowTruncated` / `isColTruncated`（有额外计算开销，仅排版检查 / 调整行高列宽前才开）（可选值：`value` / `formula` / `style` / `comment` / `data_validation` / `truncation`） |
 | `--max-chars` | int | optional | 单次返回字符上限，默认 500000（兜底防爆）。要整表无截断直接用 --output-path 落盘（自动放开为无限）；仅当要让结果直接进上下文、又不落盘时才调小（如 25000），按 has_more 分页。 |
 | `--output-path` | string | optional | 把完整读取结果写入本地路径（如 `./out.json`），文件内容为 data 载荷的 JSON；stdout 只回一个含 output_path/字节数的确认信息。**一旦设置，字符上限默认放开为无限**（覆盖 --max-chars 默认），适合大表整表落盘再分析，避免 stdout 被 max_chars 截断。省略时按常规把结果打到 stdout。 |
-| `--skip-hidden` | bool | optional | 跳过隐藏或分组折叠的行列。默认 `false`；未显式传 `--skip-filter` 时，筛选行也会随之跳过（兼容旧行为） |
-| `--skip-filter` | bool | optional | 跳过被筛选掉的行。未设置时继承 `--skip-hidden`；显式设为 `false` 可在跳过隐藏行列的同时保留筛选行 |
+| `--skip-hidden` | bool | optional | 跳过隐藏行列，默认 `false` |
 
 ### `+dropdown-get`
 
@@ -120,7 +119,7 @@ _公共四件套 · 系统：`--dry-run`_
 
 | Flag | Type | 必填 | 说明 |
 | --- | --- | --- | --- |
-| `--range` | string | optional | A1 范围，如 `A1:F30`（不带 sheet 前缀；用 `--sheet-id` / `--sheet-name` 指定 sheet）。**可省略：缺省读取整个子表**（按表格实际边界裁剪，返回的 actual_range 标注实际读取范围）；大表配合 --max-chars / --output-path 控制体量 |
+| `--range` | string | required | A1 范围，如 `A1:F30`（不带 sheet 前缀；用 `--sheet-id` / `--sheet-name` 指定 sheet） |
 | `--max-chars` | int | optional | 单次返回字符上限，默认 500000（兜底防爆）。要整表无截断直接用 --output-path 落盘（自动放开为无限）；仅当要让结果直接进上下文、又不落盘时才调小（如 25000），按 has_more 分页。 |
 | `--output-path` | string | optional | 把完整读取结果写入本地路径（如 `./out.json`），文件内容为 data 载荷的 JSON；stdout 只回一个含 output_path/字节数的确认信息。**一旦设置，字符上限默认放开为无限**（覆盖 --max-chars 默认），适合大表整表落盘再分析，避免 stdout 被 max_chars 截断。省略时按常规把结果打到 stdout。 |
 | `--include-row-prefix` | bool | optional | 是否在每行前加 `[row=N]` 前缀，默认 `true` |
@@ -153,10 +152,6 @@ lark-cli sheets +csv-get --url "https://example.feishu.cn/sheets/shtXXX" --sheet
 
 # 用 sheet-name 模糊定位（运行时框架会先解析到 sheet-id）
 lark-cli sheets +csv-get --spreadsheet-token shtXXX --sheet-name "销售明细" --range "A1:F30"
-
-# 全量读：省略 --range 即读整个子表（按实际边界裁剪，返回 actual_range 标注实读范围），
-# 无需先 +workbook-info 探行列再拼 range；大表配合 --max-chars / --output-path
-lark-cli sheets +csv-get --spreadsheet-token shtXXX --sheet-name "销售明细"
 ```
 
 输出契约（envelope.data）：

skills/lark-sheets/references/lark-sheets-sheet-structure.md

@@ -23,7 +23,7 @@
 
 - 当表格存在合并单元格时，应结合返回的 `merged_cells` 判断表头、分组标题和区域语义
 - 不要把合并区域中非左上角的空白单元格理解为"无内容"；通常应将左上角单元格的内容视为整个合并区域的语义内容
-- 插入用 `+dim-insert`：`--position`（插入位置；行用 1-based 行号如 `3`，列用字母如 `C`，新行/列插在此位置**之前**）+ `--count`（插入数量，>0）。新行/列样式继承用 `--inherit-style`（`before` 继承前一行/列 / `after` 继承后一行/列）；它只决定继承哪一侧的样式，**插入位置始终在 `--position` 之前，不改变插入方向**。⚠️ 不传时默认继承**后一行/列**（同 `after`）；底层无法插入"无格式"行/列，要真正的纯空白行/列，插入后再用 `+cells-clear --scope formats` 清除新行/列的格式。
+- 插入用 `+dim-insert`：`--position`（插入位置；行用 1-based 行号如 `3`，列用字母如 `C`，新行/列插在此位置**之前**）+ `--count`（插入数量，>0）。新行/列样式继承用 `--inherit-style`（`before`/`after`/`none`）
 - 例如"在第 20 行后新增 116 行"：`--position 21 --count 116`（"第 20 行后"即 1-based 行号 21）
 
 **区间表达统一为 A1 风格**：所有涉及"一段连续行/列"的 shortcut 都用同一套 A1 闭区间字符串语法，**不存在 inclusive / exclusive / 0-based / 1-based 跨命令差异**：
@@ -40,7 +40,7 @@
 - **插入列直接用字母**：`+dim-insert` 的 `--position` 在列场景直接传字母（如 `C`），不要把列字母换算成 0-based 索引
 - **插入后引用偏移**：插入行/列后，原有数据的行号 / 列字母会发生偏移。如果插入后还需要对原有区域执行写入操作，必须重新计算偏移后的位置
 - **删除行列前先确认范围**：删除操作不可逆，执行前应确认 `--range` 精确无误。可先用 `+csv-get` 读取目标区域验证内容（`+csv-get` / `+cells-get` 见 `lark-sheets-read-data`）
-- **"在 D 列左侧新增一列"的正确写法**：`--position D --count 1`（新列插在 D 列之前）；要继承左侧列样式加 `--inherit-style before`。不要把 `--inherit-style after` 当成“插到 D 列右侧”，它不是插入方向参数。
+- **"在 D 列左侧新增一列"的正确写法**：`--position D --count 1`（新列插在 D 列之前）；要继承左侧列样式加 `--inherit-style before`
 - **`+dim-move` 同维度约束**：`--source-range` 是行区间时 `--target` 必须是行号（数字），是列区间时 `--target` 必须是列字母——不可一行一列混用
 - **插入列后必须检查多行表头合并区域**：很多表格有 2-3 行的合并表头。插入列后，原有的合并区域不会自动扩展到新列。必须先用 `+sheet-info --include merges` 读取合并区域，插入后将跨越插入位置的合并区域重新设置（用 `+cells-{merge|unmerge}`），否则新列的表头会是空的、格式不连续
 - **公式写入范围跳过表头行**：写入公式时从数据行开始（不是第 1 行）。先确认表头占几行（可能 1-3 行），公式的起始行 = 表头行数 + 1
@@ -76,7 +76,7 @@ _公共四件套 · 系统：`--dry-run`_
 
 | Flag | Type | 必填 | 说明 |
 | --- | --- | --- | --- |
-| `--inherit-style` | string | optional | 新行/列样式继承 enum：`before`（继承前一行/列）/ `after`（继承后一行/列）；不传时默认继承后一行/列（同 `after`），底层无法插入无格式行/列。只决定继承哪侧样式、不改变插入方向（始终插在 `--position` 之前）；要纯空白行/列请插入后用 `+cells-clear --scope formats`（可选值：`before` / `after`） |
+| `--inherit-style` | string | optional | 新行/列样式继承策略 enum：`before`（继承前一行/列）/ `after`（继承后一行/列）/ `none`（默认）（可选值：`before` / `after` / `none`） |
 | `--position` | string | required | 插入位置（在此行/列**之前**插入）：行用 1-based 行号如 `3`；列用字母如 `C` |
 | `--count` | int | required | 插入数量（>0） |
 
@@ -86,8 +86,7 @@ _公共四件套 · 系统：`--yes`、`--dry-run`_
 
 | Flag | Type | 必填 | 说明 |
 | --- | --- | --- | --- |
-| `--range` | string | xor | 要删除的行/列闭区间；行用 1-based 数字如 `3:7` 或单行 `5`，列用字母如 `C:F` 或单列 `C`。与 `--ranges` 二选一 |
-| `--ranges` | string + File + Stdin（简单 JSON） | xor | 要删除的多个行/列区间 JSON 数组（最多 100 个，如 `["5:5","8:8","11:13"]` 或 `["C:C","F:G"]`），全行或全列不可混用，区间不可重叠；与 `--range` 二选一。CLI 按位置**从大到小逆序**合成一次原子批量删除——正序删除会因前面的行/列被删导致后续索引前移错位，逆序由 CLI 代劳，无需自行排序 |
+| `--range` | string | required | 要删除的行/列闭区间；行用 1-based 数字如 `3:7` 或单行 `5`，列用字母如 `C:F` 或单列 `C` |
 
 ### `+dim-hide`
 
@@ -169,11 +168,6 @@ lark-cli sheets +dim-delete --url "..." --sheet-id "$SID" --range "5:7" --yes
 
 # 删除 D-F 列
 lark-cli sheets +dim-delete --url "..." --sheet-id "$SID" --range "D:F" --yes
-
-# 删除多个散布区间（如按查重结果删行）：--ranges 一次原子交付。
-# CLI 自动按位置从大到小逆序执行——正序会因前面的行被删导致后续索引前移错位；
-# 无需自行排序，也不要为此拼 +batch-update 的子操作数组
-lark-cli sheets +dim-delete --url "..." --sheet-id "$SID" --ranges '["5:5","8:8","11:13"]' --yes
 ```
 
 ### `+dim-hide` / `+dim-unhide`
@@ -213,6 +207,6 @@ lark-cli sheets +dim-freeze --url "..." --sheet-id "$SID" --dimension row --coun
 
 ### Validate / DryRun / Execute 约束
 
-- `Validate`：XOR 公共四件套；`--range` / `--source-range` 必须是合法 A1 闭区间（行用数字、列用字母，不可混用）；`+dim-insert` 的 `--count` > 0；`+dim-move` 的 `--target` 必须与 `--source-range` 同维度（行 vs 列）；`+dim-delete` 强制 `--yes` 或 `--dry-run`，`--range` 与 `--ranges` 二选一、`--ranges` 各区间同维度且不可重叠（≤100 个）；`+rows-resize` / `+cols-resize` 的统一形态（`--range` + `--height`/`--width` 或 `--type`）与 map 形态（`--heights`/`--widths`）二选一、不可混用；详见 `lark-sheets-range-operations.md`。
+- `Validate`：XOR 公共四件套；`--range` / `--source-range` 必须是合法 A1 闭区间（行用数字、列用字母，不可混用）；`+dim-insert` 的 `--count` > 0；`+dim-move` 的 `--target` 必须与 `--source-range` 同维度（行 vs 列）；`+dim-delete` 强制 `--yes` 或 `--dry-run`；`+rows-resize` / `+cols-resize` 的统一形态（`--range` + `--height`/`--width` 或 `--type`）与 map 形态（`--heights`/`--widths`）二选一、不可混用；详见 `lark-sheets-range-operations.md`。
 - `DryRun`：写操作输出"将要 PATCH 的目标范围 + 目标参数"。
 - `Execute`：写后不自动回读；如需确认，自行调用 `+sheet-info --include row_heights,col_widths,hidden_rows,hidden_cols,groups,frozen` 查看受影响的范围。

skills/lark-sheets/references/lark-sheets-styles-put.md

@@ -1,91 +0,0 @@
-# Lark Sheet Styles Put（+styles-put）
-
-> **本文定位**：对**已有**表格做美化收尾的默认入口——样式 / 边框 / 合并 / 行高列宽 / 冻结写成一份声明式规格，一次调用原子交付。样式**取什么值**（配色 / 字号 / 对齐 / 数字格式标准）以 `lark-sheets-visual-standards` 为唯一权威，本文只讲**怎么落地**。
->
-> **边界（三分流判定，按操作组合选入口）**：目标是**样式 / 合并 / 行高列宽 / 冻结**的任意组合 → 本命令；**同一个写操作**打多个区域（如多区域清除、批量下拉）→ 用该命令自身的复数形态（`--ranges` / map 入参）；操作链**跨类型且有顺序依赖**（如插列 → 写表头 → 回填数据）→ `+batch-update`。美化收尾不需要也不应该拼 `--operations` 子操作数组。
-
-## 使用场景
-
-写入。对存量表格的多个子表批量应用视觉规格：新表美化、加汇总行后统一版式、按分组合并同类单元格、调列宽行高、冻结表头。整份规格展开为一次原子批量提交，全部生效或全部不生效；纯样式盖章可安全重放（同一份规格重发无副作用）。
-
-**词汇三处同构**：`--styles` 的字段词汇与 `+workbook-create --styles`（建新表同步美化）、`+table-put --styles`（写数据同步美化）完全一致——`cell_styles` / `cell_merges` / `row_sizes` / `col_sizes` / `freeze` 学一次三处通用。区别只有两点：本命令作用于**已有**表格（顶层 `--url` / `--spreadsheet-token` 定位），且 `cell_styles` 的 range 不受「本次写入区域」限制、可指向表内任意区域。
-
-**规格要点**：
-
-- 顶层 `{styles:[...]}`，每项对应一个目标子表，`name` 必须是真实子表名（不确定先 `+workbook-info` 查，禁止猜 `Sheet1`）。
-- 每个子表项按固定顺序执行：`cell_merges` → `cell_styles` → `row_sizes` → `col_sizes` → `freeze`；样式盖章允许覆盖含合并区的区域（合并区限制只针对值写入，样式不受限）。
-- `row_sizes` / `col_sizes` 只需 `{range, size}`（px，即像素尺寸；`standard` / 行的 `auto` 才需显式 `type`）。尺寸键统一是 `size`。
-- 加边框用 `border` 简写：`{"style":"solid","color":"#DDDDDD"}` 应用到四边；只有分侧不同样式才用 `border_styles` 完整形态。
-- `freeze` 用 `{rows:N, cols:N}` 冻结前 N 行 / 列，0 或省略表示该维度不冻结。
-
-**回读校验**：整份规格执行成功后按编辑准则抽样回读受影响区域（`+cells-get --include style` 或 `+sheet-info` 看合并 / 行高列宽 / 冻结），确认关键样式实际生效。
-
-## Shortcuts
-
-| Shortcut | Risk | 分组 |
-| --- | --- | --- |
-| `+styles-put` | write | 批量 |
-
-## Flags
-
-### `+styles-put`
-
-_公共：URL/token（无 sheet 定位） · 系统：`--dry-run`_
-
-| Flag | Type | 必填 | 说明 |
-| --- | --- | --- | --- |
-| `--styles` | string + File + Stdin（复合 JSON） | required | 对**已有**表格应用的视觉规格 JSON：顶层 `{styles:[...]}`，每项对应一个目标子表（`name` 用真实子表名），并至少给 `cell_styles` / `cell_merges` / `row_sizes` / `col_sizes` / `freeze` 之一。字段词汇与 `+workbook-create` / `+table-put` 的 `--styles` 完全同构（cell_styles 用 A1 range + 扁平样式字段，边框用 `border` 简写 {style,weight,color} 四边同款、分侧才用 border_styles；row/col sizes 用行/列范围 + size（px 即像素，standard/auto 才需 type）；merges 用单元格 range；freeze 用 `{rows:N, cols:N}` 冻结前 N 行/列）。整份规格展开为一次原子批量提交；range 不受「本次写入区域」限制，可指向表内任意区域 |
-
-## Schemas
-
-> 复合 JSON flag 字段速查（只列顶层 + 一层嵌套）。深层结构看下方 `## Examples`，或用 `--print-schema` 读完整 JSON Schema（用法见 SKILL.md「公共 flag 速查」与「Agent 使用提示」）。
-
-### `+styles-put` `--styles`
-
-
-**数组项**（类型 object）：
-- `cell_merges` (array<object>?) — 单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all each: { merge_type?: enum, range: string }
-- `cell_styles` (array<object>?) — 单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐 each: { background_color?: string, border?: object, border_styles?: object, font_color?: string, font_family?: string, …共 14 项 }
-- `col_sizes` (array<object>?) — 列宽操作数组；range 使用列范围如 A:C，给 size（px）即像素列宽（type 可省略）；type 为 standard 时不带 size each: { range: string, size?: number, type?: enum }
-- `freeze` (object?) — 冻结行列：rows = 冻结前 N 行，cols = 冻结前 N 列（0 或省略 = 该维度不冻结） { cols?: integer, rows?: integer }
-- `name` (string) — 子表名
-- `row_sizes` (array<object>?) — 行高操作数组；range 使用行范围如 1:3，给 size（px）即像素行高（type 可省略）；type 为 standard/auto 时不带 size each: { range: string, size?: number, type?: enum }
-
-## Examples
-
-### `+styles-put`
-
-表头美化 + 按组合并 + 列宽 + 冻结首行，一次交付：
-
-```bash
-lark-cli sheets +styles-put --url "https://example.feishu.cn/sheets/shtXXX" --styles - <<'JSON'
-{"styles":[{
-  "name": "Sheet1",
-  "cell_merges": [{"range":"A5:A8"},{"range":"A9:A12"}],
-  "cell_styles": [
-    {"range":"A1:F1","font_weight":"bold","background_color":"#1E5BC6","font_color":"#FFFFFF","horizontal_alignment":"center"},
-    {"range":"A2:F30","border":{"style":"solid","color":"#DDDDDD"}}
-  ],
-  "row_sizes":  [{"range":"1:1","size":36}],
-  "col_sizes":  [{"range":"A:C","size":120}],
-  "freeze":     {"rows":1}
-}]}
-JSON
-```
-
-多子表同一批交付（每个子表一个 styles 项）：
-
-```bash
-lark-cli sheets +styles-put --url "..." --styles - <<'JSON'
-{"styles":[
-  {"name":"明细","cell_styles":[{"range":"A1:H1","font_weight":"bold","background_color":"#F0F0F0"}],"freeze":{"rows":1}},
-  {"name":"汇总","cell_styles":[{"range":"A1:D1","font_weight":"bold"}],"col_sizes":[{"range":"A:D","type":"pixel","size":140}]}
-]}
-JSON
-```
-
-### Validate / DryRun / Execute 约束
-
-- `Validate`：`--styles` 必须是合法 JSON、`styles` 非空数组；每项 `name` 必填、至少给 `cell_merges` / `cell_styles` / `row_sizes` / `col_sizes` / `freeze` 之一；`cell_styles` 每项至少一个样式字段；展开后受子操作数（100）与总格数预算约束，超限报错给拆分建议。
-- `DryRun`：输出展开后每个子操作的请求模板，不发起调用。
-- `Execute`：整份规格合成一次批量请求按序执行；失败时报错会注明已生效的子操作区间与续发方式。

skills/lark-sheets/references/lark-sheets-workbook.md

@@ -197,11 +197,10 @@ _一个或多个子表的 typed 数据，每个数组元素写入一张子表；
 
 **数组项**（类型 object）：
 - `cell_merges` (array<object>?) — 单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all each: { merge_type?: enum, range: string }
-- `cell_styles` (array<object>?) — 单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐 each: { background_color?: string, border?: object, border_styles?: object, font_color?: string, font_family?: string, …共 14 项 }
-- `col_sizes` (array<object>?) — 列宽操作数组；range 使用列范围如 A:C，给 size（px）即像素列宽（type 可省略）；type 为 standard 时不带 size each: { range: string, size?: number, type?: enum }
-- `freeze` (object?) — 冻结行列：rows = 冻结前 N 行，cols = 冻结前 N 列（0 或省略 = 该维度不冻结） { cols?: integer, rows?: integer }
+- `cell_styles` (array<object>?) — 单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐 each: { background_color?: string, border_styles?: object, font_color?: string, font_family?: string, font_line?: enum, …共 13 项 }
+- `col_sizes` (array<object>?) — 列宽操作数组；range 使用列范围如 A:C，type 为 pixel/standard，pixel 需要 size each: { range: string, size?: number, type: enum }
 - `name` (string) — 子表名
-- `row_sizes` (array<object>?) — 行高操作数组；range 使用行范围如 1:3，给 size（px）即像素行高（type 可省略）；type 为 standard/auto 时不带 size each: { range: string, size?: number, type?: enum }
+- `row_sizes` (array<object>?) — 行高操作数组；range 使用行范围如 1:3，type 为 pixel/standard/auto，pixel 需要 size each: { range: string, size?: number, type: enum }
 
 ## Examples
 

skills/lark-sheets/references/lark-sheets-write-cells.md

@@ -89,19 +89,6 @@
 
 ⚠️ **逐行写入公式是常见低效写法**：对每一行单独调用 `+cells-set` 写公式（如 26 次）既慢又易错，且不会自动平移公式引用。正确做法是 1 次模板写入 + 1 次 `--copy-to-range`（公式引用自动平移）。
 
-💡 **多个不连续区域写入（批量修公式的正解）**：散布多处（可跨 sheet）的值 / 公式写入，用 `--writes` 一次原子交付——每项 `{sheet_name, range, cells}`（sheet 定位必须写在每项里），不要为此拼 `+batch-update` 的 `--operations`，也不要逐区域多次调用（非原子）：
-
-```bash
-lark-cli sheets +cells-set --url "..." --writes - <<'JSON'
-[
-  {"sheet_name":"明细","range":"D5","cells":[[{"formula":"=IFERROR(C5/B5,0)"}]]},
-  {"sheet_name":"汇总","range":"B3","cells":[[{"formula":"=SUM(明细!C:C)"}]]}
-]
-JSON
-```
-
-范围级统一样式不在 `--writes` 里做（cells 逐格 `cell_styles` 仅用于逐格差异化），写完接 `+styles-put`。
-
 💡 **写入公式前先按迁移规则改写**：如果公式来自 Excel 或包含数组场景，先读取并遵循 `lark-sheets-formula-translation` 的规则完成改写，再把最终公式写入 `formula` 字段。
 
 💡 **内容与样式分离写入（推荐）**：当需要同时写入内容和样式时，`cells` 中每个单元格都带上 `cell_styles` / `border_styles` 会导致入参非常冗长。由于同一区域的样式通常高度重复（如整列统一背景色、统一边框），推荐拆成两步：
@@ -115,7 +102,7 @@ Step 2: `+cells-set` — range="A2", cells 含 value + cell_styles + border_styl
 ```
 这比在 99 个单元格中都重复写样式 JSON 高效得多。
 
-💡 **样式更新是「部分合并」，不是整体覆盖**：`+cells-set-style` / `+styles-put`（以及 `+cells-set` 的 `cell_styles` / `border_styles`）只改你**显式传入**的样式属性，未传的属性保留原值。两个实用推论：
+💡 **样式更新是「部分合并」，不是整体覆盖**：`+cells-set-style` / `+cells-batch-set-style`（以及 `+cells-set` 的 `cell_styles` / `border_styles`）只改你**显式传入**的样式属性，未传的属性保留原值。两个实用推论：
 - **可分层叠加**：对同一区域先刷字体色、再单独刷背景色、再单独刷边框，后一步不会清掉前一步——美化已有区域时无需一次带齐所有字段，可拆成多次窄调用。
 - **`border_styles` 按边合并**：只传 `{"top":{...}}` 只更新上边框，`bottom` / `left` / `right` 保留原状；不必为了「只改一条边」而把四边全部重传。（例外见上方「新增行的边框/样式禁止用 `{}` 跳过」：**全新行**底子里没有边框，仍需把要显示的边都显式传出。）
 
@@ -249,7 +236,7 @@ lark-cli sheets +dropdown-set \
 
 > ⚠️ **`--source-range` 必须带 sheet 前缀**（即使跟 `--range` 同 sheet）。注意一个坑：回读这种 listFromRange 下拉单元格时，`data_validation.range` 看起来不带 sheet 前缀（形如 `$T$1:$T$3`），如果要把读出来的 range 反过来写回 `--source-range`，**必须自己重新补上 sheet 前缀**，否则会被拒。
 >
-> ⚠️ **`--ranges` 类批量 flag 的 sheet 前缀必须「裸写」**——`+cells-batch-clear` / `+dropdown-update` / `+dropdown-delete` 的 `--ranges` 解析器不接受引号：表名含点或空格（如 `2025.9`、`一月份`）也直接写 `2025.9!A1`，写成 `'2025.9'!A1` 会被当成表名一部分、报 `sheet not found`。**但 `--source-range`、透视表 `--source`、`--range` 走 A1 标准**：sheet 名带单引号（如 `'Sheet1'!A1:B2`）是标准写法、裸写也接受，回读统一返回带引号形式——别把 `--ranges` 的裸写要求套到这些 flag 上。
+> ⚠️ **`--ranges` 类批量 flag 的 sheet 前缀必须「裸写」**——`+cells-batch-set-style` / `+cells-batch-clear` / `+dropdown-update` / `+dropdown-delete` 的 `--ranges` 解析器不接受引号：表名含点或空格（如 `2025.9`、`一月份`）也直接写 `2025.9!A1`，写成 `'2025.9'!A1` 会被当成表名一部分、报 `sheet not found`。**但 `--source-range`、透视表 `--source`、`--range` 走 A1 标准**：sheet 名带单引号（如 `'Sheet1'!A1:B2`）是标准写法、裸写也接受，回读统一返回带引号形式——别把 `--ranges` 的裸写要求套到这些 flag 上。
 
 `+dropdown-update`（多 range 批量更新）的所有 flag 语义与 `+dropdown-set` 完全一致；只是目标 `--ranges` 由单值变成 JSON 数组（每项带 sheet 前缀），同一份选项 + 配色应用到所有 range。
 
@@ -272,9 +259,8 @@ _公共四件套 · 系统：`--dry-run`_
 
 | Flag | Type | 必填 | 说明 |
 | --- | --- | --- | --- |
-| `--range` | string | xor | 写入区域（A1 格式）。与 `--writes` 二选一（单区域用 --range+--cells，多区域用 --writes） |
-| `--cells` | string + File + Stdin（复合 JSON） | xor | JSON：2D 数组 `[[{cell},...],...]`，维度与 `--range` 完全一致；每个 cell 可含 `value` / `formula` / `cell_styles` / `note` / `rich_text`（含 `type="embed-image"` 单元格嵌图）等，完整字段跑 `--print-schema` |
-| `--writes` | string + File + Stdin（复合 JSON） | xor | 多区域写入 JSON 数组（最多 100 项），每项 `{sheet_name\|sheet_id, range, cells}`——**sheet 定位必须写在每项里**（与 +batch-update 子操作、+styles-put 项同惯例，不认顶层 --sheet-name），cells 结构同 `--cells`（二维数组，可逐格带 cell_styles/border_styles）。整批展开为**单次原子批量提交**，支持跨 sheet；典型场景：批量修复散布多处的公式、跨表同构写入——不要为此拼 +batch-update 的 --operations。与 `--range`+`--cells` 二选一；范围级统一样式不在此做，写完接 +styles-put |
+| `--range` | string | required | 写入区域（A1 格式） |
+| `--cells` | string + File + Stdin（复合 JSON） | required | JSON：2D 数组 `[[{cell},...],...]`，维度与 `--range` 完全一致；每个 cell 可含 `value` / `formula` / `cell_styles` / `note` / `rich_text`（含 `type="embed-image"` 单元格嵌图）等，完整字段跑 `--print-schema` |
 | `--allow-overwrite` | bool | optional | 允许覆盖非空 cell（默认 true）；设为 false 时遇非空 cell 报错 |
 | `--max-cells` | int | optional | 防爆，默认 50000（隐藏 flag：不在 `--help` 列出，但可正常传入） |
 | `--copy-to-range` | string | optional | 复制范围（A1 表示法）：把 --range 中 --cells 写入的内容（值/公式/样式，取决于实际传入字段）复制到该区域，公式引用自动平移（如 C2=B2 → C3=B3）。适合先写一行/一块模板再扩展填充整列/整区域（如 --range A1:G1 写模板、--copy-to-range A1:G100 填充 100 行）。支持整行 3:6、整列 C:E、到列尾 D3:D、到行尾 D3:3；支持英文逗号分隔多个目标区域，如 C1:D2,E5:F6 |
@@ -360,16 +346,6 @@ _【维度】行列数必须与 range 完全一致：'A1:C2'→[[_,_,_],[_,_,_]]
 - `multiple_values` (array<object>?) — 多值内容，用于支持多选的列表验证单元格 each: { value: oneOf, format?: string }
 - `data_validation` (object?) — 数据验证配置 { type: enum, items?: array<string>, range?: string, operator?: enum, values?: array<oneOf>, …共 9 项 }
 
-### `+cells-set` `--writes`
-
-_多区域写入项数组（最多 100 项），整批单次原子提交；支持跨 sheet_
-
-**数组项**（类型 object）：
-- `sheet_id` (string?) — 目标子表 reference_id；与 sheet_name 二选一，必须写在每一项里（不认顶层 sheet 定位）
-- `sheet_name` (string?) — 目标子表名；与 sheet_id 二选一，必须写在每一项里
-- `range` (string) — A1 矩形范围，行列维度必须与 cells 严格一致（同 --range）
-- `cells` (array) — 二维单元格数组，结构同 --cells（value / formula / cell_styles / border_styles 等，见 set_cell_…
-
 ### `+cells-set-style` `--border-styles`
 
 _单元格边框配置，含 top/bottom/left/right 四个方向，每个方向的结构相同（见 top）_
@@ -407,11 +383,10 @@ _一个或多个子表的 typed 数据，每个数组元素写入一张子表；
 
 **数组项**（类型 object）：
 - `cell_merges` (array<object>?) — 单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all each: { merge_type?: enum, range: string }
-- `cell_styles` (array<object>?) — 单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐 each: { background_color?: string, border?: object, border_styles?: object, font_color?: string, font_family?: string, …共 14 项 }
-- `col_sizes` (array<object>?) — 列宽操作数组；range 使用列范围如 A:C，给 size（px）即像素列宽（type 可省略）；type 为 standard 时不带 size each: { range: string, size?: number, type?: enum }
-- `freeze` (object?) — 冻结行列：rows = 冻结前 N 行，cols = 冻结前 N 列（0 或省略 = 该维度不冻结） { cols?: integer, rows?: integer }
+- `cell_styles` (array<object>?) — 单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐 each: { background_color?: string, border_styles?: object, font_color?: string, font_family?: string, font_line?: enum, …共 13 项 }
+- `col_sizes` (array<object>?) — 列宽操作数组；range 使用列范围如 A:C，type 为 pixel/standard，pixel 需要 size each: { range: string, size?: number, type: enum }
 - `name` (string) — 子表名
-- `row_sizes` (array<object>?) — 行高操作数组；range 使用行范围如 1:3，给 size（px）即像素行高（type 可省略）；type 为 standard/auto 时不带 size each: { range: string, size?: number, type?: enum }
+- `row_sizes` (array<object>?) — 行高操作数组；range 使用行范围如 1:3，type 为 pixel/standard/auto，pixel 需要 size each: { range: string, size?: number, type: enum }
 
 ## Examples
 
@@ -426,7 +401,7 @@ _一个或多个子表的 typed 数据，每个数组元素写入一张子表；
 | 只改**已有 cell 的样式**，不动 value/formula | `+cells-set-style` | `+cells-set`（会触发不必要的值写入） |
 | 把**单张图片嵌入**到某个 cell | `+cells-set-image` | `+cells-set`（参数更繁琐） |
 | **插行/列 + 写入** 这种多步组合，且要原子 | `+batch-update`（见 lark-sheets-batch-update） | 多次独立 `+cells-set`（非原子；插入会扰动后续 range） |
-| 在**多个不连续 range** 上应用同一组样式 | `+styles-put`（cell_styles 多项即多区域，见 lark-sheets-styles-put） | 多次 `+cells-set-style`（非原子） |
+| 在**多个不连续 range** 上应用同一组样式 | `+cells-batch-set-style`（见 lark-sheets-batch-update） | 多次 `+cells-set-style`（非原子） |
 
 ### `+cells-set`
 

tests/cli_e2e/sheets/sheets_sheet_shortcuts_dryrun_test.go

@@ -255,36 +255,3 @@ func TestSheets_SheetShortcutsDryRun(t *testing.T) {
 		})
 	}
 }
-
-func TestSheets_DimInsertDryRunInheritAfterKeepsBeforePosition(t *testing.T) {
-	setSheetsDryRunEnv(t)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	t.Cleanup(cancel)
-
-	result, err := clie2e.RunCmd(ctx, clie2e.Request{
-		Args: []string{
-			"sheets", "+dim-insert",
-			"--spreadsheet-token", "shtDryRun",
-			"--sheet-id", "sheet1",
-			"--position", "D",
-			"--count", "1",
-			"--inherit-style", "after",
-			"--dry-run",
-		},
-		DefaultAs: "user",
-	})
-	require.NoError(t, err)
-	result.AssertExitCode(t, 0)
-
-	out := result.Stdout
-	require.Equal(t, "/open-apis/sheet_ai/v2/spreadsheets/shtDryRun/tools/invoke_write", clie2e.DryRunGet(out, "api.0.url").String(), "stdout:\n%s", out)
-	require.Equal(t, "modify_sheet_structure", clie2e.DryRunGet(out, "tool_name").String(), "stdout:\n%s", out)
-	require.Equal(t, "insert", clie2e.DryRunGet(out, "tool_input.operation").String(), "stdout:\n%s", out)
-	// inherit-style=after copies the following column's style via a plain
-	// before-insert at the same position (the backend anchors on the following
-	// column), so position stays D with side=before — the blank lands before D.
-	require.Equal(t, "D", clie2e.DryRunGet(out, "tool_input.position").String(), "stdout:\n%s", out)
-	require.Equal(t, int64(1), clie2e.DryRunGet(out, "tool_input.count").Int(), "stdout:\n%s", out)
-	require.Equal(t, "before", clie2e.DryRunGet(out, "tool_input.side").String(), "inherit-style=after copies the following-side style via side=before; stdout:\n%s", out)
-}