docs: remove lark doc workflows

Change-Id: I7d36543f090ebbb42c945667ad25534273a5c305

.gitignore

@@ -7,6 +7,11 @@ bin/
 # Node
 node_modules/
 
+# Python (skill-bundled helper scripts)
+__pycache__/
+*.py[cod]
+*$py.class
+
 
 # OS
 .DS_Store

cmd/event/list_test.go

@@ -26,6 +26,7 @@ func TestRunList_TextOutput(t *testing.T) {
 		"KEY", "AUTH", "PARAMS", "DESCRIPTION",
 		"im.message.receive_v1",
 		"im.message.message_read_v1",
+		"task.task.update_user_access_v2",
 	} {
 		if !strings.Contains(out, want) {
 			t.Errorf("list output missing %q; full output:\n%s", want, out)
@@ -55,4 +56,17 @@ func TestRunList_JSONOutput(t *testing.T) {
 			}
 		}
 	}
+
+	var foundTask bool
+	for _, row := range rows {
+		if row["key"] == "task.task.update_user_access_v2" {
+			foundTask = true
+			if row["single_consumer"] != true {
+				t.Errorf("task row single_consumer = %v, want true", row["single_consumer"])
+			}
+		}
+	}
+	if !foundTask {
+		t.Fatal("event list JSON missing task.task.update_user_access_v2")
+	}
 }

cmd/event/schema_test.go

@@ -96,6 +96,34 @@ func TestRunSchema_JSONOutput(t *testing.T) {
 	}
 }
 
+func TestRunSchema_TaskUpdateUserAccessJSON(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})
+
+	if err := runSchema(f, "task.task.update_user_access_v2", true); err != nil {
+		t.Fatalf("runSchema json: %v", err)
+	}
+
+	var payload map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
+		t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
+	}
+	if payload["jq_root_path"] != ".event" {
+		t.Errorf("jq_root_path = %v, want .event", payload["jq_root_path"])
+	}
+	if payload["single_consumer"] != true {
+		t.Errorf("single_consumer = %v, want true", payload["single_consumer"])
+	}
+	resolved := payload["resolved_output_schema"].(map[string]interface{})
+	props := resolved["properties"].(map[string]interface{})
+	eventProps := props["event"].(map[string]interface{})["properties"].(map[string]interface{})
+	if got := eventProps["task_guid"].(map[string]interface{})["format"]; got != "task_guid" {
+		t.Errorf("task_guid format = %v, want task_guid", got)
+	}
+	if _, ok := eventProps["event_types"].(map[string]interface{})["items"].(map[string]interface{})["enum"]; !ok {
+		t.Fatalf("event_types enum missing in schema: %#v", eventProps["event_types"])
+	}
+}
+
 func TestSchema_RendersSubscriptionKeyMarker(t *testing.T) {
 	const syntheticKey = "test.evt_sub"
 	t.Cleanup(func() { eventlib.UnregisterKeyForTest(syntheticKey) })

events/im/card_action.go

@@ -0,0 +1,132 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package im
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"github.com/larksuite/cli/internal/event"
+)
+
+// CardActionTriggerOutput is the flattened shape for card.action.trigger.
+type CardActionTriggerOutput struct {
+	Type        string `json:"type"                    desc:"Event type; always card.action.trigger"`
+	EventID     string `json:"event_id,omitempty"      desc:"Globally unique event ID"`
+	Timestamp   string `json:"timestamp,omitempty"     desc:"Event delivery time (ms timestamp string)" kind:"timestamp_ms"`
+	OperatorID  string `json:"operator_id,omitempty"   desc:"Operator open_id"                          kind:"open_id"`
+	MessageID   string `json:"message_id,omitempty"    desc:"Message ID of the card"                    kind:"message_id"`
+	ChatID      string `json:"chat_id,omitempty"       desc:"Chat ID"                                   kind:"chat_id"`
+	Host        string `json:"host,omitempty"          desc:"Host type: im_message / im_top_notice"`
+	Token       string `json:"token,omitempty"         desc:"Token for delay card update (valid 30 min, max 2 updates)"`
+	ActionTag   string `json:"action_tag,omitempty"    desc:"Triggered element type: button/select_static/input/checker/etc"`
+	ActionValue string `json:"action_value,omitempty"  desc:"Developer-defined action value as JSON string"`
+	ActionName  string `json:"action_name,omitempty"   desc:"Element name attribute"`
+	FormValue   string `json:"form_value,omitempty"    desc:"Form submission values as JSON string (only on form submit)"`
+	InputValue  string `json:"input_value,omitempty"   desc:"Input field value (only for input elements)"`
+	Option      string `json:"option,omitempty"        desc:"Selected option value (for single-select dropdown)"`
+	Options     string `json:"options,omitempty"       desc:"Selected options, comma-separated (for multi-select)"`
+	Checked     bool   `json:"checked"                 desc:"Checkbox state (for checkbox elements)"`
+	Timezone    string `json:"timezone,omitempty"      desc:"User timezone for date/time picker interactions"`
+	CardContent string `json:"card_content,omitempty"  desc:"Original card JSON content (body.content) auto-fetched via message get API at consume time using message_id; empty if message_id absent or fetch fails"`
+}
+
+func processCardAction(ctx context.Context, rt event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
+	var envelope struct {
+		Header struct {
+			EventID    string `json:"event_id"`
+			EventType  string `json:"event_type"`
+			CreateTime string `json:"create_time"`
+		} `json:"header"`
+		Event struct {
+			Operator struct {
+				OpenID string `json:"open_id"`
+			} `json:"operator"`
+			Token  string `json:"token"`
+			Host   string `json:"host"`
+			Action struct {
+				Tag        string                 `json:"tag"`
+				Value      map[string]interface{} `json:"value"`
+				Name       string                 `json:"name"`
+				FormValue  map[string]interface{} `json:"form_value"`
+				InputValue string                 `json:"input_value"`
+				Option     string                 `json:"option"`
+				Options    []string               `json:"options"`
+				Checked    bool                   `json:"checked"`
+				Timezone   string                 `json:"timezone"`
+			} `json:"action"`
+			Context struct {
+				OpenMessageID string `json:"open_message_id"`
+				OpenChatID    string `json:"open_chat_id"`
+			} `json:"context"`
+		} `json:"event"`
+	}
+	if err := json.Unmarshal(raw.Payload, &envelope); err != nil {
+		return raw.Payload, nil //nolint:nilerr // passthrough on malformed payload
+	}
+
+	actionValue := marshalToString(envelope.Event.Action.Value)
+	formValue := marshalToString(envelope.Event.Action.FormValue)
+	options := strings.Join(envelope.Event.Action.Options, ",")
+
+	out := &CardActionTriggerOutput{
+		Type:        envelope.Header.EventType,
+		EventID:     envelope.Header.EventID,
+		Timestamp:   envelope.Header.CreateTime,
+		OperatorID:  envelope.Event.Operator.OpenID,
+		MessageID:   envelope.Event.Context.OpenMessageID,
+		ChatID:      envelope.Event.Context.OpenChatID,
+		Host:        envelope.Event.Host,
+		Token:       envelope.Event.Token,
+		ActionTag:   envelope.Event.Action.Tag,
+		ActionValue: actionValue,
+		ActionName:  envelope.Event.Action.Name,
+		FormValue:   formValue,
+		InputValue:  envelope.Event.Action.InputValue,
+		Option:      envelope.Event.Action.Option,
+		Options:     options,
+		Checked:     envelope.Event.Action.Checked,
+		Timezone:    envelope.Event.Action.Timezone,
+	}
+
+	if out.MessageID != "" && rt != nil {
+		out.CardContent = fetchCardUserDSL(ctx, rt, out.MessageID)
+	}
+
+	return json.Marshal(out)
+}
+
+// fetchCardUserDSL gets the card message content via message get API.
+// Returns empty string on any failure — never blocks event consumption.
+func fetchCardUserDSL(ctx context.Context, rt event.APIClient, messageID string) string {
+	path := "/open-apis/im/v1/messages/" + messageID + "?card_msg_content_type=user_card_content"
+	resp, err := rt.CallAPI(ctx, "GET", path, nil)
+	if err != nil {
+		return ""
+	}
+	var result struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+		Data struct {
+			Items []struct {
+				Body struct {
+					Content string `json:"content"`
+				} `json:"body"`
+			} `json:"items"`
+		} `json:"data"`
+	}
+	if json.Unmarshal(resp, &result) != nil || result.Code != 0 || len(result.Data.Items) == 0 {
+		return ""
+	}
+	return result.Data.Items[0].Body.Content
+}
+
+func marshalToString(m map[string]interface{}) string {
+	if len(m) == 0 {
+		return ""
+	}
+	b, _ := json.Marshal(m)
+	return string(b)
+}

events/im/card_action_test.go

@@ -0,0 +1,432 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package im
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/larksuite/cli/internal/event"
+)
+
+func TestCardActionTriggerRegistered(t *testing.T) {
+	def, ok := event.Lookup("card.action.trigger")
+	if !ok {
+		t.Fatal("card.action.trigger should be registered via Keys()")
+	}
+	if def.Schema.Custom == nil {
+		t.Error("card.action.trigger must set Schema.Custom")
+	}
+	if def.Process == nil {
+		t.Error("card.action.trigger must set Process")
+	}
+	if len(def.Scopes) == 0 {
+		t.Error("Scopes must not be empty")
+	}
+}
+
+func TestProcessCardAction_Button(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_btn_001",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469273"
+		},
+		"event": {
+			"operator": {"open_id": "ou_operator"},
+			"token": "c-token-btn",
+			"host": "im_message",
+			"action": {
+				"tag": "button",
+				"value": {"key": "approve"},
+				"name": "approve_btn",
+				"form_value": {},
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_msg_001",
+				"open_chat_id": "oc_chat_001"
+			}
+		}
+	}`
+	out := runCardAction(t, payload, nil)
+
+	if out.Type != "card.action.trigger" {
+		t.Errorf("Type = %q, want card.action.trigger", out.Type)
+	}
+	if out.EventID != "ev_btn_001" {
+		t.Errorf("EventID = %q", out.EventID)
+	}
+	if out.OperatorID != "ou_operator" {
+		t.Errorf("OperatorID = %q", out.OperatorID)
+	}
+	if out.ActionTag != "button" {
+		t.Errorf("ActionTag = %q, want button", out.ActionTag)
+	}
+	if out.ActionValue != `{"key":"approve"}` {
+		t.Errorf("ActionValue = %q", out.ActionValue)
+	}
+	if out.ActionName != "approve_btn" {
+		t.Errorf("ActionName = %q", out.ActionName)
+	}
+	if out.Token != "c-token-btn" {
+		t.Errorf("Token = %q", out.Token)
+	}
+	if out.MessageID != "om_msg_001" {
+		t.Errorf("MessageID = %q", out.MessageID)
+	}
+	if out.ChatID != "oc_chat_001" {
+		t.Errorf("ChatID = %q", out.ChatID)
+	}
+	if out.Host != "im_message" {
+		t.Errorf("Host = %q", out.Host)
+	}
+	if out.Timestamp != "1776409469273" {
+		t.Errorf("Timestamp = %q", out.Timestamp)
+	}
+}
+
+func TestProcessCardAction_FormSubmit(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_form_001",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469274"
+		},
+		"event": {
+			"operator": {"open_id": "ou_form_user"},
+			"token": "c-token-form",
+			"host": "im_message",
+			"action": {
+				"tag": "button",
+				"value": {},
+				"name": "submit_btn",
+				"form_value": {"name": "test-user", "reason": "testing"},
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_form_001",
+				"open_chat_id": "oc_chat_002"
+			}
+		}
+	}`
+	out := runCardAction(t, payload, nil)
+
+	if out.FormValue != `{"name":"test-user","reason":"testing"}` {
+		t.Errorf("FormValue = %q", out.FormValue)
+	}
+	if out.ActionTag != "button" {
+		t.Errorf("ActionTag = %q, want button", out.ActionTag)
+	}
+}
+
+func TestProcessCardAction_MultiSelect(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_ms_001",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469275"
+		},
+		"event": {
+			"operator": {"open_id": "ou_ms_user"},
+			"token": "c-token-ms",
+			"host": "im_message",
+			"action": {
+				"tag": "multi_select_static",
+				"value": {},
+				"name": "multi_select",
+				"options": ["opt_1", "opt_3"],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_ms_001",
+				"open_chat_id": "oc_chat_003"
+			}
+		}
+	}`
+	out := runCardAction(t, payload, nil)
+
+	if out.Options != "opt_1,opt_3" {
+		t.Errorf("Options = %q, want opt_1,opt_3", out.Options)
+	}
+	if out.ActionTag != "multi_select_static" {
+		t.Errorf("ActionTag = %q", out.ActionTag)
+	}
+}
+
+func TestProcessCardAction_Input(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_input_001",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469276"
+		},
+		"event": {
+			"operator": {"open_id": "ou_input_user"},
+			"token": "c-token-input",
+			"host": "im_message",
+			"action": {
+				"tag": "input",
+				"value": {},
+				"name": "text_input",
+				"input_value": "hello world",
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_input_001",
+				"open_chat_id": "oc_chat_004"
+			}
+		}
+	}`
+	out := runCardAction(t, payload, nil)
+
+	if out.InputValue != "hello world" {
+		t.Errorf("InputValue = %q", out.InputValue)
+	}
+	if out.ActionTag != "input" {
+		t.Errorf("ActionTag = %q", out.ActionTag)
+	}
+}
+
+func TestProcessCardAction_DatePicker(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_date_001",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469277"
+		},
+		"event": {
+			"operator": {"open_id": "ou_date_user"},
+			"token": "c-token-date",
+			"host": "im_message",
+			"action": {
+				"tag": "date_picker",
+				"value": {},
+				"name": "date_selector",
+				"option": "2024-04-01 +0800",
+				"timezone": "Asia/Shanghai",
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_date_001",
+				"open_chat_id": "oc_chat_005"
+			}
+		}
+	}`
+	out := runCardAction(t, payload, nil)
+
+	if out.Option != "2024-04-01 +0800" {
+		t.Errorf("Option = %q", out.Option)
+	}
+	if out.Timezone != "Asia/Shanghai" {
+		t.Errorf("Timezone = %q", out.Timezone)
+	}
+}
+
+func TestProcessCardAction_MalformedPayload(t *testing.T) {
+	raw := &event.RawEvent{
+		EventID:   "ev_bad",
+		EventType: "card.action.trigger",
+		Payload:   json.RawMessage(`not json`),
+		Timestamp: time.Now(),
+	}
+	got, err := processCardAction(context.Background(), nil, raw, nil)
+	if err != nil {
+		t.Fatalf("Process should swallow parse errors, got %v", err)
+	}
+	if string(got) != "not json" {
+		t.Errorf("malformed fallback output = %q, want original bytes", string(got))
+	}
+}
+
+func TestProcessCardAction_MessageGetSuccess(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_mg_ok",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469278"
+		},
+		"event": {
+			"operator": {"open_id": "ou_mg_user"},
+			"token": "c-token-mg",
+			"host": "im_message",
+			"action": {
+				"tag": "button",
+				"value": {"key": "click"},
+				"name": "btn",
+				"form_value": {},
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_mg_001",
+				"open_chat_id": "oc_chat_mg"
+			}
+		}
+	}`
+	cardContent := `{"header":{"title":{"tag":"plain_text","content":"A card"}}}`
+	mock := &mockAPIClient{resp: `{
+		"code": 0,
+		"msg": "success",
+		"data": {
+			"items": [{
+				"body": {"content": "` + escapeJSON(cardContent) + `"}
+			}]
+		}
+	}`}
+	out := runCardAction(t, payload, mock)
+
+	if out.CardContent == "" {
+		t.Error("CardContent should not be empty when message get succeeds")
+	}
+}
+
+func TestProcessCardAction_MessageGetErrorCode(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_mg_ec",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469279"
+		},
+		"event": {
+			"operator": {"open_id": "ou_mg_user2"},
+			"token": "c-token-mg2",
+			"host": "im_message",
+			"action": {
+				"tag": "button",
+				"value": {},
+				"name": "btn",
+				"form_value": {},
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_mg_002",
+				"open_chat_id": "oc_chat_mg2"
+			}
+		}
+	}`
+	mock := &mockAPIClient{resp: `{"code": 1, "msg": "error", "data": {"items": []}}`}
+	out := runCardAction(t, payload, mock)
+
+	if out.CardContent != "" {
+		t.Errorf("CardContent should be empty when code != 0, got %q", out.CardContent)
+	}
+}
+
+func TestProcessCardAction_MessageGetFailure(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_mg_fail",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469280"
+		},
+		"event": {
+			"operator": {"open_id": "ou_mg_user3"},
+			"token": "c-token-mg3",
+			"host": "im_message",
+			"action": {
+				"tag": "button",
+				"value": {},
+				"name": "btn",
+				"form_value": {},
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "om_mg_003",
+				"open_chat_id": "oc_chat_mg3"
+			}
+		}
+	}`
+	mock := &mockAPIClient{errResp: true}
+	out := runCardAction(t, payload, mock)
+
+	if out.CardContent != "" {
+		t.Errorf("CardContent should be empty when message get fails, got %q", out.CardContent)
+	}
+}
+
+func TestProcessCardAction_EmptyMessageID(t *testing.T) {
+	payload := `{
+		"schema": "2.0",
+		"header": {
+			"event_id": "ev_no_msg",
+			"event_type": "card.action.trigger",
+			"create_time": "1776409469281"
+		},
+		"event": {
+			"operator": {"open_id": "ou_no_msg"},
+			"token": "c-token-nm",
+			"host": "im_message",
+			"action": {
+				"tag": "button",
+				"value": {},
+				"name": "btn",
+				"form_value": {},
+				"options": [],
+				"checked": false
+			},
+			"context": {
+				"open_message_id": "",
+				"open_chat_id": "oc_chat_nm"
+			}
+		}
+	}`
+	out := runCardAction(t, payload, nil)
+
+	if out.CardContent != "" {
+		t.Errorf("CardContent should be empty when message_id is absent, got %q", out.CardContent)
+	}
+}
+
+type mockAPIClient struct {
+	resp    string
+	errResp bool
+}
+
+func (m *mockAPIClient) CallAPI(_ context.Context, _, _ string, _ interface{}) (json.RawMessage, error) {
+	if m.errResp {
+		return nil, context.DeadlineExceeded
+	}
+	return json.RawMessage(m.resp), nil
+}
+
+func runCardAction(t *testing.T, payload string, rt event.APIClient) CardActionTriggerOutput {
+	t.Helper()
+	raw := &event.RawEvent{
+		EventID:   "ev_test",
+		EventType: "card.action.trigger",
+		Payload:   json.RawMessage(payload),
+		Timestamp: time.Now(),
+	}
+	got, err := processCardAction(context.Background(), rt, raw, nil)
+	if err != nil {
+		t.Fatalf("Process error: %v", err)
+	}
+	var out CardActionTriggerOutput
+	if err := json.Unmarshal(got, &out); err != nil {
+		t.Fatalf("Process output is not valid CardActionTriggerOutput JSON: %v\nraw=%s", err, string(got))
+	}
+	return out
+}
+
+func escapeJSON(s string) string {
+	b, _ := json.Marshal(s)
+	return string(b[1 : len(b)-1])
+}

events/im/register.go

@@ -27,6 +27,21 @@ func Keys() []event.KeyDefinition {
 			AuthTypes:             []string{"bot"},
 			RequiredConsoleEvents: []string{"im.message.receive_v1"},
 		},
+		{
+			Key:              "card.action.trigger",
+			DisplayName:      "Card action",
+			Description:      "Triggered when a user interacts with an interactive card (button click, form submit, dropdown select, etc.). Output includes: token (valid 30 min, max 2 updates), action details (tag, value, name, form_value), and card_content (original card in userDSL text format, auto-fetched at consume time). To update the card: parse card_content to understand the current state, construct the new card JSON, then call `lark-cli api POST /open-apis/interactive/v1/card/update` with the token (see lark-im-card-action-reply.md).",
+			EventType:        "card.action.trigger",
+			SubscriptionType: event.SubTypeCallback,
+			Schema: event.SchemaDef{
+				Custom: &event.SchemaSpec{Type: reflect.TypeOf(CardActionTriggerOutput{})},
+			},
+			Process:               processCardAction,
+			Scopes:                []string{"im:message:readonly"},
+			AuthTypes:             []string{"bot"},
+			SingleConsumer:        true,
+			RequiredConsoleEvents: []string{"card.action.trigger"},
+		},
 	}
 
 	for _, rk := range nativeIMKeys {

events/register.go

@@ -7,6 +7,7 @@ package events
 import (
 	"github.com/larksuite/cli/events/im"
 	"github.com/larksuite/cli/events/minutes"
+	"github.com/larksuite/cli/events/task"
 	"github.com/larksuite/cli/events/vc"
 	"github.com/larksuite/cli/events/whiteboard"
 	"github.com/larksuite/cli/internal/event"
@@ -17,6 +18,7 @@ func init() {
 	all := [][]event.KeyDefinition{
 		im.Keys(),
 		minutes.Keys(),
+		task.Keys(),
 		vc.Keys(),
 		whiteboard.Keys(),
 	}

events/task/native.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package task
+
+// TaskUpdateUserAccessV2Data is the Task v2 update event payload under the
+// standard Lark V2 event envelope.
+type TaskUpdateUserAccessV2Data struct {
+	EventTypes []string `json:"event_types,omitempty" desc:"Task commit types included in this event" enum:"task_create,task_deleted,task_summary_update,task_desc_update,task_assignees_update,task_followers_update,task_reminders_update,task_start_due_update,task_completed_update"`
+	TaskGUID   string   `json:"task_guid,omitempty" desc:"Task GUID that changed" kind:"task_guid"`
+}
+
+var taskUpdateUserAccessCommitTypes = []string{
+	"task_create",
+	"task_deleted",
+	"task_summary_update",
+	"task_desc_update",
+	"task_assignees_update",
+	"task_followers_update",
+	"task_reminders_update",
+	"task_start_due_update",
+	"task_completed_update",
+}

events/task/preconsume.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package task
+
+import (
+	"context"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/event"
+)
+
+const taskSubscriptionPath = "/open-apis/task/v2/task_v2/task_subscription?user_id_type=open_id"
+
+func taskSubscriptionPreConsume(ctx context.Context, rt event.APIClient, _ map[string]string) (func() error, error) {
+	if rt == nil {
+		return nil, errs.NewInternalError(errs.SubtypeUnknown,
+			"runtime API client is required for pre-consume subscription")
+	}
+
+	if _, err := rt.CallAPI(ctx, "POST", taskSubscriptionPath, nil); err != nil {
+		if _, ok := errs.ProblemOf(err); ok {
+			return nil, err
+		}
+		return nil, errs.NewNetworkError(
+			errs.SubtypeNetworkTransport,
+			"failed to subscribe task event",
+		).WithCause(err)
+	}
+
+	return nil, nil
+}

events/task/preconsume_test.go

@@ -0,0 +1,119 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package task
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+)
+
+type stubAPIClient struct {
+	err error
+
+	method string
+	path   string
+	body   interface{}
+	calls  int
+}
+
+func (s *stubAPIClient) CallAPI(_ context.Context, method, path string, body interface{}) (json.RawMessage, error) {
+	s.method = method
+	s.path = path
+	s.body = body
+	s.calls++
+	if s.err != nil {
+		return nil, s.err
+	}
+	return json.RawMessage(`{"code":0,"msg":"success","data":{}}`), nil
+}
+
+func TestTaskSubscriptionPreConsumeCallsSubscribeAPI(t *testing.T) {
+	rt := &stubAPIClient{}
+	cleanup, err := taskSubscriptionPreConsume(context.Background(), rt, nil)
+	if err != nil {
+		t.Fatalf("taskSubscriptionPreConsume error = %v", err)
+	}
+	if cleanup != nil {
+		t.Fatal("cleanup = non-nil, want nil because task subscription has no unsubscribe API")
+	}
+	if rt.calls != 1 {
+		t.Fatalf("calls = %d, want 1", rt.calls)
+	}
+	if rt.method != "POST" {
+		t.Errorf("method = %q, want POST", rt.method)
+	}
+	if rt.path != taskSubscriptionPath {
+		t.Errorf("path = %q, want %q", rt.path, taskSubscriptionPath)
+	}
+	if rt.body != nil {
+		t.Errorf("body = %#v, want nil", rt.body)
+	}
+}
+
+func TestTaskSubscriptionPreConsumeRequiresRuntime(t *testing.T) {
+	_, err := taskSubscriptionPreConsume(context.Background(), nil, nil)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got %T: %v", err, err)
+	}
+	if p.Category != errs.CategoryInternal {
+		t.Errorf("category = %s, want %s", p.Category, errs.CategoryInternal)
+	}
+	if p.Subtype != errs.SubtypeUnknown {
+		t.Errorf("subtype = %s, want %s", p.Subtype, errs.SubtypeUnknown)
+	}
+}
+
+func TestTaskSubscriptionPreConsumePassesThroughAPIError(t *testing.T) {
+	wantErr := errs.NewValidationError(errs.SubtypeFailedPrecondition, "subscription already exists")
+	rt := &stubAPIClient{err: wantErr}
+
+	_, err := taskSubscriptionPreConsume(context.Background(), rt, nil)
+	if err != wantErr {
+		t.Fatalf("err identity changed: got %T %v, want original %T %v", err, err, wantErr, wantErr)
+	}
+	if !errors.Is(err, wantErr) {
+		t.Fatalf("err = %v, want %v", err, wantErr)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got %T: %v", err, err)
+	}
+	if p.Category != errs.CategoryValidation {
+		t.Errorf("category = %s, want %s", p.Category, errs.CategoryValidation)
+	}
+	if p.Subtype != errs.SubtypeFailedPrecondition {
+		t.Errorf("subtype = %s, want %s", p.Subtype, errs.SubtypeFailedPrecondition)
+	}
+}
+
+func TestTaskSubscriptionPreConsumeWrapsUntypedAPIError(t *testing.T) {
+	cause := errors.New("connection reset")
+	rt := &stubAPIClient{err: cause}
+
+	_, err := taskSubscriptionPreConsume(context.Background(), rt, nil)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if !errors.Is(err, cause) {
+		t.Fatalf("err = %v, want cause %v", err, cause)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got %T: %v", err, err)
+	}
+	if p.Category != errs.CategoryNetwork {
+		t.Errorf("category = %s, want %s", p.Category, errs.CategoryNetwork)
+	}
+	if p.Subtype != errs.SubtypeNetworkTransport {
+		t.Errorf("subtype = %s, want %s", p.Subtype, errs.SubtypeNetworkTransport)
+	}
+}

events/task/register.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package task registers Task-domain EventKeys.
+package task
+
+import (
+	"reflect"
+
+	"github.com/larksuite/cli/internal/event"
+)
+
+const eventTypeTaskUpdateUserAccessV2 = "task.task.update_user_access_v2"
+
+// Keys returns all Task-domain EventKey definitions.
+func Keys() []event.KeyDefinition {
+	return []event.KeyDefinition{
+		{
+			Key:         eventTypeTaskUpdateUserAccessV2,
+			DisplayName: "Task updated",
+			Description: "Triggered when tasks visible to the current user or app are created, deleted, or updated",
+			EventType:   eventTypeTaskUpdateUserAccessV2,
+			Schema: event.SchemaDef{
+				Native: &event.SchemaSpec{Type: reflect.TypeOf(TaskUpdateUserAccessV2Data{})},
+			},
+			PreConsume:            taskSubscriptionPreConsume,
+			Scopes:                []string{"task:task:read"},
+			AuthTypes:             []string{"user", "bot"},
+			RequiredConsoleEvents: []string{eventTypeTaskUpdateUserAccessV2},
+			SingleConsumer:        true,
+		},
+	}
+}

events/task/register_test.go

@@ -0,0 +1,95 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package task
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"github.com/larksuite/cli/internal/event"
+	"github.com/larksuite/cli/internal/event/schemas"
+)
+
+func TestKeysTaskUpdateUserAccessMetadata(t *testing.T) {
+	keys := Keys()
+	if len(keys) != 1 {
+		t.Fatalf("len(Keys()) = %d, want 1", len(keys))
+	}
+
+	def := keys[0]
+	if def.Key != eventTypeTaskUpdateUserAccessV2 {
+		t.Errorf("Key = %q, want %q", def.Key, eventTypeTaskUpdateUserAccessV2)
+	}
+	if def.EventType != eventTypeTaskUpdateUserAccessV2 {
+		t.Errorf("EventType = %q, want %q", def.EventType, eventTypeTaskUpdateUserAccessV2)
+	}
+	if def.Schema.Native == nil {
+		t.Fatal("Schema.Native is nil")
+	}
+	if def.Schema.Native.Type != reflect.TypeOf(TaskUpdateUserAccessV2Data{}) {
+		t.Errorf("native type = %v, want TaskUpdateUserAccessV2Data", def.Schema.Native.Type)
+	}
+	if def.Process != nil {
+		t.Fatal("Native Task EventKey must not set Process")
+	}
+	if def.PreConsume == nil {
+		t.Fatal("PreConsume is nil")
+	}
+	if !def.SingleConsumer {
+		t.Fatal("SingleConsumer = false, want true")
+	}
+	if !reflect.DeepEqual(def.Scopes, []string{"task:task:read"}) {
+		t.Errorf("Scopes = %#v", def.Scopes)
+	}
+	if !reflect.DeepEqual(def.AuthTypes, []string{"user", "bot"}) {
+		t.Errorf("AuthTypes = %#v", def.AuthTypes)
+	}
+	if !reflect.DeepEqual(def.RequiredConsoleEvents, []string{eventTypeTaskUpdateUserAccessV2}) {
+		t.Errorf("RequiredConsoleEvents = %#v", def.RequiredConsoleEvents)
+	}
+}
+
+func TestTaskUpdateUserAccessSchemaAnnotations(t *testing.T) {
+	raw := schemas.WrapV2Envelope(schemas.FromType(reflect.TypeOf(TaskUpdateUserAccessV2Data{})))
+	var schema map[string]interface{}
+	if err := json.Unmarshal(raw, &schema); err != nil {
+		t.Fatalf("unmarshal schema: %v", err)
+	}
+
+	eventProps := schema["properties"].(map[string]interface{})["event"].(map[string]interface{})["properties"].(map[string]interface{})
+	taskGUID := eventProps["task_guid"].(map[string]interface{})
+	if got := taskGUID["format"]; got != "task_guid" {
+		t.Errorf("task_guid format = %v, want task_guid", got)
+	}
+
+	eventTypes := eventProps["event_types"].(map[string]interface{})
+	items := eventTypes["items"].(map[string]interface{})
+	rawEnum, ok := items["enum"].([]interface{})
+	if !ok {
+		t.Fatalf("event_types item enum missing: %#v", items["enum"])
+	}
+	got := make(map[string]bool, len(rawEnum))
+	for _, v := range rawEnum {
+		got[v.(string)] = true
+	}
+	for _, want := range taskUpdateUserAccessCommitTypes {
+		if !got[want] {
+			t.Errorf("event_types enum missing %q; enum=%v", want, rawEnum)
+		}
+	}
+}
+
+func TestTaskUpdateUserAccessRegistersCleanly(t *testing.T) {
+	const key = eventTypeTaskUpdateUserAccessV2
+	event.UnregisterKeyForTest(key)
+	t.Cleanup(func() { event.UnregisterKeyForTest(key) })
+
+	for _, def := range Keys() {
+		event.RegisterKey(def)
+	}
+	if _, ok := event.Lookup(key); !ok {
+		t.Fatalf("event.Lookup(%q) not registered", key)
+	}
+}

internal/binding/audit.go

@@ -131,31 +131,3 @@ func requireInTrustedDirs(effectivePath string, trustedDirs []string, label stri
 	}
 	return fmt.Errorf("%s: path %q is not inside any trusted directory", label, effectivePath)
 }
-
-// auditFilePermissions rejects world/group-writable modes (always) and
-// world/group-readable modes (unless allowReadableByOthers is true, which
-// exec commands typically need for their usual 755 mode).
-func auditFilePermissions(effectivePath string, allowReadableByOthers bool, label string) error {
-	info, err := vfs.Stat(effectivePath)
-	if err != nil {
-		return fmt.Errorf("%s: cannot stat %q: %w", label, effectivePath, err)
-	}
-	mode := info.Mode().Perm()
-
-	if mode&0o002 != 0 {
-		return fmt.Errorf("%s: path %q is world-writable (mode %04o)", label, effectivePath, mode)
-	}
-	if mode&0o020 != 0 {
-		return fmt.Errorf("%s: path %q is group-writable (mode %04o)", label, effectivePath, mode)
-	}
-	if allowReadableByOthers {
-		return nil
-	}
-	if mode&0o004 != 0 {
-		return fmt.Errorf("%s: path %q is world-readable (mode %04o)", label, effectivePath, mode)
-	}
-	if mode&0o040 != 0 {
-		return fmt.Errorf("%s: path %q is group-readable (mode %04o)", label, effectivePath, mode)
-	}
-	return nil
-}

internal/binding/audit_unix.go

@@ -29,3 +29,31 @@ func checkOwnerUID(path, label string) error {
 	}
 	return nil
 }
+
+// auditFilePermissions rejects world/group-writable modes (always) and
+// world/group-readable modes (unless allowReadableByOthers is true, which
+// exec commands typically need for their usual 755 mode).
+func auditFilePermissions(effectivePath string, allowReadableByOthers bool, label string) error {
+	info, err := vfs.Stat(effectivePath)
+	if err != nil {
+		return fmt.Errorf("%s: cannot stat %q: %w", label, effectivePath, err)
+	}
+	mode := info.Mode().Perm()
+
+	if mode&0o002 != 0 {
+		return fmt.Errorf("%s: path %q is world-writable (mode %04o)", label, effectivePath, mode)
+	}
+	if mode&0o020 != 0 {
+		return fmt.Errorf("%s: path %q is group-writable (mode %04o)", label, effectivePath, mode)
+	}
+	if allowReadableByOthers {
+		return nil
+	}
+	if mode&0o004 != 0 {
+		return fmt.Errorf("%s: path %q is world-readable (mode %04o)", label, effectivePath, mode)
+	}
+	if mode&0o040 != 0 {
+		return fmt.Errorf("%s: path %q is group-readable (mode %04o)", label, effectivePath, mode)
+	}
+	return nil
+}

internal/binding/audit_windows.go

@@ -5,7 +5,22 @@
 
 package binding
 
+import (
+	"fmt"
+
+	"github.com/larksuite/cli/internal/vfs"
+)
+
 // checkOwnerUID is a no-op on Windows where Unix UID semantics don't apply.
 func checkOwnerUID(path, label string) error {
 	return nil
 }
+
+// auditFilePermissions skips POSIX permission-bit auditing on Windows because
+// Go synthesizes mode bits from file attributes rather than NTFS ACLs.
+func auditFilePermissions(effectivePath string, allowReadableByOthers bool, label string) error {
+	if _, err := vfs.Stat(effectivePath); err != nil {
+		return fmt.Errorf("%s: cannot stat %q: %w", label, effectivePath, err)
+	}
+	return nil
+}

internal/binding/audit_windows_test.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build windows
+
+package binding
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestAssertSecurePath_WindowsIgnoresSyntheticUnixPermissionBits(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "secrets-getter.cmd")
+	if err := os.WriteFile(p, []byte("@echo off\r\n"), 0o600); err != nil {
+		t.Fatalf("write temp command: %v", err)
+	}
+
+	got, err := AssertSecurePath(AuditParams{
+		TargetPath:            p,
+		Label:                 "exec provider command",
+		AllowInsecurePath:     false,
+		AllowReadableByOthers: true,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error for Windows synthetic mode bits: %v", err)
+	}
+	if got != p {
+		t.Errorf("got %q, want %q", got, p)
+	}
+}

shortcuts/base/base_resolve.go

@@ -0,0 +1,545 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package base
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+const (
+	baseURLResolveHintGeneric = "Provide a /base/, /wiki/, or /record/ URL, or use base +title-resolve --title if you only know the Base title."
+	baseTitleResolveHint      = "choose one candidate, then use +base-block-list to list tables, dashboards, workflows, and other Base blocks"
+	nextStepBaseBlockList     = "use +base-block-list to list tables, dashboards, workflows, and other Base blocks"
+	nextStepRecordList        = "use +record-list to list records in the resolved table"
+	titleResolveQueryMaxLen   = 30
+)
+
+var BaseURLResolve = common.Shortcut{
+	Service:     "base",
+	Command:     "+url-resolve",
+	Description: "Resolve a Base-related URL into Base coordinates",
+	Risk:        "read",
+	Scopes:      []string{},
+	ConditionalScopes: []string{
+		"base:field:read",
+		"base:record:read",
+		"wiki:node:retrieve",
+	},
+	AuthTypes: authTypes(),
+	HasFormat: true,
+	Flags: []common.Flag{
+		{Name: "url", Desc: "Base/Wiki/record-share URL to resolve"},
+		{Name: "query", Hidden: true, Desc: "Alias for --url; accepted to recover from AI routing mistakes"},
+	},
+	Tips: []string{
+		`Example: lark-cli base +url-resolve --url "https://example.larkoffice.com/base/<base_token>?table=<table_id>&view=<view_id>"`,
+		"Only URLs are accepted. For Base titles or keywords, use +title-resolve --title.",
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		_, err := readURLResolveInput(runtime)
+		return err
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		raw, err := readURLResolveInput(runtime)
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		parsed, err := parseResolveURL(raw)
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		switch classifyBaseURL(parsed) {
+		case "wiki_url":
+			return common.NewDryRunAPI().
+				GET("/open-apis/wiki/v2/spaces/get_node").
+				Params(map[string]interface{}{"token": firstPathSegmentAfter(parsed.Path, "/wiki/")})
+		case "record_share_url":
+			return common.NewDryRunAPI().
+				GET("/open-apis/base/v3/record_share/:record_share_token/meta").
+				Set("record_share_token", firstPathSegmentAfter(parsed.Path, "/record/"))
+		default:
+			return common.NewDryRunAPI().Set("url", raw).Set("resolution", "local")
+		}
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		return executeBaseURLResolve(runtime)
+	},
+}
+
+var BaseTitleResolve = common.Shortcut{
+	Service:     "base",
+	Command:     "+title-resolve",
+	Description: "Resolve a Base title or keyword through Drive search",
+	Risk:        "read",
+	Scopes:      []string{"search:docs:read"},
+	AuthTypes:   []string{"user"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "title", Desc: "Base title keyword to search via Drive (30 characters or fewer)"},
+		{Name: "query", Hidden: true, Desc: "Alias for --title; accepted to recover from AI routing mistakes"},
+		{Name: "url", Hidden: true, Desc: "Alias for --title; accepted to recover from AI routing mistakes"},
+	},
+	Tips: []string{
+		`Example: lark-cli base +title-resolve --title "Sales pipeline"`,
+		"Pass a short keyword from the Base title, 30 characters or fewer. Use +url-resolve for URLs.",
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		_, err := readTitleResolveQuery(runtime)
+		return err
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		query, err := readTitleResolveQuery(runtime)
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		return common.NewDryRunAPI().
+			POST("/open-apis/search/v2/doc_wiki/search").
+			Body(buildTitleResolveSearchBody(query))
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		return executeBaseTitleResolve(runtime)
+	},
+}
+
+func readURLResolveInput(runtime *common.RuntimeContext) (string, error) {
+	urlValue := strings.TrimSpace(runtime.Str("url"))
+	queryValue := strings.TrimSpace(runtime.Str("query"))
+	if urlValue != "" && queryValue != "" {
+		return "", baseFlagErrorf("--url and --query are mutually exclusive")
+	}
+	value := urlValue
+	if value == "" {
+		value = queryValue
+	}
+	if value == "" {
+		return "", baseFlagErrorf("specify --url")
+	}
+	return value, nil
+}
+
+func readTitleResolveQuery(runtime *common.RuntimeContext) (string, error) {
+	values := []struct {
+		name  string
+		value string
+	}{
+		{"title", strings.TrimSpace(runtime.Str("title"))},
+		{"query", strings.TrimSpace(runtime.Str("query"))},
+		{"url", strings.TrimSpace(runtime.Str("url"))},
+	}
+	var pickedName, pickedValue string
+	for _, v := range values {
+		if v.value == "" {
+			continue
+		}
+		if pickedValue != "" {
+			return "", baseFlagErrorf("--%s and --%s are mutually exclusive", pickedName, v.name)
+		}
+		pickedName = v.name
+		pickedValue = v.value
+	}
+	if pickedValue == "" {
+		return "", baseFlagErrorf("specify --title")
+	}
+	if len([]rune(pickedValue)) > titleResolveQueryMaxLen {
+		return "", resolveValidationError(
+			fmt.Sprintf("base +title-resolve title keyword must be %d characters or fewer.", titleResolveQueryMaxLen),
+			"Use a shorter keyword from the Base title, or provide a /base/ URL and use base +url-resolve.",
+		)
+	}
+	return pickedValue, nil
+}
+
+func executeBaseURLResolve(runtime *common.RuntimeContext) error {
+	raw, err := readURLResolveInput(runtime)
+	if err != nil {
+		return err
+	}
+	parsed, err := parseResolveURL(raw)
+	if err != nil {
+		return err
+	}
+
+	switch classifyBaseURL(parsed) {
+	case "base_url":
+		out := resolveBaseURL(parsed)
+		enrichBaseResolveHint(runtime, out)
+		runtime.OutFormat(out, nil, nil)
+		return nil
+	case "wiki_url":
+		out, err := resolveWikiBaseURL(runtime, parsed)
+		if err != nil {
+			return err
+		}
+		runtime.OutFormat(out, nil, nil)
+		return nil
+	case "record_share_url":
+		out, err := resolveRecordShareURL(runtime, parsed)
+		if err != nil {
+			return err
+		}
+		runtime.OutFormat(out, nil, nil)
+		return nil
+	case "form_share_url":
+		runtime.OutFormat(resolveFormShareURL(parsed), nil, nil)
+		return nil
+	case "view_share_url":
+		return resolveValidationError(
+			"This is a Base view share URL. CLI does not support resolving Base view share URLs.",
+			"Open it in the browser, or provide the URL of the Base itself, such as its Wiki URL or Base URL.",
+		)
+	case "dashboard_share_url":
+		return resolveValidationError(
+			"This is a Base dashboard share URL. CLI does not support resolving Base dashboard share URLs.",
+			"Open it in the browser, or provide the URL of the Base itself, such as its Wiki URL or Base URL.",
+		)
+	case "workspace_url":
+		return resolveValidationError(
+			"This is a Base workspace URL. CLI does not support resolving Base workspace URLs.",
+			"Open it in the browser, or provide the URL of the Base itself, such as its Wiki URL or Base URL.",
+		)
+	case "add_record_url":
+		return resolveValidationError(
+			"This is a Base add-record URL. CLI does not support resolving Base add-record URLs.",
+			"Open it in the browser, or provide the URL of the Base itself, such as its Wiki URL or Base URL.",
+		)
+	default:
+		return resolveValidationError("This URL is not a supported Base URL pattern.", baseURLResolveHintGeneric)
+	}
+}
+
+func parseResolveURL(raw string) (*url.URL, error) {
+	parsed, err := url.Parse(strings.TrimSpace(raw))
+	if err != nil || parsed.Scheme == "" || parsed.Host == "" {
+		return nil, resolveValidationError("base +url-resolve only accepts full URLs.", "For a Base title or keyword, use base +title-resolve --title.")
+	}
+	if parsed.Scheme != "http" && parsed.Scheme != "https" {
+		return nil, resolveValidationError("base +url-resolve only accepts HTTP or HTTPS URLs.", baseURLResolveHintGeneric)
+	}
+	return parsed, nil
+}
+
+func classifyBaseURL(u *url.URL) string {
+	path := normalizeResolvePath(u.Path)
+	switch {
+	case pathSegmentExists(path, "/base/workspace/"):
+		return "workspace_url"
+	case pathSegmentExists(path, "/base/add/"):
+		return "add_record_url"
+	case pathSegmentExists(path, "/base/"):
+		return "base_url"
+	case pathSegmentExists(path, "/wiki/"):
+		return "wiki_url"
+	case pathSegmentExists(path, "/record/"):
+		return "record_share_url"
+	case pathSegmentExists(path, "/share/base/form/"):
+		return "form_share_url"
+	case pathSegmentExists(path, "/share/base/view/"):
+		return "view_share_url"
+	case pathSegmentExists(path, "/share/base/dashboard/"):
+		return "dashboard_share_url"
+	default:
+		return ""
+	}
+}
+
+func resolveBaseURL(u *url.URL) map[string]interface{} {
+	query := u.Query()
+	out := map[string]interface{}{
+		"input_type":    "base_url",
+		"resource_type": "bitable",
+		"base_token":    firstPathSegmentAfter(u.Path, "/base/"),
+	}
+	if tableID := strings.TrimSpace(query.Get("table")); tableID != "" {
+		out["table_id"] = tableID
+	}
+	if viewID := strings.TrimSpace(query.Get("view")); viewID != "" {
+		out["view_id"] = viewID
+	}
+	if recordID := strings.TrimSpace(query.Get("record")); recordID != "" {
+		out["record_id"] = recordID
+	}
+	return out
+}
+
+func resolveWikiBaseURL(runtime *common.RuntimeContext, u *url.URL) (map[string]interface{}, error) {
+	token := firstPathSegmentAfter(u.Path, "/wiki/")
+	data, err := runtime.CallAPITyped("GET", "/open-apis/wiki/v2/spaces/get_node", map[string]interface{}{"token": token}, nil)
+	if err != nil {
+		return nil, err
+	}
+	node := common.GetMap(data, "node")
+	objType := strings.TrimSpace(common.GetString(node, "obj_type"))
+	if objType != "bitable" {
+		return nil, resolveValidationError(
+			fmt.Sprintf("This Wiki URL resolves to %s, not Base.", valueOrUnknown(objType)),
+			"Use the corresponding skill for that resource, or provide a Base URL.",
+		)
+	}
+	baseToken := strings.TrimSpace(common.GetString(node, "obj_token"))
+	if baseToken == "" {
+		return nil, errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki node response is missing obj_token")
+	}
+	return map[string]interface{}{
+		"input_type":      "wiki_url",
+		"resource_type":   "bitable",
+		"wiki_node_token": token,
+		"base_token":      baseToken,
+		"title":           common.GetString(node, "title"),
+		"hint":            resolveHint("", nil),
+	}, nil
+}
+
+func resolveRecordShareURL(runtime *common.RuntimeContext, u *url.URL) (map[string]interface{}, error) {
+	shareToken := firstPathSegmentAfter(u.Path, "/record/")
+	data, err := baseV3Call(runtime, "GET", baseV3Path("record_share", shareToken, "meta"), nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	out := map[string]interface{}{
+		"input_type":         "record_share_url",
+		"resource_type":      "bitable",
+		"record_share_token": firstNonEmpty(common.GetString(data, "record_share_token"), shareToken),
+		"base_token":         common.GetString(data, "base_token"),
+		"table_id":           common.GetString(data, "table_id"),
+		"record_id":          common.GetString(data, "record_id"),
+	}
+	enrichRecordShareResolveHint(runtime, out)
+	return out, nil
+}
+
+func resolveFormShareURL(u *url.URL) map[string]interface{} {
+	return map[string]interface{}{
+		"input_type":    "form_share_url",
+		"resource_type": "bitable_form",
+		"share_token":   firstPathSegmentAfter(u.Path, "/share/base/form/"),
+		"hint": map[string]interface{}{
+			"next_step": "use +form-detail to inspect the form, or use +form-submit to submit a response",
+		},
+	}
+}
+
+func executeBaseTitleResolve(runtime *common.RuntimeContext) error {
+	query, err := readTitleResolveQuery(runtime)
+	if err != nil {
+		return err
+	}
+	data, err := runtime.CallAPITyped("POST", "/open-apis/search/v2/doc_wiki/search", nil, buildTitleResolveSearchBody(query))
+	if err != nil {
+		return err
+	}
+	candidates := normalizeTitleResolveCandidates(common.GetSlice(data, "res_units"))
+	switch len(candidates) {
+	case 0:
+		return resolveValidationError(
+			"No Base matched this title or keyword.",
+			"Try a more specific Base title, or provide a /base/ URL and use base +url-resolve.",
+		)
+	case 1:
+		out := map[string]interface{}{
+			"input_type":    "title_query",
+			"resource_type": "bitable",
+			"title":         candidates[0]["title"],
+			"base_token":    candidates[0]["base_token"],
+			"url":           candidates[0]["url"],
+			"owner_name":    candidates[0]["owner_name"],
+			"update_time":   candidates[0]["update_time"],
+			"hint":          resolveHint("", nil),
+		}
+		runtime.OutFormat(out, nil, nil)
+		return nil
+	default:
+		runtime.OutFormat(map[string]interface{}{
+			"input_type":    "title_query",
+			"resource_type": "bitable",
+			"candidates":    candidates,
+			"hint": map[string]interface{}{
+				"next_step": baseTitleResolveHint,
+			},
+		}, nil, nil)
+		return nil
+	}
+}
+
+func enrichBaseResolveHint(runtime *common.RuntimeContext, out map[string]interface{}) {
+	baseToken := strings.TrimSpace(common.GetString(out, "base_token"))
+	tableID := strings.TrimSpace(common.GetString(out, "table_id"))
+	if baseToken == "" || tableID == "" {
+		out["hint"] = resolveHint("", nil)
+		return
+	}
+	fields, total, err := listAllFields(runtime, baseToken, tableID, 0, 100)
+	if err != nil {
+		out["hint"] = resolveHint(tableID, nil)
+		return
+	}
+	out["hint"] = resolveHint(tableID, map[string]interface{}{"fields": map[string]interface{}{"fields": fields, "total": total}})
+}
+
+func enrichRecordShareResolveHint(runtime *common.RuntimeContext, out map[string]interface{}) {
+	baseToken := strings.TrimSpace(common.GetString(out, "base_token"))
+	tableID := strings.TrimSpace(common.GetString(out, "table_id"))
+	recordID := strings.TrimSpace(common.GetString(out, "record_id"))
+	hint := map[string]interface{}{}
+	if baseToken != "" && tableID != "" && recordID != "" {
+		if record, err := getResolveRecord(runtime, baseToken, tableID, recordID); err == nil {
+			hint["record_data"] = formatResolvedRecordData(record)
+		}
+	}
+	if baseToken != "" && tableID != "" {
+		if fields, total, err := listAllFields(runtime, baseToken, tableID, 0, 100); err == nil {
+			hint["fields"] = map[string]interface{}{"fields": fields, "total": total}
+		}
+	}
+	out["hint"] = resolveHint(tableID, hint)
+	common.GetMap(out, "hint")["next_step"] = recordShareNextStep(baseToken, tableID, recordID)
+}
+
+func getResolveRecord(runtime *common.RuntimeContext, baseToken, tableID, recordID string) (map[string]interface{}, error) {
+	body := map[string]interface{}{"record_id_list": []string{recordID}}
+	result, err := baseV3Raw(runtime, "POST", baseV3Path("bases", baseToken, "tables", tableID, "records", "batch_get"), nil, body)
+	return handleBaseAPIResult(result, err, "batch get records")
+}
+
+func formatResolvedRecordData(record map[string]interface{}) map[string]interface{} {
+	fieldIDs := common.GetSlice(record, "field_id_list")
+	fieldNames := common.GetSlice(record, "fields")
+	rows := common.GetSlice(record, "data")
+
+	data := map[string]interface{}{}
+	if len(rows) > 0 {
+		if values, ok := rows[0].([]interface{}); ok {
+			for i, value := range values {
+				data[resolvedRecordFieldKey(fieldIDs, fieldNames, i)] = value
+			}
+		}
+	}
+	return data
+}
+
+func resolvedRecordFieldKey(fieldIDs, fieldNames []interface{}, index int) string {
+	if index < len(fieldIDs) {
+		if fieldID := strings.TrimSpace(fmt.Sprintf("%v", fieldIDs[index])); fieldID != "" {
+			return fieldID
+		}
+	}
+	if index < len(fieldNames) {
+		if fieldName := strings.TrimSpace(fmt.Sprintf("%v", fieldNames[index])); fieldName != "" {
+			return fieldName
+		}
+	}
+	return fmt.Sprintf("field_%d", index+1)
+}
+
+func recordShareNextStep(baseToken, tableID, recordID string) string {
+	return fmt.Sprintf(`use +record-upsert --base-token %s --table-id %s --record-id %s --json '{"<field_id>":"<new_value>"}' to update this record`, baseToken, tableID, recordID)
+}
+
+func resolveHint(tableID string, extra map[string]interface{}) map[string]interface{} {
+	hint := map[string]interface{}{}
+	for key, value := range extra {
+		hint[key] = value
+	}
+	if strings.TrimSpace(tableID) != "" {
+		hint["next_step"] = nextStepRecordList
+	} else {
+		hint["next_step"] = nextStepBaseBlockList
+	}
+	return hint
+}
+
+func buildTitleResolveSearchBody(query string) map[string]interface{} {
+	filter := map[string]interface{}{"doc_types": []string{"BITABLE"}}
+	return map[string]interface{}{
+		"query":       query,
+		"page_size":   5,
+		"doc_filter":  filter,
+		"wiki_filter": filter,
+	}
+}
+
+func normalizeTitleResolveCandidates(items []interface{}) []map[string]interface{} {
+	candidates := make([]map[string]interface{}, 0, len(items))
+	for _, item := range items {
+		row, _ := item.(map[string]interface{})
+		meta, _ := row["result_meta"].(map[string]interface{})
+		if row == nil || meta == nil || strings.ToUpper(common.GetString(meta, "doc_types")) != "BITABLE" {
+			continue
+		}
+		token := strings.TrimSpace(common.GetString(meta, "token"))
+		if token == "" {
+			continue
+		}
+		title := stripSearchHighlight(common.GetString(row, "title_highlighted"))
+		if title == "" {
+			title = strings.TrimSpace(common.GetString(row, "title"))
+		}
+		candidates = append(candidates, map[string]interface{}{
+			"title":       title,
+			"base_token":  token,
+			"url":         common.GetString(meta, "url"),
+			"owner_name":  common.GetString(meta, "owner_name"),
+			"update_time": common.GetString(meta, "update_time_iso"),
+		})
+	}
+	return candidates
+}
+
+var searchHighlightTagRe = regexp.MustCompile(`</?h>`)
+
+func stripSearchHighlight(s string) string {
+	return strings.TrimSpace(searchHighlightTagRe.ReplaceAllString(s, ""))
+}
+
+func resolveValidationError(message, hint string) error {
+	return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", message).WithHint("%s", hint)
+}
+
+func normalizeResolvePath(path string) string {
+	if path == "" {
+		return "/"
+	}
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	return path
+}
+
+func pathSegmentExists(path, prefix string) bool {
+	return firstPathSegmentAfter(path, prefix) != ""
+}
+
+func firstPathSegmentAfter(path, prefix string) string {
+	path = normalizeResolvePath(path)
+	if !strings.HasPrefix(path, prefix) {
+		return ""
+	}
+	rest := path[len(prefix):]
+	if idx := strings.IndexByte(rest, '/'); idx >= 0 {
+		rest = rest[:idx]
+	}
+	return strings.TrimSpace(rest)
+}
+
+func valueOrUnknown(s string) string {
+	if strings.TrimSpace(s) == "" {
+		return "an unknown resource type"
+	}
+	return s
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}

shortcuts/base/base_resolve_test.go

@@ -0,0 +1,454 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package base
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/shortcuts/common"
+	"github.com/spf13/cobra"
+)
+
+func TestBaseURLResolveBaseURL(t *testing.T) {
+	t.Run("with coordinates", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(fieldListStub("bas123", "tbl123"))
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve",
+			"--url", "https://example.larkoffice.com/base/bas123?table=tbl123&view=vew123&record=rec123",
+			"--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+
+		data := decodeBaseEnvelope(t, stdout)
+		if data["input_type"] != "base_url" || data["base_token"] != "bas123" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+		if data["table_id"] != "tbl123" || data["view_id"] != "vew123" || data["record_id"] != "rec123" {
+			t.Fatalf("missing Base coordinates: %#v", data)
+		}
+		hint, _ := data["hint"].(map[string]interface{})
+		fields, _ := hint["fields"].(map[string]interface{})
+		if hint["next_step"] != nextStepRecordList || fields["total"] != float64(2) {
+			t.Fatalf("unexpected hint: %#v", hint)
+		}
+	})
+
+	t.Run("base only", func(t *testing.T) {
+		factory, stdout, _ := newExecuteFactory(t)
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.larkoffice.com/base/bas123", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		if data["input_type"] != "base_url" || data["base_token"] != "bas123" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+		if _, ok := data["table_id"]; ok {
+			t.Fatalf("table_id should be omitted for base-only URL: %#v", data)
+		}
+		hint, _ := data["hint"].(map[string]interface{})
+		if hint["next_step"] != nextStepBaseBlockList {
+			t.Fatalf("unexpected hint: %#v", hint)
+		}
+	})
+
+	t.Run("field list enrichment failure still returns coordinates", func(t *testing.T) {
+		factory, stdout, _ := newExecuteFactory(t)
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.larkoffice.com/base/bas123?table=tbl123", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		if data["base_token"] != "bas123" || data["table_id"] != "tbl123" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+		hint, _ := data["hint"].(map[string]interface{})
+		if hint["next_step"] != nextStepRecordList {
+			t.Fatalf("unexpected hint: %#v", hint)
+		}
+		if _, ok := hint["fields"]; ok {
+			t.Fatalf("fields should be omitted when enrichment fails: %#v", hint)
+		}
+	})
+}
+
+func TestBaseURLResolveWikiURL(t *testing.T) {
+	t.Run("bitable", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "GET",
+			URL:    "/open-apis/wiki/v2/spaces/get_node?token=wik123",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"node": map[string]interface{}{
+						"obj_type":  "bitable",
+						"obj_token": "bas123",
+						"title":     "Demo Base",
+					},
+				},
+			},
+		})
+
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.larkoffice.com/wiki/wik123", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		if data["input_type"] != "wiki_url" || data["base_token"] != "bas123" || data["title"] != "Demo Base" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+	})
+
+	t.Run("non bitable", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(&httpmock.Stub{
+			Method: "GET",
+			URL:    "/open-apis/wiki/v2/spaces/get_node?token=wikdoc",
+			Body: map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"node": map[string]interface{}{"obj_type": "docx", "obj_token": "docx123"},
+				},
+			},
+		})
+
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.larkoffice.com/wiki/wikdoc", "--as", "user",
+		}, factory, stdout)
+		if err == nil || !strings.Contains(err.Error(), "not Base") {
+			t.Fatalf("err=%v, want non-Base validation error", err)
+		}
+	})
+}
+
+func TestBaseURLResolveRecordShareURL(t *testing.T) {
+	t.Run("enriched", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(recordShareMetaStub("shr123", "bas123", "tbl123", "rec123"))
+		reg.Register(recordBatchGetStub("bas123", "tbl123", "rec123"))
+		reg.Register(fieldListStub("bas123", "tbl123"))
+
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.larkoffice.com/record/shr123", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		if data["input_type"] != "record_share_url" || data["base_token"] != "bas123" || data["record_id"] != "rec123" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+		hint, _ := data["hint"].(map[string]interface{})
+		recordData, _ := hint["record_data"].(map[string]interface{})
+		fields, _ := hint["fields"].(map[string]interface{})
+		nextStep, _ := hint["next_step"].(string)
+		if !strings.Contains(nextStep, "+record-upsert --base-token bas123 --table-id tbl123 --record-id rec123") || recordData["fld_name"] != "Alice" || fields["total"] != float64(2) {
+			t.Fatalf("unexpected hint: %#v", hint)
+		}
+	})
+
+	t.Run("enrichment failure still returns meta", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(recordShareMetaStub("shr123", "bas123", "tbl123", "rec123"))
+
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.larkoffice.com/record/shr123", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		if data["input_type"] != "record_share_url" || data["base_token"] != "bas123" || data["record_id"] != "rec123" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+		hint, _ := data["hint"].(map[string]interface{})
+		nextStep, _ := hint["next_step"].(string)
+		if !strings.Contains(nextStep, "+record-upsert --base-token bas123 --table-id tbl123 --record-id rec123") {
+			t.Fatalf("unexpected hint: %#v", hint)
+		}
+		if _, ok := hint["record_data"]; ok {
+			t.Fatalf("record_data should be omitted when enrichment fails: %#v", hint)
+		}
+		if _, ok := hint["fields"]; ok {
+			t.Fatalf("fields should be omitted when enrichment fails: %#v", hint)
+		}
+	})
+}
+
+func recordShareMetaStub(shareToken, baseToken, tableID, recordID string) *httpmock.Stub {
+	return &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/base/v3/record_share/" + shareToken + "/meta",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"record_share_token": shareToken,
+				"base_token":         baseToken,
+				"table_id":           tableID,
+				"record_id":          recordID,
+			},
+		},
+	}
+}
+
+func TestBaseURLResolveFormShareURL(t *testing.T) {
+	factory, stdout, _ := newExecuteFactory(t)
+	err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+		"+url-resolve", "--query", "https://example.larkoffice.com/share/base/form/shrform", "--as", "user",
+	}, factory, stdout)
+	if err != nil {
+		t.Fatalf("err=%v", err)
+	}
+	data := decodeBaseEnvelope(t, stdout)
+	if data["input_type"] != "form_share_url" || data["share_token"] != "shrform" {
+		t.Fatalf("unexpected output: %#v", data)
+	}
+}
+
+func TestBaseURLResolveValidationErrors(t *testing.T) {
+	tests := []struct {
+		name     string
+		rawURL   string
+		wantText string
+		wantHint string
+	}{
+		{"dashboard share", "https://example.larkoffice.com/share/base/dashboard/shr1", "CLI does not support resolving Base dashboard share URLs", "provide the URL of the Base itself"},
+		{"view share", "https://example.larkoffice.com/share/base/view/shr1", "CLI does not support resolving Base view share URLs", "provide the URL of the Base itself"},
+		{"workspace", "https://example.larkoffice.com/base/workspace/ws1", "CLI does not support resolving Base workspace URLs", "provide the URL of the Base itself"},
+		{"add record", "https://example.larkoffice.com/base/add/addtoken", "CLI does not support resolving Base add-record URLs", "provide the URL of the Base itself"},
+		{"unrelated", "https://example.larkoffice.com/docx/doc1", "not a supported Base URL pattern", ""},
+		{"not url", "bas123", "only accepts full URLs", ""},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			factory, stdout, _ := newExecuteFactory(t)
+			err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+				"+url-resolve", "--url", tc.rawURL, "--as", "user",
+			}, factory, stdout)
+			if err == nil || !strings.Contains(err.Error(), tc.wantText) {
+				t.Fatalf("err=%v, want contains %q", err, tc.wantText)
+			}
+			p, ok := errs.ProblemOf(err)
+			if !ok || p.Hint == "" {
+				t.Fatalf("err=%v, want typed error with hint", err)
+			}
+			if tc.wantHint != "" && !strings.Contains(p.Hint, tc.wantHint) {
+				t.Fatalf("hint=%q, want contains %q", p.Hint, tc.wantHint)
+			}
+			if strings.Contains(p.Hint, "original /base/{base_token}") {
+				t.Fatalf("hint should not require original /base URL: %q", p.Hint)
+			}
+		})
+	}
+}
+
+func TestBaseResolveInputXOR(t *testing.T) {
+	t.Run("url resolve", func(t *testing.T) {
+		factory, stdout, _ := newExecuteFactory(t)
+		err := runShortcutWithAuthTypes(t, BaseURLResolve, authTypes(), []string{
+			"+url-resolve", "--url", "https://example.com/base/bas1", "--query", "https://example.com/base/bas2", "--as", "user",
+		}, factory, stdout)
+		if err == nil || !strings.Contains(err.Error(), "mutually exclusive") {
+			t.Fatalf("err=%v, want xor validation", err)
+		}
+	})
+
+	t.Run("title resolve", func(t *testing.T) {
+		factory, stdout, _ := newExecuteFactory(t)
+		err := runShortcutWithAuthTypes(t, BaseTitleResolve, nil, []string{
+			"+title-resolve", "--title", "Pipeline", "--query", "Sales", "--as", "user",
+		}, factory, stdout)
+		if err == nil || !strings.Contains(err.Error(), "mutually exclusive") {
+			t.Fatalf("err=%v, want xor validation", err)
+		}
+	})
+}
+
+func TestBaseResolveHelpFlags(t *testing.T) {
+	for _, tc := range []struct {
+		shortcut    string
+		definition  common.Shortcut
+		primaryFlag string
+		primaryDesc string
+		aliasFlags  []string
+	}{
+		{
+			shortcut:    "+url-resolve",
+			definition:  BaseURLResolve,
+			primaryFlag: "url",
+			primaryDesc: "Base/Wiki/record-share URL to resolve",
+			aliasFlags:  []string{"query"},
+		},
+		{
+			shortcut:    "+title-resolve",
+			definition:  BaseTitleResolve,
+			primaryFlag: "title",
+			primaryDesc: "Base title keyword",
+			aliasFlags:  []string{"query", "url"},
+		},
+	} {
+		t.Run(tc.shortcut, func(t *testing.T) {
+			parent := &cobra.Command{Use: "base"}
+			tc.definition.Mount(parent, &cmdutil.Factory{})
+			cmd := parent.Commands()[0]
+			primary := cmd.Flags().Lookup(tc.primaryFlag)
+			primaryUsage := ""
+			if primary != nil {
+				primaryUsage = primary.Usage
+			}
+			if primary == nil || !strings.Contains(primaryUsage, tc.primaryDesc) {
+				t.Fatalf("primary flag %q usage=%q", tc.primaryFlag, primaryUsage)
+			}
+			for _, aliasFlag := range tc.aliasFlags {
+				alias := cmd.Flags().Lookup(aliasFlag)
+				if alias == nil || !alias.Hidden {
+					t.Fatalf("alias flag %q should exist and be hidden: %#v", aliasFlag, alias)
+				}
+			}
+		})
+	}
+}
+
+func TestBaseTitleResolve(t *testing.T) {
+	t.Run("single result", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(titleResolveSearchStub([]interface{}{
+			map[string]interface{}{
+				"title_highlighted": "Sales <h>Pipeline</h>",
+				"result_meta": map[string]interface{}{
+					"doc_types":       "BITABLE",
+					"token":           "bas123",
+					"url":             "https://example.larkoffice.com/base/bas123",
+					"owner_name":      "Alice",
+					"update_time_iso": "2026-06-09T10:00:00+08:00",
+				},
+			},
+		}))
+
+		err := runShortcutWithAuthTypes(t, BaseTitleResolve, nil, []string{
+			"+title-resolve", "--title", "Pipeline", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		if data["title"] != "Sales Pipeline" || data["base_token"] != "bas123" || data["owner_name"] != "Alice" {
+			t.Fatalf("unexpected output: %#v", data)
+		}
+	})
+
+	t.Run("multiple results and filter non bitable", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(titleResolveSearchStub([]interface{}{
+			map[string]interface{}{
+				"title_highlighted": "Doc hit",
+				"result_meta":       map[string]interface{}{"doc_types": "DOCX", "token": "docx123"},
+			},
+			map[string]interface{}{
+				"title_highlighted": "Base <h>One</h>",
+				"result_meta":       map[string]interface{}{"doc_types": "BITABLE", "token": "bas1", "url": "https://example/base/bas1"},
+			},
+			map[string]interface{}{
+				"title_highlighted": "Base <h>Two</h>",
+				"result_meta":       map[string]interface{}{"doc_types": "BITABLE", "token": "bas2", "url": "https://example/base/bas2"},
+			},
+		}))
+
+		err := runShortcutWithAuthTypes(t, BaseTitleResolve, nil, []string{
+			"+title-resolve", "--url", "Base", "--as", "user",
+		}, factory, stdout)
+		if err != nil {
+			t.Fatalf("err=%v", err)
+		}
+		data := decodeBaseEnvelope(t, stdout)
+		candidates, _ := data["candidates"].([]interface{})
+		if len(candidates) != 2 {
+			t.Fatalf("candidates=%#v, want 2", data["candidates"])
+		}
+	})
+
+	t.Run("no results", func(t *testing.T) {
+		factory, stdout, reg := newExecuteFactory(t)
+		reg.Register(titleResolveSearchStub(nil))
+		err := runShortcutWithAuthTypes(t, BaseTitleResolve, nil, []string{
+			"+title-resolve", "--title", "missing", "--as", "user",
+		}, factory, stdout)
+		if err == nil || !strings.Contains(err.Error(), "No Base matched") {
+			t.Fatalf("err=%v, want no result validation", err)
+		}
+	})
+
+	t.Run("query too long", func(t *testing.T) {
+		factory, stdout, _ := newExecuteFactory(t)
+		err := runShortcutWithAuthTypes(t, BaseTitleResolve, nil, []string{
+			"+title-resolve", "--title", "codex record share resolve 20260616152113", "--as", "user",
+		}, factory, stdout)
+		if err == nil || !strings.Contains(err.Error(), "30 characters or fewer") {
+			t.Fatalf("err=%v, want query length validation", err)
+		}
+	})
+}
+
+func titleResolveSearchStub(items []interface{}) *httpmock.Stub {
+	if items == nil {
+		items = []interface{}{}
+	}
+	return &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/search/v2/doc_wiki/search",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"res_units": items,
+			},
+		},
+	}
+}
+
+func fieldListStub(baseToken, tableID string) *httpmock.Stub {
+	return &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/base/v3/bases/" + baseToken + "/tables/" + tableID + "/fields",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"total": 2,
+				"fields": []interface{}{
+					map[string]interface{}{"field_id": "fld_name", "field_name": "Name", "type": "text"},
+					map[string]interface{}{"field_id": "fld_status", "field_name": "Status", "type": "singleSelect"},
+				},
+			},
+		},
+	}
+}
+
+func recordBatchGetStub(baseToken, tableID, recordID string) *httpmock.Stub {
+	return &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/base/v3/bases/" + baseToken + "/tables/" + tableID + "/records/batch_get",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"record_id_list": []interface{}{recordID},
+				"field_id_list":  []interface{}{"fld_name", "fld_status"},
+				"fields":         []interface{}{"Name", "Status"},
+				"data":           []interface{}{[]interface{}{"Alice", "Done"}},
+			},
+		},
+	}
+}

shortcuts/base/base_shortcuts_test.go

@@ -155,6 +155,7 @@ func TestViewSetVisibleFieldsValidateHook(t *testing.T) {
 func TestShortcutsCatalog(t *testing.T) {
 	shortcuts := Shortcuts()
 	want := []string{
+		"+url-resolve", "+title-resolve",
 		"+base-block-list", "+base-block-create", "+base-block-move", "+base-block-rename", "+base-block-delete",
 		"+table-list", "+table-get", "+table-create", "+table-update", "+table-delete",
 		"+field-list", "+field-get", "+field-create", "+field-update", "+field-delete", "+field-search-options",

shortcuts/base/shortcuts.go

@@ -8,6 +8,8 @@ import "github.com/larksuite/cli/shortcuts/common"
 // Shortcuts returns all base shortcuts.
 func Shortcuts() []common.Shortcut {
 	return []common.Shortcut{
+		BaseURLResolve,
+		BaseTitleResolve,
 		BaseBaseBlockList,
 		BaseBaseBlockCreate,
 		BaseBaseBlockMove,

shortcuts/common/drive_media_upload_typed_test.go

@@ -199,16 +199,7 @@ func TestParseDriveMediaMultipartUploadSessionTypedValidatesResponseFields(t *te
 			t.Parallel()
 
 			_, err := parseDriveMediaMultipartUploadSessionTyped(tt.data)
-			if err == nil || !strings.Contains(err.Error(), tt.wantText) {
-				t.Fatalf("err = %v, want substring %q", err, tt.wantText)
-			}
-			p, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("expected typed problem, got %T (%v)", err, err)
-			}
-			if p.Subtype != errs.SubtypeInvalidResponse {
-				t.Fatalf("subtype = %s, want invalid_response", p.Subtype)
-			}
+			requireProblem(t, err, errs.CategoryInternal, errs.SubtypeInvalidResponse, tt.wantText)
 		})
 	}
 }

shortcuts/common/mcp_client_test.go

@@ -142,9 +142,7 @@ func TestNormalizeMCPToolResult(t *testing.T) {
 
 			got, err := normalizeMCPToolResult(tt.raw)
 			if tt.wantErr != "" {
-				if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
-					t.Fatalf("expected error containing %q, got %v", tt.wantErr, err)
-				}
+				requireProblem(t, err, errs.CategoryAPI, errs.SubtypeUnknown, tt.wantErr)
 				return
 			}
 			if err != nil {

shortcuts/common/runner.go

@@ -49,6 +49,7 @@ type RuntimeContext struct {
 	apiClientFunc func() (*client.APIClient, error) // sync.OnceValues; initialized in newRuntimeContext
 	botInfoFunc   func() (*BotInfo, error)          // sync.OnceValues; lazy bot identity from /bot/v3/info
 	larkSDK       *lark.Client                      // eagerly initialized in mountDeclarative
+	stdinConsumed bool                              // set when an Input flag has consumed stdin (`-`); guards against a second flag also using `-` within the same call
 }
 
 // ── Identity ──
@@ -1029,7 +1030,6 @@ func stripUTF8BOM(s string) string {
 // resolveInputFlags resolves @file and - (stdin) for flags with Input sources.
 // Must be called before Validate/DryRun/Execute so that runtime.Str() returns resolved content.
 func resolveInputFlags(rctx *RuntimeContext, flags []Flag) error {
-	stdinUsed := false
 	for _, fl := range flags {
 		if len(fl.Input) == 0 {
 			continue
@@ -1049,11 +1049,14 @@ func resolveInputFlags(rctx *RuntimeContext, flags []Flag) error {
 				return ValidationErrorf("--%s does not support stdin (-)", fl.Name).
 					WithParam("--" + fl.Name)
 			}
-			if stdinUsed {
+			// A process has a single stdin, so we reject a second Input flag
+			// trying to use `-` after the first one has already consumed it.
+			if rctx.stdinConsumed {
 				return ValidationErrorf("--%s: stdin (-) can only be used by one flag", fl.Name).
-					WithParam("--" + fl.Name)
+					WithParam("--"+fl.Name).
+					WithHint("a process has a single stdin, so only one flag per call may use '-'; pass the others as @file (e.g. --%s @/path/to/file)", fl.Name)
 			}
-			stdinUsed = true
+			rctx.stdinConsumed = true
 			data, err := io.ReadAll(rctx.IO().In)
 			if err != nil {
 				return ValidationErrorf("--%s: failed to read from stdin: %v", fl.Name, err).
@@ -1166,7 +1169,13 @@ func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f
 				hints = append(hints, "@file")
 			}
 			if slices.Contains(fl.Input, Stdin) {
-				hints = append(hints, "- for stdin")
+				// "- reads stdin" intentionally avoids implying each flag has
+				// its own stdin: a process has a single stdin, so at most one
+				// flag per call may use "-" (the rest must use @file). The old
+				// per-flag "- for stdin" wording led AI agents to write
+				// `--a - <x --b - <y`, where the second `<` silently clobbers
+				// the first and `--a` reads the wrong payload.
+				hints = append(hints, "- reads stdin (one flag per call; use @file for others)")
 			}
 			desc += " (supports " + strings.Join(hints, ", ") + ")"
 		}

shortcuts/common/runner_args_test.go

@@ -22,6 +22,7 @@ func TestRejectPositionalArgs_WithArgs(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for positional arg, got nil")
 	}
+	// rejectPositionalArgs returns a raw fmt.Errorf via cobra's PositionalArgs contract — not a typed envelope, message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "positional arguments are not supported") {
 		t.Errorf("expected positional args rejection message, got: %v", err)
 	}
@@ -39,6 +40,7 @@ func TestRejectPositionalArgs_MultipleArgs(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for multiple positional args, got nil")
 	}
+	// rejectPositionalArgs returns a raw fmt.Errorf via cobra's PositionalArgs contract — not a typed envelope, message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "positional arguments are not supported") {
 		t.Errorf("unexpected error message: %v", err)
 	}

shortcuts/common/runner_botinfo_test.go

@@ -171,6 +171,7 @@ func TestFetchBotInfo_APICodeNonZero(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for non-zero code")
 	}
+	// fetchBotInfo returns a raw fmt.Errorf, not a typed envelope — message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "[99991]") {
 		t.Errorf("error = %q, want substring [99991]", err.Error())
 	}
@@ -197,6 +198,7 @@ func TestFetchBotInfo_EmptyOpenID(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for empty open_id")
 	}
+	// fetchBotInfo returns a raw fmt.Errorf, not a typed envelope — message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "open_id is empty") {
 		t.Errorf("error = %q, want substring 'open_id is empty'", err.Error())
 	}
@@ -218,6 +220,7 @@ func TestFetchBotInfo_HTTP4xx(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for HTTP 403")
 	}
+	// fetchBotInfo returns a raw fmt.Errorf, not a typed envelope — message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "403") {
 		t.Errorf("error = %q, want substring '403'", err.Error())
 	}
@@ -238,7 +241,7 @@ func TestFetchBotInfo_InvalidJSON(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for invalid JSON")
 	}
-	// Error may come from SDK-level parse or our unmarshal wrapper
+	// Error may come from SDK-level parse or our unmarshal wrapper — both are raw fmt.Errorf, not a typed envelope.
 	if !strings.Contains(err.Error(), "unmarshal") && !strings.Contains(err.Error(), "invalid character") {
 		t.Errorf("error = %q, want JSON parse failure", err.Error())
 	}
@@ -279,6 +282,7 @@ func TestFetchBotInfo_CanBotFalse(t *testing.T) {
 	if info != nil {
 		t.Errorf("expected nil info, got %+v", info)
 	}
+	// fetchBotInfo returns a raw fmt.Errorf, not a typed envelope — message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "not available") {
 		t.Errorf("error = %q, want substring 'not available'", err.Error())
 	}
@@ -291,6 +295,7 @@ func TestBotInfo_NilFunc(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for nil botInfoFunc")
 	}
+	// BotInfo() returns a raw fmt.Errorf when botInfoFunc is nil, not a typed envelope — message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "not fully initialized") {
 		t.Errorf("unexpected error: %v", err)
 	}

shortcuts/common/runner_input_test.go

@@ -129,9 +129,9 @@ func TestResolveInputFlags_StdinNotSupported(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for stdin not supported")
 	}
-	assertValidationParam(t, err, "--data")
-	if !strings.Contains(err.Error(), "does not support stdin") {
-		t.Errorf("unexpected error: %v", err)
+	vErr := assertValidationParam(t, err, "--data")
+	if !strings.Contains(vErr.Message, "does not support stdin") {
+		t.Errorf("unexpected error message: %q", vErr.Message)
 	}
 }
 
@@ -143,9 +143,9 @@ func TestResolveInputFlags_FileNotSupported(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for file not supported")
 	}
-	assertValidationParam(t, err, "--data")
-	if !strings.Contains(err.Error(), "does not support file input") {
-		t.Errorf("unexpected error: %v", err)
+	vErr := assertValidationParam(t, err, "--data")
+	if !strings.Contains(vErr.Message, "does not support file input") {
+		t.Errorf("unexpected error message: %q", vErr.Message)
 	}
 }
 
@@ -160,9 +160,9 @@ func TestResolveInputFlags_FileNotFound(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for missing file")
 	}
-	assertValidationParam(t, err, "--markdown")
-	if !strings.Contains(err.Error(), "cannot read file") {
-		t.Errorf("unexpected error: %v", err)
+	vErr := assertValidationParam(t, err, "--markdown")
+	if !strings.Contains(vErr.Message, "cannot read file") {
+		t.Errorf("unexpected error message: %q", vErr.Message)
 	}
 }
 
@@ -174,9 +174,9 @@ func TestResolveInputFlags_EmptyFilePath(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for empty file path")
 	}
-	assertValidationParam(t, err, "--markdown")
-	if !strings.Contains(err.Error(), "file path cannot be empty after @") {
-		t.Errorf("unexpected error: %v", err)
+	vErr := assertValidationParam(t, err, "--markdown")
+	if !strings.Contains(vErr.Message, "file path cannot be empty after @") {
+		t.Errorf("unexpected error message: %q", vErr.Message)
 	}
 }
 
@@ -216,9 +216,14 @@ func TestResolveInputFlags_DuplicateStdin(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for duplicate stdin usage")
 	}
-	assertValidationParam(t, err, "--b")
-	if !strings.Contains(err.Error(), "stdin (-) can only be used by one flag") {
-		t.Errorf("unexpected error: %v", err)
+	vErr := assertValidationParam(t, err, "--b")
+	if !strings.Contains(vErr.Message, "stdin (-) can only be used by one flag") {
+		t.Errorf("unexpected error message: %q", vErr.Message)
+	}
+	// The hint must steer an AI agent to the fix (@file for the extra flags),
+	// since `--a - <x --b - <y` is the exact misuse this guards against.
+	if !strings.Contains(vErr.Hint, "@file") {
+		t.Errorf("hint %q should mention @file as the fix", vErr.Hint)
 	}
 }
 

shortcuts/common/runner_jq_test.go

@@ -186,9 +186,7 @@ func TestRunShortcut_JqAndFormatConflict(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for --jq + --format table conflict")
 	}
-	if !strings.Contains(err.Error(), "mutually exclusive") {
-		t.Errorf("expected 'mutually exclusive' error, got: %v", err)
-	}
+	requireValidation(t, err, "mutually exclusive")
 }
 
 func TestRunShortcut_JqInvalidExpression(t *testing.T) {
@@ -208,9 +206,7 @@ func TestRunShortcut_JqInvalidExpression(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for invalid jq expression")
 	}
-	if !strings.Contains(err.Error(), "invalid jq expression") {
-		t.Errorf("expected 'invalid jq expression' error, got: %v", err)
-	}
+	requireValidation(t, err, "invalid jq expression")
 }
 
 func TestRunShortcut_JqRuntimeError_PropagatesError(t *testing.T) {

shortcuts/common/typed_error_assertions_test.go

@@ -0,0 +1,50 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package common
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+)
+
+// requireProblem asserts err carries a typed errs.Problem with the given
+// category and (optional) subtype, and that its message contains msgContains
+// (skip the message check by passing ""). Returns the Problem so callers can
+// drill into the typed envelope's category-specific fields (e.g. cast to
+// *errs.ValidationError to read .Param / .Params / .Cause).
+func requireProblem(t *testing.T, err error, wantCategory errs.Category, wantSubtype errs.Subtype, msgContains string) *errs.Problem {
+	t.Helper()
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error carrying errs.Problem, got %T: %v", err, err)
+	}
+	if p.Category != wantCategory {
+		t.Errorf("category = %q, want %q (err=%v)", p.Category, wantCategory, err)
+	}
+	if wantSubtype != "" && p.Subtype != wantSubtype {
+		t.Errorf("subtype = %q, want %q (err=%v)", p.Subtype, wantSubtype, err)
+	}
+	if msgContains != "" && !strings.Contains(p.Message, msgContains) {
+		t.Errorf("message = %q, want containing %q", p.Message, msgContains)
+	}
+	return p
+}
+
+// requireValidation is shorthand for CategoryValidation + SubtypeInvalidArgument.
+// Returns *errs.ValidationError so callers can also assert on .Param / .Params / .Cause.
+func requireValidation(t *testing.T, err error, msgContains string) *errs.ValidationError {
+	t.Helper()
+	requireProblem(t, err, errs.CategoryValidation, errs.SubtypeInvalidArgument, msgContains)
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
+	}
+	return ve
+}

shortcuts/doc/doc_resource_cover.go

@@ -55,7 +55,7 @@ var docCoverAllowedContentTypes = map[string]string{
 
 var DocResourceDownload = common.Shortcut{
 	Service:     "docs",
-	Command:     "resource-download",
+	Command:     "+resource-download",
 	Description: "Download a document resource (type=cover downloads the cover image content)",
 	Risk:        "read",
 	Scopes:      []string{"docx:document:readonly", "docs:document.media:download"},
@@ -154,7 +154,7 @@ var DocResourceDownload = common.Shortcut{
 
 var DocResourceUpdate = common.Shortcut{
 	Service:     "docs",
-	Command:     "resource-update",
+	Command:     "+resource-update",
 	Description: "Upload and update a document resource (type=cover)",
 	Risk:        "write",
 	Scopes:      []string{"docx:document:readonly", "docx:document:write_only", "docs:document.media:upload"},
@@ -256,7 +256,7 @@ var DocResourceUpdate = common.Shortcut{
 
 var DocResourceDelete = common.Shortcut{
 	Service:     "docs",
-	Command:     "resource-delete",
+	Command:     "+resource-delete",
 	Description: "Delete a document resource (type=cover is idempotent when empty)",
 	Risk:        "write",
 	Scopes:      []string{"docx:document:readonly", "docx:document:write_only"},

shortcuts/doc/doc_resource_cover_test.go

@@ -48,7 +48,7 @@ func TestDocResourceDownloadCoverDownloadsImageContent(t *testing.T) {
 	withDocsWorkingDir(t, tmpDir)
 
 	err := mountAndRunDocs(t, DocResourceDownload, []string{
-		"resource-download",
+		"+resource-download",
 		"--doc", documentID,
 		"--type", "cover",
 		"--output", "cover",
@@ -95,7 +95,7 @@ func TestDocResourceDownloadCoverEmptyReturnsErrorWithoutDownload(t *testing.T)
 	withDocsWorkingDir(t, tmpDir)
 
 	err := mountAndRunDocs(t, DocResourceDownload, []string{
-		"resource-download",
+		"+resource-download",
 		"--doc", documentID,
 		"--type", "cover",
 		"--output", "cover.png",
@@ -116,7 +116,7 @@ func TestDocResourceDeleteCoverEmptyIsIdempotent(t *testing.T) {
 	reg.Register(docCoverMetadataStub(documentID, map[string]interface{}{}))
 
 	err := mountAndRunDocs(t, DocResourceDelete, []string{
-		"resource-delete",
+		"+resource-delete",
 		"--doc", documentID,
 		"--type", "cover",
 		"--as", "bot",
@@ -146,7 +146,7 @@ func TestDocResourceDeleteCoverClearsExistingCover(t *testing.T) {
 	reg.Register(patchStub)
 
 	err := mountAndRunDocs(t, DocResourceDelete, []string{
-		"resource-delete",
+		"+resource-delete",
 		"--doc", documentID,
 		"--type", "cover",
 		"--as", "bot",
@@ -195,7 +195,7 @@ func TestDocResourceUpdateCoverUploadsFileAndReturnsFullTokenOnlyOnStdout(t *tes
 	reg.Register(patchStub)
 
 	err := mountAndRunDocs(t, DocResourceUpdate, []string{
-		"resource-update",
+		"+resource-update",
 		"--doc", documentID,
 		"--type", "cover",
 		"--file", "cover.png",
@@ -241,7 +241,7 @@ func TestDocResourceUpdateCoverRejectsMultipleSources(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-cover-source-validation-app"))
 
 	err := mountAndRunDocs(t, DocResourceUpdate, []string{
-		"resource-update",
+		"+resource-update",
 		"--doc", "doxcnCoverValidate1",
 		"--type", "cover",
 		"--file", "cover.png",
@@ -258,7 +258,7 @@ func TestDocResourceUpdateCoverRejectsMissingSource(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-cover-source-required-app"))
 
 	err := mountAndRunDocs(t, DocResourceUpdate, []string{
-		"resource-update",
+		"+resource-update",
 		"--doc", "doxcnCoverValidateRequired1",
 		"--type", "cover",
 		"--as", "bot",
@@ -273,7 +273,7 @@ func TestDocResourceUpdateCoverRejectsUnsafeURLSource(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-cover-url-validation-app"))
 
 	err := mountAndRunDocs(t, DocResourceUpdate, []string{
-		"resource-update",
+		"+resource-update",
 		"--doc", "doxcnCoverURLValidate1",
 		"--type", "cover",
 		"--url", "https://127.0.0.1/cover.png",
@@ -617,7 +617,7 @@ func TestDocShortcutsIncludeCoverResourceCommands(t *testing.T) {
 	for _, shortcut := range Shortcuts() {
 		got[shortcut.Command] = true
 	}
-	for _, want := range []string{"resource-download", "resource-update", "resource-delete"} {
+	for _, want := range []string{"+resource-download", "+resource-update", "+resource-delete"} {
 		if !got[want] {
 			t.Fatalf("Shortcuts() missing %s", want)
 		}

shortcuts/doc/docs_fetch_im_markdown.go

@@ -0,0 +1,861 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package doc
+
+import (
+	"fmt"
+	"html"
+	"net/url"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+)
+
+type imMarkdownContext struct {
+	baseURL         string
+	blockquoteDepth int
+}
+
+type imMarkdownHandleFunc func(segment, inner string, attrs map[string]string, imCtx imMarkdownContext) string
+
+type imMarkdownTagHandler struct {
+	closeRE *regexp.Regexp
+	handle  imMarkdownHandleFunc
+}
+
+func registerIMMarkdownHandler(tag string, handle imMarkdownHandleFunc) {
+	imMarkdownHandlers[tag] = imMarkdownTagHandler{
+		closeRE: regexp.MustCompile(`(?is)<(/?)` + regexp.QuoteMeta(tag) + `(?:\s[^<>]*?)?\s*/?>`),
+		handle:  handle,
+	}
+}
+
+var (
+	imMarkdownTagStartRE  = regexp.MustCompile(`(?s)<([A-Za-z][A-Za-z0-9:_-]*)(?:\s[^<>]*?)?\s*/?>`)
+	imMarkdownAttrRE      = regexp.MustCompile(`([A-Za-z_:][A-Za-z0-9_:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')`)
+	imMarkdownRowTagRE    = regexp.MustCompile(`(?is)<(/?)tr\b[^>]*?\s*/?>`)
+	imMarkdownCellTagRE   = regexp.MustCompile(`(?is)<(/?)t[dh]\b[^>]*?\s*/?>`)
+	imMarkdownCellBreakRE = regexp.MustCompile(`(?i)<br\s*/?>`)
+	imMarkdownAnyTagRE    = regexp.MustCompile(`(?s)</?([A-Za-z][A-Za-z0-9:_-]*)(?:\s[^<>]*?)?>`)
+	imMarkdownLinkRE      = regexp.MustCompile(`(?is)<a\b[^>]*\bhref=(?:"([^"]*)"|'([^']*)')[^>]*>(.*?)</a>`)
+	imMarkdownCodeBlockRE = regexp.MustCompile(`(?is)^\s*<code(?:\s[^<>]*?)?>(.*?)</code>\s*$`)
+	imMarkdownLiOpenRE    = regexp.MustCompile(`(?is)<li(?:\s[^<>]*?)?>`)
+	imMarkdownLiCloseRE   = regexp.MustCompile(`(?is)<(/?)li(?:\s[^<>]*?)?\s*/?>`)
+)
+
+var imMarkdownHandlers = map[string]imMarkdownTagHandler{}
+
+func init() {
+	registerIMMarkdownHandler("title", handleIMMarkdownTitle)
+	for level := 1; level <= 9; level++ {
+		registerIMMarkdownHandler(fmt.Sprintf("h%d", level), handleIMMarkdownHeading(level))
+	}
+	registerIMMarkdownHandler("p", handleIMMarkdownParagraph)
+	registerIMMarkdownHandler("ul", handleIMMarkdownUnorderedList)
+	registerIMMarkdownHandler("ol", handleIMMarkdownOrderedList)
+	registerIMMarkdownHandler("li", handleIMMarkdownListItem)
+	registerIMMarkdownHandler("callout", handleIMMarkdownCallout)
+	registerIMMarkdownHandler("blockquote", handleIMMarkdownBlockquote)
+	registerIMMarkdownHandler("grid", handleIMMarkdownPassthroughContainer)
+	registerIMMarkdownHandler("column", handleIMMarkdownColumn)
+	registerIMMarkdownHandler("table", handleIMMarkdownTable)
+	registerIMMarkdownHandler("colgroup", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("col", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("pre", handleIMMarkdownPre)
+	registerIMMarkdownHandler("code", handleIMMarkdownCode)
+	registerIMMarkdownHandler("latex", handleIMMarkdownLatex)
+	registerIMMarkdownHandler("hr", handleIMMarkdownHorizontalRule)
+	registerIMMarkdownHandler("img", handleIMMarkdownImage)
+	registerIMMarkdownHandler("figure", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("source", handleIMMarkdownSource)
+	registerIMMarkdownHandler("button", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("time", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("whiteboard", handleIMMarkdownInlineCode)
+	registerIMMarkdownHandler("sheet", handleIMMarkdownSheet)
+	registerIMMarkdownHandler("task", handleIMMarkdownConditionalResourceLabel("任务", "task-id", "guid", "token", "id"))
+	registerIMMarkdownHandler("chat_card", handleIMMarkdownConditionalResourceLabel("群聊卡片", "chat-id", "chat_id", "id"))
+	registerIMMarkdownHandler("bitable", handleIMMarkdownResourceLabel("多维表格"))
+	registerIMMarkdownHandler("base_refer", handleIMMarkdownResourceLabel("多维表格"))
+	registerIMMarkdownHandler("okr", handleIMMarkdownResourceLabel("OKR"))
+	registerIMMarkdownHandler("poll", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("agenda", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("folder_manager", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("wiki_catalog", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("wiki_recent_update", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("chart_refer_host_perm", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("synced_reference", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("synced-source", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("mindnote", handleIMMarkdownDiscard)
+	registerIMMarkdownHandler("bookmark", handleIMMarkdownBookmark)
+	registerIMMarkdownHandler("cite", handleIMMarkdownCite)
+	registerIMMarkdownHandler("b", handleIMMarkdownStrong)
+	registerIMMarkdownHandler("em", handleIMMarkdownEmphasis)
+	registerIMMarkdownHandler("del", handleIMMarkdownDelete)
+	registerIMMarkdownHandler("u", handleIMMarkdownPlainInline)
+	registerIMMarkdownHandler("span", handleIMMarkdownPlainInline)
+	registerIMMarkdownHandler("a", handleIMMarkdownAnchor)
+}
+
+func isIMMarkdownFetch(runtime interface{ Str(string) string }) bool {
+	return strings.TrimSpace(runtime.Str("doc-format")) == "im-markdown"
+}
+
+func applyFetchIMMarkdown(data map[string]interface{}, docInput string) {
+	doc, ok := data["document"].(map[string]interface{})
+	if !ok {
+		return
+	}
+	content, ok := doc["content"].(string)
+	if !ok {
+		return
+	}
+	doc["content"] = convertToIMMarkdown(content, newIMMarkdownContext(docInput))
+}
+
+func newIMMarkdownContext(docInput string) imMarkdownContext {
+	base := "https://larkoffice.com"
+	raw := strings.TrimSpace(docInput)
+	if extracted, ok := imMarkdownBaseURLFromInput(raw); ok {
+		base = extracted
+	}
+	return imMarkdownContext{baseURL: base}
+}
+
+func (c imMarkdownContext) withBlockquote() imMarkdownContext {
+	c.blockquoteDepth++
+	return c
+}
+
+func (c imMarkdownContext) inBlockquote() bool {
+	return c.blockquoteDepth > 0
+}
+
+// imMarkdownBaseURLFromInput keeps the tenant host from --doc when it is a URL
+// so generated doc/sheet links point back to the same tenant. parseDocumentRef
+// intentionally strips host information, so it cannot serve this formatting path.
+func imMarkdownBaseURLFromInput(raw string) (string, bool) {
+	if raw == "" {
+		return "", false
+	}
+	if u, err := url.Parse(raw); err == nil && u.Scheme != "" && u.Host != "" {
+		return u.Scheme + "://" + u.Host, true
+	}
+	for _, marker := range []string{"/docx/", "/wiki/", "/doc/"} {
+		idx := strings.Index(raw, marker)
+		if idx <= 0 {
+			continue
+		}
+		candidate := strings.Trim(raw[:idx], "/")
+		if candidate == "" {
+			continue
+		}
+		if u, err := url.Parse(candidate); err == nil && u.Scheme != "" && u.Host != "" {
+			return u.Scheme + "://" + u.Host, true
+		}
+		if u, err := url.Parse("https://" + candidate); err == nil && u.Host != "" && strings.Contains(u.Host, ".") {
+			return "https://" + u.Host, true
+		}
+	}
+	return "", false
+}
+
+func convertToIMMarkdown(content string, imCtx imMarkdownContext) string {
+	var out strings.Builder
+	for offset := 0; offset < len(content); {
+		// Scan only to the next XML-like opening tag. Plain Markdown text between
+		// registered tags is copied unchanged, so ordinary Markdown is not re-parsed.
+		loc := imMarkdownTagStartRE.FindStringSubmatchIndex(content[offset:])
+		if loc == nil {
+			out.WriteString(content[offset:])
+			break
+		}
+		start := offset + loc[0]
+		openEnd := offset + loc[1]
+		tag := strings.ToLower(content[offset+loc[2] : offset+loc[3]])
+		handler, ok := imMarkdownHandlers[tag]
+		if !ok {
+			// Unknown tags are left intact. im-markdown only downgrades tags with
+			// explicit handlers so future server output does not get guessed at.
+			out.WriteString(content[offset:openEnd])
+			offset = openEnd
+			continue
+		}
+
+		out.WriteString(content[offset:start])
+		opening := content[start:openEnd]
+		attrs := parseIMMarkdownAttrs(opening)
+		if isSelfClosingIMMarkdownTag(opening) {
+			out.WriteString(handler.handle(opening, "", attrs, imCtx))
+			offset = openEnd
+			continue
+		}
+
+		// Use the handler's precompiled close regexp to find the matching end tag.
+		// Depth tracking keeps nested same-name containers paired correctly.
+		closeStart, closeEnd, found := findIMMarkdownClosingTag(content, openEnd, handler)
+		if !found {
+			// Malformed or truncated fragments are preserved as-is from the opening
+			// tag onward; do not drop content when the XML-ish structure is incomplete.
+			out.WriteString(content[start:])
+			break
+		}
+		segment := content[start:closeEnd]
+		inner := content[openEnd:closeStart]
+		out.WriteString(handler.handle(segment, inner, attrs, imCtx))
+		offset = closeEnd
+	}
+	return out.String()
+}
+
+func findIMMarkdownClosingTag(content string, from int, handler imMarkdownTagHandler) (int, int, bool) {
+	depth := 1
+	for _, loc := range handler.closeRE.FindAllStringSubmatchIndex(content[from:], -1) {
+		start := from + loc[0]
+		end := from + loc[1]
+		token := content[start:end]
+		if loc[2] >= 0 && content[from+loc[2]:from+loc[3]] == "/" {
+			depth--
+			if depth == 0 {
+				return start, end, true
+			}
+			continue
+		}
+		if !isSelfClosingIMMarkdownTag(token) {
+			depth++
+		}
+	}
+	return 0, 0, false
+}
+
+func parseIMMarkdownAttrs(opening string) map[string]string {
+	attrs := map[string]string{}
+	for _, match := range imMarkdownAttrRE.FindAllStringSubmatch(opening, -1) {
+		value := match[2]
+		if value == "" {
+			value = match[3]
+		}
+		attrs[strings.ToLower(match[1])] = html.UnescapeString(value)
+	}
+	return attrs
+}
+
+func isSelfClosingIMMarkdownTag(tag string) bool {
+	return strings.HasSuffix(strings.TrimSpace(tag), "/>")
+}
+
+func handleIMMarkdownTitle(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	text := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if text == "" {
+		return ""
+	}
+	return "# " + text
+}
+
+func handleIMMarkdownHeading(level int) imMarkdownHandleFunc {
+	return func(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+		text := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+		if text == "" {
+			return ""
+		}
+		markdownLevel := level
+		if markdownLevel > 6 {
+			markdownLevel = 6
+		}
+		return strings.Repeat("#", markdownLevel) + " " + text
+	}
+}
+
+func handleIMMarkdownParagraph(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if body == "" {
+		return ""
+	}
+	if imCtx.inBlockquote() {
+		return body + "\n"
+	}
+	return body
+}
+
+func handleIMMarkdownUnorderedList(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	return convertIMMarkdownListItems(inner, false, imCtx)
+}
+
+func handleIMMarkdownOrderedList(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	return convertIMMarkdownListItems(inner, true, imCtx)
+}
+
+func handleIMMarkdownListItem(_ string, inner string, attrs map[string]string, imCtx imMarkdownContext) string {
+	prefix := "-"
+	if seq := strings.TrimSpace(attrs["seq"]); seq != "" && seq != "auto" {
+		prefix = strings.TrimSuffix(seq, ".") + "."
+	}
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if body == "" {
+		return ""
+	}
+	return prefix + " " + indentIMMarkdownListContinuation(body) + "\n"
+}
+
+func handleIMMarkdownCallout(_ string, inner string, attrs map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	emoji := strings.TrimSpace(attrs["emoji"])
+	if emoji != "" {
+		if body == "" {
+			body = emoji
+		} else {
+			body = emoji + " " + body
+		}
+	}
+	if body == "" {
+		return "---\n---"
+	}
+	return fmt.Sprintf("---\n%s\n---", body)
+}
+
+func handleIMMarkdownBlockquote(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx.withBlockquote()))
+	if body == "" {
+		return ""
+	}
+	lines := strings.Split(body, "\n")
+	for i, line := range lines {
+		if strings.TrimSpace(line) == "" {
+			lines[i] = ">"
+			continue
+		}
+		lines[i] = "> " + line
+	}
+	return strings.Join(lines, "\n")
+}
+
+func handleIMMarkdownPassthroughContainer(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	return strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+}
+
+func handleIMMarkdownColumn(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if body == "" {
+		return ""
+	}
+	return body + "\n"
+}
+
+func handleIMMarkdownDiscard(_ string, _ string, _ map[string]string, _ imMarkdownContext) string {
+	return ""
+}
+
+func handleIMMarkdownInlineCode(segment string, _ string, _ map[string]string, _ imMarkdownContext) string {
+	return imMarkdownInlineCode(segment)
+}
+
+func handleIMMarkdownPre(_ string, inner string, attrs map[string]string, _ imMarkdownContext) string {
+	lang := strings.TrimSpace(attrs["lang"])
+	code := strings.TrimSpace(inner)
+	if match := imMarkdownCodeBlockRE.FindStringSubmatch(code); match != nil {
+		code = match[1]
+	}
+	return imMarkdownFencedCode(html.UnescapeString(code), lang)
+}
+
+func handleIMMarkdownCode(_ string, inner string, _ map[string]string, _ imMarkdownContext) string {
+	return imMarkdownInlineCode(markdownPlainText(inner))
+}
+
+func handleIMMarkdownLatex(_ string, inner string, _ map[string]string, _ imMarkdownContext) string {
+	expr := strings.TrimSpace(markdownPlainText(inner))
+	if expr == "" {
+		return ""
+	}
+	return "$" + strings.ReplaceAll(expr, "$", `\$`) + "$"
+}
+
+func handleIMMarkdownHorizontalRule(_ string, _ string, _ map[string]string, _ imMarkdownContext) string {
+	return "---"
+}
+
+func handleIMMarkdownImage(_ string, _ string, attrs map[string]string, _ imMarkdownContext) string {
+	href := firstNonEmpty(attrs["href"], attrs["src"], attrs["url"])
+	if href == "" {
+		return ""
+	}
+	alt := firstNonEmpty(attrs["alt"], attrs["name"], attrs["title"])
+	return fmt.Sprintf("![%s](%s)", escapeMarkdownLinkText(alt), escapeMarkdownLinkDestination(href))
+}
+
+func handleIMMarkdownSource(_ string, _ string, attrs map[string]string, _ imMarkdownContext) string {
+	name := strings.TrimSpace(attrs["name"])
+	if name == "" {
+		return ""
+	}
+	return imMarkdownInlineCode(name)
+}
+
+func handleIMMarkdownResourceLabel(label string) imMarkdownHandleFunc {
+	return func(_ string, _ string, _ map[string]string, _ imMarkdownContext) string {
+		return imMarkdownInlineCode(label)
+	}
+}
+
+func handleIMMarkdownConditionalResourceLabel(label string, attrNames ...string) imMarkdownHandleFunc {
+	return func(_ string, _ string, attrs map[string]string, _ imMarkdownContext) string {
+		for _, attrName := range attrNames {
+			if strings.TrimSpace(attrs[attrName]) != "" {
+				return imMarkdownInlineCode(label)
+			}
+		}
+		return ""
+	}
+}
+
+func handleIMMarkdownSheet(segment string, _ string, attrs map[string]string, imCtx imMarkdownContext) string {
+	token := strings.TrimSpace(attrs["token"])
+	if token == "" {
+		return imMarkdownInlineCode(segment)
+	}
+	label := "sheet"
+	if sheetID := strings.TrimSpace(attrs["sheet-id"]); sheetID != "" {
+		label = "sheet " + sheetID
+	}
+	return markdownLink(label, strings.TrimRight(imCtx.baseURL, "/")+"/sheets/"+token)
+}
+
+func handleIMMarkdownBookmark(segment string, inner string, attrs map[string]string, imCtx imMarkdownContext) string {
+	href := strings.TrimSpace(attrs["href"])
+	name := firstNonEmpty(attrs["name"], attrs["title"], markdownLinkLabelText(convertToIMMarkdown(inner, imCtx)), href)
+	if href == "" {
+		return name
+	}
+	return markdownLink(name, href)
+}
+
+func handleIMMarkdownStrong(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if body == "" {
+		return ""
+	}
+	return "**" + body + "**"
+}
+
+func handleIMMarkdownEmphasis(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if body == "" {
+		return ""
+	}
+	return "*" + body + "*"
+}
+
+func handleIMMarkdownDelete(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	body := strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+	if body == "" {
+		return ""
+	}
+	return "~~" + body + "~~"
+}
+
+func handleIMMarkdownPlainInline(_ string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	return strings.TrimSpace(convertToIMMarkdown(inner, imCtx))
+}
+
+func handleIMMarkdownAnchor(_ string, inner string, attrs map[string]string, imCtx imMarkdownContext) string {
+	href := strings.TrimSpace(attrs["href"])
+	text := firstNonEmpty(markdownLinkLabelText(convertToIMMarkdown(inner, imCtx)), attrs["name"], attrs["title"], href)
+	if href == "" {
+		return text
+	}
+	return markdownLink(text, href)
+}
+
+func handleIMMarkdownCite(segment string, inner string, attrs map[string]string, imCtx imMarkdownContext) string {
+	switch strings.ToLower(strings.TrimSpace(attrs["type"])) {
+	case "user":
+		userID := firstNonEmpty(attrs["user-id"], attrs["open-id"], attrs["id"])
+		name := firstNonEmpty(attrs["user-name"], attrs["name"], markdownPlainText(inner), userID)
+		if userID == "" {
+			return name
+		}
+		return fmt.Sprintf(`<at user_id="%s">%s</at>`, html.EscapeString(userID), html.EscapeString(name))
+	case "doc":
+		title := firstNonEmpty(attrs["title"], attrs["name"], attrs["doc-id"], "document")
+		if href := firstNonEmpty(attrs["href"], attrs["url"]); href != "" {
+			return markdownLink(title, href)
+		}
+		docID := firstNonEmpty(attrs["doc-id"], attrs["token"])
+		if docID == "" {
+			return imMarkdownInlineCode(segment)
+		}
+		fileType := strings.Trim(strings.ToLower(firstNonEmpty(attrs["file-type"], "docx")), "/")
+		return markdownLink(title, strings.TrimRight(imCtx.baseURL, "/")+"/"+fileType+"/"+docID)
+	case "citation":
+		if text, href, ok := extractIMMarkdownInnerLink(inner); ok {
+			return markdownLink(text, href)
+		}
+		if href := firstNonEmpty(attrs["href"], attrs["url"]); href != "" {
+			return markdownLink(firstNonEmpty(attrs["title"], attrs["name"], href), href)
+		}
+		return markdownPlainText(convertToIMMarkdown(inner, imCtx))
+	default:
+		return imMarkdownInlineCode(segment)
+	}
+}
+
+func handleIMMarkdownTable(segment string, inner string, _ map[string]string, imCtx imMarkdownContext) string {
+	// Rows and cells are matched with tag-depth tracking instead of non-greedy
+	// regex captures. A table nested inside a cell can contain its own </tr> and
+	// </td>; treating those as the outer row/cell boundary corrupts the table.
+	rowBodies := extractIMMarkdownElementBodies(inner, imMarkdownRowTagRE)
+	if len(rowBodies) == 0 {
+		return imMarkdownInlineCode(segment)
+	}
+
+	rows := make([][]string, 0, len(rowBodies))
+	for _, rowBody := range rowBodies {
+		cellBodies := extractIMMarkdownElementBodies(rowBody, imMarkdownCellTagRE)
+		if len(cellBodies) == 0 {
+			continue
+		}
+		row := make([]string, 0, len(cellBodies))
+		for _, cellBody := range cellBodies {
+			row = append(row, normalizeIMMarkdownTableCell(convertToIMMarkdown(cellBody, imCtx)))
+		}
+		rows = append(rows, row)
+	}
+	if len(rows) == 0 {
+		return imMarkdownInlineCode(segment)
+	}
+
+	cols := 0
+	for _, row := range rows {
+		if len(row) > cols {
+			cols = len(row)
+		}
+	}
+	var out strings.Builder
+	writeIMMarkdownTableRow(&out, padIMMarkdownTableRow(rows[0], cols))
+	separator := make([]string, cols)
+	for i := range separator {
+		separator[i] = "-"
+	}
+	writeIMMarkdownTableRow(&out, separator)
+	for _, row := range rows[1:] {
+		writeIMMarkdownTableRow(&out, padIMMarkdownTableRow(row, cols))
+	}
+	return strings.TrimRight(out.String(), "\n")
+}
+
+// extractIMMarkdownElementBodies returns the inner content of each top-level
+// element matched by tagRE. tagRE must expose the optional closing slash as its
+// first capture group, matching the row/cell regexes above.
+func extractIMMarkdownElementBodies(content string, tagRE *regexp.Regexp) []string {
+	var bodies []string
+	for offset := 0; offset < len(content); {
+		loc := tagRE.FindStringSubmatchIndex(content[offset:])
+		if loc == nil {
+			break
+		}
+		openStart := offset + loc[0]
+		openEnd := offset + loc[1]
+		opening := content[openStart:openEnd]
+		if loc[2] >= 0 && content[offset+loc[2]:offset+loc[3]] == "/" {
+			offset = openEnd
+			continue
+		}
+		if isSelfClosingIMMarkdownTag(opening) {
+			bodies = append(bodies, "")
+			offset = openEnd
+			continue
+		}
+		closeStart, closeEnd, found := findIMMarkdownElementClosingTag(content, openEnd, tagRE)
+		if !found {
+			break
+		}
+		bodies = append(bodies, content[openEnd:closeStart])
+		offset = closeEnd
+	}
+	return bodies
+}
+
+func findIMMarkdownElementClosingTag(content string, from int, tagRE *regexp.Regexp) (int, int, bool) {
+	depth := 1
+	for _, loc := range tagRE.FindAllStringSubmatchIndex(content[from:], -1) {
+		start := from + loc[0]
+		end := from + loc[1]
+		token := content[start:end]
+		if loc[2] >= 0 && content[from+loc[2]:from+loc[3]] == "/" {
+			depth--
+			if depth == 0 {
+				return start, end, true
+			}
+			continue
+		}
+		if !isSelfClosingIMMarkdownTag(token) {
+			depth++
+		}
+	}
+	return 0, 0, false
+}
+
+func normalizeIMMarkdownTableCell(cell string) string {
+	const brPlaceholder = "\x00BR\x00"
+	cell = imMarkdownCellBreakRE.ReplaceAllString(cell, brPlaceholder)
+	cell = imMarkdownAnyTagRE.ReplaceAllStringFunc(cell, func(tag string) string {
+		name := strings.ToLower(strings.TrimPrefix(imMarkdownAnyTagRE.FindStringSubmatch(tag)[1], "/"))
+		if name == "at" {
+			return tag
+		}
+		return ""
+	})
+	cell = html.UnescapeString(cell)
+	cell = strings.ReplaceAll(cell, brPlaceholder, "<br>")
+	cell = strings.ReplaceAll(cell, "  \n", "<br>")
+	cell = strings.ReplaceAll(cell, "\n", "<br>")
+	cell = strings.ReplaceAll(cell, "|", `\|`)
+	lines := strings.Fields(cell)
+	if len(lines) == 0 {
+		return ""
+	}
+	return strings.Join(lines, " ")
+}
+
+func writeIMMarkdownTableRow(out *strings.Builder, row []string) {
+	out.WriteString("| ")
+	out.WriteString(strings.Join(row, " | "))
+	out.WriteString(" |\n")
+}
+
+func padIMMarkdownTableRow(row []string, cols int) []string {
+	if len(row) >= cols {
+		return row
+	}
+	padded := make([]string, cols)
+	copy(padded, row)
+	return padded
+}
+
+func convertIMMarkdownListItems(inner string, ordered bool, imCtx imMarkdownContext) string {
+	var out strings.Builder
+	for offset, index := 0, 1; offset < len(inner); {
+		loc := imMarkdownLiOpenRE.FindStringIndex(inner[offset:])
+		if loc == nil {
+			break
+		}
+		openStart := offset + loc[0]
+		openEnd := offset + loc[1]
+		opening := inner[openStart:openEnd]
+		closeStart, closeEnd, found := findIMMarkdownListItemClosingTag(inner, openEnd)
+		if !found {
+			break
+		}
+		body := strings.TrimSpace(convertToIMMarkdown(inner[openEnd:closeStart], imCtx))
+		if body != "" {
+			prefix := "-"
+			if ordered {
+				attrs := parseIMMarkdownAttrs(opening)
+				if seq := strings.TrimSpace(attrs["seq"]); seq != "" && seq != "auto" {
+					prefix = strings.TrimSuffix(seq, ".") + "."
+				} else {
+					prefix = fmt.Sprintf("%d.", index)
+				}
+				index++
+			}
+			out.WriteString(prefix)
+			out.WriteString(" ")
+			out.WriteString(indentIMMarkdownListContinuation(body))
+			out.WriteString("\n")
+		}
+		offset = closeEnd
+	}
+	return strings.TrimRight(out.String(), "\n")
+}
+
+func findIMMarkdownListItemClosingTag(content string, from int) (int, int, bool) {
+	depth := 1
+	for _, loc := range imMarkdownLiCloseRE.FindAllStringSubmatchIndex(content[from:], -1) {
+		start := from + loc[0]
+		end := from + loc[1]
+		token := content[start:end]
+		if loc[2] >= 0 && content[from+loc[2]:from+loc[3]] == "/" {
+			depth--
+			if depth == 0 {
+				return start, end, true
+			}
+			continue
+		}
+		if !isSelfClosingIMMarkdownTag(token) {
+			depth++
+		}
+	}
+	return 0, 0, false
+}
+
+func indentIMMarkdownListContinuation(body string) string {
+	return strings.ReplaceAll(body, "\n", "\n  ")
+}
+
+func extractIMMarkdownInnerLink(inner string) (string, string, bool) {
+	match := imMarkdownLinkRE.FindStringSubmatch(inner)
+	if match == nil {
+		return "", "", false
+	}
+	href := match[1]
+	if href == "" {
+		href = match[2]
+	}
+	text := strings.TrimSpace(markdownPlainText(match[3]))
+	if text == "" {
+		text = href
+	}
+	return text, html.UnescapeString(href), true
+}
+
+func markdownPlainText(s string) string {
+	s = imMarkdownCellBreakRE.ReplaceAllString(s, "\n")
+	s = imMarkdownAnyTagRE.ReplaceAllString(s, "")
+	return strings.TrimSpace(html.UnescapeString(s))
+}
+
+func markdownLinkLabelText(s string) string {
+	text := markdownPlainText(s)
+	if !strings.Contains(text, "---") {
+		return text
+	}
+	lines := strings.Split(text, "\n")
+	kept := lines[:0]
+	for _, line := range lines {
+		if strings.TrimSpace(line) == "---" {
+			continue
+		}
+		kept = append(kept, line)
+	}
+	return strings.TrimSpace(strings.Join(kept, "\n"))
+}
+
+func markdownLink(text, href string) string {
+	cleanHref := strings.TrimSpace(href)
+	return fmt.Sprintf("[%s](%s)", escapeMarkdownLinkText(firstNonEmpty(text, cleanHref)), escapeMarkdownLinkDestination(cleanHref))
+}
+
+func escapeMarkdownLinkText(text string) string {
+	text = strings.ReplaceAll(text, `\`, `\\`)
+	text = strings.ReplaceAll(text, `[`, `\[`)
+	text = strings.ReplaceAll(text, `]`, `\]`)
+	return text
+}
+
+func escapeMarkdownLinkDestination(href string) string {
+	// Lark/Feishu IM Markdown does not reliably parse raw spaces or parentheses
+	// inside (...). Keep URL delimiters like :/?#&= intact, but percent-encode
+	// characters that can terminate or split the Markdown link destination.
+	var out strings.Builder
+	out.Grow(len(href))
+	for i := 0; i < len(href); {
+		if href[i] == '%' {
+			if i+2 < len(href) && isHexDigit(href[i+1]) && isHexDigit(href[i+2]) {
+				out.WriteString(href[i : i+3])
+				i += 3
+			} else {
+				writePercentEncodedByte(&out, href[i])
+				i++
+			}
+			continue
+		}
+		if href[i] < utf8.RuneSelf {
+			if shouldPercentEncodeIMMarkdownURLByte(href[i]) {
+				writePercentEncodedByte(&out, href[i])
+			} else {
+				out.WriteByte(href[i])
+			}
+			i++
+			continue
+		}
+		r, size := utf8.DecodeRuneInString(href[i:])
+		if r == utf8.RuneError && size == 1 {
+			writePercentEncodedByte(&out, href[i])
+			i++
+			continue
+		}
+		for _, b := range []byte(href[i : i+size]) {
+			writePercentEncodedByte(&out, b)
+		}
+		i += size
+	}
+	return out.String()
+}
+
+func shouldPercentEncodeIMMarkdownURLByte(b byte) bool {
+	if b <= ' ' || b >= 0x7f {
+		return true
+	}
+	switch b {
+	case '(', ')', '<', '>', '"', '\\', '^', '`', '{', '|', '}':
+		return true
+	default:
+		return false
+	}
+}
+
+func writePercentEncodedByte(out *strings.Builder, b byte) {
+	const hex = "0123456789ABCDEF"
+	out.WriteByte('%')
+	out.WriteByte(hex[b>>4])
+	out.WriteByte(hex[b&0x0f])
+}
+
+func isHexDigit(b byte) bool {
+	return ('0' <= b && b <= '9') || ('a' <= b && b <= 'f') || ('A' <= b && b <= 'F')
+}
+
+func imMarkdownInlineCode(s string) string {
+	maxRun := 0
+	run := 0
+	for _, r := range s {
+		if r == '`' {
+			run++
+			if run > maxRun {
+				maxRun = run
+			}
+			continue
+		}
+		run = 0
+	}
+	fence := strings.Repeat("`", maxRun+1)
+	if strings.HasPrefix(s, "`") || strings.HasSuffix(s, "`") {
+		return fence + " " + s + " " + fence
+	}
+	return fence + s + fence
+}
+
+func imMarkdownFencedCode(code, lang string) string {
+	maxRun := 0
+	for _, line := range strings.Split(code, "\n") {
+		if run := leadingBacktickRun(line); run > maxRun {
+			maxRun = run
+		}
+	}
+	fenceLen := maxRun + 1
+	if fenceLen < 3 {
+		fenceLen = 3
+	}
+	fence := strings.Repeat("`", fenceLen)
+	return fence + strings.TrimSpace(lang) + "\n" + strings.Trim(code, "\n") + "\n" + fence
+}
+
+func leadingBacktickRun(s string) int {
+	run := 0
+	for _, r := range s {
+		if r != '`' {
+			break
+		}
+		run++
+	}
+	return run
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}

shortcuts/doc/docs_fetch_v2.go

@@ -17,7 +17,7 @@ import (
 // v2FetchFlags returns the flag definitions for the v2 (OpenAPI) fetch path.
 func v2FetchFlags() []common.Flag {
 	return []common.Flag{
-		{Name: "doc-format", Desc: "output content format; xml keeps DocxXML structure and optional block ids, markdown is plain export", Default: "xml", Enum: []string{"xml", "markdown"}},
+		{Name: "doc-format", Desc: "output content format; xml keeps DocxXML structure and optional block ids, markdown is plain export, im-markdown downgrades residual DocxXML fragments for IM messages", Default: "xml", Enum: []string{"xml", "markdown", "im-markdown"}},
 		{Name: "detail", Desc: "detail level; simple for reading, with-ids for block references, full for styles and edit metadata", Default: "simple", Enum: []string{"simple", "with-ids", "full"}},
 		{Name: "lang", Desc: "user cite display language, e.g. en-US, zh-CN, ja-JP"},
 		{Name: "revision-id", Desc: "document revision id; -1 means latest", Type: "int", Default: "-1"},
@@ -72,6 +72,9 @@ func executeFetchV2(_ context.Context, runtime *common.RuntimeContext) error {
 	if warning := addFetchDetailDowngradeWarning(runtime, data); warning != "" && runtime.Format == "pretty" {
 		fmt.Fprintf(runtime.IO().ErrOut, "warning: %s\n", warning)
 	}
+	if isIMMarkdownFetch(runtime) {
+		applyFetchIMMarkdown(data, runtime.Str("doc"))
+	}
 
 	runtime.OutFormatRaw(data, nil, func(w io.Writer) {
 		if doc, ok := data["document"].(map[string]interface{}); ok {
@@ -85,7 +88,7 @@ func executeFetchV2(_ context.Context, runtime *common.RuntimeContext) error {
 
 func buildFetchBody(runtime *common.RuntimeContext) map[string]interface{} {
 	body := map[string]interface{}{
-		"format": runtime.Str("doc-format"),
+		"format": effectiveFetchFormat(runtime),
 	}
 	if v := runtime.Int("revision-id"); v > 0 {
 		body["revision_id"] = v
@@ -122,6 +125,14 @@ func buildFetchBody(runtime *common.RuntimeContext) map[string]interface{} {
 	return body
 }
 
+func effectiveFetchFormat(runtime *common.RuntimeContext) string {
+	format := strings.TrimSpace(runtime.Str("doc-format"))
+	if format == "im-markdown" {
+		return "markdown"
+	}
+	return format
+}
+
 func resolveFetchLang(runtime *common.RuntimeContext) string {
 	if runtime.Changed("lang") {
 		return strings.TrimSpace(runtime.Str("lang"))

shortcuts/doc/docs_fetch_v2_test.go

@@ -6,9 +6,12 @@ package doc
 import (
 	"context"
 	"encoding/json"
+	"errors"
+	"reflect"
 	"strings"
 	"testing"
 
+	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/httpmock"
@@ -104,6 +107,369 @@ func TestBuildFetchBodyExplicitBlankLangOmitsLang(t *testing.T) {
 	}
 }
 
+func TestBuildFetchBodyIncludesRevisionAndFullDetail(t *testing.T) {
+	t.Parallel()
+
+	runtime := newFetchBodyTestRuntime(context.Background())
+	mustSetFetchFlag(t, runtime, "revision-id", "42")
+	mustSetFetchFlag(t, runtime, "detail", "full")
+
+	body := buildFetchBody(runtime)
+	if got := body["revision_id"]; got != 42 {
+		t.Fatalf("revision_id = %#v, want 42", got)
+	}
+	exportOption, _ := body["export_option"].(map[string]interface{})
+	want := map[string]interface{}{
+		"export_block_id":        true,
+		"export_style_attrs":     true,
+		"export_cite_extra_data": true,
+	}
+	if !reflect.DeepEqual(exportOption, want) {
+		t.Fatalf("export_option = %#v, want %#v", exportOption, want)
+	}
+}
+
+func TestBuildFetchBodyIncludesWithIDsDetail(t *testing.T) {
+	t.Parallel()
+
+	runtime := newFetchBodyTestRuntime(context.Background())
+	mustSetFetchFlag(t, runtime, "detail", "with-ids")
+
+	body := buildFetchBody(runtime)
+	exportOption, _ := body["export_option"].(map[string]interface{})
+	want := map[string]interface{}{
+		"export_block_id": true,
+	}
+	if !reflect.DeepEqual(exportOption, want) {
+		t.Fatalf("export_option = %#v, want %#v", exportOption, want)
+	}
+}
+
+func TestBuildFetchBodyIncludesReadOption(t *testing.T) {
+	t.Parallel()
+
+	runtime := newFetchBodyTestRuntime(context.Background())
+	mustSetFetchFlag(t, runtime, "scope", "section")
+	mustSetFetchFlag(t, runtime, "start-block-id", "blk_heading")
+
+	body := buildFetchBody(runtime)
+	want := map[string]interface{}{
+		"read_mode":      "section",
+		"start_block_id": "blk_heading",
+	}
+	if got := body["read_option"]; !reflect.DeepEqual(got, want) {
+		t.Fatalf("read_option = %#v, want %#v", got, want)
+	}
+}
+
+func TestBuildReadOptionModes(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		setFlags map[string]string
+		want     map[string]interface{}
+	}{
+		{
+			name: "full omits read option",
+			setFlags: map[string]string{
+				"scope": "full",
+			},
+			want: nil,
+		},
+		{
+			name: "outline with max depth",
+			setFlags: map[string]string{
+				"scope":     "outline",
+				"max-depth": "3",
+			},
+			want: map[string]interface{}{
+				"read_mode": "outline",
+				"max_depth": "3",
+			},
+		},
+		{
+			name: "range with block ids and context",
+			setFlags: map[string]string{
+				"scope":          "range",
+				"start-block-id": "blk_start",
+				"end-block-id":   "blk_end",
+				"context-before": "2",
+				"context-after":  "1",
+				"max-depth":      "0",
+			},
+			want: map[string]interface{}{
+				"read_mode":      "range",
+				"start_block_id": "blk_start",
+				"end_block_id":   "blk_end",
+				"context_before": "2",
+				"context_after":  "1",
+				"max_depth":      "0",
+			},
+		},
+		{
+			name: "keyword with query",
+			setFlags: map[string]string{
+				"scope":          "keyword",
+				"keyword":        "foo|bar",
+				"context-before": "1",
+			},
+			want: map[string]interface{}{
+				"read_mode":      "keyword",
+				"keyword":        "foo|bar",
+				"context_before": "1",
+			},
+		},
+		{
+			name: "section keeps unlimited depth omitted",
+			setFlags: map[string]string{
+				"scope":          "section",
+				"start-block-id": "blk_heading",
+				"max-depth":      "-1",
+			},
+			want: map[string]interface{}{
+				"read_mode":      "section",
+				"start_block_id": "blk_heading",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			runtime := newFetchBodyTestRuntime(context.Background())
+			for name, value := range tt.setFlags {
+				mustSetFetchFlag(t, runtime, name, value)
+			}
+
+			if got := buildReadOption(runtime); !reflect.DeepEqual(got, tt.want) {
+				t.Fatalf("buildReadOption() = %#v, want %#v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestValidateReadModeFlagsRejectsInvalidScopeOptions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		setFlags   map[string]string
+		wantParam  string
+		wantParams []string
+	}{
+		{
+			name: "negative context before",
+			setFlags: map[string]string{
+				"scope":          "range",
+				"start-block-id": "blk_start",
+				"context-before": "-1",
+			},
+			wantParam: "--context-before",
+		},
+		{
+			name: "negative context after",
+			setFlags: map[string]string{
+				"scope":          "range",
+				"start-block-id": "blk_start",
+				"context-after":  "-1",
+			},
+			wantParam: "--context-after",
+		},
+		{
+			name: "max depth below unlimited sentinel",
+			setFlags: map[string]string{
+				"scope":          "range",
+				"start-block-id": "blk_start",
+				"max-depth":      "-2",
+			},
+			wantParam: "--max-depth",
+		},
+		{
+			name: "range needs boundary",
+			setFlags: map[string]string{
+				"scope": "range",
+			},
+			wantParams: []string{
+				"--start-block-id",
+				"--end-block-id",
+			},
+		},
+		{
+			name: "keyword needs keyword",
+			setFlags: map[string]string{
+				"scope": "keyword",
+			},
+			wantParam: "--keyword",
+		},
+		{
+			name: "section needs start block",
+			setFlags: map[string]string{
+				"scope": "section",
+			},
+			wantParam: "--start-block-id",
+		},
+		{
+			name: "unknown scope",
+			setFlags: map[string]string{
+				"scope": "bad",
+			},
+			wantParam: "--scope",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			runtime := newFetchBodyTestRuntime(context.Background())
+			for name, value := range tt.setFlags {
+				mustSetFetchFlag(t, runtime, name, value)
+			}
+
+			err := validateReadModeFlags(runtime)
+			if err == nil {
+				t.Fatal("validateReadModeFlags() succeeded, want error")
+			}
+			assertValidationContract(t, err, errs.SubtypeInvalidArgument, tt.wantParam, tt.wantParams...)
+		})
+	}
+}
+
+func TestValidateReadModeFlagsAcceptsValidScopeOptions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		setFlags map[string]string
+	}{
+		{
+			name: "outline",
+			setFlags: map[string]string{
+				"scope": "outline",
+			},
+		},
+		{
+			name: "range with end block",
+			setFlags: map[string]string{
+				"scope":        "range",
+				"end-block-id": "blk_end",
+			},
+		},
+		{
+			name: "keyword with keyword",
+			setFlags: map[string]string{
+				"scope":   "keyword",
+				"keyword": "bug|缺陷",
+			},
+		},
+		{
+			name: "section with start block",
+			setFlags: map[string]string{
+				"scope":          "section",
+				"start-block-id": "blk_heading",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			runtime := newFetchBodyTestRuntime(context.Background())
+			for name, value := range tt.setFlags {
+				mustSetFetchFlag(t, runtime, name, value)
+			}
+
+			if err := validateReadModeFlags(runtime); err != nil {
+				t.Fatalf("validateReadModeFlags() error = %v", err)
+			}
+		})
+	}
+}
+
+func TestValidateFetchV2RejectsInvalidDocAndScope(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		setFlags  map[string]string
+		wantParam string
+	}{
+		{
+			name: "invalid doc",
+			setFlags: map[string]string{
+				"doc": "https://example.com/sheets/sht_token",
+			},
+			wantParam: "--doc",
+		},
+		{
+			name: "invalid scope",
+			setFlags: map[string]string{
+				"scope": "bad",
+			},
+			wantParam: "--scope",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			runtime := newFetchShortcutTestRuntime(t, "", tt.setFlags)
+			err := validateFetchV2(context.Background(), runtime)
+			if err == nil {
+				t.Fatal("validateFetchV2() succeeded, want error")
+			}
+			assertValidationContract(t, err, errs.SubtypeInvalidArgument, tt.wantParam)
+		})
+	}
+}
+
+func TestAddFetchDetailDowngradeWarningNoops(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		setFlags map[string]string
+	}{
+		{
+			name: "xml format",
+			setFlags: map[string]string{
+				"doc-format": "xml",
+				"detail":     "full",
+			},
+		},
+		{
+			name: "markdown simple detail",
+			setFlags: map[string]string{
+				"doc-format": "markdown",
+				"detail":     "simple",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			runtime := newFetchBodyTestRuntime(context.Background())
+			for name, value := range tt.setFlags {
+				mustSetFetchFlag(t, runtime, name, value)
+			}
+
+			data := map[string]interface{}{}
+			if got := addFetchDetailDowngradeWarning(runtime, data); got != "" {
+				t.Fatalf("warning = %q, want empty", got)
+			}
+			if _, ok := data["warnings"]; ok {
+				t.Fatalf("unexpected warnings: %#v", data["warnings"])
+			}
+		})
+	}
+}
+
 func TestDocsFetchDryRunDefaultsToV2Endpoint(t *testing.T) {
 	t.Parallel()
 
@@ -141,36 +507,54 @@ func TestDocsFetchAPIVersionV1StillUsesV2Endpoint(t *testing.T) {
 	}
 }
 
+func TestDocsFetchIMMarkdownRequestsMarkdownFromAPI(t *testing.T) {
+	t.Parallel()
+
+	runtime := newFetchShortcutTestRuntime(t, "", map[string]string{
+		"doc-format": "im-markdown",
+	})
+	if err := validateFetchV2(context.Background(), runtime); err != nil {
+		t.Fatalf("validateFetchV2() error = %v", err)
+	}
+
+	dry := decodeDocDryRun(t, DocsFetch.DryRun(context.Background(), runtime))
+	if got, want := dry.API[0].Body["format"], "markdown"; got != want {
+		t.Fatalf("dry-run format = %#v, want %q", got, want)
+	}
+}
+
 func TestDocsFetchMarkdownDetailDowngradesToSimple(t *testing.T) {
 	t.Parallel()
 
-	for _, detail := range []string{"with-ids", "full"} {
-		t.Run(detail, func(t *testing.T) {
-			t.Parallel()
+	for _, format := range []string{"markdown", "im-markdown"} {
+		for _, detail := range []string{"with-ids", "full"} {
+			t.Run(format+"/"+detail, func(t *testing.T) {
+				t.Parallel()
 
-			runtime := newFetchShortcutTestRuntime(t, "", map[string]string{
-				"doc-format": "markdown",
-				"detail":     detail,
+				runtime := newFetchShortcutTestRuntime(t, "", map[string]string{
+					"doc-format": format,
+					"detail":     detail,
+				})
+				if err := validateFetchV2(context.Background(), runtime); err != nil {
+					t.Fatalf("validateFetchV2() error = %v", err)
+				}
+
+				dry := decodeDocDryRun(t, DocsFetch.DryRun(context.Background(), runtime))
+				exportOption, _ := dry.API[0].Body["export_option"].(map[string]interface{})
+				if exportOption == nil {
+					t.Fatalf("missing export_option: %#v", dry.API[0].Body)
+				}
+				if got := exportOption["export_block_id"]; got != false {
+					t.Fatalf("export_block_id = %#v, want false after markdown detail downgrade", got)
+				}
+				if got := exportOption["export_style_attrs"]; got != false {
+					t.Fatalf("export_style_attrs = %#v, want false after markdown detail downgrade", got)
+				}
+				if got := exportOption["export_cite_extra_data"]; got != false {
+					t.Fatalf("export_cite_extra_data = %#v, want false after markdown detail downgrade", got)
+				}
 			})
-			if err := validateFetchV2(context.Background(), runtime); err != nil {
-				t.Fatalf("validateFetchV2() error = %v", err)
-			}
-
-			dry := decodeDocDryRun(t, DocsFetch.DryRun(context.Background(), runtime))
-			exportOption, _ := dry.API[0].Body["export_option"].(map[string]interface{})
-			if exportOption == nil {
-				t.Fatalf("missing export_option: %#v", dry.API[0].Body)
-			}
-			if got := exportOption["export_block_id"]; got != false {
-				t.Fatalf("export_block_id = %#v, want false after markdown detail downgrade", got)
-			}
-			if got := exportOption["export_style_attrs"]; got != false {
-				t.Fatalf("export_style_attrs = %#v, want false after markdown detail downgrade", got)
-			}
-			if got := exportOption["export_cite_extra_data"]; got != false {
-				t.Fatalf("export_cite_extra_data = %#v, want false after markdown detail downgrade", got)
-			}
-		})
+		}
 	}
 }
 
@@ -261,6 +645,107 @@ func TestDocsFetchMarkdownDetailDowngradeWarnsInPrettyOutput(t *testing.T) {
 	}
 }
 
+func TestDocsFetchV2ReturnsAPIError(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+
+	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-fetch-api-error"))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/docs_ai/v1/documents/doxcnFetchAPIError/fetch",
+		Body: map[string]interface{}{
+			"code": 999999,
+			"msg":  "fetch failed",
+		},
+	})
+
+	err := mountAndRunDocs(t, DocsFetch, []string{
+		"+fetch",
+		"--doc", "doxcnFetchAPIError",
+		"--as", "bot",
+	}, f, stdout)
+	if err == nil {
+		t.Fatal("mountAndRunDocs() succeeded, want API error")
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error type = %T, want *errs.APIError (%v)", err, err)
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("ProblemOf() ok = false for %T (%v)", err, err)
+	}
+	if p.Category != errs.CategoryAPI {
+		t.Errorf("category = %q, want %q", p.Category, errs.CategoryAPI)
+	}
+	if p.Subtype != errs.SubtypeUnknown {
+		t.Errorf("subtype = %q, want %q", p.Subtype, errs.SubtypeUnknown)
+	}
+	if p.Code != 999999 {
+		t.Errorf("code = %d, want 999999", p.Code)
+	}
+	if p.Message != "fetch failed" {
+		t.Errorf("message = %q, want %q", p.Message, "fetch failed")
+	}
+	if cause := errors.Unwrap(err); cause != nil {
+		t.Fatalf("unexpected wrapped cause for API response error: %T %v", cause, cause)
+	}
+}
+
+func TestDocsFetchIMMarkdownConvertsContentInJSONOutput(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+
+	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-fetch-im-markdown"))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/docs_ai/v1/documents/doxcnFetchIMMarkdown/fetch",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"document": map[string]interface{}{
+					"document_id": "doxcnFetchIMMarkdown",
+					"revision_id": float64(1),
+					"content": strings.Join([]string{
+						`<title>Doc Title</title>`,
+						`<callout emoji="💡">Read **this**.</callout>`,
+						`<bookmark name="Example" href="https://example.com"></bookmark>`,
+					}, "\n\n"),
+				},
+			},
+		},
+	})
+
+	err := mountAndRunDocs(t, DocsFetch, []string{
+		"+fetch",
+		"--doc", "doxcnFetchIMMarkdown",
+		"--doc-format", "im-markdown",
+		"--as", "bot",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	var envelope map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
+		t.Fatalf("decode output: %v\nraw=%s", err, stdout.String())
+	}
+	data, _ := envelope["data"].(map[string]interface{})
+	doc, _ := data["document"].(map[string]interface{})
+	content, _ := doc["content"].(string)
+	for _, want := range []string{
+		"# Doc Title",
+		"---\n💡 Read **this**.\n---",
+		"[Example](https://example.com)",
+	} {
+		if !strings.Contains(content, want) {
+			t.Fatalf("converted content missing %q:\n%s", want, content)
+		}
+	}
+	if strings.Contains(content, "<title>") || strings.Contains(content, "<callout") || strings.Contains(content, "<bookmark") {
+		t.Fatalf("converted content still contains downgraded XML tags:\n%s", content)
+	}
+}
+
 func TestDocsFetchRejectsLegacyFlags(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -291,6 +776,7 @@ func TestDocsFetchRejectsLegacyFlags(t *testing.T) {
 			if err == nil {
 				t.Fatal("expected v2-only validation error")
 			}
+			assertValidationContract(t, err, errs.SubtypeInvalidArgument, "--offset")
 			for _, want := range tt.want {
 				if !strings.Contains(err.Error(), want) {
 					t.Fatalf("error missing %q: %v", want, err)
@@ -316,6 +802,14 @@ func newFetchBodyTestRuntime(ctx context.Context) *common.RuntimeContext {
 	return common.TestNewRuntimeContextWithCtx(ctx, cmd, nil)
 }
 
+func mustSetFetchFlag(t *testing.T, runtime *common.RuntimeContext, name, value string) {
+	t.Helper()
+
+	if err := runtime.Cmd.Flags().Set(name, value); err != nil {
+		t.Fatalf("set %s: %v", name, err)
+	}
+}
+
 func newFetchShortcutTestRuntime(t *testing.T, apiVersion string, setFlags map[string]string) *common.RuntimeContext {
 	t.Helper()
 

shortcuts/drive/drive_export.go

@@ -5,6 +5,7 @@ package drive
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"strings"
@@ -15,6 +16,24 @@ import (
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
+// wrapExportContextErr converts a context cancellation / deadline error into a
+// typed errs.NetworkError so the cobra layer sees a typed envelope (with cause
+// preserved for errors.Is) instead of an untyped context.Canceled /
+// context.DeadlineExceeded escaping as a plain string. CR-flagged hole on the
+// poll loop: returning ctx.Err() directly bypassed the typed-error contract.
+func wrapExportContextErr(err error) error {
+	if err == nil {
+		return nil
+	}
+	subtype := errs.SubtypeNetworkTransport
+	msg := "drive +export polling cancelled: %s"
+	if errors.Is(err, context.DeadlineExceeded) {
+		subtype = errs.SubtypeNetworkTimeout
+		msg = "drive +export polling deadline exceeded: %s"
+	}
+	return errs.NewNetworkError(subtype, msg, err).WithCause(err)
+}
+
 // DriveExport exports Drive-native documents to local files and falls back to
 // a follow-up command when the async export task does not finish in time.
 var DriveExport = common.Shortcut{
@@ -40,236 +59,305 @@ var DriveExport = common.Shortcut{
 		{Name: "overwrite", Type: "bool", Desc: "overwrite existing output file"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		return validateDriveExportSpec(driveExportSpec{
-			Token:         runtime.Str("token"),
-			DocType:       runtime.Str("doc-type"),
-			FileExtension: runtime.Str("file-extension"),
-			SubID:         runtime.Str("sub-id"),
-			OnlySchema:    runtime.Bool("only-schema"),
-		})
+		return validateExport(exportParamsFromFlags(runtime))
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec := driveExportSpec{
-			Token:         runtime.Str("token"),
-			DocType:       runtime.Str("doc-type"),
-			FileExtension: runtime.Str("file-extension"),
-			SubID:         runtime.Str("sub-id"),
-			OnlySchema:    runtime.Bool("only-schema"),
-		}
-		// Markdown export is a special case: docx markdown comes from the V2
-		// docs_ai fetch API directly instead of the Drive export task API.
-		if spec.FileExtension == "markdown" {
-			apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
-			dr := common.NewDryRunAPI().
-				Desc("2-step orchestration: fetch docx markdown -> write local file").
-				POST(apiPath).
-				Body(map[string]interface{}{
-					"format": "markdown",
-				}).
-				Set("output_dir", runtime.Str("output-dir"))
-			if name := strings.TrimSpace(runtime.Str("file-name")); name != "" {
-				dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
-			}
-			return dr
-		}
+		return PlanExportDryRun(runtime, exportParamsFromFlags(runtime))
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		return RunExport(ctx, runtime, exportParamsFromFlags(runtime))
+	},
+}
 
-		body := map[string]interface{}{
-			"token":          spec.Token,
-			"type":           spec.DocType,
-			"file_extension": spec.FileExtension,
-		}
-		if strings.TrimSpace(spec.SubID) != "" {
-			body["sub_id"] = spec.SubID
-		}
-		if spec.OnlySchema {
-			body["only_schema"] = true
-		}
+// ExportParams holds the user-facing inputs for an export flow, decoupled from
+// cobra flags so other command groups (e.g. sheets +workbook-export) can reuse
+// the drive export implementation. An empty OutputDir means "create the export
+// task and poll, but do not download" — callers that only need the ready file
+// token / status get it back without writing a local file.
+type ExportParams struct {
+	Token         string
+	DocType       string
+	FileExtension string
+	SubID         string
+	OnlySchema    bool
+	OutputDir     string
+	FileName      string
+	Overwrite     bool
+}
 
+func (p ExportParams) spec() driveExportSpec {
+	return driveExportSpec{
+		Token:         p.Token,
+		DocType:       p.DocType,
+		FileExtension: p.FileExtension,
+		SubID:         p.SubID,
+		OnlySchema:    p.OnlySchema,
+	}
+}
+
+// exportParamsFromFlags reads the standard drive +export flag set.
+func exportParamsFromFlags(runtime *common.RuntimeContext) ExportParams {
+	// drive +export always downloads; an empty --output-dir historically means
+	// the current directory (saveContentToOutputDir maps "" -> "."), so normalize
+	// it here to keep behavior identical and stay off the export-only ("" => skip
+	// download) path that only sheets +workbook-export uses.
+	outputDir := runtime.Str("output-dir")
+	if outputDir == "" {
+		outputDir = "."
+	}
+	return ExportParams{
+		Token:         runtime.Str("token"),
+		DocType:       runtime.Str("doc-type"),
+		FileExtension: runtime.Str("file-extension"),
+		SubID:         runtime.Str("sub-id"),
+		OnlySchema:    runtime.Bool("only-schema"),
+		OutputDir:     outputDir,
+		FileName:      strings.TrimSpace(runtime.Str("file-name")),
+		Overwrite:     runtime.Bool("overwrite"),
+	}
+}
+
+// validateExport runs the CLI-level export constraint checks. Unexported because
+// only drive +export's Validate consumes it directly; sheets +workbook-export
+// reuses RunExport / PlanExportDryRun but inlines its own (sheet-specific)
+// validation, so there is no cross-package call site to keep exported.
+func validateExport(p ExportParams) error {
+	return validateDriveExportSpec(p.spec())
+}
+
+// PlanExportDryRun builds the dry-run plan for an export without performing I/O.
+func PlanExportDryRun(runtime *common.RuntimeContext, p ExportParams) *common.DryRunAPI {
+	spec := p.spec()
+	// Markdown export is a special case: docx markdown comes from the V2
+	// docs_ai fetch API directly instead of the Drive export task API.
+	if spec.FileExtension == "markdown" {
+		apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
 		dr := common.NewDryRunAPI().
-			Desc("3-step orchestration: create export task -> limited polling -> download file").
-			POST("/open-apis/drive/v1/export_tasks").
-			Body(body).
-			Set("output_dir", runtime.Str("output-dir"))
-		if name := strings.TrimSpace(runtime.Str("file-name")); name != "" {
+			Desc("2-step orchestration: fetch docx markdown -> write local file").
+			POST(apiPath).
+			Body(map[string]interface{}{
+				"format": "markdown",
+			}).
+			Set("output_dir", p.OutputDir)
+		if name := strings.TrimSpace(p.FileName); name != "" {
 			dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
 		}
 		return dr
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec := driveExportSpec{
-			Token:         runtime.Str("token"),
-			DocType:       runtime.Str("doc-type"),
-			FileExtension: runtime.Str("file-extension"),
-			SubID:         runtime.Str("sub-id"),
-			OnlySchema:    runtime.Bool("only-schema"),
+	}
+
+	body := map[string]interface{}{
+		"token":          spec.Token,
+		"type":           spec.DocType,
+		"file_extension": spec.FileExtension,
+	}
+	if strings.TrimSpace(spec.SubID) != "" {
+		body["sub_id"] = spec.SubID
+	}
+	if spec.OnlySchema {
+		body["only_schema"] = true
+	}
+
+	dr := common.NewDryRunAPI().
+		Desc("3-step orchestration: create export task -> limited polling -> download file").
+		POST("/open-apis/drive/v1/export_tasks").
+		Body(body).
+		Set("output_dir", p.OutputDir)
+	if name := strings.TrimSpace(p.FileName); name != "" {
+		dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
+	}
+	return dr
+}
+
+// RunExport drives create export task -> bounded poll -> optional download. It
+// is the shared core behind both drive +export and sheets +workbook-export. An
+// empty p.OutputDir skips the download step and returns the ready file token.
+func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportParams) error {
+	spec := p.spec()
+	outputDir := p.OutputDir
+	preferredFileName := strings.TrimSpace(p.FileName)
+	overwrite := p.Overwrite
+
+	// Markdown export bypasses the async export task and writes the fetched
+	// markdown content directly to disk. Uses the V2 docs_ai fetch API for
+	// higher-quality Lark-flavored Markdown output.
+	if spec.FileExtension == "markdown" {
+		fmt.Fprintf(runtime.IO().ErrOut, "Exporting docx as markdown: %s\n", common.MaskToken(spec.Token))
+		apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
+		data, err := runtime.CallAPITyped(
+			"POST",
+			apiPath,
+			nil,
+			map[string]interface{}{
+				"format": "markdown",
+			},
+		)
+		if err != nil {
+			return err
 		}
-		outputDir := runtime.Str("output-dir")
-		preferredFileName := strings.TrimSpace(runtime.Str("file-name"))
-		overwrite := runtime.Bool("overwrite")
 
-		// Markdown export bypasses the async export task and writes the fetched
-		// markdown content directly to disk. Uses the V2 docs_ai fetch API for
-		// higher-quality Lark-flavored Markdown output.
-		if spec.FileExtension == "markdown" {
-			fmt.Fprintf(runtime.IO().ErrOut, "Exporting docx as markdown: %s\n", common.MaskToken(spec.Token))
-			apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
-			data, err := runtime.CallAPITyped(
-				"POST",
-				apiPath,
-				nil,
-				map[string]interface{}{
-					"format": "markdown",
-				},
-			)
+		// Extract content from the V2 response: data.document.content
+		doc, ok := data["document"].(map[string]interface{})
+		if !ok {
+			return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document object")
+		}
+		content, ok := doc["content"].(string)
+		if !ok {
+			return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document.content")
+		}
+
+		fileName := preferredFileName
+		if fileName == "" {
+			// Prefer the remote title for the exported file name, but still fall
+			// back to the token if metadata is empty.
+			title, err := common.FetchDriveMetaTitle(runtime, spec.Token, spec.DocType)
 			if err != nil {
-				return err
+				fmt.Fprintf(runtime.IO().ErrOut, "Title lookup failed, using token as filename: %v\n", err)
+				title = spec.Token
 			}
+			fileName = title
+		}
+		fileName = ensureExportFileExtension(sanitizeExportFileName(fileName, spec.Token), spec.FileExtension)
+		savedPath, err := saveContentToOutputDir(runtime.FileIO(), outputDir, fileName, []byte(content), overwrite)
+		if err != nil {
+			return err
+		}
 
-			// Extract content from the V2 response: data.document.content
-			doc, ok := data["document"].(map[string]interface{})
-			if !ok {
-				return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document object")
+		runtime.Out(map[string]interface{}{
+			"token":          spec.Token,
+			"doc_type":       spec.DocType,
+			"file_extension": spec.FileExtension,
+			"file_name":      filepath.Base(savedPath),
+			"saved_path":     savedPath,
+			"size_bytes":     len(content),
+		}, nil)
+		return nil
+	}
+
+	ticket, err := createDriveExportTask(runtime, spec)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(runtime.IO().ErrOut, "Created export task: %s\n", ticket)
+
+	var lastStatus driveExportStatus
+	var lastPollErr error
+	hasObservedStatus := false
+	// Keep the command responsive by polling for a bounded window. If the task
+	// is still running after that, return a resume command instead of blocking.
+	for attempt := 1; attempt <= driveExportPollAttempts; attempt++ {
+		if attempt > 1 {
+			select {
+			case <-ctx.Done():
+				return wrapExportContextErr(ctx.Err())
+			case <-time.After(driveExportPollInterval):
 			}
-			content, ok := doc["content"].(string)
-			if !ok {
-				return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document.content")
+		}
+		if err := ctx.Err(); err != nil {
+			return wrapExportContextErr(err)
+		}
+
+		status, err := getDriveExportStatus(runtime, spec.Token, ticket)
+		if err != nil {
+			// Treat polling failures as transient so short-lived backend hiccups
+			// do not immediately fail an otherwise healthy export task.
+			lastPollErr = err
+			fmt.Fprintf(runtime.IO().ErrOut, "Export status attempt %d/%d failed: %v\n", attempt, driveExportPollAttempts, err)
+			continue
+		}
+		lastStatus = status
+		hasObservedStatus = true
+
+		if status.Ready() {
+			fmt.Fprintf(runtime.IO().ErrOut, "Export task completed: %s\n", common.MaskToken(status.FileToken))
+
+			// Export-only mode: caller wants the ready file token / metadata but
+			// no local download (e.g. sheets +workbook-export without an output
+			// path). Skip the download and return the status envelope.
+			if strings.TrimSpace(outputDir) == "" {
+				runtime.Out(map[string]interface{}{
+					"ticket":         ticket,
+					"token":          spec.Token,
+					"doc_type":       spec.DocType,
+					"file_extension": spec.FileExtension,
+					"file_token":     status.FileToken,
+					"file_name":      status.FileName,
+					"file_size":      status.FileSize,
+					"ready":          true,
+					"downloaded":     false,
+				}, nil)
+				return nil
 			}
 
 			fileName := preferredFileName
 			if fileName == "" {
-				// Prefer the remote title for the exported file name, but still fall
-				// back to the token if metadata is empty.
-				title, err := common.FetchDriveMetaTitle(runtime, spec.Token, spec.DocType)
-				if err != nil {
-					fmt.Fprintf(runtime.IO().ErrOut, "Title lookup failed, using token as filename: %v\n", err)
-					title = spec.Token
-				}
-				fileName = title
+				fileName = status.FileName
 			}
 			fileName = ensureExportFileExtension(sanitizeExportFileName(fileName, spec.Token), spec.FileExtension)
-			savedPath, err := saveContentToOutputDir(runtime.FileIO(), outputDir, fileName, []byte(content), overwrite)
+			out, err := downloadDriveExportFile(ctx, runtime, status.FileToken, outputDir, fileName, overwrite)
 			if err != nil {
-				return err
+				recoveryCommand := driveExportDownloadCommand(status.FileToken, fileName, outputDir, overwrite)
+				hint := fmt.Sprintf(
+					"the export artifact is already ready (ticket=%s, file_token=%s)\nretry download with: %s",
+					ticket,
+					status.FileToken,
+					recoveryCommand,
+				)
+				return appendDriveExportRecoveryHint(err, hint)
 			}
-
-			runtime.Out(map[string]interface{}{
-				"token":          spec.Token,
-				"doc_type":       spec.DocType,
-				"file_extension": spec.FileExtension,
-				"file_name":      filepath.Base(savedPath),
-				"saved_path":     savedPath,
-				"size_bytes":     len(content),
-			}, nil)
+			out["ticket"] = ticket
+			out["doc_type"] = spec.DocType
+			out["file_extension"] = spec.FileExtension
+			runtime.Out(out, nil)
 			return nil
 		}
 
-		ticket, err := createDriveExportTask(runtime, spec)
-		if err != nil {
-			return err
-		}
-		fmt.Fprintf(runtime.IO().ErrOut, "Created export task: %s\n", ticket)
-
-		var lastStatus driveExportStatus
-		var lastPollErr error
-		hasObservedStatus := false
-		// Keep the command responsive by polling for a bounded window. If the task
-		// is still running after that, return a resume command instead of blocking.
-		for attempt := 1; attempt <= driveExportPollAttempts; attempt++ {
-			if attempt > 1 {
-				select {
-				case <-ctx.Done():
-					return ctx.Err()
-				case <-time.After(driveExportPollInterval):
-				}
+		if status.Failed() {
+			msg := strings.TrimSpace(status.JobErrorMsg)
+			if msg == "" {
+				msg = status.StatusLabel()
 			}
-			if err := ctx.Err(); err != nil {
-				return err
-			}
-
-			status, err := getDriveExportStatus(runtime, spec.Token, ticket)
-			if err != nil {
-				// Treat polling failures as transient so short-lived backend hiccups
-				// do not immediately fail an otherwise healthy export task.
-				lastPollErr = err
-				fmt.Fprintf(runtime.IO().ErrOut, "Export status attempt %d/%d failed: %v\n", attempt, driveExportPollAttempts, err)
-				continue
-			}
-			lastStatus = status
-			hasObservedStatus = true
-
-			if status.Ready() {
-				fmt.Fprintf(runtime.IO().ErrOut, "Export task completed: %s\n", common.MaskToken(status.FileToken))
-				fileName := preferredFileName
-				if fileName == "" {
-					fileName = status.FileName
-				}
-				fileName = ensureExportFileExtension(sanitizeExportFileName(fileName, spec.Token), spec.FileExtension)
-				out, err := downloadDriveExportFile(ctx, runtime, status.FileToken, outputDir, fileName, overwrite)
-				if err != nil {
-					recoveryCommand := driveExportDownloadCommand(status.FileToken, fileName, outputDir, overwrite)
-					hint := fmt.Sprintf(
-						"the export artifact is already ready (ticket=%s, file_token=%s)\nretry download with: %s",
-						ticket,
-						status.FileToken,
-						recoveryCommand,
-					)
-					return appendDriveExportRecoveryHint(err, hint)
-				}
-				out["ticket"] = ticket
-				out["doc_type"] = spec.DocType
-				out["file_extension"] = spec.FileExtension
-				runtime.Out(out, nil)
-				return nil
-			}
-
-			if status.Failed() {
-				msg := strings.TrimSpace(status.JobErrorMsg)
-				if msg == "" {
-					msg = status.StatusLabel()
-				}
-				return errs.NewAPIError(errs.SubtypeServerError, "export task failed: %s (ticket=%s)", msg, ticket)
-			}
-
-			fmt.Fprintf(runtime.IO().ErrOut, "Export status %d/%d: %s\n", attempt, driveExportPollAttempts, status.StatusLabel())
+			return errs.NewAPIError(errs.SubtypeServerError, "export task failed: %s (ticket=%s)", msg, ticket)
 		}
 
-		nextCommand := driveExportTaskResultCommand(ticket, spec.Token)
-		if !hasObservedStatus && lastPollErr != nil {
-			hint := fmt.Sprintf(
-				"the export task was created but every status poll failed (ticket=%s)\nretry status lookup with: %s",
-				ticket,
-				nextCommand,
-			)
-			return appendDriveExportRecoveryHint(lastPollErr, hint)
-		}
+		fmt.Fprintf(runtime.IO().ErrOut, "Export status %d/%d: %s\n", attempt, driveExportPollAttempts, status.StatusLabel())
+	}
 
-		failed := false
-		var jobStatus interface{}
-		jobStatusLabel := "unknown"
-		if hasObservedStatus {
-			failed = lastStatus.Failed()
-			jobStatus = lastStatus.JobStatus
-			jobStatusLabel = lastStatus.StatusLabel()
-		}
-		// Return the last observed status so callers can resume from a known task
-		// state instead of losing all progress information on timeout.
-		result := map[string]interface{}{
-			"ticket":           ticket,
-			"token":            spec.Token,
-			"doc_type":         spec.DocType,
-			"file_extension":   spec.FileExtension,
-			"ready":            false,
-			"failed":           failed,
-			"job_status":       jobStatus,
-			"job_status_label": jobStatusLabel,
-			"timed_out":        true,
-			"next_command":     nextCommand,
-		}
-		if preferredFileName != "" {
-			result["file_name"] = ensureExportFileExtension(sanitizeExportFileName(preferredFileName, spec.Token), spec.FileExtension)
-		}
-		runtime.Out(result, nil)
-		fmt.Fprintf(runtime.IO().ErrOut, "Export task is still in progress. Continue with: %s\n", nextCommand)
-		return nil
-	},
+	nextCommand := driveExportTaskResultCommand(ticket, spec.Token)
+	if !hasObservedStatus && lastPollErr != nil {
+		hint := fmt.Sprintf(
+			"the export task was created but every status poll failed (ticket=%s)\nretry status lookup with: %s",
+			ticket,
+			nextCommand,
+		)
+		return appendDriveExportRecoveryHint(lastPollErr, hint)
+	}
+
+	failed := false
+	var jobStatus interface{}
+	jobStatusLabel := "unknown"
+	if hasObservedStatus {
+		failed = lastStatus.Failed()
+		jobStatus = lastStatus.JobStatus
+		jobStatusLabel = lastStatus.StatusLabel()
+	}
+	// Return the last observed status so callers can resume from a known task
+	// state instead of losing all progress information on timeout.
+	result := map[string]interface{}{
+		"ticket":           ticket,
+		"token":            spec.Token,
+		"doc_type":         spec.DocType,
+		"file_extension":   spec.FileExtension,
+		"ready":            false,
+		"failed":           failed,
+		"job_status":       jobStatus,
+		"job_status_label": jobStatusLabel,
+		"timed_out":        true,
+		"next_command":     nextCommand,
+	}
+	if preferredFileName != "" {
+		result["file_name"] = ensureExportFileExtension(sanitizeExportFileName(preferredFileName, spec.Token), spec.FileExtension)
+	}
+	runtime.Out(result, nil)
+	fmt.Fprintf(runtime.IO().ErrOut, "Export task is still in progress. Continue with: %s\n", nextCommand)
+	return nil
 }

shortcuts/drive/drive_export_test.go

@@ -5,6 +5,7 @@ package drive
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"net/http"
@@ -497,6 +498,72 @@ func TestDriveExportAsyncSuccess(t *testing.T) {
 	}
 }
 
+// TestDriveExportEmptyOutputDirDownloadsToCwd guards the export refactor: an
+// explicit empty --output-dir must still download to the current directory
+// (normalized to "."), not trigger the export-only no-download path that the
+// shared RunExport core uses for sheets +workbook-export.
+func TestDriveExportEmptyOutputDirDownloadsToCwd(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/drive/v1/export_tasks",
+		Body:   map[string]interface{}{"code": 0, "data": map[string]interface{}{"ticket": "tk_e"}},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/drive/v1/export_tasks/tk_e",
+		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
+			"result": map[string]interface{}{
+				"job_status": 0, "file_token": "box_e", "file_name": "report",
+				"file_extension": "pdf", "type": "docx", "file_size": 3,
+			},
+		}},
+	})
+	reg.Register(&httpmock.Stub{
+		Method:  "GET",
+		URL:     "/open-apis/drive/v1/export_tasks/file/box_e/download",
+		Status:  200,
+		RawBody: []byte("pdf"),
+		Headers: http.Header{
+			"Content-Type":        []string{"application/pdf"},
+			"Content-Disposition": []string{`attachment; filename="report.pdf"`},
+		},
+	})
+
+	tmpDir := t.TempDir()
+	withDriveWorkingDir(t, tmpDir)
+
+	prevAttempts, prevInterval := driveExportPollAttempts, driveExportPollInterval
+	driveExportPollAttempts, driveExportPollInterval = 1, 0
+	t.Cleanup(func() {
+		driveExportPollAttempts, driveExportPollInterval = prevAttempts, prevInterval
+	})
+
+	err := mountAndRunDrive(t, DriveExport, []string{
+		"+export",
+		"--token", "docx123",
+		"--doc-type", "docx",
+		"--file-extension", "pdf",
+		"--output-dir", "",
+		"--as", "bot",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Empty --output-dir must still write to cwd, not skip the download.
+	data, err := os.ReadFile(filepath.Join(tmpDir, "report.pdf"))
+	if err != nil {
+		t.Fatalf("empty --output-dir should still download to cwd: %v", err)
+	}
+	if string(data) != "pdf" {
+		t.Fatalf("downloaded content = %q", string(data))
+	}
+	if strings.Contains(stdout.String(), `"downloaded": false`) {
+		t.Fatalf("export-only path must not trigger for drive +export: %s", stdout.String())
+	}
+}
+
 func TestDriveExportAsyncUsesProvidedFileName(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
@@ -1034,3 +1101,37 @@ func TestDriveTaskResultExportIncludesReadyFlags(t *testing.T) {
 		t.Fatalf("stdout missing job_status_label: %s", stdout.String())
 	}
 }
+
+// TestWrapExportContextErr verifies the export poll loop's typed wrapping for
+// context cancellation / deadline. Previously the poll loop returned ctx.Err()
+// directly so an untyped context.Canceled would escape as a plain string at
+// the command layer, bypassing the typed-error contract.
+func TestWrapExportContextErr(t *testing.T) {
+	if err := wrapExportContextErr(nil); err != nil {
+		t.Errorf("wrapExportContextErr(nil) = %v, want nil", err)
+	}
+
+	cancelled := wrapExportContextErr(context.Canceled)
+	var netErrCancel *errs.NetworkError
+	if !errors.As(cancelled, &netErrCancel) {
+		t.Fatalf("wrapExportContextErr(Canceled) = %T, want *errs.NetworkError", cancelled)
+	}
+	if netErrCancel.Subtype != errs.SubtypeNetworkTransport {
+		t.Errorf("Canceled subtype = %q, want %q", netErrCancel.Subtype, errs.SubtypeNetworkTransport)
+	}
+	if !errors.Is(cancelled, context.Canceled) {
+		t.Error("wrapExportContextErr should preserve context.Canceled via errors.Is")
+	}
+
+	deadline := wrapExportContextErr(context.DeadlineExceeded)
+	var netErrDeadline *errs.NetworkError
+	if !errors.As(deadline, &netErrDeadline) {
+		t.Fatalf("wrapExportContextErr(DeadlineExceeded) = %T, want *errs.NetworkError", deadline)
+	}
+	if netErrDeadline.Subtype != errs.SubtypeNetworkTimeout {
+		t.Errorf("DeadlineExceeded subtype = %q, want %q", netErrDeadline.Subtype, errs.SubtypeNetworkTimeout)
+	}
+	if !errors.Is(deadline, context.DeadlineExceeded) {
+		t.Error("wrapExportContextErr should preserve context.DeadlineExceeded via errors.Is")
+	}
+}

shortcuts/drive/drive_import.go

@@ -35,132 +35,164 @@ var DriveImport = common.Shortcut{
 		{Name: "target-token", Desc: "existing token to import data into (only for type=bitable); when set, data is mounted into this bitable instead of creating a new one"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		return validateDriveImportSpec(driveImportSpec{
-			FilePath:    runtime.Str("file"),
-			DocType:     strings.ToLower(runtime.Str("type")),
-			FolderToken: runtime.Str("folder-token"),
-			Name:        runtime.Str("name"),
-			TargetToken: runtime.Str("target-token"),
-		})
+		return ValidateImport(importParamsFromFlags(runtime))
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec := driveImportSpec{
-			FilePath:    runtime.Str("file"),
-			DocType:     strings.ToLower(runtime.Str("type")),
-			FolderToken: runtime.Str("folder-token"),
-			Name:        runtime.Str("name"),
-			TargetToken: runtime.Str("target-token"),
-		}
-		fileSize, err := preflightDriveImportFile(runtime.FileIO(), &spec)
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		if valErr := validateDriveImportSpec(spec); valErr != nil {
-			return common.NewDryRunAPI().Set("error", valErr.Error())
-		}
-
-		dry := common.NewDryRunAPI()
-		dry.Desc("Upload file (single-part or multipart) -> create import task -> poll status")
-
-		appendDriveImportFolderTokenWikiCheckDryRun(dry, spec)
-		appendDriveImportUploadDryRun(dry, spec, fileSize)
-
-		dry.POST("/open-apis/drive/v1/import_tasks").
-			Desc("[2] Create import task").
-			Body(spec.CreateTaskBody("<file_token>"))
-
-		dry.GET("/open-apis/drive/v1/import_tasks/:ticket").
-			Desc("[3] Poll import task result").
-			Set("ticket", "<ticket>")
-		if runtime.IsBot() {
-			dry.Desc("After the import result returns the final cloud document target in bot mode, the CLI will also try to grant the current CLI user full_access (可管理权限) on it.")
-		}
-
-		return dry
+		return PlanImportDryRun(runtime, importParamsFromFlags(runtime))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec := driveImportSpec{
-			FilePath:    runtime.Str("file"),
-			DocType:     strings.ToLower(runtime.Str("type")),
-			FolderToken: runtime.Str("folder-token"),
-			Name:        runtime.Str("name"),
-			TargetToken: runtime.Str("target-token"),
-		}
-		if _, err := preflightDriveImportFile(runtime.FileIO(), &spec); err != nil {
-			return err
-		}
-		if err := rejectDriveImportWikiFolderToken(runtime, spec.FolderToken); err != nil {
-			return err
-		}
-
-		// Step 1: Upload file as media
-		fileToken, uploadErr := uploadMediaForImport(ctx, runtime, spec.FilePath, spec.SourceFileName(), spec.DocType)
-		if uploadErr != nil {
-			return uploadErr
-		}
-
-		fmt.Fprintf(runtime.IO().ErrOut, "Creating import task for %s as %s...\n", spec.TargetFileName(), spec.DocType)
-
-		// Step 2: Create import task
-		ticket, err := createDriveImportTask(runtime, spec, fileToken)
-		if err != nil {
-			return err
-		}
-
-		// Step 3: Poll task
-		fmt.Fprintf(runtime.IO().ErrOut, "Polling import task %s...\n", ticket)
-
-		status, ready, err := pollDriveImportTask(runtime, ticket)
-		if err != nil {
-			return err
-		}
-
-		// Some intermediate responses omit the final type, so fall back to the
-		// requested type to keep the output shape stable.
-		resultType := status.DocType
-		if resultType == "" {
-			resultType = spec.DocType
-		}
-		out := map[string]interface{}{
-			"ticket":           ticket,
-			"type":             resultType,
-			"ready":            ready,
-			"job_status":       status.JobStatus,
-			"job_status_label": status.StatusLabel(),
-		}
-		if status.Token != "" {
-			out["token"] = status.Token
-		}
-		if statusURL := strings.TrimSpace(status.URL); statusURL != "" {
-			out["url"] = statusURL
-		} else if status.Token != "" {
-			if u := common.BuildResourceURL(runtime.Config.Brand, normalizeDriveImportKindForURL(resultType, spec.DocType), status.Token); u != "" {
-				out["url"] = u
-			}
-		}
-		if status.JobErrorMsg != "" {
-			out["job_error_msg"] = status.JobErrorMsg
-		}
-		if status.Extra != nil {
-			out["extra"] = status.Extra
-		}
-		if !ready {
-			nextCommand := driveImportTaskResultCommand(ticket)
-			fmt.Fprintf(runtime.IO().ErrOut, "Import task is still in progress. Continue with: %s\n", nextCommand)
-			out["timed_out"] = true
-			out["next_command"] = nextCommand
-		}
-		if ready {
-			if grant := common.AutoGrantCurrentUserDrivePermission(runtime, common.GetString(out, "token"), resultType); grant != nil {
-				out["permission_grant"] = grant
-			}
-		}
-
-		runtime.Out(out, nil)
-		return nil
+		return RunImport(ctx, runtime, importParamsFromFlags(runtime))
 	},
 }
 
+// ImportParams holds the user-facing inputs for an import flow, decoupled from
+// cobra flags so other command groups (e.g. sheets +workbook-import) can reuse
+// the drive import implementation without taking a dependency on a --type flag.
+type ImportParams struct {
+	File        string
+	DocType     string
+	FolderToken string
+	Name        string
+	TargetToken string
+}
+
+func (p ImportParams) spec() driveImportSpec {
+	return driveImportSpec{
+		FilePath:    p.File,
+		DocType:     strings.ToLower(p.DocType),
+		FolderToken: p.FolderToken,
+		Name:        p.Name,
+		TargetToken: p.TargetToken,
+	}
+}
+
+// importParamsFromFlags reads the standard drive +import flag set.
+func importParamsFromFlags(runtime *common.RuntimeContext) ImportParams {
+	return ImportParams{
+		File:        runtime.Str("file"),
+		DocType:     runtime.Str("type"),
+		FolderToken: runtime.Str("folder-token"),
+		Name:        runtime.Str("name"),
+		TargetToken: runtime.Str("target-token"),
+	}
+}
+
+// ValidateImport runs the CLI-level compatibility checks for an import.
+func ValidateImport(p ImportParams) error {
+	return validateDriveImportSpec(p.spec())
+}
+
+// PlanImportDryRun builds the dry-run plan (upload -> create task -> poll) for
+// an import without performing any network or file I/O beyond a local stat.
+func PlanImportDryRun(runtime *common.RuntimeContext, p ImportParams) *common.DryRunAPI {
+	spec := p.spec()
+	fileSize, err := preflightDriveImportFile(runtime.FileIO(), &spec)
+	if err != nil {
+		return common.NewDryRunAPI().Set("error", err.Error())
+	}
+	if valErr := validateDriveImportSpec(spec); valErr != nil {
+		return common.NewDryRunAPI().Set("error", valErr.Error())
+	}
+
+	dry := common.NewDryRunAPI()
+	dry.Desc("Upload file (single-part or multipart) -> create import task -> poll status")
+
+	appendDriveImportFolderTokenWikiCheckDryRun(dry, spec)
+	appendDriveImportUploadDryRun(dry, spec, fileSize)
+
+	dry.POST("/open-apis/drive/v1/import_tasks").
+		Desc("[2] Create import task").
+		Body(spec.CreateTaskBody("<file_token>"))
+
+	dry.GET("/open-apis/drive/v1/import_tasks/:ticket").
+		Desc("[3] Poll import task result").
+		Set("ticket", "<ticket>")
+	if runtime.IsBot() {
+		dry.Desc("After the import result returns the final cloud document target in bot mode, the CLI will also try to grant the current CLI user full_access (可管理权限) on it.")
+	}
+
+	return dry
+}
+
+// RunImport executes the full import flow: upload media -> create import task ->
+// bounded poll, then writes the result envelope to the runtime output. It is
+// the shared core behind both drive +import and sheets +workbook-import.
+func RunImport(ctx context.Context, runtime *common.RuntimeContext, p ImportParams) error {
+	spec := p.spec()
+	if _, err := preflightDriveImportFile(runtime.FileIO(), &spec); err != nil {
+		return err
+	}
+	if err := rejectDriveImportWikiFolderToken(runtime, spec.FolderToken); err != nil {
+		return err
+	}
+
+	// Step 1: Upload file as media
+	fileToken, uploadErr := uploadMediaForImport(ctx, runtime, spec.FilePath, spec.SourceFileName(), spec.DocType)
+	if uploadErr != nil {
+		return uploadErr
+	}
+
+	fmt.Fprintf(runtime.IO().ErrOut, "Creating import task for %s as %s...\n", spec.TargetFileName(), spec.DocType)
+
+	// Step 2: Create import task
+	ticket, err := createDriveImportTask(runtime, spec, fileToken)
+	if err != nil {
+		return err
+	}
+
+	// Step 3: Poll task
+	fmt.Fprintf(runtime.IO().ErrOut, "Polling import task %s...\n", ticket)
+
+	status, ready, err := pollDriveImportTask(runtime, ticket)
+	if err != nil {
+		return err
+	}
+
+	// Some intermediate responses omit the final type, so fall back to the
+	// requested type to keep the output shape stable.
+	resultType := status.DocType
+	if resultType == "" {
+		resultType = spec.DocType
+	}
+	out := map[string]interface{}{
+		"ticket":           ticket,
+		"type":             resultType,
+		"ready":            ready,
+		"job_status":       status.JobStatus,
+		"job_status_label": status.StatusLabel(),
+	}
+	if status.Token != "" {
+		out["token"] = status.Token
+	}
+	if statusURL := strings.TrimSpace(status.URL); statusURL != "" {
+		out["url"] = statusURL
+	} else if status.Token != "" {
+		if u := common.BuildResourceURL(runtime.Config.Brand, normalizeDriveImportKindForURL(resultType, spec.DocType), status.Token); u != "" {
+			out["url"] = u
+		}
+	}
+	if status.JobErrorMsg != "" {
+		out["job_error_msg"] = status.JobErrorMsg
+	}
+	if status.Extra != nil {
+		out["extra"] = status.Extra
+	}
+	if !ready {
+		nextCommand := driveImportTaskResultCommand(ticket)
+		fmt.Fprintf(runtime.IO().ErrOut, "Import task is still in progress. Continue with: %s\n", nextCommand)
+		out["timed_out"] = true
+		out["next_command"] = nextCommand
+	}
+	if ready {
+		if grant := common.AutoGrantCurrentUserDrivePermission(runtime, common.GetString(out, "token"), resultType); grant != nil {
+			out["permission_grant"] = grant
+		}
+	}
+
+	runtime.Out(out, nil)
+	return nil
+}
+
 func preflightDriveImportFile(fio fileio.FileIO, spec *driveImportSpec) (int64, error) {
 	// Keep dry-run and execution aligned on path normalization, file existence,
 	// and format-specific size limits before planning the upload path.

shortcuts/im/builders_test.go

@@ -469,6 +469,29 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})
 
+	t.Run("ImMessagesSend audio rejects non-opus local file", func(t *testing.T) {
+		runtime := newTestRuntimeContext(t, map[string]string{
+			"chat-id": "oc_123",
+			"audio":   "./voice.mp3",
+		}, nil)
+		err := ImMessagesSend.Validate(context.Background(), runtime)
+		if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
+			t.Fatalf("ImMessagesSend.Validate() error = %v", err)
+		}
+	})
+
+	t.Run("ImMessagesSend audio accepts opus and ogg local files", func(t *testing.T) {
+		for _, audio := range []string{"./voice.opus", "./voice.ogg"} {
+			runtime := newTestRuntimeContext(t, map[string]string{
+				"chat-id": "oc_123",
+				"audio":   audio,
+			}, nil)
+			if err := ImMessagesSend.Validate(context.Background(), runtime); err != nil {
+				t.Fatalf("ImMessagesSend.Validate(%q) unexpected error = %v", audio, err)
+			}
+		}
+	})
+
 	t.Run("ImMessagesSend conflicting explicit msg-type", func(t *testing.T) {
 		runtime := newTestRuntimeContext(t, map[string]string{
 			"chat-id":  "oc_123",
@@ -492,6 +515,17 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})
 
+	t.Run("ImMessagesReply audio rejects non-opus local file", func(t *testing.T) {
+		runtime := newTestRuntimeContext(t, map[string]string{
+			"message-id": "om_123",
+			"audio":      "./voice.mp3",
+		}, nil)
+		err := ImMessagesReply.Validate(context.Background(), runtime)
+		if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
+			t.Fatalf("ImMessagesReply.Validate() error = %v", err)
+		}
+	})
+
 	t.Run("ImThreadsMessagesList invalid thread", func(t *testing.T) {
 		runtime := newTestRuntimeContext(t, map[string]string{
 			"thread": "bad_thread",

shortcuts/im/helpers.go

@@ -1048,6 +1048,42 @@ func detectIMFileType(filePath string) string {
 	}
 }
 
+const (
+	audioMessageInputDesc = "audio file key (file_xxx), URL, or cwd-relative local path for a voice message (absolute paths and .. are rejected); local paths and URLs must be Opus (.opus or Ogg Opus .ogg). For mp3/wav, convert to .opus first, or use --file to send as an attachment"
+	audioMessageHint      = "Convert non-Opus audio to .opus and use --audio for a voice message, for example: ffmpeg -i input.mp3 -acodec libopus -ac 1 -ar 16000 output.opus. To send the original mp3/wav as an attachment, use --file instead."
+)
+
+func validateAudioMessageInput(flagName, value string) error {
+	value = strings.TrimSpace(value)
+	if value == "" || isMediaKey(value) {
+		return nil
+	}
+
+	ext := audioInputExt(value)
+	if ext == "" {
+		return nil
+	}
+	if ext == ".opus" || ext == ".ogg" {
+		return nil
+	}
+	return errs.NewValidationError(
+		errs.SubtypeInvalidArgument,
+		"%s supports only Opus audio files for audio messages, such as .opus files or Ogg Opus (.ogg) files",
+		flagName,
+	).WithParam(flagName).WithHint("%s", audioMessageHint)
+}
+
+func audioInputExt(value string) string {
+	if isURL(value) {
+		parsed, err := url.Parse(value)
+		if err != nil {
+			return ""
+		}
+		return strings.ToLower(path.Ext(parsed.Path))
+	}
+	return strings.ToLower(filepath.Ext(value))
+}
+
 const maxImageUploadSize = 5 * 1024 * 1024  // 5MB — Lark API limit for images
 const maxFileUploadSize = 100 * 1024 * 1024 // 100MB — Lark API limit for files
 

shortcuts/im/helpers_test.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
@@ -50,6 +51,56 @@ func TestDetectIMFileType(t *testing.T) {
 	}
 }
 
+func TestValidateAudioMessageInput(t *testing.T) {
+	tests := []struct {
+		name    string
+		value   string
+		wantErr bool
+	}{
+		{name: "empty", value: ""},
+		{name: "existing file key", value: "file_abc"},
+		{name: "opus file", value: "./voice.opus"},
+		{name: "ogg opus file", value: "./voice.ogg"},
+		{name: "uppercase opus", value: "./VOICE.OPUS"},
+		{name: "mp3 local file", value: "./voice.mp3", wantErr: true},
+		{name: "wav local file", value: "./voice.wav", wantErr: true},
+		{name: "extensionless local path", value: "./voice"},
+		{name: "opus url", value: "https://example.com/voice.opus?download=1"},
+		{name: "ogg url", value: "https://example.com/voice.ogg?download=1"},
+		{name: "mp3 url", value: "https://example.com/voice.mp3?download=1", wantErr: true},
+		{name: "extensionless url", value: "https://example.com/download?id=1"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateAudioMessageInput("--audio", tt.value)
+			if tt.wantErr {
+				if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
+					t.Fatalf("validateAudioMessageInput(%q) error = %v", tt.value, err)
+				}
+				p, ok := errs.ProblemOf(err)
+				if !ok {
+					t.Fatalf("validateAudioMessageInput(%q) error is not typed: %v", tt.value, err)
+				}
+				if p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
+					t.Fatalf("ProblemOf(%q) = category %q subtype %q", tt.value, p.Category, p.Subtype)
+				}
+				validationErr, ok := err.(*errs.ValidationError)
+				if !ok || validationErr.Param != "--audio" {
+					t.Fatalf("validateAudioMessageInput(%q) param = %q, want --audio", tt.value, validationErr.Param)
+				}
+				if !strings.Contains(p.Hint, "use --file") || !strings.Contains(p.Hint, "ffmpeg") {
+					t.Fatalf("validateAudioMessageInput(%q) hint = %q, want --file and ffmpeg guidance", tt.value, p.Hint)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("validateAudioMessageInput(%q) unexpected error = %v", tt.value, err)
+			}
+		})
+	}
+}
+
 // TestSplitCSV covers the shared helper that replaced the three identical functions
 func TestSplitCSV(t *testing.T) {
 	tests := []struct {

shortcuts/im/im_messages_reply.go

@@ -33,7 +33,7 @@ var ImMessagesReply = common.Shortcut{
 		{Name: "file", Desc: "file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
 		{Name: "video", Desc: "video file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); must be used together with --video-cover"},
 		{Name: "video-cover", Desc: "video cover image key (img_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); required when using --video"},
-		{Name: "audio", Desc: "audio file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
+		{Name: "audio", Desc: audioMessageInputDesc},
 		{Name: "reply-in-thread", Type: "bool", Desc: "reply in thread (message appears in thread stream instead of main chat)"},
 		{Name: "idempotency-key", Desc: "idempotency key (prevents duplicate sends)"},
 	},
@@ -100,6 +100,9 @@ var ImMessagesReply = common.Shortcut{
 				return err
 			}
 		}
+		if err := validateAudioMessageInput("--audio", audioKey); err != nil {
+			return err
+		}
 
 		if messageId == "" {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--message-id is required (om_xxx)").WithParam("--message-id")

shortcuts/im/im_messages_send.go

@@ -37,7 +37,7 @@ var ImMessagesSend = common.Shortcut{
 		{Name: "file", Desc: "file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
 		{Name: "video", Desc: "video file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); must be used together with --video-cover"},
 		{Name: "video-cover", Desc: "video cover image key (img_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); required when using --video"},
-		{Name: "audio", Desc: "audio file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
+		{Name: "audio", Desc: audioMessageInputDesc},
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		chatFlag := runtime.Str("chat-id")
@@ -112,6 +112,9 @@ var ImMessagesSend = common.Shortcut{
 				return err
 			}
 		}
+		if err := validateAudioMessageInput("--audio", audioKey); err != nil {
+			return err
+		}
 
 		if err := common.ExactlyOneTyped(runtime, "chat-id", "user-id"); err != nil {
 			return err

shortcuts/sheets/batch_op_contract_test.go

@@ -177,6 +177,18 @@ func TestBatchOp_BodyMatchesStandalone(t *testing.T) {
 			args:     []string{"--sheet-id", "sh1", "--color", "#FF0000"},
 			subInput: `{"sheet-id":"sh1","color":"#FF0000"}`,
 		},
+		{
+			shortcut: "+sheet-show-gridline",
+			sc:       SheetShowGridline,
+			args:     []string{"--sheet-id", "sh1"},
+			subInput: `{"sheet-id":"sh1"}`,
+		},
+		{
+			shortcut: "+sheet-hide-gridline",
+			sc:       SheetHideGridline,
+			args:     []string{"--sheet-id", "sh1"},
+			subInput: `{"sheet-id":"sh1"}`,
+		},
 		{
 			shortcut: "+dropdown-set",
 			sc:       DropdownSet,
@@ -432,12 +444,7 @@ func TestBatchOp_ErrorEquivalence(t *testing.T) {
 				t, tc.shortcut,
 				append([]string{"--url", testURL, "--dry-run"}, tc.args...),
 			)
-			if standaloneErr == nil {
-				t.Fatalf("standalone Validate accepted bad input — expected error containing %q", tc.wantContains)
-			}
-			if !strings.Contains(standaloneErr.Error(), tc.wantContains) {
-				t.Errorf("standalone error = %q, want substring %q", standaloneErr.Error(), tc.wantContains)
-			}
+			requireValidation(t, standaloneErr, tc.wantContains)
 
 			// Batch path: translate the matching sub-op. The translator wraps
 			// the inner error with "operations[i] (<shortcut>): " — assert the
@@ -451,17 +458,12 @@ func TestBatchOp_ErrorEquivalence(t *testing.T) {
 				"input":    subInput,
 			}
 			_, batchErr := translateBatchOp(rawOp, testToken, 0)
-			if batchErr == nil {
-				t.Fatalf("batch translator accepted bad input — expected error containing %q", tc.wantContains)
-			}
-			if !strings.Contains(batchErr.Error(), tc.wantContains) {
-				t.Errorf("batch error = %q, want substring %q (operations[i] prefix is fine)", batchErr.Error(), tc.wantContains)
-			}
+			batchVE := requireValidation(t, batchErr, tc.wantContains)
 			// And the wrap context must include the sub-op index + shortcut
 			// name so error reports stay actionable in multi-op batches.
 			wrapHint := "operations[0] (" + tc.subShortcut + "):"
-			if !strings.Contains(batchErr.Error(), wrapHint) {
-				t.Errorf("batch error %q missing context prefix %q", batchErr.Error(), wrapHint)
+			if !strings.Contains(batchVE.Message, wrapHint) {
+				t.Errorf("batch error %q missing context prefix %q", batchVE.Message, wrapHint)
 			}
 		})
 	}
@@ -517,12 +519,7 @@ func TestBatchOp_RejectsWrongScalarType(t *testing.T) {
 			}
 			rawOp := map[string]interface{}{"shortcut": tc.subShortcut, "input": subInput}
 			_, err := translateBatchOp(rawOp, testToken, 0)
-			if err == nil {
-				t.Fatalf("translateBatchOp accepted wrong-typed field; want error containing %q", tc.wantContains)
-			}
-			if !strings.Contains(err.Error(), tc.wantContains) {
-				t.Errorf("error = %q, want substring %q", err.Error(), tc.wantContains)
-			}
+			requireValidation(t, err, tc.wantContains)
 		})
 	}
 }
@@ -580,12 +577,7 @@ func TestBatchOp_GuardsBeyondCobra(t *testing.T) {
 			}
 			rawOp := map[string]interface{}{"shortcut": tc.subShortcut, "input": subInput}
 			_, err := translateBatchOp(rawOp, testToken, 0)
-			if err == nil {
-				t.Fatalf("translateBatchOp accepted bad input; want error containing %q", tc.wantContains)
-			}
-			if !strings.Contains(err.Error(), tc.wantContains) {
-				t.Errorf("error = %q, want substring %q", err.Error(), tc.wantContains)
-			}
+			requireValidation(t, err, tc.wantContains)
 		})
 	}
 }
@@ -716,12 +708,7 @@ func TestBatchOp_RejectsBadSubOpInput(t *testing.T) {
 				"input":    subInput,
 			}
 			_, err := translateBatchOp(rawOp, testToken, 0)
-			if err == nil {
-				t.Fatalf("translator accepted bad input — expected error containing %q", tc.wantContains)
-			}
-			if !strings.Contains(err.Error(), tc.wantContains) {
-				t.Errorf("error = %q, want substring %q", err.Error(), tc.wantContains)
-			}
+			requireValidation(t, err, tc.wantContains)
 		})
 	}
 }
@@ -782,12 +769,7 @@ func TestBatchOp_SchemaValidatesSubOps(t *testing.T) {
 				"input":    subInput,
 			}
 			_, err := translateBatchOp(rawOp, testToken, 0)
-			if err == nil {
-				t.Fatalf("translator accepted schema-violating sub-op — expected error containing %q", tc.wantContains)
-			}
-			if !strings.Contains(err.Error(), tc.wantContains) {
-				t.Errorf("error = %q, want substring %q", err.Error(), tc.wantContains)
-			}
+			requireValidation(t, err, tc.wantContains)
 		})
 	}
 }

shortcuts/sheets/batch_op_dispatch.go

@@ -150,6 +150,12 @@ var batchOpDispatch = map[string]batchOpMapping{
 		return sheetVisibilityInput(fv, t, sid, sn, "unhide")
 	}},
 	"+sheet-set-tab-color": {"modify_workbook_structure", sheetSetTabColorInput},
+	"+sheet-show-gridline": {"modify_workbook_structure", func(fv flagView, t, sid, sn string) (map[string]interface{}, error) {
+		return sheetVisibilityInput(fv, t, sid, sn, "show_gridline")
+	}},
+	"+sheet-hide-gridline": {"modify_workbook_structure", func(fv flagView, t, sid, sn string) (map[string]interface{}, error) {
+		return sheetVisibilityInput(fv, t, sid, sn, "hide_gridline")
+	}},
 
 	// ─── 对象族 CRUD (manage_*_object, operation 区分) ─────────────
 	"+chart-create": {"manage_chart_object", objCreateTranslate(chartSpec)},

shortcuts/sheets/csv_put_guard_test.go

@@ -4,12 +4,10 @@
 package sheets
 
 import (
-	"errors"
 	"os"
 	"strings"
 	"testing"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
 	_ "github.com/larksuite/cli/internal/vfs/localfileio"
 	"github.com/larksuite/cli/shortcuts/common"
@@ -37,18 +35,9 @@ func TestGuardCSVValueIsNotFilePath(t *testing.T) {
 
 	// Bare value naming an existing file → guarded with a fix-it hint.
 	err := guardCSVValueIsNotFilePath(newCSVGuardRuntime("data.csv"))
-	if err == nil {
-		t.Fatal("expected guard error when --csv names an existing file")
-	}
-	if !strings.Contains(err.Error(), "existing file") || !strings.Contains(err.Error(), "@data.csv") {
-		t.Errorf("error should flag the file and suggest @data.csv, got: %v", err)
-	}
-	if p, ok := errs.ProblemOf(err); !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("problem = %+v, want validation/invalid_argument", p)
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("guard error = %T, want *errs.ValidationError", err)
+	ve := requireValidation(t, err, "existing file")
+	if !strings.Contains(ve.Message, "@data.csv") {
+		t.Errorf("message should suggest @data.csv, got: %q", ve.Message)
 	}
 	if ve.Param != "--csv" {
 		t.Errorf("param = %q, want --csv", ve.Param)

shortcuts/sheets/csv_put_range_alias_test.go

@@ -4,7 +4,6 @@
 package sheets
 
 import (
-	"strings"
 	"testing"
 )
 
@@ -44,12 +43,7 @@ func TestCsvPutInput_RejectsStartCellAndRangeTogether(t *testing.T) {
 		"range":      "A1:H17",
 	})
 	_, err := csvPutInput(fv, "tok", "sid", "")
-	if err == nil {
-		t.Fatal("csvPutInput accepted both start-cell and range; want mutual-exclusion error")
-	}
-	if !strings.Contains(err.Error(), "--start-cell and --range are mutually exclusive") {
-		t.Errorf("error = %q, want it to mention start-cell/range mutual exclusion", err.Error())
-	}
+	requireValidation(t, err, "--start-cell and --range are mutually exclusive")
 }
 
 // With neither --start-cell nor --range explicitly set, csvPutInput rejects the
@@ -61,12 +55,7 @@ func TestCsvPutInput_RejectsStartCellAndRangeTogether(t *testing.T) {
 func TestCsvPutInput_RequiresStartCellOrRange(t *testing.T) {
 	fv := newMapFlagViewForCommand("+csv-put", map[string]interface{}{"csv": "a,b"})
 	_, err := csvPutInput(fv, "tok", "sid", "")
-	if err == nil {
-		t.Fatal("csvPutInput accepted missing start-cell/range; want a required-flag error")
-	}
-	if !strings.Contains(err.Error(), "--start-cell or --range is required") {
-		t.Errorf("error = %q, want it to mention '--start-cell or --range is required'", err.Error())
-	}
+	requireValidation(t, err, "--start-cell or --range is required")
 }
 
 // csvPutWriteRangeFromInput surfaces the real paste footprint so agents can see

shortcuts/sheets/data/flag-defs.json

@@ -54,7 +54,7 @@
         "kind": "own",
         "type": "int",
         "required": "optional",
-        "desc": "Insert position; appended to the end when omitted",
+        "desc": "Insert position (0-based); appended to the end when omitted",
         "default": "-1"
       },
       {
@@ -413,6 +413,86 @@
       }
     ]
   },
+  "+sheet-hide-gridline": {
+    "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": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": ""
+      }
+    ]
+  },
+  "+sheet-show-gridline": {
+    "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": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": ""
+      }
+    ]
+  },
   "+workbook-create": {
     "risk": "write",
     "flags": [
@@ -431,22 +511,33 @@
         "desc": "Target folder token; placed at the drive root when omitted"
       },
       {
-        "name": "headers",
+        "name": "values",
         "kind": "own",
         "type": "string",
         "required": "optional",
-        "desc": "Header row as a JSON array: `[\"Col A\",\"Col B\"]`",
+        "desc": "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected, through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes",
         "input": [
           "file",
           "stdin"
         ]
       },
       {
-        "name": "values",
+        "name": "sheets",
         "kind": "own",
         "type": "string",
         "required": "optional",
-        "desc": "Initial data as a 2D JSON array: `[[\"alice\",95]]`",
+        "desc": "Typed table payload as JSON (same shape as `+table-put`): top-level `{\"sheets\":[...]}`, with each array item a sub-sheet `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}` — `name` and the outer `sheets` envelope are both required. Agents typically use `df_to_sheet(df, name)` from `scripts/sheets_df.py` to pack each DataFrame into one item, then wrap the list in `{\"sheets\":[...]}`. Mutually exclusive with --values. Creates the workbook, then writes typed type-faithful data (dates land as real dates, numbers keep precision).",
+        "input": [
+          "file",
+          "stdin"
+        ]
+      },
+      {
+        "name": "styles",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Initial visual operations as JSON: top-level `{styles:[...]}`. Each item corresponds to one target sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. With --sheets, styles array length/order/name must match --sheets.sheets. With --values, pass exactly one styles item for the initial sheet (its name is ignored).",
         "input": [
           "file",
           "stdin"
@@ -502,7 +593,7 @@
         "kind": "own",
         "type": "string",
         "required": "optional",
-        "desc": "Local save path; export is triggered but not downloaded when omitted"
+        "desc": "Local save path. When omitted, **only the export task is triggered + polled, the file is NOT downloaded** (returns file_token / status so a later step can resume the download). Pass a concrete path (e.g. `./out.xlsx`) or a directory (`.` keeps the server-provided filename) to download. Note: the equivalent `lark-cli drive +export --doc-type sheet` uses three separate flags (`--output-dir` / `--file-name` / `--overwrite`) and defaults to downloading into the current directory; this wrapper collapses them into a single `--output-path` for ergonomics but defaults to no-download — fall back to `drive +export` if the split flag set fits better."
       },
       {
         "name": "dry-run",
@@ -513,6 +604,32 @@
       }
     ]
   },
+  "+workbook-import": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "file",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "Local file path (.xlsx / .xls / .csv)"
+      },
+      {
+        "name": "folder-token",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Target folder token; imported to the cloud drive root when omitted"
+      },
+      {
+        "name": "name",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Imported spreadsheet name; defaults to the local file name without its extension"
+      }
+    ]
+  },
   "+sheet-info": {
     "risk": "read",
     "flags": [
@@ -1082,9 +1199,8 @@
         "kind": "own",
         "type": "int",
         "required": "optional",
-        "desc": "Safety cap; default 200000",
-        "default": "200000",
-        "hidden": true
+        "desc": "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more",
+        "default": "500000"
       },
       {
         "name": "skip-hidden",
@@ -1192,9 +1308,8 @@
         "kind": "own",
         "type": "int",
         "required": "optional",
-        "desc": "Safety cap; default 200000",
-        "default": "200000",
-        "hidden": true
+        "desc": "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more",
+        "default": "500000"
       },
       {
         "name": "include-row-prefix",
@@ -1212,19 +1327,65 @@
         "desc": "Skip hidden rows and columns; default `false`"
       },
       {
-        "name": "rows-json",
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Print the request path and parameters without executing"
+      }
+    ]
+  },
+  "+table-get": {
+    "risk": "read",
+    "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": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Read only this sheet (by id); omit to read all sheets"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Read only this sheet (by name); omit to read all sheets"
+      },
+      {
+        "name": "range",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "A1 range to read; omit to read each sheet's full used range (spans internal blank rows/columns, not just the A1 current region)"
+      },
+      {
+        "name": "no-header",
         "kind": "own",
         "type": "bool",
         "required": "optional",
-        "desc": "Return structured rows ({row_number, values:{col→cell}}) instead of CSV text; default false",
-        "default": "false"
+        "desc": "Treat the first row as data instead of a header (columns get positional names col1, col2, ...)"
       },
       {
         "name": "dry-run",
         "kind": "system",
         "type": "bool",
         "required": "optional",
-        "desc": "Print the request path and parameters without executing"
+        "desc": ""
       }
     ]
   },
@@ -1849,7 +2010,7 @@
         "kind": "own",
         "type": "string",
         "required": "required",
-        "desc": "RFC 4180 CSV text; plain values only (no formulas / styles / comments)",
+        "desc": "RFC 4180 CSV text; values or formulas (a leading = is evaluated as a formula); no styles / comments / images (use +cells-set for those).",
         "input": [
           "file",
           "stdin"
@@ -1880,6 +2041,54 @@
       }
     ]
   },
+  "+table-put": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL to write into (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token to write into (XOR with `--url`)"
+      },
+      {
+        "name": "sheets",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "Typed table payload (pandas-DataFrame-shaped) as JSON: top-level `{\"sheets\":[...]}`, with each array item a sub-sheet `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}` — `name` and the outer `sheets` envelope are both required. Agents typically use `df_to_sheet(df, name)` from `scripts/sheets_df.py` to pack each DataFrame into one item, then wrap the list in `{\"sheets\":[...]}`. `dtypes` values are pandas dtype strings (`int64`, `float64`, `Int64`, `bool`, `boolean`, `datetime64[ns]`, `object`, ...); the writer maps them to internal string/number/date/bool — omit `dtypes` and a column writes as text (good for raw CSV-shaped data). `formats[col]` is an Excel number_format string (e.g. `#,##0.00`, `0.0%`, `yyyy-mm`); when absent, date columns default to `yyyy-mm-dd` and string columns to text format (`@`).",
+        "input": [
+          "file",
+          "stdin"
+        ]
+      },
+      {
+        "name": "styles",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Visual operations applied after the typed write, as JSON: top-level `{styles:[...]}`. Each item corresponds to one written sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. The styles array length/order/name must match the written sheets in --sheets.sheets. Run `+table-put --print-schema --flag-name styles` for the full cell_styles field schema.",
+        "input": [
+          "file",
+          "stdin"
+        ]
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": ""
+      }
+    ]
+  },
   "+cells-clear": {
     "risk": "high-risk-write",
     "flags": [

shortcuts/sheets/data/flag-schemas.json

@@ -1,5 +1,5 @@
 {
-  "schema_version": "2",
+  "schema_version": "3",
   "flags": {
     "+batch-update": {
       "operations": {
@@ -44,6 +44,8 @@
                 "+sheet-hide",
                 "+sheet-unhide",
                 "+sheet-set-tab-color",
+                "+sheet-show-gridline",
+                "+sheet-hide-gridline",
                 "+chart-create",
                 "+chart-update",
                 "+chart-delete",
@@ -454,7 +456,7 @@
                       "type": "object"
                     },
                     "link": {
-                      "description": "超链接地址（仅 type='link' 时必填）",
+                      "description": "超链接地址（type='link' 时必填）；@文档 mention（mention_type 非 0）时也必填，传文档 URL（如搜索结果里的文档链接），否则卡片不可点。@人（mention_type=0）不需要传",
                       "type": "string"
                     },
                     "mention_token": {
@@ -462,8 +464,21 @@
                       "type": "string"
                     },
                     "mention_type": {
-                      "description": "@提及类型编号（仅 type='mention' 时可选）",
-                      "type": "number"
+                      "description": "@提及类型编号（仅 type='mention' 时可选）。0 或不填=@用户；@文件时按类型取：1=文档 3=电子表格 8=多维表格 11=思维笔记 12=文件 15=旧版幻灯片 16=知识库 22=新版文档 30=幻灯片 38=画板",
+                      "type": "number",
+                      "enum": [
+                        0,
+                        1,
+                        3,
+                        8,
+                        11,
+                        12,
+                        15,
+                        16,
+                        22,
+                        30,
+                        38
+                      ]
                     },
                     "notify": {
                       "description": "是否发送通知（仅 type='mention' 时可选，默认 true）",
@@ -1730,11 +1745,12 @@
                             },
                             "aggregateType": {
                               "type": "string",
-                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效",
+                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效。count 只统计数值单元格；counta 统计所有非空单元格（含文本），按文本/分类列统计出现次数（如各类别的数量、频次分布）时用 counta。",
                               "enum": [
                                 "sum",
                                 "average",
                                 "count",
+                                "counta",
                                 "min",
                                 "max",
                                 "median"
@@ -1787,11 +1803,7 @@
               "data"
             ]
           }
-        },
-        "required": [
-          "position",
-          "size"
-        ]
+        }
       }
     },
     "+chart-update": {
@@ -2769,11 +2781,12 @@
                             },
                             "aggregateType": {
                               "type": "string",
-                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效",
+                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效。count 只统计数值单元格；counta 统计所有非空单元格（含文本），按文本/分类列统计出现次数（如各类别的数量、频次分布）时用 counta。",
                               "enum": [
                                 "sum",
                                 "average",
                                 "count",
+                                "counta",
                                 "min",
                                 "max",
                                 "median"
@@ -2826,11 +2839,7 @@
               "data"
             ]
           }
-        },
-        "required": [
-          "position",
-          "size"
-        ]
+        }
       }
     },
     "+cond-format-create": {
@@ -6249,6 +6258,744 @@
           }
         }
       }
+    },
+    "+table-put": {
+      "sheets": {
+        "type": "array",
+        "minItems": 1,
+        "description": "一个或多个子表的 typed 数据，每个数组元素写入一张子表；支持多 DataFrame → 多子表一次写入。每个数组项的形状对齐 pandas `df.to_json(orient=\"split\")`：列名走 `columns`、二维取值走 `data`、每列的 pandas dtype 走 `dtypes`、可选的展示格式走 `formats`，并显式带上目标子表名 `name`。pandas 来源直接用 `scripts/sheets_df.py` 的 `df_to_sheet(df, name)` 生成一项，再把 list 包到 `{\"sheets\":[...]}`。",
+        "items": {
+          "type": "object",
+          "required": [
+            "name",
+            "columns",
+            "data"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "目标子表名。按名匹配已有子表；不存在则新建该子表。同一次调用内子表名不可重复。"
+            },
+            "start_cell": {
+              "type": "string",
+              "default": "A1",
+              "description": "写入起点单元格（A1 记法，如 \"B2\"），默认 \"A1\"。mode=append 时忽略其行号、仅沿用其列。"
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "overwrite",
+                "append"
+              ],
+              "default": "overwrite",
+              "description": "overwrite（默认）：从 start_cell 起写「表头 + 数据」块；append：把数据追加到子表已有数据下方（默认不重复表头）。"
+            },
+            "header": {
+              "type": "boolean",
+              "description": "是否写一行列名表头。省略时按 mode 取默认:overwrite→true、append→false（避免在已有表头下重复）；显式给值可覆盖。"
+            },
+            "allow_overwrite": {
+              "type": "boolean",
+              "default": true,
+              "description": "为 false 时，若写入会落在非空单元格则拒写以保护原数据（返回 partial_success）。默认 true。"
+            },
+            "columns": {
+              "type": "array",
+              "minItems": 1,
+              "description": "列名字符串数组，顺序与 `data` 中每行取值一一对应。同一子表内列名不可重复。",
+              "items": {
+                "type": "string"
+              }
+            },
+            "data": {
+              "type": "array",
+              "description": "数据行；每行是一个数组，长度必须等于 `columns` 数。元素按 `dtypes` 推得的列类型取值（date 列写 ISO yyyy-mm-dd 字符串、number 列写数值、bool 列写布尔、其余写文本），null 表示空单元格。",
+              "items": {
+                "type": "array",
+                "items": {
+                  "type": [
+                    "string",
+                    "number",
+                    "boolean",
+                    "null"
+                  ],
+                  "description": "单元格值：date→ISO yyyy-mm-dd 字符串；number→数值（json.Number 精度保留）；bool→布尔；string→文本；null→空单元格。"
+                }
+              }
+            },
+            "dtypes": {
+              "type": "object",
+              "description": "可选。列名 → pandas dtype 字符串的映射；缺失项默认按 object（string + 文本格式 `@`）处理，所以省略整段时整张表按文本写入（导入 CSV-shaped 数据的最简形态）。dtype 解析规则：`int*` / `uint*` / `Int*` / `UInt*` / `float*` / `Float*` / `complex*` → number（精度保留），`bool` / `boolean` → bool，`datetime64[ns]` / 含时区的 `datetime64[ns, UTC]` 等 → date（默认 `yyyy-mm-dd` 格式），`object` / `string` / `category` / 未识别 → string + 文本格式 `@`（数字样字符串如「00123」不会塌缩成数字）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            "formats": {
+              "type": "object",
+              "description": "可选。列名 → Excel number_format 字符串的映射，覆盖 dtype 自带的默认格式（金额 `#,##0.00`、百分比 `0.0%`、自定义日期 `yyyy-mm` 等）。percent 列的数值尺度由调用方负责（0.0469 配 `0.00%` 显示 4.69%）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      },
+      "styles": {
+        "items": {
+          "properties": {
+            "cell_merges": {
+              "description": "单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all。",
+              "items": {
+                "properties": {
+                  "merge_type": {
+                    "enum": [
+                      "all",
+                      "rows",
+                      "columns"
+                    ],
+                    "type": "string"
+                  },
+                  "range": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "cell_styles": {
+              "description": "单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐。",
+              "items": {
+                "properties": {
+                  "background_color": {
+                    "type": "string"
+                  },
+                  "border_styles": {
+                    "type": "object",
+                    "description": "边框配置，结构同 +cells-set-style --border-styles。",
+                    "properties": {
+                      "bottom": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "left": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "right": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "top": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      }
+                    }
+                  },
+                  "font_color": {
+                    "type": "string"
+                  },
+                  "font_line": {
+                    "enum": [
+                      "none",
+                      "underline",
+                      "line-through"
+                    ],
+                    "type": "string"
+                  },
+                  "font_size": {
+                    "type": "number"
+                  },
+                  "font_style": {
+                    "enum": [
+                      "normal",
+                      "italic"
+                    ],
+                    "type": "string"
+                  },
+                  "font_weight": {
+                    "enum": [
+                      "normal",
+                      "bold"
+                    ],
+                    "type": "string"
+                  },
+                  "horizontal_alignment": {
+                    "enum": [
+                      "left",
+                      "center",
+                      "right"
+                    ],
+                    "type": "string"
+                  },
+                  "number_format": {
+                    "type": "string"
+                  },
+                  "range": {
+                    "description": "A1 单元格范围，必须落在该子表本次写入区域内；例如 A1:B1、B2。",
+                    "type": "string"
+                  },
+                  "vertical_alignment": {
+                    "enum": [
+                      "top",
+                      "middle",
+                      "bottom"
+                    ],
+                    "type": "string"
+                  },
+                  "word_wrap": {
+                    "enum": [
+                      "overflow",
+                      "auto-wrap",
+                      "word-clip"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "col_sizes": {
+              "description": "列宽操作数组；range 使用列范围如 A:C，type 为 pixel/standard，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "name": {
+              "description": "子表名。--sheets 模式下必须与同位置 --sheets.sheets[].name 一致；--values 模式下建议写 Sheet1（其 name 会被忽略）。",
+              "type": "string"
+            },
+            "row_sizes": {
+              "description": "行高操作数组；range 使用行范围如 1:3，type 为 pixel/standard/auto，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard",
+                      "auto"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "name"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
+    },
+    "+workbook-create": {
+      "sheets": {
+        "type": "array",
+        "minItems": 1,
+        "description": "一个或多个子表的 typed 数据，每个数组元素写入一张子表；支持多 DataFrame → 多子表一次写入。每个数组项的形状对齐 pandas `df.to_json(orient=\"split\")`：列名走 `columns`、二维取值走 `data`、每列的 pandas dtype 走 `dtypes`、可选的展示格式走 `formats`，并显式带上目标子表名 `name`。pandas 来源直接用 `scripts/sheets_df.py` 的 `df_to_sheet(df, name)` 生成一项，再把 list 包到 `{\"sheets\":[...]}`。",
+        "items": {
+          "type": "object",
+          "required": [
+            "name",
+            "columns",
+            "data"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "目标子表名。按名匹配已有子表；不存在则新建该子表。同一次调用内子表名不可重复。"
+            },
+            "start_cell": {
+              "type": "string",
+              "default": "A1",
+              "description": "写入起点单元格（A1 记法，如 \"B2\"），默认 \"A1\"。mode=append 时忽略其行号、仅沿用其列。"
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "overwrite",
+                "append"
+              ],
+              "default": "overwrite",
+              "description": "overwrite（默认）：从 start_cell 起写「表头 + 数据」块；append：把数据追加到子表已有数据下方（默认不重复表头）。"
+            },
+            "header": {
+              "type": "boolean",
+              "description": "是否写一行列名表头。省略时按 mode 取默认:overwrite→true、append→false（避免在已有表头下重复）；显式给值可覆盖。"
+            },
+            "allow_overwrite": {
+              "type": "boolean",
+              "default": true,
+              "description": "为 false 时，若写入会落在非空单元格则拒写以保护原数据（返回 partial_success）。默认 true。"
+            },
+            "columns": {
+              "type": "array",
+              "minItems": 1,
+              "description": "列名字符串数组，顺序与 `data` 中每行取值一一对应。同一子表内列名不可重复。",
+              "items": {
+                "type": "string"
+              }
+            },
+            "data": {
+              "type": "array",
+              "description": "数据行；每行是一个数组，长度必须等于 `columns` 数。元素按 `dtypes` 推得的列类型取值（date 列写 ISO yyyy-mm-dd 字符串、number 列写数值、bool 列写布尔、其余写文本），null 表示空单元格。",
+              "items": {
+                "type": "array",
+                "items": {
+                  "type": [
+                    "string",
+                    "number",
+                    "boolean",
+                    "null"
+                  ],
+                  "description": "单元格值：date→ISO yyyy-mm-dd 字符串；number→数值（json.Number 精度保留）；bool→布尔；string→文本；null→空单元格。"
+                }
+              }
+            },
+            "dtypes": {
+              "type": "object",
+              "description": "可选。列名 → pandas dtype 字符串的映射；缺失项默认按 object（string + 文本格式 `@`）处理，所以省略整段时整张表按文本写入（导入 CSV-shaped 数据的最简形态）。dtype 解析规则：`int*` / `uint*` / `Int*` / `UInt*` / `float*` / `Float*` / `complex*` → number（精度保留），`bool` / `boolean` → bool，`datetime64[ns]` / 含时区的 `datetime64[ns, UTC]` 等 → date（默认 `yyyy-mm-dd` 格式），`object` / `string` / `category` / 未识别 → string + 文本格式 `@`（数字样字符串如「00123」不会塌缩成数字）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            "formats": {
+              "type": "object",
+              "description": "可选。列名 → Excel number_format 字符串的映射，覆盖 dtype 自带的默认格式（金额 `#,##0.00`、百分比 `0.0%`、自定义日期 `yyyy-mm` 等）。percent 列的数值尺度由调用方负责（0.0469 配 `0.00%` 显示 4.69%）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      },
+      "styles": {
+        "items": {
+          "properties": {
+            "cell_merges": {
+              "description": "单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all。",
+              "items": {
+                "properties": {
+                  "merge_type": {
+                    "enum": [
+                      "all",
+                      "rows",
+                      "columns"
+                    ],
+                    "type": "string"
+                  },
+                  "range": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "cell_styles": {
+              "description": "单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐。",
+              "items": {
+                "properties": {
+                  "background_color": {
+                    "type": "string"
+                  },
+                  "border_styles": {
+                    "type": "object",
+                    "description": "边框配置，结构同 +cells-set-style --border-styles。",
+                    "properties": {
+                      "bottom": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "left": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "right": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "top": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      }
+                    }
+                  },
+                  "font_color": {
+                    "type": "string"
+                  },
+                  "font_line": {
+                    "enum": [
+                      "none",
+                      "underline",
+                      "line-through"
+                    ],
+                    "type": "string"
+                  },
+                  "font_size": {
+                    "type": "number"
+                  },
+                  "font_style": {
+                    "enum": [
+                      "normal",
+                      "italic"
+                    ],
+                    "type": "string"
+                  },
+                  "font_weight": {
+                    "enum": [
+                      "normal",
+                      "bold"
+                    ],
+                    "type": "string"
+                  },
+                  "horizontal_alignment": {
+                    "enum": [
+                      "left",
+                      "center",
+                      "right"
+                    ],
+                    "type": "string"
+                  },
+                  "number_format": {
+                    "type": "string"
+                  },
+                  "range": {
+                    "description": "A1 单元格范围，必须落在该子表本次写入区域内；例如 A1:B1、B2。",
+                    "type": "string"
+                  },
+                  "vertical_alignment": {
+                    "enum": [
+                      "top",
+                      "middle",
+                      "bottom"
+                    ],
+                    "type": "string"
+                  },
+                  "word_wrap": {
+                    "enum": [
+                      "overflow",
+                      "auto-wrap",
+                      "word-clip"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "col_sizes": {
+              "description": "列宽操作数组；range 使用列范围如 A:C，type 为 pixel/standard，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "name": {
+              "description": "子表名。--sheets 模式下必须与同位置 --sheets.sheets[].name 一致；--values 模式下建议写 Sheet1（其 name 会被忽略）。",
+              "type": "string"
+            },
+            "row_sizes": {
+              "description": "行高操作数组；range 使用行范围如 1:3，type 为 pixel/standard/auto，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard",
+                      "auto"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "name"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
     }
   }
 }

shortcuts/sheets/execute_paths_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/output"
 )
 
 // TestExecute_WorkbookInfo_Happy stubs the invoke_read endpoint and
@@ -47,19 +48,132 @@ func TestExecute_WorkbookInfo_ToolError(t *testing.T) {
 			"data": map[string]interface{}{},
 		},
 	}
-	stdout, stderr, err := func() (string, string, error) {
+	_, _, err := func() (string, string, error) {
 		parent, stdout, stderr, reg := newTestRig(t, WorkbookInfo)
 		reg.Register(stub)
 		parent.SetArgs([]string{"+workbook-info", "--url", testURL})
 		err := parent.Execute()
 		return stdout.String(), stderr.String(), err
 	}()
-	if err == nil {
-		t.Fatalf("expected non-zero code to surface as error; stdout=%s stderr=%s", stdout, stderr)
+	p := requireProblem(t, err, errs.CategoryAPI, errs.SubtypeServerError, "")
+	if !strings.Contains(p.Message, "1310201") && !strings.Contains(p.Message, "not found") {
+		t.Errorf("expected error code or message in problem; got message=%q", p.Message)
 	}
-	combined := stdout + stderr + err.Error()
-	if !strings.Contains(combined, "1310201") && !strings.Contains(combined, "not found") {
-		t.Errorf("expected error code in envelope; got=%s|%s|%v", stdout, stderr, err)
+}
+
+// TestExecute_WikiURLResolvesToSheet covers the two-step wiki path: a /wiki/
+// URL is resolved via get_node to its spreadsheet obj_token, which then feeds
+// the tool invoke. The tool stub is keyed on the resolved obj_token, so the
+// test would fail if the node_token were used unresolved.
+func TestExecute_WikiURLResolvesToSheet(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{
+					"obj_type":  "sheet",
+					"obj_token": testToken,
+				},
+			},
+		},
+	}
+	tool := toolOutputStub(testToken, "read", `{"sheets":[{"sheet_id":"sh1","title":"Sheet1","index":0}]}`)
+	out, err := runShortcutWithStubs(t, WorkbookInfo,
+		[]string{"--url", "https://example.feishu.cn/wiki/wikTestNODE"}, getNode, tool)
+	if err != nil {
+		t.Fatalf("execute failed: %v\nout=%s", err, out)
+	}
+	data := decodeEnvelopeData(t, out)
+	if sheets, _ := data["sheets"].([]interface{}); len(sheets) != 1 {
+		t.Fatalf("sheets len = %d, want 1; out=%s", len(sheets), out)
+	}
+}
+
+// TestExecute_WikiURLWrongObjType rejects a wiki node that resolves to a
+// non-spreadsheet obj_type before any tool invoke.
+func TestExecute_WikiURLWrongObjType(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{
+					"obj_type":  "docx",
+					"obj_token": "docABC",
+				},
+			},
+		},
+	}
+	_, err := runShortcutWithStubs(t, WorkbookInfo,
+		[]string{"--url", "https://example.feishu.cn/wiki/wikTestNODE"}, getNode)
+	requireValidation(t, err, "obj_type")
+}
+
+// TestExecute_WikiURLIncompleteNode treats an incomplete get_node response
+// (missing obj_type/obj_token) as an internal/server error, not a user --url
+// validation error.
+func TestExecute_WikiURLIncompleteNode(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{},
+			},
+		},
+	}
+	_, err := runShortcutWithStubs(t, WorkbookInfo,
+		[]string{"--url", "https://example.feishu.cn/wiki/wikTestNODE"}, getNode)
+	if err == nil {
+		t.Fatal("want error for incomplete get_node node data")
+	}
+	var ve *errs.ValidationError
+	if errors.As(err, &ve) {
+		t.Fatalf("incomplete-data error classified as validation (%v); want internal", err)
+	}
+}
+
+// TestExecute_RangeMove_WikiURL guards the transformExecuteFn path: +range-move
+// and +range-copy use a named Execute helper (not an inline func), so they must
+// still resolve a /wiki/ URL to the backing spreadsheet token before calling
+// transform_range. The tool stub is keyed on the resolved obj_token, so an
+// unresolved node_token would miss it and fail this test.
+func TestExecute_RangeMove_WikiURL(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{
+					"obj_type":  "sheet",
+					"obj_token": testToken,
+				},
+			},
+		},
+	}
+	tool := toolOutputStub(testToken, "write", `{"updated_range":"A10:B11"}`)
+	out, err := runShortcutWithStubs(t, RangeMove,
+		[]string{
+			"--url", "https://example.feishu.cn/wiki/wikTestNODE",
+			"--sheet-id", testSheetID,
+			"--source-range", "A1:B2",
+			"--target-range", "A10",
+		}, getNode, tool)
+	if err != nil {
+		t.Fatalf("execute failed: %v\nout=%s", err, out)
 	}
 }
 
@@ -365,14 +479,17 @@ func TestExecute_WorkbookCreate(t *testing.T) {
 			},
 		},
 	}
-	// Initial fill first reads the workbook structure to resolve the default
-	// sheet's id (the create response doesn't echo it), then writes.
+	// The write reads the workbook structure to resolve the default sheet's id
+	// (the create response doesn't echo it). lookupFirstSheetID and
+	// writeTypedSheets' listSheetIDsByName both read it — one reusable stub serves
+	// both. The synthesized sheet is named "Sheet1", matching the default sheet,
+	// so it's adopted in place (no rename).
 	structure := toolOutputStub("shtcnBRAND", "read", `{"sheets":[{"sheet_id":"shtFirst","sheet_name":"Sheet1","index":0}]}`)
+	structure.Reusable = true
 	fill := toolOutputStub("shtcnBRAND", "write", `{"updated_cells":4}`)
 	out, err := runShortcutWithStubs(t, WorkbookCreate, []string{
 		"--title", "Sales",
-		"--headers", `["Name","Score"]`,
-		"--values", `[["alice",95]]`,
+		"--values", `[["Name","Score"],["alice",95]]`,
 	}, create, structure, fill)
 	if err != nil {
 		t.Fatalf("execute failed: %v\nout=%s", err, out)
@@ -382,8 +499,8 @@ func TestExecute_WorkbookCreate(t *testing.T) {
 	if ss["spreadsheet_token"] != "shtcnBRAND" {
 		t.Errorf("spreadsheet_token = %v", ss["spreadsheet_token"])
 	}
-	if data["initial_fill"] == nil {
-		t.Errorf("initial_fill missing in envelope")
+	if sheets, _ := data["sheets"].([]interface{}); len(sheets) != 1 {
+		t.Errorf("sheets summary missing in envelope; got %#v", data["sheets"])
 	}
 	// The fill must target the resolved first sheet, not an empty selector.
 	fillInput := decodeToolInput(t, decodeRawEnvelopeBody(t, fill.CapturedBody), "set_cell_range")
@@ -393,14 +510,13 @@ func TestExecute_WorkbookCreate(t *testing.T) {
 }
 
 // TestExecute_WorkbookCreate_EmptyArraysSkipFill locks the fix for the nil-map
-// panic / illegal-range bug: --values '[]' or --headers '[]' must short-circuit
-// the initial fill (no structure/fill calls fire) and finish with the
-// spreadsheet created but no initial_fill — never panic on a nil fill map.
+// panic / illegal-range bug: --values '[]' must short-circuit the initial fill
+// (no structure/fill calls fire) and finish with the spreadsheet created but no
+// sheets summary — never panic on a nil payload.
 func TestExecute_WorkbookCreate_EmptyArraysSkipFill(t *testing.T) {
 	t.Parallel()
 	for _, tc := range []struct{ name, flag, val string }{
 		{"empty values", "--values", "[]"},
-		{"empty headers", "--headers", "[]"},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
@@ -421,8 +537,8 @@ func TestExecute_WorkbookCreate_EmptyArraysSkipFill(t *testing.T) {
 				t.Fatalf("execute failed: %v\nout=%s", err, out)
 			}
 			data := decodeEnvelopeData(t, out)
-			if data["initial_fill"] != nil {
-				t.Errorf("initial_fill should be absent for %s %s; got %#v", tc.flag, tc.val, data["initial_fill"])
+			if data["sheets"] != nil {
+				t.Errorf("sheets should be absent for %s %s; got %#v", tc.flag, tc.val, data["sheets"])
 			}
 			if ss, _ := data["spreadsheet"].(map[string]interface{}); ss["spreadsheet_token"] != "shtNEW" {
 				t.Errorf("spreadsheet_token = %v, want shtNEW", ss["spreadsheet_token"])
@@ -431,10 +547,14 @@ func TestExecute_WorkbookCreate_EmptyArraysSkipFill(t *testing.T) {
 	}
 }
 
-// TestExecute_WorkbookCreate_FillFailureKeepsToken locks the partial-success
+// TestExecute_WorkbookCreate_FillFailureKeepsToken locks the partial-state
 // contract: when the spreadsheet is created but the follow-up fill can't resolve
-// its first sheet, the error must be structured and retain spreadsheet_token so
-// the caller can recover instead of orphaning the new workbook.
+// its first sheet, the result lands on stdout as an ok:false envelope carrying
+// spreadsheet_token + reason + a structured cause field, and the process exits
+// with the bare partial-failure signal — matching +table-put's tablePutPartial
+// shape so agents see one consistent "side effect landed but follow-up didn't"
+// contract across the sheets domain (instead of the old failed_precondition
+// stderr envelope).
 func TestExecute_WorkbookCreate_FillFailureKeepsToken(t *testing.T) {
 	t.Parallel()
 	create := &httpmock.Stub{
@@ -448,33 +568,41 @@ func TestExecute_WorkbookCreate_FillFailureKeepsToken(t *testing.T) {
 		},
 	}
 	// Structure comes back with no sheets, so lookupFirstSheetID fails AFTER the
-	// spreadsheet already exists — exercising the partial-success path.
+	// spreadsheet already exists — exercising the partial-state path.
 	structure := toolOutputStub("shtNEW", "read", `{"sheets":[]}`)
 	out, err := runShortcutWithStubs(t, WorkbookCreate, []string{"--title", "X", "--values", `[["a"]]`}, create, structure)
 	if err == nil {
-		t.Fatalf("expected a partial-success error; got nil\nout=%s", out)
+		t.Fatalf("expected partial-failure exit signal; got nil. out=%s", out)
 	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error type = %T, want typed problem", err)
+	var pfErr *output.PartialFailureError
+	if !errors.As(err, &pfErr) {
+		t.Fatalf("expected *output.PartialFailureError exit signal; got %T %v", err, err)
 	}
-	if p.Subtype != errs.SubtypeFailedPrecondition {
-		t.Errorf("subtype = %q, want failed_precondition (the spreadsheet exists; caller must change state, not retry)", p.Subtype)
+
+	var env map[string]interface{}
+	if jerr := json.Unmarshal([]byte(out), &env); jerr != nil {
+		t.Fatalf("decode envelope: %v\nraw=%s", jerr, out)
 	}
-	if !strings.Contains(p.Message, "shtNEW") {
-		t.Errorf("message = %q, want spreadsheet token for recovery", p.Message)
+	if ok, _ := env["ok"].(bool); ok {
+		t.Errorf("partial-state envelope must be ok:false; got out=%s", out)
 	}
-	if !strings.Contains(p.Hint, "spreadsheet_token") {
-		t.Errorf("hint = %q, want recovery guidance naming spreadsheet_token", p.Hint)
+	data, _ := env["data"].(map[string]interface{})
+	if got := data["spreadsheet_token"]; got != "shtNEW" {
+		t.Errorf("spreadsheet_token = %v, want shtNEW (recovery requires the token to be in the envelope)", got)
 	}
-	// The underlying fill failure is preserved as the cause so its subtype and
-	// log_id stay diagnosable rather than being flattened into the message.
-	inner := errors.Unwrap(err)
-	if inner == nil {
-		t.Fatalf("expected the underlying fill failure preserved as the cause")
+	reason, _ := data["reason"].(string)
+	if !strings.Contains(reason, "shtNEW") {
+		t.Errorf("reason = %q, want the spreadsheet token named for recovery", reason)
 	}
-	if ip, ok := errs.ProblemOf(inner); !ok || ip.Subtype != errs.SubtypeInvalidResponse {
-		t.Errorf("cause = %v, want the underlying invalid_response failure preserved for diagnosis", inner)
+	hint, _ := data["hint"].(string)
+	if !strings.Contains(hint, "spreadsheet_token") {
+		t.Errorf("hint = %q, want recovery guidance naming spreadsheet_token", hint)
+	}
+	// The underlying fill failure's typed shape is flattened into the cause
+	// field so the inner subtype stays diagnosable from the JSON envelope alone.
+	cause, _ := data["cause"].(map[string]interface{})
+	if got := cause["subtype"]; got != string(errs.SubtypeInvalidResponse) {
+		t.Errorf("cause.subtype = %v, want the underlying invalid_response subtype", got)
 	}
 }
 

shortcuts/sheets/flag_defs.go

@@ -80,3 +80,28 @@ func flagsFor(command string) []common.Flag {
 	}
 	return out
 }
+
+// flagAcceptsStdin reports whether the (command, flag) pair declares stdin as
+// an input source in flag-defs.json. Used to decide whether an "invalid JSON"
+// error should also steer the caller toward stdin. It runs on an error path,
+// so it returns false for an unknown command/flag rather than panicking the
+// way flagsFor does.
+func flagAcceptsStdin(command, name string) bool {
+	defs, _ := loadFlagDefs()
+	spec, ok := defs[command]
+	if !ok {
+		return false
+	}
+	for _, df := range spec.Flags {
+		if df.Name != name {
+			continue
+		}
+		for _, in := range df.Input {
+			if in == common.Stdin {
+				return true
+			}
+		}
+		return false
+	}
+	return false
+}

shortcuts/sheets/flag_defs_gen.go

@@ -75,7 +75,7 @@ var flagDefs = map[string]commandDef{
 			{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: "A1 range, e.g. `A1:F10` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet)"},
 			{Name: "include", Kind: "own", Type: "string_slice", Required: "optional", Desc: "Comma-separated info categories to include", Enum: []string{"value", "formula", "style", "comment", "data_validation"}},
-			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Safety cap; default 200000", Default: "200000", Hidden: true},
+			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more", Default: "500000"},
 			{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"},
 		},
@@ -305,10 +305,9 @@ 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: "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: "Safety cap; default 200000", Default: "200000", Hidden: true},
+			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more", Default: "500000"},
 			{Name: "include-row-prefix", Kind: "own", Type: "bool", Required: "optional", Desc: "Whether to prefix each row with `[row=N]`; default `true`", Default: "true"},
 			{Name: "skip-hidden", Kind: "own", Type: "bool", Required: "optional", Desc: "Skip hidden rows and columns; default `false`"},
-			{Name: "rows-json", Kind: "own", Type: "bool", Required: "optional", Desc: "Return structured rows ({row_number, values:{col→cell}}) instead of CSV text; default false", Default: "false"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request path and parameters without executing"},
 		},
 	},
@@ -320,7 +319,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: "start-cell", Kind: "own", Type: "string", Required: "required", Desc: "Top-left A1 anchor (e.g. `A1`, `B5`; no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet); must be a single cell, range notation not accepted; the bottom-right is inferred from CSV row/column counts", Default: "A1"},
-			{Name: "csv", Kind: "own", Type: "string", Required: "required", Desc: "RFC 4180 CSV text; plain values only (no formulas / styles / comments)", Input: []string{"file", "stdin"}},
+			{Name: "csv", Kind: "own", Type: "string", Required: "required", Desc: "RFC 4180 CSV text; values or formulas (a leading = is evaluated as a formula); no styles / comments / images (use +cells-set for those).", Input: []string{"file", "stdin"}},
 			{Name: "allow-overwrite", Kind: "own", Type: "bool", Required: "optional", Desc: "Allow overwriting (default true); set false to error if any target cell is non-empty", Default: "true"},
 			{Name: "range", Kind: "own", Type: "string", Required: "optional", Desc: "alias for --start-cell (parity with +csv-get / +cells-set, which locate with --range); a range like A1:H17 collapses to its top-left cell", Hidden: true},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
@@ -766,7 +765,7 @@ var flagDefs = map[string]commandDef{
 			{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: "title", Kind: "own", Type: "string", Required: "required", Desc: "New sheet title"},
-			{Name: "index", Kind: "own", Type: "int", Required: "optional", Desc: "Insert position; appended to the end when omitted", Default: "-1"},
+			{Name: "index", Kind: "own", Type: "int", Required: "optional", Desc: "Insert position (0-based); appended to the end when omitted", Default: "-1"},
 			{Name: "row-count", Kind: "own", Type: "int", Required: "optional", Desc: "Initial row count (default 200, max 50000)", Default: "200"},
 			{Name: "col-count", Kind: "own", Type: "int", Required: "optional", Desc: "Initial column count (default 20, max 200)", Default: "20"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
@@ -793,6 +792,16 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+sheet-hide-gridline": {
+		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: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
 	"+sheet-info": {
 		Risk: "read",
 		Flags: []flagDef{
@@ -839,6 +848,16 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+sheet-show-gridline": {
+		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: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
 	"+sheet-unhide": {
 		Risk: "write",
 		Flags: []flagDef{
@@ -895,13 +914,36 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+table-get": {
+		Risk: "read",
+		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: "own", Type: "string", Required: "optional", Desc: "Read only this sheet (by id); omit to read all sheets"},
+			{Name: "sheet-name", Kind: "own", Type: "string", Required: "optional", Desc: "Read only this sheet (by name); omit to read all sheets"},
+			{Name: "range", Kind: "own", Type: "string", Required: "optional", Desc: "A1 range to read; omit to read each sheet's full used range (spans internal blank rows/columns, not just the A1 current region)"},
+			{Name: "no-header", Kind: "own", Type: "bool", Required: "optional", Desc: "Treat the first row as data instead of a header (columns get positional names col1, col2, ...)"},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
+	"+table-put": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL to write into (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token to write into (XOR with `--url`)"},
+			{Name: "sheets", Kind: "own", Type: "string", Required: "required", Desc: "Typed table payload (pandas-DataFrame-shaped) as JSON: top-level `{\"sheets\":[...]}`, with each array item a sub-sheet `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}` — `name` and the outer `sheets` envelope are both required. Agents typically use `df_to_sheet(df, name)` from `scripts/sheets_df.py` to pack each DataFrame into one item, then wrap the list in `{\"sheets\":[...]}`. `dtypes` values are pandas dtype strings (`int64`, `float64`, `Int64`, `bool`, `boolean`, `datetime64[ns]`, `object`, ...); the writer maps them to internal string/number/date/bool — omit `dtypes` and a column writes as text (good for raw CSV-shaped data). `formats[col]` is an Excel number_format string (e.g. `#,##0.00`, `0.0%`, `yyyy-mm`); when absent, date columns default to `yyyy-mm-dd` and string columns to text format (`@`).", Input: []string{"file", "stdin"}},
+			{Name: "styles", Kind: "own", Type: "string", Required: "optional", Desc: "Visual operations applied after the typed write, as JSON: top-level `{styles:[...]}`. Each item corresponds to one written sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. The styles array length/order/name must match the written sheets in --sheets.sheets. Run `+table-put --print-schema --flag-name styles` for the full cell_styles field schema.", Input: []string{"file", "stdin"}},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
 	"+workbook-create": {
 		Risk: "write",
 		Flags: []flagDef{
 			{Name: "title", Kind: "own", Type: "string", Required: "required", Desc: "Spreadsheet title"},
 			{Name: "folder-token", Kind: "own", Type: "string", Required: "optional", Desc: "Target folder token; placed at the drive root when omitted"},
-			{Name: "headers", Kind: "own", Type: "string", Required: "optional", Desc: "Header row as a JSON array: `[\"Col A\",\"Col B\"]`", Input: []string{"file", "stdin"}},
-			{Name: "values", Kind: "own", Type: "string", Required: "optional", Desc: "Initial data as a 2D JSON array: `[[\"alice\",95]]`", Input: []string{"file", "stdin"}},
+			{Name: "values", Kind: "own", Type: "string", Required: "optional", Desc: "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected, through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes", Input: []string{"file", "stdin"}},
+			{Name: "sheets", Kind: "own", Type: "string", Required: "optional", Desc: "Typed table payload as JSON (same shape as `+table-put`): top-level `{\"sheets\":[...]}`, with each array item a sub-sheet `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}` — `name` and the outer `sheets` envelope are both required. Agents typically use `df_to_sheet(df, name)` from `scripts/sheets_df.py` to pack each DataFrame into one item, then wrap the list in `{\"sheets\":[...]}`. Mutually exclusive with --values. Creates the workbook, then writes typed type-faithful data (dates land as real dates, numbers keep precision).", Input: []string{"file", "stdin"}},
+			{Name: "styles", Kind: "own", Type: "string", Required: "optional", Desc: "Initial visual operations as JSON: top-level `{styles:[...]}`. Each item corresponds to one target sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. With --sheets, styles array length/order/name must match --sheets.sheets. With --values, pass exactly one styles item for the initial sheet (its name is ignored).", Input: []string{"file", "stdin"}},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -912,10 +954,18 @@ var flagDefs = map[string]commandDef{
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "file-extension", Kind: "own", Type: "string", Required: "optional", Desc: "Export file format; `csv` mode requires `--sheet-id`", Default: "xlsx", Enum: []string{"xlsx", "csv"}},
 			{Name: "sheet-id", Kind: "own", Type: "string", Required: "optional", Desc: "Required only in csv mode: which sheet to export as CSV. This is a `+workbook-export`-specific flag, unrelated to the common four-tuple sheet locator (this shortcut does not accept the common sheet locator)"},
-			{Name: "output-path", Kind: "own", Type: "string", Required: "optional", Desc: "Local save path; export is triggered but not downloaded when omitted"},
+			{Name: "output-path", Kind: "own", Type: "string", Required: "optional", Desc: "Local save path. When omitted, **only the export task is triggered + polled, the file is NOT downloaded** (returns file_token / status so a later step can resume the download). Pass a concrete path (e.g. `./out.xlsx`) or a directory (`.` keeps the server-provided filename) to download. Note: the equivalent `lark-cli drive +export --doc-type sheet` uses three separate flags (`--output-dir` / `--file-name` / `--overwrite`) and defaults to downloading into the current directory; this wrapper collapses them into a single `--output-path` for ergonomics but defaults to no-download — fall back to `drive +export` if the split flag set fits better."},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+workbook-import": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "file", Kind: "own", Type: "string", Required: "required", Desc: "Local file path (.xlsx / .xls / .csv)"},
+			{Name: "folder-token", Kind: "own", Type: "string", Required: "optional", Desc: "Target folder token; imported to the cloud drive root when omitted"},
+			{Name: "name", Kind: "own", Type: "string", Required: "optional", Desc: "Imported spreadsheet name; defaults to the local file name without its extension"},
+		},
+	},
 	"+workbook-info": {
 		Risk: "read",
 		Flags: []flagDef{

shortcuts/sheets/flag_defs_test.go

@@ -65,9 +65,9 @@ func TestFlagsFor_MapsAllFields(t *testing.T) {
 	if url == nil || url.Required {
 		t.Errorf("+sheet-create --url should not be cobra-required: %+v", url)
 	}
-	// hidden + int default
+	// visible + int default
 	cap := byName("+cells-get", "max-chars")
-	if cap == nil || !cap.Hidden || cap.Default != "200000" {
+	if cap == nil || cap.Hidden || cap.Default != "500000" {
 		t.Errorf("+cells-get --max-chars not mapped: %+v", cap)
 	}
 	// input sources
@@ -140,3 +140,24 @@ func TestFlagsFor_EveryRegisteredCommandHasDefs(t *testing.T) {
 		}
 	}
 }
+
+// TestFlagAcceptsStdin verifies the stdin-capability probe that decides whether
+// an "invalid JSON" error should also steer the caller toward stdin: a composite
+// flag (cells) accepts stdin, a plain locator (spreadsheet-token) does not, and
+// an unknown command/flag returns false without panicking (it runs on an error
+// path, unlike flagsFor).
+func TestFlagAcceptsStdin(t *testing.T) {
+	t.Parallel()
+	if !flagAcceptsStdin("+cells-set", "cells") {
+		t.Error("+cells-set --cells should accept stdin")
+	}
+	if flagAcceptsStdin("+cells-set", "spreadsheet-token") {
+		t.Error("--spreadsheet-token should not accept stdin")
+	}
+	if flagAcceptsStdin("+nope", "cells") {
+		t.Error("unknown command should be false (and must not panic)")
+	}
+	if flagAcceptsStdin("+cells-set", "nope") {
+		t.Error("unknown flag should be false")
+	}
+}

shortcuts/sheets/flag_schema.go

@@ -9,6 +9,8 @@ import (
 	"fmt"
 	"sort"
 	"sync"
+
+	"github.com/larksuite/cli/errs"
 )
 
 // ─── --print-schema runtime introspection ─────────────────────────────
@@ -91,7 +93,7 @@ func printFlagSchemaFor(command string) func(flagName string) ([]byte, error) {
 		}
 		entry, ok := idx.Flags[command]
 		if !ok || len(entry) == 0 {
-			return nil, fmt.Errorf("no JSON Schema registered for %s", command)
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "no JSON Schema registered for %s", command)
 		}
 		if flagName == "" {
 			flags := make([]string, 0, len(entry))
@@ -112,7 +114,9 @@ func printFlagSchemaFor(command string) func(flagName string) ([]byte, error) {
 				flags = append(flags, f)
 			}
 			sort.Strings(flags)
-			return nil, fmt.Errorf("no JSON Schema registered for %s --%s; available: %v", command, flagName, flags)
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"no JSON Schema registered for %s --%s; available: %v", command, flagName, flags).
+				WithParam("--flag-name")
 		}
 		// Reformat for readability — schema files store compact JSON.
 		var pretty interface{}

shortcuts/sheets/flag_schema_test.go

@@ -84,12 +84,12 @@ func TestPrintFlagSchema_NamedFlagReturnsSchemaSubtree(t *testing.T) {
 func TestPrintFlagSchema_UnknownFlagListsAvailable(t *testing.T) {
 	t.Parallel()
 	_, err := printFlagSchemaFor("+chart-create")("does-not-exist")
-	if err == nil {
-		t.Fatal("expected error for unknown flag, got nil")
+	ve := requireValidation(t, err, "+chart-create")
+	if !strings.Contains(ve.Message, "properties") {
+		t.Errorf("message should list available flags; got %q", ve.Message)
 	}
-	msg := err.Error()
-	if !strings.Contains(msg, "+chart-create") || !strings.Contains(msg, "properties") {
-		t.Errorf("error should mention shortcut + available flags; got %q", msg)
+	if ve.Param != "--flag-name" {
+		t.Errorf("param = %q, want --flag-name", ve.Param)
 	}
 }
 

shortcuts/sheets/flag_schema_validate.go

@@ -63,6 +63,7 @@ func validateParsedJSONFlag(fv flagView, name string, value interface{}) error {
 var parseJSONFlagSkip = map[string]struct{}{
 	"properties": {},
 	"operations": {},
+	"styles":     {},
 }
 
 // validateValueAgainstSchema is the (command, flag) → schema → check
@@ -93,7 +94,17 @@ func validateValueAgainstSchema(fv flagView, name string, value interface{}) err
 	var schema schemaProperty
 	json.Unmarshal(raw, &schema)
 	if vErr := validateAgainstSchema(value, &schema, ""); vErr != nil {
-		return sheetsValidationForFlag(name, "--%s: %s", name, vErr.Error())
+		// 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.
+		// Point them straight at --print-schema, which dumps the exact JSON
+		// Schema for this (command, flag) pair. The hint is always actionable:
+		// reaching this branch means entry[name] resolved a schema from the
+		// embedded index, and --print-schema reads that same index, so the
+		// suggested command is guaranteed to print it.
+		return sheetsValidationForFlag(name,
+			"--%s: %s; run `lark-cli sheets %s --print-schema --flag-name %s` to see the expected JSON Schema",
+			name, vErr.Error(), command, name).WithCause(vErr)
 	}
 	return nil
 }

shortcuts/sheets/flag_schema_validate_test.go

@@ -478,11 +478,9 @@ func TestValidateInputAgainstSchema_RealSchema(t *testing.T) {
 		},
 	}
 	err := validateInputAgainstSchema(fv, bad)
-	if err == nil {
-		t.Fatal("expected enum violation, got nil")
-	}
-	if !strings.Contains(err.Error(), "summarize_by") || !strings.Contains(err.Error(), "not in enum") {
-		t.Errorf("error = %q, want summarize_by + enum hint", err.Error())
+	ve := requireValidation(t, err, "summarize_by")
+	if !strings.Contains(ve.Message, "not in enum") {
+		t.Errorf("error = %q, want enum hint", ve.Message)
 	}
 }
 
@@ -499,11 +497,9 @@ func TestValidateInputAgainstSchema_RealMinItems(t *testing.T) {
 		},
 	}
 	err := validateInputAgainstSchema(fv, bad)
-	if err == nil {
-		t.Fatal("expected minItems violation for empty values, got nil")
-	}
-	if !strings.Contains(err.Error(), "values") || !strings.Contains(err.Error(), "minimum is 1") {
-		t.Errorf("error = %q, want values + minimum-is-1 hint", err.Error())
+	ve := requireValidation(t, err, "values")
+	if !strings.Contains(ve.Message, "minimum is 1") {
+		t.Errorf("error = %q, want minimum-is-1 hint", ve.Message)
 	}
 }
 
@@ -520,11 +516,9 @@ func TestValidateInputAgainstSchema_RealMinimum(t *testing.T) {
 		},
 	}
 	err := validateInputAgainstSchema(fv, bad)
-	if err == nil {
-		t.Fatal("expected minimum violation for row:-1, got nil")
-	}
-	if !strings.Contains(err.Error(), "row") || !strings.Contains(err.Error(), "below minimum") {
-		t.Errorf("error = %q, want row + below-minimum hint", err.Error())
+	ve := requireValidation(t, err, "row")
+	if !strings.Contains(ve.Message, "below minimum") {
+		t.Errorf("error = %q, want below-minimum hint", ve.Message)
 	}
 }
 
@@ -554,11 +548,9 @@ func TestValidateInputAgainstSchema_RealAdditionalProperties(t *testing.T) {
 		},
 	}
 	err := validateInputAgainstSchema(fv, bad)
-	if err == nil {
-		t.Fatal("expected additionalProperties violation, got nil")
-	}
-	if !strings.Contains(err.Error(), "collapse") || !strings.Contains(err.Error(), `expected type "string"`) {
-		t.Errorf("error = %q, want collapse + string-type hint", err.Error())
+	ve := requireValidation(t, err, "collapse")
+	if !strings.Contains(ve.Message, `expected type "string"`) {
+		t.Errorf("error = %q, want string-type hint", ve.Message)
 	}
 }
 
@@ -587,3 +579,24 @@ func TestValidateInputAgainstSchema_SkipOperations(t *testing.T) {
 		t.Errorf("operations should be skipped; got %v", err)
 	}
 }
+
+// TestValidateValueAgainstSchema_PrintSchemaHint pins the highest-value
+// recovery affordance for composite-JSON flags: when the shape is wrong, the
+// error must point the agent straight at --print-schema (with the right
+// command + flag) instead of leaving it to guess across retries. +cells-set
+// --cells expects a 2-D array; a bare string trips the top-level type check.
+func TestValidateValueAgainstSchema_PrintSchemaHint(t *testing.T) {
+	t.Parallel()
+	fv := mapFlagView{command: "+cells-set"}
+	err := validateValueAgainstSchema(fv, "cells", "not-an-array")
+	// Underlying shape error is preserved (substring callers still match).
+	ve := requireValidation(t, err, `expected type "array"`)
+	// And the actionable --print-schema hint is appended with the exact
+	// command + flag, so a copy-paste fetches the schema for this pair.
+	if !strings.Contains(ve.Message, "lark-cli sheets +cells-set --print-schema --flag-name cells") {
+		t.Errorf("want --print-schema hint with command+flag; got %q", ve.Message)
+	}
+	if ve.Param != "--cells" {
+		t.Errorf("param = %q, want --cells", ve.Param)
+	}
+}

shortcuts/sheets/flag_schemas_gen.go

@@ -32,4 +32,6 @@ var commandsWithSchema = map[string]struct{}{
 	"+range-sort":            {},
 	"+sparkline-create":      {},
 	"+sparkline-update":      {},
+	"+table-put":             {},
+	"+workbook-create":       {},
 }

shortcuts/sheets/helpers.go

@@ -10,6 +10,8 @@ package sheets
 import (
 	"context"
 	"encoding/json"
+	"fmt"
+	neturl "net/url"
 	"strings"
 
 	"github.com/larksuite/cli/errs"
@@ -48,46 +50,151 @@ func sheetsInputStatError(flag string, err error) error {
 	return wrapped
 }
 
-// resolveSpreadsheetToken applies the public --url / --spreadsheet-token XOR
-// pair shared by every sheets canonical shortcut and returns the resolved
-// token. Network-free, safe to call from Validate and DryRun.
-func resolveSpreadsheetToken(runtime *common.RuntimeContext) (string, error) {
+// spreadsheetRef classification: a --url / --spreadsheet-token input names a
+// spreadsheet either directly (a /sheets/ URL or raw token) or indirectly via a
+// wiki node that must be resolved to its backing spreadsheet at Execute time.
+const (
+	spreadsheetRefSheet = "sheet"
+	spreadsheetRefWiki  = "wiki"
+)
+
+// spreadsheetRef is a parsed --url / --spreadsheet-token input. A wiki ref holds
+// the still-unresolved wiki node_token; resolveSpreadsheetTokenExec turns it
+// into the real spreadsheet token at Execute time.
+type spreadsheetRef struct {
+	Kind  string // spreadsheetRefSheet | spreadsheetRefWiki
+	Token string
+}
+
+// parseSpreadsheetRef applies the public --url / --spreadsheet-token XOR pair and
+// classifies the input. Network-free, safe to call from Validate and DryRun.
+//
+// Recognized --url shapes:
+//   - https://.../sheets/<token>        → {sheet, token}
+//   - https://.../spreadsheets/<token>  → {sheet, token}
+//   - https://.../wiki/<node_token>     → {wiki, node_token}  (resolved at Execute)
+//
+// A raw --spreadsheet-token is always treated as a spreadsheet token; wiki nodes
+// only ever arrive as a /wiki/ URL.
+func parseSpreadsheetRef(runtime *common.RuntimeContext) (spreadsheetRef, error) {
 	if err := common.ExactlyOneTyped(runtime, "url", "spreadsheet-token"); err != nil {
-		return "", err
+		return spreadsheetRef{}, err
 	}
 	if token := strings.TrimSpace(runtime.Str("spreadsheet-token")); token != "" {
 		if err := validate.RejectControlChars(token, "spreadsheet-token"); err != nil {
-			return "", sheetsValidationCauseForFlag("spreadsheet-token", err)
+			return spreadsheetRef{}, sheetsValidationCauseForFlag("spreadsheet-token", err)
 		}
-		return token, nil
+		return spreadsheetRef{Kind: spreadsheetRefSheet, Token: token}, nil
 	}
 
-	url := strings.TrimSpace(runtime.Str("url"))
-	token := extractSpreadsheetToken(url)
-	if token == "" || token == url {
-		return "", sheetsValidationForFlag("url", "--url must be a spreadsheet URL like https://.../sheets/<token>")
+	rawURL := strings.TrimSpace(runtime.Str("url"))
+	token, kind, ok := spreadsheetURLToken(rawURL)
+	if !ok {
+		return spreadsheetRef{}, sheetsValidationForFlag("url", "--url must be a spreadsheet URL like https://.../sheets/<token> or a wiki URL like https://.../wiki/<token>")
 	}
 	if err := validate.RejectControlChars(token, "url"); err != nil {
-		return "", sheetsValidationCauseForFlag("url", err)
+		return spreadsheetRef{}, sheetsValidationCauseForFlag("url", err)
 	}
-	return token, nil
+	return spreadsheetRef{Kind: kind, Token: token}, nil
 }
 
-// extractSpreadsheetToken pulls the token segment out of a /sheets/<token>
-// or /spreadsheets/<token> URL. Returns the input unchanged when no known
-// prefix is present (callers must check token != originalInput).
-func extractSpreadsheetToken(input string) string {
-	input = strings.TrimSpace(input)
-	for _, prefix := range []string{"/sheets/", "/spreadsheets/"} {
-		if idx := strings.Index(input, prefix); idx >= 0 {
-			token := input[idx+len(prefix):]
-			if idx2 := strings.IndexAny(token, "/?#"); idx2 >= 0 {
-				token = token[:idx2]
-			}
-			return token
+// spreadsheetURLToken extracts the token and its kind from a Lark URL, matching
+// only on the URL *path* segment (parsed via net/url). A /wiki/ or /sheets/ that
+// appears only in the query or fragment (e.g. a redirect or anchor param) never
+// hijacks classification. Returns ok=false when no known prefix heads the path.
+func spreadsheetURLToken(rawURL string) (token, kind string, ok bool) {
+	u, err := neturl.Parse(rawURL)
+	if err != nil || u.Path == "" {
+		return "", "", false
+	}
+	for _, m := range []struct {
+		prefix string
+		kind   string
+	}{
+		{"/sheets/", spreadsheetRefSheet},
+		{"/spreadsheets/", spreadsheetRefSheet},
+		{"/wiki/", spreadsheetRefWiki},
+	} {
+		if seg, found := pathSegmentAfter(u.Path, m.prefix); found {
+			return seg, m.kind, true
 		}
 	}
-	return input
+	return "", "", false
+}
+
+// pathSegmentAfter returns the first path segment after prefix when path begins
+// with prefix, else ("", false).
+func pathSegmentAfter(path, prefix string) (string, bool) {
+	if !strings.HasPrefix(path, prefix) {
+		return "", false
+	}
+	rest := path[len(prefix):]
+	if i := strings.IndexByte(rest, '/'); i >= 0 {
+		rest = rest[:i]
+	}
+	rest = strings.TrimSpace(rest)
+	if rest == "" {
+		return "", false
+	}
+	return rest, true
+}
+
+// resolveSpreadsheetToken applies the public --url / --spreadsheet-token XOR pair
+// and returns the resolved token. Network-free, safe to call from Validate and
+// DryRun.
+//
+// A /wiki/ URL yields the still-unresolved wiki node_token: turning it into the
+// backing spreadsheet token needs a get_node call, which only Execute may make.
+// Validate/DryRun only need a non-empty, control-char-clean token, so the
+// node_token passes through unchanged here; Execute paths call
+// resolveSpreadsheetTokenExec instead.
+func resolveSpreadsheetToken(runtime *common.RuntimeContext) (string, error) {
+	ref, err := parseSpreadsheetRef(runtime)
+	if err != nil {
+		return "", err
+	}
+	return ref.Token, nil
+}
+
+// resolveSpreadsheetTokenExec is the Execute-time counterpart of
+// resolveSpreadsheetToken: it additionally resolves a /wiki/ URL's node_token to
+// the backing spreadsheet token via wiki get_node, verifying obj_type=sheet.
+// Non-wiki inputs make no API call. Use this from every sheets Execute hook and
+// keep resolveSpreadsheetToken in Validate/DryRun so those stay network-free.
+func resolveSpreadsheetTokenExec(runtime *common.RuntimeContext) (string, error) {
+	ref, err := parseSpreadsheetRef(runtime)
+	if err != nil {
+		return "", err
+	}
+	if ref.Kind != spreadsheetRefWiki {
+		return ref.Token, nil
+	}
+	return resolveWikiNodeToSpreadsheetToken(runtime, ref.Token)
+}
+
+// resolveWikiNodeToSpreadsheetToken resolves a wiki node_token to the spreadsheet
+// obj_token it points at, erroring when the node is not a spreadsheet. The
+// wiki:node:read scope is only needed on this path, so it is enforced here rather
+// than declared unconditionally on every sheets shortcut.
+func resolveWikiNodeToSpreadsheetToken(runtime *common.RuntimeContext, nodeToken string) (string, error) {
+	if err := runtime.EnsureScopes([]string{"wiki:node:read"}); err != nil {
+		return "", err
+	}
+	data, err := runtime.CallAPITyped("GET", "/open-apis/wiki/v2/spaces/get_node",
+		map[string]interface{}{"token": nodeToken}, nil)
+	if err != nil {
+		return "", err
+	}
+	node := common.GetMap(data, "node")
+	objType := common.GetString(node, "obj_type")
+	objToken := common.GetString(node, "obj_token")
+	if objType == "" || objToken == "" {
+		return "", errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki get_node returned incomplete node data for %q", nodeToken)
+	}
+	if objType != "sheet" {
+		return "", sheetsValidationForFlag("url", "wiki URL resolves to obj_type=%q, but a spreadsheet (obj_type=sheet) is required", objType)
+	}
+	return objToken, nil
 }
 
 // resolveSheetSelector validates the --sheet-id / --sheet-name XOR and
@@ -241,6 +348,16 @@ func parseJSONFlag(runtime flagView, name string) (interface{}, error) {
 	}
 	var out interface{}
 	if err := json.Unmarshal([]byte(raw), &out); err != nil {
+		// Composite payloads that embed formulas / quotes / commas are the
+		// classic source of this error: inlined into the shell, the JSON gets
+		// mangled (e.g. `\$` → "invalid character in string escape"). For any
+		// flag that accepts stdin, steer the caller there — passing the payload
+		// via `--<flag> - < file` sidesteps shell escaping entirely.
+		if flagAcceptsStdin(runtime.Command(), name) {
+			return nil, sheetsValidationForFlag(name,
+				"--%s: invalid JSON: %v; if the payload contains formulas / quotes / commas, pass it via stdin (`--%s - < file`) so the shell doesn't mangle the JSON",
+				name, err, name).WithCause(err)
+		}
 		return nil, sheetsValidationForFlag(name, "--%s: invalid JSON: %v", name, err).WithCause(err)
 	}
 	// Schema-driven flag validation at the user-input boundary. Skips
@@ -325,6 +442,72 @@ func buildCellStyleFromFlags(runtime flagView) map[string]interface{} {
 	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.
+// 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
+			}
+			st, ok := cell["cell_styles"].(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if err := normalizeCellStyleAliases(st, fmt.Sprintf("%s[%d][%d].cell_styles", path, r, c)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // borderStylesFromFlag parses --border-styles as a JSON object (top/bottom/
 // left/right with style sub-objects). Returns nil when the flag is empty.
 func borderStylesFromFlag(runtime flagView) (map[string]interface{}, error) {

shortcuts/sheets/helpers_test.go

@@ -81,6 +81,53 @@ func runShortcutWithStubs(t *testing.T, sc common.Shortcut, args []string, stubs
 	return stdout.String(), err
 }
 
+// requireProblem asserts err carries a typed errs.Problem with the given
+// category and (optional) subtype, and that its message contains msgContains
+// (skip the message check by passing ""). Returns the Problem so callers can
+// drill into the typed envelope's category-specific fields (e.g. cast to
+// *errs.ValidationError to read .Param / .Params / .Cause).
+//
+// Replaces the older "strings.Contains(stdout+stderr+err.Error(), ...)" pattern
+// across sheets tests: substring on a rendered envelope was brittle (any
+// message tweak silently broke it) and didn't verify that the typed contract —
+// category / subtype / cause preservation — held. Per coding guideline
+// "Error-path tests must assert typed metadata via errs.ProblemOf
+// (category / subtype / param) and cause preservation, not message substrings
+// alone."
+func requireProblem(t *testing.T, err error, wantCategory errs.Category, wantSubtype errs.Subtype, msgContains string) *errs.Problem {
+	t.Helper()
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error carrying errs.Problem, got %T: %v", err, err)
+	}
+	if p.Category != wantCategory {
+		t.Errorf("category = %q, want %q (err=%v)", p.Category, wantCategory, err)
+	}
+	if wantSubtype != "" && p.Subtype != wantSubtype {
+		t.Errorf("subtype = %q, want %q (err=%v)", p.Subtype, wantSubtype, err)
+	}
+	if msgContains != "" && !strings.Contains(p.Message, msgContains) {
+		t.Errorf("message = %q, want containing %q", p.Message, msgContains)
+	}
+	return p
+}
+
+// requireValidation is shorthand for the most common case: a typed
+// CategoryValidation error with SubtypeInvalidArgument. Returns the
+// *errs.ValidationError so callers can also assert on .Param / .Params / .Cause.
+func requireValidation(t *testing.T, err error, msgContains string) *errs.ValidationError {
+	t.Helper()
+	requireProblem(t, err, errs.CategoryValidation, errs.SubtypeInvalidArgument, msgContains)
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
+	}
+	return ve
+}
+
 func TestSheetHelpersValidationMetadata(t *testing.T) {
 	t.Parallel()
 
@@ -268,3 +315,52 @@ const (
 	testSheetID  = "shtSubA"
 	testSheetID2 = "shtSubB"
 )
+
+// TestParseSpreadsheetRef locks the network-free classification of
+// --url / --spreadsheet-token into a sheet token vs an (unresolved) wiki
+// node_token. The wiki node is resolved later, at Execute time only.
+func TestParseSpreadsheetRef(t *testing.T) {
+	t.Parallel()
+	mk := func(url, tok string) *common.RuntimeContext {
+		cmd := &cobra.Command{Use: "sheets"}
+		cmd.Flags().String("url", url, "")
+		cmd.Flags().String("spreadsheet-token", tok, "")
+		return common.TestNewRuntimeContext(cmd, testConfig(t))
+	}
+	cases := []struct {
+		name      string
+		url       string
+		tok       string
+		wantKind  string
+		wantToken string
+		wantErr   bool
+	}{
+		{name: "sheets url", url: "https://x.feishu.cn/sheets/shtABC", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "spreadsheets url", url: "https://x.feishu.cn/spreadsheets/shtABC", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "wiki url", url: "https://x.feishu.cn/wiki/wikDEF", wantKind: spreadsheetRefWiki, wantToken: "wikDEF"},
+		{name: "wiki url with query", url: "https://x.feishu.cn/wiki/wikDEF?sheet=xxxxxx", wantKind: spreadsheetRefWiki, wantToken: "wikDEF"},
+		{name: "raw token", tok: "shtRAW", wantKind: spreadsheetRefSheet, wantToken: "shtRAW"},
+		{name: "sheets url with /wiki/ in query stays sheet", url: "https://x.feishu.cn/sheets/shtABC?from=/wiki/wikX", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "sheets url with /wiki/ in fragment stays sheet", url: "https://x.feishu.cn/sheets/shtABC#/wiki/wikX", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "docx url unsupported", url: "https://x.feishu.cn/docx/docABC", wantErr: true},
+		{name: "neither provided", wantErr: true},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			ref, err := parseSpreadsheetRef(mk(tc.url, tc.tok))
+			if tc.wantErr {
+				if err == nil {
+					t.Fatalf("want error, got ref=%+v", ref)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if ref.Kind != tc.wantKind || ref.Token != tc.wantToken {
+				t.Fatalf("ref = %+v, want {Kind:%s Token:%s}", ref, tc.wantKind, tc.wantToken)
+			}
+		})
+	}
+}

shortcuts/sheets/lark_sheet_batch_update.go

@@ -67,7 +67,7 @@ var BatchUpdate = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -89,8 +89,9 @@ var BatchUpdate = common.Shortcut{
 }
 
 // batchUpdateInput translates the user-supplied CLI-shape operations array
-// into the MCP batch_update payload. Returns FlagErrorf-typed errors on
-// any per-op shape problem (translator validates each entry).
+// into the MCP batch_update payload. Returns ValidationErrorf-typed errors
+// (errs.ValidationError) on any per-op shape problem (translator validates
+// each entry).
 func batchUpdateInput(runtime *common.RuntimeContext, token string) (map[string]interface{}, error) {
 	rawOps, err := parseBatchOperationsFlag(runtime)
 	if err != nil {
@@ -180,7 +181,7 @@ var CellsBatchSetStyle = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -270,7 +271,7 @@ var CellsBatchClear = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -350,7 +351,7 @@ var DropdownUpdate = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -396,7 +397,7 @@ var DropdownDelete = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_batch_update_test.go

@@ -5,7 +5,6 @@ package sheets
 
 import (
 	"encoding/json"
-	"strings"
 	"testing"
 )
 
@@ -166,18 +165,16 @@ func TestCellsBatchClear_Guards(t *testing.T) {
 	t.Parallel()
 
 	// sheetless range → prefix guard (shared with the dropdown fan-outs).
-	stdout, stderr, err := runShortcutCapturingErr(t, CellsBatchClear, []string{
+	_, _, err := runShortcutCapturingErr(t, CellsBatchClear, []string{
 		"--url", testURL,
 		"--ranges", `["A1:A10"]`,
 		"--yes",
 		"--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "must include a sheet prefix") {
-		t.Errorf("expected sheet-prefix guard; got=%s|%s|%v", stdout, stderr, err)
-	}
+	requireValidation(t, err, "must include a sheet prefix")
 
 	// missing --yes → confirmation_required (high-risk-write).
-	stdout, stderr, err = runShortcutCapturingErr(t, CellsBatchClear, []string{
+	stdout, stderr, err := runShortcutCapturingErr(t, CellsBatchClear, []string{
 		"--url", testURL,
 		"--ranges", `["sheet1!A1:A10"]`,
 	})
@@ -268,38 +265,32 @@ func TestBatchUpdate_ValidationGuards(t *testing.T) {
 	t.Parallel()
 
 	// dropdown-update with sheetless range
-	stdout, stderr, err := runShortcutCapturingErr(t, DropdownUpdate, []string{
+	_, _, err := runShortcutCapturingErr(t, DropdownUpdate, []string{
 		"--url", testURL,
 		"--ranges", `["A2:A5"]`,
 		"--options", `["a"]`,
 		"--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "must include a sheet prefix") {
-		t.Errorf("expected sheet-prefix guard for +dropdown-update; got=%s|%s|%v", stdout, stderr, err)
-	}
+	requireValidation(t, err, "must include a sheet prefix")
 
 	// batch-update with empty operations
-	stdout, stderr, err = runShortcutCapturingErr(t, BatchUpdate, []string{
+	_, _, err = runShortcutCapturingErr(t, BatchUpdate, []string{
 		"--url", testURL,
 		"--operations", `[]`,
 		"--yes",
 		"--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "non-empty JSON array") {
-		t.Errorf("expected empty-operations guard; got=%s|%s|%v", stdout, stderr, err)
-	}
+	requireValidation(t, err, "non-empty JSON array")
 
 	// dropdown-update with non-array --options (object instead) → array guard
 	// (now via schema validator at parseJSONFlag time)
-	stdout, stderr, err = runShortcutCapturingErr(t, DropdownUpdate, []string{
+	_, _, err = runShortcutCapturingErr(t, DropdownUpdate, []string{
 		"--url", testURL,
 		"--ranges", `["sheet1!A1:A2"]`,
 		"--options", `{"not":"array"}`,
 		"--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), `expected type "array"`) {
-		t.Errorf("expected JSON array guard; got=%s|%s|%v", stdout, stderr, err)
-	}
+	requireValidation(t, err, `expected type "array"`)
 }
 
 // TestValidateDropdownRanges_RejectsMalformedRange locks the up-front sheet!range
@@ -322,15 +313,13 @@ func TestValidateDropdownRanges_RejectsMalformedRange(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, DropdownUpdate, []string{
+			_, _, err := runShortcutCapturingErr(t, DropdownUpdate, []string{
 				"--url", testURL,
 				"--ranges", tc.ranges,
 				"--options", `["a"]`,
 				"--dry-run",
 			})
-			if err == nil || !strings.Contains(stdout+stderr+err.Error(), tc.want) {
-				t.Errorf("ranges=%s: expected error containing %q; got=%s|%s|%v", tc.ranges, tc.want, stdout, stderr, err)
-			}
+			requireValidation(t, err, tc.want)
 		})
 	}
 }
@@ -419,18 +408,13 @@ func TestBatchUpdate_TranslatorRejects(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, BatchUpdate, []string{
+			_, _, err := runShortcutCapturingErr(t, BatchUpdate, []string{
 				"--url", testURL,
 				"--operations", tc.opsJSON,
 				"--yes",
 				"--dry-run",
 			})
-			if err == nil {
-				t.Fatalf("expected error containing %q; got stdout=%s stderr=%s", tc.wantMatch, stdout, stderr)
-			}
-			if !strings.Contains(stdout+stderr+err.Error(), tc.wantMatch) {
-				t.Errorf("expected error containing %q; got: %s | %s | %v", tc.wantMatch, stdout, stderr, err)
-			}
+			requireValidation(t, err, tc.wantMatch)
 		})
 	}
 }

shortcuts/sheets/lark_sheet_object_crud.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"github.com/larksuite/cli/errs"
@@ -49,6 +50,20 @@ type objectCRUDSpec struct {
 	// right nesting level.
 	enhanceCreateInput func(rt flagView, input map[string]interface{})
 	enhanceUpdateInput func(rt flagView, input map[string]interface{})
+	// validateCreateInput, when set, runs after enhanceCreateInput to
+	// enforce cross-flag / cross-field, create-only constraints JSON
+	// Schema can't express. Two uses today:
+	//   - pivot rejects --target-position vs --range when both carry
+	//     non-default values — they map to the same wire field and
+	//     conflicting values are ambiguous (needs raw flags via rt).
+	//   - cond-format requires every properties.attrs entry to match the
+	//     sibling rule_type's shape (see validateCondFormatAttrs); a
+	//     colorScale rule fed cellIs-shaped attrs writes a color-less
+	//     segment that breaks the sheet on open (inspects input only).
+	// It is the create-path twin of validateUpdateInput; the same scope
+	// notes apply. Validators that only inspect the wire input can ignore
+	// the rt argument.
+	validateCreateInput func(rt flagView, input map[string]interface{}) error
 	// validateUpdateInput, when set, runs after enhanceUpdateInput to
 	// enforce *cross-field, update-only* constraints JSON Schema can't
 	// express (e.g. sparkline requires properties.sparklines[i] to
@@ -140,7 +155,7 @@ func newObjectCreateShortcut(spec objectCRUDSpec) common.Shortcut {
 			return dr
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -190,6 +205,11 @@ func objectCreateInput(runtime flagView, token, sheetID, sheetName string, spec
 	if spec.enhanceCreateInput != nil {
 		spec.enhanceCreateInput(runtime, input)
 	}
+	if spec.validateCreateInput != nil {
+		if err := spec.validateCreateInput(runtime, input); err != nil {
+			return nil, err
+		}
+	}
 	if err := validateInputAgainstSchema(runtime, input); err != nil {
 		return nil, err
 	}
@@ -224,7 +244,7 @@ func newObjectUpdateShortcut(spec objectCRUDSpec) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindWrite, spec.toolName, input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -308,7 +328,7 @@ func newObjectDeleteShortcut(spec objectCRUDSpec) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindWrite, spec.toolName, input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -381,9 +401,6 @@ var pivotSpec = objectCRUDSpec{
 	},
 	createWarn: pivotPlacementWarn,
 	enhanceCreateInput: func(rt flagView, input map[string]interface{}) {
-		if v := strings.TrimSpace(rt.Str("target-position")); v != "" && v != "A1" {
-			input["target_position"] = v
-		}
 		props, _ := input["properties"].(map[string]interface{})
 		if props == nil {
 			return
@@ -391,10 +408,26 @@ var pivotSpec = objectCRUDSpec{
 		if v := strings.TrimSpace(rt.Str("source")); v != "" {
 			props["source"] = v
 		}
-		if v := strings.TrimSpace(rt.Str("range")); v != "" {
+		// --target-position 与 --range 都映射到 properties.range；
+		// --target-position 优先，未给（或为默认值 A1）时回落到 --range。
+		// 互斥校验在 validateCreateInput 里做。
+		if v := strings.TrimSpace(rt.Str("target-position")); v != "" && v != "A1" {
+			props["range"] = v
+		} else if v := strings.TrimSpace(rt.Str("range")); v != "" {
 			props["range"] = v
 		}
 	},
+	// --target-position 与 --range 落到同一 wire 字段（properties.range），
+	// 同时给非默认值时无法判断意图——按 --target-sheet-id / --target-sheet-name
+	// 的处理方式，CLI 端直接拒绝（优于静默丢弃其一）。
+	validateCreateInput: func(rt flagView, _ map[string]interface{}) error {
+		pos := strings.TrimSpace(rt.Str("target-position"))
+		rng := strings.TrimSpace(rt.Str("range"))
+		if pos != "" && pos != "A1" && rng != "" {
+			return common.ValidationErrorf("--target-position and --range are mutually exclusive (both map to properties.range; pass only one)")
+		}
+		return nil
+	},
 }
 var PivotCreate = newObjectCreateShortcut(pivotSpec)
 var PivotUpdate = newObjectUpdateShortcut(pivotSpec)
@@ -487,7 +520,118 @@ var condFormatSpec = objectCRUDSpec{
 	idField:            "conditional_format_id",
 	enhanceCreateInput: condFormatEnhance,
 	enhanceUpdateInput: condFormatEnhance,
+	// validateCondFormatAttrs only inspects the wire input, so the create
+	// hook ignores rt; the update hook (func(input)) calls it directly.
+	validateCreateInput: func(_ flagView, input map[string]interface{}) error {
+		return validateCondFormatAttrs(input)
+	},
+	validateUpdateInput: validateCondFormatAttrs,
 }
+
+// condFormatAttrsRequired maps each conditional-format rule_type to the
+// keys every properties.attrs entry must carry for that rule. It mirrors
+// the per-rule attrs contract the tool's manage_conditional_format_object
+// converter reads (byted-sheet ai-tools manage-conditional-format-object.ts):
+// that converter maps each attrs entry *blindly by rule_type*, so a
+// colorScale rule fed cellIs-shaped attrs ({compare_type,value}) silently
+// yields a color-less color-scale segment — dirty data that crashes the
+// frontend on snapshot deserialization (the 5005 "can't open" report this
+// validator was added for).
+//
+// JSON Schema can't catch this: properties.attrs.items is a oneOf over all
+// nine shapes, and the validator accepts an entry as soon as *any* branch
+// matches — blind to the sibling rule_type. {compare_type,value} matches
+// the cellIs branch regardless of whether rule_type says colorScale.
+//
+// Rule types absent from the map (duplicateValues, uniqueValues,
+// containsBlanks, notContainsBlanks) carry no attrs, so nothing to check.
+// Counts (dataBar==2, colorScale 2–3, iconSet ordering) stay the tool's
+// job — it already rejects those with actionable messages; the gap this
+// closes is per-entry *shape*, which the tool does not check.
+var condFormatAttrsRequired = map[string][]string{
+	"cellIs":       {"compare_type", "value"},
+	"containsText": {"compare_type", "text"},
+	"timePeriod":   {"operator", "time_period"},
+	"dataBar":      {"color", "value_type"},
+	"colorScale":   {"value_type", "color"},
+	"rank":         {"is_bottom", "value_type"},
+	"aboveAverage": {"operator"},
+	"expression":   {"formula"},
+	"iconSet":      {"icon_type", "value_type", "operator"},
+}
+
+// validateCondFormatAttrs enforces that every properties.attrs entry
+// matches the shape required by the sibling properties.rule_type. Shared
+// by create and update. On update, rule_type may be omitted (the caller is
+// editing style only and the existing rule's type governs the attrs shape,
+// which the CLI can't see); in that case validation is deferred to the
+// server. Missing/empty attrs is likewise left to the tool, which already
+// reports "attrs are required for rule_type: X" clearly.
+func validateCondFormatAttrs(input map[string]interface{}) error {
+	props, _ := input["properties"].(map[string]interface{})
+	if props == nil {
+		return nil
+	}
+	ruleType, _ := props["rule_type"].(string)
+	ruleType = strings.TrimSpace(ruleType)
+	if ruleType == "" {
+		return nil
+	}
+	required, ok := condFormatAttrsRequired[ruleType]
+	if !ok {
+		return nil
+	}
+	attrs, ok := props["attrs"].([]interface{})
+	if !ok {
+		// Missing attrs, or a non-array shape the schema check already
+		// flagged — nothing for this cross-field rule to add.
+		return nil
+	}
+	for i, entryRaw := range attrs {
+		entry, ok := entryRaw.(map[string]interface{})
+		if !ok {
+			continue // schema validation owns per-entry type errors.
+		}
+		for _, key := range required {
+			if v, has := entry[key]; !has || condAttrIsBlank(v) {
+				return common.ValidationErrorf(
+					"--properties: attrs[%d] is missing %q, which rule_type %q requires on every entry (expected keys %s; got %s). "+
+						"A common cause is reusing another rule's attrs shape — e.g. cellIs-style {compare_type,value} under a colorScale rule, which writes a color-less segment that breaks the sheet on open.",
+					i, key, ruleType, strings.Join(required, "+"), condAttrPresentKeys(entry))
+			}
+		}
+	}
+	return nil
+}
+
+// condAttrIsBlank treats a present-but-empty string (after trimming) as
+// missing. The crash-causing case is an empty `color`, but an empty value
+// for any required key is never meaningful in these branches, so the rule
+// is uniform. Non-string values (numbers, booleans) count as present.
+func condAttrIsBlank(v interface{}) bool {
+	if v == nil {
+		return true
+	}
+	if s, ok := v.(string); ok {
+		return strings.TrimSpace(s) == ""
+	}
+	return false
+}
+
+// condAttrPresentKeys lists the keys actually present on an attrs entry,
+// sorted, for the "got ..." half of the error message.
+func condAttrPresentKeys(entry map[string]interface{}) string {
+	if len(entry) == 0 {
+		return "{}"
+	}
+	keys := make([]string, 0, len(entry))
+	for k := range entry {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return "{" + strings.Join(keys, ",") + "}"
+}
+
 var CondFormatCreate = newObjectCreateShortcut(condFormatSpec)
 var CondFormatUpdate = newObjectUpdateShortcut(condFormatSpec)
 var CondFormatDelete = newObjectDeleteShortcut(condFormatSpec)
@@ -732,7 +876,7 @@ func newFloatImageWriteShortcut(command, description, op string, withIDFlag, isH
 			return invokeToolDryRun(token, ToolKindWrite, "manage_float_image_object", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -882,7 +1026,7 @@ var FilterCreate = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "manage_filter_object", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -957,7 +1101,7 @@ var FilterUpdate = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "manage_filter_object", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -1025,7 +1169,7 @@ var FilterDelete = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "manage_filter_object", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_object_crud_test.go

@@ -4,9 +4,12 @@
 package sheets
 
 import (
+	"encoding/json"
+	"sort"
 	"strings"
 	"testing"
 
+	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
@@ -137,25 +140,24 @@ func TestObjectCRUDShortcuts_DryRun(t *testing.T) {
 		// covered separately in the +pivot-create empty-selector / mutex
 		// tests below.
 		{
-			name: "+pivot-create with placement / source / range flags",
+			name: "+pivot-create with placement / source / target-position flags",
 			sc:   PivotCreate,
 			args: []string{
 				"--url", testURL, "--target-sheet-id", testSheetID,
 				"--properties", `{"rows":[{"field":"A"}]}`,
 				"--source", "Sheet1!A1:F1000",
-				"--range", "F1",
 				"--target-position", "B5",
 			},
 			toolName: "manage_pivot_table_object",
 			wantInput: map[string]interface{}{
-				"excel_id":        testToken,
-				"sheet_id":        testSheetID,
-				"operation":       "create",
-				"target_position": "B5",
+				"excel_id":  testToken,
+				"sheet_id":  testSheetID,
+				"operation": "create",
 				"properties": map[string]interface{}{
 					"rows":   []interface{}{map[string]interface{}{"field": "A"}},
 					"source": "Sheet1!A1:F1000",
-					"range":  "F1",
+					// --target-position 映射到 properties.range。
+					"range": "B5",
 				},
 			},
 		},
@@ -202,7 +204,7 @@ func TestObjectCRUDShortcuts_DryRun(t *testing.T) {
 			args: []string{
 				"--url", testURL, "--sheet-id", testSheetID,
 				"--rule-id", "ruleA",
-				"--properties", `{"attrs":[{"operator":"greaterThan","value":"100"}],"style":{"back_color":"#FFD7D7"}}`,
+				"--properties", `{"attrs":[{"compare_type":"greaterThan","value":"100"}],"style":{"back_color":"#FFD7D7"}}`,
 				"--rule-type", "cellIs",
 				"--ranges", `["A1:A100"]`,
 			},
@@ -214,7 +216,7 @@ func TestObjectCRUDShortcuts_DryRun(t *testing.T) {
 				"conditional_format_id": "ruleA",
 				"properties": map[string]interface{}{
 					"rule_type": "cellIs",
-					"attrs":     []interface{}{map[string]interface{}{"operator": "greaterThan", "value": "100"}},
+					"attrs":     []interface{}{map[string]interface{}{"compare_type": "greaterThan", "value": "100"}},
 					"style":     map[string]interface{}{"back_color": "#FFD7D7"},
 					"ranges":    []interface{}{"A1:A100"},
 				},
@@ -471,24 +473,18 @@ func TestPivotCreate_SheetSelectorSemantics(t *testing.T) {
 
 	t.Run("both set is rejected", func(t *testing.T) {
 		t.Parallel()
-		_, stderr, err := runShortcutCapturingErr(t, PivotCreate, []string{
+		_, _, err := runShortcutCapturingErr(t, PivotCreate, []string{
 			"--url", testURL,
 			"--target-sheet-id", testSheetID,
 			"--target-sheet-name", "Sheet1",
 			"--properties", `{"rows":[{"field":"A"}]}`,
 			"--source", "Sheet1!A1:F1000",
 		})
-		if err == nil {
-			t.Fatalf("expected CLI to reject both --target-sheet-id and --target-sheet-name set; stderr=%s", stderr)
-		}
-		combined := stderr + err.Error()
-		if !strings.Contains(combined, "mutually exclusive") {
-			t.Errorf("expected error to say 'mutually exclusive'; got=%s|%v", stderr, err)
-		}
+		ve := requireValidation(t, err, "mutually exclusive")
 		// 错误信息必须用真实的 flag 名（target-*），否则模型按消息提示去
 		// 改 --sheet-id 还是错的。
-		if !strings.Contains(combined, "--target-sheet-id") {
-			t.Errorf("expected error to quote --target-sheet-id flag name; got=%s|%v", stderr, err)
+		if !strings.Contains(ve.Message, "--target-sheet-id") {
+			t.Errorf("expected error to quote --target-sheet-id flag name; got message=%q", ve.Message)
 		}
 	})
 
@@ -507,6 +503,49 @@ func TestPivotCreate_SheetSelectorSemantics(t *testing.T) {
 	})
 }
 
+// TestPivotCreate_TargetPositionRangeMutex regresses the "--target-position
+// and --range cannot both be set" guardrail on +pivot-create. They map to
+// the same wire field (properties.range), so two non-default values are
+// ambiguous; the CLI rejects up front (mirrors the --target-sheet-id /
+// --target-sheet-name mutex). --target-position=A1 is the documented default
+// and is treated as "not set" — pairing it with --range still works.
+func TestPivotCreate_TargetPositionRangeMutex(t *testing.T) {
+	t.Parallel()
+
+	t.Run("both non-default values rejected", func(t *testing.T) {
+		t.Parallel()
+		_, _, err := runShortcutCapturingErr(t, PivotCreate, []string{
+			"--url", testURL,
+			"--target-sheet-id", testSheetID,
+			"--properties", `{"rows":[{"field":"A"}]}`,
+			"--source", "Sheet1!A1:F1000",
+			"--target-position", "B5",
+			"--range", "F1",
+		})
+		ve := requireValidation(t, err, "mutually exclusive")
+		if !strings.Contains(ve.Message, "--target-position") || !strings.Contains(ve.Message, "--range") {
+			t.Errorf("expected error to quote both --target-position and --range; got message=%q", ve.Message)
+		}
+	})
+
+	t.Run("default A1 with --range is accepted (range wins)", func(t *testing.T) {
+		t.Parallel()
+		body := parseDryRunBody(t, PivotCreate, []string{
+			"--url", testURL,
+			"--target-sheet-id", testSheetID,
+			"--properties", `{"rows":[{"field":"A"}]}`,
+			"--source", "Sheet1!A1:F1000",
+			"--target-position", "A1",
+			"--range", "F1",
+		})
+		input := decodeToolInput(t, body, "manage_pivot_table_object")
+		props, _ := input["properties"].(map[string]interface{})
+		if got, _ := props["range"].(string); got != "F1" {
+			t.Errorf("properties.range = %q, want %q", got, "F1")
+		}
+	})
+}
+
 // TestPivotCreate_SchemaValidates exercises the schema-driven
 // validator wired into objectCreateInput. The pivot create schema
 // doesn't constrain rows/columns/values to be present (the backend
@@ -518,35 +557,27 @@ func TestPivotCreate_SchemaValidates(t *testing.T) {
 
 	t.Run("rejects wrong type for rows", func(t *testing.T) {
 		t.Parallel()
-		_, stderr, err := runShortcutCapturingErr(t, PivotCreate, []string{
+		_, _, err := runShortcutCapturingErr(t, PivotCreate, []string{
 			"--url", testURL,
 			"--properties", `{"rows":"not-an-array"}`,
 			"--source", "Sheet1!A1:F1000",
 			"--dry-run",
 		})
-		if err == nil {
-			t.Fatalf("expected schema validator to reject rows=string; stderr=%s", stderr)
-		}
-		combined := stderr + err.Error()
-		if !strings.Contains(combined, "rows") || !strings.Contains(combined, "array") {
-			t.Errorf("expected error to mention rows/array; got=%s|%v", stderr, err)
+		ve := requireValidation(t, err, "rows")
+		if !strings.Contains(ve.Message, "array") {
+			t.Errorf("expected error to mention array; got message=%q", ve.Message)
 		}
 	})
 
 	t.Run("rejects out-of-enum summarize_by", func(t *testing.T) {
 		t.Parallel()
-		_, stderr, err := runShortcutCapturingErr(t, PivotCreate, []string{
+		_, _, err := runShortcutCapturingErr(t, PivotCreate, []string{
 			"--url", testURL,
 			"--properties", `{"values":[{"field":"A","summarize_by":"BOGUS"}]}`,
 			"--source", "Sheet1!A1:F1000",
 			"--dry-run",
 		})
-		if err == nil {
-			t.Fatalf("expected schema validator to reject summarize_by=BOGUS; stderr=%s", stderr)
-		}
-		if !strings.Contains(stderr+err.Error(), "summarize_by") {
-			t.Errorf("expected error to mention summarize_by; got=%s|%v", stderr, err)
-		}
+		requireValidation(t, err, "summarize_by")
 	})
 
 	t.Run("schema-conformant input is accepted", func(t *testing.T) {
@@ -580,14 +611,8 @@ func TestObjectCreate_RequiresSheetSelector(t *testing.T) {
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			_, stderr, err := runShortcutCapturingErr(t, tt.sc, tt.args)
-			if err == nil {
-				t.Fatalf("expected CLI to reject empty sheet selector for +%s-create; stderr=%s", tt.name, stderr)
-			}
-			combined := stderr + err.Error()
-			if !strings.Contains(combined, "specify at least one of --sheet-id or --sheet-name") {
-				t.Errorf("expected 'specify at least one of --sheet-id or --sheet-name'; got=%s|%v", stderr, err)
-			}
+			_, _, err := runShortcutCapturingErr(t, tt.sc, tt.args)
+			requireValidation(t, err, "specify at least one of --sheet-id or --sheet-name")
 		})
 	}
 }
@@ -598,19 +623,184 @@ func TestObjectCreate_RequiresSheetSelector(t *testing.T) {
 // +sparkline-list, before any server call goes out.
 func TestSparklineUpdate_MissingSparklineID(t *testing.T) {
 	t.Parallel()
-	_, stderr, err := runShortcutCapturingErr(t, SparklineUpdate, []string{
+	_, _, err := runShortcutCapturingErr(t, SparklineUpdate, []string{
 		"--url", testURL, "--sheet-id", testSheetID, "--group-id", "grpA",
 		"--properties", `{"sparklines":[{"source":"Sheet1!A1:A10"}]}`,
 	})
-	if err == nil {
-		t.Fatalf("expected CLI to reject missing sparkline_id; stderr=%s", stderr)
+	ve := requireValidation(t, err, "missing sparkline_id")
+	if !strings.Contains(ve.Message, "+sparkline-list") {
+		t.Errorf("expected error to point at +sparkline-list; got message=%q", ve.Message)
 	}
-	combined := stderr + err.Error()
-	if !strings.Contains(combined, "missing sparkline_id") {
-		t.Errorf("expected error to mention missing sparkline_id; got=%s|%v", stderr, err)
+}
+
+// TestCondFormatAttrs_ShapeMatchesRuleType regresses the cross-field
+// guard that rejects attrs whose shape doesn't match the sibling
+// rule_type — the gap behind the "缺 color 的 colorScale 脏数据导致表格
+// 打不开" report: a colorScale rule fed cellIs-shaped attrs
+// ({compare_type,value}, no color) passed both the CLI's per-entry oneOf
+// schema check and the tool, writing a color-less segment that crashed
+// the frontend on open. The check covers create and update symmetrically.
+func TestCondFormatAttrs_ShapeMatchesRuleType(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name    string
+		sc      common.Shortcut
+		args    []string
+		wantErr bool
+		wantMsg string // substring expected in the error, when wantErr
+	}{
+		{
+			name: "colorScale fed cellIs-shaped attrs (missing color) is rejected",
+			sc:   CondFormatCreate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID,
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"compare_type":"greaterThan","value":"0"},{"compare_type":"lessThan","value":"100"}]}`, "--dry-run",
+			},
+			wantErr: true,
+			wantMsg: "colorScale",
+		},
+		{
+			name: "colorScale with empty color string is rejected",
+			sc:   CondFormatCreate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID,
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"value_type":"minValue","color":""},{"value_type":"maxValue","color":"#FF0000"}]}`, "--dry-run",
+			},
+			wantErr: true,
+			wantMsg: `"color"`,
+		},
+		{
+			name: "well-formed colorScale attrs pass",
+			sc:   CondFormatCreate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID,
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"value_type":"minValue","color":"#FFFFFF"},{"value_type":"maxValue","color":"#FF0000"}]}`, "--dry-run",
+			},
+			wantErr: false,
+		},
+		{
+			name: "update path is guarded too (colorScale + cellIs attrs)",
+			sc:   CondFormatUpdate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID, "--rule-id", "ruleA",
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"compare_type":"greaterThan","value":"0"}]}`, "--dry-run",
+			},
+			wantErr: true,
+			wantMsg: "colorScale",
+		},
 	}
-	if !strings.Contains(combined, "+sparkline-list") {
-		t.Errorf("expected error to point at +sparkline-list; got=%s|%v", stderr, err)
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			_, stderr, err := runShortcutCapturingErr(t, tt.sc, tt.args)
+			if tt.wantErr {
+				requireValidation(t, err, tt.wantMsg)
+				return
+			}
+			if err != nil {
+				t.Fatalf("expected acceptance (dry-run); got err=%v stderr=%s", err, stderr)
+			}
+		})
+	}
+}
+
+// TestCondFormatAttrsRequired_MatchesSchemaOneOf guards against drift
+// between the hand-maintained condFormatAttrsRequired table (the source
+// validateCondFormatAttrs enforces) and the embedded flag-schemas.json
+// attrs oneOf (the authoritative shape contract synced from the spec
+// repo). The cross-field validator only works if its per-rule_type
+// required keys mirror the schema branches; if a future schema sync adds
+// or drops a required key on any branch without updating the table, the
+// CLI would silently under- or over-validate. They share no compile-time
+// link, so this test is the only thing pinning them together.
+//
+// The schema oneOf branches are NOT labeled by rule_type (that's the whole
+// point — rule_type is a sibling field the per-entry oneOf can't see), so
+// we can't match branch→rule_type. We instead compare the *multiset* of
+// required-key sets: every branch's required array must appear as some
+// table entry's value and vice versa. This catches any added/dropped
+// required key (real drift); it tolerates only a relabeling between two
+// branches that happen to share an identical required set (dataBar and
+// colorScale both require {color,value_type}), which is harmless here.
+func TestCondFormatAttrsRequired_MatchesSchemaOneOf(t *testing.T) {
+	t.Parallel()
+
+	// multiset key: required keys sorted + joined, so order within a
+	// branch's required array doesn't matter.
+	keyOf := func(req []string) string {
+		s := append([]string(nil), req...)
+		sort.Strings(s)
+		return strings.Join(s, "+")
+	}
+
+	tableMS := map[string]int{}
+	for _, req := range condFormatAttrsRequired {
+		tableMS[keyOf(req)]++
+	}
+
+	schemaMS := func(t *testing.T, command string) map[string]int {
+		idx, err := loadFlagSchemas()
+		if err != nil {
+			t.Fatalf("loadFlagSchemas: %v", err)
+		}
+		raw, ok := idx.Flags[command]["properties"]
+		if !ok {
+			t.Fatalf("no embedded schema for %s --properties", command)
+		}
+		var schema map[string]interface{}
+		if err := json.Unmarshal(raw, &schema); err != nil {
+			t.Fatalf("unmarshal %s properties schema: %v", command, err)
+		}
+		dig := func(m map[string]interface{}, key string) map[string]interface{} {
+			next, _ := m[key].(map[string]interface{})
+			if next == nil {
+				t.Fatalf("%s: missing %q while navigating to attrs oneOf", command, key)
+			}
+			return next
+		}
+		attrs := dig(dig(schema, "properties"), "attrs")
+		items := dig(attrs, "items")
+		oneOf, ok := items["oneOf"].([]interface{})
+		if !ok || len(oneOf) == 0 {
+			t.Fatalf("%s: attrs.items.oneOf is missing or empty", command)
+		}
+		ms := map[string]int{}
+		for i, branchRaw := range oneOf {
+			branch, ok := branchRaw.(map[string]interface{})
+			if !ok {
+				t.Fatalf("%s: oneOf[%d] is not an object", command, i)
+			}
+			reqRaw, _ := branch["required"].([]interface{})
+			req := make([]string, 0, len(reqRaw))
+			for _, r := range reqRaw {
+				if s, ok := r.(string); ok {
+					req = append(req, s)
+				}
+			}
+			ms[keyOf(req)]++
+		}
+		return ms
+	}
+
+	for _, command := range []string{"+cond-format-create", "+cond-format-update"} {
+		got := schemaMS(t, command)
+		if len(got) != len(tableMS) {
+			t.Errorf("%s: schema oneOf has %d distinct required-sets, table has %d", command, len(got), len(tableMS))
+		}
+		for k, n := range tableMS {
+			if got[k] != n {
+				t.Errorf("%s: required-set %q appears %d× in schema but %d× in condFormatAttrsRequired — table drifted from schema; re-sync the table", command, k, got[k], n)
+			}
+		}
+		for k, n := range got {
+			if tableMS[k] != n {
+				t.Errorf("%s: schema branch with required-set %q (×%d) has no matching condFormatAttrsRequired entry — add it to the table", command, k, n)
+			}
+		}
 	}
 }
 
@@ -625,18 +815,13 @@ func TestSparklineUpdate_MissingSparklineID(t *testing.T) {
 // create still mandates one of --image / --image-token / --image-uri.
 func TestFloatImageCreate_RequiresImageSource(t *testing.T) {
 	t.Parallel()
-	_, stderr, err := runShortcutCapturingErr(t, FloatImageCreate, []string{
+	_, _, err := runShortcutCapturingErr(t, FloatImageCreate, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--image-name", "x.png",
 		"--position-row", "0", "--position-col", "A",
 		"--size-width", "10", "--size-height", "10",
 	})
-	if err == nil {
-		t.Fatalf("expected CLI to require an image source on create; stderr=%s", stderr)
-	}
-	if combined := stderr + err.Error(); !strings.Contains(combined, "one of --image, --image-token, or --image-uri is required") {
-		t.Errorf("expected error to require an image source; got=%s|%v", stderr, err)
-	}
+	requireValidation(t, err, "one of --image, --image-token, or --image-uri is required")
 }
 
 // TestObjectDelete_AllHighRisk asserts every delete shortcut blocks
@@ -659,14 +844,8 @@ func TestObjectDelete_AllHighRisk(t *testing.T) {
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, tt.sc, tt.args)
-			if err == nil {
-				t.Fatalf("expected confirmation_required; stdout=%s stderr=%s", stdout, stderr)
-			}
-			combined := stdout + stderr + err.Error()
-			if !strings.Contains(combined, "confirmation_required") && !strings.Contains(combined, "requires confirmation") {
-				t.Errorf("expected confirmation gate; got=%s|%s|%v", stdout, stderr, err)
-			}
+			_, _, err := runShortcutCapturingErr(t, tt.sc, tt.args)
+			requireProblem(t, err, errs.CategoryConfirmation, errs.SubtypeConfirmationRequired, "")
 		})
 	}
 }

shortcuts/sheets/lark_sheet_object_list.go

@@ -57,7 +57,7 @@ func newObjectListShortcut(spec objectListSpec) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindRead, spec.toolName, objectListInput(runtime, token, sheetID, sheetName, spec))
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}

shortcuts/sheets/lark_sheet_range_operations.go

@@ -45,7 +45,7 @@ var CellsClear = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "clear_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -163,7 +163,7 @@ func newMergeShortcut(command, desc, op string, withMergeType bool) common.Short
 			return invokeToolDryRun(token, ToolKindWrite, "merge_cells", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -239,7 +239,7 @@ var RowsResize = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "resize_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -279,7 +279,7 @@ var ColsResize = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "resize_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -451,7 +451,7 @@ var RangeFill = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "transform_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -490,7 +490,7 @@ var RangeSort = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "transform_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -540,7 +540,7 @@ func transformDryRunFn(op string, withPasteType, _ bool) func(context.Context, *
 
 func transformExecuteFn(op string, withPasteType, _ bool) func(context.Context, *common.RuntimeContext) error {
 	return func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_range_operations_test.go

@@ -287,16 +287,11 @@ func TestRangeSort_RejectsMalformedKeys(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, RangeSort, []string{
+			_, _, err := runShortcutCapturingErr(t, RangeSort, []string{
 				"--url", testURL, "--sheet-id", testSheetID,
 				"--range", "A1:E10", "--sort-keys", c.keys, "--dry-run",
 			})
-			if err == nil {
-				t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-			}
-			if !strings.Contains(stdout+stderr+err.Error(), c.want) {
-				t.Errorf("want substring %q in error; got stdout=%s stderr=%s err=%v", c.want, stdout, stderr, err)
-			}
+			requireValidation(t, err, c.want)
 		})
 	}
 }
@@ -349,13 +344,8 @@ func TestResize_TypeAndSizeGuards(t *testing.T) {
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, tt.sc, append(tt.args, "--dry-run"))
-			if err == nil {
-				t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-			}
-			if !strings.Contains(stdout+stderr+err.Error(), tt.want) {
-				t.Errorf("expected %q; got=%s|%s|%v", tt.want, stdout, stderr, err)
-			}
+			_, _, err := runShortcutCapturingErr(t, tt.sc, append(tt.args, "--dry-run"))
+			requireValidation(t, err, tt.want)
 		})
 	}
 }

shortcuts/sheets/lark_sheet_read_data.go

@@ -5,8 +5,6 @@ package sheets
 
 import (
 	"context"
-	"encoding/csv"
-	"regexp"
 	"strconv"
 	"strings"
 
@@ -59,7 +57,7 @@ var CellsGet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_cell_ranges", cellsGetInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -152,7 +150,7 @@ var CsvGet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_range_as_csv", csvGetInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -164,12 +162,7 @@ var CsvGet = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		switch {
-		case runtime.Bool("rows-json"):
-			// --rows-json reshapes the CSV response into structured rows
-			// ({row_number, values:{col→cell}}); see assembleRowsJSON.
-			out = assembleRowsJSON(out, strings.TrimSpace(runtime.Str("range")))
-		case !runtime.Bool("include-row-prefix"):
+		if !runtime.Bool("include-row-prefix") {
 			out = stripRowPrefixFromCsvOutput(out)
 		}
 		runtime.Out(out, nil)
@@ -219,141 +212,6 @@ func stripRowPrefixFromCsvOutput(out interface{}) interface{} {
 	return m
 }
 
-// rowPrefixRe matches the leading "[row=N] " (or "[row=N],") annotation that
-// the tool prepends to the first physical line of each logical CSV record.
-var rowPrefixRe = regexp.MustCompile(`^\[row=(\d+)\][ ,]?`)
-
-// assembleRowsJSON reshapes the tool's annotated_csv string into structured
-// rows so callers never have to regex-parse "[row=N]" or RFC-4180 CSV by hand:
-//
-//	{
-//	  "range": "A1:K3380",
-//	  "current_region": "...",        // passthrough, if the tool returned it
-//	  "rows": [{"row_number":1,"values":{"A":"姓名", ..., "K":"时间差_分钟"}},
-//	           {"row_number":2,"values":{"A":"张三", ..., "K":"8.5"}}, ...]
-//	}
-//
-// Every logical row is emitted, including the first — no row is assumed to be a
-// header, since sheet data is not always tabular. Each cell is keyed by its
-// column letter (from the tool's col_indices when present, else derived from the
-// requested range's start column). On any parsing trouble it returns the
-// original output unchanged.
-func assembleRowsJSON(out interface{}, requestedRange string) interface{} {
-	m, ok := out.(map[string]interface{})
-	if !ok {
-		return out
-	}
-	csvStr, ok := m["annotated_csv"].(string)
-	if !ok {
-		return out
-	}
-
-	// Group physical lines into logical records by [row=N] boundaries; lines
-	// without a prefix are embedded-newline continuations of the current record.
-	type logicalRow struct {
-		num  int
-		text string
-	}
-	var groups []logicalRow
-	for _, line := range strings.Split(csvStr, "\n") {
-		if mm := rowPrefixRe.FindStringSubmatch(line); mm != nil {
-			n, _ := strconv.Atoi(mm[1])
-			groups = append(groups, logicalRow{num: n, text: line[len(mm[0]):]})
-		} else if len(groups) > 0 {
-			groups[len(groups)-1].text += "\n" + line
-		}
-	}
-	if len(groups) == 0 {
-		return out
-	}
-
-	// Parse every logical row; widest row sets the column count. No row is
-	// singled out as a header — that would assume the data is tabular, which it
-	// often is not. The model reads row 1 like any other row and decides for
-	// itself whether it is a header.
-	parsed := make([][]string, len(groups))
-	maxCols := 0
-	for i, g := range groups {
-		parsed[i] = parseCSVRecord(g.text)
-		if len(parsed[i]) > maxCols {
-			maxCols = len(parsed[i])
-		}
-	}
-	if maxCols == 0 {
-		return out
-	}
-
-	// Column letters key each cell. Prefer the tool's col_indices (authoritative,
-	// length == col_count); otherwise derive from the requested range's start col.
-	letters := coerceStringSlice(m["col_indices"])
-	if len(letters) < maxCols {
-		start := csvStartColIndex(requestedRange)
-		letters = make([]string, maxCols)
-		for j := 0; j < maxCols; j++ {
-			letters[j] = csvColLetter(start + j)
-		}
-	}
-
-	rows := make([]map[string]interface{}, 0, len(groups))
-	for i := range groups {
-		fields := parsed[i]
-		values := make(map[string]interface{}, len(letters))
-		for j := range letters {
-			v := ""
-			if j < len(fields) {
-				v = fields[j]
-			}
-			values[letters[j]] = v
-		}
-		rows = append(rows, map[string]interface{}{
-			"row_number": groups[i].num,
-			"values":     values,
-		})
-	}
-
-	result := map[string]interface{}{}
-	for k, v := range m {
-		result[k] = v
-	}
-	result["range"] = requestedRange
-	result["rows"] = rows
-
-	// Surface the backend's "数据没读全" signal structurally instead of leaving it
-	// buried in warning_message prose. The tool flags it when current_region (the
-	// true data extent) reaches past actual_range (what was actually read) — the
-	// single most important anti-under-read hint. Mirror that same comparison
-	// (regionEndRow > actualEndRow) from the already-passthrough A1 ranges so the
-	// model gets the real data range as a first-class field, never having to
-	// parse it out of prose.
-	if cr, _ := m["current_region"].(string); cr != "" {
-		ar, _ := m["actual_range"].(string)
-		regionEnd := a1EndRow(cr)
-		readEnd := a1EndRow(ar)
-		if regionEnd > 0 && readEnd > 0 && regionEnd > readEnd {
-			result["data_not_fully_read"] = map[string]interface{}{
-				"read_through_row":         readEnd,
-				"data_extends_through_row": regionEnd,
-				"unread_rows":              regionEnd - readEnd,
-				"reread_range":             cr,
-			}
-		}
-	}
-
-	// Drop the fields whose information rows-json fully carries elsewhere:
-	//   - annotated_csv / row_indices / col_indices → reconstructed into
-	//     columns + rows (with integer row_number), losslessly.
-	//   - warning_message → its two halves are both handled: the static
-	//     "[row=N] / col_indices[j]" parse nag is moot once those fields exist,
-	//     and the dynamic "数据没读全" half is now the structured
-	//     data_not_fully_read field above. (Confirmed against the backend's
-	//     get-range-as-csv.ts — warning_message has no other content.)
-	delete(result, "annotated_csv")
-	delete(result, "row_indices")
-	delete(result, "col_indices")
-	delete(result, "warning_message")
-	return result
-}
-
 // a1EndRow extracts the ending row number from an A1 range, e.g. "A1:N51" → 51,
 // "Sheet1!B2:D9" → 9, "C5" → 5. Returns 0 when no row number is present.
 func a1EndRow(rng string) int {
@@ -377,89 +235,6 @@ func a1EndRow(rng string) int {
 	return n
 }
 
-// parseCSVRecord parses a single logical CSV record (which may span multiple
-// physical lines via quoted embedded newlines) into its fields. An empty record
-// yields no fields; a malformed record falls back to a naive comma split so a
-// stray quote never drops a whole row.
-func parseCSVRecord(text string) []string {
-	if strings.TrimSpace(text) == "" {
-		return nil
-	}
-	r := csv.NewReader(strings.NewReader(text))
-	r.FieldsPerRecord = -1
-	fields, err := r.Read()
-	if err != nil {
-		return strings.Split(text, ",")
-	}
-	return fields
-}
-
-// coerceStringSlice returns v as []string when it is a homogeneous []interface{}
-// of strings (the shape of the tool's col_indices), else nil.
-func coerceStringSlice(v interface{}) []string {
-	arr, ok := v.([]interface{})
-	if !ok {
-		return nil
-	}
-	out := make([]string, 0, len(arr))
-	for _, e := range arr {
-		s, ok := e.(string)
-		if !ok {
-			return nil
-		}
-		out = append(out, s)
-	}
-	return out
-}
-
-// csvStartColIndex returns the 0-based column index of a range's start column,
-// e.g. "A1:K3380" → 0, "C5:F9" → 2, "Sheet1!D2" → 3. Unparseable input → 0.
-func csvStartColIndex(rng string) int {
-	rng = strings.TrimSpace(rng)
-	if i := strings.LastIndex(rng, "!"); i >= 0 {
-		rng = rng[i+1:]
-	}
-	var letters strings.Builder
-	for _, c := range rng {
-		if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
-			letters.WriteRune(c)
-			continue
-		}
-		break
-	}
-	if letters.Len() == 0 {
-		return 0
-	}
-	return csvColToIndex(letters.String())
-}
-
-// csvColToIndex converts a column letter to its 0-based index ("A"→0, "K"→10,
-// "AA"→26). Non-letter input → -1.
-func csvColToIndex(s string) int {
-	n := 0
-	for _, c := range strings.ToUpper(s) {
-		if c < 'A' || c > 'Z' {
-			break
-		}
-		n = n*26 + int(c-'A'+1)
-	}
-	return n - 1
-}
-
-// csvColLetter converts a 0-based column index back to its letter (0→"A",
-// 25→"Z", 26→"AA"). Negative input → "".
-func csvColLetter(idx int) string {
-	if idx < 0 {
-		return ""
-	}
-	var b []byte
-	for idx >= 0 {
-		b = append([]byte{byte('A' + idx%26)}, b...)
-		idx = idx/26 - 1
-	}
-	return string(b)
-}
-
 // DropdownGet wraps get_cell_ranges scoped to data_validation: read the
 // dropdown configuration on a range. Aligned with its sibling +cells-get
 // — sheet selection is via --sheet-id / --sheet-name (XOR), and --range
@@ -494,7 +269,7 @@ var DropdownGet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_cell_ranges", dropdownGetInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_read_data_test.go

@@ -63,20 +63,6 @@ func TestReadDataShortcuts_DryRun(t *testing.T) {
 				"value_render_option": "formatted_value",
 			},
 		},
-		{
-			// --rows-json is post-processing on +csv-get's response; it must
-			// NOT leak into the get_range_as_csv input.
-			name:     "+csv-get --rows-json builds the same input (flag is post-process)",
-			sc:       CsvGet,
-			args:     []string{"--url", testURL, "--sheet-id", testSheetID, "--range", "A1:C10", "--rows-json"},
-			toolName: "get_range_as_csv",
-			wantInput: map[string]interface{}{
-				"excel_id": testToken,
-				"sheet_id": testSheetID,
-				"range":    "A1:C10",
-				"max_rows": float64(unboundedReadLimit),
-			},
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -95,15 +81,12 @@ func TestReadDataShortcuts_DryRun(t *testing.T) {
 // every other get_cell_ranges wrapper uses.
 func TestDropdownGet_RequiresSheetSelector(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, DropdownGet, []string{
+	_, _, err := runShortcutCapturingErr(t, DropdownGet, []string{
 		"--url", testURL, "--range", "A2:A100", "--dry-run",
 	})
-	if err == nil {
-		t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-	}
-	combined := stdout + stderr + err.Error()
-	if !strings.Contains(combined, "sheet-id") && !strings.Contains(combined, "sheet-name") {
-		t.Errorf("expected --sheet-id/--sheet-name guard; got=%s|%s|%v", stdout, stderr, err)
+	ve := requireValidation(t, err, "")
+	if !strings.Contains(ve.Message, "sheet-id") && !strings.Contains(ve.Message, "sheet-name") {
+		t.Errorf("expected --sheet-id/--sheet-name guard; got message=%q", ve.Message)
 	}
 }
 
@@ -123,15 +106,10 @@ func TestReadData_RequiresRange(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, c.sc, []string{
+			_, _, err := runShortcutCapturingErr(t, c.sc, []string{
 				"--url", testURL, "--sheet-id", testSheetID, "--range", "  ", "--dry-run",
 			})
-			if err == nil {
-				t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-			}
-			if !strings.Contains(stdout+stderr+err.Error(), "--range is required") {
-				t.Errorf("expected --range guard; got=%s|%s|%v", stdout, stderr, err)
-			}
+			requireValidation(t, err, "--range is required")
 		})
 	}
 }
@@ -179,113 +157,3 @@ func TestCsvGet_StripRowPrefix(t *testing.T) {
 		t.Errorf("other field corrupted: %v", out["other"])
 	}
 }
-
-// TestAssembleRowsJSON covers the --rows-json reshaping: every logical row
-// emitted (no header singled out), integer row_number, column-letter keyed
-// values, embedded newlines inside quoted fields, and current_region passthrough.
-func TestAssembleRowsJSON(t *testing.T) {
-	t.Parallel()
-	in := map[string]interface{}{
-		"annotated_csv":   "[row=1] 姓名,备注,时间差_分钟\n[row=2] 张三,\"line1\nline2\",8.5\n[row=3] 李四,ok,3",
-		"current_region":  "A1:C3",
-		"col_indices":     []interface{}{"A", "B", "C"},
-		"row_indices":     []interface{}{1, 2, 3},
-		"warning_message": "①定位行号…②定位列字母…",
-	}
-	out, ok := assembleRowsJSON(in, "A1:C3").(map[string]interface{})
-	if !ok {
-		t.Fatalf("assembleRowsJSON did not return a map")
-	}
-
-	// Fields whose info rows-json carries elsewhere are dropped (annotated_csv /
-	// indices → rows; warning_message → moot static nag + structured
-	// data_not_fully_read). Unrelated metadata like current_region is preserved.
-	if _, exists := out["annotated_csv"]; exists {
-		t.Errorf("annotated_csv should be dropped")
-	}
-	if _, exists := out["col_indices"]; exists {
-		t.Errorf("col_indices should be dropped")
-	}
-	if _, exists := out["warning_message"]; exists {
-		t.Errorf("warning_message should be dropped in rows-json mode")
-	}
-	if _, exists := out["columns"]; exists {
-		t.Errorf("columns field should not exist (no header assumption)")
-	}
-	if out["current_region"] != "A1:C3" {
-		t.Errorf("current_region passthrough lost: %v", out["current_region"])
-	}
-
-	rows, _ := out["rows"].([]map[string]interface{})
-	if len(rows) != 3 {
-		t.Fatalf("want all 3 rows (incl. row 1), got %d: %+v", len(rows), rows)
-	}
-	// Row 1 is emitted as a normal row, not consumed as a header.
-	if rows[0]["row_number"].(int) != 1 {
-		t.Errorf("first row_number = %v, want 1", rows[0]["row_number"])
-	}
-	if v := rows[0]["values"].(map[string]interface{}); v["A"] != "姓名" || v["C"] != "时间差_分钟" {
-		t.Errorf("row 1 values wrong: %+v", v)
-	}
-	// Row 2 keeps its embedded newline inside a single cell.
-	v1 := rows[1]["values"].(map[string]interface{})
-	if rows[1]["row_number"].(int) != 2 || v1["A"] != "张三" || v1["B"] != "line1\nline2" || v1["C"] != "8.5" {
-		t.Errorf("row 2 wrong (embedded newline?): %+v", rows[1])
-	}
-}
-
-// TestAssembleRowsJSON_DerivedLetters verifies cell letters are derived from the
-// range start when the tool omits col_indices (e.g. a C-anchored read).
-func TestAssembleRowsJSON_DerivedLetters(t *testing.T) {
-	t.Parallel()
-	in := map[string]interface{}{
-		"annotated_csv": "[row=5] h1,h2\n[row=6] a,b",
-	}
-	out := assembleRowsJSON(in, "C5:D6").(map[string]interface{})
-	rows := out["rows"].([]map[string]interface{})
-	if len(rows) != 2 {
-		t.Fatalf("want 2 rows, got %d", len(rows))
-	}
-	if rows[0]["row_number"].(int) != 5 {
-		t.Errorf("first row_number = %v, want 5", rows[0]["row_number"])
-	}
-	if v := rows[0]["values"].(map[string]interface{}); v["C"] != "h1" || v["D"] != "h2" {
-		t.Errorf("derived-letter values wrong: %+v", v)
-	}
-	if v := rows[1]["values"].(map[string]interface{}); v["C"] != "a" || v["D"] != "b" {
-		t.Errorf("row 6 values wrong: %+v", v)
-	}
-}
-
-// TestAssembleRowsJSON_DataNotFullyRead verifies the structured under-read hint:
-// when current_region extends past actual_range, rows-json surfaces the true data
-// range as a first-class field (mirroring the backend's prose warning).
-func TestAssembleRowsJSON_DataNotFullyRead(t *testing.T) {
-	t.Parallel()
-	// Read only A1:D2, but the data region reaches D4 → 2 rows unread.
-	in := map[string]interface{}{
-		"annotated_csv":  "[row=1] 序号,姓名\n[row=2] 101,张三",
-		"actual_range":   "A1:D2",
-		"current_region": "A1:D4",
-	}
-	out := assembleRowsJSON(in, "A1:D2").(map[string]interface{})
-	hint, ok := out["data_not_fully_read"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("data_not_fully_read missing; out=%+v", out)
-	}
-	if hint["read_through_row"] != 2 || hint["data_extends_through_row"] != 4 ||
-		hint["unread_rows"] != 2 || hint["reread_range"] != "A1:D4" {
-		t.Errorf("data_not_fully_read wrong: %+v", hint)
-	}
-
-	// Fully-read case: no hint emitted.
-	in2 := map[string]interface{}{
-		"annotated_csv":  "[row=1] 序号,姓名\n[row=2] 101,张三",
-		"actual_range":   "A1:D2",
-		"current_region": "A1:D2",
-	}
-	out2 := assembleRowsJSON(in2, "A1:D2").(map[string]interface{})
-	if _, exists := out2["data_not_fully_read"]; exists {
-		t.Errorf("data_not_fully_read should be absent when fully read")
-	}
-}

shortcuts/sheets/lark_sheet_search_replace.go

@@ -46,7 +46,7 @@ var CellsSearch = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "search_data", searchInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -122,7 +122,7 @@ var CellsReplace = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "replace_data", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_search_replace_test.go

@@ -89,14 +89,17 @@ func TestSearchReplaceShortcuts_DryRun(t *testing.T) {
 
 func TestCellsReplace_RequireFlag(t *testing.T) {
 	t.Parallel()
-	// --replace not passed at all (vs empty string) should error.
+	// --replace not passed at all (vs empty string) should error. This trips
+	// cobra's required-flag gate before our Validate hook runs, so the error
+	// is cobra's plain `required flag(s) "replacement" not set` rather than a
+	// typed *errs.ValidationError — keep this assertion as a substring check.
 	stdout, stderr, err := runShortcutCapturingErr(t, CellsReplace, []string{
 		"--url", testURL, "--sheet-id", testSheetID, "--find", "foo", "--dry-run",
 	})
 	if err == nil {
-		t.Fatalf("expected error when --replace omitted; stdout=%s stderr=%s", stdout, stderr)
+		t.Fatalf("expected error when --replacement omitted; stdout=%s stderr=%s", stdout, stderr)
 	}
-	if !strings.Contains(stdout+stderr+err.Error(), "replace") {
-		t.Errorf("expected message about --replace; got=%s|%s|%v", stdout, stderr, err)
+	if !strings.Contains(err.Error(), "replacement") {
+		t.Errorf("expected message about --replacement; got=%s|%s|%v", stdout, stderr, err)
 	}
 }

shortcuts/sheets/lark_sheet_sheet_structure.go

@@ -51,7 +51,7 @@ var SheetInfo = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_sheet_structure", sheetInfoInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -136,7 +136,7 @@ var DimInsert = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -211,7 +211,7 @@ var DimDelete = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -300,7 +300,7 @@ var DimFreeze = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -395,7 +395,7 @@ func newDimRangeOpShortcut(command, desc, op, risk string) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -439,7 +439,7 @@ func newDimGroupShortcut(command, desc, op string) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -593,7 +593,7 @@ var DimMove = common.Shortcut{
 			Set("spreadsheet_token", token)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_sheet_structure_test.go

@@ -198,13 +198,8 @@ func TestDimRange_Validation(t *testing.T) {
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, DimHide, tt.args)
-			if err == nil {
-				t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-			}
-			if !strings.Contains(stdout+stderr+err.Error(), tt.want) {
-				t.Errorf("expected %q substring; got=%s|%s|%v", tt.want, stdout, stderr, err)
-			}
+			_, _, err := runShortcutCapturingErr(t, DimHide, tt.args)
+			requireValidation(t, err, tt.want)
 		})
 	}
 }
@@ -269,16 +264,11 @@ func TestDimMove_Column(t *testing.T) {
 // column (or vice versa) is rejected at Validate.
 func TestDimMove_MismatchedDimension(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, DimMove, []string{
+	_, _, err := runShortcutCapturingErr(t, DimMove, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--source-range", "1:3", "--target", "H", "--dry-run",
 	})
-	if err == nil {
-		t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-	}
-	if !strings.Contains(stdout+stderr+err.Error(), "must match --source-range") {
-		t.Errorf("expected dimension-mismatch guard; got=%s|%s|%v", stdout, stderr, err)
-	}
+	requireValidation(t, err, "must match --source-range")
 }
 
 // TestParseA1Range covers parser edge cases directly.

shortcuts/sheets/lark_sheet_style_alias_test.go

@@ -0,0 +1,189 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// TestNormalizeCellStyleAliases pins the shorthand → canonical renaming for a
+// single cell_styles map: the alignment shorthands models commonly hallucinate
+// are rewritten in place, values are preserved, and a shorthand colliding with
+// its canonical key is a hard error rather than a silent pick.
+func TestNormalizeCellStyleAliases(t *testing.T) {
+	t.Parallel()
+
+	t.Run("renames *_align shorthands, keeps values and other fields", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{
+			"horizontal_align": "center",
+			"vertical_align":   "middle",
+			"font_weight":      "bold",
+		}
+		if err := normalizeCellStyleAliases(style, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if style["horizontal_alignment"] != "center" || style["vertical_alignment"] != "middle" {
+			t.Errorf("alignment not renamed: %#v", style)
+		}
+		if _, ok := style["horizontal_align"]; ok {
+			t.Errorf("shorthand horizontal_align should be removed: %#v", style)
+		}
+		if _, ok := style["vertical_align"]; ok {
+			t.Errorf("shorthand vertical_align should be removed: %#v", style)
+		}
+		if style["font_weight"] != "bold" {
+			t.Errorf("unrelated field font_weight dropped: %#v", style)
+		}
+	})
+
+	t.Run("renames halign/valign shorthands", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{"halign": "left", "valign": "top"}
+		if err := normalizeCellStyleAliases(style, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if style["horizontal_alignment"] != "left" || style["vertical_alignment"] != "top" {
+			t.Errorf("halign/valign not renamed: %#v", style)
+		}
+	})
+
+	t.Run("shorthand colliding with canonical is an error", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{
+			"horizontal_align":     "center",
+			"horizontal_alignment": "left",
+		}
+		err := normalizeCellStyleAliases(style, "cell_styles[0]")
+		requireValidation(t, err, "conflicts with horizontal_alignment")
+	})
+
+	t.Run("no shorthand leaves the map untouched", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{"font_weight": "bold", "horizontal_alignment": "center"}
+		if err := normalizeCellStyleAliases(style, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if len(style) != 2 || style["font_weight"] != "bold" || style["horizontal_alignment"] != "center" {
+			t.Errorf("map should be unchanged: %#v", style)
+		}
+	})
+
+	t.Run("empty map is a no-op", func(t *testing.T) {
+		t.Parallel()
+		if err := normalizeCellStyleAliases(map[string]interface{}{}, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	})
+}
+
+// TestNormalizeTypedCellsStyleAliases pins the 2D --cells walk: every cell's
+// inline cell_styles is normalized, malformed shapes are skipped (matching the
+// pass-through contract) rather than rejected, and a conflict propagates.
+func TestNormalizeTypedCellsStyleAliases(t *testing.T) {
+	t.Parallel()
+
+	t.Run("normalizes inline cell_styles across the grid", func(t *testing.T) {
+		t.Parallel()
+		cells := []interface{}{
+			[]interface{}{
+				map[string]interface{}{
+					"value":       "x",
+					"cell_styles": map[string]interface{}{"horizontal_align": "center"},
+				},
+				map[string]interface{}{"value": "y"}, // no cell_styles → untouched
+			},
+		}
+		if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		row := cells[0].([]interface{})
+		st := row[0].(map[string]interface{})["cell_styles"].(map[string]interface{})
+		if st["horizontal_alignment"] != "center" {
+			t.Errorf("cell_styles not normalized: %#v", st)
+		}
+		if _, ok := st["horizontal_align"]; ok {
+			t.Errorf("shorthand should be removed: %#v", st)
+		}
+	})
+
+	t.Run("malformed shapes are skipped, not rejected", func(t *testing.T) {
+		t.Parallel()
+		cells := []interface{}{
+			"not-a-row",
+			[]interface{}{
+				"not-a-cell",
+				map[string]interface{}{"cell_styles": "not-a-map"},
+			},
+		}
+		if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
+			t.Fatalf("lenient walk should not error on odd shapes: %v", err)
+		}
+	})
+
+	t.Run("conflict inside a cell propagates", func(t *testing.T) {
+		t.Parallel()
+		cells := []interface{}{
+			[]interface{}{
+				map[string]interface{}{
+					"cell_styles": map[string]interface{}{
+						"valign":             "top",
+						"vertical_alignment": "middle",
+					},
+				},
+			},
+		}
+		err := normalizeTypedCellsStyleAliases(cells, "--cells")
+		requireValidation(t, err, "--cells[0][0].cell_styles")
+	})
+}
+
+// TestCellsSet_StyleAliasesNormalized is the end-to-end guard for +cells-set:
+// a typed --cells payload using alignment shorthands reaches set_cell_range
+// with canonical field names so the backend doesn't silently drop them.
+func TestCellsSet_StyleAliasesNormalized(t *testing.T) {
+	t.Parallel()
+	cells := `[[{"value":"Header","cell_styles":{"horizontal_align":"center","vertical_align":"middle","font_weight":"bold"}}]]`
+	body := parseDryRunBody(t, CellsSet, []string{
+		"--url", testURL, "--sheet-id", testSheetID,
+		"--range", "A1", "--cells", cells,
+	})
+	input := decodeToolInput(t, body, "set_cell_range")
+	raw, _ := json.Marshal(input["cells"])
+	s := string(raw)
+	if !strings.Contains(s, `"horizontal_alignment":"center"`) || !strings.Contains(s, `"vertical_alignment":"middle"`) {
+		t.Errorf("alignment shorthands not normalized in cells: %s", s)
+	}
+	if strings.Contains(s, `"horizontal_align":`) || strings.Contains(s, `"vertical_align":`) {
+		t.Errorf("shorthand keys leaked through to backend payload: %s", s)
+	}
+}
+
+// TestWorkbookCreate_StyleAliasesNormalized is the end-to-end guard for
+// +workbook-create --styles: alignment shorthands in a cell_styles op are
+// accepted (no "unsupported style field" error) and emitted as canonical
+// field names merged into the fill cells.
+func TestWorkbookCreate_StyleAliasesNormalized(t *testing.T) {
+	t.Parallel()
+	calls := parseDryRunAPI(t, WorkbookCreate, []string{
+		"--title", "Sales",
+		"--values", `[["Name","Score"],["alice",95]]`,
+		"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:B2","horizontal_align":"center","vertical_align":"middle"}]}]}`,
+	})
+	if len(calls) != 2 {
+		t.Fatalf("api calls = %d, want 2 (create + fill)", len(calls))
+	}
+	body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+	input := decodeToolInput(t, body, "set_cell_range")
+	raw, _ := json.Marshal(input["cells"])
+	s := string(raw)
+	if c := strings.Count(s, `"horizontal_alignment":"center"`); c != 4 {
+		t.Errorf("horizontal_alignment occurrences = %d, want 4 in 2x2 range; cells=%s", c, s)
+	}
+	if strings.Contains(s, `"horizontal_align":`) || strings.Contains(s, `"vertical_align":`) {
+		t.Errorf("shorthand keys leaked through after normalization: %s", s)
+	}
+}

shortcuts/sheets/lark_sheet_workbook_export_test.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/httpmock"
+)
+
+// TestWorkbookExport_ExecuteExportOnly covers the no-download path: without
+// --output-path, +workbook-export delegates to the shared drive export core
+// with OutputDir="" so it creates + polls the export task and returns the ready
+// file token without writing a local file (downloaded=false).
+func TestWorkbookExport_ExecuteExportOnly(t *testing.T) {
+	stubs := []*httpmock.Stub{
+		{
+			Method: "POST",
+			URL:    "/open-apis/drive/v1/export_tasks",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"ticket": "tk_export"},
+			},
+		},
+		{
+			Method: "GET",
+			URL:    "/open-apis/drive/v1/export_tasks/tk_export",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"result": map[string]interface{}{
+					"job_status": float64(0),
+					"file_token": "ftk_xlsx",
+					"file_name":  "report.xlsx",
+					"file_size":  float64(2048),
+				}},
+			},
+		},
+	}
+
+	out, err := runShortcutWithStubs(t, WorkbookExport, []string{
+		"--url", testURL, "--file-extension", "xlsx", "--as", "user",
+	}, stubs...)
+	if err != nil {
+		t.Fatalf("export-only execute failed: %v\n%s", err, out)
+	}
+
+	idx := strings.Index(out, "{")
+	if idx < 0 {
+		t.Fatalf("no JSON envelope:\n%s", out)
+	}
+	var env struct {
+		Data map[string]interface{} `json:"data"`
+	}
+	if err := json.Unmarshal([]byte(out[idx:]), &env); err != nil {
+		t.Fatalf("decode envelope: %v\nraw=%s", err, out)
+	}
+	if env.Data["ready"] != true {
+		t.Errorf("ready = %v, want true", env.Data["ready"])
+	}
+	if env.Data["downloaded"] != false {
+		t.Errorf("downloaded = %v, want false (no --output-path)", env.Data["downloaded"])
+	}
+	if env.Data["file_token"] != "ftk_xlsx" {
+		t.Errorf("file_token = %v, want ftk_xlsx", env.Data["file_token"])
+	}
+	if env.Data["doc_type"] != "sheet" {
+		t.Errorf("doc_type = %v, want sheet", env.Data["doc_type"])
+	}
+}

shortcuts/sheets/lark_sheet_workbook_import_test.go

@@ -0,0 +1,133 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/httpmock"
+	_ "github.com/larksuite/cli/internal/vfs/localfileio"
+)
+
+// chdirTemp switches into a fresh temp dir for the duration of the test and
+// restores the original cwd afterwards. +workbook-import is the first sheets
+// shortcut that stat()s a real local file, so these tests need a working dir.
+func chdirTemp(t *testing.T) {
+	t.Helper()
+	orig, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("getwd: %v", err)
+	}
+	if err := os.Chdir(t.TempDir()); err != nil {
+		t.Fatalf("chdir: %v", err)
+	}
+	t.Cleanup(func() { _ = os.Chdir(orig) })
+}
+
+// TestWorkbookImport_DryRunPinsSheetType verifies the shortcut delegates to the
+// shared drive import core and hard-codes the import target type to "sheet".
+func TestWorkbookImport_DryRunPinsSheetType(t *testing.T) {
+	chdirTemp(t)
+	if err := os.WriteFile("data.xlsx", []byte("fake-xlsx"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+
+	calls := parseDryRunAPI(t, WorkbookImport, []string{"--file", "./data.xlsx"})
+
+	var createBody map[string]interface{}
+	for _, c := range calls {
+		cm, _ := c.(map[string]interface{})
+		if u, _ := cm["url"].(string); u == "/open-apis/drive/v1/import_tasks" {
+			createBody, _ = cm["body"].(map[string]interface{})
+		}
+	}
+	if createBody == nil {
+		t.Fatalf("no import_tasks create call in dry-run: %#v", calls)
+	}
+	if createBody["type"] != "sheet" {
+		t.Errorf("import type = %v, want sheet (must be pinned regardless of file)", createBody["type"])
+	}
+	if createBody["file_extension"] != "xlsx" {
+		t.Errorf("file_extension = %v, want xlsx", createBody["file_extension"])
+	}
+}
+
+// TestWorkbookImport_RejectsNonSheetFile ensures a file that cannot become a
+// spreadsheet (e.g. .docx) is rejected up front by the pinned-sheet validation.
+func TestWorkbookImport_RejectsNonSheetFile(t *testing.T) {
+	chdirTemp(t)
+	if err := os.WriteFile("notes.docx", []byte("fake-docx"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+
+	// Validate runs before DryRun, so the pinned-sheet check rejects .docx up
+	// front and the error surfaces through the normal envelope/err path.
+	_, _, err := runShortcutCapturingErr(t, WorkbookImport, []string{"--file", "./notes.docx", "--dry-run"})
+	requireValidation(t, err, "can only be imported")
+}
+
+// TestWorkbookImport_ExecuteCreatesSheet runs the full upload → create → poll
+// flow against stubs and asserts the resulting URL is a /sheets/ link.
+func TestWorkbookImport_ExecuteCreatesSheet(t *testing.T) {
+	chdirTemp(t)
+	if err := os.WriteFile("data.csv", []byte("a,b\n1,2\n"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+
+	stubs := []*httpmock.Stub{
+		{
+			Method: "POST",
+			URL:    "/open-apis/drive/v1/medias/upload_all",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"file_token": "file_import_media"},
+			},
+		},
+		{
+			Method: "POST",
+			URL:    "/open-apis/drive/v1/import_tasks",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"ticket": "tk_sheet"},
+			},
+		},
+		{
+			Method: "GET",
+			URL:    "/open-apis/drive/v1/import_tasks/tk_sheet",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"result": map[string]interface{}{
+					"token":      "shtcn_imported",
+					"type":       "sheet",
+					"job_status": float64(0),
+				}},
+			},
+		},
+	}
+
+	out, err := runShortcutWithStubs(t, WorkbookImport, []string{"--file", "./data.csv", "--as", "user"}, stubs...)
+	if err != nil {
+		t.Fatalf("import execute failed: %v\n%s", err, out)
+	}
+
+	idx := strings.Index(out, "{")
+	if idx < 0 {
+		t.Fatalf("execute output has no JSON envelope:\n%s", out)
+	}
+	var env struct {
+		Data map[string]interface{} `json:"data"`
+	}
+	if err := json.Unmarshal([]byte(out[idx:]), &env); err != nil {
+		t.Fatalf("decode envelope: %v\nraw=%s", err, out)
+	}
+	if url, _ := env.Data["url"].(string); !strings.Contains(url, "/sheets/") {
+		t.Errorf("imported url = %q, want a /sheets/ link", url)
+	}
+	if tok, _ := env.Data["token"].(string); tok != "shtcn_imported" {
+		t.Errorf("token = %q, want shtcn_imported", tok)
+	}
+}

shortcuts/sheets/lark_sheet_workbook_test.go

@@ -4,13 +4,10 @@
 package sheets
 
 import (
-	"errors"
-	"net/http"
+	"encoding/json"
 	"strings"
 	"testing"
 
-	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
-
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/shortcuts/common"
 )
@@ -145,6 +142,28 @@ func TestWorkbookShortcuts_DryRun(t *testing.T) {
 				"tab_color": "",
 			},
 		},
+		{
+			name:     "+sheet-show-gridline",
+			sc:       SheetShowGridline,
+			args:     []string{"--url", testURL, "--sheet-id", testSheetID},
+			toolName: "modify_workbook_structure",
+			wantInput: map[string]interface{}{
+				"excel_id":  testToken,
+				"operation": "show_gridline",
+				"sheet_id":  testSheetID,
+			},
+		},
+		{
+			name:     "+sheet-hide-gridline",
+			sc:       SheetHideGridline,
+			args:     []string{"--url", testURL, "--sheet-id", testSheetID},
+			toolName: "modify_workbook_structure",
+			wantInput: map[string]interface{}{
+				"excel_id":  testToken,
+				"operation": "hide_gridline",
+				"sheet_id":  testSheetID,
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -209,14 +228,8 @@ func TestSheetMove_DryRunResolvePlaceholders(t *testing.T) {
 // high-risk-write — exit code 10 (confirmation_required) without --yes.
 func TestSheetDelete_HighRiskWriteRequiresYes(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, SheetDelete, []string{"--url", testURL, "--sheet-id", testSheetID})
-	if err == nil {
-		t.Fatalf("expected confirmation_required error; got nil. stdout=%s stderr=%s", stdout, stderr)
-	}
-	combined := stdout + stderr + err.Error()
-	if !strings.Contains(combined, "confirmation_required") && !strings.Contains(combined, "requires confirmation") {
-		t.Errorf("expected confirmation envelope; got=%s|%s|%v", stdout, stderr, err)
-	}
+	_, _, err := runShortcutCapturingErr(t, SheetDelete, []string{"--url", testURL, "--sheet-id", testSheetID})
+	requireProblem(t, err, errs.CategoryConfirmation, errs.SubtypeConfirmationRequired, "")
 }
 
 // TestWorkbook_Validation covers a few critical validation paths shared
@@ -230,6 +243,11 @@ func TestWorkbook_Validation(t *testing.T) {
 		sc      common.Shortcut
 		args    []string
 		wantMsg string
+		// cobraNative=true means the error originates from cobra's native
+		// flag parsing (e.g. required-flag enforcement) which is not wrapped
+		// into a typed errs.ValidationError, so the test falls back to a
+		// substring match on err.Error().
+		cobraNative bool
 	}{
 		{
 			name:    "+workbook-info needs --url or --spreadsheet-token",
@@ -238,10 +256,11 @@ func TestWorkbook_Validation(t *testing.T) {
 			wantMsg: "at least one of --url or --spreadsheet-token",
 		},
 		{
-			name:    "+workbook-info rejects both url and token",
-			sc:      WorkbookInfo,
-			args:    []string{"--url", testURL, "--spreadsheet-token", testToken},
-			wantMsg: "mutually exclusive",
+			name:        "+workbook-info rejects both url and token",
+			sc:          WorkbookInfo,
+			args:        []string{"--url", testURL, "--spreadsheet-token", testToken},
+			wantMsg:     "mutually exclusive",
+			cobraNative: true,
 		},
 		{
 			name:    "+sheet-delete needs sheet selector",
@@ -250,10 +269,11 @@ func TestWorkbook_Validation(t *testing.T) {
 			wantMsg: "at least one of --sheet-id or --sheet-name",
 		},
 		{
-			name:    "+sheet-create requires --title",
-			sc:      SheetCreate,
-			args:    []string{"--url", testURL},
-			wantMsg: "required flag(s) \"title\" not set",
+			name:        "+sheet-create requires --title",
+			sc:          SheetCreate,
+			args:        []string{"--url", testURL},
+			wantMsg:     "required flag(s) \"title\" not set",
+			cobraNative: true,
 		},
 		{
 			name:    "+sheet-create row-count over cap",
@@ -265,14 +285,14 @@ func TestWorkbook_Validation(t *testing.T) {
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, tt.sc, append(tt.args, "--dry-run"))
-			if err == nil {
-				t.Fatalf("expected validation error; got nil. stdout=%s stderr=%s", stdout, stderr)
-			}
-			combined := stdout + stderr + err.Error()
-			if !strings.Contains(combined, tt.wantMsg) {
-				t.Errorf("error message missing %q; got=%s", tt.wantMsg, combined)
+			_, _, err := runShortcutCapturingErr(t, tt.sc, append(tt.args, "--dry-run"))
+			if tt.cobraNative {
+				if err == nil || !strings.Contains(err.Error(), tt.wantMsg) {
+					t.Errorf("error message missing %q; got=%v", tt.wantMsg, err)
+				}
+				return
 			}
+			requireValidation(t, err, tt.wantMsg)
 		})
 	}
 }
@@ -288,7 +308,7 @@ func TestWorkbookCreate_DryRun(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookCreate, []string{"--title", "MySheet"})
 		if len(calls) != 1 {
-			t.Fatalf("api calls = %d, want 1 (no headers/data)", len(calls))
+			t.Fatalf("api calls = %d, want 1 (no values)", len(calls))
 		}
 		c := calls[0].(map[string]interface{})
 		if c["url"] != "/open-apis/sheets/v3/spreadsheets" {
@@ -300,12 +320,11 @@ func TestWorkbookCreate_DryRun(t *testing.T) {
 		}
 	})
 
-	t.Run("with headers and data → 2-step plan", func(t *testing.T) {
+	t.Run("with values → 2-step plan", func(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookCreate, []string{
 			"--title", "Sales",
-			"--headers", `["Name","Score"]`,
-			"--values", `[["alice",95],["bob",88]]`,
+			"--values", `[["Name","Score"],["alice",95],["bob",88]]`,
 		})
 		if len(calls) != 2 {
 			t.Fatalf("api calls = %d, want 2 (create + fill)", len(calls))
@@ -317,7 +336,138 @@ func TestWorkbookCreate_DryRun(t *testing.T) {
 		body, _ := fill["body"].(map[string]interface{})
 		input := decodeToolInput(t, body, "set_cell_range")
 		if input["range"] != "A1:B3" {
-			t.Errorf("fill range = %v, want A1:B3 (1 header + 2 data rows × 2 cols)", input["range"])
+			t.Errorf("fill range = %v, want A1:B3 (3 rows × 2 cols)", input["range"])
+		}
+	})
+
+	t.Run("with styles merges into set_cell_range cells", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "Sales",
+			"--values", `[["Name","Score"],["alice",95]]`,
+			"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","font_weight":"bold","background_color":"#f5f5f5"},{"range":"B1","number_format":"0","border_styles":{"bottom":{"style":"solid","weight":"thin","color":"#000000"}}},{"range":"B2","font_color":"#0f7b0f"}]}]}`,
+		})
+		if len(calls) != 2 {
+			t.Fatalf("api calls = %d, want 2 (create + fill)", len(calls))
+		}
+		body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+		input := decodeToolInput(t, body, "set_cell_range")
+		cells, _ := input["cells"].([]interface{})
+		if len(cells) != 2 {
+			t.Fatalf("cells rows = %#v, want 2", input["cells"])
+		}
+		headerRow, _ := cells[0].([]interface{})
+		firstHeader, _ := headerRow[0].(map[string]interface{})
+		firstStyle, _ := firstHeader["cell_styles"].(map[string]interface{})
+		if firstStyle["font_weight"] != "bold" || firstStyle["background_color"] != "#f5f5f5" {
+			t.Errorf("first header style = %#v, want bold + background", firstStyle)
+		}
+		secondHeader, _ := headerRow[1].(map[string]interface{})
+		if secondHeader["border_styles"] == nil {
+			t.Errorf("second header missing border_styles: %#v", secondHeader)
+		}
+		secondStyle, _ := secondHeader["cell_styles"].(map[string]interface{})
+		if secondStyle["number_format"] != "0" {
+			t.Errorf("second header number_format = %#v, want 0", secondStyle)
+		}
+		dataRow, _ := cells[1].([]interface{})
+		firstData, _ := dataRow[0].(map[string]interface{})
+		if _, ok := firstData["cell_styles"]; ok {
+			t.Errorf("null style should leave first data cell unstyled: %#v", firstData)
+		}
+		secondData, _ := dataRow[1].(map[string]interface{})
+		secondDataStyle, _ := secondData["cell_styles"].(map[string]interface{})
+		if secondDataStyle["font_color"] != "#0f7b0f" {
+			t.Errorf("second data style = %#v, want font color", secondDataStyle)
+		}
+	})
+
+	t.Run("cell style range can cover the whole initial range", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "Sales",
+			"--values", `[["Name","Score"],["alice",95]]`,
+			"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:B2","horizontal_alignment":"center"}]}]}`,
+		})
+		body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+		input := decodeToolInput(t, body, "set_cell_range")
+		raw, _ := json.Marshal(input["cells"])
+		if got := strings.Count(string(raw), "horizontal_alignment"); got != 4 {
+			t.Errorf("horizontal_alignment occurrences = %d, want 4 in 2x2 range; cells=%s", got, raw)
+		}
+	})
+	t.Run("style-only payload (cell_merges) still fills and emits merge_cells", func(t *testing.T) {
+		t.Parallel()
+		// Previously workbookCreateStyleDimensions only counted cell_styles, so a
+		// payload with only cell_merges would compute extent 0; Execute then
+		// skipped writeTypedSheets entirely and the visual ops were silently
+		// dropped. The dry-run plan must include the create + fill + merge_cells.
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "X",
+			"--styles", `{"styles":[{"name":"Sheet1","cell_merges":[{"range":"A1:B1"}]}]}`,
+		})
+		if len(calls) < 3 {
+			t.Fatalf("api calls = %d, want >=3 (create + fill + merge_cells); calls=%#v", len(calls), calls)
+		}
+		// Walk every body and look for the merge_cells tool name in the input JSON.
+		sawMerge := false
+		for _, c := range calls {
+			body, _ := c.(map[string]interface{})["body"].(map[string]interface{})
+			if body == nil {
+				continue
+			}
+			if toolName, _ := body["tool_name"].(string); toolName == "merge_cells" {
+				sawMerge = true
+				break
+			}
+		}
+		if !sawMerge {
+			t.Errorf("merge_cells tool call missing from dry-run plan; calls=%#v", calls)
+		}
+	})
+	t.Run("style-only payload (col_sizes) still fills and emits resize_range", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "X",
+			"--styles", `{"styles":[{"name":"Sheet1","col_sizes":[{"range":"A:C","type":"pixel","size":120}]}]}`,
+		})
+		sawResize := false
+		for _, c := range calls {
+			body, _ := c.(map[string]interface{})["body"].(map[string]interface{})
+			if body == nil {
+				continue
+			}
+			if toolName, _ := body["tool_name"].(string); toolName == "resize_range" {
+				sawResize = true
+				break
+			}
+		}
+		if !sawResize {
+			t.Errorf("resize_range tool call missing from dry-run plan; calls=%#v", calls)
+		}
+	})
+	t.Run("overlapping cell_styles deep-merge fields, no cross-cell pollution", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "X",
+			"--values", `[["a","b"]]`,
+			"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:B1","font_weight":"bold"},{"range":"B1","font_color":"#ff0000"}]}]}`,
+		})
+		body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+		input := decodeToolInput(t, body, "set_cell_range")
+		cells, _ := input["cells"].([]interface{})
+		row0, _ := cells[0].([]interface{})
+		// B1 hit by both ops → must keep BOTH font_weight (op1) and font_color (op2).
+		b1, _ := row0[1].(map[string]interface{})
+		b1s, _ := b1["cell_styles"].(map[string]interface{})
+		if b1s["font_weight"] != "bold" || b1s["font_color"] != "#ff0000" {
+			t.Errorf("B1 should deep-merge both ops, got %#v", b1s)
+		}
+		// A1 hit only by op1 → must NOT be polluted by op2's font_color (shared submap).
+		a1, _ := row0[0].(map[string]interface{})
+		a1s, _ := a1["cell_styles"].(map[string]interface{})
+		if a1s["font_color"] != nil {
+			t.Errorf("A1 must not be polluted by op2, got %#v", a1s)
 		}
 	})
 }
@@ -330,35 +480,44 @@ func TestWorkbookCreate_DataValidation(t *testing.T) {
 		args []string
 		want string
 	}{
-		{"headers not array", []string{"--title", "X", "--headers", `"abc"`}, "must be a JSON array"},
 		{"values not 2D", []string{"--title", "X", "--values", `["a","b"]`}, "must be an array"},
+		{"styles not object", []string{"--title", "X", "--styles", `"bold"`}, `shaped as {"styles":[...]}`},
+		{"styles missing array", []string{"--title", "X", "--styles", `{"value":"x"}`}, "--styles.styles is required"},
+		{"styles item missing groups", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","value":"x"}]}`}, "must include at least one of cell_styles/row_sizes/col_sizes/cell_merges"},
+		{"cell styles must be array", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":{"range":"A1","font_weight":"bold"}}]}`}, "cell_styles must be an array"},
+		{"cell style needs range", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"font_weight":"bold"}]}]}`}, "range is required"},
+		{"nested cell_styles rejected", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","cell_styles":{"font_weight":"bold"}}]}]}`}, "put style fields directly"},
+		{"row size needs row range", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","row_sizes":[{"range":"A1","type":"pixel","size":20}]}]}`}, "must use row numbers"},
+		{"col size needs pixel size", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","col_sizes":[{"range":"A:A","type":"pixel"}]}]}`}, "requires size"},
+		{"border bad style enum", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","border_styles":{"bottom":{"style":"NONSENSE"}}}]}]}`}, `style "NONSENSE" is invalid`},
+		{"border invalid side", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","border_styles":{"diagonal":{"style":"solid"}}}]}]}`}, "not a valid side"},
+		{"border bad weight", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","border_styles":{"top":{"weight":"xxl"}}}]}]}`}, `weight "xxl" is invalid`},
+		{"--values trailing JSON rejected", []string{"--title", "X", "--values", `[["a"]] trailing`}, "trailing data after JSON value"},
 	}
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			stdout, stderr, err := runShortcutCapturingErr(t, WorkbookCreate, append(tt.args, "--dry-run"))
-			if err == nil || !strings.Contains(stdout+stderr+err.Error(), tt.want) {
-				t.Errorf("expected %q; got=%s|%s|%v", tt.want, stdout, stderr, err)
-			}
+			_, _, err := runShortcutCapturingErr(t, WorkbookCreate, append(tt.args, "--dry-run"))
+			requireValidation(t, err, tt.want)
 		})
 	}
 }
 
-// TestWorkbookExport_DryRun checks the 2-or-3 step plan depending on
-// --output-path. The order should be: POST → GET (poll) → optional GET
-// (download).
+// TestWorkbookExport_DryRun verifies the export dry-run now delegates to the
+// shared drive export core: a single create-task POST (poll + download are
+// described inline rather than as separate api entries).
 func TestWorkbookExport_DryRun(t *testing.T) {
 	t.Parallel()
 
-	t.Run("xlsx without --output-path → 2 steps", func(t *testing.T) {
+	t.Run("xlsx create-task body pins type=sheet", func(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookExport, []string{"--url", testURL, "--file-extension", "xlsx"})
-		if len(calls) != 2 {
-			t.Fatalf("api calls = %d, want 2 (create + poll)", len(calls))
+		if len(calls) != 1 {
+			t.Fatalf("api calls = %d, want 1 (create export task)", len(calls))
 		}
 		create := calls[0].(map[string]interface{})
 		if create["url"] != "/open-apis/drive/v1/export_tasks" {
-			t.Errorf("first url = %v", create["url"])
+			t.Errorf("url = %v", create["url"])
 		}
 		body, _ := create["body"].(map[string]interface{})
 		if body["type"] != "sheet" || body["file_extension"] != "xlsx" || body["token"] != testToken {
@@ -366,122 +525,30 @@ func TestWorkbookExport_DryRun(t *testing.T) {
 		}
 	})
 
-	t.Run("csv → 3 steps, with sub_id", func(t *testing.T) {
+	t.Run("csv includes sub_id from --sheet-id", func(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookExport, []string{
 			"--url", testURL, "--file-extension", "csv", "--sheet-id", "sh1",
 			"--output-path", "/tmp/out.csv",
 		})
-		if len(calls) != 3 {
-			t.Fatalf("api calls = %d, want 3", len(calls))
+		if len(calls) != 1 {
+			t.Fatalf("api calls = %d, want 1", len(calls))
 		}
 		body, _ := calls[0].(map[string]interface{})["body"].(map[string]interface{})
-		if body["sub_id"] != "sh1" {
-			t.Errorf("csv export missing sub_id: %#v", body)
-		}
-		dl := calls[2].(map[string]interface{})
-		if !strings.Contains(dl["url"].(string), "/export_tasks/file/") {
-			t.Errorf("download url = %v", dl["url"])
+		if body["type"] != "sheet" || body["sub_id"] != "sh1" {
+			t.Errorf("csv export body = %#v (want type=sheet, sub_id=sh1)", body)
 		}
 	})
 
 	t.Run("csv requires --sheet-id", func(t *testing.T) {
 		t.Parallel()
-		stdout, stderr, err := runShortcutCapturingErr(t, WorkbookExport, []string{
+		_, _, err := runShortcutCapturingErr(t, WorkbookExport, []string{
 			"--url", testURL, "--file-extension", "csv", "--dry-run",
 		})
-		if err == nil || !strings.Contains(stdout+stderr+err.Error(), "--sheet-id is required") {
-			t.Errorf("expected sheet-id guard; got=%s|%s|%v", stdout, stderr, err)
-		}
+		requireValidation(t, err, "--sheet-id is required")
 	})
 }
 
-func TestWorkbookExportDownloadErrorClassification(t *testing.T) {
-	t.Parallel()
-
-	t.Run("preserves typed request errors", func(t *testing.T) {
-		t.Parallel()
-		in := errs.NewAPIError(errs.SubtypeServerError, "typed upstream").WithCode(123)
-		got := sheetsDownloadRequestError(in)
-		if got != in {
-			t.Fatalf("typed error was not preserved: got %T %v", got, got)
-		}
-	})
-
-	t.Run("wraps raw request errors as network transport", func(t *testing.T) {
-		t.Parallel()
-		got := sheetsDownloadRequestError(errors.New("dial refused"))
-		p, ok := errs.ProblemOf(got)
-		if !ok {
-			t.Fatalf("expected typed problem, got %T %v", got, got)
-		}
-		if p.Category != errs.CategoryNetwork || p.Subtype != errs.SubtypeNetworkTransport {
-			t.Fatalf("problem = %s/%s, want %s/%s", p.Category, p.Subtype, errs.CategoryNetwork, errs.SubtypeNetworkTransport)
-		}
-	})
-
-	tests := []struct {
-		name          string
-		status        int
-		wantCategory  errs.Category
-		wantSubtype   errs.Subtype
-		wantRetryable bool
-	}{
-		{
-			name:          "5xx is retryable network server error",
-			status:        http.StatusBadGateway,
-			wantCategory:  errs.CategoryNetwork,
-			wantSubtype:   errs.SubtypeNetworkServer,
-			wantRetryable: true,
-		},
-		{
-			name:         "404 is API not found",
-			status:       http.StatusNotFound,
-			wantCategory: errs.CategoryAPI,
-			wantSubtype:  errs.SubtypeNotFound,
-		},
-		{
-			name:          "429 is retryable API rate limit",
-			status:        http.StatusTooManyRequests,
-			wantCategory:  errs.CategoryAPI,
-			wantSubtype:   errs.SubtypeRateLimit,
-			wantRetryable: true,
-		},
-		{
-			name:         "other 4xx is API unknown",
-			status:       http.StatusForbidden,
-			wantCategory: errs.CategoryAPI,
-			wantSubtype:  errs.SubtypeUnknown,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			got := sheetsDownloadHTTPStatusError(&larkcore.ApiResp{
-				StatusCode: tt.status,
-				RawBody:    []byte("body"),
-				Header:     http.Header{larkcore.HttpHeaderKeyLogId: []string{"log123"}},
-			})
-			p, ok := errs.ProblemOf(got)
-			if !ok {
-				t.Fatalf("expected typed problem, got %T %v", got, got)
-			}
-			if p.Category != tt.wantCategory || p.Subtype != tt.wantSubtype {
-				t.Fatalf("problem = %s/%s, want %s/%s", p.Category, p.Subtype, tt.wantCategory, tt.wantSubtype)
-			}
-			if p.Code != tt.status {
-				t.Fatalf("code = %d, want %d", p.Code, tt.status)
-			}
-			if p.LogID != "log123" {
-				t.Fatalf("log_id = %q, want log123", p.LogID)
-			}
-			if p.Retryable != tt.wantRetryable {
-				t.Fatalf("retryable = %v, want %v", p.Retryable, tt.wantRetryable)
-			}
-		})
-	}
-}
-
 // assertInputEquals compares the decoded tool input map against the wanted
 // fields. Extra fields in `got` are allowed (defaults, optional fields);
 // every key in `want` must match exactly.

shortcuts/sheets/lark_sheet_write_cells.go

@@ -56,7 +56,7 @@ var CellsSet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -88,6 +88,9 @@ func cellsSetInput(runtime flagView, token, sheetID, sheetName string) (map[stri
 	if err != nil {
 		return nil, err
 	}
+	if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
+		return nil, err
+	}
 	input := map[string]interface{}{
 		"excel_id": token,
 		"range":    strings.TrimSpace(runtime.Str("range")),
@@ -129,7 +132,7 @@ var CellsSetStyle = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -197,12 +200,12 @@ func cellsSetStyleInput(runtime flagView, token, sheetID, sheetName string) (map
 	return input, nil
 }
 
-// CsvPut wraps set_range_from_csv: dump a CSV blob into a sheet, only writing
-// plain values. Use +cells-set for anything richer (formula / style / note).
+// CsvPut wraps set_range_from_csv: dump a CSV blob into a sheet. A cell whose
+// text starts with = is evaluated as a formula; use +cells-set for styles / notes / images.
 var CsvPut = common.Shortcut{
 	Service:     "sheets",
 	Command:     "+csv-put",
-	Description: "Paste RFC-4180 CSV into a sheet at --start-cell (plain values only, auto-expands sheet if needed).",
+	Description: "Paste RFC-4180 CSV into a sheet at --start-cell (values or formulas: a leading = is evaluated as a formula; no styles / comments; auto-expands sheet if needed).",
 	Risk:        "write",
 	Scopes:      []string{"sheets:spreadsheet:write_only"},
 	AuthTypes:   []string{"user", "bot"},
@@ -237,7 +240,7 @@ var CsvPut = common.Shortcut{
 		return dr
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -414,7 +417,7 @@ var DropdownSet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -801,7 +804,7 @@ var CellsSetImage = common.Shortcut{
 			Body(setCellBody)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}

shortcuts/sheets/lark_sheet_write_cells_test.go

@@ -4,6 +4,7 @@
 package sheets
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
@@ -241,18 +242,16 @@ func TestDropdownSet_HighlightTriState(t *testing.T) {
 // cycles the rest through a built-in palette).
 func TestDropdownSet_ColorsLongerThanOptions(t *testing.T) {
 	t.Parallel()
-	_, stderr, err := runShortcutCapturingErr(t, DropdownSet, []string{
+	_, _, err := runShortcutCapturingErr(t, DropdownSet, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "A2:A4",
 		"--options", `["a","b"]`,
 		"--colors", `["#FFE699","#bff7d9","#ffb3b3"]`,
 		"--dry-run",
 	})
-	if err == nil {
-		t.Fatal("expected --colors length error, got nil")
-	}
-	if !strings.Contains(stderr, "must not exceed dropdown source size") && !strings.Contains(err.Error(), "must not exceed dropdown source size") {
-		t.Errorf("error message missing length-overflow hint:\nerr=%v\nstderr=%s", err, stderr)
+	ve := requireValidation(t, err, "must not exceed dropdown source size")
+	if ve.Param != "--colors" {
+		t.Errorf("param = %q, want --colors", ve.Param)
 	}
 }
 
@@ -318,7 +317,7 @@ func TestDropdownSet_ListFromRange(t *testing.T) {
 // must be refused).
 func TestDropdownSet_ListFromRange_ColorsLongerThanCells(t *testing.T) {
 	t.Parallel()
-	_, stderr, err := runShortcutCapturingErr(t, DropdownSet, []string{
+	_, _, err := runShortcutCapturingErr(t, DropdownSet, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "B2:B21",
 		"--source-range", "Sheet1!T1:T3",
@@ -326,11 +325,9 @@ func TestDropdownSet_ListFromRange_ColorsLongerThanCells(t *testing.T) {
 		"--highlight",
 		"--dry-run",
 	})
-	if err == nil {
-		t.Fatal("expected --colors length error, got nil")
-	}
-	if !strings.Contains(stderr, "must not exceed dropdown source size") && !strings.Contains(err.Error(), "must not exceed dropdown source size") {
-		t.Errorf("error message missing source-size hint:\nerr=%v\nstderr=%s", err, stderr)
+	ve := requireValidation(t, err, "must not exceed dropdown source size")
+	if ve.Param != "--colors" {
+		t.Errorf("param = %q, want --colors", ve.Param)
 	}
 }
 
@@ -338,36 +335,26 @@ func TestDropdownSet_ListFromRange_ColorsLongerThanCells(t *testing.T) {
 // --source-range.
 func TestDropdownSet_XorBothSet(t *testing.T) {
 	t.Parallel()
-	_, stderr, err := runShortcutCapturingErr(t, DropdownSet, []string{
+	_, _, err := runShortcutCapturingErr(t, DropdownSet, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "B2:B21",
 		"--options", `["a","b"]`,
 		"--source-range", "Sheet1!T1:T3",
 		"--dry-run",
 	})
-	if err == nil {
-		t.Fatal("expected XOR error, got nil")
-	}
-	if !strings.Contains(stderr, "mutually exclusive") && !strings.Contains(err.Error(), "mutually exclusive") {
-		t.Errorf("error message missing XOR hint:\nerr=%v\nstderr=%s", err, stderr)
-	}
+	requireValidation(t, err, "mutually exclusive")
 }
 
 // TestDropdownSet_XorNeitherSet rejects passing neither --options nor
 // --source-range.
 func TestDropdownSet_XorNeitherSet(t *testing.T) {
 	t.Parallel()
-	_, stderr, err := runShortcutCapturingErr(t, DropdownSet, []string{
+	_, _, err := runShortcutCapturingErr(t, DropdownSet, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "B2:B21",
 		"--dry-run",
 	})
-	if err == nil {
-		t.Fatal("expected required-one error, got nil")
-	}
-	if !strings.Contains(stderr, "one of --options") && !strings.Contains(err.Error(), "one of --options") {
-		t.Errorf("error message missing required-one hint:\nerr=%v\nstderr=%s", err, stderr)
-	}
+	requireValidation(t, err, "one of --options")
 }
 
 // TestCellsSetStyle_FlatFlags verifies that the 11 flat style flags +
@@ -400,30 +387,60 @@ func TestCellsSetStyle_FlatFlags(t *testing.T) {
 
 func TestCellsSetStyle_RequiresAtLeastOneFlag(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, CellsSetStyle, []string{
+	_, _, err := runShortcutCapturingErr(t, CellsSetStyle, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "A1:B2", "--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "at least one style flag") {
-		t.Errorf("expected style-flag guard; got=%s|%s|%v", stdout, stderr, err)
-	}
+	requireValidation(t, err, "at least one style flag")
 }
 
 func TestCellsSet_RequiresJSONArray(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, CellsSet, []string{
+	_, _, err := runShortcutCapturingErr(t, CellsSet, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "A1", "--cells", `{"foo":"bar"}`, "--dry-run",
 	})
-	if err == nil {
-		t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
-	}
 	// Schema validator fires first now: "--cells: expected type \"array\", got \"object\"".
 	// Either the schema phrasing or the legacy requireJSONArray phrasing is
 	// acceptable — both pin the same contract.
-	combined := stdout + stderr + err.Error()
-	if !strings.Contains(combined, `expected type "array"`) && !strings.Contains(combined, "must be a JSON array") {
-		t.Errorf("expected array-type guard; got=%s|%s|%v", stdout, stderr, err)
+	ve := requireValidation(t, err, "")
+	if !strings.Contains(ve.Message, `expected type "array"`) && !strings.Contains(ve.Message, "must be a JSON array") {
+		t.Errorf("expected array-type guard; got message=%q", ve.Message)
+	}
+}
+
+// TestCellsSet_RejectsUnsupportedMentionType pins the mention_type enum in
+// data/flag-schemas.json (synced from the upstream tool schema): a rich_text
+// mention whose mention_type is outside MENTION_FILE_TYPE (here 6 = cloud
+// shared folder) is rejected by the schema validator at flag-parse time,
+// before it can reach the server and blow up pb serialization
+// ("mentionFileInfo.fileType: enum value expected").
+func TestCellsSet_RejectsUnsupportedMentionType(t *testing.T) {
+	t.Parallel()
+	cells := `[[{"rich_text":[{"type":"mention","text":"x","mention_type":6,"mention_token":"t"}]}]]`
+	_, _, err := runShortcutCapturingErr(t, CellsSet, []string{
+		"--url", testURL, "--sheet-id", testSheetID,
+		"--range", "A1", "--cells", cells, "--dry-run",
+	})
+	ve := requireValidation(t, err, "mention_type")
+	if !strings.Contains(ve.Message, "not in enum") {
+		t.Errorf("expected enum guard; got message=%q", ve.Message)
+	}
+}
+
+// TestCellsSet_AllowsValidMentionTypes confirms the guard lets through a
+// user @mention (mention_type 0) and a render-supported file type (22 = DOCX).
+func TestCellsSet_AllowsValidMentionTypes(t *testing.T) {
+	t.Parallel()
+	for _, mt := range []int{0, 22} {
+		cells := fmt.Sprintf(`[[{"rich_text":[{"type":"mention","text":"x","mention_type":%d,"mention_token":"t"}]}]]`, mt)
+		stdout, stderr, err := runShortcutCapturingErr(t, CellsSet, []string{
+			"--url", testURL, "--sheet-id", testSheetID,
+			"--range", "A1", "--cells", cells, "--dry-run",
+		})
+		if err != nil {
+			t.Errorf("mention_type %d: unexpected error: stdout=%s stderr=%s err=%v", mt, stdout, stderr, err)
+		}
 	}
 }
 
@@ -481,12 +498,13 @@ func TestCellsSetImage_DryRun(t *testing.T) {
 
 func TestCellsSetImage_RangeMustBeSingleCell(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, CellsSetImage, []string{
+	_, _, err := runShortcutCapturingErr(t, CellsSetImage, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "A1:B2", "--image", "./foo.png", "--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "must be exactly one cell") {
-		t.Errorf("expected single-cell guard; got=%s|%s|%v", stdout, stderr, err)
+	ve := requireValidation(t, err, "must be exactly one cell")
+	if ve.Param != "--range" {
+		t.Errorf("param = %q, want --range", ve.Param)
 	}
 }
 
@@ -495,12 +513,13 @@ func TestCellsSetImage_RangeMustBeSingleCell(t *testing.T) {
 // same way as a real run instead of printing a misleading success preview.
 func TestCellsSetImage_DryRunRejectsUnsafePath(t *testing.T) {
 	t.Parallel()
-	stdout, stderr, err := runShortcutCapturingErr(t, CellsSetImage, []string{
+	_, _, err := runShortcutCapturingErr(t, CellsSetImage, []string{
 		"--url", testURL, "--sheet-id", testSheetID,
 		"--range", "A1", "--image", "/etc/hosts", "--dry-run",
 	})
-	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "must be a relative path") {
-		t.Errorf("expected unsafe-path guard during dry-run; got=%s|%s|%v", stdout, stderr, err)
+	ve := requireValidation(t, err, "must be a relative path")
+	if ve.Param != "--image" {
+		t.Errorf("param = %q, want --image", ve.Param)
 	}
 }
 

shortcuts/sheets/shortcuts.go

@@ -3,7 +3,11 @@
 
 package sheets
 
-import "github.com/larksuite/cli/shortcuts/common"
+import (
+	"github.com/larksuite/cli/shortcuts/common"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
 
 // Shortcuts returns all lark-sheets shortcuts. The list is grouped by
 // canonical skill to mirror the sheet-skill-spec layout
@@ -22,10 +26,46 @@ func Shortcuts() []common.Shortcut {
 		if _, ok := commandsWithSchema[all[i].Command]; ok {
 			all[i].PrintFlagSchema = printFlagSchemaFor(all[i].Command)
 		}
+		// Accept --token as a parse-time alias for --spreadsheet-token (the
+		// single highest-frequency reflex misspelling in eval traces) on every
+		// shortcut that registers --spreadsheet-token, so the typo costs zero
+		// round-trips instead of an unknown-flag failure. Wired through the
+		// existing PostMount hook and composed onto any prior PostMount, so the
+		// common framework needs no change at all.
+		if hasFlag(all[i].Flags, "spreadsheet-token") {
+			all[i].PostMount = withTokenAlias(all[i].PostMount)
+		}
 	}
 	return all
 }
 
+func hasFlag(flags []common.Flag, name string) bool {
+	for _, fl := range flags {
+		if fl.Name == name {
+			return true
+		}
+	}
+	return false
+}
+
+// withTokenAlias wraps an optional PostMount so that, after it runs, --token
+// resolves to --spreadsheet-token at parse time via pflag's normalize hook (no
+// duplicate flag in --help). It preserves any pre-existing PostMount — e.g.
+// +csv-put's --range / --start-cell flag-group setup — by running it first.
+func withTokenAlias(prev func(cmd *cobra.Command)) func(cmd *cobra.Command) {
+	return func(cmd *cobra.Command) {
+		if prev != nil {
+			prev(cmd)
+		}
+		cmd.Flags().SetNormalizeFunc(func(_ *pflag.FlagSet, name string) pflag.NormalizedName {
+			if name == "token" {
+				return pflag.NormalizedName("spreadsheet-token")
+			}
+			return pflag.NormalizedName(name)
+		})
+	}
+}
+
 func shortcutList() []common.Shortcut {
 	return []common.Shortcut{
 		// lark_sheet_workbook
@@ -38,8 +78,11 @@ func shortcutList() []common.Shortcut {
 		SheetHide,
 		SheetUnhide,
 		SheetSetTabColor,
+		SheetShowGridline,
+		SheetHideGridline,
 		WorkbookCreate,
 		WorkbookExport,
+		WorkbookImport,
 
 		// lark_sheet_sheet_structure
 		SheetInfo,
@@ -56,6 +99,7 @@ func shortcutList() []common.Shortcut {
 		CellsGet,
 		CsvGet,
 		DropdownGet,
+		TableGet,
 
 		// lark_sheet_search_replace
 		CellsSearch,
@@ -67,6 +111,7 @@ func shortcutList() []common.Shortcut {
 		CellsSetImage,
 		CsvPut,
 		DropdownSet,
+		TablePut,
 
 		// lark_sheet_range_operations
 		CellsClear,

shortcuts/sheets/shortcuts_alias_test.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+// TestWithTokenAlias verifies the PostMount-based --token → --spreadsheet-token
+// alias: it resolves at parse time, and it composes onto (rather than replaces)
+// any pre-existing PostMount — the property that lets it coexist with
+// +csv-put's --range/--start-cell flag-group setup.
+func TestWithTokenAlias(t *testing.T) {
+	t.Parallel()
+
+	// Alias resolves to the canonical flag.
+	cmd := &cobra.Command{Use: "x"}
+	cmd.Flags().String("spreadsheet-token", "", "")
+	withTokenAlias(nil)(cmd)
+	if err := cmd.Flags().Parse([]string{"--token", "shtABC"}); err != nil {
+		t.Fatalf("--token should resolve as an alias: %v", err)
+	}
+	if got := cmd.Flags().Lookup("spreadsheet-token").Value.String(); got != "shtABC" {
+		t.Errorf("--token should set --spreadsheet-token; got %q", got)
+	}
+
+	// Composes with an existing PostMount instead of dropping it.
+	prevRan := false
+	cmd2 := &cobra.Command{Use: "y"}
+	cmd2.Flags().String("spreadsheet-token", "", "")
+	withTokenAlias(func(_ *cobra.Command) { prevRan = true })(cmd2)
+	if !prevRan {
+		t.Error("pre-existing PostMount should still run")
+	}
+	if err := cmd2.Flags().Parse([]string{"--token", "shtZ"}); err != nil {
+		t.Fatalf("--token should still resolve when composed: %v", err)
+	}
+}
+
+// TestShortcuts_TokenAliasOnSpreadsheetTokenCommands asserts every shortcut that
+// takes --spreadsheet-token ends up with a PostMount (the composed token alias),
+// so the reflex typo is forgiven wherever the canonical flag exists.
+func TestShortcuts_TokenAliasOnSpreadsheetTokenCommands(t *testing.T) {
+	t.Parallel()
+	for _, s := range Shortcuts() {
+		if hasFlag(s.Flags, "spreadsheet-token") && s.PostMount == nil {
+			t.Errorf("%s takes --spreadsheet-token but has no PostMount (token alias missing)", s.Command)
+		}
+	}
+}

shortcuts/task/shortcuts.go

@@ -242,7 +242,6 @@ func Shortcuts() []common.Shortcut {
 		GetMyTasks,
 		GetRelatedTasks,
 		SearchTask,
-		SubscribeTaskEvent,
 		UploadAttachmentTask,
 		CreateTasklist,
 		SearchTasklist,

shortcuts/task/task_subscribe_event.go

@@ -1,40 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package task
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-var SubscribeTaskEvent = common.Shortcut{
-	Service:     "task",
-	Command:     "+subscribe-event",
-	Description: "subscribe to task events",
-	Risk:        "write",
-	Scopes:      []string{"task:task:read"},
-	AuthTypes:   []string{"user", "bot"},
-	HasFormat:   true,
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		return common.NewDryRunAPI().
-			POST("/open-apis/task/v2/task_v2/task_subscription").
-			Params(map[string]interface{}{"user_id_type": "open_id"})
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		params := map[string]interface{}{"user_id_type": "open_id"}
-		if _, err := callTaskAPITyped(runtime, http.MethodPost, "/open-apis/task/v2/task_v2/task_subscription", params, nil); err != nil {
-			return err
-		}
-
-		outData := map[string]interface{}{"ok": true}
-		runtime.OutFormat(outData, nil, func(w io.Writer) {
-			fmt.Fprintln(w, "✅ Task event subscription created successfully!")
-		})
-		return nil
-	},
-}

shortcuts/task/task_subscribe_event_test.go

@@ -1,163 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package task
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-func TestSubscribeTaskEvent(t *testing.T) {
-	tests := []struct {
-		name      string
-		mode      string
-		args      []string
-		register  func(*httpmock.Registry)
-		wantErr   bool
-		wantParts []string
-	}{
-		{
-			name: "execute json (user identity)",
-			mode: "execute",
-			args: []string{"+subscribe-event", "--as", "user", "--format", "json"},
-			register: func(reg *httpmock.Registry) {
-				reg.Register(&httpmock.Stub{
-					Method: "POST",
-					URL:    "/open-apis/task/v2/task_v2/task_subscription",
-					Body: map[string]interface{}{
-						"code": 0,
-						"msg":  "success",
-						"data": map[string]interface{}{},
-					},
-				})
-			},
-			wantParts: []string{`"ok": true`},
-		},
-		{
-			name: "execute json (bot identity)",
-			mode: "execute",
-			args: []string{"+subscribe-event", "--as", "bot", "--format", "json"},
-			register: func(reg *httpmock.Registry) {
-				reg.Register(&httpmock.Stub{
-					Method: "POST",
-					URL:    "/open-apis/task/v2/task_v2/task_subscription",
-					Body: map[string]interface{}{
-						"code": 0,
-						"msg":  "success",
-						"data": map[string]interface{}{},
-					},
-				})
-			},
-			wantParts: []string{`"ok": true`},
-		},
-		{
-			name: "execute api error",
-			mode: "execute",
-			args: []string{"+subscribe-event", "--as", "bot", "--format", "json"},
-			register: func(reg *httpmock.Registry) {
-				reg.Register(&httpmock.Stub{
-					Method: "POST",
-					URL:    "/open-apis/task/v2/task_v2/task_subscription",
-					Body: map[string]interface{}{
-						"code": 401,
-						"msg":  "Unauthorized",
-						"error": map[string]interface{}{
-							"log_id": "test-log-id",
-						},
-					},
-				})
-			},
-			wantErr:   true,
-			wantParts: []string{"Unauthorized"},
-		},
-		{
-			name:      "dry run",
-			mode:      "dryrun",
-			wantParts: []string{"POST /open-apis/task/v2/task_v2/task_subscription"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch tt.mode {
-			case "execute":
-				f, stdout, _, reg := taskShortcutTestFactory(t)
-				warmTenantToken(t, f, reg)
-				if tt.register != nil {
-					tt.register(reg)
-				}
-
-				err := runMountedTaskShortcut(t, SubscribeTaskEvent, tt.args, f, stdout)
-				if tt.wantErr {
-					if err == nil {
-						t.Fatal("expected error, got nil")
-					}
-					out := err.Error()
-					for _, want := range tt.wantParts {
-						if !strings.Contains(out, want) {
-							t.Fatalf("error missing %q: %s", want, out)
-						}
-					}
-					return
-				}
-				if err != nil {
-					t.Fatalf("runMountedTaskShortcut() error = %v", err)
-				}
-
-				out := stdout.String()
-				outNorm := strings.ReplaceAll(out, `":"`, `": "`)
-				for _, want := range tt.wantParts {
-					if !strings.Contains(out, want) && !strings.Contains(outNorm, want) {
-						t.Fatalf("output missing %q: %s", want, out)
-					}
-				}
-			case "dryrun":
-				runtime := common.TestNewRuntimeContextWithIdentity(&cobra.Command{Use: "test"}, taskTestConfig(t), "user")
-				out := SubscribeTaskEvent.DryRun(nil, runtime).Format()
-				for _, want := range tt.wantParts {
-					if !strings.Contains(out, want) {
-						t.Fatalf("dry run output missing %q: %s", want, out)
-					}
-				}
-			}
-		})
-	}
-}
-
-// TestSubscribeTaskEvent_MalformedResponse covers the parse-response arm: a 200
-// with an unparseable body surfaces a typed internal invalid_response error
-// (exit 5).
-func TestSubscribeTaskEvent_MalformedResponse(t *testing.T) {
-	f, stdout, _, reg := taskShortcutTestFactory(t)
-	warmTenantToken(t, f, reg)
-
-	reg.Register(&httpmock.Stub{
-		Method:  "POST",
-		URL:     "/open-apis/task/v2/task_v2/task_subscription",
-		Status:  200,
-		RawBody: []byte("{not-json"),
-	})
-
-	args := []string{"+subscribe-event", "--as", "bot", "--format", "json"}
-	err := runMountedTaskShortcut(t, SubscribeTaskEvent, args, f, stdout)
-
-	var ie *errs.InternalError
-	if !errors.As(err, &ie) {
-		t.Fatalf("err = %T, want *errs.InternalError; err = %v", err, err)
-	}
-	if ie.Subtype != errs.SubtypeInvalidResponse {
-		t.Errorf("subtype = %q, want %q", ie.Subtype, errs.SubtypeInvalidResponse)
-	}
-	if got := output.ExitCodeOf(err); got != output.ExitInternal {
-		t.Errorf("exit code = %d, want %d", got, output.ExitInternal)
-	}
-}

shortcuts/whiteboard/whiteboard_query.go

@@ -5,6 +5,7 @@ package whiteboard
 import (
 	"bytes"
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -21,40 +22,54 @@ import (
 )
 
 const (
+	// WhiteboardQueryAsImage exports a whiteboard preview image.
 	WhiteboardQueryAsImage = "image"
-	WhiteboardQueryAsCode  = "code"
-	WhiteboardQueryAsRaw   = "raw"
+	// WhiteboardQueryAsSvg exports a whiteboard as SVG.
+	WhiteboardQueryAsSvg = "svg"
+	// WhiteboardQueryAsCode exports Mermaid or PlantUML source extracted from the whiteboard.
+	WhiteboardQueryAsCode = "code"
+	// WhiteboardQueryAsRaw exports the raw whiteboard node payload.
+	WhiteboardQueryAsRaw = "raw"
 )
 
+// SyntaxType identifies the diagram syntax extracted from whiteboard code blocks.
 type SyntaxType int
 
 const (
+	// SyntaxTypePlantUML marks PlantUML code blocks.
 	SyntaxTypePlantUML SyntaxType = 1
-	SyntaxTypeMermaid  SyntaxType = 2
+	// SyntaxTypeMermaid marks Mermaid code blocks.
+	SyntaxTypeMermaid SyntaxType = 2
 )
 
+// SyntaxTypeNameMap maps whiteboard syntax types to their CLI output names.
 var SyntaxTypeNameMap = map[SyntaxType]string{
 	SyntaxTypePlantUML: "plantuml",
 	SyntaxTypeMermaid:  "mermaid",
 }
 
+// SyntaxTypeExtensionMap maps whiteboard syntax types to their default file extensions.
 var SyntaxTypeExtensionMap = map[SyntaxType]string{
 	SyntaxTypePlantUML: ".puml",
 	SyntaxTypeMermaid:  ".mmd",
 }
 
+// String returns the CLI-facing name for the syntax type.
 func (s SyntaxType) String() string {
 	return SyntaxTypeNameMap[s]
 }
 
+// ExtensionName returns the default file extension for the syntax type.
 func (s SyntaxType) ExtensionName() string {
 	return SyntaxTypeExtensionMap[s]
 }
 
+// IsValid reports whether the syntax type is one of the supported whiteboard code syntaxes.
 func (s SyntaxType) IsValid() bool {
 	return s == SyntaxTypePlantUML || s == SyntaxTypeMermaid
 }
 
+// WhiteboardQuery registers the `whiteboard +query` shortcut.
 var WhiteboardQuery = common.Shortcut{
 	Service:     "whiteboard",
 	Command:     "+query",
@@ -64,8 +79,8 @@ var WhiteboardQuery = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "whiteboard-token", Desc: "whiteboard token of the whiteboard. You will need read permission to download preview image.", Required: true},
-		{Name: "output_as", Desc: "output whiteboard as: image | code | raw.", Required: true},
-		{Name: "output", Desc: "output directory. It is required when output as image. If not specified when --output_as code/raw, it will output directly.", Required: false},
+		{Name: "output_as", Desc: "output whiteboard as: image | svg | code | raw.", Required: true},
+		{Name: "output", Desc: "output directory. It is required when output as image. If not specified when --output_as svg/code/raw, it will output directly.", Required: false},
 		{Name: "overwrite", Desc: "overwrite existing file if it exists", Required: false, Type: "bool"},
 	},
 	HasFormat: true,
@@ -86,8 +101,8 @@ var WhiteboardQuery = common.Shortcut{
 		}
 
 		as := runtime.Str("output_as")
-		if as != WhiteboardQueryAsImage && as != WhiteboardQueryAsCode && as != WhiteboardQueryAsRaw {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--output_as flag must be one of: image | code | raw").WithParam("--output_as")
+		if as != WhiteboardQueryAsImage && as != WhiteboardQueryAsSvg && as != WhiteboardQueryAsCode && as != WhiteboardQueryAsRaw {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--output_as flag must be one of: image | svg | code | raw").WithParam("--output_as")
 		}
 		return nil
 	},
@@ -107,8 +122,13 @@ var WhiteboardQuery = common.Shortcut{
 			return common.NewDryRunAPI().
 				GET(fmt.Sprintf("/open-apis/board/v1/whiteboards/%s/nodes", common.MaskToken(url.PathEscape(token)))).
 				Desc("Extract raw nodes structure from given whiteboard")
+		case WhiteboardQueryAsSvg:
+			return common.NewDryRunAPI().
+				POST(fmt.Sprintf("/open-apis/board/v1/whiteboards/%s/export", common.MaskToken(url.PathEscape(token)))).
+				Body(map[string]string{"export_type": "svg"}).
+				Desc("Export SVG of given whiteboard")
 		default:
-			return common.NewDryRunAPI().Desc("invalid --output_as flag, must be one of: image | code | raw")
+			return common.NewDryRunAPI().Desc("invalid --output_as flag, must be one of: image | svg | code | raw")
 		}
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -119,17 +139,105 @@ var WhiteboardQuery = common.Shortcut{
 		switch as {
 		case WhiteboardQueryAsImage:
 			return exportWhiteboardPreview(ctx, runtime, token, outDir)
+		case WhiteboardQueryAsSvg:
+			return exportWhiteboardSvg(runtime, token, outDir)
 		case WhiteboardQueryAsCode:
 			return exportWhiteboardCode(runtime, token, outDir)
 		case WhiteboardQueryAsRaw:
 			return exportWhiteboardRaw(runtime, token, outDir)
 		default:
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--output_as flag must be one of: image | code | raw").WithParam("--output_as")
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--output_as flag must be one of: image | svg | code | raw").WithParam("--output_as")
 		}
 
 	},
 }
 
+// exportReq defines the request body for whiteboard export APIs.
+type exportReq struct {
+	ExportType string `json:"export_type"`
+}
+
+// exportResp models the whiteboard export response envelope.
+type exportResp struct {
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+	Data struct {
+		Content  string `json:"content"`
+		MimeType string `json:"mime_type"`
+	} `json:"data"`
+}
+
+// exportWhiteboardSvg exports a whiteboard as SVG and writes it to stdout or a file.
+func exportWhiteboardSvg(runtime *common.RuntimeContext, wbToken, outDir string) error {
+	reqBody := exportReq{ExportType: "svg"}
+	req := &larkcore.ApiReq{
+		HttpMethod: http.MethodPost,
+		ApiPath:    fmt.Sprintf("/open-apis/board/v1/whiteboards/%s/export", url.PathEscape(wbToken)),
+		Body:       reqBody,
+	}
+
+	resp, err := runtime.DoAPI(req)
+	if err != nil {
+		return wrapWbNetworkErr(err, "export whiteboard svg failed: %v", err)
+	}
+
+	var exportData exportResp
+	if err := json.Unmarshal(resp.RawBody, &exportData); err == nil {
+		if exportData.Code != 0 {
+			subtype := errs.SubtypeUnknown
+			if resp.StatusCode == http.StatusNotFound {
+				subtype = errs.SubtypeNotFound
+			}
+			return errs.NewAPIError(subtype, "export whiteboard svg failed: %s", exportData.Msg).WithCode(exportData.Code)
+		}
+	} else if resp.StatusCode == http.StatusOK {
+		return errs.NewInternalError(errs.SubtypeInvalidResponse, "parse export response failed: %v", err).WithCause(err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		body := common.TruncateStr(strings.TrimSpace(string(resp.RawBody)), 500)
+		if resp.StatusCode >= 500 {
+			return errs.NewNetworkError(errs.SubtypeNetworkServer, "export whiteboard svg failed: HTTP %d: %s", resp.StatusCode, body).
+				WithCode(resp.StatusCode).
+				WithRetryable()
+		}
+		subtype := errs.SubtypeUnknown
+		if resp.StatusCode == http.StatusNotFound {
+			subtype = errs.SubtypeNotFound
+		}
+		return errs.NewAPIError(subtype, "export whiteboard svg failed: HTTP %d: %s", resp.StatusCode, body).
+			WithCode(resp.StatusCode)
+	}
+
+	svgBytes, err := base64.StdEncoding.DecodeString(exportData.Data.Content)
+	if err != nil {
+		return errs.NewInternalError(errs.SubtypeInvalidResponse, "decode svg base64 failed: %v", err).WithCause(err)
+	}
+
+	if outDir == "" {
+		runtime.OutFormat(map[string]interface{}{
+			"svg_content": string(svgBytes),
+		}, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "%s\n", string(svgBytes))
+		})
+		return nil
+	}
+
+	finalPath, size, err := saveOutputFile(outDir, ".svg", wbToken, runtime, bytes.NewReader(svgBytes))
+	if err != nil {
+		return err
+	}
+
+	runtime.OutFormat(map[string]interface{}{
+		"svg_path":   finalPath,
+		"size_bytes": size,
+	}, nil, func(w io.Writer) {
+		fmt.Fprintf(w, "SVG saved to %s\n", finalPath)
+		fmt.Fprintf(w, "File size: %d bytes", size)
+	})
+	return nil
+}
+
 func exportWhiteboardPreview(ctx context.Context, runtime *common.RuntimeContext, wbToken, outDir string) error {
 	req := &larkcore.ApiReq{
 		HttpMethod: http.MethodGet,
@@ -367,6 +475,8 @@ func saveOutputFile(outPath, ext, token string, runtime *common.RuntimeContext,
 	switch ext {
 	case ".png":
 		contentType = "image/png"
+	case ".svg":
+		contentType = "image/svg+xml"
 	case ".json":
 		contentType = "application/json"
 	case ".mmd", ".puml":

shortcuts/whiteboard/whiteboard_query_test.go

@@ -6,6 +6,8 @@ package whiteboard
 import (
 	"bytes"
 	"context"
+	"encoding/base64"
+	"encoding/json"
 	"errors"
 	"os"
 	"path/filepath"
@@ -13,6 +15,7 @@ import (
 	"testing"
 
 	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/extension/fileio"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/httpmock"
@@ -20,6 +23,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// TestSyntaxType verifies syntax names, extensions, and validity checks.
 func TestSyntaxType(t *testing.T) {
 	t.Parallel()
 
@@ -75,6 +79,7 @@ func TestSyntaxType(t *testing.T) {
 	}
 }
 
+// TestWhiteboardQuery_Validate verifies query flag validation for supported output modes.
 func TestWhiteboardQuery_Validate(t *testing.T) {
 	ctx := context.Background()
 	chdirTemp(t)
@@ -199,6 +204,9 @@ func TestWhiteboardQuery_Validate_TypedErrors(t *testing.T) {
 			if p.Category != errs.CategoryValidation {
 				t.Errorf("Category = %q, want %q", p.Category, errs.CategoryValidation)
 			}
+			if p.Subtype != errs.SubtypeInvalidArgument {
+				t.Errorf("Problem subtype = %q, want %q", p.Subtype, errs.SubtypeInvalidArgument)
+			}
 		})
 	}
 }
@@ -232,6 +240,7 @@ func TestExportWhiteboardPreview_HTTPError(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardPreview_HTTPNotFoundIsAPIError verifies 404 preview downloads surface as typed API errors.
 func TestExportWhiteboardPreview_HTTPNotFoundIsAPIError(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 	chdirTemp(t)
@@ -255,6 +264,7 @@ func TestExportWhiteboardPreview_HTTPNotFoundIsAPIError(t *testing.T) {
 	}
 }
 
+// TestWhiteboardQuery_DryRun verifies dry-run output for the supported query modes.
 func TestWhiteboardQuery_DryRun(t *testing.T) {
 	t.Parallel()
 
@@ -307,6 +317,64 @@ func TestWhiteboardQuery_DryRun(t *testing.T) {
 	}
 }
 
+// TestWhiteboardQuery_DryRun_InvalidOutputAs verifies dry-run guidance for unsupported output modes.
+func TestWhiteboardQuery_DryRun_InvalidOutputAs(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	rt := newTestRuntime(map[string]string{
+		"whiteboard-token": "test-token-123",
+		"output_as":        "invalid",
+	}, nil)
+
+	dryRun := WhiteboardQuery.DryRun(ctx, rt)
+	if dryRun == nil {
+		t.Fatal("WhiteboardQuery.DryRun() returned nil")
+	}
+
+	data, err := json.Marshal(dryRun)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+	if !strings.Contains(string(data), "image | svg | code | raw") {
+		t.Fatalf("dry run desc = %s, want invalid output_as guidance", string(data))
+	}
+}
+
+// TestWhiteboardQuery_Execute_InvalidOutputAs_TypedError verifies invalid output modes return typed validation errors.
+func TestWhiteboardQuery_Execute_InvalidOutputAs_TypedError(t *testing.T) {
+	rt := newTestRuntime(map[string]string{
+		"whiteboard-token": "test-token-123",
+		"output_as":        "invalid",
+	}, nil)
+
+	err := WhiteboardQuery.Execute(context.Background(), rt)
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) {
+		t.Fatalf("error is not *errs.ValidationError: %T (%v)", err, err)
+	}
+	if ve.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("Subtype = %q, want %q", ve.Subtype, errs.SubtypeInvalidArgument)
+	}
+	if ve.Param != "--output_as" {
+		t.Errorf("Param = %q, want %q", ve.Param, "--output_as")
+	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("errs.ProblemOf returned false")
+	}
+	if p.Category != errs.CategoryValidation {
+		t.Errorf("Category = %q, want %q", p.Category, errs.CategoryValidation)
+	}
+	if p.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("Problem subtype = %q, want %q", p.Subtype, errs.SubtypeInvalidArgument)
+	}
+}
+
+// TestWhiteboardQuery_ShortcutRegistration verifies the whiteboard query shortcut metadata.
 func TestWhiteboardQuery_ShortcutRegistration(t *testing.T) {
 	t.Parallel()
 
@@ -325,6 +393,7 @@ func TestWhiteboardQuery_ShortcutRegistration(t *testing.T) {
 	}
 }
 
+// TestSaveOutputFile verifies output saving, overwrite handling, and extension-specific paths.
 func TestSaveOutputFile(t *testing.T) {
 	t.Parallel()
 
@@ -476,6 +545,7 @@ func TestSaveOutputFile(t *testing.T) {
 	}
 }
 
+// TestSaveOutputFile_InvalidFinalPathTypedError verifies invalid save paths return typed validation errors.
 func TestSaveOutputFile_InvalidFinalPathTypedError(t *testing.T) {
 	chdirTemp(t)
 
@@ -491,6 +561,19 @@ func TestSaveOutputFile_InvalidFinalPathTypedError(t *testing.T) {
 	if ve.Subtype != errs.SubtypeInvalidArgument || ve.Param != "--output" {
 		t.Fatalf("validation details = subtype %q param %q, want %q --output", ve.Subtype, ve.Param, errs.SubtypeInvalidArgument)
 	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("errs.ProblemOf returned false")
+	}
+	if p.Category != errs.CategoryValidation {
+		t.Errorf("Category = %q, want %q", p.Category, errs.CategoryValidation)
+	}
+	if p.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("Problem subtype = %q, want %q", p.Subtype, errs.SubtypeInvalidArgument)
+	}
+	if !errors.Is(err, fileio.ErrPathValidation) {
+		t.Fatalf("expected path-validation cause to be preserved, err=%v", err)
+	}
 }
 
 func newExecuteFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *httpmock.Registry) {
@@ -525,6 +608,7 @@ func runShortcut(t *testing.T, shortcut common.Shortcut, args []string, factory
 	return err
 }
 
+// TestWhiteboardQueryExecute_AsRaw verifies raw query execution emits the raw node payload.
 func TestWhiteboardQueryExecute_AsRaw(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -553,6 +637,7 @@ func TestWhiteboardQueryExecute_AsRaw(t *testing.T) {
 	}
 }
 
+// TestWhiteboardQueryExecute_AsCode verifies code query execution emits extracted diagram source.
 func TestWhiteboardQueryExecute_AsCode(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 	chdirTemp(t)
@@ -583,6 +668,7 @@ func TestWhiteboardQueryExecute_AsCode(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardCode_EmptyNodes verifies code export handles empty whiteboards.
 func TestExportWhiteboardCode_EmptyNodes(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -605,6 +691,7 @@ func TestExportWhiteboardCode_EmptyNodes(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardCode_NoCodeBlocks verifies code export reports whiteboards without code blocks.
 func TestExportWhiteboardCode_NoCodeBlocks(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -629,6 +716,7 @@ func TestExportWhiteboardCode_NoCodeBlocks(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardCode_InvalidSyntaxType verifies unknown syntax types are rejected.
 func TestExportWhiteboardCode_InvalidSyntaxType(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -658,6 +746,7 @@ func TestExportWhiteboardCode_InvalidSyntaxType(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardCode_MultipleCodeBlocks verifies multiple code blocks are exported together.
 func TestExportWhiteboardCode_MultipleCodeBlocks(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -697,6 +786,7 @@ func TestExportWhiteboardCode_MultipleCodeBlocks(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardCode_SingleBlock_PlantUML_DirectOutput verifies direct PlantUML output for a single code block.
 func TestExportWhiteboardCode_SingleBlock_PlantUML_DirectOutput(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -730,6 +820,7 @@ func TestExportWhiteboardCode_SingleBlock_PlantUML_DirectOutput(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardCode_SingleBlock_Mermaid_DirectOutput verifies direct Mermaid output for a single code block.
 func TestExportWhiteboardCode_SingleBlock_Mermaid_DirectOutput(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -763,6 +854,7 @@ func TestExportWhiteboardCode_SingleBlock_Mermaid_DirectOutput(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardPreview verifies preview downloads can be written to disk.
 func TestExportWhiteboardPreview(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -791,6 +883,7 @@ func TestExportWhiteboardPreview(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardRaw_EmptyNodes verifies raw export reports empty whiteboards.
 func TestExportWhiteboardRaw_EmptyNodes(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -813,6 +906,7 @@ func TestExportWhiteboardRaw_EmptyNodes(t *testing.T) {
 	}
 }
 
+// TestFetchWhiteboardNodes_APIError verifies node fetch failures preserve typed API errors.
 func TestFetchWhiteboardNodes_APIError(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
 
@@ -842,6 +936,7 @@ func TestFetchWhiteboardNodes_APIError(t *testing.T) {
 	}
 }
 
+// TestFetchWhiteboardNodes_InvalidResponseTypedError verifies malformed node responses become typed invalid-response errors.
 func TestFetchWhiteboardNodes_InvalidResponseTypedError(t *testing.T) {
 	tests := []struct {
 		name  string
@@ -901,6 +996,482 @@ func TestFetchWhiteboardNodes_MissingNodesIsEmpty(t *testing.T) {
 	}
 }
 
+// TestExportWhiteboardSvg_DirectOutput verifies SVG export is printed when no output path is provided.
+func TestExportWhiteboardSvg_DirectOutput(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	svgContent := `<svg xmlns="http://www.w3.org/2000/svg"><rect width="100" height="100"/></svg>`
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg/export",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"content":   base64.StdEncoding.EncodeToString([]byte(svgContent)),
+				"mime_type": "image/svg+xml",
+			},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg", "--output_as", "svg"}
+	if err := runShortcut(t, WhiteboardQuery, args, factory, stdout); err != nil {
+		t.Fatalf("err=%v", err)
+	}
+
+	if !strings.Contains(stdout.String(), "svg_content") {
+		t.Fatalf("stdout missing svg_content key: %s", stdout.String())
+	}
+}
+
+// TestExportWhiteboardSvg_SaveToFile verifies SVG export is written to the requested file.
+func TestExportWhiteboardSvg_SaveToFile(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+	chdirTemp(t)
+
+	svgContent := `<svg xmlns="http://www.w3.org/2000/svg"><circle cx="50" cy="50" r="40"/></svg>`
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg-file/export",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"content":   base64.StdEncoding.EncodeToString([]byte(svgContent)),
+				"mime_type": "image/svg+xml",
+			},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-file", "--output_as", "svg", "--output", "output", "--overwrite"}
+	if err := runShortcut(t, WhiteboardQuery, args, factory, stdout); err != nil {
+		t.Fatalf("err=%v", err)
+	}
+
+	data, err := os.ReadFile("output.svg")
+	if err != nil {
+		t.Fatalf("ReadFile() error: %v", err)
+	}
+	if string(data) != svgContent {
+		t.Fatalf("svg content = %q, want %q", string(data), svgContent)
+	}
+}
+
+// TestExportWhiteboardSvg_PrettyOutput verifies pretty output includes inline SVG content.
+func TestExportWhiteboardSvg_PrettyOutput(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	svgContent := `<svg xmlns="http://www.w3.org/2000/svg"><path d="M0 0L10 10"/></svg>`
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg-pretty/export",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"content":   base64.StdEncoding.EncodeToString([]byte(svgContent)),
+				"mime_type": "image/svg+xml",
+			},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-pretty", "--output_as", "svg", "--format", "pretty"}
+	if err := runShortcut(t, WhiteboardQuery, args, factory, stdout); err != nil {
+		t.Fatalf("err=%v", err)
+	}
+
+	if got := stdout.String(); !strings.Contains(got, svgContent) {
+		t.Fatalf("stdout = %q, want svg content", got)
+	}
+}
+
+// TestExportWhiteboardSvg_SaveToFile_PrettyOutput verifies pretty output reports the saved SVG path and size.
+func TestExportWhiteboardSvg_SaveToFile_PrettyOutput(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+	chdirTemp(t)
+
+	svgContent := `<svg xmlns="http://www.w3.org/2000/svg"><ellipse cx="60" cy="40" rx="50" ry="30"/></svg>`
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg-file-pretty/export",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"content":   base64.StdEncoding.EncodeToString([]byte(svgContent)),
+				"mime_type": "image/svg+xml",
+			},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-file-pretty", "--output_as", "svg", "--output", "output", "--overwrite", "--format", "pretty"}
+	if err := runShortcut(t, WhiteboardQuery, args, factory, stdout); err != nil {
+		t.Fatalf("err=%v", err)
+	}
+
+	if got := stdout.String(); !strings.Contains(got, "SVG saved to output.svg") || !strings.Contains(got, "File size:") {
+		t.Fatalf("stdout = %q, want save summary", got)
+	}
+
+	data, err := os.ReadFile("output.svg")
+	if err != nil {
+		t.Fatalf("ReadFile() error: %v", err)
+	}
+	if string(data) != svgContent {
+		t.Fatalf("svg content = %q, want %q", string(data), svgContent)
+	}
+}
+
+// TestExportWhiteboardSvg_SaveToFile_ExistingFileWithoutOverwrite verifies existing SVG outputs require --overwrite.
+func TestExportWhiteboardSvg_SaveToFile_ExistingFileWithoutOverwrite(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+	chdirTemp(t)
+
+	if err := os.WriteFile("output.svg", []byte("existing content"), 0644); err != nil {
+		t.Fatalf("WriteFile() error = %v", err)
+	}
+
+	svgContent := `<svg xmlns="http://www.w3.org/2000/svg"><line x1="0" y1="0" x2="1" y2="1"/></svg>`
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg-existing/export",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"content":   base64.StdEncoding.EncodeToString([]byte(svgContent)),
+				"mime_type": "image/svg+xml",
+			},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-existing", "--output_as", "svg", "--output", "output"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for existing output without overwrite")
+	}
+
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) {
+		t.Fatalf("error is not *errs.ValidationError: %T (%v)", err, err)
+	}
+	if ve.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("Subtype = %q, want %q", ve.Subtype, errs.SubtypeInvalidArgument)
+	}
+	if ve.Param != "--overwrite" {
+		t.Errorf("Param = %q, want %q", ve.Param, "--overwrite")
+	}
+}
+
+// TestExportWhiteboardSvg_HTTP5xx verifies plain HTTP 5xx failures are classified as retryable network errors.
+func TestExportWhiteboardSvg_HTTP5xx(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/test-token-svg-5xx/export",
+		Status:      502,
+		RawBody:     []byte("bad gateway"),
+		ContentType: "text/plain",
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-5xx", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for HTTP 502")
+	}
+	var ne *errs.NetworkError
+	if !errors.As(err, &ne) {
+		t.Fatalf("error is not *errs.NetworkError: %T (%v)", err, err)
+	}
+	if ne.Subtype != errs.SubtypeNetworkServer {
+		t.Errorf("Subtype = %q, want %q", ne.Subtype, errs.SubtypeNetworkServer)
+	}
+	if ne.Code != 502 {
+		t.Errorf("Code = %d, want 502", ne.Code)
+	}
+	if !ne.Retryable {
+		t.Error("expected Retryable = true")
+	}
+}
+
+// TestExportWhiteboardSvg_HTTP5xxJSONEnvelopeReturnsAPIError verifies API envelopes take precedence over generic 5xx handling.
+func TestExportWhiteboardSvg_HTTP5xxJSONEnvelopeReturnsAPIError(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/test-token-svg-5xx-json/export",
+		Status:      502,
+		ContentType: "application/json",
+		RawBody:     []byte(`{"code":99002,"msg":"export task failed"}`),
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-5xx-json", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for HTTP 502 JSON envelope")
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error is not *errs.APIError: %T (%v)", err, err)
+	}
+	var ne *errs.NetworkError
+	if errors.As(err, &ne) {
+		t.Fatalf("expected JSON envelope to win over HTTP 5xx fallback, got *errs.NetworkError: %v", err)
+	}
+	if apiErr.Subtype != errs.SubtypeUnknown {
+		t.Errorf("Subtype = %q, want %q", apiErr.Subtype, errs.SubtypeUnknown)
+	}
+	if apiErr.Code != 99002 {
+		t.Errorf("Code = %d, want 99002", apiErr.Code)
+	}
+}
+
+// TestExportWhiteboardSvg_HTTP4xx verifies plain HTTP 4xx failures are surfaced as API errors.
+func TestExportWhiteboardSvg_HTTP4xx(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/test-token-svg-403/export",
+		Status:      403,
+		RawBody:     []byte("forbidden"),
+		ContentType: "text/plain",
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-403", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for HTTP 403")
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error is not *errs.APIError: %T (%v)", err, err)
+	}
+	if apiErr.Subtype != errs.SubtypeUnknown {
+		t.Errorf("Subtype = %q, want %q", apiErr.Subtype, errs.SubtypeUnknown)
+	}
+	if apiErr.Code != 403 {
+		t.Errorf("Code = %d, want 403", apiErr.Code)
+	}
+}
+
+// TestExportWhiteboardSvg_HTTPNotFoundJSONEnvelopeIsAPIError verifies not-found envelopes preserve the typed API error classification.
+func TestExportWhiteboardSvg_HTTPNotFoundJSONEnvelopeIsAPIError(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/missing-token-svg/export",
+		Status:      404,
+		ContentType: "application/json",
+		RawBody:     []byte(`{"code":99001,"msg":"whiteboard not found"}`),
+	})
+
+	args := []string{"+query", "--whiteboard-token", "missing-token-svg", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for HTTP 404 JSON envelope")
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error is not *errs.APIError: %T (%v)", err, err)
+	}
+	if apiErr.Subtype != errs.SubtypeNotFound {
+		t.Errorf("Subtype = %q, want %q", apiErr.Subtype, errs.SubtypeNotFound)
+	}
+	if apiErr.Code != 99001 {
+		t.Errorf("Code = %d, want 99001", apiErr.Code)
+	}
+}
+
+// TestExportWhiteboardSvg_HTTPNotFoundPlainText verifies plain-text 404 responses surface as not-found API errors.
+func TestExportWhiteboardSvg_HTTPNotFoundPlainText(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/missing-token-svg-plain/export",
+		Status:      404,
+		ContentType: "text/plain",
+		RawBody:     []byte("whiteboard not found"),
+	})
+
+	args := []string{"+query", "--whiteboard-token", "missing-token-svg-plain", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for HTTP 404 plain text response")
+	}
+
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error is not *errs.APIError: %T (%v)", err, err)
+	}
+	if apiErr.Subtype != errs.SubtypeNotFound {
+		t.Errorf("Subtype = %q, want %q", apiErr.Subtype, errs.SubtypeNotFound)
+	}
+	if apiErr.Code != 404 {
+		t.Errorf("Code = %d, want 404", apiErr.Code)
+	}
+}
+
+// TestExportWhiteboardSvg_InvalidJSON verifies malformed success responses are rejected as invalid responses.
+func TestExportWhiteboardSvg_InvalidJSON(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/test-token-svg-badjson/export",
+		Status:      200,
+		RawBody:     []byte("not json at all"),
+		ContentType: "application/json",
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-badjson", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for invalid JSON")
+	}
+	assertInvalidResponse(t, err)
+}
+
+// TestExportWhiteboardSvg_InvalidBody200PlainText verifies plain-text 200 responses are rejected as invalid export responses.
+func TestExportWhiteboardSvg_InvalidBody200PlainText(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/board/v1/whiteboards/test-token-svg-plain-200/export",
+		Status:      200,
+		RawBody:     []byte("not json at all"),
+		ContentType: "text/plain",
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-plain-200", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for plain text success response")
+	}
+	assertInvalidResponse(t, err)
+}
+
+// TestExportWhiteboardSvg_NonZeroCode verifies non-zero API codes are returned as typed API errors.
+func TestExportWhiteboardSvg_NonZeroCode(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg-apierr/export",
+		Body: map[string]interface{}{
+			"code": 99001,
+			"msg":  "whiteboard not found",
+			"data": map[string]interface{}{},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-apierr", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for non-zero code")
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error is not *errs.APIError: %T (%v)", err, err)
+	}
+	if apiErr.Code != 99001 {
+		t.Errorf("Code = %d, want 99001", apiErr.Code)
+	}
+}
+
+// TestExportWhiteboardSvg_InvalidBase64 verifies invalid SVG payload encoding is rejected.
+func TestExportWhiteboardSvg_InvalidBase64(t *testing.T) {
+	factory, stdout, reg := newExecuteFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg-badbase64/export",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"content":   "!!!not-valid-base64!!!",
+				"mime_type": "image/svg+xml",
+			},
+		},
+	})
+
+	args := []string{"+query", "--whiteboard-token", "test-token-svg-badbase64", "--output_as", "svg"}
+	err := runShortcut(t, WhiteboardQuery, args, factory, stdout)
+	if err == nil {
+		t.Fatal("expected error for invalid base64")
+	}
+	assertInvalidResponse(t, err)
+}
+
+// TestWhiteboardQuery_Validate_SvgValid verifies svg is accepted as a valid query output format.
+func TestWhiteboardQuery_Validate_SvgValid(t *testing.T) {
+	ctx := context.Background()
+	chdirTemp(t)
+
+	rt := newTestRuntime(map[string]string{
+		"whiteboard-token": "test-token-123",
+		"output_as":        "svg",
+	}, nil)
+	if err := WhiteboardQuery.Validate(ctx, rt); err != nil {
+		t.Fatalf("expected svg to be valid, got err=%v", err)
+	}
+}
+
+// TestWhiteboardQuery_DryRun_Svg verifies the svg dry-run request uses the export endpoint and body.
+func TestWhiteboardQuery_DryRun_Svg(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	rt := newTestRuntime(map[string]string{
+		"whiteboard-token": "test-token-123",
+		"output_as":        "svg",
+	}, nil)
+	dryRun := WhiteboardQuery.DryRun(ctx, rt)
+	if dryRun == nil {
+		t.Fatal("DryRun() returned nil for svg")
+	}
+
+	data, err := json.Marshal(dryRun)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+
+	var got struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
+	if err := json.Unmarshal(data, &got); err != nil {
+		t.Fatalf("Unmarshal() error = %v", err)
+	}
+
+	if len(got.API) != 1 {
+		t.Fatalf("len(api) = %d, want 1", len(got.API))
+	}
+	if got.API[0].Method != "POST" {
+		t.Fatalf("method = %q, want POST", got.API[0].Method)
+	}
+	if got.API[0].URL != "/open-apis/board/v1/whiteboards/test...-123/export" {
+		t.Fatalf("url = %q", got.API[0].URL)
+	}
+	if got.API[0].Body["export_type"] != "svg" {
+		t.Fatalf("body = %#v, want export_type=svg", got.API[0].Body)
+	}
+	if _, ok := got.API[0].Params["export_type"]; ok {
+		t.Fatalf("params should not include export_type, got %#v", got.API[0].Params)
+	}
+}
+
+// assertInvalidResponse verifies an error is classified as a typed invalid-response failure.
 func assertInvalidResponse(t *testing.T, err error) {
 	t.Helper()
 	if err == nil {

shortcuts/whiteboard/whiteboard_update.go

@@ -17,15 +17,21 @@ import (
 )
 
 const (
-	FormatRaw      = "raw"
+	// FormatRaw sends raw whiteboard node JSON to the create-nodes API.
+	FormatRaw = "raw"
+	// FormatPlantUML sends PlantUML source through the diagram import API.
 	FormatPlantUML = "plantuml"
-	FormatMermaid  = "mermaid"
+	// FormatMermaid sends Mermaid source through the diagram import API.
+	FormatMermaid = "mermaid"
+	// FormatSVG sends SVG source through the diagram import API.
+	FormatSVG = "svg"
 )
 
 var formatCodeMap = map[string]int{
 	FormatRaw:      0,
 	FormatPlantUML: 1,
 	FormatMermaid:  2,
+	FormatSVG:      3,
 }
 
 var wbUpdateScopes = []string{"board:whiteboard:node:create"}
@@ -35,7 +41,7 @@ var wbUpdateFlags = []common.Flag{
 	{Name: "whiteboard-token", Desc: "whiteboard token of the whiteboard to update. You will need edit permission to update the whiteboard.", Required: true},
 	{Name: "overwrite", Desc: "overwrite the whiteboard content, delete all existing content before update. Default is false.", Required: false, Type: "bool"},
 	{Name: "source", Desc: "Input whiteboard data.", Required: true, Input: []string{common.Stdin, common.File}},
-	{Name: "input_format", Desc: "format of input data: raw | plantuml | mermaid. Default is raw.", Required: false},
+	{Name: "input_format", Desc: "format of input data: raw | plantuml | mermaid | svg. Default is raw.", Required: false},
 }
 
 func wbUpdateValidate(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -53,8 +59,8 @@ func wbUpdateValidate(ctx context.Context, runtime *common.RuntimeContext) error
 
 	// 检查 --input_format 标志
 	format := getFormat(runtime)
-	if format != FormatRaw && format != FormatPlantUML && format != FormatMermaid {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--input_format must be one of: raw | plantuml | mermaid").WithParam("--input_format")
+	if format != FormatRaw && format != FormatPlantUML && format != FormatMermaid && format != FormatSVG {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--input_format must be one of: raw | plantuml | mermaid | svg").WithParam("--input_format")
 	}
 	return nil
 }
@@ -91,7 +97,7 @@ func wbUpdateDryRun(ctx context.Context, runtime *common.RuntimeContext) *common
 			Overwrite: overwrite,
 		}
 		desc.POST(fmt.Sprintf("/open-apis/board/v1/whiteboards/%s/nodes", common.MaskToken(url.PathEscape(token)))).Body(reqBody).Desc("create all nodes of the whiteboard.")
-	case FormatPlantUML, FormatMermaid:
+	case FormatPlantUML, FormatMermaid, FormatSVG:
 		syntaxType := formatCodeMap[format]
 		reqBody := plantumlCreateReq{
 			PlantUmlCode: input,
@@ -120,15 +126,17 @@ func wbUpdateExecute(ctx context.Context, runtime *common.RuntimeContext) error
 	switch format {
 	case FormatRaw:
 		return updateWhiteboardByRawNodes(ctx, runtime, token, []byte(input), overwrite, idempotentToken)
-	case FormatPlantUML, FormatMermaid:
+	case FormatPlantUML, FormatMermaid, FormatSVG:
 		return updateWhiteboardByCode(ctx, runtime, token, []byte(input), format, overwrite, idempotentToken)
 	default:
 		return errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported format: %s", format).WithParam("--input_format")
 	}
 }
 
+// WhiteboardUpdateDescription describes the whiteboard update shortcut.
 const WhiteboardUpdateDescription = "Update an existing whiteboard in lark document with mermaid, plantuml or whiteboard dsl. refer to lark-whiteboard skill for more details."
 
+// WhiteboardUpdate registers the `whiteboard +update` shortcut.
 var WhiteboardUpdate = common.Shortcut{
 	Service:     "whiteboard",
 	Command:     "+update",

shortcuts/whiteboard/whiteboard_update_test.go

@@ -6,6 +6,7 @@ package whiteboard
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"errors"
 	"strings"
 	"testing"
@@ -18,6 +19,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// TestWhiteboardUpdate_Validate verifies update flag validation for supported input formats.
 func TestWhiteboardUpdate_Validate(t *testing.T) {
 	ctx := context.Background()
 
@@ -53,6 +55,15 @@ func TestWhiteboardUpdate_Validate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "valid: svg format",
+			flags: map[string]string{
+				"whiteboard-token": "test-token-123",
+				"input_format":     "svg",
+				"source":           "<svg/>",
+			},
+			wantErr: false,
+		},
 		{
 			name: "valid: with idempotent-token",
 			flags: map[string]string{
@@ -117,25 +128,26 @@ func TestWhiteboardUpdate_Validate_TypedErrors(t *testing.T) {
 			"idempotent-token": "short",
 			"source":           "{}",
 		}, nil)
-		assertValidationParam(t, wbUpdateValidate(ctx, rt), "--idempotent-token")
+		assertValidationParam(t, wbUpdateValidate(ctx, rt), "--idempotent-token", false)
 	})
 
 	t.Run("bad input_format", func(t *testing.T) {
 		rt := newTestRuntime(map[string]string{
 			"whiteboard-token": "t",
-			"input_format":     "svg",
+			"input_format":     "png",
 			"source":           "{}",
 		}, nil)
-		assertValidationParam(t, wbUpdateValidate(ctx, rt), "--input_format")
+		assertValidationParam(t, wbUpdateValidate(ctx, rt), "--input_format", false)
 	})
 
 	t.Run("malformed source json", func(t *testing.T) {
 		_, err, _ := parseWBcliNodes([]byte("not-json"))
-		assertValidationParam(t, err, "--source")
+		assertValidationParam(t, err, "--source", true)
 	})
 }
 
-func assertValidationParam(t *testing.T, err error, wantParam string) {
+// assertValidationParam verifies a validation error carries the expected flag param.
+func assertValidationParam(t *testing.T, err error, wantParam string, wantJSONCause bool) {
 	t.Helper()
 	if err == nil {
 		t.Fatalf("expected error, got nil")
@@ -150,8 +162,25 @@ func assertValidationParam(t *testing.T, err error, wantParam string) {
 	if ve.Param != wantParam {
 		t.Errorf("Param = %q, want %q", ve.Param, wantParam)
 	}
+	p, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("errs.ProblemOf returned false")
+	}
+	if p.Category != errs.CategoryValidation {
+		t.Errorf("Category = %q, want %q", p.Category, errs.CategoryValidation)
+	}
+	if p.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("Problem subtype = %q, want %q", p.Subtype, errs.SubtypeInvalidArgument)
+	}
+	if wantJSONCause {
+		var syntaxErr *json.SyntaxError
+		if !errors.As(err, &syntaxErr) {
+			t.Fatalf("expected json syntax cause to be preserved, err=%v", err)
+		}
+	}
 }
 
+// TestGetFormat verifies input format defaults and explicit format selection.
 func TestGetFormat(t *testing.T) {
 	t.Parallel()
 
@@ -180,6 +209,11 @@ func TestGetFormat(t *testing.T) {
 			flagVal:  FormatMermaid,
 			expected: FormatMermaid,
 		},
+		{
+			name:     "svg returns svg",
+			flagVal:  FormatSVG,
+			expected: FormatSVG,
+		},
 	}
 
 	for _, tt := range tests {
@@ -193,6 +227,7 @@ func TestGetFormat(t *testing.T) {
 	}
 }
 
+// TestWhiteboardUpdate_ShortcutRegistration verifies the shortcut metadata for update commands.
 func TestWhiteboardUpdate_ShortcutRegistration(t *testing.T) {
 	t.Parallel()
 
@@ -213,6 +248,7 @@ func TestWhiteboardUpdate_ShortcutRegistration(t *testing.T) {
 	}
 }
 
+// TestShortcutsIncludesExpectedCommands verifies the whiteboard shortcut registry includes query and update.
 func TestShortcutsIncludesExpectedCommands(t *testing.T) {
 	t.Parallel()
 
@@ -237,6 +273,7 @@ func TestShortcutsIncludesExpectedCommands(t *testing.T) {
 	}
 }
 
+// TestParseWBcliNodes verifies whiteboard CLI output parsing for raw and wrapped node payloads.
 func TestParseWBcliNodes(t *testing.T) {
 	t.Parallel()
 
@@ -285,6 +322,7 @@ func TestParseWBcliNodes(t *testing.T) {
 	}
 }
 
+// TestWBUpdateDryRun verifies dry-run requests for the supported whiteboard update formats.
 func TestWBUpdateDryRun(t *testing.T) {
 	ctx := context.Background()
 
@@ -317,6 +355,14 @@ func TestWBUpdateDryRun(t *testing.T) {
 				"source":           "graph TD\nA-->B",
 			},
 		},
+		{
+			name: "dry run svg format",
+			flags: map[string]string{
+				"whiteboard-token": "test-token-123",
+				"input_format":     "svg",
+				"source":           "<svg/>",
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -362,6 +408,7 @@ func runUpdateShortcut(t *testing.T, shortcut common.Shortcut, args []string, fa
 	return err
 }
 
+// TestWhiteboardUpdateExecute_RawFormat verifies raw node updates call the raw nodes endpoint.
 func TestWhiteboardUpdateExecute_RawFormat(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -385,6 +432,7 @@ func TestWhiteboardUpdateExecute_RawFormat(t *testing.T) {
 	}
 }
 
+// TestWhiteboardUpdateExecute_PlantUMLFormat verifies PlantUML updates use the diagram import endpoint.
 func TestWhiteboardUpdateExecute_PlantUMLFormat(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -410,6 +458,7 @@ Bob -> Alice : hello
 	}
 }
 
+// TestWhiteboardUpdateExecute_PlantUMLInvalidResponse verifies missing node IDs are treated as invalid responses.
 func TestWhiteboardUpdateExecute_PlantUMLInvalidResponse(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -431,6 +480,7 @@ Bob -> Alice : hello
 	assertInvalidResponse(t, err)
 }
 
+// TestWhiteboardUpdateExecute_MermaidFormat verifies Mermaid updates use the diagram import endpoint.
 func TestWhiteboardUpdateExecute_MermaidFormat(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -455,6 +505,44 @@ A-->B`
 	}
 }
 
+// TestWhiteboardUpdateExecute_SVGFormat verifies svg update requests use syntax_type=3 and send the source payload.
+func TestWhiteboardUpdateExecute_SVGFormat(t *testing.T) {
+	factory, stdout, reg := newUpdateExecuteFactory(t)
+
+	// SVG shares the /nodes/plantuml endpoint with plantuml/mermaid via syntax_type=3.
+	stub := &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/board/v1/whiteboards/test-token-svg/nodes/plantuml",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node_id": "node1",
+			},
+		},
+	}
+	reg.Register(stub)
+
+	source := `<svg xmlns="http://www.w3.org/2000/svg"/>`
+	args := []string{"+update", "--whiteboard-token", "test-token-svg", "--input_format", "svg", "--source", source}
+	if err := runUpdateShortcut(t, WhiteboardUpdate, args, factory, stdout); err != nil {
+		t.Fatalf("err=%v", err)
+	}
+
+	var body map[string]interface{}
+	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
+		t.Fatalf("unmarshal captured body: %v\nraw=%s", err, string(stub.CapturedBody))
+	}
+
+	if got := body["syntax_type"]; got != float64(3) {
+		t.Fatalf("syntax_type = %#v, want 3; body=%s", got, string(stub.CapturedBody))
+	}
+	if got := body["plant_uml_code"]; got != source {
+		t.Fatalf("plant_uml_code = %#v, want %q; body=%s", got, source, string(stub.CapturedBody))
+	}
+}
+
+// TestWhiteboardUpdateExecute_RawInvalidResponse verifies malformed raw update responses are rejected.
 func TestWhiteboardUpdateExecute_RawInvalidResponse(t *testing.T) {
 	tests := []struct {
 		name  string
@@ -494,6 +582,7 @@ func TestWhiteboardUpdateExecute_RawInvalidResponse(t *testing.T) {
 	}
 }
 
+// TestWhiteboardUpdateExecute_RawWithIdempotent verifies raw updates pass through the idempotency token.
 func TestWhiteboardUpdateExecute_RawWithIdempotent(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -518,6 +607,7 @@ func TestWhiteboardUpdateExecute_RawWithIdempotent(t *testing.T) {
 	}
 }
 
+// TestWhiteboardUpdateExecute_RawFormatWithRawNodes verifies raw-node payloads are forwarded without DSL wrapping.
 func TestWhiteboardUpdateExecute_RawFormatWithRawNodes(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -541,6 +631,7 @@ func TestWhiteboardUpdateExecute_RawFormatWithRawNodes(t *testing.T) {
 	}
 }
 
+// TestWhiteboardUpdateExecute_RawAPIError verifies raw update API failures preserve typed error metadata and hints.
 func TestWhiteboardUpdateExecute_RawAPIError(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -577,6 +668,7 @@ func TestWhiteboardUpdateExecute_RawAPIError(t *testing.T) {
 	}
 }
 
+// TestWhiteboardUpdateExecute_PlantUMLAPIError verifies diagram update API failures preserve typed error metadata.
 func TestWhiteboardUpdateExecute_PlantUMLAPIError(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -607,6 +699,7 @@ invalid
 	}
 }
 
+// TestWhiteboardUpdateExecute_WithOverwrite verifies diagram updates send overwrite=true when requested.
 func TestWhiteboardUpdateExecute_WithOverwrite(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 
@@ -631,6 +724,7 @@ A-->B`
 	}
 }
 
+// TestWhiteboardUpdateExecute_RawWithOverwrite verifies raw updates send overwrite=true when requested.
 func TestWhiteboardUpdateExecute_RawWithOverwrite(t *testing.T) {
 	factory, stdout, reg := newUpdateExecuteFactory(t)
 

skills/lark-base/SKILL.md

@@ -31,10 +31,17 @@ metadata:
 - Base 业务操作只使用 `lark-cli base +...` shortcut，不使用旧聚合式 `+table / +field / +record / +view / +history / +workspace`。
 - 本轮 Base 不依赖 `lark-cli schema`。SKILL 只保留路由、风险和复杂 JSON/DSL；简单命令由命令自身的参数、tips 和错误恢复承接。
 - 用户要把 Excel / CSV / `.base` 导入成 Base 时，先转 `lark-cli drive +import --type bitable`，导入完成后再回到 Base 命令。
-- 用户只给 Base 名称或关键词时，先用 `lark-cli drive +search --query <keyword> --doc-types bitable` 定位资源。
-- Base 命令必须先有 `base_token` 或可解析出的 Base URL。没有 token 时：用户要新建就用 `+base-create`；用户给标题/关键词就搜 `lark-cli drive +search --query "<base title>" --doc-types bitable --only-title --as user`；仍无法定位时，反问用户具体是哪一个 Base。
 - 认证、初始化、scope、身份切换、权限不足恢复属于 `lark-shared`；Base 文档只保留会影响 Base 路径选择的权限规则。
 
+## 先获取 Base Token 和所需 ID
+
+进入任何需要目标 Base 的 shortcut 前，必须先拿到可用的 `base_token`，以及当前任务需要的 `table_id` / `view_id` / `record_id` / `form_id` / `dashboard_id` / `workflow_id` 等真实 ID；不要把完整 URL、wiki token、workspace token 或孤立 raw token 直接当作 `--base-token`。
+
+- 用户输入 URL 或分享链接：先运行 `lark-cli base +url-resolve --url "<url>" --as user`，用返回的 `base_token` 和相关 ID 继续后续命令。
+- 用户输入 Base 标题、关键词或不确定名称：先运行 `lark-cli base +title-resolve --title "<keyword>" --as user`；`--title` 传入标题中的短关键词，不超过 30 个字符；过长标题先取最有区分度的短关键词；多候选时先让用户消歧，不要猜。
+- 文档嵌入 Base 标签：直接读取 `<bitable>` / `<base_refer>` 的 `token` 作为 `--base-token`，`table-id` 作为 `--table-id`，`view-id` 作为 `--view-id`；孤立 raw token 不走 `+url-resolve`。
+- 仍无法定位且用户不是要新建 Base 时，先反问用户要操作哪一个 Base；用户要新建时才用 `+base-create`。
+
 ## 快速路由
 
 | 用户目标 | 优先命令 | 何时读 reference |
@@ -113,22 +120,6 @@ metadata:
 - `+view-set-filter` 是唯一保留的 view reference；sort/group/card/timebar/visible-fields 这类配置先用对应 get 命令读现状，保留未修改字段，只替换用户要求变更的配置。
 - 视图适合持久化、共享和 UI 复用；一次性筛选/排序可先用 `+record-list` / `+record-search` 的 filter/sort 验证结果，再按需要沉淀为持久视图。
 
-## Token 与链接
-
-| 输入类型 | 含义 / 正确处理方式 |
-|---|---|
-| `/base/{token}` | 普通 Base 链接；提取 `/base/` 后的 token 作为 `--base-token` |
-| `/wiki/{token}` | Wiki 节点链接；先 `wiki +node-get`，当 `data.obj_type=bitable` 时使用 `data.obj_token` 作为 `--base-token` |
-| `/base/{token}?table={id}` | `table` 参数用于定位 Base 内对象：`tbl` 开头是数据表 `--table-id`；`blk` 开头是 dashboard ID；`wkf` 开头是 workflow ID |
-| `/base/{token}?view={id}` | `view` 参数用于定位表视图，提取为 `--view-id`；通常还需要确认 `table` 参数或先查表结构 |
-| `/share/base/form/{shareToken}` | 表单分享链接；这是表单 share token，走 `+form-detail` / `+form-submit --share-token <shareToken>` |
-| `/share/base/view/{shareToken}` | 视图分享链接；具有分享权限语义，暂不支持用 CLI 直接访问，引导用户在浏览器或飞书客户端打开 |
-| `/share/base/dashboard/{shareToken}` | 仪表盘分享链接；具有分享权限语义，暂不支持用 CLI 直接访问，引导用户在浏览器或飞书客户端打开 |
-| `/record/{shareToken}` | 记录分享链接；暂不支持用 CLI 直接访问，引导用户在浏览器或飞书客户端打开。若用户想生成现有记录的分享链接，用 `+record-share-link-create --base-token <base_token> --table-id <table_id> --record-ids <record_id>` |
-| `/base/workspace/{token}` | BaseApp / workspace 链接；暂不支持用 CLI 直接访问 |
-
-`wiki +node-get` 返回非 `bitable` 时，不继续使用 Base 命令：`docx` 转文档，`sheet` 转表格，其他云空间对象转对应 skill 或 drive。
-
 ## Dashboard / Workflow / Role
 
 - Dashboard 的复杂点是 block 的 `data_config`，不是 list/get/create/delete 命令参数。创建或更新 block 前先读 [dashboard-block-data-config.md](references/dashboard-block-data-config.md)，组件必须串行创建；`+dashboard-arrange` 是服务端智能布局，只在用户明确要求重排/美化时执行。`+dashboard-block-get-data` 读取图表最终计算结果，不返回 block 名称、类型、布局或 `data_config`；需要元数据先用 `+dashboard-block-get`。
@@ -139,7 +130,7 @@ metadata:
 
 | 错误 / 现象 | 恢复动作 |
 |---|---|
-| `param baseToken is invalid` / `base_token invalid` | 检查是否把 wiki token、workspace token 或完整 URL 当成了 `--base-token`；按 `Token 与链接` 重新定位真实 Base token |
+| `param baseToken is invalid` / `base_token invalid` | 检查是否把 wiki token、workspace token 或完整 URL 当成了 `--base-token`；按入口规则重新获取真实 `base_token` |
 | `not found` 且输入来自 Wiki 链接 | 优先检查是否把 wiki token 当成 base token，不要立刻改走裸 API |
 | `1254045` 字段名不存在 | 重新 `+field-list`，使用真实字段名或字段 ID；注意空格、大小写和跨表字段 |
 | `1254015` 字段值类型不匹配 | 先 `+field-list`，再按 [lark-base-cell-value.md](references/lark-base-cell-value.md) 构造 CellValue |

skills/lark-doc/SKILL.md

@@ -1,11 +1,10 @@
 ---
 name: lark-doc
-version: 2.0.0
 description: "飞书云文档（Docx / Wiki 文档，v2 API）：读取和编辑飞书文档内容。当用户给出文档 URL 或 token，或需要查看、创建、编辑文档、插入或下载文档图片附件时使用。文档中嵌入的电子表格、多维表格、画板，先用本 skill 提取 token 再切到对应 skill。当用户给出 doubao.com 的 /docx/ 或 /wiki/ URL/token 时，也应直接使用本 skill；路由依据是 URL 路径模式和 token，而不是域名。不负责文档评论管理，也不负责表格或 Base 的数据操作。"
 metadata:
   requires:
     bins: ["lark-cli"]
-  cliHelp: "lark-cli docs --api-version v2 --help; lark-cli docs +create --api-version v2 --help; lark-cli docs +fetch --api-version v2 --help; lark-cli docs +update --api-version v2 --help; lark-cli docs resource-download --help; lark-cli docs resource-update --help; lark-cli docs resource-delete --help"
+  cliHelp: "lark-cli docs --api-version v2 --help; lark-cli docs +create --api-version v2 --help; lark-cli docs +fetch --api-version v2 --help; lark-cli docs +update --api-version v2 --help; lark-cli docs +resource-download --help; lark-cli docs +resource-update --help; lark-cli docs +resource-delete --help"
 ---
 
 # docs (v2)
@@ -26,7 +25,7 @@ lark-cli docs +update --api-version v2 --doc "文档URL或token" --command appen
 **CRITICAL — 执行对应操作前，MUST 先用 Read 工具读取以下文件，缺一不可：**
 1. [`../lark-shared/SKILL.md`](../lark-shared/SKILL.md) — 认证、权限处理、全局参数（所有操作通用）
 2. **读取文档（`docs +fetch --api-version v2`）** → 必读 [`lark-doc-fetch.md`](references/lark-doc-fetch.md)（`--scope` / `--detail` 选择、局部读取策略、`<fragment>` / `<excerpt>` 输出结构）
-3. **创建或编辑文档内容** → 必读 [`lark-doc-xml.md`](references/lark-doc-xml.md)（XML 语法规则，仅当用户明确要求 Markdown 时改读 [`lark-doc-md.md`](references/lark-doc-md.md)）；从零创建时加读 [`lark-doc-create-workflow.md`](references/style/lark-doc-create-workflow.md)；编辑已有文档时加读 [`lark-doc-update.md`](references/lark-doc-update.md) 和 [`lark-doc-update-workflow.md`](references/style/lark-doc-update-workflow.md)
+3. **创建或编辑文档内容** → 必读 [`lark-doc-xml.md`](references/lark-doc-xml.md)（XML 语法规则，仅当用户明确要求 Markdown 时改读 [`lark-doc-md.md`](references/lark-doc-md.md)）；编辑已有文档时加读 [`lark-doc-update.md`](references/lark-doc-update.md)
 4. **需要使用 callout、grid、table、whiteboard 等富 block 时** → 参考 [`lark-doc-style.md`](references/style/lark-doc-style.md) 的元素能力说明。该文件不是固定模板或强制排版规范；除非用户明确要求美化、重排版或特定风格，不要为了“达标”主动套用固定结构。
 
 **未读完以上文件就执行相应操作会导致参数选择错误或格式错误。**
@@ -44,7 +43,7 @@ lark-cli docs +update --api-version v2 --doc "文档URL或token" --command appen
 - 新增画板必须隔离到 SubAgent：简单图由 SubAgent 直接插入 `<whiteboard type="svg">完整 SVG</whiteboard>`，不读 `lark-whiteboard`；复杂图才由主 Agent 先建 `<whiteboard type="blank"></whiteboard>`，再启动 SubAgent 读取 `lark-whiteboard` 写入
 - 用户说"看一下文档里的图片/附件/素材""预览素材" → 用 `lark-cli docs +media-preview`
 - 用户明确说"下载素材" → 用 `lark-cli docs +media-download`
-- 用户明确说"下载/更新/删除文档封面图" → 用 `lark-cli docs resource-download/resource-update/resource-delete --type cover`
+- 用户明确说"下载/更新/删除文档封面图" → 用 `lark-cli docs +resource-download/+resource-update/+resource-delete --type cover`
 - `resource-*` 目前仅支持 Docx 封面资源；其他图片、附件或素材请走 `+media-*`
 - 如果目标是画板/whiteboard/画板缩略图 → 只能用 `lark-cli docs +media-download --type whiteboard`（不要用 `+media-preview`）
 - 拿到 spreadsheet URL/token 后 → 切到 `lark-sheets` 做对象内部操作
@@ -67,12 +66,12 @@ Shortcut 是对常用操作的高级封装（`lark-cli docs +<verb> [flags]`）
 | Shortcut | 说明 |
 |----------|------|
 | [`+create`](references/lark-doc-create.md) | Create a Lark document (XML / Markdown) |
-| [`+fetch`](references/lark-doc-fetch.md) | Fetch Lark document content (XML / Markdown) |
+| [`+fetch`](references/lark-doc-fetch.md) | Fetch Lark document content (XML / Markdown / im-markdown; `im-markdown` only after fetch for `lark-im`) |
 | [`+update`](references/lark-doc-update.md) | Update a Lark document (str_replace / block_insert_after / block_replace / ...) |
 | [`+media-insert`](references/lark-doc-media-insert.md) | Insert a local image or file at the end of a Lark document (4-step orchestration + auto-rollback). Prefer `--from-clipboard` when the image is already on the system clipboard (screenshots, copy from Feishu/browser); use `--file` only for on-disk sources. |
 | [`+media-download`](references/lark-doc-media-download.md) | Download document media or whiteboard thumbnail (auto-detects extension) |
 | [`+media-preview`](references/lark-doc-media-preview.md) | Preview document media file (auto-detects extension) |
-| [`resource-download` / `resource-update` / `resource-delete`](references/lark-doc-resource-cover.md) | Download, update, or delete a Docx cover image resource with `--type cover` |
+| [`+resource-download` / `+resource-update` / `+resource-delete`](references/lark-doc-resource-cover.md) | Download, update, or delete a Docx cover image resource with `--type cover` |
 | [`+whiteboard-update`](../lark-whiteboard/references/lark-whiteboard-update.md) | Alias of `whiteboard +update`. Update an existing whiteboard with DSL, Mermaid or PlantUML. Prefer `whiteboard +update`; refer to lark-whiteboard skill for details. |
 
 ## 不在本 Skill 范围

skills/lark-doc/references/lark-doc-create.md

@@ -2,7 +2,6 @@
 
 > **前置条件（MUST READ）：** 生成文档内容前，必须先用 Read 工具读取以下文件，缺一不可：
 > 1. [`lark-doc-xml.md`](lark-doc-xml.md) — XML 语法规则（使用 Markdown 格式时改读 [`lark-doc-md.md`](lark-doc-md.md)）
-> 2. [`lark-doc-create-workflow.md`](style/lark-doc-create-workflow.md) — 从零创作工作流（Code-Act Loop、并行执行策略）
 >
 > **需要富 block 或用户明确要求美化/重排版时，再参考 [`lark-doc-style.md`](style/lark-doc-style.md)。**
 >
@@ -74,12 +73,11 @@ lark-cli docs +create --api-version v2 --doc-format markdown --content $'# 项
 ## 最佳实践
 
 - 文档标题从内容中自动提取：XML 使用 `<title>`；Markdown 使用文档开头唯一的一级标题（`# 标题`），正文从 `##` 开始。不要在内容开头重复写标题，也不要在 Markdown 正文中使用多个一级标题。
-- **较长文档**：参考 [`lark-doc-create-workflow.md`](style/lark-doc-create-workflow.md) 先建骨架再分段写入；短文档可一次写完整内容。
+- **较长文档**：先建骨架再通过 `docs +update` 分段写入；短文档可一次写完整内容。
 - **表达形式**：由用户目标和内容决定。需要结构化表达时可参考 [`lark-doc-style.md`](style/lark-doc-style.md)，但不要默认套用固定开头、固定富 block 比例或固定图表
 
 ## 参考
 
-- [`lark-doc-create-workflow.md`](style/lark-doc-create-workflow.md) — 从零创作工作流（Code-Act Loop、并行执行策略）
 - [`lark-doc-style.md`](style/lark-doc-style.md) — 文档样式指南（元素选择 + 丰富度规则 + 颜色语义）
 - [`lark-doc-xml.md`](lark-doc-xml.md) — XML 语法规范
 - [`lark-doc-fetch.md`](lark-doc-fetch.md) — 获取文档

skills/lark-doc/references/lark-doc-fetch.md

@@ -91,7 +91,7 @@ lark-cli docs +fetch --api-version v2 --doc Z1Fj...tnAc \
 }
 ```
 
-`content` 的格式由 `--doc-format` 决定。设置 `--scope` 时会被 `<fragment>` 包裹，详见上文"局部读取的输出结构"。
+`content` 的格式由 `--doc-format` 决定；`im-markdown` 仅用于获取内容后在 `lark-im` 场景下使用。设置 `--scope` 时会被 `<fragment>` 包裹，详见上文"局部读取的输出结构"。
 
 ## 参数
 
@@ -99,7 +99,7 @@ lark-cli docs +fetch --api-version v2 --doc Z1Fj...tnAc \
 |------|------|------|
 | `--api-version` | 是 | 固定传 `v2` |
 | `--doc` | 是 | 文档 URL 或 token（支持 `/docx/` 和 `/wiki/`） |
-| `--doc-format` | 否 | `xml`（默认）\| `markdown` \| `text` |
+| `--doc-format` | 否 | `xml`（默认）\| `markdown` \| `text` \| `im-markdown`（仅用于获取内容后在 `lark-im` 场景下使用） |
 | `--detail` | 否 | `simple`（默认）\| `with-ids` \| `full` |
 | `--revision-id` | 否 | 文档版本号，`-1` = 最新（默认） |
 | `--scope` | 否 | `outline` \| `range` \| `keyword` \| `section`（省略 = 读整篇） |
@@ -124,7 +124,7 @@ lark-cli docs +fetch --api-version v2 --doc Z1Fj...tnAc \
 - `<img>` / `<source>` 带 `url` 时，直接用该 URL 下载即可（普通 HTTP GET），无需走 shortcut。
 - 没有 `url`、或只想预览 → `docs +media-preview --token <token> --output ./preview_media`
 - 明确下载，或目标是 `<whiteboard>`（画板只能走 shortcut） → `docs +media-download --token <token> --output ./downloaded_media`
-- 文档封面图不是正文素材；下载/更新/删除封面图 → `docs resource-download/resource-update/resource-delete --type cover`
+- 文档封面图不是正文素材；下载/更新/删除封面图 → `docs +resource-download/+resource-update/+resource-delete --type cover`
 
 ## 嵌入电子表格 / 多维表格
 

skills/lark-doc/references/lark-doc-md.md

@@ -1,6 +1,6 @@
 # Markdown 格式参考
 
-`docs +fetch --api-version v2` / `docs +create --api-version v2` / `docs +update --api-version v2` 使用 `--doc-format markdown` 时适用。
+`docs +fetch --api-version v2` / `docs +create --api-version v2` / `docs +update --api-version v2` 使用 `--doc-format markdown` 时适用；fetch 的 `--doc-format im-markdown` 仅用于获取内容后在 `lark-im` 场景下使用，不作为 create/update 写入格式。
 
 ## 创建文档标题
 

skills/lark-doc/references/lark-doc-resource-cover.md

@@ -1,36 +1,36 @@
-# docs resource-*（Docx 封面图资源）
+# docs +resource-*（Docx 封面图资源）
 
 > **前置条件：** 先阅读 [`../lark-shared/SKILL.md`](../../lark-shared/SKILL.md) 了解认证、全局参数和安全规则。
 
-Docx 封面图不是正文里的 `<img token="...">` 素材块。读取、更新、删除文档封面图时，使用 `docs resource-download/resource-update/resource-delete --type cover`，不要使用 `+media-insert` 或 `+media-download --token <cover.token>` 让用户手动拼步骤。
+Docx 封面图不是正文里的 `<img token="...">` 素材块。读取、更新、删除文档封面图时，使用 `docs +resource-download/+resource-update/+resource-delete --type cover`，不要使用 `+media-insert` 或 `+media-download --token <cover.token>` 让用户手动拼步骤。
 
 ## 选择规则
 
-- 用户要下载文档封面图：`docs resource-download --type cover`
-- 用户要设置/替换文档封面图：`docs resource-update --type cover`
-- 用户要删除文档封面图：`docs resource-delete --type cover`
+- 用户要下载文档封面图：`docs +resource-download --type cover`
+- 用户要设置/替换文档封面图：`docs +resource-update --type cover`
+- 用户要删除文档封面图：`docs +resource-delete --type cover`
 - 用户要下载正文图片、附件、画板缩略图：继续使用 [`docs +media-download`](lark-doc-media-download.md)
 
 ## 命令
 
 ```bash
 # 下载封面图。CLI 会先读取 document.cover.token，再下载图片内容并保存到本地。
-lark-cli docs resource-download --doc doxcnXXX --type cover --output ./cover
+lark-cli docs +resource-download --doc doxcnXXX --type cover --output ./cover
 
 # 使用本地文件更新封面图。
-lark-cli docs resource-update --doc doxcnXXX --type cover --file ./cover.png
+lark-cli docs +resource-update --doc doxcnXXX --type cover --file ./cover.png
 
 # 使用剪切板图片更新封面图。
-lark-cli docs resource-update --doc doxcnXXX --type cover --from-clipboard
+lark-cli docs +resource-update --doc doxcnXXX --type cover --from-clipboard
 
 # 使用 HTTPS URL 更新封面图。CLI 会先下载 URL 内容，再上传并写入 cover.token。
-lark-cli docs resource-update --doc doxcnXXX --type cover --url "https://example.com/cover.png"
+lark-cli docs +resource-update --doc doxcnXXX --type cover --url "https://example.com/cover.png"
 
 # 可选：设置封面图裁切偏移。
-lark-cli docs resource-update --doc doxcnXXX --type cover --file ./cover.png --offset-ratio-x 0.2 --offset-ratio-y 0.8
+lark-cli docs +resource-update --doc doxcnXXX --type cover --file ./cover.png --offset-ratio-x 0.2 --offset-ratio-y 0.8
 
 # 删除封面图；当文档本来没有封面图时也成功返回。
-lark-cli docs resource-delete --doc doxcnXXX --type cover
+lark-cli docs +resource-delete --doc doxcnXXX --type cover
 ```
 
 ## 参数
@@ -49,13 +49,13 @@ lark-cli docs resource-delete --doc doxcnXXX --type cover
 
 ## 输出契约
 
-- `resource-download` 成功时 stdout JSON 的 `data` 包含 `document_id`、`type`、`saved_path`、`size_bytes`、`content_type`、`cover.token`。如果文档没有封面图，命令失败退出，错误包含 `document has no cover` 和脱敏 `document_id`，不会创建输出文件。
-- `resource-update` 成功时 stdout JSON 的 `data` 包含完整 `file_token` 和 `cover.token`；stderr 只打印脱敏 token。
-- `resource-delete` 成功时 stdout JSON 的 `data.deleted` 表示本次是否真的发起删除，`data.already_empty` 表示删除前是否没有封面图。空封面图是幂等成功，不报错。
+- `+resource-download` 成功时 stdout JSON 的 `data` 包含 `document_id`、`type`、`saved_path`、`size_bytes`、`content_type`、`cover.token`。如果文档没有封面图，命令失败退出，错误包含 `document has no cover` 和脱敏 `document_id`，不会创建输出文件。
+- `+resource-update` 成功时 stdout JSON 的 `data` 包含完整 `file_token` 和 `cover.token`；stderr 只打印脱敏 token。
+- `+resource-delete` 成功时 stdout JSON 的 `data.deleted` 表示本次是否真的发起删除，`data.already_empty` 表示删除前是否没有封面图。空封面图是幂等成功，不报错。
 
 ## URL 来源安全边界
 
-`resource-update --url` 只用于下载公开 HTTPS 图片：
+`+resource-update --url` 只用于下载公开 HTTPS 图片：
 
 - 只允许 `https://`，拒绝 HTTP、空 host 和 URL userinfo。
 - 拒绝解析到 private、loopback、link-local、multicast、unspecified 地址的 host。

skills/lark-doc/references/lark-doc-update.md

@@ -3,7 +3,6 @@
 
 > **前置条件（MUST READ）：** 生成文档内容前，必须先用 Read 工具读取以下文件，缺一不可：
 > 1. [`lark-doc-xml.md`](lark-doc-xml.md) — XML 语法规则（使用 Markdown 格式时改读 [`lark-doc-md.md`](lark-doc-md.md)）
-> 2. [`lark-doc-update-workflow.md`](style/lark-doc-update-workflow.md) — 改写增强工作流（Code-Act Loop、并行执行策略）
 >
 > **需要富 block 或用户明确要求美化/重排版时，再参考 [`lark-doc-style.md`](style/lark-doc-style.md)。**
 >
@@ -253,7 +252,6 @@ lark-cli docs +update --api-version v2 --doc "<doc_id>" --command str_replace \
 
 ## 参考
 
-- [`lark-doc-update-workflow.md`](style/lark-doc-update-workflow.md) — 改写增强工作流（Code-Act Loop、并行执行策略）
 - [`lark-doc-style.md`](style/lark-doc-style.md) — 文档样式指南（元素选择 + 丰富度规则 + 颜色语义）
 - [`lark-doc-xml.md`](lark-doc-xml.md) — XML 语法规范
 - [`lark-doc-fetch.md`](lark-doc-fetch.md) — 获取文档

skills/lark-doc/references/style/lark-doc-create-workflow.md

@@ -1,59 +0,0 @@
-# 从零创作工作流
-
-用户提供主题、需求或简要说明，需要生成一份新的飞书文档时，遵循本工作流。
-
-## 核心方法论 — Code-Act Loop
-
-通过自适应的 **Code-Act Loop** 驱动文档创作，而非固定模板式的工作流。每次任务都循环执行：
-
-1. **Plan（规划）** — 根据用户目标和文档当前状态，评估下一步该做什么
-2. **Execute（执行）** — 运行相应的 `lark-cli docs` 命令，或 **spawn** Agent 子任务并行推进
-3. **Observe（观察）** — 检查命令输出，验证正确性，确认内容是否满足用户目标
-4. **Iterate（迭代）** — 如需调整，回到 Plan 继续循环
-
-循环在文档达到质量标准且满足用户需求时结束。不要试图一次性产出完美内容——迭代打磨效果更好。根据用户实际需求灵活决定文档结构和版块，而不是套用固定模板。
-
-
-## 典型 Code-Act Loop 流程
-
-### 步骤一：规划与初始创建（串行）
-
-1. 分析用户需求：受众、目的、范围
-2. 设计大纲：根据任务自然选择结构。可以是短文、纪要、FAQ、方案、报告、清单或其他形式；不要默认套固定章节、固定开头或固定富 block 配比
-3. `docs +create --api-version v2` 创建文档。长文档可**只建骨架**：标题 + 各级标题 + 每节一句占位摘要；短文档可以一次写入完整内容
-   - ⚠️ 创建较长文档时，**不要**一次性把完整章节内容塞进 `--content`。超长 `--content` 容易触发字符/参数限制。
-   - 完整内容留到步骤二，由各 Agent 用 `block_insert_after --block-id <章节标题 block_id>` 分段写入。
-   - ⚠️ **`@file` 路径限制**：`--content @file` 只接受当前工作目录下的相对路径，传绝对路径（如 `@/tmp/xxx.md`）会报 `unsafe file path`。需要落盘时，将文件写在 cwd 下，用完自行清理。
-
-### 步骤二：分段撰写（并行 Agent）
-
-4. Spawn Agent 并行撰写各章节。每个 Agent 需收到：
-   - 文档 token、负责的章节范围、用户目标、目标读者和已有风格线索
-   - `lark-doc-xml.md` 的完整路径（Agent 须先读取）；仅在需要使用富 block 或用户要求美化时提供 `lark-doc-style.md`
-   - 使用 `block_insert_after --block-id <章节标题 block_id>` 写入对应章节内容
-
-### 步骤三：整合审查与画板识别（串行）
-
-5. `docs +fetch --api-version v2 --detail with-ids` 获取文档，审查整体效果
-6. 评估内容是否满足用户目标：事实是否完整、结构是否清楚、语气是否匹配、是否保留必要素材
-7. **画板意图识别**：逐章节扫描，按 `lark-doc-style.md`「画板意图识别」表判断是否有段落适合用图表达。重要信息优先画板化，记录需要插图的章节、推荐画板类型、mermaid/SVG 路径和用于画图的源内容
-
-### 步骤四：画板处理与润色（并行 Agent）
-
-8. **优先处理步骤三识别出的画板需求**：
-   参考 [lark-doc-whiteboard.md](../lark-doc-whiteboard.md)中的方式，插入图表画板。
-9. Spawn 内容改写 Agent 定向润色：
-   - 文字密集且不易读时，优先拆段、改列表、增加小标题或调整顺序；只有确实存在行列数据、并列对比或强提醒信息时，才考虑 `<table>` / `<grid>` / `<callout>`
-   - 需要明显分隔的主题可补充 `<hr/>`，不强制章节间都使用
-   - 本地图片使用 `docs +media-insert` 插入
-
-
-## Agent 子任务要求
-
-内容改写 Agent 必须收到：文档 token、章节范围（标题/block ID）、`lark-doc-xml.md` 路径、用户目标/风格要求、具体的 `docs +update` command 和 `--block-id`。只有在需要使用富 block 或用户要求美化时，才提供 `lark-doc-style.md` 路径。
-
-Mermaid 图由主 Agent 直接插入 `<whiteboard type="mermaid">...</whiteboard>`，无需 SubAgent。
-
-SVG SubAgent 必须收到：文档 token、插入位置（标题/block ID）、图表目标、源内容片段、`lark-doc-xml.md` 路径，以及[lark-doc-whiteboard.md](../lark-doc-whiteboard.md) 中的 "SVG 设计 Workflow" 指南。它只负责插入一个 `<whiteboard type="svg">...</whiteboard>`，不改其他正文，也不读取 `lark-whiteboard`。
-
-已有画板更新 SubAgent 必须收到：board_token、图表目标、推荐画板类型、源内容片段、[`../../../lark-whiteboard/SKILL.md`](../../../lark-whiteboard/SKILL.md) 路径。它只负责写入画板，不改文档正文。

skills/lark-doc/references/style/lark-doc-update-workflow.md

@@ -1,55 +0,0 @@
-# 改写增强工作流
-
-用户提供已有文档链接或 token，需要改写、润色、补充或重排版时，遵循本工作流。
-
-## 核心方法论 — Code-Act Loop
-通过自适应的 **Code-Act Loop** 驱动文档改写，而非固定模板式的工作流。每次任务都循环执行：
-1. **Plan（规划）** — 根据用户目标和文档当前状态，评估下一步该做什么
-2. **Execute（执行）** — 运行相应的 `lark-cli docs` 命令，或 **spawn** Agent 子任务并行推进
-3. **Observe（观察）** — 检查命令输出，验证正确性，确认内容是否满足用户目标
-4. **Iterate（迭代）** — 如需调整，回到 Plan 继续循环
-
-## 核心原则：精准手术优于全量覆盖
-1. **精准手术**：只改用户指定的 block，不改其他 block。
-2. **全量覆盖**：如果用户明确要改整篇，才用 `overwrite` 命令。
-3. **保真约束**：改写时原文里的 `<cite type="user">`（@人）、`<cite type="doc">`（@文档）、`<img>`、`<source>`、`<whiteboard>`、`<sheet>`、`<bitable>`、`<synced_reference>` 等行内组件和资源块一律原样保留（含所有 token / user-id / doc-id 属性），不许替换成纯文本姓名、链接或占位符。
-
-## 工作流程
-
-### 步骤一：分析与画板识别（串行）
-
-1. **选择读取范围**（节省上下文的关键）：
-   - 用户只改某一节 / 文档较大 → 先 `docs +fetch --api-version v2 --scope outline --max-depth 2` 拿目录，再 `docs +fetch --api-version v2 --scope section --start-block-id <目标标题id> --detail with-ids` 精读该节（`section` 会自动展开到下一个同级/更高级标题前，不用手动算结束 block id）
-   - 需要精确跨节区间 → `docs +fetch --api-version v2 --scope range --start-block-id xxx --end-block-id yyy`（或 `--end-block-id -1` 读到末尾）
-   - 用户只给了模糊关键词 → `docs +fetch --api-version v2 --scope keyword --keyword xxx --context-before 1 --context-after 1 --detail with-ids`
-   - 用户明确要改整篇 → `docs +fetch --api-version v2 --detail with-ids`
-   - 详见 [`lark-doc-fetch.md`](../lark-doc-fetch.md) "意图引导：选择正确的 --scope"
-2. 系统性评估：用户想改什么、现有文档风格是什么、哪些内容需要保留、哪些问题影响理解
-3. **画板意图识别**：逐章节扫描，按 `lark-doc-style.md`「画板意图识别」表判断哪些段落的信息适合用图表达。重要信息优先画板化，记录需要插图的章节（block ID）、推荐画板类型、mermaid/SVG路径和源内容片段
-4. 向用户简要说明改进计划（包含识别出的画板机会）
-
-### 步骤二：定向改写（并行 Agent）
-
-5. **优先处理步骤一识别出的画板候选段落**：
-   参考 [lark-doc-whiteboard.md](../lark-doc-whiteboard.md)中的方式，插入图表画板。
-6. Spawn 内容改写 Agent 在不重叠的章节上并行改进，各 Agent 收到文档 token 和特定 block ID：
-   - 沿用或轻微调整已有文档风格，除非用户要求彻底重排版
-   - 优先通过重写段落、调整标题、拆分列表或补充小标题提升可读性
-   - 富 block 是可选表达手段，不因固定比例而添加；画板类需求只走第 5 步
-
-### 步骤三：验证（串行）
-
-7. 获取更新后文档局部内容，检查是否符合用户目标和已有风格
-8. 检查是否满足用户目标并保留原有关键内容；如仍有明显问题则定向修正，向用户呈现结果
-
-## Agent 子任务要求
-
-内容改写 Agent 必须收到：文档 token、章节范围（标题/block ID）、`lark-doc-xml.md` 路径、用户目标/风格要求、具体的 `docs +update` command 和 `--block-id`。只有在需要使用富 block 或用户要求美化时，才提供 `lark-doc-style.md` 路径。
-
-Mermaid 图由主 Agent 直接插入 `<whiteboard type="mermaid">...</whiteboard>`，无需 SubAgent。
-
-SVG SubAgent 必须收到：文档 token、插入位置（标题/block ID）、图表目标、源内容片段、`lark-doc-xml.md` 路径，以及[lark-doc-whiteboard.md](../lark-doc-whiteboard.md) 中的 "SVG 设计 Workflow" 指南。它只负责插入一个 `<whiteboard type="svg">...</whiteboard>`，不改其他正文，也不读取 `lark-whiteboard`。
-
-已有画板更新 SubAgent 必须收到：board_token、图表目标、推荐画板类型、源内容片段、[`../../../lark-whiteboard/SKILL.md`](../../../lark-whiteboard/SKILL.md) 路径。它只负责写入画板，不改文档正文。
-
-**上下文节省提示**：Agent 如需在自己负责的章节内重新读取内容，优先用 `docs +fetch --api-version v2 --scope section --start-block-id <章节标题id>`（自动覆盖整节），或 `--scope range --start-block-id xxx --end-block-id yyy` 精确区间，只拉自己的章节，不要重复拉全文。

skills/lark-event/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: lark-event
 version: 1.0.0
-description: "Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via `lark-cli event consume <EventKey>` (covers IM messages/reactions/chat changes, VC meeting ended, Minutes generated, Whiteboard updated, etc.). Use for Lark bots, real-time message processing, long-running subscribers, streaming webhook/push handlers. Supports `--max-events` / `--timeout` bounded runs and a stderr ready-marker contract — designed for AI agents running as subprocesses."
+description: "Lark/Feishu real-time event listening / subscribing / consuming: stream events as NDJSON via `lark-cli event consume <EventKey>` (covers IM messages/reactions/chat changes, Task updates, VC meeting ended, Minutes generated, Whiteboard updated, etc.). Use for Lark bots, real-time message processing, long-running subscribers, streaming webhook/push handlers. Supports `--max-events` / `--timeout` bounded runs and a stderr ready-marker contract — designed for AI agents running as subprocesses."
 metadata:
   requires:
     bins: ["lark-cli"]
@@ -147,7 +147,8 @@ Lark-defined semantic tags (**not** JSON Schema's standard `format`). Common val
 
 | Topic      | Reference                                                                    | Coverage |
 |------------|------------------------------------------------------------------------------|---|
-| IM         | [`references/lark-event-im.md`](references/lark-event-im.md)                 | Catalog of 11 IM EventKeys + shape notes (flat vs V2 envelope) + `im.message.receive_v1` field gotchas (`sender_id` is open_id only; `.content` is plain text except for `interactive` cards) + common jq recipes (filter by chat_type / message_type / sender) |
+| IM         | [`references/lark-event-im.md`](references/lark-event-im.md)                 | Catalog of 12 IM EventKeys + shape notes (flat vs V2 envelope) + `im.message.receive_v1` field gotchas (`sender_id` is open_id only; `.content` is plain text except for `interactive` cards) + common jq recipes (filter by chat_type / message_type / sender); for `card.action.trigger` see also [`../lark-im/references/lark-im-card-action-reply.md`](../lark-im/references/lark-im-card-action-reply.md) |
+| Task       | [`references/lark-event-task.md`](references/lark-event-task.md)             | Catalog of 1 Task EventKey (`task.task.update_user_access_v2`) + Native V2 envelope shape + task commit types + user/bot subscription notes |
 | VC         | [`references/lark-event-vc.md`](references/lark-event-vc.md)                 | Catalog of 2 VC EventKeys (`vc.meeting.participant_meeting_ended_v1`, `vc.note.generated_v1`) + field reference + source type semantics (meeting only) |
 | Minutes    | [`references/lark-event-minutes.md`](references/lark-event-minutes.md)       | Catalog of 1 Minutes EventKey (`minutes.minute.generated_v1`) + field reference + source type semantics (meeting only) |
 | Whiteboard | [`references/lark-event-whiteboard.md`](references/lark-event-whiteboard.md) | Catalog of 1 Board EventKey (`board.whiteboard.updated_v1`) + per-whiteboard subscription model (requires `-p whiteboard_id=<token>`) + payload field reference (whiteboard_id / operator_ids triple-id) |