chore: release v1.0.17 (#614)

Change-Id: I12f59a72996c9d21dacd5478190a85af765bb1a4

CHANGELOG.md

@@ -2,6 +2,50 @@
 
 All notable changes to this project will be documented in this file.
 
+## [v1.0.17] - 2026-04-22
+
+### Features
+
+- **im**: Use `Content-Disposition` filename when downloading message resources (#536)
+- **drive**: Add `+apply-permission` to request doc access (#588)
+- Support record share link (#466)
+- **whiteboard**: Add image support to `whiteboard-cli` skill (#553)
+- **cmdutil**: Add `X-Cli-Build` header for CLI build classification (#596)
+
+### Bug Fixes
+
+- **base**: Add default-table follow-up hint to `base-create` (#600)
+- Skip flag-completion registration outside completion path (#598)
+- Add `record-share-link-create` in `SKILL.md` (#597)
+- **mail**: Remove leftover conflict marker in skill docs (#594)
+
+### Documentation
+
+- **drive**: Clarify that comment listing defaults to unresolved comments only (#609)
+- **doc**: Fix `--markdown` examples that teach literal `\n` (#602)
+- **mail**: Remove `get_signatures` from skill reference, exposed via `+signature` instead (#545)
+
+## [v1.0.16] - 2026-04-21
+
+### Features
+
+- **mail**: Support large email attachments (#537)
+- **mail**: Add draft preview URL to draft operations (#438)
+- **doc**: Add pre-write semantic warnings to `docs +update` (#569)
+- **doc**: Add `--selection-with-ellipsis` position flag to `+media-insert` (#335)
+- **calendar**: Support event share link and error details (#583)
+
+### Bug Fixes
+
+- **doc**: Preserve round-trip formatting in `+fetch` output (#469)
+- **docs**: Validate `--selection-by-title` format early (#256)
+- **whiteboard**: Register `+media-upload` shortcut and add whiteboard parent type
+
+### Refactor
+
+- Split `Execute` into `Build` + `Execute` with explicit IO and keychain injection (#371)
+- **auth**: Simplify scope reporting in login flow (#582)
+
 ## [v1.0.15] - 2026-04-20
 
 ### Features
@@ -420,6 +464,8 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
+[v1.0.17]: https://github.com/larksuite/cli/releases/tag/v1.0.17
+[v1.0.16]: https://github.com/larksuite/cli/releases/tag/v1.0.16
 [v1.0.15]: https://github.com/larksuite/cli/releases/tag/v1.0.15
 [v1.0.14]: https://github.com/larksuite/cli/releases/tag/v1.0.14
 [v1.0.13]: https://github.com/larksuite/cli/releases/tag/v1.0.13

cmd/api/api.go

@@ -57,6 +57,10 @@ func normalisePath(raw string) string {
 
 // NewCmdApi creates the api command. If runF is non-nil it is called instead of apiRun (test hook).
 func NewCmdApi(f *cmdutil.Factory, runF func(*APIOptions) error) *cobra.Command {
+	return NewCmdApiWithContext(context.Background(), f, runF)
+}
+
+func NewCmdApiWithContext(ctx context.Context, f *cmdutil.Factory, runF func(*APIOptions) error) *cobra.Command {
 	opts := &APIOptions{Factory: f}
 	var asStr string
 
@@ -79,7 +83,7 @@ func NewCmdApi(f *cmdutil.Factory, runF func(*APIOptions) error) *cobra.Command
 
 	cmd.Flags().StringVar(&opts.Params, "params", "", "query parameters JSON (supports - for stdin)")
 	cmd.Flags().StringVar(&opts.Data, "data", "", "request body JSON (supports - for stdin)")
-	cmd.Flags().StringVar(&asStr, "as", "auto", "identity type: user | bot | auto (default)")
+	cmdutil.AddAPIIdentityFlag(ctx, cmd, f, &asStr)
 	cmd.Flags().StringVarP(&opts.Output, "output", "o", "", "output file path for binary responses")
 	cmd.Flags().BoolVar(&opts.PageAll, "page-all", false, "automatically paginate through all pages")
 	cmd.Flags().IntVar(&opts.PageSize, "page-size", 0, "page size (0 = use API default)")
@@ -96,10 +100,7 @@ func NewCmdApi(f *cmdutil.Factory, runF func(*APIOptions) error) *cobra.Command
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
-	_ = cmd.RegisterFlagCompletionFunc("as", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return []string{"user", "bot"}, cobra.ShellCompDirectiveNoFileComp
-	})
-	_ = cmd.RegisterFlagCompletionFunc("format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+	cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 		return []string{"json", "ndjson", "table", "csv"}, cobra.ShellCompDirectiveNoFileComp
 	})
 

cmd/api/api_test.go

@@ -180,6 +180,24 @@ func TestApiValidArgsFunction(t *testing.T) {
 	}
 }
 
+func TestNewCmdApi_StrictModeHidesAsFlag(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu, SupportedIdentities: 2,
+	})
+
+	cmd := NewCmdApi(f, nil)
+	flag := cmd.Flags().Lookup("as")
+	if flag == nil {
+		t.Fatal("expected --as flag to be registered")
+	}
+	if !flag.Hidden {
+		t.Fatal("expected --as flag to be hidden in strict mode")
+	}
+	if got := flag.DefValue; got != "bot" {
+		t.Fatalf("default value = %q, want %q", got, "bot")
+	}
+}
+
 func TestApiCmd_PageLimitDefault(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,

cmd/auth/login.go

@@ -72,7 +72,7 @@ browser. Run it in the background and retrieve the verification URL from its out
 	cmd.Flags().BoolVar(&opts.NoWait, "no-wait", false, "initiate device authorization and return immediately; use --device-code to complete")
 	cmd.Flags().StringVar(&opts.DeviceCode, "device-code", "", "poll and complete authorization with a device code from a previous --no-wait call")
 
-	_ = cmd.RegisterFlagCompletionFunc("domain", func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	cmdutil.RegisterFlagCompletion(cmd, "domain", func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		return completeDomain(toComplete), cobra.ShellCompDirectiveNoFileComp
 	})
 

cmd/auth/login_messages.go

@@ -29,7 +29,6 @@ type loginMsg struct {
 	ScopeHint          string
 	RequestedScopes    string
 	NewlyGrantedScopes string
-	MissingScopes      string
 	NoScopes           string
 	StatusHint         string
 
@@ -59,14 +58,13 @@ var loginMsgZh = &loginMsg{
 
 	OpenURL:            "在浏览器中打开以下链接进行认证:\n\n",
 	WaitingAuth:        "等待用户授权...",
-	AuthSuccess:        "授权已完成，正在获取用户信息并校验授权结果...",
+	AuthSuccess:        "已收到授权确认，正在获取用户信息并校验授权结果...",
 	LoginSuccess:       "授权成功! 用户: %s (%s)",
 	AuthorizedUser:     "当前授权账号: %s (%s)",
-	ScopeMismatch:      "授权结果异常：以下请求 scopes 未被授予: %s",
+	ScopeMismatch:      "授权结果异常: 以下请求 scopes 未被授予: %s",
 	ScopeHint:          "以上结果是本次授权请求用户最终确认后的结果，请勿持续重试；Scopes 未授予的原因是多样的，如 scope 被禁用；具体原因已通过授权页提示用户。可执行 `lark-cli auth status` 查看账号当前已授予的全部 scopes；",
 	RequestedScopes:    "  本次请求 scopes: %s\n",
 	NewlyGrantedScopes: "  本次新授予 scopes: %s\n",
-	MissingScopes:      "  本次未授予 scopes: %s\n",
 	NoScopes:           "（空）",
 	StatusHint:         "可执行 `lark-cli auth status` 查看账号当前已授予的全部 scopes；",
 
@@ -95,14 +93,13 @@ var loginMsgEn = &loginMsg{
 
 	OpenURL:            "Open this URL in your browser to authenticate:\n\n",
 	WaitingAuth:        "Waiting for user authorization...",
-	AuthSuccess:        "Authorization completed, fetching user info and validating granted scopes...",
+	AuthSuccess:        "Authorization confirmed, fetching user info and validating granted scopes...",
 	LoginSuccess:       "Authorization successful! User: %s (%s)",
 	AuthorizedUser:     "Authorized account: %s (%s)",
 	ScopeMismatch:      "authorization result is abnormal: these requested scopes were not granted: %s",
 	ScopeHint:          "The result above is the user's final confirmation for this authorization request. Do not retry continuously. Scopes may be not granted for various reasons, such as a scope being disabled. The specific reason has already been shown to the user on the authorization page. Run `lark-cli auth status` to inspect all scopes currently granted to the account.",
 	RequestedScopes:    "  Requested scopes: %s\n",
 	NewlyGrantedScopes: "  Newly granted scopes: %s\n",
-	MissingScopes:      "  Not granted scopes: %s\n",
 	NoScopes:           "(none)",
 	StatusHint:         "Run `lark-cli auth status` to inspect all scopes currently granted to the account.",
 

cmd/auth/login_result.go

@@ -128,7 +128,7 @@ func emptyIfNil(s []string) []string {
 	return s
 }
 
-// writeLoginScopeBreakdown renders the requested/newly granted/missing scope
+// writeLoginScopeBreakdown renders the requested/newly granted scope
 // breakdown to stderr.
 func writeLoginScopeBreakdown(errOut *cmdutil.IOStreams, msg *loginMsg, summary *loginScopeSummary) {
 	if summary == nil {
@@ -136,7 +136,6 @@ func writeLoginScopeBreakdown(errOut *cmdutil.IOStreams, msg *loginMsg, summary
 	}
 	fmt.Fprintf(errOut.ErrOut, msg.RequestedScopes, formatScopeList(summary.Requested, msg.NoScopes))
 	fmt.Fprintf(errOut.ErrOut, msg.NewlyGrantedScopes, formatScopeList(summary.NewlyGranted, msg.NoScopes))
-	fmt.Fprintf(errOut.ErrOut, msg.MissingScopes, formatScopeList(summary.Missing, msg.NoScopes))
 }
 
 // writeLoginSuccess emits the successful login payload in either JSON or text

cmd/auth/login_test.go

@@ -363,7 +363,7 @@ func TestWriteLoginSuccess_JSONIncludesScopeDiff(t *testing.T) {
 func TestHandleLoginScopeIssue_NonJSONAlignsWithLoginSuccess(t *testing.T) {
 	f, _, stderr, _ := cmdutil.TestFactory(t, nil)
 	err := handleLoginScopeIssue(&LoginOptions{}, getLoginMsg("zh"), f, &loginScopeIssue{
-		Message: "授权结果异常：以下请求 scopes 未被授予: im:message:send",
+		Message: "授权结果异常: 以下请求 scopes 未被授予: im:message:send",
 		Hint:    "以上结果是本次授权请求用户最终确认后的结果，请勿持续重试；Scopes 未授予的原因是多样的，如 scope 被禁用；具体原因已通过授权页提示用户。可执行 `lark-cli auth status` 查看账号当前已授予的全部 scopes；",
 		Summary: &loginScopeSummary{
 			Requested: []string{"im:message:send"},
@@ -376,11 +376,10 @@ func TestHandleLoginScopeIssue_NonJSONAlignsWithLoginSuccess(t *testing.T) {
 	}
 	got := stderr.String()
 	for _, want := range []string{
-		"授权结果异常：以下请求 scopes 未被授予: im:message:send",
+		"授权结果异常: 以下请求 scopes 未被授予: im:message:send",
 		"当前授权账号: tester (ou_user)",
 		"本次请求 scopes: im:message:send",
 		"本次新授予 scopes: （空）",
-		"本次未授予 scopes: im:message:send",
 		"以上结果是本次授权请求用户最终确认后的结果，请勿持续重试",
 		"scope 被禁用",
 		"lark-cli auth status",
@@ -395,6 +394,9 @@ func TestHandleLoginScopeIssue_NonJSONAlignsWithLoginSuccess(t *testing.T) {
 	if strings.Contains(got, "授权成功") {
 		t.Fatalf("stderr should not contain success wording, got:\n%s", got)
 	}
+	if strings.Contains(got, "本次未授予 scopes:") {
+		t.Fatalf("stderr should not duplicate missing scopes, got:\n%s", got)
+	}
 }
 
 func TestHandleLoginScopeIssue_JSONAlignsWithLoginSuccess(t *testing.T) {
@@ -472,10 +474,10 @@ func TestWriteLoginSuccess_TextOutputScenarios(t *testing.T) {
 				"授权成功! 用户: tester (ou_user)",
 				"本次请求 scopes: im:message:send im:message:reply",
 				"本次新授予 scopes: im:message:send",
-				"本次未授予 scopes: （空）",
 				"可执行 `lark-cli auth status` 查看账号当前已授予的全部 scopes；",
 			},
 			expectedAbsent: []string{
+				"本次未授予 scopes:",
 				"最终已授权 scopes:",
 				"已有 scopes:",
 			},
@@ -490,10 +492,10 @@ func TestWriteLoginSuccess_TextOutputScenarios(t *testing.T) {
 			expectedPresent: []string{
 				"本次请求 scopes: im:message:send",
 				"本次新授予 scopes: （空）",
-				"本次未授予 scopes: （空）",
 				"可执行 `lark-cli auth status` 查看账号当前已授予的全部 scopes；",
 			},
 			expectedAbsent: []string{
+				"本次未授予 scopes:",
 				"最终已授权 scopes:",
 				"已有 scopes:",
 			},
@@ -508,9 +510,9 @@ func TestWriteLoginSuccess_TextOutputScenarios(t *testing.T) {
 			expectedPresent: []string{
 				"本次请求 scopes: im:message:send im:message:reply",
 				"本次新授予 scopes: （空）",
-				"本次未授予 scopes: im:message:send",
 			},
 			expectedAbsent: []string{
+				"本次未授予 scopes:",
 				"已有 scopes:",
 				"最终已授权 scopes:",
 				"可执行 `lark-cli auth status` 查看账号当前已授予的全部 scopes；",
@@ -619,10 +621,9 @@ func TestAuthLoginRun_MissingRequestedScopeAlignsWithLoginSuccess(t *testing.T)
 	}
 	got := stderr.String()
 	for _, want := range []string{
-		"授权结果异常：以下请求 scopes 未被授予: im:message:send",
+		"授权结果异常: 以下请求 scopes 未被授予: im:message:send",
 		"当前授权账号: tester (ou_user)",
 		"本次请求 scopes: im:message:send",
-		"本次未授予 scopes: im:message:send",
 		"以上结果是本次授权请求用户最终确认后的结果，请勿持续重试",
 		"scope 被禁用",
 		"lark-cli auth status",
@@ -637,6 +638,9 @@ func TestAuthLoginRun_MissingRequestedScopeAlignsWithLoginSuccess(t *testing.T)
 	if strings.Contains(got, "OK: 授权成功") {
 		t.Fatalf("stderr should not contain success prefix when scopes are missing, got:\n%s", got)
 	}
+	if strings.Contains(got, "本次未授予 scopes:") {
+		t.Fatalf("stderr should not duplicate missing scopes, got:\n%s", got)
+	}
 	if strings.Contains(got, "ERROR:") {
 		t.Fatalf("stderr should not contain error prefix, got:\n%s", got)
 	}
@@ -777,13 +781,15 @@ func TestWriteLoginSuccess_TextOutputEnglishIncludesStatusHintWhenNoMissingScope
 		"Authorization successful! User: tester (ou_user)",
 		"Requested scopes: im:message:send",
 		"Newly granted scopes: im:message:send",
-		"Not granted scopes: (none)",
 		"Run `lark-cli auth status` to inspect all scopes currently granted to the account.",
 	} {
 		if !strings.Contains(got, want) {
 			t.Fatalf("stderr missing %q, got:\n%s", want, got)
 		}
 	}
+	if strings.Contains(got, "Not granted scopes:") {
+		t.Fatalf("stderr should not contain not granted scopes, got:\n%s", got)
+	}
 }
 
 func TestAuthLoginRun_DeviceCodeTokenNilCleansScopeCache(t *testing.T) {

cmd/build.go

@@ -0,0 +1,129 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"context"
+	"io"
+
+	"github.com/larksuite/cli/cmd/api"
+	"github.com/larksuite/cli/cmd/auth"
+	"github.com/larksuite/cli/cmd/completion"
+	cmdconfig "github.com/larksuite/cli/cmd/config"
+	"github.com/larksuite/cli/cmd/doctor"
+	"github.com/larksuite/cli/cmd/profile"
+	"github.com/larksuite/cli/cmd/schema"
+	"github.com/larksuite/cli/cmd/service"
+	cmdupdate "github.com/larksuite/cli/cmd/update"
+	"github.com/larksuite/cli/internal/build"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/keychain"
+	"github.com/larksuite/cli/shortcuts"
+	"github.com/spf13/cobra"
+)
+
+// BuildOption configures optional aspects of the command tree construction.
+type BuildOption func(*buildConfig)
+
+type buildConfig struct {
+	streams  *cmdutil.IOStreams
+	keychain keychain.KeychainAccess
+	globals  GlobalOptions
+}
+
+// WithIO sets the IO streams for the CLI by wrapping raw reader/writers.
+// Terminal detection is delegated to cmdutil.NewIOStreams.
+func WithIO(in io.Reader, out, errOut io.Writer) BuildOption {
+	return func(c *buildConfig) {
+		c.streams = cmdutil.NewIOStreams(in, out, errOut)
+	}
+}
+
+// WithKeychain sets the secret storage backend. If not provided, the platform keychain is used.
+func WithKeychain(kc keychain.KeychainAccess) BuildOption {
+	return func(c *buildConfig) {
+		c.keychain = kc
+	}
+}
+
+// HideProfile sets the visibility policy for the root-level --profile flag.
+// When hide is true the flag stays registered (so existing invocations still
+// parse) but is omitted from help and shell completion. Typically called as
+// HideProfile(isSingleAppMode()).
+func HideProfile(hide bool) BuildOption {
+	return func(c *buildConfig) {
+		c.globals.HideProfile = hide
+	}
+}
+
+// Build constructs the full command tree without executing.
+// Returns only the cobra.Command; Factory is internal.
+// Use Execute for the standard production entry point.
+func Build(ctx context.Context, inv cmdutil.InvocationContext, opts ...BuildOption) *cobra.Command {
+	_, rootCmd := buildInternal(ctx, inv, opts...)
+	return rootCmd
+}
+
+// buildInternal is a pure assembly function: it wires the command tree from
+// inv and BuildOptions alone. Any state-dependent decision (disk, network,
+// env) belongs in the caller and must be threaded in via BuildOption.
+func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...BuildOption) (*cmdutil.Factory, *cobra.Command) {
+	// cfg.globals.Profile is left zero here; it's bound to the --profile
+	// flag in RegisterGlobalFlags and filled by cobra's parse step.
+	cfg := &buildConfig{}
+	for _, o := range opts {
+		if o != nil {
+			o(cfg)
+		}
+	}
+	// Default streams when WithIO is not supplied so the root command's
+	// SetIn/Out/Err calls below don't deref nil. NewDefault also normalizes
+	// partial streams internally; keep both in sync so cfg.streams reflects
+	// the same values the Factory ends up using.
+	if cfg.streams == nil {
+		cfg.streams = cmdutil.SystemIO()
+	}
+
+	f := cmdutil.NewDefault(cfg.streams, inv)
+	if cfg.keychain != nil {
+		f.Keychain = cfg.keychain
+	}
+	rootCmd := &cobra.Command{
+		Use:     "lark-cli",
+		Short:   "Lark/Feishu CLI — OAuth authorization, UAT management, API calls",
+		Long:    rootLong,
+		Version: build.Version,
+	}
+
+	rootCmd.SetContext(ctx)
+	rootCmd.SetIn(cfg.streams.In)
+	rootCmd.SetOut(cfg.streams.Out)
+	rootCmd.SetErr(cfg.streams.ErrOut)
+
+	installTipsHelpFunc(rootCmd)
+	rootCmd.SilenceErrors = true
+
+	RegisterGlobalFlags(rootCmd.PersistentFlags(), &cfg.globals)
+	rootCmd.PersistentPreRun = func(cmd *cobra.Command, args []string) {
+		cmd.SilenceUsage = true
+	}
+
+	rootCmd.AddCommand(cmdconfig.NewCmdConfig(f))
+	rootCmd.AddCommand(auth.NewCmdAuth(f))
+	rootCmd.AddCommand(profile.NewCmdProfile(f))
+	rootCmd.AddCommand(doctor.NewCmdDoctor(f))
+	rootCmd.AddCommand(api.NewCmdApiWithContext(ctx, f, nil))
+	rootCmd.AddCommand(schema.NewCmdSchema(f, nil))
+	rootCmd.AddCommand(completion.NewCmdCompletion(f))
+	rootCmd.AddCommand(cmdupdate.NewCmdUpdate(f))
+	service.RegisterServiceCommandsWithContext(ctx, rootCmd, f)
+	shortcuts.RegisterShortcutsWithContext(ctx, rootCmd, f)
+
+	// Prune commands incompatible with strict mode.
+	if mode := f.ResolveStrictMode(ctx); mode.IsActive() {
+		pruneForStrictMode(rootCmd, mode)
+	}
+
+	return f, rootCmd
+}

cmd/build_api_test.go

@@ -0,0 +1,63 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+// noopKeychain is a zero-side-effect KeychainAccess for exercising
+// WithKeychain without touching the platform keychain.
+type noopKeychain struct{}
+
+func (noopKeychain) Get(service, account string) (string, error) { return "", nil }
+func (noopKeychain) Set(service, account, value string) error    { return nil }
+func (noopKeychain) Remove(service, account string) error        { return nil }
+
+// TestBuild_ExternalAPI asserts the library surface that external consumers
+// (e.g. cli-server) depend on: Build composes a root command from an
+// InvocationContext plus BuildOptions (WithIO, WithKeychain, HideProfile),
+// and SetDefaultFS swaps the global VFS. This test is the contract guard.
+func TestBuild_ExternalAPI(t *testing.T) {
+	// Exercise SetDefaultFS both directions. Passing nil restores the OS FS.
+	SetDefaultFS(vfs.OsFs{})
+	SetDefaultFS(nil)
+
+	var in, out, errOut bytes.Buffer
+	rootCmd := Build(
+		context.Background(),
+		cmdutil.InvocationContext{},
+		WithIO(&in, &out, &errOut),
+		WithKeychain(noopKeychain{}),
+		HideProfile(true),
+	)
+
+	if rootCmd == nil {
+		t.Fatal("Build returned nil root command")
+	}
+	if rootCmd.Use != "lark-cli" {
+		t.Errorf("rootCmd.Use = %q, want %q", rootCmd.Use, "lark-cli")
+	}
+	if len(rootCmd.Commands()) == 0 {
+		t.Error("Build produced a root command with no subcommands")
+	}
+}
+
+// TestBuild_NoOptions guards against regression of the nil-streams panic:
+// calling Build without WithIO must fall back to SystemIO rather than
+// deref nil at rootCmd.SetIn/Out/Err.
+func TestBuild_NoOptions(t *testing.T) {
+	rootCmd := Build(context.Background(), cmdutil.InvocationContext{})
+	if rootCmd == nil {
+		t.Fatal("Build returned nil root command")
+	}
+	if rootCmd.Use != "lark-cli" {
+		t.Errorf("rootCmd.Use = %q, want %q", rootCmd.Use, "lark-cli")
+	}
+}

cmd/global_flags.go

@@ -3,15 +3,38 @@
 
 package cmd
 
-import "github.com/spf13/pflag"
+import (
+	"github.com/larksuite/cli/internal/core"
+	"github.com/spf13/pflag"
+)
 
 // GlobalOptions are the root-level flags shared by bootstrap parsing and the
-// actual Cobra command tree.
+// actual Cobra command tree. Profile is the parsed --profile value; HideProfile
+// is a build-time policy — when true, --profile stays parseable but is marked
+// hidden from help and shell completion.
 type GlobalOptions struct {
-	Profile string
+	Profile     string
+	HideProfile bool
 }
 
-// RegisterGlobalFlags registers the root-level persistent flags.
+// RegisterGlobalFlags registers the root-level persistent flags on fs and
+// applies any visibility policy encoded in opts. Pure function: no disk,
+// network, or environment reads — the caller decides HideProfile.
 func RegisterGlobalFlags(fs *pflag.FlagSet, opts *GlobalOptions) {
 	fs.StringVar(&opts.Profile, "profile", "", "use a specific profile")
+	if opts.HideProfile {
+		_ = fs.MarkHidden("profile")
+	}
+}
+
+// isSingleAppMode reports whether the on-disk config has at most one app.
+// Missing configs are treated as single-app since --profile is meaningless
+// until at least two profiles exist. Intended for the Execute entry point —
+// buildInternal must not call this directly to stay state-free.
+func isSingleAppMode() bool {
+	raw, err := core.LoadMultiAppConfig()
+	if err != nil || raw == nil {
+		return true
+	}
+	return len(raw.Apps) <= 1
 }

cmd/global_flags_test.go

@@ -0,0 +1,110 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/spf13/pflag"
+)
+
+func testStreams() BuildOption { return WithIO(os.Stdin, os.Stdout, os.Stderr) }
+
+func TestRegisterGlobalFlags_PolicyVisible(t *testing.T) {
+	fs := pflag.NewFlagSet("test", pflag.ContinueOnError)
+	opts := &GlobalOptions{}
+	RegisterGlobalFlags(fs, opts)
+
+	flag := fs.Lookup("profile")
+	if flag == nil {
+		t.Fatal("profile flag should be registered")
+	}
+	if flag.Hidden {
+		t.Fatal("profile flag should be visible when HideProfile is false")
+	}
+}
+
+func TestRegisterGlobalFlags_PolicyHidden(t *testing.T) {
+	fs := pflag.NewFlagSet("test", pflag.ContinueOnError)
+	opts := &GlobalOptions{HideProfile: true}
+	RegisterGlobalFlags(fs, opts)
+
+	flag := fs.Lookup("profile")
+	if flag == nil {
+		t.Fatal("profile flag should be registered")
+	}
+	if !flag.Hidden {
+		t.Fatal("profile flag should be hidden when HideProfile is true")
+	}
+	if err := fs.Parse([]string{"--profile", "x"}); err != nil {
+		t.Fatalf("Parse() error = %v; hidden flag should still parse", err)
+	}
+	if opts.Profile != "x" {
+		t.Fatalf("opts.Profile = %q, want %q", opts.Profile, "x")
+	}
+}
+
+func TestIsSingleAppMode_NoConfig(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	if !isSingleAppMode() {
+		t.Fatal("isSingleAppMode() = false, want true when no config exists")
+	}
+}
+
+func TestIsSingleAppMode_SingleApp(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	saveAppsForTest(t, []core.AppConfig{
+		{Name: "default", AppId: "cli_a", AppSecret: core.PlainSecret("x"), Brand: core.BrandFeishu},
+	})
+	if !isSingleAppMode() {
+		t.Fatal("isSingleAppMode() = false, want true for single-app config")
+	}
+}
+
+func TestIsSingleAppMode_MultiApp(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	saveAppsForTest(t, []core.AppConfig{
+		{Name: "a", AppId: "cli_a", AppSecret: core.PlainSecret("x"), Brand: core.BrandFeishu},
+		{Name: "b", AppId: "cli_b", AppSecret: core.PlainSecret("y"), Brand: core.BrandFeishu},
+	})
+	if isSingleAppMode() {
+		t.Fatal("isSingleAppMode() = true, want false for multi-app config")
+	}
+}
+
+func TestBuildInternal_HideProfileOption(t *testing.T) {
+	_, root := buildInternal(context.Background(), cmdutil.InvocationContext{}, testStreams(), HideProfile(true))
+
+	flag := root.PersistentFlags().Lookup("profile")
+	if flag == nil {
+		t.Fatal("profile flag should be registered")
+	}
+	if !flag.Hidden {
+		t.Fatal("profile flag should be hidden when HideProfile(true) is applied")
+	}
+}
+
+func TestBuildInternal_DefaultShowsProfileFlag(t *testing.T) {
+	_, root := buildInternal(context.Background(), cmdutil.InvocationContext{}, testStreams())
+
+	flag := root.PersistentFlags().Lookup("profile")
+	if flag == nil {
+		t.Fatal("profile flag should be registered by default")
+	}
+	if flag.Hidden {
+		t.Fatal("profile flag should be visible by default")
+	}
+}
+
+func saveAppsForTest(t *testing.T, apps []core.AppConfig) {
+	t.Helper()
+	multi := &core.MultiAppConfig{CurrentApp: apps[0].Name, Apps: apps}
+	if err := core.SaveMultiAppConfig(multi); err != nil {
+		t.Fatalf("SaveMultiAppConfig() error = %v", err)
+	}
+}

cmd/init.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import "github.com/larksuite/cli/internal/vfs"
+
+// SetDefaultFS replaces the global filesystem implementation used by internal
+// packages. The provided fs must implement the vfs.FS interface. If fs is nil,
+// the default OS filesystem is restored.
+//
+// Call this before Build or Execute to take effect.
+func SetDefaultFS(fs vfs.FS) {
+	if fs == nil {
+		fs = vfs.OsFs{}
+	}
+	vfs.DefaultFS = fs
+}

cmd/root.go

@@ -14,15 +14,6 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/larksuite/cli/cmd/api"
-	"github.com/larksuite/cli/cmd/auth"
-	"github.com/larksuite/cli/cmd/completion"
-	cmdconfig "github.com/larksuite/cli/cmd/config"
-	"github.com/larksuite/cli/cmd/doctor"
-	"github.com/larksuite/cli/cmd/profile"
-	"github.com/larksuite/cli/cmd/schema"
-	"github.com/larksuite/cli/cmd/service"
-	cmdupdate "github.com/larksuite/cli/cmd/update"
 	internalauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdutil"
@@ -30,7 +21,6 @@ import (
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/registry"
 	"github.com/larksuite/cli/internal/update"
-	"github.com/larksuite/cli/shortcuts"
 	"github.com/spf13/cobra"
 )
 
@@ -95,38 +85,13 @@ func Execute() int {
 		fmt.Fprintln(os.Stderr, "Error:", err)
 		return 1
 	}
-	f := cmdutil.NewDefault(inv)
+	configureFlagCompletions(os.Args)
 
-	globals := &GlobalOptions{Profile: inv.Profile}
-	rootCmd := &cobra.Command{
-		Use:     "lark-cli",
-		Short:   "Lark/Feishu CLI — OAuth authorization, UAT management, API calls",
-		Long:    rootLong,
-		Version: build.Version,
-	}
-	installTipsHelpFunc(rootCmd)
-	rootCmd.SilenceErrors = true
-
-	RegisterGlobalFlags(rootCmd.PersistentFlags(), globals)
-	rootCmd.PersistentPreRun = func(cmd *cobra.Command, args []string) {
-		cmd.SilenceUsage = true
-	}
-
-	rootCmd.AddCommand(cmdconfig.NewCmdConfig(f))
-	rootCmd.AddCommand(auth.NewCmdAuth(f))
-	rootCmd.AddCommand(profile.NewCmdProfile(f))
-	rootCmd.AddCommand(doctor.NewCmdDoctor(f))
-	rootCmd.AddCommand(api.NewCmdApi(f, nil))
-	rootCmd.AddCommand(schema.NewCmdSchema(f, nil))
-	rootCmd.AddCommand(completion.NewCmdCompletion(f))
-	rootCmd.AddCommand(cmdupdate.NewCmdUpdate(f))
-	service.RegisterServiceCommands(rootCmd, f)
-	shortcuts.RegisterShortcuts(rootCmd, f)
-
-	// Prune commands incompatible with strict mode.
-	if mode := f.ResolveStrictMode(context.Background()); mode.IsActive() {
-		pruneForStrictMode(rootCmd, mode)
-	}
+	f, rootCmd := buildInternal(
+		context.Background(), inv,
+		WithIO(os.Stdin, os.Stdout, os.Stderr),
+		HideProfile(isSingleAppMode()),
+	)
 
 	// --- Update check (non-blocking) ---
 	if !isCompletionCommand(os.Args) {
@@ -190,6 +155,12 @@ func isCompletionCommand(args []string) bool {
 	return false
 }
 
+// configureFlagCompletions enables cmdutil.RegisterFlagCompletion only when
+// the invocation will actually serve a __complete request.
+func configureFlagCompletions(args []string) {
+	cmdutil.SetFlagCompletionsDisabled(!isCompletionCommand(args))
+}
+
 // handleRootError dispatches a command error to the appropriate handler
 // and returns the process exit code.
 func handleRootError(f *cmdutil.Factory, err error) int {
@@ -277,10 +248,19 @@ func writeSecurityPolicyError(w io.Writer, spErr *internalauth.SecurityPolicyErr
 }
 
 // installTipsHelpFunc wraps the default help function to append a TIPS section
-// when a command has tips set via cmdutil.SetTips.
+// when a command has tips set via cmdutil.SetTips. It also force-shows global
+// flags that are normally hidden in single-app mode (currently --profile)
+// when rendering the root command's own help, so users discovering the CLI
+// still see them at `lark-cli --help`.
 func installTipsHelpFunc(root *cobra.Command) {
 	defaultHelp := root.HelpFunc()
 	root.SetHelpFunc(func(cmd *cobra.Command, args []string) {
+		if cmd == root {
+			if f := root.PersistentFlags().Lookup("profile"); f != nil && f.Hidden {
+				f.Hidden = false
+				defer func() { f.Hidden = true }()
+			}
+		}
 		defaultHelp(cmd, args)
 		tips := cmdutil.GetTips(cmd)
 		if len(tips) == 0 {

cmd/root_integration_test.go

@@ -135,10 +135,12 @@ func newStrictModeDefaultFactory(t *testing.T, profile string, mode core.StrictM
 		t.Fatalf("SaveMultiAppConfig() error = %v", err)
 	}
 
-	f := cmdutil.NewDefault(cmdutil.InvocationContext{Profile: profile})
 	stdout := &bytes.Buffer{}
 	stderr := &bytes.Buffer{}
-	f.IOStreams = &cmdutil.IOStreams{In: nil, Out: stdout, ErrOut: stderr}
+	f := cmdutil.NewDefault(
+		cmdutil.NewIOStreams(&bytes.Buffer{}, stdout, stderr),
+		cmdutil.InvocationContext{Profile: profile},
+	)
 	return f, stdout, stderr
 }
 

cmd/root_test.go

@@ -196,3 +196,28 @@ func TestRootLong_AgentSkillsLinkTargetsReadmeSection(t *testing.T) {
 		t.Fatalf("root help should not reference the removed install-ai-agent-skills anchor, got:\n%s", rootLong)
 	}
 }
+
+func TestConfigureFlagCompletions(t *testing.T) {
+	t.Cleanup(func() { cmdutil.SetFlagCompletionsDisabled(false) })
+
+	tests := []struct {
+		name         string
+		args         []string
+		wantDisabled bool
+	}{
+		{"plain command", []string{"im", "+send"}, true},
+		{"help flag", []string{"im", "--help"}, true},
+		{"no args", []string{}, true},
+		{"__complete request", []string{"__complete", "im", "+send", ""}, false},
+		{"completion subcommand", []string{"completion", "bash"}, false},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			cmdutil.SetFlagCompletionsDisabled(!tc.wantDisabled)
+			configureFlagCompletions(tc.args)
+			if got := cmdutil.FlagCompletionsDisabled(); got != tc.wantDisabled {
+				t.Fatalf("FlagCompletionsDisabled() = %v, want %v", got, tc.wantDisabled)
+			}
+		})
+	}
+}

cmd/schema/schema.go

@@ -4,12 +4,14 @@
 package schema
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"sort"
 	"strings"
 
 	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/registry"
 	"github.com/larksuite/cli/internal/util"
@@ -19,6 +21,7 @@ import (
 // SchemaOptions holds all inputs for the schema command.
 type SchemaOptions struct {
 	Factory *cmdutil.Factory
+	Ctx     context.Context
 
 	// Positional args
 	Path string
@@ -41,7 +44,7 @@ func printServices(w io.Writer) {
 	fmt.Fprintf(w, "\n%sUsage: lark-cli schema <service>.<resource>.<method>%s\n", output.Dim, output.Reset)
 }
 
-func printResourceList(w io.Writer, spec map[string]interface{}) {
+func printResourceList(w io.Writer, spec map[string]interface{}, mode core.StrictMode) {
 	name := registry.GetStrFromMap(spec, "name")
 	version := registry.GetStrFromMap(spec, "version")
 	title := registry.GetStrFromMap(spec, "title")
@@ -55,9 +58,13 @@ func printResourceList(w io.Writer, spec map[string]interface{}) {
 
 	resources, _ := spec["resources"].(map[string]interface{})
 	for _, resName := range sortedKeys(resources) {
-		fmt.Fprintf(w, "  %s%s%s\n", output.Cyan, resName, output.Reset)
 		resMap, _ := resources[resName].(map[string]interface{})
 		methods, _ := resMap["methods"].(map[string]interface{})
+		methods = filterMethodsByStrictMode(methods, mode)
+		if len(methods) == 0 {
+			continue
+		}
+		fmt.Fprintf(w, "  %s%s%s\n", output.Cyan, resName, output.Reset)
 		for _, methodName := range sortedKeys(methods) {
 			m, _ := methods[methodName].(map[string]interface{})
 			httpMethod := registry.GetStrFromMap(m, "httpMethod")
@@ -359,6 +366,7 @@ func NewCmdSchema(f *cmdutil.Factory, runF func(*SchemaOptions) error) *cobra.Co
 			if len(args) > 0 {
 				opts.Path = args[0]
 			}
+			opts.Ctx = cmd.Context()
 			if runF != nil {
 				return runF(opts)
 			}
@@ -367,9 +375,9 @@ func NewCmdSchema(f *cmdutil.Factory, runF func(*SchemaOptions) error) *cobra.Co
 	}
 	cmdutil.DisableAuthCheck(cmd)
 
-	cmd.ValidArgsFunction = completeSchemaPath
+	cmd.ValidArgsFunction = completeSchemaPath(f)
 	cmd.Flags().StringVar(&opts.Format, "format", "json", "output format: json (default) | pretty")
-	_ = cmd.RegisterFlagCompletionFunc("format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+	cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 		return []string{"json", "pretty"}, cobra.ShellCompDirectiveNoFileComp
 	})
 
@@ -379,78 +387,86 @@ func NewCmdSchema(f *cmdutil.Factory, runF func(*SchemaOptions) error) *cobra.Co
 // completeSchemaPath provides tab-completion for the schema path argument.
 // It handles dotted resource names (e.g. app.table.fields) by iterating all
 // resources and classifying each as a prefix-match or fully-matched.
-func completeSchemaPath(_ *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-	if len(args) > 0 {
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	}
+func completeSchemaPath(f *cmdutil.Factory) func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
+	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
 
-	parts := strings.Split(toComplete, ".")
+		parts := strings.Split(toComplete, ".")
 
-	// Level 1: complete service names
-	if len(parts) <= 1 {
-		var completions []string
-		for _, s := range registry.ListFromMetaProjects() {
-			if strings.HasPrefix(s, toComplete) {
-				completions = append(completions, s+".")
+		// Level 1: complete service names
+		if len(parts) <= 1 {
+			var completions []string
+			for _, s := range registry.ListFromMetaProjects() {
+				if strings.HasPrefix(s, toComplete) {
+					completions = append(completions, s+".")
+				}
+			}
+			return completions, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveNoSpace
+		}
+
+		serviceName := parts[0]
+		spec := registry.LoadFromMeta(serviceName)
+		if spec == nil {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		mode := f.ResolveStrictMode(cmd.Context())
+		spec = filterSpecByStrictMode(spec, mode)
+		resources, _ := spec["resources"].(map[string]interface{})
+		if resources == nil {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		afterService := strings.Join(parts[1:], ".")
+		completions := completeSchemaPathForSpec(serviceName, resources, afterService)
+
+		allTrailingDot := len(completions) > 0
+		for _, c := range completions {
+			if !strings.HasSuffix(c, ".") {
+				allTrailingDot = false
+				break
 			}
 		}
-		return completions, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveNoSpace
+		directive := cobra.ShellCompDirectiveNoFileComp
+		if allTrailingDot {
+			directive |= cobra.ShellCompDirectiveNoSpace
+		}
+		return completions, directive
 	}
+}
 
-	serviceName := parts[0]
-	spec := registry.LoadFromMeta(serviceName)
-	if spec == nil {
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	}
-	resources, _ := spec["resources"].(map[string]interface{})
-	if resources == nil {
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	}
-
-	// afterService = everything user typed after "serviceName."
-	afterService := strings.Join(parts[1:], ".")
-
+func completeSchemaPathForSpec(serviceName string, resources map[string]interface{}, afterService string) []string {
 	var completions []string
 
 	for resName, resVal := range resources {
 		if strings.HasPrefix(resName, afterService) {
-			// afterService is a prefix of this resource name → resource candidate
 			completions = append(completions, serviceName+"."+resName+".")
-		} else if strings.HasPrefix(afterService, resName+".") {
-			// This resource is fully matched; remainder is method prefix
-			methodPrefix := afterService[len(resName)+1:]
-			resMap, _ := resVal.(map[string]interface{})
-			if resMap == nil {
-				continue
-			}
-			methods, _ := resMap["methods"].(map[string]interface{})
-			for methodName := range methods {
-				if strings.HasPrefix(methodName, methodPrefix) {
-					completions = append(completions, serviceName+"."+resName+"."+methodName)
-				}
+			continue
+		}
+		if !strings.HasPrefix(afterService, resName+".") {
+			continue
+		}
+		methodPrefix := afterService[len(resName)+1:]
+		resMap, _ := resVal.(map[string]interface{})
+		if resMap == nil {
+			continue
+		}
+		methods, _ := resMap["methods"].(map[string]interface{})
+		for methodName := range methods {
+			if strings.HasPrefix(methodName, methodPrefix) {
+				completions = append(completions, serviceName+"."+resName+"."+methodName)
 			}
 		}
 	}
 
 	sort.Strings(completions)
-
-	// If all completions end with ".", user is still navigating resources → NoSpace
-	allTrailingDot := len(completions) > 0
-	for _, c := range completions {
-		if !strings.HasSuffix(c, ".") {
-			allTrailingDot = false
-			break
-		}
-	}
-	directive := cobra.ShellCompDirectiveNoFileComp
-	if allTrailingDot {
-		directive |= cobra.ShellCompDirectiveNoSpace
-	}
-	return completions, directive
+	return completions
 }
 
 func schemaRun(opts *SchemaOptions) error {
 	out := opts.Factory.IOStreams.Out
+	mode := opts.Factory.ResolveStrictMode(opts.Ctx)
 
 	if opts.Path == "" {
 		printServices(out)
@@ -469,9 +485,9 @@ func schemaRun(opts *SchemaOptions) error {
 
 	if len(parts) == 1 {
 		if opts.Format == "pretty" {
-			printResourceList(out, spec)
+			printResourceList(out, spec, mode)
 		} else {
-			output.PrintJson(out, spec)
+			output.PrintJson(out, filterSpecByStrictMode(spec, mode))
 		}
 		return nil
 	}
@@ -492,6 +508,7 @@ func schemaRun(opts *SchemaOptions) error {
 		if opts.Format == "pretty" {
 			fmt.Fprintf(out, "%s%s.%s%s\n\n", output.Bold, serviceName, resName, output.Reset)
 			methods, _ := resource["methods"].(map[string]interface{})
+			methods = filterMethodsByStrictMode(methods, mode)
 			for _, mName := range sortedKeys(methods) {
 				m, _ := methods[mName].(map[string]interface{})
 				httpMethod := registry.GetStrFromMap(m, "httpMethod")
@@ -500,13 +517,26 @@ func schemaRun(opts *SchemaOptions) error {
 			}
 			fmt.Fprintf(out, "\n%sUsage: lark-cli schema %s.%s.<method>%s\n", output.Dim, serviceName, resName, output.Reset)
 		} else {
-			output.PrintJson(out, resource)
+			// For JSON output, filter methods in a copy to avoid mutating the registry.
+			if mode.IsActive() {
+				filtered := make(map[string]interface{})
+				for k, v := range resource {
+					filtered[k] = v
+				}
+				if methods, ok := resource["methods"].(map[string]interface{}); ok {
+					filtered["methods"] = filterMethodsByStrictMode(methods, mode)
+				}
+				output.PrintJson(out, filtered)
+			} else {
+				output.PrintJson(out, resource)
+			}
 		}
 		return nil
 	}
 
 	methodName := remaining[0]
 	methods, _ := resource["methods"].(map[string]interface{})
+	methods = filterMethodsByStrictMode(methods, mode)
 	method, ok := methods[methodName].(map[string]interface{})
 	if !ok {
 		var mNames []string
@@ -525,3 +555,67 @@ func schemaRun(opts *SchemaOptions) error {
 	}
 	return nil
 }
+
+// filterSpecByStrictMode returns a shallow copy of spec with each resource's methods
+// filtered by strict mode. Returns the original spec when strict mode is off.
+func filterSpecByStrictMode(spec map[string]interface{}, mode core.StrictMode) map[string]interface{} {
+	if !mode.IsActive() {
+		return spec
+	}
+	result := make(map[string]interface{}, len(spec))
+	for k, v := range spec {
+		result[k] = v
+	}
+	resources, _ := spec["resources"].(map[string]interface{})
+	if resources == nil {
+		return result
+	}
+	filteredRes := make(map[string]interface{}, len(resources))
+	for resName, resVal := range resources {
+		resMap, ok := resVal.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		methods, _ := resMap["methods"].(map[string]interface{})
+		filtered := filterMethodsByStrictMode(methods, mode)
+		if len(filtered) == 0 {
+			continue
+		}
+		resCopy := make(map[string]interface{}, len(resMap))
+		for k, v := range resMap {
+			resCopy[k] = v
+		}
+		resCopy["methods"] = filtered
+		filteredRes[resName] = resCopy
+	}
+	result["resources"] = filteredRes
+	return result
+}
+
+// filterMethodsByStrictMode removes methods incompatible with the active strict mode.
+// Returns the original map unmodified when strict mode is off.
+func filterMethodsByStrictMode(methods map[string]interface{}, mode core.StrictMode) map[string]interface{} {
+	if !mode.IsActive() || methods == nil {
+		return methods
+	}
+	token := registry.IdentityToAccessToken(string(mode.ForcedIdentity()))
+	filtered := make(map[string]interface{}, len(methods))
+	for name, val := range methods {
+		m, ok := val.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		tokens, _ := m["accessTokens"].([]interface{})
+		if tokens == nil {
+			filtered[name] = val
+			continue
+		}
+		for _, t := range tokens {
+			if ts, ok := t.(string); ok && ts == token {
+				filtered[name] = val
+				break
+			}
+		}
+	}
+	return filtered
+}

cmd/schema/schema_test.go

@@ -182,3 +182,49 @@ func TestHasFileFields(t *testing.T) {
 		})
 	}
 }
+
+func TestCompleteSchemaPathForSpec(t *testing.T) {
+	resources := map[string]interface{}{
+		"records": map[string]interface{}{
+			"methods": map[string]interface{}{
+				"create": map[string]interface{}{},
+				"list":   map[string]interface{}{},
+			},
+		},
+		"record_permissions": map[string]interface{}{
+			"methods": map[string]interface{}{
+				"get": map[string]interface{}{},
+			},
+		},
+	}
+
+	got := completeSchemaPathForSpec("base", resources, "records.cr")
+	if len(got) != 1 || got[0] != "base.records.create" {
+		t.Fatalf("completions = %v, want [base.records.create]", got)
+	}
+
+	got = completeSchemaPathForSpec("base", resources, "record")
+	if len(got) != 2 || got[0] != "base.record_permissions." || got[1] != "base.records." {
+		t.Fatalf("resource completions = %v", got)
+	}
+}
+
+func TestFilterSpecByStrictMode_RemovesIncompatibleMethodsFromCompletionSource(t *testing.T) {
+	spec := map[string]interface{}{
+		"resources": map[string]interface{}{
+			"records": map[string]interface{}{
+				"methods": map[string]interface{}{
+					"list":   map[string]interface{}{"accessTokens": []interface{}{"tenant"}},
+					"create": map[string]interface{}{"accessTokens": []interface{}{"user"}},
+				},
+			},
+		},
+	}
+
+	filtered := filterSpecByStrictMode(spec, core.StrictModeBot)
+	resources, _ := filtered["resources"].(map[string]interface{})
+	got := completeSchemaPathForSpec("base", resources, "records.")
+	if len(got) != 1 || got[0] != "base.records.list" {
+		t.Fatalf("filtered completions = %v, want [base.records.list]", got)
+	}
+}

cmd/service/service.go

@@ -24,6 +24,10 @@ import (
 
 // RegisterServiceCommands registers all service commands from from_meta specs.
 func RegisterServiceCommands(parent *cobra.Command, f *cmdutil.Factory) {
+	RegisterServiceCommandsWithContext(context.Background(), parent, f)
+}
+
+func RegisterServiceCommandsWithContext(ctx context.Context, parent *cobra.Command, f *cmdutil.Factory) {
 	for _, project := range registry.ListFromMetaProjects() {
 		spec := registry.LoadFromMeta(project)
 		if spec == nil {
@@ -38,11 +42,15 @@ func RegisterServiceCommands(parent *cobra.Command, f *cmdutil.Factory) {
 		if resources == nil {
 			continue
 		}
-		registerService(parent, spec, resources, f)
+		registerServiceWithContext(ctx, parent, spec, resources, f)
 	}
 }
 
 func registerService(parent *cobra.Command, spec map[string]interface{}, resources map[string]interface{}, f *cmdutil.Factory) {
+	registerServiceWithContext(context.Background(), parent, spec, resources, f)
+}
+
+func registerServiceWithContext(ctx context.Context, parent *cobra.Command, spec map[string]interface{}, resources map[string]interface{}, f *cmdutil.Factory) {
 	specName := registry.GetStrFromMap(spec, "name")
 	specDesc := registry.GetServiceDescription(specName, "en")
 	if specDesc == "" {
@@ -70,11 +78,11 @@ func registerService(parent *cobra.Command, spec map[string]interface{}, resourc
 		if resMap == nil {
 			continue
 		}
-		registerResource(svc, spec, resName, resMap, f)
+		registerResourceWithContext(ctx, svc, spec, resName, resMap, f)
 	}
 }
 
-func registerResource(parent *cobra.Command, spec map[string]interface{}, name string, resource map[string]interface{}, f *cmdutil.Factory) {
+func registerResourceWithContext(ctx context.Context, parent *cobra.Command, spec map[string]interface{}, name string, resource map[string]interface{}, f *cmdutil.Factory) {
 	res := &cobra.Command{
 		Use:   name,
 		Short: name + " operations",
@@ -87,7 +95,7 @@ func registerResource(parent *cobra.Command, spec map[string]interface{}, name s
 		if methodMap == nil {
 			continue
 		}
-		registerMethod(res, spec, methodMap, methodName, name, f)
+		registerMethodWithContext(ctx, res, spec, methodMap, methodName, name, f)
 	}
 }
 
@@ -120,12 +128,16 @@ func detectFileFields(method map[string]interface{}) []string {
 	return cmdutil.DetectFileFields(method)
 }
 
-func registerMethod(parent *cobra.Command, spec map[string]interface{}, method map[string]interface{}, name string, resName string, f *cmdutil.Factory) {
-	parent.AddCommand(NewCmdServiceMethod(f, spec, method, name, resName, nil))
+func registerMethodWithContext(ctx context.Context, parent *cobra.Command, spec map[string]interface{}, method map[string]interface{}, name string, resName string, f *cmdutil.Factory) {
+	parent.AddCommand(NewCmdServiceMethodWithContext(ctx, f, spec, method, name, resName, nil))
 }
 
 // NewCmdServiceMethod creates a command for a dynamically registered service method.
 func NewCmdServiceMethod(f *cmdutil.Factory, spec, method map[string]interface{}, name, resName string, runF func(*ServiceMethodOptions) error) *cobra.Command {
+	return NewCmdServiceMethodWithContext(context.Background(), f, spec, method, name, resName, runF)
+}
+
+func NewCmdServiceMethodWithContext(ctx context.Context, f *cmdutil.Factory, spec, method map[string]interface{}, name, resName string, runF func(*ServiceMethodOptions) error) *cobra.Command {
 	desc := registry.GetStrFromMap(method, "description")
 	httpMethod := registry.GetStrFromMap(method, "httpMethod")
 	specName := registry.GetStrFromMap(spec, "name")
@@ -159,7 +171,7 @@ func NewCmdServiceMethod(f *cmdutil.Factory, spec, method map[string]interface{}
 	case "POST", "PUT", "PATCH", "DELETE":
 		cmd.Flags().StringVar(&opts.Data, "data", "", "request body JSON (supports - for stdin)")
 	}
-	cmd.Flags().StringVar(&asStr, "as", "auto", "identity type: user | bot | auto (default)")
+	cmdutil.AddAPIIdentityFlag(ctx, cmd, f, &asStr)
 	cmd.Flags().StringVarP(&opts.Output, "output", "o", "", "output file path for binary responses")
 	cmd.Flags().BoolVar(&opts.PageAll, "page-all", false, "automatically paginate through all pages")
 	cmd.Flags().IntVar(&opts.PageLimit, "page-limit", 10, "max pages to fetch with --page-all (0 = unlimited)")
@@ -177,11 +189,7 @@ func NewCmdServiceMethod(f *cmdutil.Factory, spec, method map[string]interface{}
 			cmd.Flags().StringVar(&opts.File, "file", "", "file to upload ([field=]path, supports - for stdin)")
 		}
 	}
-
-	_ = cmd.RegisterFlagCompletionFunc("as", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return []string{"user", "bot"}, cobra.ShellCompDirectiveNoFileComp
-	})
-	_ = cmd.RegisterFlagCompletionFunc("format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+	cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 		return []string{"json", "ndjson", "table", "csv"}, cobra.ShellCompDirectiveNoFileComp
 	})
 

cmd/service/service_test.go

@@ -121,6 +121,24 @@ func TestRegisterService_MergesExistingCommand(t *testing.T) {
 	}
 }
 
+func TestNewCmdServiceMethod_StrictModeHidesAsFlag(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu, SupportedIdentities: 2,
+	})
+
+	cmd := NewCmdServiceMethod(f, driveSpec(), driveMethod("GET", nil), "copy", "files", nil)
+	flag := cmd.Flags().Lookup("as")
+	if flag == nil {
+		t.Fatal("expected --as flag to be registered")
+	}
+	if !flag.Hidden {
+		t.Fatal("expected --as flag to be hidden in strict mode")
+	}
+	if got := flag.DefValue; got != "bot" {
+		t.Fatalf("default value = %q, want %q", got, "bot")
+	}
+}
+
 // ── NewCmdServiceMethod flags ──
 
 func TestNewCmdServiceMethod_GETHasNoDataFlag(t *testing.T) {

extension/transport/errors.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package transport
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ErrAborted is a sentinel matched by errors.Is on any extension-triggered
+// round-trip abort. Callers that only need to know whether an error was
+// caused by an extension interception should use:
+//
+//	if errors.Is(err, transport.ErrAborted) { ... }
+var ErrAborted = errors.New("round trip aborted by extension")
+
+// AbortError is returned by the built-in middleware when an AbortableInterceptor
+// short-circuits a request via PreRoundTripE. It wraps the extension's original
+// reason and carries the extension's Provider.Name() for traceability.
+//
+// Use errors.As to recover the typed error:
+//
+//	var aErr *transport.AbortError
+//	if errors.As(err, &aErr) {
+//	    log.Printf("blocked by %s: %v", aErr.Extension, aErr.Reason)
+//	}
+//
+// errors.Is(err, transport.ErrAborted) also works, and errors.Is against the
+// inner reason still works via Unwrap.
+type AbortError struct {
+	// Extension is the name of the Provider whose interceptor aborted the
+	// request (from Provider.Name()). May be empty if the provider did not
+	// supply a name.
+	Extension string
+	// Reason is the original non-nil error returned by PreRoundTripE.
+	Reason error
+}
+
+func (e *AbortError) Error() string {
+	if e.Extension != "" {
+		return fmt.Sprintf("extension %q aborted round trip: %v", e.Extension, e.Reason)
+	}
+	return fmt.Sprintf("extension aborted round trip: %v", e.Reason)
+}
+
+// Unwrap lets errors.Is / errors.As traverse to the underlying Reason.
+func (e *AbortError) Unwrap() error { return e.Reason }
+
+// Is enables errors.Is(err, ErrAborted) at any nesting depth.
+func (e *AbortError) Is(target error) bool { return target == ErrAborted }

extension/transport/errors_test.go

@@ -0,0 +1,103 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package transport
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestAbortError_Error(t *testing.T) {
+	tests := []struct {
+		name string
+		err  *AbortError
+		want string
+	}{
+		{
+			name: "with extension name",
+			err:  &AbortError{Extension: "audit", Reason: errors.New("bad")},
+			want: `extension "audit" aborted round trip: bad`,
+		},
+		{
+			name: "without extension name",
+			err:  &AbortError{Reason: errors.New("bad")},
+			want: "extension aborted round trip: bad",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.err.Error(); got != tt.want {
+				t.Fatalf("Error() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestAbortError_Unwrap(t *testing.T) {
+	reason := errors.New("bad")
+	e := &AbortError{Reason: reason}
+	if got := e.Unwrap(); got != reason {
+		t.Fatalf("Unwrap() = %v, want %v", got, reason)
+	}
+}
+
+func TestAbortError_IsErrAborted(t *testing.T) {
+	e := &AbortError{Reason: errors.New("bad")}
+	if !errors.Is(e, ErrAborted) {
+		t.Fatal("errors.Is(e, ErrAborted) = false, want true")
+	}
+	// Sanity: not matched by unrelated sentinels.
+	if errors.Is(e, errors.New("other")) {
+		t.Fatal("errors.Is matched unrelated sentinel")
+	}
+}
+
+func TestAbortError_UnwrapReachesInnerSentinel(t *testing.T) {
+	// Extensions often return typed/sentinel errors; callers should still be
+	// able to errors.Is against those after the middleware wraps them.
+	innerSentinel := errors.New("policy-deny-42")
+	e := &AbortError{Reason: fmt.Errorf("wrapped: %w", innerSentinel)}
+	if !errors.Is(e, innerSentinel) {
+		t.Fatal("errors.Is(e, innerSentinel) = false, want true (Unwrap chain broken)")
+	}
+}
+
+func TestAbortError_As(t *testing.T) {
+	reason := errors.New("bad")
+	base := &AbortError{Extension: "audit", Reason: reason}
+
+	// Direct As.
+	var aErr *AbortError
+	if !errors.As(base, &aErr) {
+		t.Fatal("errors.As(base, *AbortError) = false")
+	}
+	if aErr.Extension != "audit" || aErr.Reason != reason {
+		t.Fatalf("aErr = %+v, want {audit, bad}", aErr)
+	}
+
+	// Nested As: even when the *AbortError is wrapped in another error,
+	// errors.As must still find it via Unwrap chain.
+	wrapped := fmt.Errorf("outer: %w", base)
+	var aErr2 *AbortError
+	if !errors.As(wrapped, &aErr2) {
+		t.Fatal("errors.As(wrapped, *AbortError) = false")
+	}
+	if aErr2 != base {
+		t.Fatalf("aErr2 = %p, want %p", aErr2, base)
+	}
+
+	// errors.Is still matches the sentinel through the outer wrapper.
+	if !errors.Is(wrapped, ErrAborted) {
+		t.Fatal("errors.Is(wrapped, ErrAborted) = false via nested wrap")
+	}
+}
+
+func TestErrAborted_IsItselfSentinel(t *testing.T) {
+	// Guard against accidental re-assignment of ErrAborted: a bare ErrAborted
+	// value should still satisfy errors.Is(err, ErrAborted) for symmetry.
+	if !errors.Is(ErrAborted, ErrAborted) {
+		t.Fatal("errors.Is(ErrAborted, ErrAborted) = false")
+	}
+}

extension/transport/types.go

@@ -27,6 +27,31 @@ type Provider interface {
 //
 // The returned function (if non-nil) is called after the built-in chain
 // completes. Use it for logging, ending trace spans, or recording metrics.
+//
+// Body note: the middleware Clones the caller's request before invoking the
+// interceptor, which copies headers/URL/etc. but shares the underlying
+// io.ReadCloser. Extensions that read req.Body are responsible for restoring
+// a replayable body (e.g. via req.GetBody) before returning, otherwise the
+// built-in chain will see an exhausted stream.
 type Interceptor interface {
 	PreRoundTrip(req *http.Request) func(resp *http.Response, err error)
 }
+
+// AbortableInterceptor is an optional extension of Interceptor that lets an
+// extension reject a request before the built-in chain runs. Extensions that
+// implement this interface are detected by the built-in middleware via a
+// type assertion; both methods must be present, but when an extension
+// implements PreRoundTripE the middleware will NOT call PreRoundTrip.
+//
+// Returning a non-nil error from PreRoundTripE aborts the request: the
+// built-in chain is not executed and the middleware returns an *AbortError
+// wrapping the reason. The returned post function (if non-nil) is still
+// invoked with (nil, reason) so that extensions can unwind any state they
+// created in the pre hook (spans, metrics, audit records).
+//
+// Extensions that only care about the abortable variant can provide a no-op
+// PreRoundTrip method alongside PreRoundTripE to satisfy Interceptor.
+type AbortableInterceptor interface {
+	Interceptor
+	PreRoundTripE(req *http.Request) (post func(resp *http.Response, err error), err error)
+}

internal/auth/device_flow.go

@@ -200,7 +200,7 @@ func PollDeviceToken(ctx context.Context, httpClient *http.Client, appId, appSec
 		errStr := getStr(data, "error")
 
 		if errStr == "" && getStr(data, "access_token") != "" {
-			fmt.Fprintf(errOut, "[lark-cli] device-flow: token obtained successfully\n")
+			fmt.Fprintf(errOut, "[lark-cli] device-flow: token response received\n")
 			refreshToken := getStr(data, "refresh_token")
 			tokenExpiresIn := getInt(data, "expires_in", 7200)
 			refreshExpiresIn := getInt(data, "refresh_token_expires_in", 604800)

internal/cmdutil/completion.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"sync/atomic"
+
+	"github.com/spf13/cobra"
+)
+
+// Cobra keeps completion callbacks in a package-global map keyed by
+// *pflag.Flag with no removal path, so registrations made for a *cobra.Command
+// outlive the command itself. Skip registration when the current invocation
+// will not serve a completion request.
+var flagCompletionsDisabled atomic.Bool
+
+// SetFlagCompletionsDisabled switches RegisterFlagCompletion between
+// registering and no-op. Typically set once at process start.
+func SetFlagCompletionsDisabled(disabled bool) {
+	flagCompletionsDisabled.Store(disabled)
+}
+
+// FlagCompletionsDisabled reports the current switch state.
+func FlagCompletionsDisabled() bool {
+	return flagCompletionsDisabled.Load()
+}
+
+// RegisterFlagCompletion wraps (*cobra.Command).RegisterFlagCompletionFunc
+// and honors the package switch. The underlying error is swallowed to match
+// the `_ = cmd.RegisterFlagCompletionFunc(...)` style already used here.
+func RegisterFlagCompletion(cmd *cobra.Command, flagName string, fn cobra.CompletionFunc) {
+	if flagCompletionsDisabled.Load() {
+		return
+	}
+	_ = cmd.RegisterFlagCompletionFunc(flagName, fn)
+}

internal/cmdutil/completion_test.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"runtime"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+func TestSetFlagCompletionsDisabled_RoundTrip(t *testing.T) {
+	t.Cleanup(func() { SetFlagCompletionsDisabled(false) })
+
+	if FlagCompletionsDisabled() {
+		t.Fatal("expected default false")
+	}
+	SetFlagCompletionsDisabled(true)
+	if !FlagCompletionsDisabled() {
+		t.Fatal("expected true after Set(true)")
+	}
+	SetFlagCompletionsDisabled(false)
+	if FlagCompletionsDisabled() {
+		t.Fatal("expected false after Set(false)")
+	}
+}
+
+// When disabled, a *cobra.Command must be collectable after the caller drops
+// its reference — i.e. the wrapper did not touch cobra's global map.
+func TestRegisterFlagCompletion_Disabled_DoesNotRetainCommand(t *testing.T) {
+	SetFlagCompletionsDisabled(true)
+	t.Cleanup(func() { SetFlagCompletionsDisabled(false) })
+
+	const N = 5
+	var collected atomic.Int32
+	func() {
+		for range N {
+			cmd := &cobra.Command{Use: "x"}
+			cmd.Flags().String("foo", "", "")
+			RegisterFlagCompletion(cmd, "foo", func(_ *cobra.Command, _ []string, _ string) ([]cobra.Completion, cobra.ShellCompDirective) {
+				return nil, cobra.ShellCompDirectiveNoFileComp
+			})
+			runtime.SetFinalizer(cmd, func(_ *cobra.Command) { collected.Add(1) })
+		}
+	}()
+	// Finalizers run on a dedicated goroutine after GC; loop to give it time.
+	for range 30 {
+		runtime.GC()
+		time.Sleep(20 * time.Millisecond)
+	}
+	if got := collected.Load(); int(got) != N {
+		t.Fatalf("expected %d *cobra.Command finalizers to fire when completions disabled, got %d", N, got)
+	}
+}
+
+// When enabled, the registered completion must be reachable via cobra.
+func TestRegisterFlagCompletion_Enabled_DoesRegister(t *testing.T) {
+	SetFlagCompletionsDisabled(false)
+
+	cmd := &cobra.Command{Use: "x"}
+	cmd.Flags().String("foo", "", "")
+	want := []cobra.Completion{"a", "b"}
+	RegisterFlagCompletion(cmd, "foo", func(_ *cobra.Command, _ []string, _ string) ([]cobra.Completion, cobra.ShellCompDirective) {
+		return want, cobra.ShellCompDirectiveNoFileComp
+	})
+
+	fn, ok := cmd.GetFlagCompletionFunc("foo")
+	if !ok {
+		t.Fatal("expected completion func to be registered")
+	}
+	got, _ := fn(cmd, nil, "")
+	if len(got) != 2 || got[0] != "a" || got[1] != "b" {
+		t.Fatalf("unexpected completion result: %v", got)
+	}
+}

internal/cmdutil/factory_default.go

@@ -8,13 +8,11 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"sync"
 	"time"
 
 	lark "github.com/larksuite/oapi-sdk-go/v3"
 	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
-	"golang.org/x/term"
 
 	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/extension/fileio"
@@ -34,27 +32,24 @@ import (
 //	Phase 2: Credential (sole data source for account info)
 //	Phase 3: Config derived from Credential
 //	Phase 4: LarkClient derived from Credential
-func NewDefault(inv InvocationContext) *Factory {
+func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
+	streams = normalizeStreams(streams)
 	f := &Factory{
 		Keychain:   keychain.Default(),
 		Invocation: inv,
-	}
-	f.IOStreams = &IOStreams{
-		In:         os.Stdin,
-		Out:        os.Stdout,
-		ErrOut:     os.Stderr,
-		IsTerminal: term.IsTerminal(int(os.Stdin.Fd())),
+		IOStreams:  streams,
 	}
 
 	// Phase 0: FileIO provider (no dependency)
 	f.FileIOProvider = fileio.GetProvider()
 
 	// Phase 1: HttpClient (no credential dependency)
-	f.HttpClient = cachedHttpClientFunc()
+	f.HttpClient = cachedHttpClientFunc(f)
 
 	// Phase 2: Credential (sole data source)
+	// Keychain is read via closure so callers can replace f.Keychain after construction.
 	f.Credential = buildCredentialProvider(credentialDeps{
-		Keychain:   f.Keychain,
+		Keychain:   func() keychain.KeychainAccess { return f.Keychain },
 		Profile:    inv.Profile,
 		HttpClient: f.HttpClient,
 		ErrOut:     f.IOStreams.ErrOut,
@@ -93,11 +88,11 @@ func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 	return nil
 }
 
-func cachedHttpClientFunc() func() (*http.Client, error) {
+func cachedHttpClientFunc(f *Factory) func() (*http.Client, error) {
 	return sync.OnceValues(func() (*http.Client, error) {
-		util.WarnIfProxied(os.Stderr)
+		util.WarnIfProxied(f.IOStreams.ErrOut)
 
-		var transport http.RoundTripper = util.NewBaseTransport()
+		var transport http.RoundTripper = util.SharedTransport()
 		transport = &RetryTransport{Base: transport}
 		transport = &SecurityHeaderTransport{Base: transport}
 		transport = &auth.SecurityPolicyTransport{Base: transport} // Add our global response interceptor
@@ -122,7 +117,7 @@ func cachedLarkClientFunc(f *Factory) func() (*lark.Client, error) {
 			lark.WithLogLevel(larkcore.LogLevelError),
 			lark.WithHeaders(BaseSecurityHeaders()),
 		}
-		util.WarnIfProxied(os.Stderr)
+		util.WarnIfProxied(f.IOStreams.ErrOut)
 		opts = append(opts, lark.WithHttpClient(&http.Client{
 			Transport:     buildSDKTransport(),
 			CheckRedirect: safeRedirectPolicy,
@@ -134,15 +129,16 @@ func cachedLarkClientFunc(f *Factory) func() (*lark.Client, error) {
 }
 
 func buildSDKTransport() http.RoundTripper {
-	var sdkTransport http.RoundTripper = util.NewBaseTransport()
+	var sdkTransport http.RoundTripper = util.SharedTransport()
 	sdkTransport = &RetryTransport{Base: sdkTransport}
 	sdkTransport = &UserAgentTransport{Base: sdkTransport}
+	sdkTransport = &BuildHeaderTransport{Base: sdkTransport}
 	sdkTransport = &auth.SecurityPolicyTransport{Base: sdkTransport}
 	return wrapWithExtension(sdkTransport)
 }
 
 type credentialDeps struct {
-	Keychain   keychain.KeychainAccess
+	Keychain   func() keychain.KeychainAccess
 	Profile    string
 	HttpClient func() (*http.Client, error)
 	ErrOut     io.Writer

internal/cmdutil/factory_default_test.go

@@ -6,14 +6,10 @@ package cmdutil
 import (
 	"context"
 	"errors"
-	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	_ "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/extension/fileio"
-	exttransport "github.com/larksuite/cli/extension/transport"
-	internalauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/envvars"
@@ -63,7 +59,7 @@ func TestNewDefault_InvocationProfileUsedByStrictModeAndConfig(t *testing.T) {
 		t.Fatalf("SaveMultiAppConfig() error = %v", err)
 	}
 
-	f := NewDefault(InvocationContext{Profile: "target"})
+	f := NewDefault(nil, InvocationContext{Profile: "target"})
 	if got := f.ResolveStrictMode(context.Background()); got != core.StrictModeBot {
 		t.Fatalf("ResolveStrictMode() = %q, want %q", got, core.StrictModeBot)
 	}
@@ -103,7 +99,7 @@ func TestNewDefault_InvocationProfileMissingSticksAcrossEarlyStrictMode(t *testi
 		t.Fatalf("SaveMultiAppConfig() error = %v", err)
 	}
 
-	f := NewDefault(InvocationContext{Profile: "missing"})
+	f := NewDefault(nil, InvocationContext{Profile: "missing"})
 	if got := f.ResolveStrictMode(context.Background()); got != core.StrictModeOff {
 		t.Fatalf("ResolveStrictMode() = %q, want %q", got, core.StrictModeOff)
 	}
@@ -120,22 +116,6 @@ func TestNewDefault_InvocationProfileMissingSticksAcrossEarlyStrictMode(t *testi
 	}
 }
 
-func TestBuildSDKTransport_IncludesRetryTransport(t *testing.T) {
-	transport := buildSDKTransport()
-
-	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
-	if !ok {
-		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
-	}
-	ua, ok := sec.Base.(*UserAgentTransport)
-	if !ok {
-		t.Fatalf("middle transport type = %T, want *UserAgentTransport", sec.Base)
-	}
-	if _, ok := ua.Base.(*RetryTransport); !ok {
-		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
-	}
-}
-
 func TestNewDefault_ResolveAs_UsesDefaultAsFromEnvAccount(t *testing.T) {
 	t.Setenv(envvars.CliAppID, "env-app")
 	t.Setenv(envvars.CliAppSecret, "env-secret")
@@ -144,7 +124,7 @@ func TestNewDefault_ResolveAs_UsesDefaultAsFromEnvAccount(t *testing.T) {
 	t.Setenv(envvars.CliTenantAccessToken, "")
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 
-	f := NewDefault(InvocationContext{})
+	f := NewDefault(nil, InvocationContext{})
 	cmd := newCmdWithAsFlag("auto", false)
 
 	got := f.ResolveAs(context.Background(), cmd, "auto")
@@ -164,7 +144,7 @@ func TestNewDefault_ConfigReturnsCliConfigCopyOfCredentialAccount(t *testing.T)
 	t.Setenv(envvars.CliTenantAccessToken, "")
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 
-	f := NewDefault(InvocationContext{})
+	f := NewDefault(nil, InvocationContext{})
 
 	acct, err := f.Credential.ResolveAccount(context.Background())
 	if err != nil {
@@ -189,7 +169,7 @@ func TestNewDefault_ConfigUsesRuntimePlaceholderForTokenOnlyEnvAccount(t *testin
 	t.Setenv(envvars.CliTenantAccessToken, "")
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 
-	f := NewDefault(InvocationContext{})
+	f := NewDefault(nil, InvocationContext{})
 
 	acct, err := f.Credential.ResolveAccount(context.Background())
 	if err != nil {
@@ -217,7 +197,7 @@ func TestNewDefault_FileIOProviderDoesNotResolveDuringInitialization(t *testing.
 	fileio.Register(provider)
 	t.Cleanup(func() { fileio.Register(prev) })
 
-	f := NewDefault(InvocationContext{})
+	f := NewDefault(nil, InvocationContext{})
 	if f.FileIOProvider != provider {
 		t.Fatalf("NewDefault() provider = %T, want %T", f.FileIOProvider, provider)
 	}
@@ -232,170 +212,3 @@ func TestNewDefault_FileIOProviderDoesNotResolveDuringInitialization(t *testing.
 		t.Fatalf("ResolveFileIO() calls after explicit resolve = %d, want 1", provider.resolveCalls)
 	}
 }
-
-type stubTransportProvider struct {
-	interceptor exttransport.Interceptor
-}
-
-func (s *stubTransportProvider) Name() string { return "stub" }
-func (s *stubTransportProvider) ResolveInterceptor(context.Context) exttransport.Interceptor {
-	if s.interceptor != nil {
-		return s.interceptor
-	}
-	return &stubTransportImpl{}
-}
-
-type stubTransportImpl struct{}
-
-func (s *stubTransportImpl) PreRoundTrip(req *http.Request) func(*http.Response, error) {
-	return nil
-}
-
-// headerCapturingInterceptor sets custom headers in PreRoundTrip and records
-// whether PostRoundTrip was called, to verify execution order.
-type headerCapturingInterceptor struct {
-	preCalled  bool
-	postCalled bool
-}
-
-func (h *headerCapturingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
-	h.preCalled = true
-	// Set a custom header that should survive (no built-in override)
-	req.Header.Set("X-Custom-Trace", "ext-trace-123")
-	// Try to override a security header — should be overwritten by SecurityHeaderTransport
-	req.Header.Set(HeaderSource, "ext-tampered")
-	return func(resp *http.Response, err error) {
-		h.postCalled = true
-	}
-}
-
-func TestExtensionInterceptor_ExecutionOrder(t *testing.T) {
-	var receivedHeaders http.Header
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		receivedHeaders = r.Header.Clone()
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer srv.Close()
-
-	ic := &headerCapturingInterceptor{}
-	exttransport.Register(&stubTransportProvider{interceptor: ic})
-	t.Cleanup(func() { exttransport.Register(nil) })
-
-	// Use HTTP transport chain (has SecurityHeaderTransport)
-	var base http.RoundTripper = http.DefaultTransport
-	base = &RetryTransport{Base: base}
-	base = &SecurityHeaderTransport{Base: base}
-	transport := wrapWithExtension(base)
-	client := &http.Client{Transport: transport}
-
-	req, _ := http.NewRequest("GET", srv.URL, nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatalf("request failed: %v", err)
-	}
-	resp.Body.Close()
-
-	// PreRoundTrip was called
-	if !ic.preCalled {
-		t.Fatal("PreRoundTrip was not called")
-	}
-	// PostRoundTrip (closure) was called
-	if !ic.postCalled {
-		t.Fatal("PostRoundTrip closure was not called")
-	}
-	// Custom header set by extension survives (no built-in override)
-	if got := receivedHeaders.Get("X-Custom-Trace"); got != "ext-trace-123" {
-		t.Fatalf("X-Custom-Trace = %q, want %q", got, "ext-trace-123")
-	}
-	// Security header overridden by extension is restored by SecurityHeaderTransport
-	if got := receivedHeaders.Get(HeaderSource); got != SourceValue {
-		t.Fatalf("%s = %q, want %q (built-in should override extension)", HeaderSource, got, SourceValue)
-	}
-}
-
-func TestExtensionInterceptor_ContextTamperPrevented(t *testing.T) {
-	type ctxKeyType string
-	const testKey ctxKeyType = "original"
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer srv.Close()
-
-	var ctxValue any
-
-	// Use a custom transport that captures the context value seen by the built-in chain
-	capturer := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		ctxValue = req.Context().Value(testKey)
-		return http.DefaultTransport.RoundTrip(req)
-	})
-
-	// Interceptor that tries to tamper with context
-	tamperIC := interceptorFunc(func(req *http.Request) func(*http.Response, error) {
-		// Try to replace context with a new one
-		*req = *req.WithContext(context.WithValue(req.Context(), testKey, "tampered"))
-		return nil
-	})
-
-	mid := &extensionMiddleware{Base: capturer, Ext: tamperIC}
-
-	origCtx := context.WithValue(context.Background(), testKey, "original")
-	req, _ := http.NewRequestWithContext(origCtx, "GET", srv.URL, nil)
-	resp, err := mid.RoundTrip(req)
-	if err != nil {
-		t.Fatalf("request failed: %v", err)
-	}
-	resp.Body.Close()
-
-	// Built-in chain should see original context, not tampered
-	if ctxValue != "original" {
-		t.Fatalf("built-in chain saw context value %q, want %q", ctxValue, "original")
-	}
-}
-
-// interceptorFunc adapts a function to exttransport.Interceptor.
-type interceptorFunc func(*http.Request) func(*http.Response, error)
-
-func (f interceptorFunc) PreRoundTrip(req *http.Request) func(*http.Response, error) { return f(req) }
-
-func TestBuildSDKTransport_WithExtension(t *testing.T) {
-	exttransport.Register(&stubTransportProvider{})
-	t.Cleanup(func() { exttransport.Register(nil) })
-
-	transport := buildSDKTransport()
-
-	// Chain: extensionMiddleware → SecurityPolicy → UserAgent → Retry → Base
-	mid, ok := transport.(*extensionMiddleware)
-	if !ok {
-		t.Fatalf("outer transport type = %T, want *extensionMiddleware", transport)
-	}
-	sec, ok := mid.Base.(*internalauth.SecurityPolicyTransport)
-	if !ok {
-		t.Fatalf("transport type = %T, want *auth.SecurityPolicyTransport", mid.Base)
-	}
-	ua, ok := sec.Base.(*UserAgentTransport)
-	if !ok {
-		t.Fatalf("transport type = %T, want *UserAgentTransport", sec.Base)
-	}
-	if _, ok := ua.Base.(*RetryTransport); !ok {
-		t.Fatalf("innermost transport type = %T, want *RetryTransport", ua.Base)
-	}
-}
-
-func TestBuildSDKTransport_WithoutExtension(t *testing.T) {
-	exttransport.Register(nil)
-
-	transport := buildSDKTransport()
-
-	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
-	if !ok {
-		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
-	}
-	ua, ok := sec.Base.(*UserAgentTransport)
-	if !ok {
-		t.Fatalf("middle transport type = %T, want *UserAgentTransport", sec.Base)
-	}
-	if _, ok := ua.Base.(*RetryTransport); !ok {
-		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
-	}
-}

internal/cmdutil/factory_http_test.go

@@ -4,11 +4,12 @@
 package cmdutil
 
 import (
+	"io"
 	"testing"
 )
 
 func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
-	fn := cachedHttpClientFunc()
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 
 	c1, err := fn()
 	if err != nil {
@@ -28,7 +29,7 @@ func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
 }
 
 func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
-	fn := cachedHttpClientFunc()
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.Timeout == 0 {
 		t.Error("expected non-zero timeout")
@@ -36,7 +37,7 @@ func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
 }
 
 func TestCachedHttpClientFunc_HasRedirectPolicy(t *testing.T) {
-	fn := cachedHttpClientFunc()
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.CheckRedirect == nil {
 		t.Error("expected CheckRedirect to be set (safeRedirectPolicy)")

internal/cmdutil/identity_flag.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// AddAPIIdentityFlag registers the standard --as flag shape used by api/service commands.
+func AddAPIIdentityFlag(ctx context.Context, cmd *cobra.Command, f *Factory, target *string) {
+	addIdentityFlag(ctx, cmd, f, target, identityFlagConfig{
+		defaultValue:     "auto",
+		usage:            "identity type: user | bot | auto (default)",
+		completionValues: []string{"user", "bot"},
+	})
+}
+
+// AddShortcutIdentityFlag registers the standard --as flag shape used by shortcuts.
+func AddShortcutIdentityFlag(ctx context.Context, cmd *cobra.Command, f *Factory, authTypes []string) {
+	if len(authTypes) == 0 {
+		authTypes = []string{"user"}
+	}
+	addIdentityFlag(ctx, cmd, f, nil, identityFlagConfig{
+		defaultValue:     authTypes[0],
+		usage:            "identity type: " + strings.Join(authTypes, " | "),
+		completionValues: authTypes,
+	})
+}
+
+type identityFlagConfig struct {
+	defaultValue     string
+	usage            string
+	completionValues []string
+}
+
+// addIdentityFlag centralizes --as registration and strict-mode UX.
+// When strict mode is active, the flag is still accepted for compatibility
+// but hidden from help/completion and locked to the forced identity by default.
+func addIdentityFlag(ctx context.Context, cmd *cobra.Command, f *Factory, target *string, cfg identityFlagConfig) {
+	if forced := f.ResolveStrictMode(ctx).ForcedIdentity(); forced != "" {
+		// Keep registering --as in strict mode even though it is hidden.
+		// This preserves parser compatibility for existing invocations that still pass
+		// --as, and keeps downstream GetString("as") / ResolveAs paths stable.
+		// The usage text below is effectively placeholder text because the flag is hidden.
+		registerIdentityFlag(cmd, target, string(forced),
+			fmt.Sprintf("identity locked to %s by strict mode (admin-managed)", forced))
+		_ = cmd.Flags().MarkHidden("as")
+		return
+	}
+
+	registerIdentityFlag(cmd, target, cfg.defaultValue, cfg.usage)
+	RegisterFlagCompletion(cmd, "as", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+		return cfg.completionValues, cobra.ShellCompDirectiveNoFileComp
+	})
+}
+
+func registerIdentityFlag(cmd *cobra.Command, target *string, defaultValue, usage string) {
+	if target != nil {
+		cmd.Flags().StringVar(target, "as", defaultValue, usage)
+		return
+	}
+	cmd.Flags().String("as", defaultValue, usage)
+}

internal/cmdutil/identity_flag_test.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"context"
+	"testing"
+
+	"github.com/larksuite/cli/internal/core"
+	"github.com/spf13/cobra"
+)
+
+func TestAddAPIIdentityFlag_NonStrictMode(t *testing.T) {
+	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "a", AppSecret: "s"})
+	cmd := &cobra.Command{Use: "test"}
+
+	AddAPIIdentityFlag(context.Background(), cmd, f, nil)
+
+	flag := cmd.Flags().Lookup("as")
+	if flag == nil {
+		t.Fatal("expected --as flag to be registered")
+	}
+	if flag.Hidden {
+		t.Fatal("expected --as flag to be visible outside strict mode")
+	}
+	if got := flag.DefValue; got != "auto" {
+		t.Fatalf("default value = %q, want %q", got, "auto")
+	}
+}
+
+func TestAddAPIIdentityFlag_StrictModeHidesFlagAndLocksDefault(t *testing.T) {
+	f, _, _, _ := TestFactory(t, &core.CliConfig{
+		AppID: "a", AppSecret: "s", SupportedIdentities: 2,
+	})
+	cmd := &cobra.Command{Use: "test"}
+
+	AddAPIIdentityFlag(context.Background(), cmd, f, nil)
+
+	flag := cmd.Flags().Lookup("as")
+	if flag == nil {
+		t.Fatal("expected --as flag to be registered")
+	}
+	if !flag.Hidden {
+		t.Fatal("expected --as flag to be hidden in strict mode")
+	}
+	if got := flag.DefValue; got != "bot" {
+		t.Fatalf("default value = %q, want %q", got, "bot")
+	}
+}
+
+func TestAddShortcutIdentityFlag_UsesAuthTypes(t *testing.T) {
+	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "a", AppSecret: "s"})
+	cmd := &cobra.Command{Use: "test"}
+
+	AddShortcutIdentityFlag(context.Background(), cmd, f, []string{"bot"})
+
+	flag := cmd.Flags().Lookup("as")
+	if flag == nil {
+		t.Fatal("expected --as flag to be registered")
+	}
+	if flag.Hidden {
+		t.Fatal("expected --as flag to be visible outside strict mode")
+	}
+	if got := flag.DefValue; got != "bot" {
+		t.Fatalf("default value = %q, want %q", got, "bot")
+	}
+}

internal/cmdutil/iostreams.go

@@ -3,7 +3,12 @@
 
 package cmdutil
 
-import "io"
+import (
+	"io"
+	"os"
+
+	"golang.org/x/term"
+)
 
 // IOStreams provides the standard input/output/error streams.
 // Commands should use these instead of os.Stdin/Stdout/Stderr
@@ -14,3 +19,45 @@ type IOStreams struct {
 	ErrOut     io.Writer
 	IsTerminal bool
 }
+
+// NewIOStreams builds an IOStreams from arbitrary readers/writers.
+// IsTerminal is derived from in's underlying *os.File, if any; non-file
+// readers (bytes.Buffer, strings.Reader, …) yield IsTerminal=false.
+func NewIOStreams(in io.Reader, out, errOut io.Writer) *IOStreams {
+	isTerminal := false
+	if f, ok := in.(*os.File); ok {
+		isTerminal = term.IsTerminal(int(f.Fd()))
+	}
+	return &IOStreams{In: in, Out: out, ErrOut: errOut, IsTerminal: isTerminal}
+}
+
+// SystemIO creates an IOStreams wired to the process's standard file descriptors.
+//
+//nolint:forbidigo // entry point for real stdio
+func SystemIO() *IOStreams {
+	return NewIOStreams(os.Stdin, os.Stdout, os.Stderr)
+}
+
+// normalizeStreams returns a fresh IOStreams with any nil field filled from
+// SystemIO(). Callers constructing a partial struct like &IOStreams{Out: buf}
+// get a usable result without nil writers leaking into RoundTripper warnings,
+// Cobra I/O, or credential-provider error paths.
+func normalizeStreams(s *IOStreams) *IOStreams {
+	if s == nil {
+		return SystemIO()
+	}
+	out := *s
+	if out.In == nil || out.Out == nil || out.ErrOut == nil {
+		sys := SystemIO()
+		if out.In == nil {
+			out.In = sys.In
+		}
+		if out.Out == nil {
+			out.Out = sys.Out
+		}
+		if out.ErrOut == nil {
+			out.ErrOut = sys.ErrOut
+		}
+	}
+	return &out
+}

internal/cmdutil/retry_transport_test.go

@@ -1,81 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-)
-
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return f(req)
-}
-
-func TestRetryTransport_NoRetry(t *testing.T) {
-	calls := 0
-	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		calls++
-		return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader("ok"))}, nil
-	})
-	rt := &RetryTransport{Base: base, MaxRetries: 0}
-	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
-	resp, err := rt.RoundTrip(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if resp.StatusCode != 200 {
-		t.Errorf("expected 200, got %d", resp.StatusCode)
-	}
-	if calls != 1 {
-		t.Errorf("expected 1 call, got %d", calls)
-	}
-}
-
-func TestRetryTransport_RetryOn500(t *testing.T) {
-	calls := 0
-	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		calls++
-		if calls < 3 {
-			return &http.Response{StatusCode: 500, Body: io.NopCloser(strings.NewReader("error"))}, nil
-		}
-		return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader("ok"))}, nil
-	})
-	rt := &RetryTransport{Base: base, MaxRetries: 3, Delay: 1 * time.Millisecond}
-	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
-	resp, err := rt.RoundTrip(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if resp.StatusCode != 200 {
-		t.Errorf("expected 200 after retries, got %d", resp.StatusCode)
-	}
-	if calls != 3 {
-		t.Errorf("expected 3 calls, got %d", calls)
-	}
-}
-
-func TestRetryTransport_DefaultNoRetry(t *testing.T) {
-	calls := 0
-	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		calls++
-		return &http.Response{StatusCode: 500, Body: io.NopCloser(strings.NewReader("error"))}, nil
-	})
-	rt := &RetryTransport{Base: base} // default MaxRetries=0
-	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
-	resp, err := rt.RoundTrip(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if resp.StatusCode != 500 {
-		t.Errorf("expected 500 with no retries, got %d", resp.StatusCode)
-	}
-	if calls != 1 {
-		t.Errorf("expected 1 call with default config, got %d", calls)
-	}
-}

internal/cmdutil/secheader.go

@@ -6,7 +6,14 @@ package cmdutil
 import (
 	"context"
 	"net/http"
+	"reflect"
+	"runtime/debug"
+	"strings"
+	"sync"
 
+	"github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/extension/fileio"
+	exttransport "github.com/larksuite/cli/extension/transport"
 	"github.com/larksuite/cli/internal/build"
 	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
 )
@@ -14,12 +21,21 @@ import (
 const (
 	HeaderSource      = "X-Cli-Source"
 	HeaderVersion     = "X-Cli-Version"
+	HeaderBuild       = "X-Cli-Build"
 	HeaderShortcut    = "X-Cli-Shortcut"
 	HeaderExecutionId = "X-Cli-Execution-Id"
 
 	SourceValue = "lark-cli"
 
 	HeaderUserAgent = "User-Agent"
+
+	// BuildKindOfficial / BuildKindExtended / BuildKindUnknown are the values
+	// reported in the X-Cli-Build header; see DetectBuildKind for semantics.
+	BuildKindOfficial = "official"
+	BuildKindExtended = "extended"
+	BuildKindUnknown  = "unknown"
+
+	officialModulePath = "github.com/larksuite/cli"
 )
 
 // UserAgentValue returns the User-Agent value: "lark-cli/{version}".
@@ -32,10 +48,108 @@ func BaseSecurityHeaders() http.Header {
 	h := make(http.Header)
 	h.Set(HeaderSource, SourceValue)
 	h.Set(HeaderVersion, build.Version)
+	h.Set(HeaderBuild, DetectBuildKind())
 	h.Set(HeaderUserAgent, UserAgentValue())
 	return h
 }
 
+var (
+	buildKindOnce sync.Once
+	buildKindVal  string
+)
+
+// DetectBuildKind reports whether this binary is the official CLI, an
+// extended/repackaged build, or unknown. The result is cached via sync.Once
+// so it is computed only on the first call.
+//
+// IMPORTANT: must NOT be called from any package init(). Go's init ordering
+// follows the import graph; ISV providers registered via blank import may not
+// have run yet, which would misclassify an extended build as official. Call
+// only when handling an actual request (e.g. from BaseSecurityHeaders).
+func DetectBuildKind() string {
+	buildKindOnce.Do(func() {
+		buildKindVal = computeBuildKind()
+	})
+	return buildKindVal
+}
+
+// computeBuildKind performs the actual detection without any caching.
+// Exposed for tests. Gathers runtime/global inputs and delegates the pure
+// branching logic to classifyBuild so that logic can be unit-tested without
+// mutating process-wide provider registries.
+func computeBuildKind() string {
+	info, ok := debug.ReadBuildInfo()
+	mainPath := ""
+	if ok {
+		mainPath = info.Main.Path
+	}
+
+	credProviders := credential.Providers()
+	creds := make([]any, len(credProviders))
+	for i, p := range credProviders {
+		creds[i] = p
+	}
+
+	var tp any
+	if p := exttransport.GetProvider(); p != nil {
+		tp = p
+	}
+	var fp any
+	if p := fileio.GetProvider(); p != nil {
+		fp = p
+	}
+	return classifyBuild(mainPath, ok, creds, tp, fp)
+}
+
+// classifyBuild is the pure classification logic used by computeBuildKind.
+// Callers supply concrete values so every branch is reachable from tests
+// without touching debug.ReadBuildInfo or the extension registries.
+//
+// Priority order mirrors the design doc:
+//  1. no build info → unknown
+//  2. main module path not the official one → extended (ISV wrapper)
+//  3. any non-builtin provider (credential / transport / fileio) → extended
+//  4. otherwise → official
+func classifyBuild(mainPath string, haveBuildInfo bool, credProviders []any, transportProvider, fileioProvider any) string {
+	if !haveBuildInfo {
+		return BuildKindUnknown
+	}
+	if mainPath != "" && mainPath != officialModulePath {
+		return BuildKindExtended
+	}
+	for _, p := range credProviders {
+		if !isBuiltinProvider(p) {
+			return BuildKindExtended
+		}
+	}
+	if transportProvider != nil && !isBuiltinProvider(transportProvider) {
+		return BuildKindExtended
+	}
+	if fileioProvider != nil && !isBuiltinProvider(fileioProvider) {
+		return BuildKindExtended
+	}
+	return BuildKindOfficial
+}
+
+// isBuiltinProvider reports whether p is declared under the official module
+// path. Third-party providers live under their own module and fail this check.
+// Using reflect.PkgPath makes this robust against Name() spoofing since
+// package paths are fixed at compile time.
+func isBuiltinProvider(p any) bool {
+	if p == nil {
+		return false
+	}
+	t := reflect.TypeOf(p)
+	if t == nil {
+		return false
+	}
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	pkg := t.PkgPath()
+	return pkg == officialModulePath || strings.HasPrefix(pkg, officialModulePath+"/")
+}
+
 // ── Context utilities ──
 
 type ctxKey string

internal/cmdutil/secheader_sidecar_test.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build authsidecar
+
+package cmdutil
+
+import (
+	"testing"
+
+	sidecarcred "github.com/larksuite/cli/extension/credential/sidecar"
+	sidecartrans "github.com/larksuite/cli/extension/transport/sidecar"
+)
+
+// TestIsBuiltinProvider_SidecarProviders locks the classification for the
+// sidecar-mode providers enumerated in design doc §3.3.2 as "官方自带". These
+// types only compile when the `authsidecar` build tag is active, so the test
+// is guarded by the same tag.
+func TestIsBuiltinProvider_SidecarProviders(t *testing.T) {
+	cases := []struct {
+		name     string
+		provider any
+	}{
+		{"sidecar credential provider", &sidecarcred.Provider{}},
+		{"sidecar transport provider", &sidecartrans.Provider{}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if !isBuiltinProvider(tc.provider) {
+				t.Fatalf("%T must be classified as builtin (PkgPath under %s)", tc.provider, officialModulePath)
+			}
+		})
+	}
+}

internal/cmdutil/secheader_test.go

@@ -0,0 +1,262 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/larksuite/cli/extension/credential"
+	envcred "github.com/larksuite/cli/extension/credential/env"
+	"github.com/larksuite/cli/internal/vfs/localfileio"
+)
+
+// ---------------------------------------------------------------------------
+// isBuiltinProvider
+// ---------------------------------------------------------------------------
+
+// cmdutilLocalProvider has PkgPath under the official module
+// ("github.com/larksuite/cli/internal/cmdutil") and should be classified
+// as builtin.
+type cmdutilLocalProvider struct{}
+
+// Name intentionally returns a value that mimics an external provider; the
+// PkgPath-based classifier must ignore it. See TestIsBuiltinProvider_PkgPathNotSpoofableByName.
+func (cmdutilLocalProvider) Name() string { return "external-spoofed-provider" }
+func (cmdutilLocalProvider) ResolveAccount(context.Context) (*credential.Account, error) {
+	return nil, nil
+}
+func (cmdutilLocalProvider) ResolveToken(context.Context, credential.TokenSpec) (*credential.Token, error) {
+	return nil, nil
+}
+
+func TestIsBuiltinProvider_Nil(t *testing.T) {
+	if isBuiltinProvider(nil) {
+		t.Fatal("isBuiltinProvider(nil) = true, want false")
+	}
+}
+
+func TestIsBuiltinProvider_TypeUnderOfficialModule(t *testing.T) {
+	if !isBuiltinProvider(&cmdutilLocalProvider{}) {
+		t.Fatal("type under github.com/larksuite/cli/... should be builtin")
+	}
+}
+
+func TestIsBuiltinProvider_StdlibTypeIsNotBuiltin(t *testing.T) {
+	// A standard library type has PkgPath "net/http" — outside official module.
+	// This covers the non-builtin branch, which we cannot trigger from inside
+	// this test file using a locally-defined type.
+	if isBuiltinProvider(&http.Server{}) {
+		t.Fatal("stdlib type classified as builtin, PkgPath check is broken")
+	}
+}
+
+func TestIsBuiltinProvider_PkgPathNotSpoofableByName(t *testing.T) {
+	// Name() returns a string, but classification uses reflect.Type.PkgPath
+	// which is compile-time fixed. The local type returns a name that looks
+	// like an ISV provider; it must still classify as builtin.
+	p := &cmdutilLocalProvider{}
+	if p.Name() != "external-spoofed-provider" {
+		t.Fatalf("sanity check: Name() = %q, spoof value lost", p.Name())
+	}
+	if !isBuiltinProvider(p) {
+		t.Fatal("isBuiltinProvider should decide by PkgPath, not Name()")
+	}
+}
+
+// TestIsBuiltinProvider_NonPointerValues covers the non-pointer reflect branch.
+// The existing tests only exercise pointer receivers (&T{}); when a provider
+// is passed by value the reflect.Kind is not Ptr and t.Elem() is skipped.
+func TestIsBuiltinProvider_NonPointerValues(t *testing.T) {
+	if !isBuiltinProvider(cmdutilLocalProvider{}) {
+		t.Fatal("non-pointer local type should be builtin (PkgPath still under official module)")
+	}
+	// http.Server as a non-pointer — PkgPath "net/http", not under official.
+	if isBuiltinProvider(http.Server{}) {
+		t.Fatal("non-pointer stdlib type should not be builtin")
+	}
+}
+
+// TestIsBuiltinProvider_RealBuiltinProviders locks down the classification
+// for the concrete providers enumerated in design doc §3.3.2 as "官方自带":
+// env credential provider and local fileio provider. If any of these is
+// moved out of the official module tree in the future, this test must flip
+// red so the new package path is explicitly considered.
+//
+// The sidecar providers (extension/credential/sidecar and
+// extension/transport/sidecar) are guarded by the `authsidecar` build tag
+// and covered in secheader_sidecar_test.go under that tag.
+func TestIsBuiltinProvider_RealBuiltinProviders(t *testing.T) {
+	cases := []struct {
+		name     string
+		provider any
+	}{
+		{"env credential provider", &envcred.Provider{}},
+		{"local fileio provider", &localfileio.Provider{}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if !isBuiltinProvider(tc.provider) {
+				t.Fatalf("%T must be classified as builtin (PkgPath under %s)", tc.provider, officialModulePath)
+			}
+		})
+	}
+}
+
+// ---------------------------------------------------------------------------
+// computeBuildKind
+// ---------------------------------------------------------------------------
+
+func TestComputeBuildKind_ReturnsKnownValue(t *testing.T) {
+	// Under `go test`, Main.Path is typically the module being tested
+	// ("github.com/larksuite/cli"); the concrete return may still be
+	// official, extended, or unknown depending on Main.Path and the
+	// registered providers. Just assert it's one of the defined values.
+	got := computeBuildKind()
+	switch got {
+	case BuildKindOfficial, BuildKindExtended, BuildKindUnknown:
+	default:
+		t.Fatalf("computeBuildKind() = %q, want one of official/extended/unknown", got)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// classifyBuild — pure branching logic
+// ---------------------------------------------------------------------------
+//
+// These tests cover every branch of classifyBuild with explicit inputs,
+// which is impossible from computeBuildKind alone because debug.ReadBuildInfo
+// and the process-wide provider registries can't be reshaped in a test.
+
+func TestClassifyBuild_NoBuildInfo_ReturnsUnknown(t *testing.T) {
+	if got := classifyBuild("", false, nil, nil, nil); got != BuildKindUnknown {
+		t.Fatalf("classifyBuild(haveBuildInfo=false) = %q, want %q", got, BuildKindUnknown)
+	}
+}
+
+func TestClassifyBuild_ExtendedMainPath_ReturnsExtended(t *testing.T) {
+	cases := []string{
+		"github.com/acme/lark-cli-wrapper",
+		"example.com/isv/lark",
+		"gitlab.mycorp.internal/tools/lark-cli-fork",
+	}
+	for _, mp := range cases {
+		t.Run(mp, func(t *testing.T) {
+			if got := classifyBuild(mp, true, nil, nil, nil); got != BuildKindExtended {
+				t.Fatalf("mainPath=%q classifyBuild = %q, want %q", mp, got, BuildKindExtended)
+			}
+		})
+	}
+}
+
+func TestClassifyBuild_OfficialMainPath_NoProviders_ReturnsOfficial(t *testing.T) {
+	if got := classifyBuild(officialModulePath, true, nil, nil, nil); got != BuildKindOfficial {
+		t.Fatalf("classifyBuild(official, no providers) = %q, want %q", got, BuildKindOfficial)
+	}
+}
+
+func TestClassifyBuild_EmptyMainPath_DoesNotTriggerExtended(t *testing.T) {
+	// An empty Main.Path (rare, e.g. `go run` pre-1.18) must not be treated
+	// as extended by itself — the classifier falls through to provider checks.
+	if got := classifyBuild("", true, nil, nil, nil); got != BuildKindOfficial {
+		t.Fatalf("classifyBuild(empty mainPath, no providers) = %q, want %q", got, BuildKindOfficial)
+	}
+}
+
+func TestClassifyBuild_NonBuiltinCredentialProvider_ReturnsExtended(t *testing.T) {
+	// Any non-builtin credential provider flips the verdict to extended.
+	got := classifyBuild(officialModulePath, true, []any{&http.Server{}}, nil, nil)
+	if got != BuildKindExtended {
+		t.Fatalf("classifyBuild with external credential = %q, want %q", got, BuildKindExtended)
+	}
+}
+
+func TestClassifyBuild_MixedCredentialProviders_ExtendedWins(t *testing.T) {
+	// Even if most providers are builtin, a single external one decides.
+	providers := []any{&cmdutilLocalProvider{}, &http.Server{}}
+	if got := classifyBuild(officialModulePath, true, providers, nil, nil); got != BuildKindExtended {
+		t.Fatalf("classifyBuild mixed providers = %q, want %q", got, BuildKindExtended)
+	}
+}
+
+func TestClassifyBuild_NonBuiltinTransportProvider_ReturnsExtended(t *testing.T) {
+	got := classifyBuild(officialModulePath, true, nil, &http.Server{}, nil)
+	if got != BuildKindExtended {
+		t.Fatalf("classifyBuild with external transport = %q, want %q", got, BuildKindExtended)
+	}
+}
+
+func TestClassifyBuild_NonBuiltinFileioProvider_ReturnsExtended(t *testing.T) {
+	got := classifyBuild(officialModulePath, true, nil, nil, &http.Server{})
+	if got != BuildKindExtended {
+		t.Fatalf("classifyBuild with external fileio = %q, want %q", got, BuildKindExtended)
+	}
+}
+
+func TestClassifyBuild_AllBuiltinProviders_ReturnsOfficial(t *testing.T) {
+	// All three slots filled with builtin providers must still classify as official.
+	got := classifyBuild(
+		officialModulePath, true,
+		[]any{&cmdutilLocalProvider{}},
+		&cmdutilLocalProvider{},
+		&cmdutilLocalProvider{},
+	)
+	if got != BuildKindOfficial {
+		t.Fatalf("classifyBuild all-builtin = %q, want %q", got, BuildKindOfficial)
+	}
+}
+
+// TestClassifyBuild_MainPathPriorityOverProviders documents that the main
+// module path takes precedence: even with only builtin providers, a non-
+// official main path still yields extended.
+func TestClassifyBuild_MainPathPriorityOverProviders(t *testing.T) {
+	got := classifyBuild(
+		"github.com/acme/lark-wrapper", true,
+		[]any{&cmdutilLocalProvider{}},
+		&cmdutilLocalProvider{},
+		&cmdutilLocalProvider{},
+	)
+	if got != BuildKindExtended {
+		t.Fatalf("main-path override failed: got %q, want %q", got, BuildKindExtended)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// DetectBuildKind — sync.Once caching
+// ---------------------------------------------------------------------------
+
+func TestDetectBuildKind_StableAcrossCalls(t *testing.T) {
+	a := DetectBuildKind()
+	b := DetectBuildKind()
+	if a != b {
+		t.Fatalf("DetectBuildKind() returned different values on repeat: %q vs %q", a, b)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// BaseSecurityHeaders
+// ---------------------------------------------------------------------------
+
+func TestBaseSecurityHeaders_IncludesBuildHeader(t *testing.T) {
+	h := BaseSecurityHeaders()
+	v := h.Get(HeaderBuild)
+	if v == "" {
+		t.Fatal("BaseSecurityHeaders missing X-Cli-Build header")
+	}
+	switch v {
+	case BuildKindOfficial, BuildKindExtended, BuildKindUnknown:
+	default:
+		t.Fatalf("X-Cli-Build = %q, want one of official/extended/unknown", v)
+	}
+}
+
+func TestBaseSecurityHeaders_AllRequiredHeaders(t *testing.T) {
+	h := BaseSecurityHeaders()
+	for _, key := range []string{HeaderSource, HeaderVersion, HeaderBuild, HeaderUserAgent} {
+		if h.Get(key) == "" {
+			t.Errorf("BaseSecurityHeaders missing %s", key)
+		}
+	}
+}

internal/cmdutil/transport.go

@@ -72,6 +72,24 @@ func (t *UserAgentTransport) RoundTrip(req *http.Request) (*http.Response, error
 	return util.FallbackTransport().RoundTrip(req)
 }
 
+// BuildHeaderTransport is an http.RoundTripper that force-writes the
+// X-Cli-Build header before every request. Used in the SDK transport chain,
+// where SecurityHeaderTransport is not installed, to prevent extensions from
+// tampering with the build classification. The direct HTTP chain is already
+// covered by SecurityHeaderTransport iterating BaseSecurityHeaders.
+type BuildHeaderTransport struct {
+	Base http.RoundTripper
+}
+
+func (t *BuildHeaderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	req = req.Clone(req.Context())
+	req.Header.Set(HeaderBuild, DetectBuildKind())
+	if t.Base != nil {
+		return t.Base.RoundTrip(req)
+	}
+	return util.FallbackTransport().RoundTrip(req)
+}
+
 // SecurityHeaderTransport is an http.RoundTripper that injects CLI security
 // headers into every request. Shortcut headers are read from the request context.
 type SecurityHeaderTransport struct {
@@ -104,20 +122,47 @@ func (t *SecurityHeaderTransport) RoundTrip(req *http.Request) (*http.Response,
 }
 
 // extensionMiddleware wraps the built-in transport chain with pre/post hooks.
-// The built-in chain always executes and cannot be skipped or overridden.
-// The original request context is restored after PreRoundTrip to prevent
+// The built-in chain always executes unless the extension is an
+// exttransport.AbortableInterceptor and its PreRoundTripE returns a non-nil
+// error; it cannot otherwise be skipped or overridden.
+//
+// The original request context is restored after the pre hook to prevent
 // extensions from tampering with cancellation, deadlines, or built-in values.
+// Cloning the request isolates header/URL/etc. mutations from the caller's
+// request object; req.Body is intentionally shared — extensions that consume
+// it are responsible for rewinding (see Interceptor doc).
 type extensionMiddleware struct {
-	Base http.RoundTripper
-	Ext  exttransport.Interceptor
+	Base    http.RoundTripper
+	Ext     exttransport.Interceptor
+	ExtName string // Provider.Name(), captured at wrap time for *AbortError.Extension
 }
 
-// RoundTrip calls PreRoundTrip, restores the original context, executes
-// the built-in chain, then calls the post hook if non-nil.
+// RoundTrip invokes the interceptor pre hook, restores the original context,
+// executes the built-in chain (unless aborted), then calls the post hook if
+// non-nil. When the extension implements AbortableInterceptor and returns a
+// non-nil error from PreRoundTripE, the built-in chain is skipped and an
+// *exttransport.AbortError is returned; the post hook is still invoked with
+// (nil, reason) so extensions can unwind resources.
 func (m *extensionMiddleware) RoundTrip(req *http.Request) (*http.Response, error) {
 	origCtx := req.Context()
-	req = req.Clone(origCtx) // isolate caller's request before extension mutations
-	post := m.Ext.PreRoundTrip(req)
+	req = req.Clone(origCtx)
+
+	var (
+		post    func(*http.Response, error)
+		abortEr error
+	)
+	if a, ok := m.Ext.(exttransport.AbortableInterceptor); ok {
+		post, abortEr = a.PreRoundTripE(req)
+	} else {
+		post = m.Ext.PreRoundTrip(req)
+	}
+	if abortEr != nil {
+		if post != nil {
+			post(nil, abortEr)
+		}
+		return nil, &exttransport.AbortError{Extension: m.ExtName, Reason: abortEr}
+	}
+
 	req = req.WithContext(origCtx) // restore original context
 	resp, err := m.Base.RoundTrip(req)
 	if post != nil {
@@ -137,5 +182,5 @@ func wrapWithExtension(transport http.RoundTripper) http.RoundTripper {
 	if tr == nil {
 		return transport
 	}
-	return &extensionMiddleware{Base: transport, Ext: tr}
+	return &extensionMiddleware{Base: transport, Ext: tr, ExtName: p.Name()}
 }

internal/cmdutil/transport_test.go

@@ -0,0 +1,531 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	exttransport "github.com/larksuite/cli/extension/transport"
+	internalauth "github.com/larksuite/cli/internal/auth"
+)
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+// ---------------------------------------------------------------------------
+// RetryTransport
+// ---------------------------------------------------------------------------
+
+func TestRetryTransport_NoRetry(t *testing.T) {
+	calls := 0
+	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		calls++
+		return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader("ok"))}, nil
+	})
+	rt := &RetryTransport{Base: base, MaxRetries: 0}
+	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
+	resp, err := rt.RoundTrip(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if resp.StatusCode != 200 {
+		t.Errorf("expected 200, got %d", resp.StatusCode)
+	}
+	if calls != 1 {
+		t.Errorf("expected 1 call, got %d", calls)
+	}
+}
+
+func TestRetryTransport_RetryOn500(t *testing.T) {
+	calls := 0
+	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		calls++
+		if calls < 3 {
+			return &http.Response{StatusCode: 500, Body: io.NopCloser(strings.NewReader("error"))}, nil
+		}
+		return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader("ok"))}, nil
+	})
+	rt := &RetryTransport{Base: base, MaxRetries: 3, Delay: 1 * time.Millisecond}
+	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
+	resp, err := rt.RoundTrip(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if resp.StatusCode != 200 {
+		t.Errorf("expected 200 after retries, got %d", resp.StatusCode)
+	}
+	if calls != 3 {
+		t.Errorf("expected 3 calls, got %d", calls)
+	}
+}
+
+func TestRetryTransport_DefaultNoRetry(t *testing.T) {
+	calls := 0
+	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		calls++
+		return &http.Response{StatusCode: 500, Body: io.NopCloser(strings.NewReader("error"))}, nil
+	})
+	rt := &RetryTransport{Base: base} // default MaxRetries=0
+	req, _ := http.NewRequest("GET", "http://example.com/test", nil)
+	resp, err := rt.RoundTrip(req)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if resp.StatusCode != 500 {
+		t.Errorf("expected 500 with no retries, got %d", resp.StatusCode)
+	}
+	if calls != 1 {
+		t.Errorf("expected 1 call with default config, got %d", calls)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// buildSDKTransport chain composition
+// ---------------------------------------------------------------------------
+
+func TestBuildSDKTransport_IncludesRetryTransport(t *testing.T) {
+	transport := buildSDKTransport()
+
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
+	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
+	if !ok {
+		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
+	}
+	bh, ok := sec.Base.(*BuildHeaderTransport)
+	if !ok {
+		t.Fatalf("layer after SecurityPolicy = %T, want *BuildHeaderTransport", sec.Base)
+	}
+	ua, ok := bh.Base.(*UserAgentTransport)
+	if !ok {
+		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
+	}
+	if _, ok := ua.Base.(*RetryTransport); !ok {
+		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
+	}
+}
+
+func TestBuildSDKTransport_WithExtension(t *testing.T) {
+	exttransport.Register(&stubTransportProvider{})
+	t.Cleanup(func() { exttransport.Register(nil) })
+
+	transport := buildSDKTransport()
+
+	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → Base
+	mid, ok := transport.(*extensionMiddleware)
+	if !ok {
+		t.Fatalf("outer transport type = %T, want *extensionMiddleware", transport)
+	}
+	sec, ok := mid.Base.(*internalauth.SecurityPolicyTransport)
+	if !ok {
+		t.Fatalf("transport type = %T, want *auth.SecurityPolicyTransport", mid.Base)
+	}
+	bh, ok := sec.Base.(*BuildHeaderTransport)
+	if !ok {
+		t.Fatalf("layer after SecurityPolicy = %T, want *BuildHeaderTransport", sec.Base)
+	}
+	ua, ok := bh.Base.(*UserAgentTransport)
+	if !ok {
+		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
+	}
+	if _, ok := ua.Base.(*RetryTransport); !ok {
+		t.Fatalf("innermost transport type = %T, want *RetryTransport", ua.Base)
+	}
+}
+
+func TestBuildSDKTransport_WithoutExtension(t *testing.T) {
+	exttransport.Register(nil)
+
+	transport := buildSDKTransport()
+
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
+	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
+	if !ok {
+		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
+	}
+	bh, ok := sec.Base.(*BuildHeaderTransport)
+	if !ok {
+		t.Fatalf("layer after SecurityPolicy = %T, want *BuildHeaderTransport", sec.Base)
+	}
+	ua, ok := bh.Base.(*UserAgentTransport)
+	if !ok {
+		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
+	}
+	if _, ok := ua.Base.(*RetryTransport); !ok {
+		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// extensionMiddleware — legacy Interceptor path
+// ---------------------------------------------------------------------------
+
+type stubTransportProvider struct {
+	interceptor exttransport.Interceptor
+}
+
+func (s *stubTransportProvider) Name() string { return "stub" }
+func (s *stubTransportProvider) ResolveInterceptor(context.Context) exttransport.Interceptor {
+	if s.interceptor != nil {
+		return s.interceptor
+	}
+	return &stubTransportImpl{}
+}
+
+type stubTransportImpl struct{}
+
+func (s *stubTransportImpl) PreRoundTrip(req *http.Request) func(*http.Response, error) {
+	return nil
+}
+
+// headerCapturingInterceptor sets custom headers in PreRoundTrip and records
+// whether PostRoundTrip was called, to verify execution order.
+type headerCapturingInterceptor struct {
+	preCalled  bool
+	postCalled bool
+}
+
+func (h *headerCapturingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
+	h.preCalled = true
+	// Set a custom header that should survive (no built-in override)
+	req.Header.Set("X-Custom-Trace", "ext-trace-123")
+	// Try to override a security header — should be overwritten by SecurityHeaderTransport
+	req.Header.Set(HeaderSource, "ext-tampered")
+	return func(resp *http.Response, err error) {
+		h.postCalled = true
+	}
+}
+
+func TestExtensionInterceptor_ExecutionOrder(t *testing.T) {
+	var receivedHeaders http.Header
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedHeaders = r.Header.Clone()
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	ic := &headerCapturingInterceptor{}
+	exttransport.Register(&stubTransportProvider{interceptor: ic})
+	t.Cleanup(func() { exttransport.Register(nil) })
+
+	// Use HTTP transport chain (has SecurityHeaderTransport)
+	var base http.RoundTripper = http.DefaultTransport
+	base = &RetryTransport{Base: base}
+	base = &SecurityHeaderTransport{Base: base}
+	transport := wrapWithExtension(base)
+	client := &http.Client{Transport: transport}
+
+	req, _ := http.NewRequest("GET", srv.URL, nil)
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	resp.Body.Close()
+
+	// PreRoundTrip was called
+	if !ic.preCalled {
+		t.Fatal("PreRoundTrip was not called")
+	}
+	// PostRoundTrip (closure) was called
+	if !ic.postCalled {
+		t.Fatal("PostRoundTrip closure was not called")
+	}
+	// Custom header set by extension survives (no built-in override)
+	if got := receivedHeaders.Get("X-Custom-Trace"); got != "ext-trace-123" {
+		t.Fatalf("X-Custom-Trace = %q, want %q", got, "ext-trace-123")
+	}
+	// Security header overridden by extension is restored by SecurityHeaderTransport
+	if got := receivedHeaders.Get(HeaderSource); got != SourceValue {
+		t.Fatalf("%s = %q, want %q (built-in should override extension)", HeaderSource, got, SourceValue)
+	}
+}
+
+// buildTamperingInterceptor tries to delete and spoof X-Cli-Build via
+// PreRoundTrip. The SDK chain's BuildHeaderTransport must restore the real
+// value before the request leaves the process.
+type buildTamperingInterceptor struct{}
+
+func (buildTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
+	req.Header.Del(HeaderBuild)
+	req.Header.Set(HeaderBuild, "ext-tampered-build")
+	return nil
+}
+
+// TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader verifies that the
+// X-Cli-Build header is force-written by BuildHeaderTransport in the SDK
+// transport chain, even when an extension tries to delete or spoof it. This
+// closes the gap where the SDK chain had no equivalent of
+// SecurityHeaderTransport (see design doc §3.3.3).
+func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
+	var receivedBuild string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedBuild = r.Header.Get(HeaderBuild)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	exttransport.Register(&stubTransportProvider{interceptor: buildTamperingInterceptor{}})
+	t.Cleanup(func() { exttransport.Register(nil) })
+
+	// Replicate the SDK chain layering used by buildSDKTransport.
+	var base http.RoundTripper = http.DefaultTransport
+	base = &RetryTransport{Base: base}
+	base = &UserAgentTransport{Base: base}
+	base = &BuildHeaderTransport{Base: base}
+	transport := wrapWithExtension(base)
+	client := &http.Client{Transport: transport}
+
+	req, _ := http.NewRequest("GET", srv.URL, nil)
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	resp.Body.Close()
+
+	if receivedBuild == "ext-tampered-build" {
+		t.Fatalf("%s = %q, extension tampering leaked to network", HeaderBuild, receivedBuild)
+	}
+	want := DetectBuildKind()
+	if receivedBuild != want {
+		t.Fatalf("%s = %q, want %q", HeaderBuild, receivedBuild, want)
+	}
+}
+
+// TestBuildHeaderTransport_OverridesEvenWithoutTamper verifies that even if
+// no extension is registered, BuildHeaderTransport writes X-Cli-Build.
+func TestBuildHeaderTransport_OverridesEvenWithoutTamper(t *testing.T) {
+	var receivedBuild string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedBuild = r.Header.Get(HeaderBuild)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	transport := &BuildHeaderTransport{Base: http.DefaultTransport}
+	client := &http.Client{Transport: transport}
+
+	req, _ := http.NewRequest("GET", srv.URL, nil)
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	resp.Body.Close()
+
+	if receivedBuild == "" {
+		t.Fatalf("%s header missing, BuildHeaderTransport did not inject", HeaderBuild)
+	}
+	want := DetectBuildKind()
+	if receivedBuild != want {
+		t.Fatalf("%s = %q, want %q", HeaderBuild, receivedBuild, want)
+	}
+}
+
+// TestBuildHeaderTransport_NilBase_UsesFallback verifies that when Base is nil,
+// the transport still sets X-Cli-Build and routes the request through
+// util.FallbackTransport rather than panicking. This covers the fallback
+// branch in RoundTrip that is otherwise unreachable with a non-nil Base.
+func TestBuildHeaderTransport_NilBase_UsesFallback(t *testing.T) {
+	var receivedBuild string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedBuild = r.Header.Get(HeaderBuild)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	transport := &BuildHeaderTransport{Base: nil}
+	client := &http.Client{Transport: transport}
+
+	req, _ := http.NewRequest("GET", srv.URL, nil)
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("request via nil-Base transport failed: %v", err)
+	}
+	resp.Body.Close()
+
+	want := DetectBuildKind()
+	if receivedBuild != want {
+		t.Fatalf("%s = %q, want %q (header must be set even on nil-Base path)",
+			HeaderBuild, receivedBuild, want)
+	}
+}
+
+// interceptorFunc adapts a function to exttransport.Interceptor.
+type interceptorFunc func(*http.Request) func(*http.Response, error)
+
+func (f interceptorFunc) PreRoundTrip(req *http.Request) func(*http.Response, error) { return f(req) }
+
+func TestExtensionInterceptor_ContextTamperPrevented(t *testing.T) {
+	type ctxKeyType string
+	const testKey ctxKeyType = "original"
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	var ctxValue any
+
+	// Use a custom transport that captures the context value seen by the built-in chain
+	capturer := roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		ctxValue = req.Context().Value(testKey)
+		return http.DefaultTransport.RoundTrip(req)
+	})
+
+	// Interceptor that tries to tamper with context
+	tamperIC := interceptorFunc(func(req *http.Request) func(*http.Response, error) {
+		// Try to replace context with a new one
+		*req = *req.WithContext(context.WithValue(req.Context(), testKey, "tampered"))
+		return nil
+	})
+
+	mid := &extensionMiddleware{Base: capturer, Ext: tamperIC}
+
+	origCtx := context.WithValue(context.Background(), testKey, "original")
+	req, _ := http.NewRequestWithContext(origCtx, "GET", srv.URL, nil)
+	resp, err := mid.RoundTrip(req)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	resp.Body.Close()
+
+	// Built-in chain should see original context, not tampered
+	if ctxValue != "original" {
+		t.Fatalf("built-in chain saw context value %q, want %q", ctxValue, "original")
+	}
+}
+
+// ---------------------------------------------------------------------------
+// extensionMiddleware — PreRoundTripE abort path
+// ---------------------------------------------------------------------------
+
+// abortingInterceptor implements exttransport.AbortableInterceptor and
+// records invocation of the pre and post hooks. These middleware tests only
+// assert middleware-level integration; pure *AbortError behavior
+// (Error/Unwrap/Is/As) is covered in extension/transport/errors_test.go.
+type abortingInterceptor struct {
+	reason     error // if non-nil, PreRoundTripE returns this to abort
+	nilPost    bool  // if true, PreRoundTripE returns a nil post func
+	preECalled bool
+	postCalled bool
+	postResp   *http.Response
+	postErr    error
+}
+
+// PreRoundTrip is a no-op that satisfies the legacy Interceptor method; the
+// middleware never calls it when PreRoundTripE is present.
+func (*abortingInterceptor) PreRoundTrip(*http.Request) func(*http.Response, error) {
+	return nil
+}
+
+func (a *abortingInterceptor) PreRoundTripE(req *http.Request) (func(*http.Response, error), error) {
+	a.preECalled = true
+	if a.nilPost {
+		return nil, a.reason
+	}
+	return func(resp *http.Response, err error) {
+		a.postCalled = true
+		a.postResp = resp
+		a.postErr = err
+	}, a.reason
+}
+
+func TestExtensionMiddleware_PreRoundTripEAbort(t *testing.T) {
+	innerErr := errors.New("denied by policy")
+
+	t.Run("skips base and wires AbortError fields", func(t *testing.T) {
+		ic := &abortingInterceptor{reason: innerErr}
+		baseCalls := 0
+		base := roundTripFunc(func(*http.Request) (*http.Response, error) {
+			baseCalls++
+			return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
+		})
+
+		mid := &extensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
+		req, _ := http.NewRequest("GET", "http://example.invalid/", nil)
+		resp, err := mid.RoundTrip(req)
+
+		if resp != nil {
+			t.Fatalf("resp = %v, want nil on abort", resp)
+		}
+		if baseCalls != 0 {
+			t.Fatalf("base RoundTrip called %d times on abort, want 0", baseCalls)
+		}
+		if !ic.preECalled {
+			t.Fatal("PreRoundTripE was not called")
+		}
+
+		var aErr *exttransport.AbortError
+		if !errors.As(err, &aErr) {
+			t.Fatalf("errors.As(*AbortError) = false, err = %v (%T)", err, err)
+		}
+		if aErr.Extension != "stub" || aErr.Reason != innerErr {
+			t.Fatalf("AbortError = %+v, want {Extension:stub Reason:%v}", aErr, innerErr)
+		}
+
+		// Post must see the original inner err, not the *AbortError wrapper.
+		if !ic.postCalled {
+			t.Fatal("post hook was not called on abort")
+		}
+		if ic.postResp != nil {
+			t.Fatalf("post resp = %v, want nil", ic.postResp)
+		}
+		if ic.postErr != innerErr {
+			t.Fatalf("post err = %v, want original inner err %v", ic.postErr, innerErr)
+		}
+	})
+
+	t.Run("nil post still returns AbortError", func(t *testing.T) {
+		ic := &abortingInterceptor{reason: innerErr, nilPost: true}
+		base := roundTripFunc(func(*http.Request) (*http.Response, error) {
+			t.Fatal("base must not be called on abort")
+			return nil, nil
+		})
+
+		mid := &extensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
+		req, _ := http.NewRequest("GET", "http://example.invalid/", nil)
+		_, err := mid.RoundTrip(req)
+
+		var aErr *exttransport.AbortError
+		if !errors.As(err, &aErr) {
+			t.Fatalf("errors.As(*AbortError) = false, err = %v", err)
+		}
+	})
+}
+
+func TestExtensionMiddleware_PreRoundTripEHappyPath(t *testing.T) {
+	ic := &abortingInterceptor{} // reason == nil → no abort
+	baseCalls := 0
+	base := roundTripFunc(func(*http.Request) (*http.Response, error) {
+		baseCalls++
+		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
+	})
+
+	mid := &extensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
+	req, _ := http.NewRequest("GET", "http://example.invalid/", nil)
+	resp, err := mid.RoundTrip(req)
+	if err != nil {
+		t.Fatalf("happy path returned err: %v", err)
+	}
+	if resp == nil || resp.StatusCode != http.StatusOK {
+		t.Fatalf("resp = %v, want 200", resp)
+	}
+	if baseCalls != 1 {
+		t.Fatalf("base RoundTrip called %d times, want 1", baseCalls)
+	}
+	if !ic.preECalled {
+		t.Fatal("PreRoundTripE was not called")
+	}
+	if !ic.postCalled || ic.postErr != nil {
+		t.Fatalf("post hook not called or err != nil: called=%v err=%v", ic.postCalled, ic.postErr)
+	}
+}

internal/credential/default_provider.go

@@ -21,11 +21,14 @@ import (
 
 // DefaultAccountProvider resolves account from config.json via keychain.
 type DefaultAccountProvider struct {
-	keychain keychain.KeychainAccess
+	keychain func() keychain.KeychainAccess
 	profile  string
 }
 
-func NewDefaultAccountProvider(kc keychain.KeychainAccess, profile string) *DefaultAccountProvider {
+func NewDefaultAccountProvider(kc func() keychain.KeychainAccess, profile string) *DefaultAccountProvider {
+	if kc == nil {
+		kc = keychain.Default
+	}
 	return &DefaultAccountProvider{keychain: kc, profile: profile}
 }
 
@@ -36,7 +39,7 @@ func (p *DefaultAccountProvider) ResolveAccount(ctx context.Context) (*Account,
 		return nil, &core.ConfigError{Code: 2, Type: "config", Message: "not configured", Hint: "run `lark-cli config init --new` in the background. It blocks and outputs a verification URL — retrieve the URL and open it in a browser to complete setup."}
 	}
 
-	cfg, err := core.ResolveConfigFromMulti(multi, p.keychain, p.profile)
+	cfg, err := core.ResolveConfigFromMulti(multi, p.keychain(), p.profile)
 	if err != nil {
 		return nil, err
 	}

internal/credential/integration_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/envvars"
+	"github.com/larksuite/cli/internal/keychain"
 )
 
 type noopKC struct{}
@@ -99,7 +100,7 @@ func TestFullChain_ConfigStrictMode(t *testing.T) {
 	}
 
 	ep := &envprovider.Provider{}
-	defaultAcct := credential.NewDefaultAccountProvider(&noopKC{}, "")
+	defaultAcct := credential.NewDefaultAccountProvider(func() keychain.KeychainAccess { return &noopKC{} }, "")
 
 	cp := credential.NewCredentialProvider(
 		[]extcred.Provider{ep},

internal/output/lark_errors.go

@@ -41,6 +41,14 @@ const (
 
 	// Sheets float image: width/height/offset out of range or invalid.
 	LarkErrSheetsFloatImageInvalidDims = 1310246
+
+	// Drive permission apply: per-user-per-document submission limit (5/day) reached.
+	LarkErrDrivePermApplyRateLimit = 1063006
+	// Drive permission apply: request is not applicable for this document
+	// (e.g. the document is configured to disallow access requests, or the
+	// caller already holds the requested permission, or the target type does
+	// not accept apply operations).
+	LarkErrDrivePermApplyNotApplicable = 1063007
 )
 
 // ClassifyLarkError maps a Lark API error code + message to (exitCode, errType, hint).
@@ -82,6 +90,14 @@ func ClassifyLarkError(code int, msg string) (int, string, string) {
 		return ExitAPI, "invalid_params",
 			"check --width / --height / --offset-x / --offset-y: " +
 				"width/height must be >= 20 px; offsets must be >= 0 and less than the anchor cell's width/height"
+
+	// drive permission-apply specific guidance
+	case LarkErrDrivePermApplyRateLimit:
+		return ExitAPI, "rate_limit",
+			"permission-apply quota reached: each user may request access on the same document at most 5 times per day; wait or ask the owner directly"
+	case LarkErrDrivePermApplyNotApplicable:
+		return ExitAPI, "invalid_params",
+			"this document does not accept a permission-apply request (common causes: the document is configured to disallow access requests, the caller already holds the permission, or the target type does not support apply); contact the owner directly"
 	}
 
 	return ExitAPI, "api_error", ""

internal/output/lark_errors_test.go

@@ -47,6 +47,20 @@ func TestClassifyLarkError_DriveCreateShortcutConstraints(t *testing.T) {
 			wantType:     "invalid_params",
 			wantHint:     "--width / --height / --offset-x / --offset-y",
 		},
+		{
+			name:         "drive permission apply rate limit",
+			code:         LarkErrDrivePermApplyRateLimit,
+			wantExitCode: ExitAPI,
+			wantType:     "rate_limit",
+			wantHint:     "5 times per day",
+		},
+		{
+			name:         "drive permission apply not applicable",
+			code:         LarkErrDrivePermApplyNotApplicable,
+			wantExitCode: ExitAPI,
+			wantType:     "invalid_params",
+			wantHint:     "does not accept a permission-apply request",
+		},
 	}
 
 	for _, tt := range tests {

internal/update/update.go

@@ -61,7 +61,7 @@ func httpClient() *http.Client {
 	}
 	return &http.Client{
 		Timeout:   fetchTimeout,
-		Transport: util.NewBaseTransport(),
+		Transport: util.SharedTransport(),
 	}
 }
 

internal/util/proxy.go

@@ -72,31 +72,47 @@ func WarnIfProxied(w io.Writer) {
 	})
 }
 
-// NewBaseTransport creates an *http.Transport cloned from http.DefaultTransport.
-// If LARK_CLI_NO_PROXY is set, proxy support is disabled.
-// Each call returns a new instance; use FallbackTransport for a shared singleton.
-func NewBaseTransport() *http.Transport {
+// noProxyTransport is a proxy-disabled clone of http.DefaultTransport,
+// lazily built the first time LARK_CLI_NO_PROXY is observed set.
+var noProxyTransport = sync.OnceValue(func() *http.Transport {
 	def, ok := http.DefaultTransport.(*http.Transport)
 	if !ok {
 		return &http.Transport{}
 	}
 	t := def.Clone()
-	if os.Getenv(EnvNoProxy) != "" {
-		t.Proxy = nil
-	}
+	t.Proxy = nil
 	return t
-}
-
-// fallbackTransport is a lazily-initialized singleton used by transport
-// decorators when their Base field is nil, preserving connection pooling.
-var fallbackTransport = sync.OnceValue(func() *http.Transport {
-	return NewBaseTransport()
 })
 
-// FallbackTransport returns a shared *http.Transport singleton suitable for
-// use as a fallback when a transport decorator's Base is nil.
-// Unlike NewBaseTransport (which clones per call), this reuses a single
-// instance so that TCP connections and TLS sessions are pooled.
-func FallbackTransport() *http.Transport {
-	return fallbackTransport()
+// SharedTransport returns the base http.RoundTripper for CLI HTTP clients.
+//
+// By default it returns http.DefaultTransport — the stdlib-provided
+// process-wide singleton — so every HTTP client in the process shares one
+// TCP connection pool, TLS session cache, and HTTP/2 state. When
+// LARK_CLI_NO_PROXY is set it returns a separate proxy-disabled singleton
+// clone; LARK_CLI_NO_PROXY is checked on every call, but the clone is built
+// at most once.
+//
+// The returned RoundTripper MUST NOT be mutated. Callers that need a
+// customized transport should assert to *http.Transport and Clone() it.
+// Using a shared base is required so persistConn readLoop/writeLoop
+// goroutines are reused; cloning per call leaks them until IdleConnTimeout
+// (~90s) fires.
+func SharedTransport() http.RoundTripper {
+	if os.Getenv(EnvNoProxy) != "" {
+		return noProxyTransport()
+	}
+	return http.DefaultTransport
+}
+
+// FallbackTransport returns a shared *http.Transport singleton. It is a
+// thin wrapper over SharedTransport retained so modules that were already
+// on the leak-free singleton path (internal/auth, internal/cmdutil
+// transport decorators) do not have to migrate. New code should prefer
+// SharedTransport and treat the base as an http.RoundTripper.
+func FallbackTransport() *http.Transport {
+	if t, ok := SharedTransport().(*http.Transport); ok {
+		return t
+	}
+	return noProxyTransport()
 }

internal/util/proxy_test.go

@@ -28,19 +28,65 @@ func TestDetectProxyEnv(t *testing.T) {
 	}
 }
 
-func TestNewBaseTransport_Default(t *testing.T) {
+func TestSharedTransport_DefaultReturnsStdlibSingleton(t *testing.T) {
 	t.Setenv(EnvNoProxy, "")
-	tr := NewBaseTransport()
-	if tr.Proxy == nil {
-		t.Error("expected proxy func to be set when LARK_CLI_NO_PROXY is not set")
+	tr := SharedTransport()
+	if tr != http.DefaultTransport {
+		t.Error("SharedTransport should return http.DefaultTransport when LARK_CLI_NO_PROXY is unset")
 	}
 }
 
-func TestNewBaseTransport_NoProxy(t *testing.T) {
+func TestSharedTransport_NoProxyReturnsClone(t *testing.T) {
 	t.Setenv(EnvNoProxy, "1")
-	tr := NewBaseTransport()
-	if tr.Proxy != nil {
-		t.Error("expected proxy func to be nil when LARK_CLI_NO_PROXY=1")
+	tr := SharedTransport()
+	if tr == http.DefaultTransport {
+		t.Fatal("SharedTransport should return a clone, not DefaultTransport, when LARK_CLI_NO_PROXY is set")
+	}
+	ht, ok := tr.(*http.Transport)
+	if !ok {
+		t.Fatalf("expected *http.Transport, got %T", tr)
+	}
+	if ht.Proxy != nil {
+		t.Error("no-proxy transport should have Proxy == nil")
+	}
+}
+
+func TestSharedTransport_NoProxyIsCachedSingleton(t *testing.T) {
+	t.Setenv(EnvNoProxy, "1")
+	a := SharedTransport()
+	b := SharedTransport()
+	if a != b {
+		t.Error("repeated SharedTransport calls with LARK_CLI_NO_PROXY set must return the same instance")
+	}
+}
+
+func TestSharedTransport_EnvUnsetAfterSetFallsBackToDefault(t *testing.T) {
+	// Simulate a process that first runs with LARK_CLI_NO_PROXY=1 (populating
+	// the no-proxy singleton), then unsets it. Subsequent calls must return
+	// http.DefaultTransport, NOT the cached no-proxy clone.
+	t.Setenv(EnvNoProxy, "1")
+	noProxy := SharedTransport()
+	if noProxy == http.DefaultTransport {
+		t.Fatal("precondition: first call with env set should not return DefaultTransport")
+	}
+
+	t.Setenv(EnvNoProxy, "")
+	after := SharedTransport()
+	if after != http.DefaultTransport {
+		t.Errorf("after unsetting LARK_CLI_NO_PROXY, SharedTransport must return http.DefaultTransport, got %T (%p)", after, after)
+	}
+}
+
+func TestSharedTransport_NoProxyOverridesSystemProxy(t *testing.T) {
+	t.Setenv("HTTPS_PROXY", "http://should-be-ignored:8888")
+	t.Setenv(EnvNoProxy, "1")
+
+	ht, ok := SharedTransport().(*http.Transport)
+	if !ok {
+		t.Fatalf("expected *http.Transport, got %T", SharedTransport())
+	}
+	if ht.Proxy != nil {
+		t.Error("LARK_CLI_NO_PROXY should override system proxy settings")
 	}
 }
 
@@ -156,35 +202,3 @@ func TestWarnIfProxied_RedactsCredentials(t *testing.T) {
 		t.Errorf("warning should contain redacted proxy URL, got: %s", out)
 	}
 }
-
-func TestNewBaseTransport_IsHTTPTransport(t *testing.T) {
-	t.Setenv(EnvNoProxy, "")
-	tr := NewBaseTransport()
-
-	// Should be a valid *http.Transport that can be used
-	var rt http.RoundTripper = tr
-	_ = rt
-
-	// Verify it's not the same pointer as DefaultTransport (should be a clone)
-	if tr == http.DefaultTransport {
-		t.Error("NewBaseTransport should return a clone, not DefaultTransport itself")
-	}
-}
-
-func TestNewBaseTransport_RespectsNoProxyEnv(t *testing.T) {
-	// Simulate: user sets both system proxy and our disable flag
-	t.Setenv("HTTPS_PROXY", "http://should-be-ignored:8888")
-	t.Setenv(EnvNoProxy, "1")
-
-	tr := NewBaseTransport()
-	if tr.Proxy != nil {
-		t.Error("LARK_CLI_NO_PROXY should override system proxy settings")
-	}
-
-	// Clean up and verify proxy is restored
-	t.Setenv(EnvNoProxy, "")
-	tr2 := NewBaseTransport()
-	if tr2.Proxy == nil {
-		t.Error("proxy should be enabled when LARK_CLI_NO_PROXY is unset")
-	}
-}

package.json

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

shortcuts/base/base_execute_test.go

@@ -67,11 +67,15 @@ func runShortcutWithAuthTypes(t *testing.T, shortcut common.Shortcut, authTypes
 	parent.SilenceErrors = true
 	parent.SilenceUsage = true
 	stdout.Reset()
+	if stderr, ok := factory.IOStreams.ErrOut.(*bytes.Buffer); ok {
+		stderr.Reset()
+	}
 	return parent.ExecuteContext(context.Background())
 }
 
 func TestBaseWorkspaceExecuteCreate(t *testing.T) {
 	factory, stdout, reg := newExecuteFactory(t)
+	stderr, _ := factory.IOStreams.ErrOut.(*bytes.Buffer)
 	permStub := &httpmock.Stub{
 		Method: "POST",
 		URL:    "/open-apis/drive/v1/permissions/app_x/members?need_notification=false&type=bitable",
@@ -96,6 +100,9 @@ func TestBaseWorkspaceExecuteCreate(t *testing.T) {
 	if data["created"] != true {
 		t.Fatalf("created = %#v, want true", data["created"])
 	}
+	if !strings.Contains(stderr.String(), baseCreateHint) {
+		t.Fatalf("stderr = %q, want %q", stderr.String(), baseCreateHint)
+	}
 	base, _ := data["base"].(map[string]interface{})
 	if got := common.GetString(base, "app_token"); got != "app_x" {
 		t.Fatalf("base.app_token = %q, want %q", got, "app_x")
@@ -184,6 +191,7 @@ func TestBaseWorkspaceExecuteGetAndCopy(t *testing.T) {
 
 func TestBaseWorkspaceExecuteCreateBotAutoGrantSkippedWithoutCurrentUser(t *testing.T) {
 	factory, stdout, reg := newExecuteFactoryWithUserOpenID(t, "")
+	stderr, _ := factory.IOStreams.ErrOut.(*bytes.Buffer)
 	reg.Register(&httpmock.Stub{
 		Method: "POST",
 		URL:    "/open-apis/base/v3/bases",
@@ -198,6 +206,9 @@ func TestBaseWorkspaceExecuteCreateBotAutoGrantSkippedWithoutCurrentUser(t *test
 	}
 
 	data := decodeBaseEnvelope(t, stdout)
+	if !strings.Contains(stderr.String(), baseCreateHint) {
+		t.Fatalf("stderr = %q, want %q", stderr.String(), baseCreateHint)
+	}
 	grant, _ := data["permission_grant"].(map[string]interface{})
 	if grant["status"] != common.PermissionGrantSkipped {
 		t.Fatalf("permission_grant.status = %#v, want %q", grant["status"], common.PermissionGrantSkipped)

shortcuts/base/base_ops.go

@@ -5,11 +5,14 @@ package base
 
 import (
 	"context"
+	"fmt"
 	"strings"
 
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
+const baseCreateHint = "Tip: New bases include a default empty table with 5-10 blank records. After finishing table/field setup on this base, ask whether to delete that default table. If yes, run +table-list first, then delete the default table."
+
 func dryRunBaseGet(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 	return common.NewDryRunAPI().
 		GET("/open-apis/base/v3/bases/:base_token").
@@ -65,6 +68,7 @@ func executeBaseCreate(runtime *common.RuntimeContext) error {
 	out := map[string]interface{}{"base": data, "created": true}
 	augmentBasePermissionGrant(runtime, out, data)
 	runtime.Out(out, nil)
+	fmt.Fprintln(runtime.IO().ErrOut, baseCreateHint)
 	return nil
 }
 

shortcuts/base/base_shortcuts_test.go

@@ -132,7 +132,7 @@ func TestShortcutsCatalog(t *testing.T) {
 		"+table-list", "+table-get", "+table-create", "+table-update", "+table-delete",
 		"+field-list", "+field-get", "+field-create", "+field-update", "+field-delete", "+field-search-options",
 		"+view-list", "+view-get", "+view-create", "+view-delete", "+view-get-filter", "+view-set-filter", "+view-get-visible-fields", "+view-set-visible-fields", "+view-get-group", "+view-set-group", "+view-get-sort", "+view-set-sort", "+view-get-timebar", "+view-set-timebar", "+view-get-card", "+view-set-card", "+view-rename",
-		"+record-list", "+record-search", "+record-get", "+record-upsert", "+record-batch-create", "+record-batch-update", "+record-upload-attachment", "+record-delete",
+		"+record-list", "+record-search", "+record-get", "+record-upsert", "+record-batch-create", "+record-batch-update", "+record-share-link-create", "+record-upload-attachment", "+record-delete",
 		"+record-history-list",
 		"+base-get", "+base-copy", "+base-create",
 		"+role-create", "+role-delete", "+role-update", "+role-list", "+role-get", "+advperm-enable", "+advperm-disable",

shortcuts/base/record_ops.go

@@ -112,6 +112,56 @@ func dryRunRecordHistoryList(_ context.Context, runtime *common.RuntimeContext)
 		Set("base_token", runtime.Str("base-token"))
 }
 
+func dryRunRecordShareBatch(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+	recordIDs := deduplicateRecordIDs(runtime)
+	return common.NewDryRunAPI().
+		POST("/open-apis/base/v3/bases/:base_token/tables/:table_id/records/share_links/batch").
+		Body(map[string]interface{}{"record_ids": recordIDs}).
+		Set("base_token", runtime.Str("base-token")).
+		Set("table_id", baseTableID(runtime))
+}
+
+const maxShareBatchSize = 100
+
+func validateRecordShareBatch(runtime *common.RuntimeContext) error {
+	recordIDs := deduplicateRecordIDs(runtime)
+	if len(recordIDs) == 0 {
+		return common.FlagErrorf("--record-ids is required and must not be empty")
+	}
+	if len(recordIDs) > maxShareBatchSize {
+		return common.FlagErrorf("--record-ids exceeds maximum limit of %d (got %d)", maxShareBatchSize, len(recordIDs))
+	}
+	return nil
+}
+
+func deduplicateRecordIDs(runtime *common.RuntimeContext) []string {
+	raw := runtime.StrSlice("record-ids")
+	seen := make(map[string]bool, len(raw))
+	result := make([]string, 0, len(raw))
+	for _, id := range raw {
+		if id != "" && !seen[id] {
+			seen[id] = true
+			result = append(result, id)
+		}
+	}
+	return result
+}
+
+func executeRecordShareBatch(runtime *common.RuntimeContext) error {
+	recordIDs := deduplicateRecordIDs(runtime)
+	body := map[string]interface{}{
+		"record_ids": recordIDs,
+	}
+	data, err := baseV3Call(runtime, "POST",
+		baseV3Path("bases", runtime.Str("base-token"), "tables", baseTableID(runtime), "records", "share_links", "batch"),
+		nil, body)
+	if err != nil {
+		return err
+	}
+	runtime.Out(data, nil)
+	return nil
+}
+
 func validateRecordJSON(runtime *common.RuntimeContext) error {
 	pc := newParseCtx(runtime)
 	_, err := parseJSONObject(pc, runtime.Str("json"), "json")

shortcuts/base/record_share_link_create.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package base
+
+import (
+	"context"
+
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+var BaseRecordShareLinkCreate = common.Shortcut{
+	Service:     "base",
+	Command:     "+record-share-link-create",
+	Description: "Generate share links for one or more records (max 100 per request)",
+	Risk:        "read",
+	Scopes:      []string{"base:record:read"},
+	AuthTypes:   authTypes(),
+	Flags: []common.Flag{
+		baseTokenFlag(true),
+		tableRefFlag(true),
+		{Name: "record-ids", Type: "string_slice", Desc: "record IDs to generate share links for (comma-separated or repeatable, max 100)", Required: true},
+	},
+	Tips: []string{
+		`Single record:  --base-token xxx --table-id tblxxx --record-ids recxxx`,
+		`Multiple records: --base-token xxx --table-id tblxxx --record-ids rec001,rec002,rec003`,
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		return validateRecordShareBatch(runtime)
+	},
+	DryRun: dryRunRecordShareBatch,
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		return executeRecordShareBatch(runtime)
+	},
+}

shortcuts/base/shortcuts.go

@@ -42,6 +42,7 @@ func Shortcuts() []common.Shortcut {
 		BaseRecordUpsert,
 		BaseRecordBatchCreate,
 		BaseRecordBatchUpdate,
+		BaseRecordShareLinkCreate,
 		BaseRecordUploadAttachment,
 		BaseRecordDelete,
 		BaseRecordHistoryList,

shortcuts/calendar/calendar_agenda.go

@@ -54,6 +54,7 @@ func fetchInstanceViewRange(ctx context.Context, runtime *common.RuntimeContext,
 			"start_time": fmt.Sprintf("%d", startTime),
 			"end_time":   fmt.Sprintf("%d", endTime),
 		}, nil)
+	err = wrapPredefinedError(err)
 	if err != nil {
 		return nil, output.Errorf(output.ExitAPI, "api_error", "API call failed: %s", err)
 	}

shortcuts/calendar/calendar_create.go

@@ -194,6 +194,7 @@ var CalendarCreate = common.Shortcut{
 		data, err := runtime.CallAPI("POST",
 			fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events", validate.EncodePathSegment(calendarId)),
 			nil, eventData)
+		err = wrapPredefinedError(err)
 		if err != nil {
 			return err
 		}
@@ -221,11 +222,13 @@ var CalendarCreate = common.Shortcut{
 					"attendees":         attendees,
 					"need_notification": true,
 				})
+			err = wrapPredefinedError(err)
 			if err != nil {
 				// Rollback: delete the event
 				_, rollbackErr := runtime.RawAPI("DELETE",
 					fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/%s", validate.EncodePathSegment(calendarId), validate.EncodePathSegment(eventId)),
 					map[string]interface{}{"need_notification": false}, nil)
+				rollbackErr = wrapPredefinedError(rollbackErr)
 				if rollbackErr != nil {
 					return output.Errorf(output.ExitAPI, "api_error", "failed to add attendees: %v; rollback also failed, orphan event_id=%s needs manual cleanup", rollbackErr, eventId)
 				}

shortcuts/calendar/calendar_freebusy.go

@@ -102,6 +102,7 @@ var CalendarFreebusy = common.Shortcut{
 			"user_id":          userId,
 			"need_rsvp_status": true,
 		})
+		err = wrapPredefinedError(err)
 		if err != nil {
 			return err
 		}

shortcuts/calendar/calendar_test.go

@@ -375,6 +375,238 @@ func TestCreate_NoEventIdReturned(t *testing.T) {
 	}
 }
 
+func TestCreate_CreateEvent_InvalidParamsWithDetail(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/calendar/v4/calendars/cal_test123/events",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+			"error": map[string]interface{}{
+				"details": []interface{}{
+					map[string]interface{}{"value": "end_time should be later than start_time"},
+				},
+			},
+		},
+	})
+
+	err := mountAndRun(t, CalendarCreate, []string{
+		"+create",
+		"--summary", "Bad Time",
+		"--start", "2025-03-21T10:00:00+08:00",
+		"--end", "2025-03-21T11:00:00+08:00",
+		"--calendar-id", "cal_test123",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+	if !strings.Contains(exitErr.Detail.Message, "end_time should be later than start_time") {
+		t.Errorf("expected detail value in message, got %q", exitErr.Detail.Message)
+	}
+}
+
+func TestCreate_CreateEvent_InvalidParamsWithoutDetailValue(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/calendar/v4/calendars/cal_test123/events",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+		},
+	})
+
+	err := mountAndRun(t, CalendarCreate, []string{
+		"+create",
+		"--summary", "Bad Time",
+		"--start", "2025-03-21T10:00:00+08:00",
+		"--end", "2025-03-21T11:00:00+08:00",
+		"--calendar-id", "cal_test123",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+}
+
+func TestCreate_CreateEvent_InvalidParams_ErrorNotMap(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method:      "POST",
+		URL:         "/open-apis/calendar/v4/calendars/cal_test123/events",
+		RawBody:     []byte(`{"code":190014,"msg":"invalid params","error":"just a string"}`),
+		ContentType: "text/plain",
+	})
+
+	err := mountAndRun(t, CalendarCreate, []string{
+		"+create",
+		"--summary", "Bad Time",
+		"--start", "2025-03-21T10:00:00+08:00",
+		"--end", "2025-03-21T11:00:00+08:00",
+		"--calendar-id", "cal_test123",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+}
+
+func TestCreate_CreateEvent_InvalidParams_NoDetailsKey(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/calendar/v4/calendars/cal_test123/events",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+			"error": map[string]interface{}{
+				"other_key": "no details here",
+			},
+		},
+	})
+
+	err := mountAndRun(t, CalendarCreate, []string{
+		"+create",
+		"--summary", "Bad Time",
+		"--start", "2025-03-21T10:00:00+08:00",
+		"--end", "2025-03-21T11:00:00+08:00",
+		"--calendar-id", "cal_test123",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+}
+
+func TestCreate_CreateEvent_InvalidParams_DetailItemNotMap(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/calendar/v4/calendars/cal_test123/events",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+			"error": map[string]interface{}{
+				"details": []interface{}{nil},
+			},
+		},
+	})
+
+	err := mountAndRun(t, CalendarCreate, []string{
+		"+create",
+		"--summary", "Bad Time",
+		"--start", "2025-03-21T10:00:00+08:00",
+		"--end", "2025-03-21T11:00:00+08:00",
+		"--calendar-id", "cal_test123",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+}
+
+func TestCreate_WithAttendees_InvalidParamsWithDetail_RollsBack(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/calendar/v4/calendars/cal_test123/events",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"event": map[string]interface{}{
+					"event_id":   "evt_190014",
+					"summary":    "Bad Attendees",
+					"start_time": map[string]interface{}{"timestamp": "1742515200"},
+					"end_time":   map[string]interface{}{"timestamp": "1742518800"},
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/events/evt_190014/attendees",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+			"error": map[string]interface{}{
+				"details": []interface{}{
+					map[string]interface{}{"value": "invalid attendee open_id"},
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "DELETE",
+		URL:    "/events/evt_190014",
+		Body:   map[string]interface{}{"code": 0, "msg": "ok"},
+	})
+
+	err := mountAndRun(t, CalendarCreate, []string{
+		"+create",
+		"--summary", "Bad Attendees",
+		"--start", "2025-03-21T00:00:00+08:00",
+		"--end", "2025-03-21T01:00:00+08:00",
+		"--calendar-id", "cal_test123",
+		"--attendee-ids", "ou_invalid",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for invalid attendees with 190014, got nil")
+	}
+	if !strings.Contains(err.Error(), "invalid attendee open_id") {
+		t.Errorf("expected detail value in error, got: %v", err)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // CalendarAgenda tests
 // ---------------------------------------------------------------------------
@@ -645,6 +877,67 @@ func TestAgenda_ExplicitCalendarId(t *testing.T) {
 	}
 }
 
+func TestAgenda_InvalidParamsWithDetail(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/events/instance_view",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+			"error": map[string]interface{}{
+				"details": []interface{}{
+					map[string]interface{}{"value": "start_time is required"},
+				},
+			},
+		},
+	})
+
+	err := mountAndRun(t, CalendarAgenda, []string{
+		"+agenda",
+		"--start", "2025-03-21",
+		"--end", "2025-03-21",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+}
+
+func TestAgenda_NonExitError_Passthrough(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method:  "GET",
+		URL:     "/events/instance_view",
+		RawBody: []byte("this is not json"),
+	})
+
+	err := mountAndRun(t, CalendarAgenda, []string{
+		"+agenda",
+		"--start", "2025-03-21",
+		"--end", "2025-03-21",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for non-JSON response, got nil")
+	}
+	var exitErr *output.ExitError
+	if errors.As(err, &exitErr) && exitErr.Detail != nil && exitErr.Detail.Code != 0 {
+		t.Fatalf("expected non-API error passthrough, got API error code %d", exitErr.Detail.Code)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // CalendarFreebusy tests
 // ---------------------------------------------------------------------------
@@ -725,6 +1018,46 @@ func TestFreebusy_APIError(t *testing.T) {
 	}
 }
 
+func TestFreebusy_InvalidParamsWithDetail(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/calendar/v4/freebusy/list",
+		Body: map[string]interface{}{
+			"code": errCodeInvalidParamsWithDetail,
+			"msg":  "invalid params",
+			"error": map[string]interface{}{
+				"details": []interface{}{
+					map[string]interface{}{"value": "user_id is invalid"},
+				},
+			},
+		},
+	})
+
+	err := mountAndRun(t, CalendarFreebusy, []string{
+		"+freebusy",
+		"--start", "2025-03-21",
+		"--end", "2025-03-21",
+		"--user-id", "ou_someone",
+		"--as", "bot",
+	}, f, nil)
+
+	if err == nil {
+		t.Fatal("expected error for 190014, got nil")
+	}
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) {
+		t.Fatalf("expected *output.ExitError, got %T", err)
+	}
+	if exitErr.Detail.Code != errCodeInvalidParamsWithDetail {
+		t.Errorf("expected code %d, got %d", errCodeInvalidParamsWithDetail, exitErr.Detail.Code)
+	}
+	if !strings.Contains(exitErr.Detail.Message, "user_id is invalid") {
+		t.Errorf("expected detail value in message, got %q", exitErr.Detail.Message)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // CalendarSuggestion tests
 // ---------------------------------------------------------------------------

shortcuts/calendar/errors.go

@@ -0,0 +1,66 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package calendar
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/larksuite/cli/internal/output"
+)
+
+const (
+	errCodeInvalidParamsWithDetail = 190014
+)
+
+// getErrorDetailValue extracts the first detail value from the output.ErrDetail.
+// It assumes Detail is a map containing a "details" array of objects with "value" string fields.
+// For example: {"details": [{"value": "error message 1"}, {"value": "error message 2"}]}
+// Returns an empty string if the structure doesn't match or the array is empty.
+func getErrorDetailValue(e *output.ErrDetail) string {
+	if e == nil || e.Detail == nil {
+		return ""
+	}
+
+	errMap, ok := e.Detail.(map[string]interface{})
+	if !ok {
+		return ""
+	}
+
+	details, ok := errMap["details"].([]interface{})
+	if !ok || len(details) == 0 {
+		return ""
+	}
+
+	detailObj, ok := details[0].(map[string]interface{})
+	if !ok {
+		return ""
+	}
+
+	val, _ := detailObj["value"].(string)
+	return val
+}
+
+// wrapPredefinedError wraps an error into *output.ExitError if it matches predefined error codes.
+// Currently handles error code 190014 (invalid params with detail), extracting the detail value into the message.
+// If the error is nil or doesn't match predefined codes, returns the original error.
+func wrapPredefinedError(err error) error {
+	if err == nil {
+		return nil
+	}
+
+	var exitErr *output.ExitError
+	if !errors.As(err, &exitErr) || exitErr.Detail == nil {
+		return err
+	}
+
+	if exitErr.Detail.Code == errCodeInvalidParamsWithDetail {
+		if val := getErrorDetailValue(exitErr.Detail); val != "" {
+			fullMsg := fmt.Sprintf("%s: %s", exitErr.Detail.Message, val)
+			return output.ErrAPI(exitErr.Detail.Code, fullMsg, exitErr.Detail.Detail)
+		}
+	}
+
+	return err
+}

shortcuts/common/drive_media_upload.go

@@ -37,6 +37,10 @@ type DriveMediaUploadAllConfig struct {
 	ParentType string
 	ParentNode *string
 	Extra      string
+	// Reader, when non-nil, is used as the upload source instead of opening
+	// FilePath. Callers must set FileName and FileSize explicitly. The reader
+	// is NOT closed by UploadDriveMediaAll; the caller owns its lifetime.
+	Reader io.Reader
 }
 
 type DriveMediaMultipartUploadConfig struct {
@@ -49,11 +53,17 @@ type DriveMediaMultipartUploadConfig struct {
 }
 
 func UploadDriveMediaAll(runtime *RuntimeContext, cfg DriveMediaUploadAllConfig) (string, error) {
-	f, err := runtime.FileIO().Open(cfg.FilePath)
-	if err != nil {
-		return "", WrapInputStatError(err)
+	var fileReader io.Reader
+	if cfg.Reader != nil {
+		fileReader = cfg.Reader
+	} else {
+		f, err := runtime.FileIO().Open(cfg.FilePath)
+		if err != nil {
+			return "", WrapInputStatError(err)
+		}
+		defer f.Close()
+		fileReader = f
 	}
-	defer f.Close()
 
 	fd := larkcore.NewFormdata()
 	fd.AddField("file_name", cfg.FileName)
@@ -65,7 +75,7 @@ func UploadDriveMediaAll(runtime *RuntimeContext, cfg DriveMediaUploadAllConfig)
 	if cfg.Extra != "" {
 		fd.AddField("extra", cfg.Extra)
 	}
-	fd.AddFile("file", f)
+	fd.AddFile("file", fileReader)
 
 	apiResp, err := runtime.DoAPI(&larkcore.ApiReq{
 		HttpMethod: http.MethodPost,

shortcuts/common/runner.go

@@ -181,6 +181,12 @@ func (ctx *RuntimeContext) StrArray(name string) []string {
 	return v
 }
 
+// StrSlice returns a string-slice flag value (supports CSV splitting and repeated flags).
+func (ctx *RuntimeContext) StrSlice(name string) []string {
+	v, _ := ctx.Cmd.Flags().GetStringSlice(name)
+	return v
+}
+
 // ── API helpers ──
 
 //	CallAPI uses an internal HTTP wrapper with limited control over request/response.
@@ -571,12 +577,16 @@ func enhancePermissionError(err error, requiredScopes []string) error {
 
 // Mount registers the shortcut on a parent command.
 func (s Shortcut) Mount(parent *cobra.Command, f *cmdutil.Factory) {
+	s.MountWithContext(context.Background(), parent, f)
+}
+
+func (s Shortcut) MountWithContext(ctx context.Context, parent *cobra.Command, f *cmdutil.Factory) {
 	if s.Execute != nil {
-		s.mountDeclarative(parent, f)
+		s.mountDeclarative(ctx, parent, f)
 	}
 }
 
-func (s Shortcut) mountDeclarative(parent *cobra.Command, f *cmdutil.Factory) {
+func (s Shortcut) mountDeclarative(ctx context.Context, parent *cobra.Command, f *cmdutil.Factory) {
 	shortcut := s
 	if len(shortcut.AuthTypes) == 0 {
 		shortcut.AuthTypes = []string{"user"}
@@ -592,7 +602,7 @@ func (s Shortcut) mountDeclarative(parent *cobra.Command, f *cmdutil.Factory) {
 		},
 	}
 	cmdutil.SetSupportedIdentities(cmd, shortcut.AuthTypes)
-	registerShortcutFlags(cmd, &shortcut)
+	registerShortcutFlagsWithContext(ctx, cmd, f, &shortcut)
 	cmdutil.SetTips(cmd, shortcut.Tips)
 	parent.AddCommand(cmd)
 }
@@ -823,7 +833,11 @@ func rejectPositionalArgs() cobra.PositionalArgs {
 	}
 }
 
-func registerShortcutFlags(cmd *cobra.Command, s *Shortcut) {
+func registerShortcutFlags(cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut) {
+	registerShortcutFlagsWithContext(context.Background(), cmd, f, s)
+}
+
+func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut) {
 	for _, fl := range s.Flags {
 		desc := fl.Desc
 		if len(fl.Enum) > 0 {
@@ -849,6 +863,8 @@ func registerShortcutFlags(cmd *cobra.Command, s *Shortcut) {
 			cmd.Flags().Int(fl.Name, d, desc)
 		case "string_array":
 			cmd.Flags().StringArray(fl.Name, nil, desc)
+		case "string_slice":
+			cmd.Flags().StringSlice(fl.Name, nil, desc)
 		default:
 			cmd.Flags().String(fl.Name, fl.Default, desc)
 		}
@@ -860,7 +876,7 @@ func registerShortcutFlags(cmd *cobra.Command, s *Shortcut) {
 		}
 		if len(fl.Enum) > 0 {
 			vals := fl.Enum
-			_ = cmd.RegisterFlagCompletionFunc(fl.Name, func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+			cmdutil.RegisterFlagCompletion(cmd, fl.Name, func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 				return vals, cobra.ShellCompDirectiveNoFileComp
 			})
 		}
@@ -874,13 +890,9 @@ func registerShortcutFlags(cmd *cobra.Command, s *Shortcut) {
 		cmd.Flags().Bool("yes", false, "confirm high-risk operation")
 	}
 	cmd.Flags().StringP("jq", "q", "", "jq expression to filter JSON output")
-	cmd.Flags().String("as", s.AuthTypes[0], "identity type: user | bot")
-
-	_ = cmd.RegisterFlagCompletionFunc("as", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return s.AuthTypes, cobra.ShellCompDirectiveNoFileComp
-	})
+	cmdutil.AddShortcutIdentityFlag(ctx, cmd, f, s.AuthTypes)
 	if s.HasFormat {
-		_ = cmd.RegisterFlagCompletionFunc("format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+		cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 			return []string{"json", "pretty", "table", "ndjson", "csv"}, cobra.ShellCompDirectiveNoFileComp
 		})
 	}

shortcuts/common/runner_flag_completion_test.go

@@ -0,0 +1,98 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package common
+
+import (
+	"context"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+// TestShortcutMount_FlagCompletionsRegistered exercises the two
+// cmdutil.RegisterFlagCompletion call sites in registerShortcutFlagsWithContext:
+// the per-flag enum completion (runner.go:879) and the auto-injected --format
+// completion (runner.go:895).
+func TestShortcutMount_FlagCompletionsRegistered(t *testing.T) {
+	t.Cleanup(func() { cmdutil.SetFlagCompletionsDisabled(false) })
+	cmdutil.SetFlagCompletionsDisabled(false)
+
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	parent := &cobra.Command{Use: "root"}
+	shortcut := Shortcut{
+		Service:     "docs",
+		Command:     "+fetch",
+		Description: "fetch doc",
+		HasFormat:   true,
+		Flags: []Flag{
+			{Name: "sort-by", Desc: "sort", Enum: []string{"asc", "desc"}},
+		},
+		Execute: func(context.Context, *RuntimeContext) error { return nil },
+	}
+	shortcut.Mount(parent, f)
+
+	cmd, _, err := parent.Find([]string{"+fetch"})
+	if err != nil {
+		t.Fatalf("Find() error = %v", err)
+	}
+
+	// Enum flag completion.
+	fn, ok := cmd.GetFlagCompletionFunc("sort-by")
+	if !ok {
+		t.Fatal("expected completion func for --sort-by")
+	}
+	got, _ := fn(cmd, nil, "")
+	if len(got) != 2 || got[0] != "asc" || got[1] != "desc" {
+		t.Fatalf("sort-by completion = %v, want [asc desc]", got)
+	}
+
+	// HasFormat-injected --format completion.
+	fn, ok = cmd.GetFlagCompletionFunc("format")
+	if !ok {
+		t.Fatal("expected completion func for --format")
+	}
+	got, _ = fn(cmd, nil, "")
+	want := []string{"json", "pretty", "table", "ndjson", "csv"}
+	if len(got) != len(want) {
+		t.Fatalf("format completion = %v, want %v", got, want)
+	}
+	for i, v := range want {
+		if got[i] != v {
+			t.Fatalf("format completion[%d] = %q, want %q", i, got[i], v)
+		}
+	}
+}
+
+// TestShortcutMount_FlagCompletionsDisabled verifies the switch actually
+// prevents the two registrations from landing in cobra's global map.
+func TestShortcutMount_FlagCompletionsDisabled(t *testing.T) {
+	t.Cleanup(func() { cmdutil.SetFlagCompletionsDisabled(false) })
+	cmdutil.SetFlagCompletionsDisabled(true)
+
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	parent := &cobra.Command{Use: "root"}
+	shortcut := Shortcut{
+		Service:     "docs",
+		Command:     "+fetch",
+		Description: "fetch doc",
+		HasFormat:   true,
+		Flags: []Flag{
+			{Name: "sort-by", Desc: "sort", Enum: []string{"asc", "desc"}},
+		},
+		Execute: func(context.Context, *RuntimeContext) error { return nil },
+	}
+	shortcut.Mount(parent, f)
+
+	cmd, _, err := parent.Find([]string{"+fetch"})
+	if err != nil {
+		t.Fatalf("Find() error = %v", err)
+	}
+	if _, ok := cmd.GetFlagCompletionFunc("sort-by"); ok {
+		t.Fatal("did not expect completion func for --sort-by when disabled")
+	}
+	if _, ok := cmd.GetFlagCompletionFunc("format"); ok {
+		t.Fatal("did not expect completion func for --format when disabled")
+	}
+}

shortcuts/common/runner_identity_flag_test.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package common
+
+import (
+	"context"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/spf13/cobra"
+)
+
+func TestShortcutMount_StrictModeHidesAsFlag(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu, SupportedIdentities: 2,
+	})
+	parent := &cobra.Command{Use: "root"}
+	shortcut := Shortcut{
+		Service:     "docs",
+		Command:     "+fetch",
+		Description: "fetch doc",
+		AuthTypes:   []string{"user", "bot"},
+		Execute: func(context.Context, *RuntimeContext) error {
+			return nil
+		},
+	}
+
+	shortcut.Mount(parent, f)
+	cmd, _, err := parent.Find([]string{"+fetch"})
+	if err != nil {
+		t.Fatalf("Find() error = %v", err)
+	}
+	flag := cmd.Flags().Lookup("as")
+	if flag == nil {
+		t.Fatal("expected --as flag to be registered")
+	}
+	if !flag.Hidden {
+		t.Fatal("expected --as flag to be hidden in strict mode")
+	}
+	if got := flag.DefValue; got != "bot" {
+		t.Fatalf("default value = %q, want %q", got, "bot")
+	}
+}

shortcuts/common/runner_jq_test.go

@@ -145,10 +145,10 @@ func TestRuntimeContext_FileIO_UsesExecutionContext(t *testing.T) {
 	}
 }
 
-func newTestShortcutCmd(s *Shortcut) *cobra.Command {
+func newTestShortcutCmd(s *Shortcut, f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{Use: "test-shortcut"}
 	cmd.SetContext(context.Background())
-	registerShortcutFlags(cmd, s)
+	registerShortcutFlags(cmd, f, s)
 	return cmd
 }
 
@@ -177,7 +177,7 @@ func TestRunShortcut_JqAndFormatConflict(t *testing.T) {
 			return nil
 		},
 	}
-	cmd := newTestShortcutCmd(s)
+	cmd := newTestShortcutCmd(s, newTestFactory())
 	cmd.Flags().Set("jq", ".data")
 	cmd.Flags().Set("format", "table")
 	cmd.Flags().Set("as", "bot")
@@ -200,7 +200,7 @@ func TestRunShortcut_JqInvalidExpression(t *testing.T) {
 			return nil
 		},
 	}
-	cmd := newTestShortcutCmd(s)
+	cmd := newTestShortcutCmd(s, newTestFactory())
 	cmd.Flags().Set("jq", "invalid[")
 	cmd.Flags().Set("as", "bot")
 
@@ -223,7 +223,7 @@ func TestRunShortcut_JqRuntimeError_PropagatesError(t *testing.T) {
 			return nil
 		},
 	}
-	cmd := newTestShortcutCmd(s)
+	cmd := newTestShortcutCmd(s, newTestFactory())
 	cmd.Flags().Set("jq", ".foo | invalid_func_xyz")
 	cmd.Flags().Set("as", "bot")
 

shortcuts/doc/doc_media_insert.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	"strings"
 
 	"github.com/larksuite/cli/extension/fileio"
 	"github.com/larksuite/cli/internal/output"
@@ -35,7 +36,7 @@ var fileViewMap = map[string]int{
 var DocMediaInsert = common.Shortcut{
 	Service:     "docs",
 	Command:     "+media-insert",
-	Description: "Insert a local image or file at the end of a Lark document (4-step orchestration + auto-rollback)",
+	Description: "Insert a local image or file into a Lark document (4-step orchestration + auto-rollback); appends to end by default, or inserts relative to a text selection with --selection-with-ellipsis",
 	Risk:        "write",
 	Scopes:      []string{"docs:document.media:upload", "docx:document:write_only", "docx:document:readonly"},
 	AuthTypes:   []string{"user", "bot"},
@@ -45,6 +46,8 @@ var DocMediaInsert = common.Shortcut{
 		{Name: "type", Default: "image", Desc: "type: image | file"},
 		{Name: "align", Desc: "alignment: left | center | right"},
 		{Name: "caption", Desc: "image caption text"},
+		{Name: "selection-with-ellipsis", Desc: "plain text (or 'start...end' to disambiguate) matching the target block's content. Media is inserted at the top-level ancestor of the matched block — i.e., when the selection is inside a callout, table cell, or nested list, media lands outside that container, not inside it. Pass 'start...end' (a unique prefix and suffix separated by '...') when the plain text appears in more than one block"},
+		{Name: "before", Type: "bool", Desc: "insert before the matched block instead of after (requires --selection-with-ellipsis)"},
 		{Name: "file-view", Desc: "file block rendering: card (default) | preview | inline; only applies when --type=file. preview renders audio/video as an inline player"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -55,6 +58,18 @@ var DocMediaInsert = common.Shortcut{
 		if docRef.Kind == "doc" {
 			return output.ErrValidation("docs +media-insert only supports docx documents; use a docx token/URL or a wiki URL that resolves to docx")
 		}
+		rawSelection := runtime.Str("selection-with-ellipsis")
+		trimmedSelection := strings.TrimSpace(rawSelection)
+		// Explicitly reject a flag that was supplied but blank: runtime.Str cannot
+		// distinguish "omitted" from "provided as empty/whitespace", and a silent
+		// trim-to-empty would make +media-insert fall back to append-mode and
+		// write at the wrong location.
+		if rawSelection != "" && trimmedSelection == "" {
+			return output.ErrValidation("--selection-with-ellipsis must not be blank or whitespace-only")
+		}
+		if runtime.Bool("before") && trimmedSelection == "" {
+			return output.ErrValidation("--before requires --selection-with-ellipsis")
+		}
 		if view := runtime.Str("file-view"); view != "" {
 			if _, ok := fileViewMap[view]; !ok {
 				return output.ErrValidation("invalid --file-view value %q, expected one of: card | preview | inline", view)
@@ -76,30 +91,71 @@ var DocMediaInsert = common.Shortcut{
 		filePath := runtime.Str("file")
 		mediaType := runtime.Str("type")
 		caption := runtime.Str("caption")
+		selection := strings.TrimSpace(runtime.Str("selection-with-ellipsis"))
+		hasSelection := selection != ""
 		fileViewType := fileViewMap[runtime.Str("file-view")]
 
 		parentType := parentTypeForMediaType(mediaType)
 		createBlockData := buildCreateBlockData(mediaType, 0, fileViewType)
-		createBlockData["index"] = "<children_len>"
+		if hasSelection {
+			createBlockData["index"] = "<locate_index>"
+		} else {
+			createBlockData["index"] = "<children_len>"
+		}
 		batchUpdateData := buildBatchUpdateData("<new_block_id>", mediaType, "<file_token>", runtime.Str("align"), caption)
 
 		d := common.NewDryRunAPI()
+		totalSteps := 4
+		if docRef.Kind == "wiki" {
+			totalSteps++
+		}
+		if hasSelection {
+			totalSteps++
+		}
+
+		positionLabel := map[bool]string{true: "before", false: "after"}[runtime.Bool("before")]
+
 		if docRef.Kind == "wiki" {
 			documentID = "<resolved_docx_token>"
 			stepBase = 2
-			d.Desc("5-step orchestration: resolve wiki → query root → create block → upload file → bind to block (auto-rollback on failure)").
+			d.Desc(fmt.Sprintf("%d-step orchestration: resolve wiki → query root →%s create block → upload file → bind to block (auto-rollback on failure)",
+				totalSteps, map[bool]string{true: " locate-doc →", false: ""}[hasSelection])).
 				GET("/open-apis/wiki/v2/spaces/get_node").
 				Desc("[1] Resolve wiki node to docx document").
 				Params(map[string]interface{}{"token": docRef.Token})
 		} else {
-			d.Desc("4-step orchestration: query root → create block → upload file → bind to block (auto-rollback on failure)")
+			d.Desc(fmt.Sprintf("%d-step orchestration: query root →%s create block → upload file → bind to block (auto-rollback on failure)",
+				totalSteps, map[bool]string{true: " locate-doc →", false: ""}[hasSelection]))
 		}
 
 		d.
 			GET("/open-apis/docx/v1/documents/:document_id/blocks/:document_id").
-			Desc(fmt.Sprintf("[%d] Get document root block", stepBase)).
+			Desc(fmt.Sprintf("[%d] Get document root block", stepBase))
+
+		if hasSelection {
+			mcpEndpoint := common.MCPEndpoint(runtime.Config.Brand)
+			mcpArgs := map[string]interface{}{
+				"doc_id":                  documentID,
+				"selection_with_ellipsis": selection,
+				"limit":                   1,
+			}
+			d.POST(mcpEndpoint).
+				Desc(fmt.Sprintf("[%d] MCP locate-doc: find block matching selection (%s)", stepBase+1, positionLabel)).
+				Body(map[string]interface{}{
+					"method": "tools/call",
+					"params": map[string]interface{}{
+						"name":      "locate-doc",
+						"arguments": mcpArgs,
+					},
+				}).
+				Set("mcp_tool", "locate-doc").
+				Set("args", mcpArgs)
+			stepBase++
+		}
+
+		d.
 			POST("/open-apis/docx/v1/documents/:document_id/blocks/:document_id/children").
-			Desc(fmt.Sprintf("[%d] Create empty block at document end", stepBase+1)).
+			Desc(fmt.Sprintf("[%d] Create empty block at target position", stepBase+1)).
 			Body(createBlockData)
 		appendDocMediaInsertUploadDryRun(d, runtime.FileIO(), filePath, parentType, stepBase+2)
 		d.PATCH("/open-apis/docx/v1/documents/:document_id/blocks/batch_update").
@@ -144,13 +200,31 @@ var DocMediaInsert = common.Shortcut{
 			return err
 		}
 
-		parentBlockID, insertIndex, err := extractAppendTarget(rootData, documentID)
+		parentBlockID, insertIndex, rootChildren, err := extractAppendTarget(rootData, documentID)
 		if err != nil {
 			return err
 		}
 		fmt.Fprintf(runtime.IO().ErrOut, "Root block ready: %s (%d children)\n", parentBlockID, insertIndex)
 
-		// Step 2: Create an empty block at the end of the document
+		selection := strings.TrimSpace(runtime.Str("selection-with-ellipsis"))
+		if selection != "" {
+			before := runtime.Bool("before")
+			// Redact the selection when logging — it is copied verbatim from
+			// document content and may contain confidential text.
+			fmt.Fprintf(runtime.IO().ErrOut, "Locating block matching selection (%s)\n", redactSelection(selection))
+			idx, err := locateInsertIndex(runtime, documentID, selection, rootChildren, before)
+			if err != nil {
+				return err
+			}
+			insertIndex = idx
+			posLabel := "after"
+			if before {
+				posLabel = "before"
+			}
+			fmt.Fprintf(runtime.IO().ErrOut, "locate-doc matched: inserting %s at index %d\n", posLabel, insertIndex)
+		}
+
+		// Step 2: Create an empty block at the target position
 		fmt.Fprintf(runtime.IO().ErrOut, "Creating block at index %d\n", insertIndex)
 
 		createData, err := runtime.CallAPI("POST",
@@ -224,6 +298,20 @@ func blockTypeForMediaType(mediaType string) int {
 	return 27
 }
 
+// redactSelection summarizes --selection-with-ellipsis values for logging and
+// error messages without echoing raw document text. Returns the rune count and,
+// for longer strings, a short prefix so operators can still identify which
+// selection failed without leaking confidential content into terminals or CI
+// logs.
+func redactSelection(s string) string {
+	const prefixRunes = 8
+	runes := []rune(s)
+	if len(runes) <= prefixRunes {
+		return fmt.Sprintf("%d chars", len(runes))
+	}
+	return fmt.Sprintf("%q… %d chars total", string(runes[:prefixRunes]), len(runes))
+}
+
 func parentTypeForMediaType(mediaType string) string {
 	if mediaType == "file" {
 		return "docx_file"
@@ -332,19 +420,150 @@ func buildBatchUpdateData(blockID, mediaType, fileToken, alignStr, caption strin
 	}
 }
 
-func extractAppendTarget(rootData map[string]interface{}, fallbackBlockID string) (string, int, error) {
+func extractAppendTarget(rootData map[string]interface{}, fallbackBlockID string) (parentBlockID string, insertIndex int, children []interface{}, err error) {
 	block, _ := rootData["block"].(map[string]interface{})
 	if len(block) == 0 {
-		return "", 0, output.Errorf(output.ExitAPI, "api_error", "failed to query document root block")
+		return "", 0, nil, output.Errorf(output.ExitAPI, "api_error", "failed to query document root block")
 	}
 
-	parentBlockID := fallbackBlockID
+	parentBlockID = fallbackBlockID
 	if blockID, _ := block["block_id"].(string); blockID != "" {
 		parentBlockID = blockID
 	}
 
-	children, _ := block["children"].([]interface{})
-	return parentBlockID, len(children), nil
+	children, _ = block["children"].([]interface{})
+	return parentBlockID, len(children), children, nil
+}
+
+// locateInsertIndex uses the MCP locate-doc tool to find the root-level index
+// at which to insert relative to the block matching selection. It walks the
+// parent_id chain (using single-block GET calls when needed) to resolve nested
+// blocks to their top-level ancestor in rootChildren.
+func locateInsertIndex(runtime *common.RuntimeContext, documentID string, selection string, rootChildren []interface{}, before bool) (int, error) {
+	// Ask for 2 matches so we can warn when the selection is ambiguous. locate-doc
+	// orders matches by document position, so matches[0] is still deterministic.
+	args := map[string]interface{}{
+		"doc_id":                  documentID,
+		"selection_with_ellipsis": selection,
+		"limit":                   2,
+	}
+	result, err := common.CallMCPTool(runtime, "locate-doc", args)
+	if err != nil {
+		return 0, err
+	}
+
+	matches := common.GetSlice(result, "matches")
+	if len(matches) == 0 {
+		return 0, output.ErrWithHint(
+			output.ExitValidation,
+			"no_match",
+			fmt.Sprintf("locate-doc did not find any block matching selection (%s)", redactSelection(selection)),
+			"check spelling or use 'start...end' syntax to narrow the selection",
+		)
+	}
+	if len(matches) > 1 {
+		// Silently picking the first match surprises users whose selection appears
+		// in more than one block (e.g. the same phrase in a title and a paragraph).
+		// Surface that another match exists and point at the 'start...end' disambiguator.
+		fmt.Fprintf(runtime.IO().ErrOut,
+			"warning: selection (%s) matched more than one block; inserting relative to the first. "+
+				"Pass --selection-with-ellipsis 'start...end' to narrow.\n",
+			redactSelection(selection))
+	}
+
+	matchMap, _ := matches[0].(map[string]interface{})
+	anchorBlockID := common.GetString(matchMap, "anchor_block_id")
+	if anchorBlockID == "" {
+		// Fall back to first block entry if anchor_block_id is absent.
+		blocks := common.GetSlice(matchMap, "blocks")
+		if len(blocks) > 0 {
+			if b, ok := blocks[0].(map[string]interface{}); ok {
+				anchorBlockID = common.GetString(b, "block_id")
+			}
+		}
+	}
+	if anchorBlockID == "" {
+		return 0, output.Errorf(output.ExitAPI, "api_error", "locate-doc response missing anchor_block_id")
+	}
+	parentBlockID := common.GetString(matchMap, "parent_block_id")
+
+	// Build root children set for O(1) lookup.
+	rootSet := make(map[string]int, len(rootChildren))
+	for i, c := range rootChildren {
+		if id, ok := c.(string); ok {
+			rootSet[id] = i
+		}
+	}
+
+	// Walk up the parent chain to the top-level ancestor in rootChildren. This
+	// is serial by nature: each level's parent_id is only known after the
+	// previous level's GET /blocks/{id} response arrives, so the calls cannot
+	// be batched or parallelised.
+	//
+	// visited is the real cycle guard — it stops an A→B→A parent-id loop (seen
+	// on malformed API responses) after one lap. maxDepth is belt-and-suspenders
+	// in case both visited tracking and parent_id sanity simultaneously break;
+	// 32 comfortably exceeds the deepest real docx nesting (~6–8 levels for
+	// quote/callout/list combinations) without letting a bug run unbounded.
+	cur := anchorBlockID
+	nextParent := parentBlockID
+	visited := map[string]bool{}
+	const maxDepth = 32
+	walkDepth := 0
+	for depth := 0; depth < maxDepth; depth++ {
+		if visited[cur] {
+			break
+		}
+		visited[cur] = true
+
+		if idx, ok := rootSet[cur]; ok {
+			if walkDepth > 0 {
+				// The anchor was nested inside a callout / table cell / list and
+				// got resolved to its top-level ancestor. Surface this so users
+				// don't misread "insert before 'X'" as "insert right next to X"
+				// when X is buried several levels deep.
+				posLabel := "after"
+				if before {
+					posLabel = "before"
+				}
+				fmt.Fprintf(runtime.IO().ErrOut,
+					"note: selection (%s) was nested %d level(s) deep; inserting %s its top-level ancestor at index %d\n",
+					redactSelection(selection), walkDepth, posLabel, idx)
+			}
+			if before {
+				return idx, nil
+			}
+			return idx + 1, nil
+		}
+
+		// Advance: use the parent hint we already have, or fetch from API.
+		parent := nextParent
+		nextParent = "" // clear hint after first use
+		if parent == "" || parent == cur {
+			// Need to fetch this block to find its parent.
+			data, err := runtime.CallAPI("GET",
+				fmt.Sprintf("/open-apis/docx/v1/documents/%s/blocks/%s",
+					validate.EncodePathSegment(documentID), validate.EncodePathSegment(cur)),
+				nil, nil)
+			if err != nil {
+				return 0, err
+			}
+			block := common.GetMap(data, "block")
+			parent = common.GetString(block, "parent_id")
+		}
+		if parent == "" || parent == cur {
+			break
+		}
+		cur = parent
+		walkDepth++
+	}
+
+	return 0, output.ErrWithHint(
+		output.ExitValidation,
+		"block_not_reachable",
+		fmt.Sprintf("block matching selection (%s) is not reachable from document root", redactSelection(selection)),
+		"try a top-level heading or paragraph as the selection",
+	)
 }
 
 func extractCreatedBlockTargets(createData map[string]interface{}, mediaType string) (blockID, uploadParentNode, replaceBlockID string) {

shortcuts/doc/doc_media_insert_test.go

@@ -5,12 +5,15 @@ package doc
 
 import (
 	"context"
+	"encoding/json"
 	"reflect"
 	"strings"
 	"testing"
 
 	"github.com/spf13/cobra"
 
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
@@ -222,7 +225,7 @@ func TestExtractAppendTargetUsesRootChildrenCount(t *testing.T) {
 		},
 	}
 
-	blockID, index, err := extractAppendTarget(rootData, "fallback")
+	blockID, index, children, err := extractAppendTarget(rootData, "fallback")
 	if err != nil {
 		t.Fatalf("extractAppendTarget() unexpected error: %v", err)
 	}
@@ -232,6 +235,365 @@ func TestExtractAppendTargetUsesRootChildrenCount(t *testing.T) {
 	if index != 3 {
 		t.Fatalf("extractAppendTarget() index = %d, want 3", index)
 	}
+	if len(children) != 3 {
+		t.Fatalf("extractAppendTarget() children len = %d, want 3", len(children))
+	}
+}
+
+// buildLocateDocMCPResponse builds a JSON-RPC 2.0 response for a locate-doc MCP call.
+func buildLocateDocMCPResponse(matches []map[string]interface{}) map[string]interface{} {
+	resultJSON, _ := json.Marshal(map[string]interface{}{"matches": matches})
+	return map[string]interface{}{
+		"jsonrpc": "2.0",
+		"id":      "test-id",
+		"result": map[string]interface{}{
+			"content": []interface{}{
+				map[string]interface{}{
+					"type": "text",
+					"text": string(resultJSON),
+				},
+			},
+		},
+	}
+}
+
+// registerInsertWithSelectionStubs wires the minimal stub set for the
+// --selection-with-ellipsis happy path. Returns the create-block stub so
+// callers can inspect the request body (e.g. to verify the computed index).
+func registerInsertWithSelectionStubs(reg interface {
+	Register(*httpmock.Stub)
+}, docID, anchorBlockID, parentBlockID string, rootChildren []interface{}) *httpmock.Stub {
+	// Root block
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID,
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id": docID,
+					"children": rootChildren,
+				},
+			},
+		},
+	})
+	// MCP locate-doc
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "mcp.feishu.cn/mcp",
+		Body: buildLocateDocMCPResponse([]map[string]interface{}{
+			{"anchor_block_id": anchorBlockID, "parent_block_id": parentBlockID},
+		}),
+	})
+	// Create block — returned so the test can inspect index in CapturedBody.
+	createStub := &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID + "/children",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"children": []interface{}{
+					map[string]interface{}{"block_id": "blk_new", "block_type": 27, "image": map[string]interface{}{}},
+				},
+			},
+		},
+	}
+	reg.Register(createStub)
+	// Upload
+	reg.Register(&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": "ftok_test"},
+		},
+	})
+	// Batch update
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/batch_update",
+		Body:   map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
+	})
+	return createStub
+}
+
+// assertCreateBlockIndex decodes the create-block request body and asserts the
+// `index` field equals want. Fails the test if the body is missing or wrong.
+func assertCreateBlockIndex(t *testing.T, stub *httpmock.Stub, want int) {
+	t.Helper()
+	if stub.CapturedBody == nil {
+		t.Fatalf("create-block stub captured no body")
+	}
+	var body map[string]interface{}
+	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
+		t.Fatalf("decode create-block body: %v (raw: %s)", err, stub.CapturedBody)
+	}
+	got, _ := body["index"].(float64)
+	if int(got) != want {
+		t.Fatalf("create-block index = %v, want %d (body: %s)", body["index"], want, stub.CapturedBody)
+	}
+}
+
+// TestLocateInsertIndexAfterModeViaExecute verifies that
+// --selection-with-ellipsis (default after-mode) places the new block
+// immediately after the matched root-level block. Uses three root children so
+// the after-index (2) differs from what --before would produce (1), and
+// inspects the create-block request body to prove the computed index actually
+// reaches the /children API.
+func TestLocateInsertIndexAfterModeViaExecute(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-after-app"))
+	createStub := registerInsertWithSelectionStubs(reg, "doxcnSEL", "blk_b", "doxcnSEL",
+		[]interface{}{"blk_a", "blk_b", "blk_c"})
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", "doxcnSEL",
+		"--file", "img.png",
+		"--selection-with-ellipsis", "Introduction",
+		"--as", "bot",
+	}, f, nil)
+	if err != nil {
+		t.Fatalf("Execute() error: %v", err)
+	}
+	// after blk_b (index 1) → insert at index 2, between blk_b and blk_c.
+	assertCreateBlockIndex(t, createStub, 2)
+}
+
+// TestLocateInsertIndexBeforeModeViaExecute verifies that --before inserts
+// before the matched root-level block. Pairs with the after-mode test above:
+// same fixture, same anchor, but --before should flip the index from 2 to 1.
+// A regression that ignored --before would still pass the success check alone,
+// so we assert the create-block body explicitly.
+func TestLocateInsertIndexBeforeModeViaExecute(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-before-app"))
+	createStub := registerInsertWithSelectionStubs(reg, "doxcnSEL2", "blk_b", "doxcnSEL2",
+		[]interface{}{"blk_a", "blk_b", "blk_c"})
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", "doxcnSEL2",
+		"--file", "img.png",
+		"--selection-with-ellipsis", "Architecture",
+		"--before",
+		"--as", "bot",
+	}, f, nil)
+	if err != nil {
+		t.Fatalf("Execute() error: %v", err)
+	}
+	// before blk_b (index 1) → insert at index 1, between blk_a and blk_b.
+	assertCreateBlockIndex(t, createStub, 1)
+}
+
+// TestLocateInsertIndexNestedBlockViaExecute verifies that a deeply-nested
+// anchor (2+ levels below root) walks up through an intermediate block via
+// the GET /blocks/{id} API to find the root-level ancestor. This exercises
+// the fallback ancestor-walk path in locateInsertIndex — the parent_block_id
+// hint from locate-doc is only good for one level, so deeper nesting must hit
+// the block-fetch loop.
+func TestLocateInsertIndexNestedBlockViaExecute(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-nested-app"))
+
+	docID := "doxcnNESTED"
+	// Root children: blk_section (index 0), blk_other (index 1).
+	// Anchor blk_grandchild is nested two levels deep:
+	//   root → blk_section → blk_section_child → blk_grandchild
+	// locate-doc gives us parent_block_id = blk_section_child (one level up);
+	// the walk must fetch blk_section_child to discover its parent = blk_section
+	// before it can land on a root child.
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID,
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id": docID,
+					"children": []interface{}{"blk_section", "blk_other"},
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "mcp.feishu.cn/mcp",
+		Body: buildLocateDocMCPResponse([]map[string]interface{}{
+			{"anchor_block_id": "blk_grandchild", "parent_block_id": "blk_section_child"},
+		}),
+	})
+	// Intermediate block lookup — this is the key step that exercises the
+	// fallback walk. Without this stub the test would fail.
+	intermediateStub := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/blk_section_child",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id":  "blk_section_child",
+					"parent_id": "blk_section",
+				},
+			},
+		},
+	}
+	reg.Register(intermediateStub)
+	createStub := &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID + "/children",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"children": []interface{}{
+					map[string]interface{}{"block_id": "blk_new", "block_type": 27, "image": map[string]interface{}{}},
+				},
+			},
+		},
+	}
+	reg.Register(createStub)
+	reg.Register(&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": "ftok_nested"},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/batch_update",
+		Body:   map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
+	})
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", docID,
+		"--file", "img.png",
+		"--selection-with-ellipsis", "nested content",
+		"--as", "bot",
+	}, f, nil)
+	if err != nil {
+		t.Fatalf("Execute() error: %v", err)
+	}
+	// Confirm the ancestor-walk actually fired — without this assertion a
+	// regression that short-circuited the walk would still pass.
+	if intermediateStub.CapturedBody == nil && intermediateStub.CapturedHeaders == nil {
+		t.Errorf("expected GET /blocks/blk_section_child to be invoked by the parent-walk; stub was not hit")
+	}
+	// after blk_section (index 0) → insert at index 1, between blk_section and blk_other.
+	assertCreateBlockIndex(t, createStub, 1)
+}
+
+// TestLocateInsertIndexNoMatchReturnsError verifies that when locate-doc returns
+// no matches, Execute returns a descriptive error.
+func TestLocateInsertIndexNoMatchReturnsError(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-nomatch-app"))
+
+	docID := "doxcnNOMATCH"
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID,
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id": docID,
+					"children": []interface{}{"blk_a"},
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "mcp.feishu.cn/mcp",
+		Body:   buildLocateDocMCPResponse([]map[string]interface{}{}),
+	})
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", docID,
+		"--file", "img.png",
+		"--selection-with-ellipsis", "nonexistent text",
+		"--as", "bot",
+	}, f, nil)
+	if err == nil {
+		t.Fatal("expected no-match error, got nil")
+	}
+	if !strings.Contains(err.Error(), "no_match") && !strings.Contains(err.Error(), "did not find") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// TestLocateInsertIndexDryRunIncludesMCPStep verifies that the dry-run output
+// includes a locate-doc MCP step when --selection-with-ellipsis is provided.
+func TestLocateInsertIndexDryRunIncludesMCPStep(t *testing.T) {
+	t.Parallel()
+
+	cmd := &cobra.Command{Use: "docs +media-insert"}
+	cmd.Flags().String("file", "", "")
+	cmd.Flags().String("doc", "", "")
+	cmd.Flags().String("type", "image", "")
+	cmd.Flags().String("align", "", "")
+	cmd.Flags().String("caption", "", "")
+	cmd.Flags().String("selection-with-ellipsis", "", "")
+	cmd.Flags().Bool("before", false, "")
+	_ = cmd.Flags().Set("file", "img.png")
+	_ = cmd.Flags().Set("doc", "doxcnABCDEF")
+	_ = cmd.Flags().Set("selection-with-ellipsis", "Introduction")
+
+	rt := common.TestNewRuntimeContext(cmd, docsTestConfigWithAppID("dry-run-app"))
+	dryAPI := DocMediaInsert.DryRun(context.Background(), rt)
+	raw, _ := json.Marshal(dryAPI)
+
+	var dry struct {
+		Description string `json:"description"`
+		API         []struct {
+			Desc string                 `json:"desc"`
+			URL  string                 `json:"url"`
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
+	if err := json.Unmarshal(raw, &dry); err != nil {
+		t.Fatalf("decode dry-run: %v", err)
+	}
+
+	foundMCP := false
+	for _, step := range dry.API {
+		if strings.Contains(step.Desc, "locate-doc") {
+			foundMCP = true
+		}
+	}
+	if !foundMCP {
+		t.Fatalf("dry-run should include a locate-doc step, got: %+v", dry.API)
+	}
+	if !strings.Contains(dry.Description, "locate-doc") {
+		t.Fatalf("dry-run description should mention 'locate-doc', got: %s", dry.Description)
+	}
+
+	// Verify create-block step shows <locate_index> not <children_len>
+	for _, step := range dry.API {
+		if strings.Contains(step.URL, "/children") && step.Body != nil {
+			if idx, ok := step.Body["index"]; ok {
+				if idx != "<locate_index>" {
+					t.Fatalf("create-block index in selection mode = %q, want <locate_index>", idx)
+				}
+			}
+		}
+	}
 }
 
 func TestExtractCreatedBlockTargetsForImage(t *testing.T) {
@@ -369,3 +731,256 @@ func TestDocMediaInsertValidateFileView(t *testing.T) {
 		})
 	}
 }
+
+// TestLocateInsertIndexWarnsOnMultipleMatches verifies that when locate-doc
+// returns more than one match, a warning is written to stderr pointing the user
+// at the 'start...end' disambiguation syntax. Silently picking the first match
+// of an ambiguous selection is a real UX trap — users who edit documents with
+// repeated phrases (a heading that also appears in the TOC, for example) get
+// no signal that another match existed.
+func TestLocateInsertIndexWarnsOnMultipleMatches(t *testing.T) {
+	f, _, stderr, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-multi-app"))
+
+	docID := "doxcnMULTI"
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID,
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id": docID,
+					"children": []interface{}{"blk_a", "blk_b"},
+				},
+			},
+		},
+	})
+	// Two matches — same selection appears in two different root-level blocks.
+	// locate-doc orders matches by document position, so matches[0] is still
+	// deterministic (blk_a) even with limit=2.
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "mcp.feishu.cn/mcp",
+		Body: buildLocateDocMCPResponse([]map[string]interface{}{
+			{"anchor_block_id": "blk_a", "parent_block_id": docID},
+			{"anchor_block_id": "blk_b", "parent_block_id": docID},
+		}),
+	})
+	createStub := &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID + "/children",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"children": []interface{}{
+					map[string]interface{}{"block_id": "blk_new", "block_type": 27, "image": map[string]interface{}{}},
+				},
+			},
+		},
+	}
+	reg.Register(createStub)
+	reg.Register(&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": "ftok_multi"},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/batch_update",
+		Body:   map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
+	})
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", docID,
+		"--file", "img.png",
+		"--selection-with-ellipsis", "Repeated phrase",
+		"--as", "bot",
+	}, f, nil)
+	if err != nil {
+		t.Fatalf("Execute() error: %v", err)
+	}
+
+	// Warning should name the ambiguity and point at 'start...end'.
+	stderrOut := stderr.String()
+	if !strings.Contains(stderrOut, "matched more than one block") {
+		t.Errorf("stderr missing multi-match warning; got:\n%s", stderrOut)
+	}
+	if !strings.Contains(stderrOut, "start...end") {
+		t.Errorf("stderr missing 'start...end' disambiguation hint; got:\n%s", stderrOut)
+	}
+	// Should still insert at the first match (blk_a at index 0) → after ⇒ 1.
+	assertCreateBlockIndex(t, createStub, 1)
+}
+
+// TestLocateInsertIndexLogsNestedAnchor verifies that when the matched block is
+// nested (not a direct root child), a note is written to stderr explaining that
+// the media lands at the top-level ancestor. This protects users from being
+// surprised when selecting text inside a callout or table cell and seeing the
+// image appear outside that container.
+func TestLocateInsertIndexLogsNestedAnchor(t *testing.T) {
+	f, _, stderr, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-nested-log-app"))
+
+	docID := "doxcnNESTEDLOG"
+	// Same shape as TestLocateInsertIndexNestedBlockViaExecute: anchor is two
+	// levels below root, so walkDepth == 2 when we hit the root ancestor.
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID,
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id": docID,
+					"children": []interface{}{"blk_section", "blk_other"},
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "mcp.feishu.cn/mcp",
+		Body: buildLocateDocMCPResponse([]map[string]interface{}{
+			{"anchor_block_id": "blk_grandchild", "parent_block_id": "blk_section_child"},
+		}),
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/blk_section_child",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id":  "blk_section_child",
+					"parent_id": "blk_section",
+				},
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID + "/children",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"children": []interface{}{
+					map[string]interface{}{"block_id": "blk_new", "block_type": 27, "image": map[string]interface{}{}},
+				},
+			},
+		},
+	})
+	reg.Register(&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": "ftok_nested_log"},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/batch_update",
+		Body:   map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
+	})
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", docID,
+		"--file", "img.png",
+		"--selection-with-ellipsis", "nested content",
+		"--as", "bot",
+	}, f, nil)
+	if err != nil {
+		t.Fatalf("Execute() error: %v", err)
+	}
+
+	stderrOut := stderr.String()
+	if !strings.Contains(stderrOut, "nested") || !strings.Contains(stderrOut, "top-level ancestor") {
+		t.Errorf("stderr missing nested-anchor note; got:\n%s", stderrOut)
+	}
+}
+
+// TestLocateInsertIndexCycleDetection verifies that a malformed parent chain
+// (blk_x.parent = blk_y and blk_y.parent = blk_x, neither reachable from root)
+// does not spin the locate-doc walk forever. The `visited` map must break the
+// cycle, and the user must see the "not reachable from document root" error
+// rather than the process hanging. Without this test, a regression that broke
+// cycle protection would only surface in production with a stalled CLI.
+func TestLocateInsertIndexCycleDetection(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("locate-cycle-app"))
+
+	docID := "doxcnCYCLE"
+	// Root has unrelated children — neither blk_x nor blk_y reach root.
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/" + docID,
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id": docID,
+					"children": []interface{}{"blk_unrelated_a", "blk_unrelated_b"},
+				},
+			},
+		},
+	})
+	// locate-doc hints parent_block_id = blk_y for anchor blk_x (first hop consumed).
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "mcp.feishu.cn/mcp",
+		Body: buildLocateDocMCPResponse([]map[string]interface{}{
+			{"anchor_block_id": "blk_x", "parent_block_id": "blk_y"},
+		}),
+	})
+	// blk_y claims blk_x as parent — closes the cycle. The walk must land here
+	// exactly once before visited[blk_x] triggers a break.
+	blkYStub := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/docx/v1/documents/" + docID + "/blocks/blk_y",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"block": map[string]interface{}{
+					"block_id":  "blk_y",
+					"parent_id": "blk_x",
+				},
+			},
+		},
+	}
+	reg.Register(blkYStub)
+
+	tmpDir := t.TempDir()
+	withDocsWorkingDir(t, tmpDir)
+	writeSizedDocTestFile(t, "img.png", 100)
+
+	err := mountAndRunDocs(t, DocMediaInsert, []string{
+		"+media-insert",
+		"--doc", docID,
+		"--file", "img.png",
+		"--selection-with-ellipsis", "cyclic anchor",
+		"--as", "bot",
+	}, f, nil)
+	if err == nil {
+		t.Fatal("expected 'block_not_reachable' error from cyclic parent chain; got nil")
+	}
+	if !strings.Contains(err.Error(), "not reachable") && !strings.Contains(err.Error(), "block_not_reachable") {
+		t.Fatalf("unexpected error — want cycle-bounded 'not reachable', got: %v", err)
+	}
+	// blk_y should be fetched exactly once. Registering just one stub for it
+	// already enforces an upper bound (httpmock errors on extra calls), so if
+	// the walk looped more than once the test harness would fail differently.
+	if blkYStub.CapturedHeaders == nil && blkYStub.CapturedBody == nil {
+		t.Errorf("expected the walk to fetch blk_y once; stub was not hit")
+	}
+}

shortcuts/doc/doc_media_test.go

@@ -118,7 +118,7 @@ func TestDocMediaUploadDryRunUsesMultipartForLargeFile(t *testing.T) {
 		t.Fatalf("set --parent-node: %v", err)
 	}
 
-	dry := decodeDocDryRun(t, MediaUpload.DryRun(context.Background(), common.TestNewRuntimeContext(cmd, nil)))
+	dry := decodeDocDryRun(t, DocMediaUpload.DryRun(context.Background(), common.TestNewRuntimeContext(cmd, nil)))
 	if dry.Description != "chunked media upload (files > 20MB)" {
 		t.Fatalf("dry-run description = %q", dry.Description)
 	}

shortcuts/doc/doc_media_upload.go

@@ -13,7 +13,7 @@ import (
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-var MediaUpload = common.Shortcut{
+var DocMediaUpload = common.Shortcut{
 	Service:     "docs",
 	Command:     "+media-upload",
 	Description: "Upload media file (image/attachment) to a document block",
@@ -22,8 +22,8 @@ var MediaUpload = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "file", Desc: "local file path (files > 20MB use multipart upload automatically)", Required: true},
-		{Name: "parent-type", Desc: "parent type: docx_image | docx_file", Required: true},
-		{Name: "parent-node", Desc: "parent node ID (block_id)", Required: true},
+		{Name: "parent-type", Desc: "parent type: docx_image | docx_file | whiteboard", Required: true},
+		{Name: "parent-node", Desc: "parent node ID (block_id for docx, board_token for whiteboard)", Required: true},
 		{Name: "doc-id", Desc: "document ID (for drive_route_token)"},
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {

shortcuts/doc/docs_update.go

@@ -5,6 +5,7 @@ package doc
 
 import (
 	"context"
+	"fmt"
 	"strings"
 
 	"github.com/larksuite/cli/shortcuts/common"
@@ -62,6 +63,9 @@ var DocsUpdate = common.Shortcut{
 		if needsSelection[mode] && selEllipsis == "" && selTitle == "" {
 			return common.FlagErrorf("--%s mode requires --selection-with-ellipsis or --selection-by-title", mode)
 		}
+		if err := validateSelectionByTitle(selTitle); err != nil {
+			return err
+		}
 
 		return nil
 	},
@@ -89,12 +93,22 @@ var DocsUpdate = common.Shortcut{
 			Set("mcp_tool", "update-doc").Set("args", args)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		mode := runtime.Str("mode")
+		markdown := runtime.Str("markdown")
+
+		// Static semantic checks run before the MCP call so users see
+		// warnings even if the subsequent request fails. They never block
+		// execution — the update still proceeds.
+		for _, w := range docsUpdateWarnings(mode, markdown) {
+			fmt.Fprintf(runtime.IO().ErrOut, "warning: %s\n", w)
+		}
+
 		args := map[string]interface{}{
 			"doc_id": runtime.Str("doc"),
-			"mode":   runtime.Str("mode"),
+			"mode":   mode,
 		}
-		if v := runtime.Str("markdown"); v != "" {
-			args["markdown"] = v
+		if markdown != "" {
+			args["markdown"] = markdown
 		}
 		if v := runtime.Str("selection-with-ellipsis"); v != "" {
 			args["selection_with_ellipsis"] = v
@@ -156,3 +170,17 @@ func normalizeBoardTokens(raw interface{}) []string {
 		return []string{}
 	}
 }
+
+func validateSelectionByTitle(title string) error {
+	if title == "" {
+		return nil
+	}
+	trimmed := strings.TrimSpace(title)
+	if strings.Contains(trimmed, "\n") || strings.Contains(trimmed, "\r") {
+		return common.FlagErrorf("--selection-by-title must be a single heading line (for example: '## Section')")
+	}
+	if strings.HasPrefix(trimmed, "#") {
+		return nil
+	}
+	return common.FlagErrorf("--selection-by-title must include markdown heading prefix '#'. Example: --selection-by-title '## Section'")
+}

shortcuts/doc/docs_update_check.go

@@ -0,0 +1,281 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package doc
+
+import (
+	"regexp"
+	"strings"
+)
+
+// docsUpdateWarnings returns a list of human-readable warnings for a
+// `docs +update` invocation based on static analysis of the mode and
+// Markdown payload. The warnings describe CLI/MCP contract edges that
+// commonly surprise users; the update is still executed — callers
+// decide whether to stop at a warning.
+//
+// Both checks ignore fenced code blocks (```…``` and ~~~…~~~, with up
+// to 3 leading spaces per CommonMark §4.5), inline code spans, and
+// backslash-escaped emphasis markers so that literal Markdown content
+// embedded in code samples or escaped prose does not produce false
+// positives.
+//
+// Warnings emitted (current):
+//
+//  1. replace_* modes do not split blocks. A Markdown payload containing
+//     a blank line (\n\n) in prose implies the caller expects multiple
+//     paragraphs, but replace_range / replace_all only swap in-block
+//     text. The resulting block will contain the blank line as literal
+//     text and appear as a single paragraph in the UI.
+//
+//  2. Lark does not round-trip bold+italic. Six shapes are detected:
+//     ***text***   ___text___
+//     **_text_**   __*text*__
+//     _**text**_   *__text__*
+//     Lark stores only one of the two emphases (usually italic), silently
+//     dropping the other. The user wanted both; they will get one.
+func docsUpdateWarnings(mode, markdown string) []string {
+	var warnings []string
+	if w := checkDocsUpdateReplaceMultilineMarkdown(mode, markdown); w != "" {
+		warnings = append(warnings, w)
+	}
+	if w := checkDocsUpdateBoldItalic(markdown); w != "" {
+		warnings = append(warnings, w)
+	}
+	return warnings
+}
+
+// checkDocsUpdateReplaceMultilineMarkdown flags markdown that contains a
+// blank-line paragraph break outside fenced code blocks under a replace_*
+// mode. Blank lines inside code fences are literal content and don't
+// imply paragraph semantics, so they are deliberately ignored.
+func checkDocsUpdateReplaceMultilineMarkdown(mode, markdown string) string {
+	if mode != "replace_range" && mode != "replace_all" {
+		return ""
+	}
+	// A CR/LF-robust check: both "\n\n" and "\r\n\r\n" count as paragraph
+	// separators. We normalize line endings once before detection.
+	normalized := strings.ReplaceAll(markdown, "\r\n", "\n")
+	if !proseHasBlankLine(normalized) {
+		return ""
+	}
+	return "--mode=" + mode + " does not split a block into multiple paragraphs; " +
+		"the blank line in --markdown will render as literal text. " +
+		"For multiple paragraphs, use --mode=delete_range followed by --mode=insert_before."
+}
+
+// combinedEmphasisPatterns holds the six documented combined-emphasis shapes
+// that Lark downgrades to a single emphasis. Each entry pairs a regex with a
+// short shape label for the warning message. The two forms per shape (with
+// and without `[^…]*?`) are there because the lazy quantifier needs at least
+// one non-delimiter character to match; single-rune payloads (e.g. `***X***`)
+// take the second alternation.
+var combinedEmphasisPatterns = []struct {
+	shape string
+	re    *regexp.Regexp
+}{
+	// Bold+italic with a single delimiter char.
+	{"***text***", regexp.MustCompile(`\*\*\*\S[^*]*?\S\*\*\*|\*\*\*\S\*\*\*`)},
+	{"___text___", regexp.MustCompile(`___\S[^_]*?\S___|___\S___`)},
+
+	// Bold wrapping italic (asterisk outside).
+	{"**_text_**", regexp.MustCompile(`\*\*_\S[^_*]*?\S_\*\*|\*\*_\S_\*\*`)},
+	{"__*text*__", regexp.MustCompile(`__\*\S[^_*]*?\S\*__|__\*\S\*__`)},
+
+	// Italic wrapping bold (asterisk inside).
+	{"_**text**_", regexp.MustCompile(`_\*\*\S[^_*]*?\S\*\*_|_\*\*\S\*\*_`)},
+	{"*__text__*", regexp.MustCompile(`\*__\S[^_*]*?\S__\*|\*__\S__\*`)},
+}
+
+// checkDocsUpdateBoldItalic flags Markdown emphases that attempt to
+// combine bold and italic in a way Lark cannot represent. Fenced code
+// blocks, inline code spans, and backslash-escaped emphasis markers are
+// stripped first so that literal markdown examples ("here is a
+// `***keyword***` to flag") do not trigger the warning.
+func checkDocsUpdateBoldItalic(markdown string) string {
+	if markdown == "" {
+		return ""
+	}
+	sanitized := stripEscapedEmphasisMarkers(stripMarkdownCodeRegions(markdown))
+	for _, p := range combinedEmphasisPatterns {
+		if p.re.MatchString(sanitized) {
+			return "Lark does not support combined bold+italic markers " +
+				"(e.g. ***text***, ___text___, **_text_**, _**text**_, __*text*__, *__text__*); " +
+				"the emphasis will be downgraded to either bold or italic. " +
+				"Split into two separate emphases or drop one of them."
+		}
+	}
+	return ""
+}
+
+// proseHasBlankLine reports whether markdown contains a blank line outside
+// of fenced code blocks. Blank lines inside ```...``` or ~~~...~~~ fences
+// are code content, not paragraph separators, and must not trip the
+// "replace_* cannot split paragraphs" warning.
+//
+// A blank line counts only when it sits between two non-blank boundaries
+// (other prose, or a fence open/close). A trailing empty line at EOF is
+// not treated as "\n\n".
+func proseHasBlankLine(markdown string) bool {
+	lines := strings.Split(markdown, "\n")
+	inFence := false
+	var fenceMarker string
+	for i, line := range lines {
+		if inFence {
+			if isCodeFenceClose(line, fenceMarker) {
+				inFence = false
+				fenceMarker = ""
+			}
+			continue
+		}
+		if marker := codeFenceOpenMarker(line); marker != "" {
+			inFence = true
+			fenceMarker = marker
+			continue
+		}
+		if strings.TrimSpace(line) == "" && i > 0 && i+1 < len(lines) {
+			return true
+		}
+	}
+	return false
+}
+
+// stripMarkdownCodeRegions returns markdown with fenced code blocks blanked
+// out and inline code spans replaced by whitespace of equivalent length.
+// Byte offsets outside the masked regions are preserved, so follow-on
+// regex matches still point at real prose positions.
+func stripMarkdownCodeRegions(markdown string) string {
+	lines := strings.Split(markdown, "\n")
+	inFence := false
+	var fenceMarker string
+	for i, line := range lines {
+		if inFence {
+			if isCodeFenceClose(line, fenceMarker) {
+				inFence = false
+				fenceMarker = ""
+			}
+			lines[i] = ""
+			continue
+		}
+		if marker := codeFenceOpenMarker(line); marker != "" {
+			inFence = true
+			fenceMarker = marker
+			lines[i] = ""
+			continue
+		}
+		lines[i] = maskInlineCodeSpans(line)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// maskInlineCodeSpans replaces the byte ranges of any inline code spans in
+// line with space characters of equal length. Uses scanInlineCodeSpans from
+// markdown_fix.go, which implements the CommonMark §6.1 matching-backtick-run
+// rule (so “ `a`b` “ is a single span).
+func maskInlineCodeSpans(line string) string {
+	spans := scanInlineCodeSpans(line)
+	if len(spans) == 0 {
+		return line
+	}
+	var sb strings.Builder
+	pos := 0
+	for _, loc := range spans {
+		sb.WriteString(line[pos:loc[0]])
+		sb.WriteString(strings.Repeat(" ", loc[1]-loc[0]))
+		pos = loc[1]
+	}
+	sb.WriteString(line[pos:])
+	return sb.String()
+}
+
+// stripEscapedEmphasisMarkers removes backslash-escaped '*' and '_' so the
+// bold/italic regexes don't treat literal sequences like `\***text***` as
+// real combined emphasis. CommonMark renders "\*" as a literal "*" with no
+// emphasis semantics; dropping the escape + its target from the detection
+// input keeps the heuristic aligned with what the renderer actually does.
+//
+// Known limitation: a doubled backslash escape ("\\" followed by a real
+// emphasis marker, e.g. `\\***text***`) renders as a literal backslash
+// followed by genuine combined emphasis, but this strip is not a proper
+// parser and will instead consume the second backslash as the opener for
+// another escape. That hides the real emphasis from the check, producing
+// a false negative. Practical impact is small (this shape is rare in the
+// kind of AI-Agent prompts we target) and the alternative — a full
+// CommonMark escape parser — is not worth the code surface here.
+func stripEscapedEmphasisMarkers(s string) string {
+	s = strings.ReplaceAll(s, `\*`, "")
+	s = strings.ReplaceAll(s, `\_`, "")
+	return s
+}
+
+// codeFenceOpenMarker returns the fence marker (e.g. "```" or "~~~~") if
+// line opens a fenced code block, otherwise "". Applies CommonMark §4.5
+// rules: up to 3 leading spaces are tolerated; 4+ leading spaces (or any
+// leading tab, which expands to 4 columns) make the line an indented code
+// block rather than a fence.
+func codeFenceOpenMarker(line string) string {
+	body, ok := fenceIndentOK(line)
+	if !ok {
+		return ""
+	}
+	switch {
+	case strings.HasPrefix(body, "```"):
+		return leadingRun(body, '`')
+	case strings.HasPrefix(body, "~~~"):
+		return leadingRun(body, '~')
+	}
+	return ""
+}
+
+// isCodeFenceClose reports whether line closes a fence opened with marker.
+// Per CommonMark §4.5 the closer must use the same fence character, be at
+// least as long as the opener, sit within 0..3 leading spaces, and carry
+// no info-string text.
+func isCodeFenceClose(line, marker string) bool {
+	if marker == "" {
+		return false
+	}
+	body, ok := fenceIndentOK(line)
+	if !ok {
+		return false
+	}
+	fenceChar := marker[0]
+	run := leadingRun(body, fenceChar)
+	if len(run) < len(marker) {
+		return false
+	}
+	return strings.TrimSpace(body[len(run):]) == ""
+}
+
+// fenceIndentOK returns (bodyWithoutLeadingSpaces, true) when line has
+// 0..3 leading spaces and no leading tab — i.e. the indentation is
+// permissible for a CommonMark fence. Returns ("", false) otherwise
+// (4+ leading spaces or any tab), meaning the line must be treated as
+// indented code block content rather than a fence boundary.
+func fenceIndentOK(line string) (string, bool) {
+	for i := 0; i < len(line) && i < 4; i++ {
+		switch line[i] {
+		case ' ':
+			continue
+		case '\t':
+			return "", false
+		default:
+			return line[i:], true
+		}
+	}
+	// Reached index 4 without hitting a non-space character: too indented.
+	if len(line) >= 4 {
+		return "", false
+	}
+	// Line shorter than 4 chars and all spaces — still valid (empty content).
+	return "", true
+}
+
+// leadingRun returns the longest prefix of s made up of the byte c.
+func leadingRun(s string, c byte) string {
+	i := 0
+	for i < len(s) && s[i] == c {
+		i++
+	}
+	return s[:i]
+}

shortcuts/doc/docs_update_check_test.go

@@ -0,0 +1,375 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package doc
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCheckDocsUpdateReplaceMultilineMarkdown(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		mode     string
+		markdown string
+		wantHint bool
+	}{
+		{
+			name:     "replace_range with blank line emits hint",
+			mode:     "replace_range",
+			markdown: "new paragraph\n\nsecond paragraph",
+			wantHint: true,
+		},
+		{
+			name:     "replace_all with blank line emits hint",
+			mode:     "replace_all",
+			markdown: "first\n\nsecond",
+			wantHint: true,
+		},
+		{
+			name:     "replace_range single paragraph is fine",
+			mode:     "replace_range",
+			markdown: "just a single paragraph of text",
+			wantHint: false,
+		},
+		{
+			name:     "single newline is not a paragraph break",
+			mode:     "replace_range",
+			markdown: "line one\nline two",
+			wantHint: false,
+		},
+		{
+			name:     "crlf paragraph break is also detected",
+			mode:     "replace_range",
+			markdown: "first\r\n\r\nsecond",
+			wantHint: true,
+		},
+		{
+			name:     "other modes are not flagged",
+			mode:     "insert_before",
+			markdown: "first\n\nsecond",
+			wantHint: false,
+		},
+		{
+			name:     "append mode is not flagged",
+			mode:     "append",
+			markdown: "first\n\nsecond",
+			wantHint: false,
+		},
+		{
+			name:     "empty markdown is fine",
+			mode:     "replace_range",
+			markdown: "",
+			wantHint: false,
+		},
+		{
+			// The check must ignore blank lines inside fenced code; otherwise
+			// a user replacing one block with a legitimate code sample that
+			// contains blank lines would see a spurious warning.
+			name:     "blank line inside backtick fenced code is not flagged",
+			mode:     "replace_range",
+			markdown: "```\nline1\n\nline2\n```",
+			wantHint: false,
+		},
+		{
+			name:     "blank line inside tilde fenced code is not flagged",
+			mode:     "replace_range",
+			markdown: "~~~\ncode line one\n\ncode line two\n~~~",
+			wantHint: false,
+		},
+		{
+			// Mixed prose + fenced code: any blank line in prose still wins,
+			// even if the fenced content also contains blanks.
+			name:     "blank line in prose outside fence still flags even when fence has blanks",
+			mode:     "replace_range",
+			markdown: "first paragraph\n\nsecond paragraph\n\n```\ncode\n\nmore\n```",
+			wantHint: true,
+		},
+		{
+			// Fenced code with no blank lines inside must not trip on the
+			// fence markers themselves.
+			name:     "fenced code with no blank lines does not flag",
+			mode:     "replace_range",
+			markdown: "prose before\n```go\nfmt.Println(\"hi\")\n```\nprose after",
+			wantHint: false,
+		},
+		{
+			// CommonMark §4.5: the closing fence must be ≥ opening fence length.
+			// A 4-backtick close for a 3-backtick open is a legitimate way to
+			// embed triple-backticks in a code sample; the check must see the
+			// fence as properly closed and not treat the rest of the document
+			// as still-inside-fence.
+			name:     "longer close marker closes fence correctly",
+			mode:     "replace_range",
+			markdown: "```\nsome code\n````\n\nprose paragraph after",
+			wantHint: true, // the blank line AFTER the fence is real prose
+		},
+		{
+			name:     "longer close marker still hides blank line inside fence",
+			mode:     "replace_range",
+			markdown: "```\nbefore\n\nafter\n````",
+			wantHint: false,
+		},
+		{
+			// 4+ leading spaces make the line an indented code block, not a
+			// fence open. The "fence"-looking line is code content; the
+			// surrounding blank must still be detected.
+			name:     "four-space indented fence-like line is not a fence open",
+			mode:     "replace_range",
+			markdown: "first paragraph\n\n    ```\n    code\n    ```",
+			wantHint: true,
+		},
+		{
+			// A tab in the leading whitespace is always ≥4 columns and thus
+			// forces indented-code-block semantics.
+			name:     "tab-indented fence-like line is not a fence open",
+			mode:     "replace_range",
+			markdown: "first paragraph\n\n\t```\n\tcode\n\t```",
+			wantHint: true,
+		},
+		{
+			// 3 leading spaces is still within the fence-tolerance window.
+			name:     "three-space indented fence is still a fence",
+			mode:     "replace_range",
+			markdown: "   ```\ncode\n\nmore\n   ```",
+			wantHint: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got := checkDocsUpdateReplaceMultilineMarkdown(tt.mode, tt.markdown)
+			hasHint := got != ""
+			if hasHint != tt.wantHint {
+				t.Fatalf("checkDocsUpdateReplaceMultilineMarkdown(%q, %q) = %q, wantHint=%v",
+					tt.mode, tt.markdown, got, tt.wantHint)
+			}
+			if tt.wantHint && (!strings.Contains(got, "delete_range") || !strings.Contains(got, "insert_before")) {
+				t.Errorf("hint should suggest delete_range/insert_before remediation, got: %s", got)
+			}
+		})
+	}
+}
+
+func TestCheckDocsUpdateBoldItalic(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    string
+		wantHint bool
+	}{
+		{
+			name:     "triple asterisks flagged",
+			input:    "a ***key insight*** here",
+			wantHint: true,
+		},
+		{
+			name:     "triple asterisks single char flagged",
+			input:    "a ***X*** here",
+			wantHint: true,
+		},
+		{
+			name:     "bold wrapping underscore italic flagged",
+			input:    "note: **_important_** detail",
+			wantHint: true,
+		},
+		{
+			name:     "underscore wrapping double asterisk flagged",
+			input:    "note: _**important**_ detail",
+			wantHint: true,
+		},
+		{
+			name:     "plain bold is fine",
+			input:    "this is **bold** text",
+			wantHint: false,
+		},
+		{
+			name:     "plain italic is fine",
+			input:    "this is *italic* or _italic_ text",
+			wantHint: false,
+		},
+		{
+			name:     "horizontal rule is not flagged",
+			input:    "paragraph\n\n---\n\nnext",
+			wantHint: false,
+		},
+		{
+			name:     "bold followed by italic with space is not flagged",
+			input:    "**bold** and *italic*",
+			wantHint: false,
+		},
+		{
+			name:     "empty input is fine",
+			input:    "",
+			wantHint: false,
+		},
+		{
+			// The emphasis check must not fire on literal Markdown samples
+			// inside a fenced code block — the canonical use case is docs
+			// authors pasting tutorials that demonstrate these exact patterns.
+			name:     "triple asterisks inside backtick fenced code is not flagged",
+			input:    "example:\n```\nthe shape ***keyword*** downgrades\n```",
+			wantHint: false,
+		},
+		{
+			name:     "underscore-bold inside fenced code is not flagged",
+			input:    "example:\n```markdown\nuse **_strong italic_** carefully\n```",
+			wantHint: false,
+		},
+		{
+			name:     "bold-underscore inside fenced code is not flagged",
+			input:    "example:\n~~~\n_**outside-underscore**_ is a bad shape\n~~~",
+			wantHint: false,
+		},
+		{
+			name:     "triple asterisks inside inline code span is not flagged",
+			input:    "the literal `***text***` marker is just a sample",
+			wantHint: false,
+		},
+		{
+			name:     "underscore-bold inside inline code is not flagged",
+			input:    "the shape `**_italic_**` would downgrade, but only if it were real",
+			wantHint: false,
+		},
+		{
+			name:     "escaped triple asterisks rendered as literal text is not flagged",
+			input:    `the literal \***text*** with escaped opener`,
+			wantHint: false,
+		},
+		{
+			name:     "escaped bold inside underscore-italic is not flagged",
+			input:    `shape \*\*_text_\*\* is literal, not emphasis`,
+			wantHint: false,
+		},
+		{
+			// Real emphasis outside the code span must still be detected —
+			// the strip step must not over-sanitize.
+			name:     "real triple asterisks outside inline code still flags",
+			input:    "real ***strong*** and literal `***keyword***` — the first one counts",
+			wantHint: true,
+		},
+		{
+			name:     "real triple asterisks outside fenced code still flags",
+			input:    "real ***strong***\n\n```\nliteral ***keyword*** in code\n```",
+			wantHint: true,
+		},
+		// --- Triple-underscore combined emphasis: ___text___ ---
+		{
+			name:     "triple underscores flagged",
+			input:    "a ___key insight___ here",
+			wantHint: true,
+		},
+		{
+			name:     "triple underscores single char flagged",
+			input:    "a ___X___ here",
+			wantHint: true,
+		},
+		{
+			name:     "triple underscores inside fenced code not flagged",
+			input:    "sample:\n```\nuse ___keyword___ carefully\n```",
+			wantHint: false,
+		},
+		{
+			name:     "triple underscores inside inline code not flagged",
+			input:    "the literal `___phrase___` marker",
+			wantHint: false,
+		},
+		{
+			name:     "escaped triple underscores not flagged",
+			input:    `literal \___phrase___ with escaped opener`,
+			wantHint: false,
+		},
+		// --- Underscore-bold wrapping asterisk-italic: __*text*__ ---
+		{
+			name:     "underscore-bold wrapping asterisk-italic flagged",
+			input:    "note: __*important*__ text",
+			wantHint: true,
+		},
+		{
+			name:     "underscore-bold wrapping asterisk-italic inside fenced code not flagged",
+			input:    "```\nnote: __*important*__ sample\n```",
+			wantHint: false,
+		},
+		{
+			name:     "underscore-bold wrapping asterisk-italic inside inline code not flagged",
+			input:    "literal `__*important*__` marker",
+			wantHint: false,
+		},
+		// --- Asterisk-italic wrapping underscore-bold: *__text__* ---
+		{
+			name:     "asterisk-italic wrapping underscore-bold flagged",
+			input:    "note: *__phrase__* text",
+			wantHint: true,
+		},
+		{
+			name:     "asterisk-italic wrapping underscore-bold inside fenced code not flagged",
+			input:    "```md\nnote: *__phrase__* sample\n```",
+			wantHint: false,
+		},
+		// --- Positive tests: real emphasis in prose coexisting with fake in code ---
+		{
+			// Underscore-variant in prose must still fire when an asterisk
+			// variant appears inside a code span — verifies the strip does
+			// not over-sanitize across the six regex alternatives.
+			name:     "real triple underscores outside inline code still flag when asterisk variant is in code",
+			input:    "real ___strong___ and literal `***shape***` in code",
+			wantHint: true,
+		},
+		{
+			// Longer close fence closes properly; real ***emphasis*** after
+			// the fence must fire.
+			name:     "real emphasis after a fence closed by longer marker still flags",
+			input:    "```\nliteral ***phrase*** in code\n````\n\nand then real ***phrase*** after",
+			wantHint: true,
+		},
+		{
+			// 4-space indented "```" is an indented code block, not a fence
+			// open. The fence helper should refuse it; emphasis outside the
+			// (non-existent) fence must still be detected.
+			name:     "four-space indented fence-like line does not open a fence for the emphasis check",
+			input:    "prose\n\n    ```\n    not a fence\n    ```\n\nreal ***strong*** here",
+			wantHint: true,
+		},
+		{
+			// 3-space indented fence is valid per CommonMark. Emphasis inside
+			// must be sanitized away, so the check must not fire.
+			name:     "three-space indented fence still hides triple-asterisk inside",
+			input:    "   ```\n   literal ***text*** inside\n   ```",
+			wantHint: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got := checkDocsUpdateBoldItalic(tt.input)
+			hasHint := got != ""
+			if hasHint != tt.wantHint {
+				t.Fatalf("checkDocsUpdateBoldItalic(%q) = %q, wantHint=%v", tt.input, got, tt.wantHint)
+			}
+		})
+	}
+}
+
+func TestDocsUpdateWarningsAggregates(t *testing.T) {
+	t.Parallel()
+
+	// Both flags trigger: replace_range with blank line AND triple-asterisk.
+	warnings := docsUpdateWarnings("replace_range", "***opening***\n\nsecond paragraph")
+	if len(warnings) != 2 {
+		t.Fatalf("expected 2 warnings, got %d: %v", len(warnings), warnings)
+	}
+}
+
+func TestDocsUpdateWarningsEmpty(t *testing.T) {
+	t.Parallel()
+
+	// Clean markdown in a non-replace mode produces zero warnings.
+	warnings := docsUpdateWarnings("insert_before", "plain paragraph text")
+	if len(warnings) != 0 {
+		t.Fatalf("expected no warnings, got: %v", warnings)
+	}
+}

shortcuts/doc/docs_update_test.go

@@ -3,8 +3,14 @@
 package doc
 
 import (
+	"context"
 	"reflect"
+	"strings"
 	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/shortcuts/common"
 )
 
 func TestIsWhiteboardCreateMarkdown(t *testing.T) {
@@ -30,6 +36,59 @@ func TestIsWhiteboardCreateMarkdown(t *testing.T) {
 	})
 }
 
+func TestNormalizeBoardTokens(t *testing.T) {
+	// Codecov patch includes normalizeBoardTokens in this PR's diff because
+	// the PR base predates #569 where this helper landed; the previously-
+	// untested string and default arms are what keep patch coverage under the
+	// threshold. These cases lock the fallback paths so any future caller
+	// that passes a plain string or a non-slice token bag gets a stable shape.
+
+	t.Run("nil raw returns empty slice", func(t *testing.T) {
+		got := normalizeBoardTokens(nil)
+		if len(got) != 0 {
+			t.Fatalf("expected empty slice, got %#v", got)
+		}
+	})
+
+	t.Run("already-typed string slice passes through", func(t *testing.T) {
+		in := []string{"a", "b"}
+		got := normalizeBoardTokens(in)
+		if !reflect.DeepEqual(got, in) {
+			t.Fatalf("got %#v, want %#v", got, in)
+		}
+	})
+
+	t.Run("interface slice skips non-string and empty string items", func(t *testing.T) {
+		got := normalizeBoardTokens([]interface{}{"keep", "", 42, "also"})
+		want := []string{"keep", "also"}
+		if !reflect.DeepEqual(got, want) {
+			t.Fatalf("got %#v, want %#v", got, want)
+		}
+	})
+
+	t.Run("single string wraps into one-item slice", func(t *testing.T) {
+		got := normalizeBoardTokens("solo")
+		want := []string{"solo"}
+		if !reflect.DeepEqual(got, want) {
+			t.Fatalf("got %#v, want %#v", got, want)
+		}
+	})
+
+	t.Run("empty string returns empty slice, not one-item slice", func(t *testing.T) {
+		got := normalizeBoardTokens("")
+		if len(got) != 0 {
+			t.Fatalf("expected empty slice for empty string input, got %#v", got)
+		}
+	})
+
+	t.Run("unsupported type falls through to empty slice", func(t *testing.T) {
+		got := normalizeBoardTokens(42)
+		if len(got) != 0 {
+			t.Fatalf("expected empty slice for non-string/non-slice input, got %#v", got)
+		}
+	})
+}
+
 func TestNormalizeDocsUpdateResult(t *testing.T) {
 	t.Run("adds empty board_tokens when whiteboard creation response omits it", func(t *testing.T) {
 		result := map[string]interface{}{
@@ -76,3 +135,201 @@ func TestNormalizeDocsUpdateResult(t *testing.T) {
 		}
 	})
 }
+
+func TestValidateSelectionByTitle(t *testing.T) {
+	t.Run("empty title passes", func(t *testing.T) {
+		if err := validateSelectionByTitle(""); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+	})
+
+	t.Run("heading style title passes", func(t *testing.T) {
+		if err := validateSelectionByTitle("## 第二章"); err != nil {
+			t.Fatalf("expected nil error, got %v", err)
+		}
+	})
+
+	t.Run("plain text title fails with guidance", func(t *testing.T) {
+		err := validateSelectionByTitle("第二章")
+		if err == nil {
+			t.Fatalf("expected validation error")
+		}
+		if got := err.Error(); got == "" || !containsAll(got, "selection-by-title", "heading prefix") {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	})
+
+	t.Run("multi-line heading still fails", func(t *testing.T) {
+		err := validateSelectionByTitle("## 第二章\n## 第三章")
+		if err == nil {
+			t.Fatalf("expected validation error")
+		}
+		if got := err.Error(); got == "" || !containsAll(got, "single heading line") {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	})
+
+	t.Run("multi-line title fails", func(t *testing.T) {
+		err := validateSelectionByTitle("第二章\n第三章")
+		if err == nil {
+			t.Fatalf("expected validation error")
+		}
+		if got := err.Error(); got == "" || !containsAll(got, "single heading line") {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	})
+}
+
+func containsAll(s string, tokens ...string) bool {
+	for _, token := range tokens {
+		if !strings.Contains(s, token) {
+			return false
+		}
+	}
+	return true
+}
+
+// TestDocsUpdateValidate exercises the Validate closure directly so the new
+// --selection-by-title integration point (call site in Validate) is covered,
+// not just the underlying validateSelectionByTitle helper. Without this the
+// three lines added to the closure show up as untested in the patch coverage
+// report even though the helper itself is at 100%.
+func TestDocsUpdateValidate(t *testing.T) {
+	tests := []struct {
+		name     string
+		flags    map[string]string
+		boolFlag string // name of optional bool flag to set (currently unused; placeholder for future flags)
+		wantErr  string // substring; empty = expect nil error
+	}{
+		{
+			// Happy path that exercises the new selection-by-title call site
+			// with a valid heading — reaches the `return nil` branch.
+			name: "heading-style selection-by-title passes",
+			flags: map[string]string{
+				"doc":                "doxcnABCDEF",
+				"mode":               "replace_range",
+				"markdown":           "new body",
+				"selection-by-title": "## Section",
+			},
+		},
+		{
+			// Exercises the error-return branch of the new call site.
+			name: "plain-text selection-by-title is rejected with heading-prefix guidance",
+			flags: map[string]string{
+				"doc":                "doxcnABCDEF",
+				"mode":               "replace_range",
+				"markdown":           "new body",
+				"selection-by-title": "第二章",
+			},
+			wantErr: "heading prefix",
+		},
+		{
+			// Exercises the multi-line guard inside validateSelectionByTitle
+			// through the Validate call path.
+			name: "multi-line selection-by-title is rejected as not a single heading",
+			flags: map[string]string{
+				"doc":                "doxcnABCDEF",
+				"mode":               "replace_range",
+				"markdown":           "new body",
+				"selection-by-title": "## a\n## b",
+			},
+			wantErr: "single heading line",
+		},
+		{
+			// Invalid mode — proves the earlier mode check still fires before
+			// reaching the new selection-by-title check, so the new code
+			// doesn't accidentally mask pre-existing validation.
+			name: "invalid mode is still rejected first",
+			flags: map[string]string{
+				"doc":                "doxcnABCDEF",
+				"mode":               "bogus",
+				"selection-by-title": "## Section",
+			},
+			wantErr: "invalid --mode",
+		},
+		{
+			// Both selection forms supplied — proves the mutual-exclusion
+			// check still fires before the new selection-by-title check.
+			name: "conflicting selection flags are rejected before title validation",
+			flags: map[string]string{
+				"doc":                     "doxcnABCDEF",
+				"mode":                    "replace_range",
+				"markdown":                "body",
+				"selection-with-ellipsis": "start...end",
+				"selection-by-title":      "## Section",
+			},
+			wantErr: "mutually exclusive",
+		},
+		{
+			// Non-delete_range modes require --markdown; this exercises the
+			// pre-existing empty-markdown branch that sits between the mode
+			// check and the new selection-by-title check. Covering it keeps
+			// patch coverage above codecov's threshold for this closure.
+			name: "non-delete_range mode without --markdown is rejected",
+			flags: map[string]string{
+				"doc":                "doxcnABCDEF",
+				"mode":               "replace_range",
+				"selection-by-title": "## Section",
+			},
+			wantErr: "requires --markdown",
+		},
+		{
+			// needsSelection[mode] is true for replace_range but neither
+			// selection flag is set — covers the "requires selection" branch
+			// that precedes the new call site.
+			name: "replace_range without any selection flag is rejected",
+			flags: map[string]string{
+				"doc":      "doxcnABCDEF",
+				"mode":     "replace_range",
+				"markdown": "body",
+			},
+			wantErr: "requires --selection-with-ellipsis or --selection-by-title",
+		},
+		{
+			// delete_range has no markdown requirement and no selection
+			// requirement when neither is supplied is actually ok under the
+			// current rules (delete_range still needs selection per
+			// needsSelection, but the test proves the markdown-empty guard
+			// does not fire for delete_range specifically).
+			name: "delete_range without --markdown but with selection passes markdown check",
+			flags: map[string]string{
+				"doc":                "doxcnABCDEF",
+				"mode":               "delete_range",
+				"selection-by-title": "## Section",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := &cobra.Command{Use: "docs +update"}
+			cmd.Flags().String("doc", "", "")
+			cmd.Flags().String("mode", "", "")
+			cmd.Flags().String("markdown", "", "")
+			cmd.Flags().String("selection-with-ellipsis", "", "")
+			cmd.Flags().String("selection-by-title", "", "")
+			cmd.Flags().String("new-title", "", "")
+			for k, v := range tt.flags {
+				if err := cmd.Flags().Set(k, v); err != nil {
+					t.Fatalf("set --%s=%q: %v", k, v, err)
+				}
+			}
+
+			rt := common.TestNewRuntimeContext(cmd, nil)
+			err := DocsUpdate.Validate(context.Background(), rt)
+
+			if tt.wantErr == "" {
+				if err != nil {
+					t.Fatalf("expected nil error, got %v", err)
+				}
+				return
+			}
+			if err == nil {
+				t.Fatalf("expected error containing %q, got nil", tt.wantErr)
+			}
+			if !strings.Contains(err.Error(), tt.wantErr) {
+				t.Fatalf("error %q does not contain %q", err.Error(), tt.wantErr)
+			}
+		})
+	}
+}

shortcuts/doc/markdown_fix.go

@@ -6,6 +6,8 @@ package doc
 import (
 	"regexp"
 	"strings"
+	"unicode"
+	"unicode/utf8"
 )
 
 // fixExportedMarkdown applies post-processing to Lark-exported Markdown to
@@ -15,24 +17,29 @@ import (
 //     and strips redundant ** from ATX headings. Applied only outside fenced
 //     code blocks, and skips inline code spans.
 //
-//  2. fixSetextAmbiguity: inserts a blank line before any "---" that immediately
+//  2. normalizeNestedListIndentation: rewrites space-pair-indented nested list
+//     markers to tab-indented markers. This avoids nested ordered list items
+//     being flattened or interpreted as plain text/code on re-import.
+//
+//  3. fixSetextAmbiguity: inserts a blank line before any "---" that immediately
 //     follows a non-empty line, preventing it from being parsed as a Setext H2.
 //     Applied only outside fenced code blocks.
 //
-//  3. fixBlockquoteHardBreaks: inserts a blank blockquote line (">") between
+//  4. fixBlockquoteHardBreaks: inserts a blank blockquote line (">") between
 //     consecutive blockquote content lines so create-doc preserves line breaks.
 //     Applied only outside fenced code blocks.
 //
-//  4. fixTopLevelSoftbreaks: inserts a blank line between adjacent non-empty
+//  5. fixTopLevelSoftbreaks: inserts a blank line between adjacent non-empty
 //     lines at the top level and inside content containers (callout,
 //     quote-container, lark-td). Code fences are left untouched, and
 //     consecutive list items / continuations are not separated.
 //
-//  5. fixCalloutEmoji: replaces named emoji aliases (e.g. emoji="warning") with
+//  6. fixCalloutEmoji: replaces named emoji aliases (e.g. emoji="warning") with
 //     actual Unicode emoji characters that create-doc understands. Applied only
 //     outside fenced code blocks.
 func fixExportedMarkdown(md string) string {
 	md = applyOutsideCodeFences(md, fixBoldSpacing)
+	md = applyOutsideCodeFences(md, normalizeNestedListIndentation)
 	md = applyOutsideCodeFences(md, fixSetextAmbiguity)
 	md = applyOutsideCodeFences(md, fixBlockquoteHardBreaks)
 	md = fixTopLevelSoftbreaks(md)
@@ -106,20 +113,21 @@ func fixBlockquoteHardBreaks(md string) string {
 	return strings.Join(out, "\n")
 }
 
-// fixBoldSpacing fixes two issues with bold markers exported by Lark:
+// fixBoldSpacing normalizes emphasis markers exported by Lark while preserving
+// inline code spans:
 //
-//  1. Trailing whitespace before closing **: "**text **" → "**text**"
-//     CommonMark requires no space before a closing delimiter; otherwise the
-//     ** is rendered as literal text.
+//  1. Removes leading whitespace after opening ** and * delimiters:
+//     "** text**" → "**text**", "* text*" → "*text*"
 //
-//  2. Redundant bold in ATX headings: "# **text**" → "# text"
-//     Headings are already bold, so the inner ** is visually redundant and
-//     some renderers display the markers literally.
+//  2. Removes trailing whitespace before closing ** and * delimiters:
+//     "**text **" → "**text**", "*text *" → "*text*"
 //
-// Both fixes skip inline code spans to avoid modifying literal code content.
+//  3. Removes redundant bold around an entire ATX heading:
+//     "# **text**" → "# text"
+//
+// The bold and italic spacing fixes only run on non-code segments so literal
+// code content is left unchanged.
 var (
-	boldTrailingSpaceRe   = regexp.MustCompile(`(\*\*\S[^*]*?)\s+(\*\*)`)
-	italicTrailingSpaceRe = regexp.MustCompile(`(\*\S[^*]*?)\s+(\*)`)
 	// headingBoldRe uses [^*]+ (no asterisks) to avoid mismatching headings
 	// that contain multiple disjoint bold spans such as "# **foo** and **bar**".
 	headingBoldRe = regexp.MustCompile(`(?m)^(#{1,6})\s+\*\*([^*]+)\*\*\s*$`)
@@ -182,38 +190,116 @@ func scanInlineCodeSpans(line string) [][2]int {
 // fixBoldSpacingLine applies bold/italic trailing-space fixes to a single line,
 // skipping content inside inline code spans to avoid corrupting literal code.
 // ATX heading lines are also skipped here because headingBoldRe in fixBoldSpacing
-// handles them separately and boldTrailingSpaceRe can misfire on headings with
-// multiple disjoint bold spans (e.g. "# **foo** and **bar**").
+// handles them separately, keeping heading-only normalization isolated from the
+// inline emphasis spacing scanner below.
 func fixBoldSpacingLine(line string) string {
 	if atxHeadingRe.MatchString(line) {
 		return line
 	}
 	spans := scanInlineCodeSpans(line)
 	if len(spans) == 0 {
-		line = boldTrailingSpaceRe.ReplaceAllString(line, "$1$2")
-		line = italicTrailingSpaceRe.ReplaceAllString(line, "$1$2")
-		return line
+		return fixEmphasisSpacingSegment(line)
 	}
 	var sb strings.Builder
 	pos := 0
 	for _, loc := range spans {
 		// Process the non-code segment before this inline code span.
 		seg := line[pos:loc[0]]
-		seg = boldTrailingSpaceRe.ReplaceAllString(seg, "$1$2")
-		seg = italicTrailingSpaceRe.ReplaceAllString(seg, "$1$2")
-		sb.WriteString(seg)
+		sb.WriteString(fixEmphasisSpacingSegment(seg))
 		// Preserve inline code span as-is.
 		sb.WriteString(line[loc[0]:loc[1]])
 		pos = loc[1]
 	}
 	// Remaining non-code segment after the last code span.
-	seg := line[pos:]
-	seg = boldTrailingSpaceRe.ReplaceAllString(seg, "$1$2")
-	seg = italicTrailingSpaceRe.ReplaceAllString(seg, "$1$2")
-	sb.WriteString(seg)
+	sb.WriteString(fixEmphasisSpacingSegment(line[pos:]))
 	return sb.String()
 }
 
+// fixEmphasisSpacingSegment trims only the whitespace immediately inside simple
+// *...* and **...** spans. It deliberately ignores runs of 3+ asterisks and
+// any candidate whose payload contains another asterisk so nested emphasis-like
+// text remains untouched. When both inner sides contain whitespace, single-rune
+// payloads are preserved as literal text (for example "* x *" and "** x **").
+func fixEmphasisSpacingSegment(seg string) string {
+	if !strings.Contains(seg, "*") {
+		return seg
+	}
+
+	var sb strings.Builder
+	pos := 0
+	for pos < len(seg) {
+		openStart, openEnd, ok := nextAsteriskRun(seg, pos)
+		if !ok {
+			sb.WriteString(seg[pos:])
+			break
+		}
+
+		sb.WriteString(seg[pos:openStart])
+
+		markerLen := openEnd - openStart
+		if markerLen != 1 && markerLen != 2 {
+			sb.WriteString(seg[openStart:openEnd])
+			pos = openEnd
+			continue
+		}
+
+		closeStart, closeEnd, ok := nextAsteriskRun(seg, openEnd)
+		if !ok || closeEnd-closeStart != markerLen {
+			sb.WriteString(seg[openStart:openEnd])
+			pos = openEnd
+			continue
+		}
+
+		payload := seg[openEnd:closeStart]
+		normalized, shouldNormalize := normalizeEmphasisPayload(payload)
+		if !shouldNormalize {
+			sb.WriteString(seg[openStart:closeEnd])
+			pos = closeEnd
+			continue
+		}
+
+		marker := seg[openStart:openEnd]
+		sb.WriteString(marker)
+		sb.WriteString(normalized)
+		sb.WriteString(marker)
+		pos = closeEnd
+	}
+	return sb.String()
+}
+
+func nextAsteriskRun(s string, start int) (runStart, runEnd int, ok bool) {
+	for i := start; i < len(s); i++ {
+		if s[i] != '*' {
+			continue
+		}
+		j := i
+		for j < len(s) && s[j] == '*' {
+			j++
+		}
+		return i, j, true
+	}
+	return 0, 0, false
+}
+
+func normalizeEmphasisPayload(payload string) (string, bool) {
+	trimmedLeft := strings.TrimLeftFunc(payload, unicode.IsSpace)
+	trimmed := strings.TrimRightFunc(trimmedLeft, unicode.IsSpace)
+	if trimmed == "" {
+		return payload, false
+	}
+
+	hasLeadingSpace := len(trimmedLeft) != len(payload)
+	hasTrailingSpace := len(trimmed) != len(trimmedLeft)
+	if !hasLeadingSpace && !hasTrailingSpace {
+		return payload, true
+	}
+
+	if hasLeadingSpace && hasTrailingSpace && utf8.RuneCountInString(trimmed) == 1 {
+		return payload, false
+	}
+	return trimmed, true
+}
+
 var setextRe = regexp.MustCompile(`(?m)^([^\n]+)\n(-{3,}\s*$)`)
 
 func fixSetextAmbiguity(md string) string {
@@ -291,6 +377,44 @@ var contentContainers = [][2]string{
 // indented (nested) items.
 var listItemRe = regexp.MustCompile(`^[ \t]*([-*+]|\d+[.)]) `)
 
+// nestedListIndentRe matches nested list item markers indented with pairs of
+// spaces. We rewrite those space pairs to tabs because some downstream
+// round-trip paths treat multi-space indented ordered items as flat items or
+// literal text, while tab indentation remains nested and avoids 4-space code
+// block ambiguity.
+var nestedListIndentRe = regexp.MustCompile(`^( {2,})([-*+]|\d+[.)]) `)
+
+func normalizeNestedListIndentation(md string) string {
+	lines := strings.Split(md, "\n")
+	for i, line := range lines {
+		matches := nestedListIndentRe.FindStringSubmatch(line)
+		if len(matches) != 3 {
+			continue
+		}
+		if !hasPreviousNonBlankListItem(lines, i) {
+			continue
+		}
+		indent := matches[1]
+		if len(indent)%2 != 0 {
+			continue
+		}
+		tabs := strings.Repeat("\t", len(indent)/2)
+		lines[i] = tabs + line[len(indent):]
+	}
+	return strings.Join(lines, "\n")
+}
+
+func hasPreviousNonBlankListItem(lines []string, index int) bool {
+	for i := index - 1; i >= 0; i-- {
+		trimmed := strings.TrimSpace(lines[i])
+		if trimmed == "" {
+			return false
+		}
+		return listItemRe.MatchString(lines[i])
+	}
+	return false
+}
+
 // isListItemOrContinuation returns true for lines that are part of a list:
 // either a list item marker line or an indented continuation of a list item.
 // This is used to prevent blank lines being inserted between tight list lines,

shortcuts/doc/markdown_fix_hardening_test.go

@@ -0,0 +1,287 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package doc
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestFixExportedMarkdownIdempotent asserts the core promise of the exported
+// markdown pipeline: applying the fixes twice produces the same result as
+// applying them once. Round-trip formatting relies on this invariant, so any
+// transform that keeps rewriting its own output would break fetch → edit →
+// update → fetch stability.
+func TestFixExportedMarkdownIdempotent(t *testing.T) {
+	fixtures := map[string]string{
+		"kitchen sink": strings.Join([]string{
+			"# **Title**",
+			"paragraph one",
+			"paragraph two",
+			"**bold ** and * italic*",
+			"",
+			"> q1",
+			"> q2",
+			"",
+			"1. parent",
+			"  1. child",
+			"    1. grandchild",
+			"",
+			"<callout emoji=\"warning\">",
+			"callout body line 1",
+			"callout body line 2",
+			"</callout>",
+			"",
+			"some text",
+			"---",
+			"",
+			"```go",
+			"// code content with markdown-like shapes must survive as-is",
+			"**foo **",
+			"* hello*",
+			"  1. nested",
+			"> q",
+			"---",
+			"```",
+			"",
+		}, "\n"),
+
+		"cjk content": strings.Join([]string{
+			"# **测试标题**",
+			"段落一",
+			"段落二",
+			"**有用性 ** and * 关键 *",
+			"",
+			"1. 父项",
+			"  1. 子项",
+			"",
+		}, "\n"),
+
+		"nested containers": strings.Join([]string{
+			"<callout emoji=\"info\">",
+			"line a",
+			"line b",
+			"</callout>",
+			"",
+			"<quote-container>",
+			"quoted 1",
+			"quoted 2",
+			"</quote-container>",
+			"",
+		}, "\n"),
+	}
+
+	for name, fixture := range fixtures {
+		t.Run(name, func(t *testing.T) {
+			once := fixExportedMarkdown(fixture)
+			twice := fixExportedMarkdown(once)
+			if once != twice {
+				t.Errorf("fixExportedMarkdown is not idempotent for %q\nfirst pass:\n%s\nsecond pass:\n%s",
+					name, once, twice)
+			}
+		})
+	}
+}
+
+// TestFixExportedMarkdownPreservesFencedCodeByteForByte packs a fenced code
+// block with content that every individual transform in the pipeline would
+// normally rewrite, and asserts the fence content comes out byte-for-byte
+// identical. This is the pipeline's strongest invariant — users' code samples
+// must never be silently modified by a formatting pass.
+func TestFixExportedMarkdownPreservesFencedCodeByteForByte(t *testing.T) {
+	// Every line below is something at least one transform would touch if it
+	// appeared outside a fence. None of it must change.
+	dangerous := strings.Join([]string{
+		"**foo **",      // fixBoldSpacing — trailing space bold
+		"* hello*",      // fixBoldSpacing — leading space italic
+		"# **heading**", // fixBoldSpacing — redundant heading bold
+		"para1",         // fixTopLevelSoftbreaks — adjacent paragraphs
+		"para2",
+		"> q1", // fixBlockquoteHardBreaks — blockquote pair
+		"> q2",
+		"some text", // fixSetextAmbiguity — text before ---
+		"---",
+		"  1. nested",               // normalizeNestedListIndentation
+		`<callout emoji="warning">`, // fixCalloutEmoji — emoji alias
+	}, "\n")
+
+	// Wrap the dangerous content in a triple-backtick fence and surround with
+	// content so the pipeline has adjacent regions to potentially touch.
+	input := "before\n\n```\n" + dangerous + "\n```\n\nafter\n"
+
+	got := fixExportedMarkdown(input)
+
+	// Extract the fence content from the output and compare to the input fence
+	// content byte-for-byte.
+	gotFence, ok := extractFirstFenceContent(got)
+	if !ok {
+		t.Fatalf("fixExportedMarkdown output lost its fenced code block:\n%s", got)
+	}
+	if gotFence != dangerous {
+		t.Errorf("fenced code content was modified\nwant (bytes): %q\ngot  (bytes): %q",
+			dangerous, gotFence)
+	}
+}
+
+// extractFirstFenceContent returns the inner text of the first triple-backtick
+// fenced code block it finds, or ("", false) if none is present.
+func extractFirstFenceContent(md string) (string, bool) {
+	const fence = "```"
+	open := strings.Index(md, fence)
+	if open < 0 {
+		return "", false
+	}
+	// Skip the fence marker and its info-string line.
+	rest := md[open+len(fence):]
+	lineEnd := strings.Index(rest, "\n")
+	if lineEnd < 0 {
+		return "", false
+	}
+	rest = rest[lineEnd+1:]
+	close := strings.Index(rest, "\n"+fence)
+	if close < 0 {
+		return "", false
+	}
+	return rest[:close], true
+}
+
+// TestFixExportedMarkdownPreservesCRLF feeds CRLF-terminated markdown (Windows
+// line endings) through the pipeline and asserts that line endings are
+// preserved AND the emphasis/heading transforms still apply — neither
+// silently-LF-normalized nor passed through unchanged.
+func TestFixExportedMarkdownPreservesCRLF(t *testing.T) {
+	lf := "# **Title**\nparagraph one\nparagraph two\n**bold **\n"
+	crlf := strings.ReplaceAll(lf, "\n", "\r\n")
+
+	got := fixExportedMarkdown(crlf)
+
+	// Transforms must still fire: heading bold stripped, trailing-space bold trimmed.
+	if strings.Contains(got, "**Title**") {
+		t.Errorf("heading bold not stripped on CRLF input:\n%q", got)
+	}
+	if strings.Contains(got, "**bold **") {
+		t.Errorf("trailing-space bold not fixed on CRLF input:\n%q", got)
+	}
+	// CRLF line endings must survive — we don't want to silently normalize a
+	// Windows author's document to LF.
+	if !strings.Contains(got, "\r\n") {
+		t.Errorf("CRLF line endings were normalized away:\n%q", got)
+	}
+}
+
+// TestFixExportedMarkdownTransformInteractions covers shapes where more than
+// one transform fires on the same input. Each transform is individually tested
+// elsewhere; these cases guard against composition regressions.
+func TestFixExportedMarkdownTransformInteractions(t *testing.T) {
+	tests := []struct {
+		name         string
+		input        string
+		wantContains []string // substrings that must be present after fixes
+		wantAbsent   []string // substrings that must be absent after fixes
+	}{
+		{
+			name:  "nested list item with trailing-space bold",
+			input: "1. parent\n  1. **child **\n",
+			wantContains: []string{
+				"\t1.",      // nested indent converted to tab
+				"**child**", // trailing space trimmed
+			},
+			wantAbsent: []string{
+				"  1.",       // original two-space indent gone
+				"**child **", // original trailing space gone
+			},
+		},
+		{
+			name:  "paragraph followed by list",
+			input: "paragraph\n- item a\n- item b\n",
+			wantContains: []string{
+				"paragraph\n\n- item a", // blank line inserted at text-to-list transition
+			},
+			wantAbsent: []string{
+				"\n\n\n", // no triple newline
+			},
+		},
+		{
+			name:  "callout containing list with emphasis",
+			input: "<callout emoji=\"info\">\n- **item **\n- another\n</callout>\n",
+			wantContains: []string{
+				"**item**", // trailing-space bold fixed inside callout
+			},
+			wantAbsent: []string{
+				"**item **",
+			},
+		},
+		{
+			name:  "heading followed by paragraph with bold",
+			input: "# **Title**\nbody **text **\n",
+			wantContains: []string{
+				"# Title",       // heading bold stripped
+				"body **text**", // paragraph bold trimmed, not stripped
+			},
+			wantAbsent: []string{
+				"# **Title**",
+				"body **text **",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := fixExportedMarkdown(tt.input)
+			for _, want := range tt.wantContains {
+				if !strings.Contains(got, want) {
+					t.Errorf("want substring %q not found in output:\n%s", want, got)
+				}
+			}
+			for _, unwanted := range tt.wantAbsent {
+				if strings.Contains(got, unwanted) {
+					t.Errorf("unwanted substring %q still present in output:\n%s", unwanted, got)
+				}
+			}
+		})
+	}
+}
+
+// TestNormalizeNestedListIndentationDocumentedSkips locks in the deliberate
+// "do nothing" branches of normalizeNestedListIndentation. Each case below is
+// a shape the function intentionally does not rewrite; if a future change to
+// the heuristic flips one of these, we want the regression to be visible in
+// the test diff rather than silently changing user documents.
+func TestNormalizeNestedListIndentationDocumentedSkips(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		// want is identical to input — we are asserting "no change".
+	}{
+		{
+			name:  "three-space indent (odd) under list item stays unchanged",
+			input: "1. parent\n   1. child",
+		},
+		{
+			name:  "five-space indent (odd) under list item stays unchanged",
+			input: "- parent\n     - deep",
+		},
+		{
+			name:  "two-space indent without a parent list item stays unchanged",
+			input: "plain paragraph\n  - not nested",
+		},
+		{
+			name:  "blank-line-separated loose-list sibling stays unchanged",
+			input: "1. a\n\n  1. b",
+		},
+		{
+			name:  "four-space indented code block under list item stays unchanged",
+			input: "- parent\n\n    1. code sample",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := normalizeNestedListIndentation(tt.input)
+			if got != tt.input {
+				t.Errorf("normalizeNestedListIndentation unexpectedly rewrote documented-skip input\ninput: %q\ngot:   %q", tt.input, got)
+			}
+		})
+	}
+}

shortcuts/doc/markdown_fix_test.go

@@ -14,6 +14,56 @@ func TestFixBoldSpacing(t *testing.T) {
 		input string
 		want  string
 	}{
+		{
+			name:  "leading space after opening bold",
+			input: "** hello**",
+			want:  "**hello**",
+		},
+		{
+			name:  "leading space after opening italic",
+			input: "* hello*",
+			want:  "*hello*",
+		},
+		{
+			name:  "leading and trailing spaces inside bold are collapsed",
+			input: "** hello **",
+			want:  "**hello**",
+		},
+		{
+			name:  "leading and trailing spaces inside italic are collapsed",
+			input: "* hello *",
+			want:  "*hello*",
+		},
+		{
+			name:  "multiple spaced italic spans on one line are each collapsed",
+			input: "* a* * b*",
+			want:  "*a* *b*",
+		},
+		{
+			name:  "ambiguous italic span stays literal",
+			input: "2 * x * y",
+			want:  "2 * x * y",
+		},
+		{
+			name:  "ambiguous bold span stays literal",
+			input: "2 ** x ** y",
+			want:  "2 ** x ** y",
+		},
+		{
+			name:  "single-rune italic with spaces on both sides stays literal",
+			input: "* x *",
+			want:  "* x *",
+		},
+		{
+			name:  "single-rune bold with spaces on both sides stays literal",
+			input: "** x **",
+			want:  "** x **",
+		},
+		{
+			name:  "triple-asterisk near miss stays literal",
+			input: "*** hello**",
+			want:  "*** hello**",
+		},
 		{
 			name:  "trailing space before closing bold",
 			input: "**hello **",
@@ -54,6 +104,16 @@ func TestFixBoldSpacing(t *testing.T) {
 			input: "**foo ** and `**bar **`",
 			want:  "**foo** and `**bar **`",
 		},
+		{
+			name:  "inline code with spaced italic stays literal while outside span is fixed",
+			input: "`* hello *` and * hello *",
+			want:  "`* hello *` and *hello*",
+		},
+		{
+			name:  "opening space inside text tag fixed",
+			input: `<text color="red">** Helpful - 有用性：**</text>`,
+			want:  `<text color="red">**Helpful - 有用性：**</text>`,
+		},
 		{
 			name:  "double-backtick inline code not modified",
 			input: "``**hello **`` and **world **",
@@ -222,6 +282,53 @@ func TestFixTopLevelSoftbreaks(t *testing.T) {
 	}
 }
 
+func TestNormalizeNestedListIndentation(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{
+			name:  "nested ordered list uses tabs instead of space pairs",
+			input: "1. parent\n  1. child\n    1. grandchild",
+			want:  "1. parent\n\t1. child\n\t\t1. grandchild",
+		},
+		{
+			name:  "nested mixed list markers use tabs instead of space pairs",
+			input: "- parent\n  - child\n    1. grandchild",
+			want:  "- parent\n\t- child\n\t\t1. grandchild",
+		},
+		{
+			name:  "top-level list unchanged",
+			input: "1. parent\n2. sibling",
+			want:  "1. parent\n2. sibling",
+		},
+		{
+			name:  "indented top-level marker without parent list stays unchanged",
+			input: "paragraph\n\n  1. item",
+			want:  "paragraph\n\n  1. item",
+		},
+		{
+			name:  "blank-line-separated loose-list sibling stays unchanged",
+			input: "1. a\n\n  1. b",
+			want:  "1. a\n\n  1. b",
+		},
+		{
+			name:  "indented code block inside list item stays unchanged",
+			input: "- parent\n\n    1. code",
+			want:  "- parent\n\n    1. code",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := normalizeNestedListIndentation(tt.input)
+			if got != tt.want {
+				t.Errorf("normalizeNestedListIndentation(%q) = %q, want %q", tt.input, got, tt.want)
+			}
+		})
+	}
+}
+
 func TestFixExportedMarkdown(t *testing.T) {
 	// End-to-end: all fixes applied together
 	input := "# **Title**\nparagraph one\nparagraph two\n**bold **\n> q1\n> q2\nsome text\n---"

shortcuts/doc/shortcuts.go

@@ -13,6 +13,7 @@ func Shortcuts() []common.Shortcut {
 		DocsFetch,
 		DocsUpdate,
 		DocMediaInsert,
+		DocMediaUpload,
 		DocMediaPreview,
 		DocMediaDownload,
 	}

shortcuts/drive/drive_apply_permission.go

@@ -0,0 +1,150 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package drive
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/validate"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+// permApplyTypes is the authoritative list of type values the apply-permission
+// endpoint accepts for its required `type` query parameter.
+var permApplyTypes = []string{
+	"doc", "sheet", "file", "wiki", "bitable", "docx",
+	"mindnote", "slides",
+}
+
+// permApplyURLMarkers maps document URL path markers to the `type` value the
+// apply-permission endpoint expects. Markers are disjoint strings (each begins
+// with "/" and ends with "/"), so a simple substring scan disambiguates them.
+var permApplyURLMarkers = []struct {
+	Marker string
+	Type   string
+}{
+	{"/wiki/", "wiki"},
+	{"/docx/", "docx"},
+	{"/sheets/", "sheet"},
+	{"/base/", "bitable"},
+	{"/bitable/", "bitable"},
+	{"/file/", "file"},
+	{"/mindnote/", "mindnote"},
+	{"/slides/", "slides"},
+	{"/doc/", "doc"},
+}
+
+// resolvePermApplyTarget extracts (token, type) from a user-supplied --token
+// value that may be either a bare token or a full document URL, plus an
+// optional explicit --type. Explicit --type wins over URL inference.
+func resolvePermApplyTarget(raw, explicitType string) (token, docType string, err error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return "", "", output.ErrValidation("--token is required")
+	}
+
+	if strings.Contains(raw, "://") {
+		for _, m := range permApplyURLMarkers {
+			if tok, ok := extractURLToken(raw, m.Marker); ok {
+				token = tok
+				if explicitType == "" {
+					docType = m.Type
+				}
+				break
+			}
+		}
+		if token == "" {
+			return "", "", output.ErrValidation(
+				"could not infer token from URL %q: supported paths are /docx/, /sheets/, /base/, /bitable/, /file/, /wiki/, /doc/, /mindnote/, /slides/. Pass a bare token with --type instead if the URL shape is unusual",
+				raw,
+			)
+		}
+	} else {
+		token = raw
+	}
+
+	if explicitType != "" {
+		docType = explicitType
+	}
+	if docType == "" {
+		return "", "", output.ErrValidation(
+			"--type is required when --token is a bare token; accepted values: %s",
+			strings.Join(permApplyTypes, ", "),
+		)
+	}
+	return token, docType, nil
+}
+
+// DriveApplyPermission applies to the document owner for view or edit access
+// on behalf of the invoking user. Matches the open-apis endpoint
+// /open-apis/drive/v1/permissions/:token/members/apply.
+//
+// The backend accepts only user_access_token for this endpoint, so the
+// shortcut declares AuthTypes: ["user"] — bot identity is rejected up-front.
+var DriveApplyPermission = common.Shortcut{
+	Service:     "drive",
+	Command:     "+apply-permission",
+	Description: "Apply to the document owner for view or edit permission on a doc/sheet/file/wiki/bitable/docx/mindnote/slides",
+	Risk:        "write",
+	Scopes:      []string{"docs:permission.member:apply"},
+	AuthTypes:   []string{"user"},
+	Flags: []common.Flag{
+		{Name: "token", Desc: "target token or document URL (docx/sheets/base/file/wiki/doc/mindnote/slides)", Required: true},
+		{Name: "type", Desc: "target type; auto-inferred from URL when omitted", Enum: permApplyTypes},
+		{Name: "perm", Desc: "permission to request", Required: true, Enum: []string{"view", "edit"}},
+		{Name: "remark", Desc: "optional note shown on the request card sent to the owner"},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		_, _, err := resolvePermApplyTarget(runtime.Str("token"), runtime.Str("type"))
+		return err
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		token, docType, err := resolvePermApplyTarget(runtime.Str("token"), runtime.Str("type"))
+		if err != nil {
+			return common.NewDryRunAPI().Set("error", err.Error())
+		}
+		body := buildPermApplyBody(runtime)
+		return common.NewDryRunAPI().
+			Desc("Apply to document owner for access").
+			POST("/open-apis/drive/v1/permissions/:token/members/apply").
+			Params(map[string]interface{}{"type": docType}).
+			Body(body).
+			Set("token", token)
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		token, docType, err := resolvePermApplyTarget(runtime.Str("token"), runtime.Str("type"))
+		if err != nil {
+			return err
+		}
+		body := buildPermApplyBody(runtime)
+
+		fmt.Fprintf(runtime.IO().ErrOut, "Requesting %s access on %s %s...\n",
+			runtime.Str("perm"), docType, common.MaskToken(token))
+
+		data, err := runtime.CallAPI("POST",
+			fmt.Sprintf("/open-apis/drive/v1/permissions/%s/members/apply", validate.EncodePathSegment(token)),
+			map[string]interface{}{"type": docType},
+			body,
+		)
+		if err != nil {
+			return err
+		}
+		runtime.Out(data, nil)
+		return nil
+	},
+}
+
+// buildPermApplyBody returns the request body with the caller-supplied perm
+// and optional remark. remark is omitted entirely when empty so the server
+// doesn't render an empty note on the request card.
+func buildPermApplyBody(runtime *common.RuntimeContext) map[string]interface{} {
+	body := map[string]interface{}{"perm": runtime.Str("perm")}
+	if s := runtime.Str("remark"); s != "" {
+		body["remark"] = s
+	}
+	return body
+}

shortcuts/drive/drive_apply_permission_test.go

@@ -0,0 +1,238 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package drive
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/httpmock"
+)
+
+// ── resolvePermApplyTarget unit tests ────────────────────────────────────────
+
+func TestResolvePermApplyTarget_BareTokenNeedsType(t *testing.T) {
+	t.Parallel()
+	_, _, err := resolvePermApplyTarget("bareToken", "")
+	if err == nil || !strings.Contains(err.Error(), "--type is required") {
+		t.Fatalf("expected --type required error, got: %v", err)
+	}
+}
+
+func TestResolvePermApplyTarget_BareTokenWithType(t *testing.T) {
+	t.Parallel()
+	token, docType, err := resolvePermApplyTarget("bareToken", "docx")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if token != "bareToken" || docType != "docx" {
+		t.Fatalf("got token=%q type=%q, want bareToken/docx", token, docType)
+	}
+}
+
+func TestResolvePermApplyTarget_URLInference(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name     string
+		raw      string
+		wantTok  string
+		wantType string
+	}{
+		{"docx", "https://example.feishu.cn/docx/doxTok123?from=share", "doxTok123", "docx"},
+		{"sheets", "https://example.feishu.cn/sheets/shtTok456?sheet=abc", "shtTok456", "sheet"},
+		{"base", "https://example.feishu.cn/base/bscTok789", "bscTok789", "bitable"},
+		{"bitable", "https://example.feishu.cn/bitable/bscTok789", "bscTok789", "bitable"},
+		{"file", "https://example.feishu.cn/file/boxTok111", "boxTok111", "file"},
+		{"wiki", "https://example.feishu.cn/wiki/wikTok222", "wikTok222", "wiki"},
+		{"legacy doc", "https://example.feishu.cn/doc/docTok333", "docTok333", "doc"},
+		{"mindnote", "https://example.feishu.cn/mindnote/mnTok444", "mnTok444", "mindnote"},
+		{"slides", "https://example.feishu.cn/slides/slTok666", "slTok666", "slides"},
+	}
+	for _, temp := range tests {
+		tt := temp
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			token, docType, err := resolvePermApplyTarget(tt.raw, "")
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if token != tt.wantTok || docType != tt.wantType {
+				t.Fatalf("got (%q,%q), want (%q,%q)", token, docType, tt.wantTok, tt.wantType)
+			}
+		})
+	}
+}
+
+func TestResolvePermApplyTarget_ExplicitTypeOverridesURL(t *testing.T) {
+	t.Parallel()
+	// Even though the URL marker is /docx/, an explicit --type wins.
+	token, docType, err := resolvePermApplyTarget("https://example.feishu.cn/docx/doxTok123", "wiki")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if token != "doxTok123" || docType != "wiki" {
+		t.Fatalf("got (%q,%q), want (doxTok123,wiki)", token, docType)
+	}
+}
+
+func TestResolvePermApplyTarget_UnrecognizedURL(t *testing.T) {
+	t.Parallel()
+	_, _, err := resolvePermApplyTarget("https://example.feishu.cn/unknown/xyz", "")
+	if err == nil || !strings.Contains(err.Error(), "could not infer token") {
+		t.Fatalf("expected infer error, got: %v", err)
+	}
+}
+
+func TestResolvePermApplyTarget_Empty(t *testing.T) {
+	t.Parallel()
+	_, _, err := resolvePermApplyTarget("   ", "docx")
+	if err == nil || !strings.Contains(err.Error(), "--token is required") {
+		t.Fatalf("expected token required error, got: %v", err)
+	}
+}
+
+// ── shortcut integration tests ──────────────────────────────────────────────
+
+func TestDriveApplyPermission_ValidateMissingToken(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+	err := mountAndRunDrive(t, DriveApplyPermission, []string{
+		"+apply-permission", "--perm", "view", "--type", "docx", "--as", "user",
+	}, f, stdout)
+	if err == nil || !strings.Contains(err.Error(), "token") {
+		t.Fatalf("expected token error, got: %v", err)
+	}
+}
+
+func TestDriveApplyPermission_ValidateRejectsBadPerm(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+	err := mountAndRunDrive(t, DriveApplyPermission, []string{
+		"+apply-permission",
+		"--token", "doxTok",
+		"--type", "docx",
+		"--perm", "full_access",
+		"--as", "user",
+	}, f, stdout)
+	if err == nil || !strings.Contains(err.Error(), "--perm") {
+		t.Fatalf("expected perm enum error, got: %v", err)
+	}
+}
+
+func TestDriveApplyPermission_DryRunInfersTypeFromURL(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+	err := mountAndRunDrive(t, DriveApplyPermission, []string{
+		"+apply-permission",
+		"--token", "https://example.feishu.cn/sheets/shtTok?sheet=abc",
+		"--perm", "edit",
+		"--remark", "please",
+		"--dry-run", "--as", "user",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	out := stdout.String()
+	for _, want := range []string{
+		"/open-apis/drive/v1/permissions/shtTok/members/apply",
+		`"POST"`,
+		`"sheet"`,
+		`"edit"`,
+		`"please"`,
+		`"shtTok"`,
+	} {
+		if !strings.Contains(out, want) {
+			t.Fatalf("dry-run output missing %q:\n%s", want, out)
+		}
+	}
+}
+
+func TestDriveApplyPermission_ExecuteSuccess(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	// Stub URL includes "?type=docx" — the stub only matches when the request
+	// URL contains that query, so this doubles as an assertion that the
+	// shortcut emits the type query parameter.
+	stub := &httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/drive/v1/permissions/doxTok123/members/apply?type=docx",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "success",
+			"data": map[string]interface{}{"applied": true},
+		},
+	}
+	reg.Register(stub)
+
+	err := mountAndRunDrive(t, DriveApplyPermission, []string{
+		"+apply-permission",
+		"--token", "doxTok123",
+		"--type", "docx",
+		"--perm", "view",
+		"--as", "user",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	var body map[string]interface{}
+	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
+		t.Fatalf("parse body: %v", err)
+	}
+	if body["perm"] != "view" {
+		t.Fatalf("perm = %v, want view", body["perm"])
+	}
+	if _, hasRemark := body["remark"]; hasRemark {
+		t.Fatalf("remark should be omitted when empty, got: %v", body["remark"])
+	}
+}
+
+func TestDriveApplyPermission_ExecuteNotApplicableHint(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/drive/v1/permissions/doxTok/members/apply",
+		Status: 400,
+		Body: map[string]interface{}{
+			"code": 1063007, "msg": "request not applicable",
+		},
+	})
+
+	err := mountAndRunDrive(t, DriveApplyPermission, []string{
+		"+apply-permission",
+		"--token", "doxTok",
+		"--type", "docx",
+		"--perm", "view",
+		"--as", "user",
+	}, f, nil)
+	if err == nil {
+		t.Fatal("expected error for 1063007")
+	}
+	if !strings.Contains(err.Error(), "not applicable") {
+		t.Fatalf("expected surfaced server message, got: %v", err)
+	}
+}
+
+func TestDriveApplyPermission_ExecuteRateLimitHint(t *testing.T) {
+	f, _, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/drive/v1/permissions/doxTok/members/apply",
+		Status: 429,
+		Body: map[string]interface{}{
+			"code": 1063006, "msg": "quota exceeded",
+		},
+	})
+
+	err := mountAndRunDrive(t, DriveApplyPermission, []string{
+		"+apply-permission",
+		"--token", "doxTok",
+		"--type", "docx",
+		"--perm", "view",
+		"--as", "user",
+	}, f, nil)
+	if err == nil {
+		t.Fatal("expected error for 1063006")
+	}
+}

shortcuts/drive/shortcuts.go

@@ -19,5 +19,6 @@ func Shortcuts() []common.Shortcut {
 		DriveMove,
 		DriveDelete,
 		DriveTaskResult,
+		DriveApplyPermission,
 	}
 }

shortcuts/drive/shortcuts_test.go

@@ -22,6 +22,7 @@ func TestShortcutsIncludesExpectedCommands(t *testing.T) {
 		"+move",
 		"+delete",
 		"+task_result",
+		"+apply-permission",
 	}
 
 	if len(got) != len(want) {

shortcuts/im/helpers_network_test.go

@@ -262,7 +262,7 @@ func TestDownloadIMResourceToPathSuccess(t *testing.T) {
 	cmdutil.TestChdir(t, t.TempDir())
 
 	target := filepath.Join("nested", "resource.bin")
-	_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_123", "file_123", "file", target)
+	_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_123", "file_123", "file", target, true)
 	if err != nil {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -308,7 +308,7 @@ func TestDownloadIMResourceToPathImageUsesSingleRequestWithoutRange(t *testing.T
 
 	cmdutil.TestChdir(t, t.TempDir())
 
-	gotPath, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_img", "img_123", "image", "image")
+	gotPath, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_img", "img_123", "image", "image", true)
 	if err != nil {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -342,7 +342,7 @@ func TestDownloadIMResourceToPathHTTPErrorBody(t *testing.T) {
 
 	cmdutil.TestChdir(t, t.TempDir())
 
-	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_403", "file_403", "file", "out.bin")
+	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_403", "file_403", "file", "out.bin", true)
 	if err == nil || !strings.Contains(err.Error(), "HTTP 403: denied") {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -372,7 +372,7 @@ func TestDownloadIMResourceToPathRetriesNetworkError(t *testing.T) {
 
 	cmdutil.TestChdir(t, t.TempDir())
 	target := "out.bin"
-	_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_retry", "file_retry", "file", target)
+	_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_retry", "file_retry", "file", target, true)
 	if err != nil {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -408,7 +408,7 @@ func TestDownloadIMResourceToPathRetrySecondAttemptSuccess(t *testing.T) {
 
 	cmdutil.TestChdir(t, t.TempDir())
 	target := "out.bin"
-	_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_retry2", "file_retry2", "file", target)
+	_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_retry2", "file_retry2", "file", target, true)
 	if err != nil {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -444,7 +444,7 @@ func TestDownloadIMResourceToPathRetryContextCanceled(t *testing.T) {
 
 	cmdutil.TestChdir(t, t.TempDir())
 	target := "out.bin"
-	_, _, err := downloadIMResourceToPath(ctx, runtime, "om_cancel", "file_cancel", "file", target)
+	_, _, err := downloadIMResourceToPath(ctx, runtime, "om_cancel", "file_cancel", "file", target, true)
 	if err != context.Canceled {
 		t.Fatalf("downloadIMResourceToPath() error = %v, want context.Canceled", err)
 	}
@@ -525,7 +525,7 @@ func TestDownloadIMResourceToPathRangeDownload(t *testing.T) {
 
 			cmdutil.TestChdir(t, t.TempDir())
 			target := filepath.Join("nested", "resource.bin")
-			_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_range", "file_range", "file", target)
+			_, size, err := downloadIMResourceToPath(context.Background(), runtime, "om_range", "file_range", "file", target, true)
 			if err != nil {
 				t.Fatalf("downloadIMResourceToPath() error = %v", err)
 			}
@@ -567,7 +567,7 @@ func TestDownloadIMResourceToPathInvalidContentRange(t *testing.T) {
 	}))
 
 	cmdutil.TestChdir(t, t.TempDir())
-	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_bad", "file_bad", "file", "out.bin")
+	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_bad", "file_bad", "file", "out.bin", true)
 	if err == nil || !strings.Contains(err.Error(), "invalid Content-Range header") {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -596,7 +596,7 @@ func TestDownloadIMResourceToPathRangeChunkFailureCleansOutput(t *testing.T) {
 	cmdutil.TestChdir(t, t.TempDir())
 
 	target := "out.bin"
-	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_miderr", "file_miderr", "file", target)
+	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_miderr", "file_miderr", "file", target, true)
 	if err == nil || !strings.Contains(err.Error(), "HTTP 500: chunk failed") {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -622,7 +622,7 @@ func TestDownloadIMResourceToPathRangeOverflowCleansOutput(t *testing.T) {
 	cmdutil.TestChdir(t, t.TempDir())
 
 	target := "out.bin"
-	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_overflow", "file_overflow", "file", target)
+	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_overflow", "file_overflow", "file", target, true)
 	if err == nil || !strings.Contains(err.Error(), "chunk overflow") {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -658,7 +658,7 @@ func TestDownloadIMResourceToPathRangeShortChunkSizeMismatch(t *testing.T) {
 
 	cmdutil.TestChdir(t, t.TempDir())
 
-	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_short", "file_short", "file", "out.bin")
+	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_short", "file_short", "file", "out.bin", true)
 	if err == nil || !strings.Contains(err.Error(), "file size mismatch") {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}

shortcuts/im/helpers_test.go

@@ -593,7 +593,7 @@ func TestDownloadIMResourceToPathHTTPClientError(t *testing.T) {
 		return nil, errors.New("http client unavailable")
 	}))
 
-	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_123", "img_123", "image", "out.bin")
+	_, _, err := downloadIMResourceToPath(context.Background(), runtime, "om_123", "img_123", "image", "out.bin", true)
 	if err == nil || !strings.Contains(err.Error(), "http client unavailable") {
 		t.Fatalf("downloadIMResourceToPath() error = %v", err)
 	}
@@ -637,6 +637,68 @@ func TestParseTotalSize(t *testing.T) {
 	}
 }
 
+func TestParseContentDispositionFilename(t *testing.T) {
+	tests := []struct {
+		name   string
+		header string
+		want   string
+	}{
+		{name: "empty header", header: "", want: ""},
+		{name: "no filename param", header: "attachment", want: ""},
+		{name: "plain filename", header: `attachment; filename="report.xlsx"`, want: "report.xlsx"},
+		{name: "unquoted filename", header: `attachment; filename=report.xlsx`, want: "report.xlsx"},
+		{name: "RFC 5987 UTF-8 encoded", header: `attachment; filename*=UTF-8''%E5%AD%A3%E5%BA%A6%E6%8A%A5%E5%91%8A.xlsx`, want: "季度报告.xlsx"},
+		{name: "RFC 5987 takes priority over plain", header: `attachment; filename="fallback.xlsx"; filename*=UTF-8''%E5%AD%A3%E5%BA%A6%E6%8A%A5%E5%91%8A.xlsx`, want: "季度报告.xlsx"},
+		{name: "path traversal stripped", header: `attachment; filename="../../etc/passwd"`, want: "passwd"},
+		{name: "windows path stripped", header: `attachment; filename="C:\\Windows\\evil.exe"`, want: "evil.exe"},
+		{name: "control char rejected", header: "attachment; filename=\"evil\x01file.txt\"", want: ""},
+		{name: "malformed header", header: "not/valid/mime; ===", want: ""},
+		{name: "whitespace trimmed", header: `attachment; filename="  report.pdf  "`, want: "report.pdf"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := parseContentDispositionFilename(tt.header); got != tt.want {
+				t.Fatalf("parseContentDispositionFilename(%q) = %q, want %q", tt.header, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestResolveIMResourceDownloadPath(t *testing.T) {
+	tests := []struct {
+		name                string
+		safePath            string
+		contentType         string
+		contentDisposition  string
+		userSpecifiedOutput bool
+		want                string
+	}{
+		// safePath already has extension: always return as-is
+		{name: "user path with ext, no CD", safePath: "out.xlsx", contentType: "application/pdf", userSpecifiedOutput: true, want: "out.xlsx"},
+		{name: "user path with ext, CD present", safePath: "out.xlsx", contentDisposition: `attachment; filename="server.pdf"`, userSpecifiedOutput: true, want: "out.xlsx"},
+		// No --output: use CD filename when present
+		{name: "default path, CD filename", safePath: "file_xxx", contentDisposition: `attachment; filename="季度报告.xlsx"`, want: "季度报告.xlsx"},
+		{name: "default path, CD RFC5987", safePath: "file_xxx", contentDisposition: `attachment; filename*=UTF-8''%E5%AD%A3%E5%BA%A6%E6%8A%A5%E5%91%8A.xlsx`, want: "季度报告.xlsx"},
+		{name: "default path, no CD, MIME ext", safePath: "file_xxx", contentType: "application/pdf", want: "file_xxx.pdf"},
+		{name: "default path, no CD, unknown MIME", safePath: "file_xxx", contentType: "application/x-unknown", want: "file_xxx"},
+		{name: "default path, CD with dir component", safePath: "downloads/file_xxx", contentDisposition: `attachment; filename="report.xlsx"`, want: "downloads/report.xlsx"},
+		// User --output without extension: use CD filename's extension
+		{name: "user path no ext, CD with ext", safePath: "myfile", contentDisposition: `attachment; filename="server.pdf"`, userSpecifiedOutput: true, want: "myfile.pdf"},
+		{name: "user path no ext, CD no ext, MIME ext", safePath: "myfile", contentDisposition: `attachment; filename="noext"`, contentType: "image/png", userSpecifiedOutput: true, want: "myfile.png"},
+		{name: "user path no ext, no CD, MIME ext", safePath: "myfile", contentType: "image/jpeg", userSpecifiedOutput: true, want: "myfile.jpg"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := resolveIMResourceDownloadPath(tt.safePath, tt.contentType, tt.contentDisposition, tt.userSpecifiedOutput)
+			if got != tt.want {
+				t.Fatalf("resolveIMResourceDownloadPath() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
 func TestShortcuts(t *testing.T) {
 	var commands []string
 	for _, shortcut := range Shortcuts() {

shortcuts/im/im_messages_resources_download.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"mime"
 	"net/http"
 	"path/filepath"
 	"strconv"
@@ -31,7 +32,7 @@ var ImMessagesResourcesDownload = common.Shortcut{
 		{Name: "message-id", Desc: "message ID (om_xxx)", Required: true},
 		{Name: "file-key", Desc: "resource key (img_xxx or file_xxx)", Required: true},
 		{Name: "type", Desc: "resource type (image or file)", Required: true, Enum: []string{"image", "file"}},
-		{Name: "output", Desc: "local save path (relative only, no .. traversal; defaults to file_key)"},
+		{Name: "output", Desc: "local save path (relative only, no .. traversal); when omitted, uses the server's Content-Disposition filename if available, otherwise file_key; extension is inferred from Content-Disposition or Content-Type if not provided"},
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		fileKey := runtime.Str("file-key")
@@ -72,7 +73,8 @@ var ImMessagesResourcesDownload = common.Shortcut{
 			return output.ErrValidation("unsafe output path: %s", err)
 		}
 
-		finalPath, sizeBytes, err := downloadIMResourceToPath(ctx, runtime, messageId, fileKey, fileType, relPath)
+		userSpecifiedOutput := runtime.Str("output") != ""
+		finalPath, sizeBytes, err := downloadIMResourceToPath(ctx, runtime, messageId, fileKey, fileType, relPath, userSpecifiedOutput)
 		if err != nil {
 			return err
 		}
@@ -262,18 +264,21 @@ func initialIMResourceDownloadHeaders(fileType string) map[string]string {
 	}
 }
 
-func downloadIMResourceToPath(ctx context.Context, runtime *common.RuntimeContext, messageID, fileKey, fileType, outputPath string) (string, int64, error) {
+func downloadIMResourceToPath(ctx context.Context, runtime *common.RuntimeContext, messageID, fileKey, fileType, outputPath string, userSpecifiedOutput bool) (string, int64, error) {
 	downloadResp, err := doIMResourceDownloadRequest(ctx, runtime, messageID, fileKey, fileType, initialIMResourceDownloadHeaders(fileType))
 	if err != nil {
 		return "", 0, err
 	}
+	if downloadResp == nil {
+		return "", 0, output.ErrNetwork("download failed: empty response")
+	}
 
 	if downloadResp.StatusCode >= 400 {
 		defer downloadResp.Body.Close()
 		return "", 0, downloadResponseError(downloadResp)
 	}
 
-	finalPath := resolveIMResourceDownloadPath(outputPath, downloadResp.Header.Get("Content-Type"))
+	finalPath := resolveIMResourceDownloadPath(outputPath, downloadResp.Header.Get("Content-Type"), downloadResp.Header.Get("Content-Disposition"), userSpecifiedOutput)
 
 	var (
 		body      io.ReadCloser
@@ -316,18 +321,63 @@ func downloadIMResourceToPath(ctx context.Context, runtime *common.RuntimeContex
 	return savedPath, result.Size(), nil
 }
 
-func resolveIMResourceDownloadPath(safePath, contentType string) string {
+func resolveIMResourceDownloadPath(safePath, contentType, contentDisposition string, userSpecifiedOutput bool) string {
 	if filepath.Ext(safePath) != "" {
 		return safePath
 	}
-	mimeType := strings.Split(contentType, ";")[0]
-	mimeType = strings.TrimSpace(mimeType)
+	if cdFilename := parseContentDispositionFilename(contentDisposition); cdFilename != "" {
+		if !userSpecifiedOutput {
+			// No --output flag: use the original filename from the server.
+			dir := filepath.Dir(safePath)
+			if dir == "." {
+				return cdFilename
+			}
+			return filepath.Join(dir, cdFilename)
+		}
+		// User specified a path without extension: append the extension from the CD filename.
+		if ext := filepath.Ext(cdFilename); ext != "" {
+			return safePath + ext
+		}
+	}
+	mimeType := strings.TrimSpace(strings.Split(contentType, ";")[0])
 	if ext, ok := imMimeToExt[mimeType]; ok {
 		return safePath + ext
 	}
 	return safePath
 }
 
+// parseContentDispositionFilename extracts and sanitizes the filename from a
+// Content-Disposition header. It handles RFC 5987 encoded filenames (filename*)
+// with priority over plain filename via the standard mime package.
+// Returns an empty string if no valid filename can be extracted.
+func parseContentDispositionFilename(header string) string {
+	if header == "" {
+		return ""
+	}
+	_, params, err := mime.ParseMediaType(header)
+	if err != nil {
+		return ""
+	}
+	name := strings.TrimSpace(params["filename"])
+	if name == "" {
+		return ""
+	}
+	// Strip any path component (Unix or Windows style) to prevent path traversal.
+	if i := strings.LastIndexAny(name, "/\\"); i >= 0 {
+		name = name[i+1:]
+	}
+	if name == "" || name == "." || name == ".." {
+		return ""
+	}
+	// Reject control characters (including null bytes).
+	for _, r := range name {
+		if r < 0x20 || r == 0x7f {
+			return ""
+		}
+	}
+	return name
+}
+
 func doIMResourceDownloadRequest(ctx context.Context, runtime *common.RuntimeContext, messageID, fileKey, fileType string, headers map[string]string) (*http.Response, error) {
 	query := larkcore.QueryParams{}
 	query.Set("type", fileType)

shortcuts/mail/draft/large_attachment_parse.go

@@ -0,0 +1,452 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package draft
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	xhtml "golang.org/x/net/html"
+)
+
+// largeAttHeaderEntry is a union of the CLI and server JSON formats for
+// entries in the large attachment header.
+type largeAttHeaderEntry struct {
+	ID       string `json:"id,omitempty"`
+	FileKey  string `json:"file_key,omitempty"`
+	FileName string `json:"file_name,omitempty"`
+	FileSize int64  `json:"file_size,omitempty"`
+}
+
+func (e largeAttHeaderEntry) token() string {
+	if e.ID != "" {
+		return e.ID
+	}
+	return e.FileKey
+}
+
+// IsLargeAttachmentHeader returns true if the header name matches either
+// the CLI-written or server-returned large attachment header.
+func IsLargeAttachmentHeader(name string) bool {
+	return strings.EqualFold(name, LargeAttachmentIDsHeader) ||
+		strings.EqualFold(name, ServerLargeAttachmentHeader)
+}
+
+// decodeLargeAttachmentHeader decodes the base64 value and returns entries.
+func decodeLargeAttachmentHeader(value string) ([]largeAttHeaderEntry, error) {
+	decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(value))
+	if err != nil {
+		return nil, err
+	}
+	var items []largeAttHeaderEntry
+	if err := json.Unmarshal(decoded, &items); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// parseLargeAttachmentTokens returns the ordered list of large attachment
+// tokens from either X-Lms-Large-Attachment-Ids (CLI format) or
+// X-Lark-Large-Attachment (server format). Returns nil when neither
+// header is present or the value is malformed.
+func parseLargeAttachmentTokens(headers []Header) []string {
+	for _, h := range headers {
+		if !IsLargeAttachmentHeader(h.Name) {
+			continue
+		}
+		items, err := decodeLargeAttachmentHeader(h.Value)
+		if err != nil {
+			return nil
+		}
+		out := make([]string, 0, len(items))
+		for _, it := range items {
+			if tok := it.token(); tok != "" {
+				out = append(out, tok)
+			}
+		}
+		return out
+	}
+	return nil
+}
+
+// ParseLargeAttachmentSummariesFromHeader extracts full metadata from the
+// large attachment header. Returns non-nil only when the server-format
+// header (X-Lark-Large-Attachment) is found, since it carries file_name
+// and file_size that the CLI-format header lacks.
+func ParseLargeAttachmentSummariesFromHeader(headers []Header) []LargeAttachmentSummary {
+	for _, h := range headers {
+		if !strings.EqualFold(h.Name, ServerLargeAttachmentHeader) {
+			continue
+		}
+		items, err := decodeLargeAttachmentHeader(h.Value)
+		if err != nil {
+			return nil
+		}
+		out := make([]LargeAttachmentSummary, 0, len(items))
+		for _, it := range items {
+			tok := it.token()
+			if tok == "" {
+				continue
+			}
+			out = append(out, LargeAttachmentSummary{
+				Token:     tok,
+				FileName:  it.FileName,
+				SizeBytes: it.FileSize,
+			})
+		}
+		return out
+	}
+	return nil
+}
+
+// ParseLargeAttachmentItemsFromHTML walks the HTML body looking for large
+// attachment card items (<div id="large-file-item">) and returns a map
+// from token (data-mail-token attribute value) to filename + size.
+//
+// The size is parsed best-effort from the displayed string (e.g. "25.0 MB");
+// it carries the precision of the formatted value and is not byte-exact.
+func ParseLargeAttachmentItemsFromHTML(htmlBody string) map[string]LargeAttachmentSummary {
+	out := map[string]LargeAttachmentSummary{}
+	if htmlBody == "" {
+		return out
+	}
+	doc, err := xhtml.Parse(strings.NewReader(htmlBody))
+	if err != nil {
+		return out
+	}
+	var walk func(n *xhtml.Node)
+	walk = func(n *xhtml.Node) {
+		if n == nil {
+			return
+		}
+		if n.Type == xhtml.ElementNode && n.Data == "div" && attr(n, "id") == LargeFileItemID {
+			if token, meta, ok := extractItemMeta(n); ok {
+				out[token] = meta
+			}
+			// Do not descend further: the <a> and texts have been collected.
+			return
+		}
+		for c := n.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(doc)
+	return out
+}
+
+// extractItemMeta collects the token, filename, and size from a large
+// attachment item node. Returns ok=false when the token is missing.
+//
+// Expected structure (see largeAttItemTpl in mail/large_attachment.go):
+//
+//	<div id="large-file-item">
+//	  <div><img ... /></div>               // icon
+//	  <div>
+//	    <div>FILENAME</div>
+//	    <div><span>SIZE_DISPLAY</span></div>
+//	  </div>
+//	  <a data-mail-token="TOKEN" ...>DOWNLOAD_LABEL</a>
+//	</div>
+//
+// The token comes from the <a data-mail-token=...>. The first non-anchor
+// text is the filename; the next text is the size display.
+func extractItemMeta(item *xhtml.Node) (token string, meta LargeAttachmentSummary, ok bool) {
+	var texts []string
+	var insideAnchor bool
+
+	var walk func(n *xhtml.Node)
+	walk = func(n *xhtml.Node) {
+		if n == nil {
+			return
+		}
+		if n.Type == xhtml.ElementNode && n.Data == "a" {
+			if t := attr(n, LargeAttachmentTokenAttr); t != "" && token == "" {
+				token = t
+			}
+			// Skip collecting the anchor's label (e.g. "Download" / "下载").
+			prev := insideAnchor
+			insideAnchor = true
+			defer func() { insideAnchor = prev }()
+		}
+		if n.Type == xhtml.TextNode && !insideAnchor {
+			if s := strings.TrimSpace(n.Data); s != "" {
+				texts = append(texts, s)
+			}
+		}
+		for c := n.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(item)
+
+	if token == "" {
+		return "", LargeAttachmentSummary{}, false
+	}
+	if len(texts) > 0 {
+		meta.FileName = texts[0]
+	}
+	if len(texts) > 1 {
+		meta.SizeBytes = parseSizeDisplay(texts[1])
+	}
+	return token, meta, true
+}
+
+func attr(n *xhtml.Node, name string) string {
+	for _, a := range n.Attr {
+		if a.Key == name {
+			return a.Val
+		}
+	}
+	return ""
+}
+
+// sizeDisplayRe matches sizes like "25.0 MB", "1 GB", "500 KB", "42 B".
+// The unit is case-insensitive and may be B / KB / MB / GB / TB.
+var sizeDisplayRe = regexp.MustCompile(`(?i)^\s*([0-9]+(?:\.[0-9]+)?)\s*(B|KB|MB|GB|TB)\s*$`)
+
+// parseSizeDisplay converts a formatted size display string back into
+// an approximate byte count. Precision is limited by the display rounding
+// (e.g. "25.0 MB" round-trips to 26214400 bytes).
+// Returns 0 when the input cannot be parsed.
+func parseSizeDisplay(s string) int64 {
+	m := sizeDisplayRe.FindStringSubmatch(s)
+	if m == nil {
+		return 0
+	}
+	value, err := strconv.ParseFloat(m[1], 64)
+	if err != nil {
+		return 0
+	}
+	unit := strings.ToUpper(m[2])
+	var mul int64
+	switch unit {
+	case "B":
+		mul = 1
+	case "KB":
+		mul = 1024
+	case "MB":
+		mul = 1024 * 1024
+	case "GB":
+		mul = 1024 * 1024 * 1024
+	case "TB":
+		mul = 1024 * 1024 * 1024 * 1024
+	default:
+		return 0
+	}
+	return int64(value * float64(mul))
+}
+
+// removeLargeAttachment removes a large attachment by its file token.
+// It updates both representations:
+//
+//  1. X-Lms-Large-Attachment-Ids header: removes the token from the JSON
+//     ID list. If the list becomes empty, the header itself is removed.
+//  2. HTML body: removes the <div id="large-file-item"> whose <a> has the
+//     matching data-mail-token attribute. If the enclosing container
+//     <div id="large-file-area-*"> has no remaining items, the whole
+//     container is removed.
+func removeLargeAttachment(snapshot *DraftSnapshot, token string) error {
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return fmt.Errorf("remove_attachment: token is empty")
+	}
+	if err := removeTokenFromIDsHeader(snapshot, token); err != nil {
+		return err
+	}
+	if err := removeTokenFromHTMLBody(snapshot, token); err != nil {
+		return err
+	}
+	return nil
+}
+
+// removeTokenFromIDsHeader removes the given token from whichever large
+// attachment header is present (CLI or server format). Returns an error
+// if no header is found or the token is not listed. After removal, the
+// header is re-encoded in CLI format (X-Lms-Large-Attachment-Ids) so
+// the server can process the update on upload.
+func removeTokenFromIDsHeader(snapshot *DraftSnapshot, token string) error {
+	headerIdx := -1
+	for i, h := range snapshot.Headers {
+		if IsLargeAttachmentHeader(h.Name) {
+			headerIdx = i
+			break
+		}
+	}
+	if headerIdx < 0 {
+		return fmt.Errorf("remove_attachment: draft has no large attachment header")
+	}
+	items, err := decodeLargeAttachmentHeader(snapshot.Headers[headerIdx].Value)
+	if err != nil {
+		return fmt.Errorf("remove_attachment: malformed large attachment header: %w", err)
+	}
+	filtered := make([]largeAttHeaderEntry, 0, len(items))
+	removed := false
+	for _, it := range items {
+		if it.token() == token {
+			removed = true
+			continue
+		}
+		filtered = append(filtered, it)
+	}
+	if !removed {
+		return fmt.Errorf("remove_attachment: token %q not found in large attachment header", token)
+	}
+	if len(filtered) == 0 {
+		snapshot.Headers = append(snapshot.Headers[:headerIdx], snapshot.Headers[headerIdx+1:]...)
+		return nil
+	}
+	cliItems := make([]struct {
+		ID string `json:"id"`
+	}, len(filtered))
+	for i, it := range filtered {
+		cliItems[i].ID = it.token()
+	}
+	encoded, err := json.Marshal(cliItems)
+	if err != nil {
+		return fmt.Errorf("remove_attachment: failed to re-encode large attachment header: %w", err)
+	}
+	snapshot.Headers[headerIdx].Name = LargeAttachmentIDsHeader
+	snapshot.Headers[headerIdx].Value = base64.StdEncoding.EncodeToString(encoded)
+	return nil
+}
+
+// removeTokenFromHTMLBody walks the HTML body, removes the single
+// large-file-item whose anchor has data-mail-token == token, and if the
+// enclosing container becomes empty (no more large-file-item children),
+// removes the whole container.
+//
+// It is not an error if the HTML body or item is missing — the header
+// removal is still considered the authoritative operation. This handles
+// cases where the HTML was already edited out but the header wasn't.
+func removeTokenFromHTMLBody(snapshot *DraftSnapshot, token string) error {
+	htmlPart := FindHTMLBodyPart(snapshot.Body)
+	if htmlPart == nil || len(htmlPart.Body) == 0 {
+		return nil
+	}
+	body := string(htmlPart.Body)
+	newBody, changed := RemoveLargeFileItemFromHTML(body, token)
+	if !changed {
+		return nil
+	}
+	htmlPart.Body = []byte(newBody)
+	htmlPart.Dirty = true
+	return nil
+}
+
+// RemoveLargeFileItemFromHTML parses the HTML, finds the large-file-item
+// containing an <a> whose token matches (via data-mail-token attribute or
+// href URL token= parameter), removes that item, and if the enclosing
+// large-file-area container becomes empty, removes the container as well.
+// Returns the updated HTML and a changed flag.
+func RemoveLargeFileItemFromHTML(htmlBody, token string) (string, bool) {
+	doc, err := xhtml.Parse(strings.NewReader(htmlBody))
+	if err != nil {
+		return htmlBody, false
+	}
+	item := findLargeFileItemByToken(doc, token)
+	if item == nil {
+		return htmlBody, false
+	}
+	container := item.Parent
+	// Detach the item from its parent.
+	if container != nil {
+		container.RemoveChild(item)
+	}
+	// If the container is a large-file-area and has no remaining
+	// large-file-item children, remove the whole container.
+	if container != nil && isLargeFileAreaContainer(container) && !hasLargeFileItemChild(container) {
+		if grand := container.Parent; grand != nil {
+			grand.RemoveChild(container)
+		}
+	}
+	var buf bytes.Buffer
+	if err := xhtml.Render(&buf, doc); err != nil {
+		return htmlBody, false
+	}
+	return stripHTMLEnvelope(buf.String()), true
+}
+
+func findLargeFileItemByToken(n *xhtml.Node, token string) *xhtml.Node {
+	if n == nil {
+		return nil
+	}
+	if n.Type == xhtml.ElementNode && n.Data == "div" && attr(n, "id") == LargeFileItemID {
+		if itemContainsToken(n, token) {
+			return n
+		}
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		if found := findLargeFileItemByToken(c, token); found != nil {
+			return found
+		}
+	}
+	return nil
+}
+
+func itemContainsToken(item *xhtml.Node, token string) bool {
+	if item == nil {
+		return false
+	}
+	for c := item.FirstChild; c != nil; c = c.NextSibling {
+		if c.Type == xhtml.ElementNode && c.Data == "a" {
+			if attr(c, LargeAttachmentTokenAttr) == token {
+				return true
+			}
+			if hrefContainsToken(attr(c, "href"), token) {
+				return true
+			}
+		}
+		if itemContainsToken(c, token) {
+			return true
+		}
+	}
+	return false
+}
+
+func hrefContainsToken(href, token string) bool {
+	if href == "" || token == "" {
+		return false
+	}
+	u, err := url.Parse(href)
+	if err != nil {
+		return false
+	}
+	return u.Query().Get("token") == token
+}
+
+func isLargeFileAreaContainer(n *xhtml.Node) bool {
+	if n == nil || n.Type != xhtml.ElementNode || n.Data != "div" {
+		return false
+	}
+	return strings.HasPrefix(attr(n, "id"), LargeFileContainerIDPrefix)
+}
+
+func hasLargeFileItemChild(n *xhtml.Node) bool {
+	if n == nil {
+		return false
+	}
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		if c.Type == xhtml.ElementNode && c.Data == "div" && attr(c, "id") == LargeFileItemID {
+			return true
+		}
+		if hasLargeFileItemChild(c) {
+			return true
+		}
+	}
+	return false
+}
+
+// stripHTMLEnvelope removes the <html><head></head><body>...</body></html>
+// wrapper that xhtml.Parse + xhtml.Render adds around HTML fragments.
+func stripHTMLEnvelope(s string) string {
+	s = strings.TrimPrefix(s, "<html><head></head><body>")
+	s = strings.TrimSuffix(s, "</body></html>")
+	return s
+}

shortcuts/mail/draft/large_attachment_parse_test.go

@@ -0,0 +1,314 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package draft
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestParseLargeAttachmentTokens(t *testing.T) {
+	encode := func(ids ...string) string {
+		type item struct {
+			ID string `json:"id"`
+		}
+		items := make([]item, len(ids))
+		for i, id := range ids {
+			items[i] = item{ID: id}
+		}
+		b, _ := json.Marshal(items)
+		return base64.StdEncoding.EncodeToString(b)
+	}
+
+	cases := []struct {
+		name    string
+		headers []Header
+		want    []string
+	}{
+		{
+			name:    "empty headers",
+			headers: nil,
+			want:    nil,
+		},
+		{
+			name:    "header present with one token",
+			headers: []Header{{Name: LargeAttachmentIDsHeader, Value: encode("tokA")}},
+			want:    []string{"tokA"},
+		},
+		{
+			name:    "header present with multiple tokens in order",
+			headers: []Header{{Name: LargeAttachmentIDsHeader, Value: encode("tokA", "tokB", "tokC")}},
+			want:    []string{"tokA", "tokB", "tokC"},
+		},
+		{
+			name:    "case-insensitive header name match",
+			headers: []Header{{Name: "x-lms-large-attachment-ids", Value: encode("tokA")}},
+			want:    []string{"tokA"},
+		},
+		{
+			name:    "malformed base64 → nil",
+			headers: []Header{{Name: LargeAttachmentIDsHeader, Value: "not!!base64"}},
+			want:    nil,
+		},
+		{
+			name:    "malformed JSON → nil",
+			headers: []Header{{Name: LargeAttachmentIDsHeader, Value: base64.StdEncoding.EncodeToString([]byte("not json"))}},
+			want:    nil,
+		},
+		{
+			name:    "empty string IDs filtered out",
+			headers: []Header{{Name: LargeAttachmentIDsHeader, Value: encode("tokA", "", "tokB")}},
+			want:    []string{"tokA", "tokB"},
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := parseLargeAttachmentTokens(tc.headers)
+			if !equalStrings(got, tc.want) {
+				t.Errorf("got %v, want %v", got, tc.want)
+			}
+		})
+	}
+}
+
+func equalStrings(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestParseSizeDisplay(t *testing.T) {
+	cases := []struct {
+		in   string
+		want int64
+	}{
+		{"25.0 MB", 26214400},
+		{"1 GB", 1024 * 1024 * 1024},
+		{"500 KB", 500 * 1024},
+		{"42 B", 42},
+		{"  25.0 MB  ", 26214400}, // whitespace tolerated
+		{"25.0 mb", 26214400},     // case-insensitive
+		{"garbage", 0},
+		{"", 0},
+		{"25", 0},    // no unit
+		{"25 XB", 0}, // invalid unit
+	}
+	for _, tc := range cases {
+		if got := parseSizeDisplay(tc.in); got != tc.want {
+			t.Errorf("parseSizeDisplay(%q) = %d, want %d", tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestParseLargeAttachmentItemsFromHTML(t *testing.T) {
+	// Minimal HTML mirroring the structure generated by mail/large_attachment.go
+	item := func(token, filename, size string) string {
+		return `<div id="large-file-item">` +
+			`<div><img src="x.png"/></div>` +
+			`<div>` +
+			`<div>` + filename + `</div>` +
+			`<div><span>` + size + `</span></div>` +
+			`</div>` +
+			`<a href="x" data-mail-token="` + token + `">Download</a>` +
+			`</div>`
+	}
+
+	html := `<div id="large-file-area-123">` +
+		`<div>Title</div>` +
+		item("tokA", "a.pdf", "25.0 MB") +
+		item("tokB", "b.mov", "300 MB") +
+		`</div>`
+
+	got := ParseLargeAttachmentItemsFromHTML(html)
+	if len(got) != 2 {
+		t.Fatalf("expected 2 items, got %d: %+v", len(got), got)
+	}
+	if got["tokA"].FileName != "a.pdf" {
+		t.Errorf("tokA filename: got %q, want %q", got["tokA"].FileName, "a.pdf")
+	}
+	if got["tokA"].SizeBytes != 26214400 {
+		t.Errorf("tokA size: got %d, want 26214400", got["tokA"].SizeBytes)
+	}
+	if got["tokB"].FileName != "b.mov" {
+		t.Errorf("tokB filename: got %q, want %q", got["tokB"].FileName, "b.mov")
+	}
+	if got["tokB"].SizeBytes != 300*1024*1024 {
+		t.Errorf("tokB size: got %d, want %d", got["tokB"].SizeBytes, 300*1024*1024)
+	}
+}
+
+func TestProjectLargeAttachments_MergesHeaderAndHTML(t *testing.T) {
+	type idItem struct {
+		ID string `json:"id"`
+	}
+	idsJSON, _ := json.Marshal([]idItem{{ID: "tokA"}, {ID: "tokB"}})
+	headers := []Header{{Name: LargeAttachmentIDsHeader, Value: base64.StdEncoding.EncodeToString(idsJSON)}}
+
+	html := `<div id="large-file-area-1">` +
+		`<div>Title</div>` +
+		`<div id="large-file-item"><div>a.pdf</div><div><span>25.0 MB</span></div><a data-mail-token="tokA">D</a></div>` +
+		`<div id="large-file-item"><div>b.mov</div><div><span>300 MB</span></div><a data-mail-token="tokB">D</a></div>` +
+		`</div>`
+
+	got := projectLargeAttachments(headers, html)
+	if len(got) != 2 {
+		t.Fatalf("expected 2, got %d: %+v", len(got), got)
+	}
+	if got[0].Token != "tokA" || got[0].FileName != "a.pdf" || got[0].SizeBytes != 26214400 {
+		t.Errorf("index 0: %+v", got[0])
+	}
+	if got[1].Token != "tokB" || got[1].FileName != "b.mov" {
+		t.Errorf("index 1: %+v", got[1])
+	}
+}
+
+func TestProjectLargeAttachments_HeaderWithoutHTML(t *testing.T) {
+	// Token present in header but HTML missing the card entry (malformed draft).
+	// We still report the token with empty meta.
+	type idItem struct {
+		ID string `json:"id"`
+	}
+	idsJSON, _ := json.Marshal([]idItem{{ID: "orphanToken"}})
+	headers := []Header{{Name: LargeAttachmentIDsHeader, Value: base64.StdEncoding.EncodeToString(idsJSON)}}
+
+	got := projectLargeAttachments(headers, "")
+	if len(got) != 1 {
+		t.Fatalf("expected 1, got %d", len(got))
+	}
+	if got[0].Token != "orphanToken" {
+		t.Errorf("got token %q", got[0].Token)
+	}
+	if got[0].FileName != "" || got[0].SizeBytes != 0 {
+		t.Errorf("expected empty meta, got %+v", got[0])
+	}
+}
+
+func TestProjectLargeAttachments_NoHeader(t *testing.T) {
+	got := projectLargeAttachments(nil, `<div id="large-file-area-1">...</div>`)
+	if got != nil {
+		t.Errorf("expected nil, got %v", got)
+	}
+}
+
+func TestRemoveLargeAttachment_RemovesOneOfTwo(t *testing.T) {
+	type idItem struct {
+		ID string `json:"id"`
+	}
+	idsJSON, _ := json.Marshal([]idItem{{ID: "tokA"}, {ID: "tokB"}})
+	headerValue := base64.StdEncoding.EncodeToString(idsJSON)
+	html := `<html><body><p>hi</p><div id="large-file-area-1">` +
+		`<div>Title</div>` +
+		`<div id="large-file-item"><div>a.pdf</div><div><span>25.0 MB</span></div><a data-mail-token="tokA">D</a></div>` +
+		`<div id="large-file-item"><div>b.mov</div><div><span>300 MB</span></div><a data-mail-token="tokB">D</a></div>` +
+		`</div></body></html>`
+
+	snapshot := &DraftSnapshot{
+		Headers: []Header{{Name: LargeAttachmentIDsHeader, Value: headerValue}},
+		Body: &Part{
+			MediaType: "text/html",
+			Body:      []byte(html),
+		},
+	}
+
+	if err := removeLargeAttachment(snapshot, "tokA"); err != nil {
+		t.Fatalf("removeLargeAttachment: %v", err)
+	}
+
+	// Header should contain only tokB
+	tokens := parseLargeAttachmentTokens(snapshot.Headers)
+	if !equalStrings(tokens, []string{"tokB"}) {
+		t.Errorf("tokens after removal: got %v, want [tokB]", tokens)
+	}
+
+	// HTML should not contain data-mail-token="tokA" anymore, but still contain tokB and the container
+	newHTML := string(snapshot.Body.Body)
+	if strings.Contains(newHTML, `data-mail-token="tokA"`) {
+		t.Errorf("HTML still contains tokA item:\n%s", newHTML)
+	}
+	if !strings.Contains(newHTML, `data-mail-token="tokB"`) {
+		t.Errorf("HTML missing tokB item:\n%s", newHTML)
+	}
+	if !strings.Contains(newHTML, `id="large-file-area-1"`) {
+		t.Errorf("HTML missing container (should still exist with tokB):\n%s", newHTML)
+	}
+}
+
+func TestRemoveLargeAttachment_RemovesLastOneClearsContainer(t *testing.T) {
+	type idItem struct {
+		ID string `json:"id"`
+	}
+	idsJSON, _ := json.Marshal([]idItem{{ID: "tokOnly"}})
+	headerValue := base64.StdEncoding.EncodeToString(idsJSON)
+	html := `<html><body><p>hi</p><div id="large-file-area-1">` +
+		`<div>Title</div>` +
+		`<div id="large-file-item"><div>a.pdf</div><div><span>25.0 MB</span></div><a data-mail-token="tokOnly">D</a></div>` +
+		`</div></body></html>`
+
+	snapshot := &DraftSnapshot{
+		Headers: []Header{{Name: LargeAttachmentIDsHeader, Value: headerValue}},
+		Body: &Part{
+			MediaType: "text/html",
+			Body:      []byte(html),
+		},
+	}
+
+	if err := removeLargeAttachment(snapshot, "tokOnly"); err != nil {
+		t.Fatalf("removeLargeAttachment: %v", err)
+	}
+
+	// Header should be entirely removed (empty list)
+	for _, h := range snapshot.Headers {
+		if strings.EqualFold(h.Name, LargeAttachmentIDsHeader) {
+			t.Errorf("header should have been removed when list is empty")
+		}
+	}
+
+	// HTML should not contain the container at all
+	newHTML := string(snapshot.Body.Body)
+	if strings.Contains(newHTML, "large-file-area-1") {
+		t.Errorf("container should have been removed:\n%s", newHTML)
+	}
+	if strings.Contains(newHTML, "large-file-item") {
+		t.Errorf("no items should remain:\n%s", newHTML)
+	}
+	// Other body content should survive
+	if !strings.Contains(newHTML, "<p>hi</p>") {
+		t.Errorf("user body should remain:\n%s", newHTML)
+	}
+}
+
+func TestRemoveLargeAttachment_UnknownToken(t *testing.T) {
+	type idItem struct {
+		ID string `json:"id"`
+	}
+	idsJSON, _ := json.Marshal([]idItem{{ID: "tokA"}})
+	headerValue := base64.StdEncoding.EncodeToString(idsJSON)
+	snapshot := &DraftSnapshot{
+		Headers: []Header{{Name: LargeAttachmentIDsHeader, Value: headerValue}},
+		Body:    &Part{MediaType: "text/html", Body: []byte(`<p>hi</p>`)},
+	}
+	err := removeLargeAttachment(snapshot, "unknown")
+	if err == nil {
+		t.Errorf("expected error for unknown token")
+	}
+}
+
+func TestRemoveLargeAttachment_MissingHeader(t *testing.T) {
+	snapshot := &DraftSnapshot{
+		Headers: []Header{},
+		Body:    &Part{MediaType: "text/html", Body: []byte(`<p>hi</p>`)},
+	}
+	err := removeLargeAttachment(snapshot, "any")
+	if err == nil {
+		t.Errorf("expected error when header is missing")
+	}
+}

shortcuts/mail/draft/model.go

@@ -18,6 +18,11 @@ type DraftRaw struct {
 	RawEML  string
 }
 
+type DraftResult struct {
+	DraftID   string
+	Reference string
+}
+
 type Header struct {
 	Name  string
 	Value string
@@ -133,22 +138,33 @@ type PartSummary struct {
 	CID         string `json:"cid,omitempty"`
 }
 
+// LargeAttachmentSummary describes a single large attachment registered in
+// the draft via the X-Lms-Large-Attachment-Ids header. Unlike normal
+// attachments, large attachments have no MIME part — their existence is
+// conveyed by the header plus an HTML card in the body.
+type LargeAttachmentSummary struct {
+	Token     string `json:"token"`
+	FileName  string `json:"filename,omitempty"`
+	SizeBytes int64  `json:"size_bytes,omitempty"`
+}
+
 type DraftProjection struct {
-	Subject            string        `json:"subject"`
-	To                 []Address     `json:"to,omitempty"`
-	Cc                 []Address     `json:"cc,omitempty"`
-	Bcc                []Address     `json:"bcc,omitempty"`
-	ReplyTo            []Address     `json:"reply_to,omitempty"`
-	InReplyTo          string        `json:"in_reply_to,omitempty"`
-	References         string        `json:"references,omitempty"`
-	BodyText           string        `json:"body_text,omitempty"`
-	BodyHTMLSummary    string        `json:"body_html_summary,omitempty"`
-	HasQuotedContent   bool          `json:"has_quoted_content,omitempty"`
-	HasSignature       bool          `json:"has_signature,omitempty"`
-	SignatureID        string        `json:"signature_id,omitempty"`
-	AttachmentsSummary []PartSummary `json:"attachments_summary,omitempty"`
-	InlineSummary      []PartSummary `json:"inline_summary,omitempty"`
-	Warnings           []string      `json:"warnings,omitempty"`
+	Subject                 string                   `json:"subject"`
+	To                      []Address                `json:"to,omitempty"`
+	Cc                      []Address                `json:"cc,omitempty"`
+	Bcc                     []Address                `json:"bcc,omitempty"`
+	ReplyTo                 []Address                `json:"reply_to,omitempty"`
+	InReplyTo               string                   `json:"in_reply_to,omitempty"`
+	References              string                   `json:"references,omitempty"`
+	BodyText                string                   `json:"body_text,omitempty"`
+	BodyHTMLSummary         string                   `json:"body_html_summary,omitempty"`
+	HasQuotedContent        bool                     `json:"has_quoted_content,omitempty"`
+	HasSignature            bool                     `json:"has_signature,omitempty"`
+	SignatureID             string                   `json:"signature_id,omitempty"`
+	AttachmentsSummary      []PartSummary            `json:"attachments_summary,omitempty"`
+	LargeAttachmentsSummary []LargeAttachmentSummary `json:"large_attachments_summary,omitempty"`
+	InlineSummary           []PartSummary            `json:"inline_summary,omitempty"`
+	Warnings                []string                 `json:"warnings,omitempty"`
 }
 
 type Patch struct {
@@ -164,12 +180,25 @@ type PatchOptions struct {
 type AttachmentTarget struct {
 	PartID string `json:"part_id,omitempty"`
 	CID    string `json:"cid,omitempty"`
+	// Token selects a large attachment by its file token (registered via
+	// the X-Lms-Large-Attachment-Ids header). Only valid for
+	// remove_attachment; replace_inline/remove_inline operate on MIME
+	// parts and do not accept Token.
+	Token string `json:"token,omitempty"`
 }
 
+// hasKey reports whether a PartID or CID is set. Used for ops that
+// target MIME parts (replace_inline, remove_inline).
 func (t AttachmentTarget) hasKey() bool {
 	return strings.TrimSpace(t.PartID) != "" || strings.TrimSpace(t.CID) != ""
 }
 
+// hasAnyKey reports whether any locator (PartID, CID, or Token) is set.
+// Used for remove_attachment which supports all three.
+func (t AttachmentTarget) hasAnyKey() bool {
+	return t.hasKey() || strings.TrimSpace(t.Token) != ""
+}
+
 type PatchOp struct {
 	Op          string           `json:"op"`
 	Value       string           `json:"value,omitempty"`
@@ -271,8 +300,8 @@ func (op PatchOp) Validate() error {
 			return fmt.Errorf("add_attachment requires path")
 		}
 	case "remove_attachment":
-		if !op.Target.hasKey() {
-			return fmt.Errorf("remove_attachment requires target with at least one of part_id or cid")
+		if !op.Target.hasAnyKey() {
+			return fmt.Errorf("remove_attachment requires target with at least one of part_id, cid, or token")
 		}
 	case "add_inline":
 		if strings.TrimSpace(op.Path) == "" {

shortcuts/mail/draft/patch.go

@@ -104,7 +104,16 @@ func applyOp(dctx *DraftCtx, snapshot *DraftSnapshot, op PatchOp, options PatchO
 	case "add_attachment":
 		return addAttachment(dctx, snapshot, op.Path)
 	case "remove_attachment":
-		partID, err := resolveTarget(snapshot, op.Target)
+		// Priority: part_id > cid > token. When only token is set, route to
+		// the large attachment path (updates header + HTML card, no MIME
+		// part to remove). Otherwise, resolve to a concrete part_id.
+		tgt := op.Target
+		if strings.TrimSpace(tgt.PartID) == "" && strings.TrimSpace(tgt.CID) == "" {
+			if token := strings.TrimSpace(tgt.Token); token != "" {
+				return removeLargeAttachment(snapshot, token)
+			}
+		}
+		partID, err := resolveTarget(snapshot, tgt)
 		if err != nil {
 			return fmt.Errorf("remove_attachment: %w", err)
 		}
@@ -257,7 +266,19 @@ func appendBody(snapshot *DraftSnapshot, bodyKind, value string, options PatchOp
 	return nil
 }
 
+// setBody replaces the body with value. Before replacement, it
+// automatically preserves system-managed elements (signature block and
+// large attachment card) from the old body, so body edits do not
+// accidentally delete content the user didn't author. Users can still
+// replace these elements explicitly by including their own equivalents
+// in the new value; they can delete them explicitly via the dedicated
+// ops (remove_signature, remove_attachment).
+//
+// This mirrors how normal attachments (independent MIME parts) survive
+// body edits — giving consistent mental model: attachments and signature
+// are draft-level concerns, not body content.
 func setBody(snapshot *DraftSnapshot, value string, options PatchOptions) error {
+	value = autoPreserveSystemManagedRegions(snapshot, value)
 	switch {
 	case snapshot.PrimaryTextPartID != "" && snapshot.PrimaryHTMLPartID == "":
 		return replaceBody(snapshot, "text/plain", value, options)
@@ -276,27 +297,70 @@ func setBody(snapshot *DraftSnapshot, value string, options PatchOptions) error
 	}
 }
 
-// setReplyBody replaces only the user-authored portion of the HTML body,
-// preserving the trailing reply/forward quote block (the
-// history-quote-wrapper div generated by +reply / +forward). If no quote
-// block is found, it falls back to setBody.
+// autoPreserveSystemManagedRegions extracts system-managed elements
+// (signature block and large attachment card) from the draft's old HTML
+// body and injects them into value (before any quote block in value, or
+// appended when no quote). Order is [sig][card], matching compose-time
+// layout [user][sig][card][quote].
+//
+// For each element, auto-injection is skipped when value's
+// user-authored region (before any quote block in value) already
+// contains that element — so users who explicitly reconstruct the body
+// with their own signature / card are respected. Elements inside a
+// quote block in value belong to the quoted original message and are
+// ignored for this check.
+//
+// No-op when the draft has no HTML body, or neither element exists in
+// the old body.
+func autoPreserveSystemManagedRegions(snapshot *DraftSnapshot, value string) string {
+	htmlPart := findPart(snapshot.Body, snapshot.PrimaryHTMLPartID)
+	if htmlPart == nil {
+		return value
+	}
+	oldHTML := string(htmlPart.Body)
+
+	sig := ExtractSignatureBlock(oldHTML)
+	_, card, _ := SplitAtLargeAttachment(oldHTML)
+	if sig == "" && card == "" {
+		return value
+	}
+
+	valuePreQuote, _ := SplitAtQuote(value)
+	if sig != "" && signatureWrapperRe.MatchString(valuePreQuote) {
+		sig = ""
+	}
+	if card != "" && HTMLContainsLargeAttachment(valuePreQuote) {
+		card = ""
+	}
+	if sig == "" && card == "" {
+		return value
+	}
+
+	return InsertBeforeQuoteOrAppend(value, sig+card)
+}
+
+// setReplyBody replaces only the user-authored portion of the HTML
+// body, preserving the trailing reply/forward quote block (generated
+// by +reply / +forward). Signature and large attachment card
+// preservation is delegated to setBody, which handles them via
+// autoPreserveSystemManagedRegions. When there is no quote block, this
+// falls through to setBody with no quote to preserve.
 func setReplyBody(snapshot *DraftSnapshot, value string, options PatchOptions) error {
 	htmlPartID := snapshot.PrimaryHTMLPartID
 	if htmlPartID == "" {
-		// No HTML part — fall back to setBody which handles text-only drafts.
 		return setBody(snapshot, value, options)
 	}
 	htmlPart := findPart(snapshot.Body, htmlPartID)
 	if htmlPart == nil {
 		return setBody(snapshot, value, options)
 	}
-	_, quotePart := SplitAtQuote(string(htmlPart.Body))
-	if quotePart == "" {
-		// No quote block found — fall back to regular set_body.
+	_, quote := SplitAtQuote(string(htmlPart.Body))
+	if quote == "" {
 		return setBody(snapshot, value, options)
 	}
-	// Combine the new user content with the preserved quote block.
-	return setBody(snapshot, value+quotePart, options)
+	// setBody's autoPreserve will insert the card before the quote wrapper
+	// it finds inside value (which is the quote we just appended here).
+	return setBody(snapshot, value+quote, options)
 }
 
 func tryApplyCoupledBodySetBody(snapshot *DraftSnapshot, value string) bool {
@@ -1147,41 +1211,41 @@ func postProcessInlineImages(dctx *DraftCtx, snapshot *DraftSnapshot, resolveLoc
 // insertSignatureOp inserts a pre-rendered signature into the HTML body.
 // The RenderedSignatureHTML and SignatureImages fields must be populated
 // by the shortcut layer before calling Apply.
+//
+// Placement: signature goes between the user-authored region and any
+// system-managed tail (large attachment card or history quote wrapper),
+// matching the compose-time order [user][sig][card?][quote?]. When the
+// draft already has a signature, it is replaced in place.
 func insertSignatureOp(snapshot *DraftSnapshot, op PatchOp) error {
 	htmlPart := findPart(snapshot.Body, snapshot.PrimaryHTMLPartID)
 	if htmlPart == nil {
 		return fmt.Errorf("insert_signature: no HTML body part found; use set_body first")
 	}
-	html := string(htmlPart.Body)
+	oldHTML := string(htmlPart.Body)
 
-	// Collect CIDs from old signature before removing it, so we can
-	// clean up orphaned MIME inline parts and avoid duplicates.
-	oldSigCIDs := collectSignatureCIDsFromHTML(html)
+	// Collect CIDs from old signature before replacement so we can prune
+	// MIME inline parts that the new signature doesn't re-reference.
+	oldSigCIDs := collectSignatureCIDsFromHTML(oldHTML)
 
-	// Remove existing signature (if any), including preceding spacing.
-	html = RemoveSignatureHTML(html)
+	sigBlock := SignatureSpacing() + BuildSignatureHTML(op.SignatureID, op.RenderedSignatureHTML)
+	newHTML := PlaceSignatureBeforeSystemTail(oldHTML, sigBlock)
 
 	// Remove orphaned MIME inline parts from old signature.
 	for _, cid := range oldSigCIDs {
-		if !containsCIDIgnoreCase(html, cid) {
+		if !containsCIDIgnoreCase(newHTML, cid) {
 			removeMIMEPartByCID(snapshot.Body, cid)
 		}
 	}
 
-	// Split at quote and insert signature between body and quote.
-	body, quote := SplitAtQuote(html)
-	sigBlock := SignatureSpacing() + BuildSignatureHTML(op.SignatureID, op.RenderedSignatureHTML)
-	html = body + sigBlock + quote
-
-	htmlPart.Body = []byte(html)
+	htmlPart.Body = []byte(newHTML)
 	htmlPart.Dirty = true
 
-	// Add signature inline images to the MIME tree.
+	// Add new signature inline images to the MIME tree.
 	for _, img := range op.SignatureImages {
 		addInlinePartToSnapshot(snapshot, img.Data, img.ContentType, img.FileName, img.CID)
 	}
 
-	syncTextPartFromHTML(snapshot, html)
+	syncTextPartFromHTML(snapshot, newHTML)
 	return nil
 }
 

shortcuts/mail/draft/patch_body_large_attachment_test.go

@@ -0,0 +1,425 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package draft
+
+import (
+	"strings"
+	"testing"
+)
+
+// buildSnapshotWithCard builds a minimal snapshot whose HTML body contains
+// a user section, a large attachment card, and optionally a quote block.
+func buildSnapshotWithCard(userContent, card, quote string) *DraftSnapshot {
+	html := userContent + card + quote
+	return &DraftSnapshot{
+		PrimaryHTMLPartID: "1",
+		Body: &Part{
+			PartID:    "1",
+			MediaType: "text/html",
+			Body:      []byte(html),
+		},
+	}
+}
+
+// buildSnapshotFromHTML wraps arbitrary HTML into a minimal snapshot.
+func buildSnapshotFromHTML(html string) *DraftSnapshot {
+	return &DraftSnapshot{
+		PrimaryHTMLPartID: "1",
+		Body: &Part{
+			PartID:    "1",
+			MediaType: "text/html",
+			Body:      []byte(html),
+		},
+	}
+}
+
+const testLargeCard = `<div id="large-file-area-123"><div>Title</div>` +
+	`<div id="large-file-item"><div>a.pdf</div><div><span>25.0 MB</span></div>` +
+	`<a data-mail-token="tokA">D</a></div></div>`
+
+const testQuoteBlock = `<div class="history-quote-wrapper"><p>original msg</p></div>`
+
+// testSigBlock mirrors what BuildSignatureHTML would produce, including
+// the preceding SignatureSpacing.
+var testSigBlock = SignatureSpacing() + `<div id="sig-abc" class="lark-mail-signature" style="padding-top:6px;padding-bottom:6px"><div>-- My Sig</div></div>`
+
+func TestSetBody_PreservesLargeAttachmentCard(t *testing.T) {
+	snap := buildSnapshotWithCard(`<p>old user content</p>`, testLargeCard, "")
+
+	err := setBody(snap, `<p>new user content</p>`, PatchOptions{})
+	if err != nil {
+		t.Fatalf("setBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	if !strings.Contains(newHTML, "new user content") {
+		t.Errorf("missing new content: %s", newHTML)
+	}
+	if strings.Contains(newHTML, "old user content") {
+		t.Errorf("old content should be gone: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, `id="large-file-area-123"`) {
+		t.Errorf("card should be preserved: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, "a.pdf") || !strings.Contains(newHTML, "tokA") {
+		t.Errorf("card contents should be preserved: %s", newHTML)
+	}
+}
+
+func TestSetBody_RespectsUserSuppliedCard(t *testing.T) {
+	// When user's value already contains a large-file-area div, we must not
+	// auto-duplicate. Result should have only the user's card, not the old one.
+	snap := buildSnapshotWithCard(`<p>old</p>`, testLargeCard, "")
+
+	userCard := `<div id="large-file-area-999"><div id="large-file-item">` +
+		`<a data-mail-token="userTok">X</a></div></div>`
+	err := setBody(snap, `<p>new</p>`+userCard, PatchOptions{})
+	if err != nil {
+		t.Fatalf("setBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	if !strings.Contains(newHTML, "userTok") {
+		t.Errorf("user's card should be present: %s", newHTML)
+	}
+	if strings.Contains(newHTML, "large-file-area-123") {
+		t.Errorf("old card should be gone (user supplied replacement): %s", newHTML)
+	}
+	// Should not be duplicated
+	if strings.Count(newHTML, "large-file-area-") != 1 {
+		t.Errorf("should have exactly one card, got %d: %s",
+			strings.Count(newHTML, "large-file-area-"), newHTML)
+	}
+}
+
+func TestSetBody_WithoutCardUnchangedBehavior(t *testing.T) {
+	// No card in draft — setBody behaves as before.
+	snap := &DraftSnapshot{
+		PrimaryHTMLPartID: "1",
+		Body: &Part{
+			PartID:    "1",
+			MediaType: "text/html",
+			Body:      []byte(`<p>old</p>`),
+		},
+	}
+	err := setBody(snap, `<p>new</p>`, PatchOptions{})
+	if err != nil {
+		t.Fatalf("setBody: %v", err)
+	}
+	if string(snap.Body.Body) != `<p>new</p>` {
+		t.Errorf("unexpected body: %q", string(snap.Body.Body))
+	}
+}
+
+func TestSetReplyBody_PreservesCardAndQuote(t *testing.T) {
+	snap := buildSnapshotWithCard(`<p>old user</p>`, testLargeCard, testQuoteBlock)
+
+	err := setReplyBody(snap, `<p>new user</p>`, PatchOptions{})
+	if err != nil {
+		t.Fatalf("setReplyBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	if !strings.Contains(newHTML, "new user") {
+		t.Errorf("missing new content: %s", newHTML)
+	}
+	if strings.Contains(newHTML, "old user") {
+		t.Errorf("old user content should be gone: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, `id="large-file-area-123"`) {
+		t.Errorf("card should be preserved: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, "original msg") {
+		t.Errorf("quote should be preserved: %s", newHTML)
+	}
+	// Order: new user < card < quote
+	newIdx := strings.Index(newHTML, "new user")
+	cardIdx := strings.Index(newHTML, "large-file-area")
+	quoteIdx := strings.Index(newHTML, "original msg")
+	if !(newIdx < cardIdx && cardIdx < quoteIdx) {
+		t.Errorf("expected order [user][card][quote]: newIdx=%d cardIdx=%d quoteIdx=%d, html=%s",
+			newIdx, cardIdx, quoteIdx, newHTML)
+	}
+}
+
+// TestSetReplyBody_ReplyToMessageWithCard verifies that when replying to
+// a message that itself contained a large attachment (so the quote block
+// in the draft contains the original sender's card), the user's own card
+// (sitting before the quote wrapper) is still preserved after
+// set_reply_body. The check in autoPreserveLargeAttachmentCard must only
+// look at value's user region, not inside the appended quote block.
+func TestSetReplyBody_ReplyToMessageWithCard(t *testing.T) {
+	originalCardInQuote := `<div id="large-file-area-orig">` +
+		`<div id="large-file-item"><a data-mail-token="origTok">D</a></div>` +
+		`</div>`
+	quoteWithOrigCard := `<div class="history-quote-wrapper">` +
+		`<p>original message text</p>` + originalCardInQuote +
+		`</div>`
+
+	// Draft structure: [my reply][my card][quote[orig card]]
+	snap := buildSnapshotWithCard(`<p>my old reply</p>`, testLargeCard, quoteWithOrigCard)
+
+	err := setReplyBody(snap, `<p>my new reply</p>`, PatchOptions{})
+	if err != nil {
+		t.Fatalf("setReplyBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	// My card (from [my card] slot) should be preserved, even though the
+	// quote block contains the original sender's card.
+	if !strings.Contains(newHTML, `id="large-file-area-123"`) {
+		t.Errorf("my own card (large-file-area-123) should be preserved: %s", newHTML)
+	}
+	// Original sender's card is still in the quote block (untouched by reply).
+	if !strings.Contains(newHTML, `id="large-file-area-orig"`) {
+		t.Errorf("original sender's card in quote should remain: %s", newHTML)
+	}
+	// New content present, old content gone.
+	if !strings.Contains(newHTML, "my new reply") {
+		t.Errorf("new content missing: %s", newHTML)
+	}
+	if strings.Contains(newHTML, "my old reply") {
+		t.Errorf("old content should be gone: %s", newHTML)
+	}
+	// Order: new user content < my card < quote wrapper (which contains orig card)
+	newIdx := strings.Index(newHTML, "my new reply")
+	myCardIdx := strings.Index(newHTML, "large-file-area-123")
+	quoteIdx := strings.Index(newHTML, "history-quote-wrapper")
+	origCardIdx := strings.Index(newHTML, "large-file-area-orig")
+	if !(newIdx < myCardIdx && myCardIdx < quoteIdx && quoteIdx < origCardIdx) {
+		t.Errorf("expected order [user][my-card][quote[orig-card]]: new=%d my-card=%d quote=%d orig-card=%d\nhtml=%s",
+			newIdx, myCardIdx, quoteIdx, origCardIdx, newHTML)
+	}
+}
+
+func TestSetReplyBody_NoQuoteFallsBackToSetBody(t *testing.T) {
+	// No quote — setReplyBody falls back to setBody, which preserves card.
+	snap := buildSnapshotWithCard(`<p>old</p>`, testLargeCard, "")
+
+	err := setReplyBody(snap, `<p>new</p>`, PatchOptions{})
+	if err != nil {
+		t.Fatalf("setReplyBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	if !strings.Contains(newHTML, "large-file-area-123") {
+		t.Errorf("card should be preserved: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, "new") {
+		t.Errorf("missing new content: %s", newHTML)
+	}
+}
+
+func TestSplitAtLargeAttachment(t *testing.T) {
+	cases := []struct {
+		name       string
+		html       string
+		wantBefore string
+		wantCardIn string // substring expected in card
+		wantAfter  string
+	}{
+		{
+			name:       "no card",
+			html:       `<p>hello</p>`,
+			wantBefore: `<p>hello</p>`,
+			wantCardIn: "",
+			wantAfter:  "",
+		},
+		{
+			name:       "card at end",
+			html:       `<p>user</p><div id="large-file-area-1"><div id="large-file-item"></div></div>`,
+			wantBefore: `<p>user</p>`,
+			wantCardIn: "large-file-area-1",
+			wantAfter:  "",
+		},
+		{
+			name: "card before quote",
+			html: `<p>user</p>` +
+				`<div id="large-file-area-1"><div id="large-file-item"></div></div>` +
+				`<div class="history-quote-wrapper">q</div>`,
+			wantBefore: `<p>user</p>`,
+			wantCardIn: "large-file-area-1",
+			wantAfter:  `<div class="history-quote-wrapper">q</div>`,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			before, card, after := SplitAtLargeAttachment(tc.html)
+			if before != tc.wantBefore {
+				t.Errorf("before: got %q, want %q", before, tc.wantBefore)
+			}
+			if tc.wantCardIn == "" && card != "" {
+				t.Errorf("card should be empty, got %q", card)
+			}
+			if tc.wantCardIn != "" && !strings.Contains(card, tc.wantCardIn) {
+				t.Errorf("card should contain %q, got %q", tc.wantCardIn, card)
+			}
+			if after != tc.wantAfter {
+				t.Errorf("after: got %q, want %q", after, tc.wantAfter)
+			}
+		})
+	}
+}
+
+// ---------------------------------------------------------------------------
+// set_body / set_reply_body: signature auto-preservation
+// ---------------------------------------------------------------------------
+
+func TestSetBody_PreservesSignature(t *testing.T) {
+	snap := buildSnapshotFromHTML(`<p>old user</p>` + testSigBlock)
+
+	if err := setBody(snap, `<p>new user</p>`, PatchOptions{}); err != nil {
+		t.Fatalf("setBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+	if !strings.Contains(newHTML, "new user") {
+		t.Errorf("missing new content: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, `class="lark-mail-signature"`) {
+		t.Errorf("signature should be preserved: %s", newHTML)
+	}
+	if !strings.Contains(newHTML, "My Sig") {
+		t.Errorf("signature content should be preserved: %s", newHTML)
+	}
+	// Order: new user content < signature
+	newIdx := strings.Index(newHTML, "new user")
+	sigIdx := strings.Index(newHTML, "lark-mail-signature")
+	if newIdx > sigIdx {
+		t.Errorf("signature should come after new content: new@%d sig@%d", newIdx, sigIdx)
+	}
+}
+
+func TestSetBody_PreservesSignatureAndCard(t *testing.T) {
+	snap := buildSnapshotFromHTML(`<p>old</p>` + testSigBlock + testLargeCard)
+
+	if err := setBody(snap, `<p>new</p>`, PatchOptions{}); err != nil {
+		t.Fatalf("setBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	newIdx := strings.Index(newHTML, "new")
+	sigIdx := strings.Index(newHTML, "lark-mail-signature")
+	cardIdx := strings.Index(newHTML, "large-file-area-123")
+	if newIdx < 0 || sigIdx < 0 || cardIdx < 0 {
+		t.Fatalf("missing parts: %s", newHTML)
+	}
+	if !(newIdx < sigIdx && sigIdx < cardIdx) {
+		t.Errorf("expected order [new][sig][card], got new@%d sig@%d card@%d",
+			newIdx, sigIdx, cardIdx)
+	}
+}
+
+func TestSetBody_RespectsUserSuppliedSignature(t *testing.T) {
+	snap := buildSnapshotFromHTML(`<p>old</p>` + testSigBlock)
+
+	userSig := `<div id="user-sig" class="lark-mail-signature"><div>-- User Sig</div></div>`
+	if err := setBody(snap, `<p>new</p>`+userSig, PatchOptions{}); err != nil {
+		t.Fatalf("setBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	if !strings.Contains(newHTML, "User Sig") {
+		t.Errorf("user-supplied sig should be present: %s", newHTML)
+	}
+	if strings.Contains(newHTML, "My Sig") {
+		t.Errorf("old signature should be gone when user supplied their own: %s", newHTML)
+	}
+	// Only one signature wrapper
+	if strings.Count(newHTML, "lark-mail-signature") != 1 {
+		t.Errorf("expected exactly one signature wrapper, got %d",
+			strings.Count(newHTML, "lark-mail-signature"))
+	}
+}
+
+func TestSetReplyBody_PreservesSignatureAndQuote(t *testing.T) {
+	snap := buildSnapshotFromHTML(`<p>old user</p>` + testSigBlock + testQuoteBlock)
+
+	if err := setReplyBody(snap, `<p>new user</p>`, PatchOptions{}); err != nil {
+		t.Fatalf("setReplyBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	newIdx := strings.Index(newHTML, "new user")
+	sigIdx := strings.Index(newHTML, "lark-mail-signature")
+	quoteIdx := strings.Index(newHTML, "history-quote-wrapper")
+	if !(newIdx < sigIdx && sigIdx < quoteIdx) {
+		t.Errorf("expected [new user][sig][quote], got new@%d sig@%d quote@%d",
+			newIdx, sigIdx, quoteIdx)
+	}
+}
+
+func TestSetReplyBody_PreservesAllThreeRegions(t *testing.T) {
+	snap := buildSnapshotFromHTML(`<p>old user</p>` + testSigBlock + testLargeCard + testQuoteBlock)
+
+	if err := setReplyBody(snap, `<p>new user</p>`, PatchOptions{}); err != nil {
+		t.Fatalf("setReplyBody: %v", err)
+	}
+	newHTML := string(snap.Body.Body)
+
+	newIdx := strings.Index(newHTML, "new user")
+	sigIdx := strings.Index(newHTML, "lark-mail-signature")
+	cardIdx := strings.Index(newHTML, "large-file-area-123")
+	quoteIdx := strings.Index(newHTML, "history-quote-wrapper")
+	if !(newIdx < sigIdx && sigIdx < cardIdx && cardIdx < quoteIdx) {
+		t.Errorf("expected [new][sig][card][quote], got new@%d sig@%d card@%d quote@%d",
+			newIdx, sigIdx, cardIdx, quoteIdx)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// ExtractSignatureBlock: symmetric with RemoveSignatureHTML
+// ---------------------------------------------------------------------------
+
+func TestExtractSignatureBlock_Symmetry(t *testing.T) {
+	cases := []string{
+		`<p>user</p>` + testSigBlock,
+		`<p>user</p>` + testSigBlock + testQuoteBlock,
+		`<p>user</p>` + testSigBlock + testLargeCard + testQuoteBlock,
+	}
+	for _, html := range cases {
+		extracted := ExtractSignatureBlock(html)
+		cleaned := RemoveSignatureHTML(html)
+		if extracted == "" {
+			t.Errorf("extract returned empty for: %s", html)
+			continue
+		}
+		// The concatenation of cleaned + extracted (inserted back at the
+		// right spot) should reconstitute the original. Since we don't
+		// know the position, verify extract contains "lark-mail-signature"
+		// and cleaned doesn't.
+		if !strings.Contains(extracted, "lark-mail-signature") {
+			t.Errorf("extract missing signature class: %s", extracted)
+		}
+		if strings.Contains(cleaned, "lark-mail-signature") {
+			t.Errorf("clean still has signature: %s", cleaned)
+		}
+		// Length invariant: original == cleaned + extracted (bytes)
+		if len(html) != len(cleaned)+len(extracted) {
+			t.Errorf("length mismatch: %d != %d + %d", len(html), len(cleaned), len(extracted))
+		}
+	}
+}
+
+func TestExtractSignatureBlock_NoSignature(t *testing.T) {
+	if got := ExtractSignatureBlock(`<p>just text</p>`); got != "" {
+		t.Errorf("expected empty, got %q", got)
+	}
+}
+
+func TestHTMLContainsLargeAttachment(t *testing.T) {
+	cases := []struct {
+		html string
+		want bool
+	}{
+		{`<p>hello</p>`, false},
+		{`<div id="large-file-area-123"></div>`, true},
+		{`<p>the text "large-file-area-" in body</p>`, false},
+		{`<div class="x" id="large-file-area-abc" style="...">`, true},
+	}
+	for _, tc := range cases {
+		if got := HTMLContainsLargeAttachment(tc.html); got != tc.want {
+			t.Errorf("HTMLContainsLargeAttachment(%q) = %v, want %v", tc.html, got, tc.want)
+		}
+	}
+}

shortcuts/mail/draft/patch_signature_test.go

@@ -118,6 +118,122 @@ Content-Type: text/html; charset=UTF-8
 	}
 }
 
+// ---------------------------------------------------------------------------
+// insert_signature — with large attachment card (no quote)
+// ---------------------------------------------------------------------------
+
+func TestInsertSignature_BeforeCard(t *testing.T) {
+	snapshot := mustParseFixtureDraft(t, `Subject: Sig before card
+From: Alice <alice@example.com>
+To: Bob <bob@example.com>
+MIME-Version: 1.0
+Content-Type: text/html; charset=UTF-8
+
+<p>My reply</p><div id="large-file-area-123" style="..."><div id="large-file-item"><a data-mail-token="tokA">D</a></div></div>`)
+
+	err := Apply(&DraftCtx{FIO: testFIO}, snapshot, Patch{
+		Ops: []PatchOp{{
+			Op:                    "insert_signature",
+			SignatureID:           "sig-card",
+			RenderedSignatureHTML: "<div>-- My Sig</div>",
+		}},
+	})
+	if err != nil {
+		t.Fatalf("Apply insert_signature: %v", err)
+	}
+
+	html := string(findPart(snapshot.Body, snapshot.PrimaryHTMLPartID).Body)
+	userIdx := strings.Index(html, "My reply")
+	sigIdx := strings.Index(html, "My Sig")
+	cardIdx := strings.Index(html, "large-file-area-123")
+	if userIdx < 0 || sigIdx < 0 || cardIdx < 0 {
+		t.Fatalf("missing part(s) in html: %s", html)
+	}
+	if !(userIdx < sigIdx && sigIdx < cardIdx) {
+		t.Errorf("expected order [user][sig][card], got user@%d sig@%d card@%d: %s",
+			userIdx, sigIdx, cardIdx, html)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// insert_signature — with large attachment card AND quote
+// ---------------------------------------------------------------------------
+
+func TestInsertSignature_BeforeCardAndQuote(t *testing.T) {
+	snapshot := mustParseFixtureDraft(t, `Subject: Sig before card and quote
+From: Alice <alice@example.com>
+To: Bob <bob@example.com>
+MIME-Version: 1.0
+Content-Type: text/html; charset=UTF-8
+
+<p>My reply</p><div id="large-file-area-123"><div id="large-file-item"><a data-mail-token="tokA">D</a></div></div><div class="history-quote-wrapper"><p>quoted</p></div>`)
+
+	err := Apply(&DraftCtx{FIO: testFIO}, snapshot, Patch{
+		Ops: []PatchOp{{
+			Op:                    "insert_signature",
+			SignatureID:           "sig-all",
+			RenderedSignatureHTML: "<div>-- My Sig</div>",
+		}},
+	})
+	if err != nil {
+		t.Fatalf("Apply insert_signature: %v", err)
+	}
+
+	html := string(findPart(snapshot.Body, snapshot.PrimaryHTMLPartID).Body)
+	userIdx := strings.Index(html, "My reply")
+	sigIdx := strings.Index(html, "My Sig")
+	cardIdx := strings.Index(html, "large-file-area-123")
+	quoteIdx := strings.Index(html, "quoted")
+	if userIdx < 0 || sigIdx < 0 || cardIdx < 0 || quoteIdx < 0 {
+		t.Fatalf("missing part(s) in html: %s", html)
+	}
+	if !(userIdx < sigIdx && sigIdx < cardIdx && cardIdx < quoteIdx) {
+		t.Errorf("expected order [user][sig][card][quote], got user@%d sig@%d card@%d quote@%d",
+			userIdx, sigIdx, cardIdx, quoteIdx)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// insert_signature — replaces existing signature that sits after card
+// (legacy draft produced by old buggy code); new signature should move
+// back to the correct position before the card.
+// ---------------------------------------------------------------------------
+
+func TestInsertSignature_ReplacesExistingWithCard(t *testing.T) {
+	// Old bad draft: [user][card][sig_old][quote] (legacy layout)
+	snapshot := mustParseFixtureDraft(t, `Subject: Replace sig with card
+From: Alice <alice@example.com>
+To: Bob <bob@example.com>
+MIME-Version: 1.0
+Content-Type: text/html; charset=UTF-8
+
+<p>My reply</p><div id="large-file-area-123"><div id="large-file-item"><a data-mail-token="tokA">D</a></div></div><div id="old-sig" class="lark-mail-signature" style="padding-top:6px;padding-bottom:6px"><div>-- Old Sig</div></div><div class="history-quote-wrapper"><p>quoted</p></div>`)
+
+	err := Apply(&DraftCtx{FIO: testFIO}, snapshot, Patch{
+		Ops: []PatchOp{{
+			Op:                    "insert_signature",
+			SignatureID:           "new-sig",
+			RenderedSignatureHTML: "<div>-- New Sig</div>",
+		}},
+	})
+	if err != nil {
+		t.Fatalf("Apply insert_signature: %v", err)
+	}
+
+	html := string(findPart(snapshot.Body, snapshot.PrimaryHTMLPartID).Body)
+	if strings.Contains(html, "Old Sig") {
+		t.Error("old signature should have been removed")
+	}
+	userIdx := strings.Index(html, "My reply")
+	sigIdx := strings.Index(html, "New Sig")
+	cardIdx := strings.Index(html, "large-file-area-123")
+	quoteIdx := strings.Index(html, "quoted")
+	if !(userIdx < sigIdx && sigIdx < cardIdx && cardIdx < quoteIdx) {
+		t.Errorf("expected new sig to be placed before card: user@%d sig@%d card@%d quote@%d",
+			userIdx, sigIdx, cardIdx, quoteIdx)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // insert_signature — no HTML body
 // ---------------------------------------------------------------------------

shortcuts/mail/draft/projection.go

@@ -16,6 +16,31 @@ import (
 // (the detector) share a single source of truth.
 const QuoteWrapperClass = "history-quote-wrapper"
 
+// Well-known anchors for the large attachment HTML card generated by
+// CLI and the desktop client. The HTML structure is:
+//
+//	<div id="large-file-area-{timestamp}" ...>
+//	  <div>Title</div>
+//	  <div id="large-file-item" ...>
+//	    ... filename, size, <a data-mail-token="..."> ...
+//	  </div>
+//	  <div id="large-file-item" ...> ... </div>
+//	</div>
+const (
+	LargeFileContainerIDPrefix = "large-file-area-"
+	LargeFileItemID            = "large-file-item"
+	LargeAttachmentTokenAttr   = "data-mail-token"
+)
+
+// LargeAttachmentIDsHeader is the header name CLI writes when creating
+// or editing a draft. The value is base64-encoded JSON: [{"id":"<token>"}].
+const LargeAttachmentIDsHeader = "X-Lms-Large-Attachment-Ids"
+
+// ServerLargeAttachmentHeader is the header name the mail server returns
+// on readback. The value is base64-encoded JSON with richer metadata:
+// [{"file_key":"<token>","file_name":"...","file_size":...}].
+const ServerLargeAttachmentHeader = "X-Lark-Large-Attachment"
+
 // quoteWrapperRe matches an actual <div> element whose class attribute
 // contains QuoteWrapperClass. This avoids false positives when the
 // string appears as plain text, inside <pre> blocks, or in
@@ -103,17 +128,43 @@ func Project(snapshot *DraftSnapshot) DraftProjection {
 		}
 	}
 
+	var htmlBody string
 	if part := findPart(snapshot.Body, snapshot.PrimaryHTMLPartID); part != nil {
-		for _, cid := range extractCIDRefs(string(part.Body)) {
+		htmlBody = string(part.Body)
+		for _, cid := range extractCIDRefs(htmlBody) {
 			if !inlineCIDs[strings.ToLower(cid)] {
 				proj.Warnings = append(proj.Warnings, "missing inline MIME part for cid:"+cid)
 			}
 		}
 	}
 
+	proj.LargeAttachmentsSummary = projectLargeAttachments(snapshot.Headers, htmlBody)
+
 	return proj
 }
 
+// projectLargeAttachments extracts large attachment info from the draft.
+// It first tries the server-format header (X-Lark-Large-Attachment) which
+// carries filename and size directly. Falls back to merging CLI-format
+// header tokens with HTML-parsed metadata.
+func projectLargeAttachments(headers []Header, htmlBody string) []LargeAttachmentSummary {
+	if summaries := ParseLargeAttachmentSummariesFromHeader(headers); len(summaries) > 0 {
+		return summaries
+	}
+	tokens := parseLargeAttachmentTokens(headers)
+	if len(tokens) == 0 {
+		return nil
+	}
+	metas := ParseLargeAttachmentItemsFromHTML(htmlBody)
+	out := make([]LargeAttachmentSummary, 0, len(tokens))
+	for _, token := range tokens {
+		meta := metas[token]
+		meta.Token = token
+		out = append(out, meta)
+	}
+	return out
+}
+
 func flattenParts(root *Part) []*Part {
 	if root == nil {
 		return nil
@@ -163,6 +214,129 @@ func SplitAtQuote(html string) (body, quote string) {
 	return html[:loc[0]], html[loc[0]:]
 }
 
+// largeFileAreaOpenRe matches the opening <div> of a large attachment
+// card container (id starts with "large-file-area-").
+var largeFileAreaOpenRe = regexp.MustCompile(
+	`<div\s[^>]*id="` + regexp.QuoteMeta(LargeFileContainerIDPrefix) + `[^"]*"`)
+
+// SplitAtLargeAttachment splits HTML into three pieces around the first
+// large-file-area container: content before, the entire container block,
+// and content after. If no container is present, returns (html, "", "").
+//
+// Used by set_body / set_reply_body to preserve the large attachment card
+// across body replacements.
+func SplitAtLargeAttachment(html string) (before, card, after string) {
+	loc := largeFileAreaOpenRe.FindStringIndex(html)
+	if loc == nil {
+		return html, "", ""
+	}
+	startTag := loc[0]
+	end := FindMatchingCloseDiv(html, startTag)
+	return html[:startTag], html[startTag:end], html[end:]
+}
+
+// splitAtSystemTail splits html at the earliest system-managed element:
+// either the large-file-area card container or the history-quote-wrapper,
+// whichever appears first. When neither is present, returns (html, "").
+//
+// This is the placement point for signatures. In Lark mail's compose
+// order the signature sits right after the user-authored region and
+// before any attachment cards or quoted content.
+func splitAtSystemTail(html string) (userRegion, systemTail string) {
+	cardLoc := largeFileAreaOpenRe.FindStringIndex(html)
+	quoteLoc := quoteWrapperRe.FindStringIndex(html)
+	pos := -1
+	if cardLoc != nil {
+		pos = cardLoc[0]
+	}
+	if quoteLoc != nil && (pos < 0 || quoteLoc[0] < pos) {
+		pos = quoteLoc[0]
+	}
+	if pos < 0 {
+		return html, ""
+	}
+	return html[:pos], html[pos:]
+}
+
+// PlaceSignatureBeforeSystemTail is the single source of truth for
+// signature placement. It removes any existing signature from html, then
+// inserts sigBlock at the split point between the user-authored region
+// and the system-managed tail (large attachment card or history quote
+// wrapper, whichever comes first).
+//
+// Used by both compose-time signature injection
+// (mail/signature_compose.go) and edit-time insert_signature op
+// (draft/patch.go), guaranteeing they produce a consistent HTML layout
+// [user][sig][card?][quote?].
+//
+// When sigBlock is empty, behaves as a simple "remove signature" on the
+// HTML string level — note that callers needing MIME-part orphan cleanup
+// should handle that separately.
+func PlaceSignatureBeforeSystemTail(html, sigBlock string) string {
+	cleaned := RemoveSignatureHTML(html)
+	if sigBlock == "" {
+		return cleaned
+	}
+	user, tail := splitAtSystemTail(cleaned)
+	return user + sigBlock + tail
+}
+
+// HTMLContainsLargeAttachment reports whether the given HTML fragment
+// contains a large attachment card container (`<div ... id="large-file-area-..."`).
+// Used to detect whether a user-supplied set_body value already carries
+// a card, in which case auto-preservation is skipped.
+func HTMLContainsLargeAttachment(html string) bool {
+	return largeFileAreaOpenRe.MatchString(html)
+}
+
+// FindHTMLBodyPart walks the MIME tree and returns the first text/html
+// body part (skipping attachment-disposition parts), or nil when none exists.
+func FindHTMLBodyPart(root *Part) *Part {
+	if root == nil {
+		return nil
+	}
+	if strings.EqualFold(root.MediaType, "text/html") && !strings.EqualFold(root.ContentDisposition, "attachment") {
+		return root
+	}
+	for _, c := range root.Children {
+		if f := FindHTMLBodyPart(c); f != nil {
+			return f
+		}
+	}
+	return nil
+}
+
+// FindTextBodyPart walks the MIME tree and returns the first text/plain
+// body part (skipping attachment-disposition parts), or nil when none exists.
+func FindTextBodyPart(root *Part) *Part {
+	if root == nil {
+		return nil
+	}
+	if strings.EqualFold(root.MediaType, "text/plain") && !strings.EqualFold(root.ContentDisposition, "attachment") {
+		return root
+	}
+	for _, c := range root.Children {
+		if f := FindTextBodyPart(c); f != nil {
+			return f
+		}
+	}
+	return nil
+}
+
+// InsertBeforeQuoteOrAppend inserts block into html right before the
+// outermost quote wrapper (<div ... class="history-quote-wrapper">), or
+// appends it to the end when no quote block is present. Matching uses
+// quoteWrapperRe (an actual element with the class attribute), avoiding
+// false positives from plain-text or code-snippet occurrences of the
+// class name.
+func InsertBeforeQuoteOrAppend(html, block string) string {
+	loc := quoteWrapperRe.FindStringIndex(html)
+	if loc == nil {
+		return html + block
+	}
+	return html[:loc[0]] + block + html[loc[0]:]
+}
+
 // ── Exported signature HTML utilities ──
 // Used by both draft/patch.go (internal) and mail/signature_html.go (cross-package).
 
@@ -211,20 +385,43 @@ func FindMatchingCloseDiv(html string, startPos int) int {
 // RemoveSignatureHTML removes the signature block and its preceding spacing from HTML.
 // Returns the HTML unchanged if no signature is found.
 func RemoveSignatureHTML(html string) string {
+	start, end, ok := locateSignatureBlock(html)
+	if !ok {
+		return html
+	}
+	return html[:start] + html[end:]
+}
+
+// ExtractSignatureBlock returns the signature block (including any
+// preceding spacing that would be removed by RemoveSignatureHTML) from
+// html. Returns "" when html has no signature.
+//
+// Symmetric to RemoveSignatureHTML: RemoveSignatureHTML(html) +
+// ExtractSignatureBlock(html) reconstitutes the original html.
+func ExtractSignatureBlock(html string) string {
+	start, end, ok := locateSignatureBlock(html)
+	if !ok {
+		return ""
+	}
+	return html[start:end]
+}
+
+// locateSignatureBlock returns the start and end offsets of the
+// signature block (including any preceding spacing) in html. ok=false
+// when no signature is present.
+func locateSignatureBlock(html string) (start, end int, ok bool) {
 	loc := signatureWrapperRe.FindStringIndex(html)
 	if loc == nil {
-		return html
+		return 0, 0, false
 	}
 	sigStart := loc[0]
 	sigEnd := FindMatchingCloseDiv(html, sigStart)
-
 	// Extend backward to include preceding spacing.
 	beforeSig := html[:sigStart]
 	if spacingLoc := signatureSpacingRe.FindStringIndex(beforeSig); spacingLoc != nil {
 		sigStart = spacingLoc[0]
 	}
-
-	return html[:sigStart] + html[sigEnd:]
+	return sigStart, sigEnd, true
 }
 
 func summarizeHTML(html string) string {

shortcuts/mail/draft/projection_extra_test.go

@@ -108,3 +108,79 @@ Content-Type: text/html; charset=UTF-8
 		t.Fatalf("BodyHTMLSummary len = %d, should be truncated", len(proj.BodyHTMLSummary))
 	}
 }
+
+// ---------------------------------------------------------------------------
+// FindTextBodyPart / FindHTMLBodyPart skip attachment-disposition parts
+// ---------------------------------------------------------------------------
+
+func TestFindTextBodyPart_SkipsAttachment(t *testing.T) {
+	snapshot := mustParseFixtureDraft(t, `Subject: Test
+From: alice@example.com
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=mix
+
+--mix
+Content-Type: text/html; charset=UTF-8
+
+<p>body</p>
+--mix
+Content-Type: text/plain; charset=UTF-8
+Content-Disposition: attachment; filename=notes.txt
+
+This is a .txt attachment.
+--mix--
+`)
+	got := FindTextBodyPart(snapshot.Body)
+	if got != nil {
+		t.Errorf("FindTextBodyPart should return nil when only text/plain part is an attachment, got %q", string(got.Body))
+	}
+}
+
+func TestFindTextBodyPart_ReturnsBodyNotAttachment(t *testing.T) {
+	snapshot := mustParseFixtureDraft(t, `Subject: Test
+From: alice@example.com
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=mix
+
+--mix
+Content-Type: text/plain; charset=UTF-8
+
+real body
+--mix
+Content-Type: text/plain; charset=UTF-8
+Content-Disposition: attachment; filename=notes.txt
+
+This is a .txt attachment.
+--mix--
+`)
+	got := FindTextBodyPart(snapshot.Body)
+	if got == nil {
+		t.Fatal("FindTextBodyPart should return the body part")
+	}
+	if string(got.Body) != "real body" {
+		t.Errorf("got %q, want body part", string(got.Body))
+	}
+}
+
+func TestFindHTMLBodyPart_SkipsAttachment(t *testing.T) {
+	snapshot := mustParseFixtureDraft(t, `Subject: Test
+From: alice@example.com
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=mix
+
+--mix
+Content-Type: text/plain; charset=UTF-8
+
+plain body
+--mix
+Content-Type: text/html; charset=UTF-8
+Content-Disposition: attachment; filename=page.html
+
+<html><body>attached page</body></html>
+--mix--
+`)
+	got := FindHTMLBodyPart(snapshot.Body)
+	if got != nil {
+		t.Errorf("FindHTMLBodyPart should return nil when only text/html part is an attachment, got %q", string(got.Body))
+	}
+}

shortcuts/mail/draft/service.go

@@ -42,21 +42,34 @@ func GetRaw(runtime *common.RuntimeContext, mailboxID, draftID string) (DraftRaw
 	}, nil
 }
 
-func CreateWithRaw(runtime *common.RuntimeContext, mailboxID, rawEML string) (string, error) {
+func CreateWithRaw(runtime *common.RuntimeContext, mailboxID, rawEML string) (DraftResult, error) {
 	data, err := runtime.CallAPI("POST", mailboxPath(mailboxID, "drafts"), nil, map[string]interface{}{"raw": rawEML})
 	if err != nil {
-		return "", err
+		return DraftResult{}, err
 	}
 	draftID := extractDraftID(data)
 	if draftID == "" {
-		return "", fmt.Errorf("API response missing draft_id")
+		return DraftResult{}, fmt.Errorf("API response missing draft_id")
 	}
-	return draftID, nil
+	return DraftResult{
+		DraftID:   draftID,
+		Reference: extractReference(data),
+	}, nil
 }
 
-func UpdateWithRaw(runtime *common.RuntimeContext, mailboxID, draftID, rawEML string) error {
-	_, err := runtime.CallAPI("PUT", mailboxPath(mailboxID, "drafts", draftID), nil, map[string]interface{}{"raw": rawEML})
-	return err
+func UpdateWithRaw(runtime *common.RuntimeContext, mailboxID, draftID, rawEML string) (DraftResult, error) {
+	data, err := runtime.CallAPI("PUT", mailboxPath(mailboxID, "drafts", draftID), nil, map[string]interface{}{"raw": rawEML})
+	if err != nil {
+		return DraftResult{}, err
+	}
+	gotDraftID := extractDraftID(data)
+	if gotDraftID == "" {
+		gotDraftID = draftID
+	}
+	return DraftResult{
+		DraftID:   gotDraftID,
+		Reference: extractReference(data),
+	}, nil
 }
 
 func Send(runtime *common.RuntimeContext, mailboxID, draftID, sendTime string) (map[string]interface{}, error) {
@@ -94,3 +107,16 @@ func extractRawEML(data map[string]interface{}) string {
 	}
 	return ""
 }
+
+func extractReference(data map[string]interface{}) string {
+	if data == nil {
+		return ""
+	}
+	if ref, ok := data["reference"].(string); ok && strings.TrimSpace(ref) != "" {
+		return strings.TrimSpace(ref)
+	}
+	if draft, ok := data["draft"].(map[string]interface{}); ok {
+		return extractReference(draft)
+	}
+	return ""
+}

shortcuts/mail/draft/service_test.go

@@ -0,0 +1,133 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package draft
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/zalando/go-keyring"
+
+	"github.com/larksuite/cli/internal/auth"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+func draftServiceTestRuntime(t *testing.T) (*common.RuntimeContext, *httpmock.Registry) {
+	t.Helper()
+	keyring.MockInit()
+	t.Setenv("HOME", t.TempDir())
+
+	cfg := &core.CliConfig{
+		AppID:      "test-app",
+		AppSecret:  "test-secret",
+		Brand:      core.BrandFeishu,
+		UserOpenId: "ou_testuser",
+		UserName:   "Test User",
+	}
+	token := &auth.StoredUAToken{
+		UserOpenId:       cfg.UserOpenId,
+		AppId:            cfg.AppID,
+		AccessToken:      "test-user-access-token",
+		RefreshToken:     "test-refresh-token",
+		ExpiresAt:        time.Now().Add(1 * time.Hour).UnixMilli(),
+		RefreshExpiresAt: time.Now().Add(24 * time.Hour).UnixMilli(),
+		Scope:            "mail:user_mailbox.messages:write mail:user_mailbox.messages:read mail:user_mailbox.message:modify mail:user_mailbox.message:readonly mail:user_mailbox.message.address:read mail:user_mailbox.message.subject:read mail:user_mailbox.message.body:read mail:user_mailbox:readonly",
+		GrantedAt:        time.Now().Add(-1 * time.Hour).UnixMilli(),
+	}
+	if err := auth.SetStoredToken(token); err != nil {
+		t.Fatalf("SetStoredToken() error = %v", err)
+	}
+	t.Cleanup(func() {
+		_ = auth.RemoveStoredToken(cfg.AppID, cfg.UserOpenId)
+	})
+
+	factory, _, _, reg := cmdutil.TestFactory(t, cfg)
+	runtime := common.TestNewRuntimeContextWithCtx(context.Background(), &cobra.Command{Use: "test"}, cfg)
+	runtime.Factory = factory
+	return runtime, reg
+}
+
+func TestExtractReference(t *testing.T) {
+	t.Run("top-level reference", func(t *testing.T) {
+		data := map[string]interface{}{"reference": "https://example.com/draft/1"}
+		if got := extractReference(data); got != "https://example.com/draft/1" {
+			t.Fatalf("extractReference() = %q, want %q", got, "https://example.com/draft/1")
+		}
+	})
+
+	t.Run("nested draft reference", func(t *testing.T) {
+		data := map[string]interface{}{
+			"draft": map[string]interface{}{
+				"reference": "https://example.com/draft/2",
+			},
+		}
+		if got := extractReference(data); got != "https://example.com/draft/2" {
+			t.Fatalf("extractReference() = %q, want %q", got, "https://example.com/draft/2")
+		}
+	})
+
+	t.Run("missing reference", func(t *testing.T) {
+		if got := extractReference(nil); got != "" {
+			t.Fatalf("extractReference(nil) = %q, want empty string", got)
+		}
+	})
+}
+
+func TestCreateWithRawReturnsDraftResultWithReference(t *testing.T) {
+	runtime, reg := draftServiceTestRuntime(t)
+
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/mail/v1/user_mailboxes/me/drafts",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"draft_id":  "draft_001",
+				"reference": "https://www.feishu.cn/mail?draftId=draft_001",
+			},
+		},
+	})
+
+	got, err := CreateWithRaw(runtime, "me", "raw-eml")
+	if err != nil {
+		t.Fatalf("CreateWithRaw() error = %v", err)
+	}
+	if got.DraftID != "draft_001" {
+		t.Fatalf("DraftID = %q, want %q", got.DraftID, "draft_001")
+	}
+	if got.Reference != "https://www.feishu.cn/mail?draftId=draft_001" {
+		t.Fatalf("Reference = %q, want %q", got.Reference, "https://www.feishu.cn/mail?draftId=draft_001")
+	}
+}
+
+func TestUpdateWithRawFallsBackToInputDraftIDAndReturnsReference(t *testing.T) {
+	runtime, reg := draftServiceTestRuntime(t)
+
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/open-apis/mail/v1/user_mailboxes/me/drafts/draft_002",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"reference": "https://www.feishu.cn/mail?draftId=draft_002",
+			},
+		},
+	})
+
+	got, err := UpdateWithRaw(runtime, "me", "draft_002", "raw-eml")
+	if err != nil {
+		t.Fatalf("UpdateWithRaw() error = %v", err)
+	}
+	if got.DraftID != "draft_002" {
+		t.Fatalf("DraftID = %q, want fallback %q", got.DraftID, "draft_002")
+	}
+	if got.Reference != "https://www.feishu.cn/mail?draftId=draft_002" {
+		t.Fatalf("Reference = %q, want %q", got.Reference, "https://www.feishu.cn/mail?draftId=draft_002")
+	}
+}

shortcuts/mail/emlbuilder/builder.go

@@ -879,12 +879,24 @@ func encodeBodyContent(body []byte, cte string) string {
 	return string(body)
 }
 
-// writeFoldedBody writes the encoded part body with fixed-width line wrapping.
-// RFC 2045 recommends 76 characters per encoded line; we apply the same width
-// to all body parts for consistent MIME output.
+// lineWidthForCTE returns the appropriate line width for the given CTE.
+// RFC 2045: base64 and quoted-printable lines MUST NOT exceed 76 characters.
+// RFC 5322: 7bit/8bit lines MUST NOT exceed 998 characters.
+func lineWidthForCTE(cte string) int {
+	switch cte {
+	case "base64", "quoted-printable":
+		return 76
+	default: // 7bit, 8bit
+		return 998
+	}
+}
+
+// writeFoldedBody writes the encoded part body with line wrapping.
+// The width limit depends on the Content-Transfer-Encoding:
+// base64/quoted-printable use 76 chars (RFC 2045), 7bit uses 998 (RFC 5322).
 func writeFoldedBody(buf *bytes.Buffer, encoded string, width int) {
 	if width <= 0 {
-		width = 76
+		width = 998
 	}
 	for _, line := range strings.Split(encoded, "\n") {
 		for len(line) > width {
@@ -910,7 +922,7 @@ func writeBodyPart(buf *bytes.Buffer, boundary, ct string, body []byte) {
 	cte := selectCTE(body)
 	fmt.Fprintf(buf, "Content-Type: %s; charset=UTF-8\n", ct)
 	fmt.Fprintf(buf, "Content-Transfer-Encoding: %s\n\n", cte)
-	writeFoldedBody(buf, encodeBodyContent(body, cte), 76)
+	writeFoldedBody(buf, encodeBodyContent(body, cte), lineWidthForCTE(cte))
 }
 
 // writeSingleBodyPartHeaders writes the Content-Type / CTE headers and body
@@ -920,7 +932,7 @@ func writeSingleBodyPartHeaders(buf *bytes.Buffer, ct string, body []byte) {
 	cte := selectCTE(body)
 	fmt.Fprintf(buf, "Content-Type: %s; charset=UTF-8\n", ct)
 	fmt.Fprintf(buf, "Content-Transfer-Encoding: %s\n\n", cte)
-	writeFoldedBody(buf, encodeBodyContent(body, cte), 76)
+	writeFoldedBody(buf, encodeBodyContent(body, cte), lineWidthForCTE(cte))
 }
 
 // writeAttachmentPart writes a MIME attachment part.

shortcuts/mail/emlbuilder/builder_test.go

@@ -560,8 +560,9 @@ func TestBuild_FoldBodyLines_7bit(t *testing.T) {
 	_ = headers
 	lines := strings.Split(strings.TrimSpace(bodyPart), "\n")
 	for i, line := range lines {
-		if len(line) > 76 {
-			t.Fatalf("7bit line %d too long: %d", i, len(line))
+		// RFC 5322: 7bit lines MUST NOT exceed 998 characters.
+		if len(line) > 998 {
+			t.Fatalf("7bit line %d too long: %d (RFC 5322 limit is 998)", i, len(line))
 		}
 	}
 }

shortcuts/mail/helpers.go

@@ -6,7 +6,6 @@ package mail
 import (
 	"encoding/base64"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"mime"
@@ -1291,7 +1290,7 @@ func buildMessageForCompose(msg map[string]interface{}, urlMap map[string]string
 			contentType := resolveAttachmentContentType(att, filename)
 			dlURL := urlMap[id]
 
-			if isInline {
+			if isInline && cid != "" {
 				images = append(images, mailImageOutput{
 					ID:          id,
 					Filename:    filename,
@@ -1358,9 +1357,10 @@ type inlineSourcePart struct {
 }
 
 type composeSourceMessage struct {
-	Original           originalMessage
-	ForwardAttachments []forwardSourceAttachment
-	InlineImages       []inlineSourcePart
+	Original            originalMessage
+	ForwardAttachments  []forwardSourceAttachment
+	InlineImages        []inlineSourcePart
+	FailedAttachmentIDs map[string]bool
 }
 
 // fetchComposeSourceMessage loads a message via the +message pipeline and converts it
@@ -1371,13 +1371,20 @@ func fetchComposeSourceMessage(runtime *common.RuntimeContext, mailboxID, messag
 		return composeSourceMessage{}, err
 	}
 	attIDs := extractAttachmentIDs(msg)
-	urlMap, _ := fetchAttachmentURLs(runtime, mailboxID, messageID, attIDs)
+	urlMap, warnings := fetchAttachmentURLs(runtime, mailboxID, messageID, attIDs)
+	failedIDs := make(map[string]bool)
+	for _, w := range warnings {
+		if w.Code == "attachment_download_url_failed_id" && w.AttachmentID != "" {
+			failedIDs[w.AttachmentID] = true
+		}
+	}
 	out := buildMessageForCompose(msg, urlMap, true)
 	orig := toOriginalMessageForCompose(out)
 	return composeSourceMessage{
-		Original:           orig,
-		ForwardAttachments: toForwardSourceAttachments(out),
-		InlineImages:       toInlineSourceParts(out),
+		Original:            orig,
+		ForwardAttachments:  toForwardSourceAttachments(out),
+		InlineImages:        toInlineSourceParts(out),
+		FailedAttachmentIDs: failedIDs,
 	}, nil
 }
 
@@ -1386,6 +1393,12 @@ func fetchComposeSourceMessage(runtime *common.RuntimeContext, mailboxID, messag
 func validateForwardAttachmentURLs(src composeSourceMessage) error {
 	var missing []string
 	for _, att := range src.ForwardAttachments {
+		if att.AttachmentType == attachmentTypeLarge {
+			continue
+		}
+		if src.FailedAttachmentIDs[att.ID] {
+			continue
+		}
 		if att.DownloadURL == "" {
 			missing = append(missing, fmt.Sprintf("attachment %q (%s)", att.Filename, att.ID))
 		}
@@ -1837,6 +1850,42 @@ func normalizeMessageID(id string) string {
 	return strings.TrimSpace(trimmed)
 }
 
+func buildDraftSendOutput(resData map[string]interface{}, mailboxID string) map[string]interface{} {
+	out := map[string]interface{}{
+		"message_id": resData["message_id"],
+		"thread_id":  resData["thread_id"],
+	}
+	if recallStatus, ok := resData["recall_status"].(string); ok && recallStatus == "available" {
+		messageID, _ := resData["message_id"].(string)
+		out["recall_available"] = true
+		out["recall_tip"] = fmt.Sprintf(
+			`This message can be recalled within 24 hours. To recall: lark-cli mail user_mailbox.sent_messages recall --params '{"user_mailbox_id":"%s","message_id":"%s"}'`,
+			mailboxID, messageID)
+	}
+	if automationDisable, ok := resData["automation_send_disable"]; ok {
+		if automation, ok := automationDisable.(map[string]interface{}); ok {
+			if reason, ok := automation["reason"].(string); ok && strings.TrimSpace(reason) != "" {
+				out["automation_send_disable_reason"] = strings.TrimSpace(reason)
+			}
+			if reference, ok := automation["reference"].(string); ok && strings.TrimSpace(reference) != "" {
+				out["automation_send_disable_reference"] = strings.TrimSpace(reference)
+			}
+		}
+	}
+	return out
+}
+
+func buildDraftSavedOutput(draftResult draftpkg.DraftResult, mailboxID string) map[string]interface{} {
+	out := map[string]interface{}{
+		"draft_id": draftResult.DraftID,
+		"tip":      fmt.Sprintf(`draft saved. To send: lark-cli mail user_mailbox.drafts send --params '{"user_mailbox_id":"%s","draft_id":"%s"}'`, mailboxID, draftResult.DraftID),
+	}
+	if draftResult.Reference != "" {
+		out["reference"] = draftResult.Reference
+	}
+	return out
+}
+
 func normalizeInlineCID(cid string) string {
 	trimmed := strings.TrimSpace(cid)
 	if len(trimmed) >= 4 && strings.EqualFold(trimmed[:4], "cid:") {
@@ -1868,12 +1917,13 @@ func validateInlineCIDs(html string, userCIDs, extraCIDs []string) error {
 	return nil
 }
 
-func addInlineImagesToBuilder(runtime *common.RuntimeContext, bld emlbuilder.Builder, images []inlineSourcePart) (emlbuilder.Builder, []string, error) {
+func addInlineImagesToBuilder(runtime *common.RuntimeContext, bld emlbuilder.Builder, images []inlineSourcePart) (emlbuilder.Builder, []string, int64, error) {
 	var cids []string
+	var totalBytes int64
 	for _, img := range images {
 		content, err := downloadAttachmentContent(runtime, img.DownloadURL)
 		if err != nil {
-			return bld, nil, fmt.Errorf("failed to download inline resource %s: %w", img.Filename, err)
+			return bld, nil, 0, fmt.Errorf("failed to download inline resource %s: %w", img.Filename, err)
 		}
 		cid := normalizeInlineCID(img.CID)
 		if cid == "" {
@@ -1885,8 +1935,9 @@ func addInlineImagesToBuilder(runtime *common.RuntimeContext, bld emlbuilder.Bui
 		}
 		bld = bld.AddInline(content, contentType, img.Filename, cid)
 		cids = append(cids, cid)
+		totalBytes += int64(len(content))
 	}
-	return bld, cids, nil
+	return bld, cids, totalBytes, nil
 }
 
 // InlineSpec represents one inline image entry from the --inline JSON array.
@@ -1930,37 +1981,6 @@ func inlineSpecFilePaths(specs []InlineSpec) []string {
 	return paths
 }
 
-// checkAttachmentSizeLimit returns an error if the combined attachment count exceeds
-// MaxAttachmentCount or the combined size exceeds MaxAttachmentBytes.
-// filePaths are read via os.Stat (no full read); extraBytes / extraCount account for
-// already-loaded content (e.g. downloaded original attachments in +forward).
-func checkAttachmentSizeLimit(fio fileio.FileIO, filePaths []string, extraBytes int64, extraCount ...int) error {
-	extra := 0
-	for _, c := range extraCount {
-		extra += c
-	}
-	total := extra + len(filePaths)
-	if total > MaxAttachmentCount {
-		return fmt.Errorf("attachment count %d exceeds the limit of %d", total, MaxAttachmentCount)
-	}
-	totalBytes := extraBytes
-	for _, p := range filePaths {
-		info, err := fio.Stat(p)
-		if err != nil {
-			if errors.Is(err, fileio.ErrPathValidation) {
-				return fmt.Errorf("unsafe attachment path %s: %w", p, err)
-			}
-			return fmt.Errorf("failed to stat attachment %s: %w", p, err)
-		}
-		totalBytes += info.Size()
-	}
-	if totalBytes > MaxAttachmentBytes {
-		return fmt.Errorf("total attachment size %.1f MB exceeds the 25 MB limit",
-			float64(totalBytes)/1024/1024)
-	}
-	return nil
-}
-
 // validateSendTime checks that --send-time, if provided, requires --confirm-send,
 // is a valid Unix timestamp in seconds, and is at least 5 minutes in the future.
 func validateSendTime(runtime *common.RuntimeContext) error {
@@ -2009,23 +2029,6 @@ func validateConfirmSendScope(runtime *common.RuntimeContext) error {
 	return nil
 }
 
-// buildSendResult builds the output map for a successful send, including
-// recall tip if the backend indicates the message is recallable.
-func buildSendResult(resData map[string]interface{}, mailboxID string) map[string]interface{} {
-	result := map[string]interface{}{
-		"message_id": resData["message_id"],
-		"thread_id":  resData["thread_id"],
-	}
-	if recallStatus, ok := resData["recall_status"].(string); ok && recallStatus == "available" {
-		messageID, _ := resData["message_id"].(string)
-		result["recall_available"] = true
-		result["recall_tip"] = fmt.Sprintf(
-			`This message can be recalled within 24 hours. To recall: lark-cli mail user_mailbox.sent_messages recall --params '{"user_mailbox_id":"%s","message_id":"%s"}'`,
-			mailboxID, messageID)
-	}
-	return result
-}
-
 // validateFolderReadScope checks that the user's token includes the
 // mail:user_mailbox.folder:read scope. Called on-demand by listMailboxFolders
 // before hitting the folders API. System folders are resolved locally and
@@ -2098,14 +2101,15 @@ func validateComposeInlineAndAttachments(fio fileio.FileIO, attachFlag, inlineFl
 			return fmt.Errorf("--inline requires an HTML body (the provided body appears to be plain text; add HTML tags or remove --inline)")
 		}
 	}
-	// Validate explicitly provided files (--attach + --inline) early so that
-	// dry-run and reply/forward can catch local errors before Execute.
-	// Auto-resolved local images are only known at Execute time, so Execute
-	// performs a second, complete size check that includes them.
 	inlineSpecs, err := parseInlineSpecs(inlineFlag)
 	if err != nil {
 		return err
 	}
-	allFiles := append(splitByComma(attachFlag), inlineSpecFilePaths(inlineSpecs)...)
-	return checkAttachmentSizeLimit(fio, allFiles, 0)
+	// Preflight: verify explicit file paths exist and pass blocked-extension
+	// checks so that --dry-run surfaces local errors before Execute.
+	allPaths := append(splitByComma(attachFlag), inlineSpecFilePaths(inlineSpecs)...)
+	if _, err := statAttachmentFiles(fio, allPaths); err != nil {
+		return err
+	}
+	return nil
 }

shortcuts/mail/helpers_test.go

@@ -12,7 +12,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"testing"
@@ -566,58 +565,6 @@ func TestToOriginalMessageForCompose_EmptyReferences(t *testing.T) {
 	}
 }
 
-// ---------------------------------------------------------------------------
-// checkAttachmentSizeLimit
-// ---------------------------------------------------------------------------
-
-func TestCheckAttachmentSizeLimit_NoFiles(t *testing.T) {
-	if err := checkAttachmentSizeLimit(nil, nil, 0); err != nil { //nolint:staticcheck // fio nil ok: no files
-		t.Fatalf("unexpected error for empty: %v", err)
-	}
-}
-
-func TestCheckAttachmentSizeLimit_CountExceeded(t *testing.T) {
-	err := checkAttachmentSizeLimit(nil, nil, 0, MaxAttachmentCount+1)
-	if err == nil {
-		t.Fatal("expected error for count exceeded")
-	}
-	if !strings.Contains(err.Error(), "count") {
-		t.Errorf("error should mention count: %v", err)
-	}
-}
-
-func TestCheckAttachmentSizeLimit_SizeExceeded(t *testing.T) {
-	// extraBytes alone exceeds the limit
-	err := checkAttachmentSizeLimit(nil, nil, MaxAttachmentBytes+1)
-	if err == nil {
-		t.Fatal("expected error for size exceeded")
-	}
-	if !strings.Contains(err.Error(), "25 MB") {
-		t.Errorf("error should mention 25 MB limit: %v", err)
-	}
-}
-
-func TestCheckAttachmentSizeLimit_WithFiles(t *testing.T) {
-	// Create a small temp file to exercise the file stat path
-	dir := t.TempDir()
-	f := filepath.Join(dir, "small.txt")
-	if err := os.WriteFile(f, []byte("hello"), 0644); err != nil {
-		t.Fatal(err)
-	}
-	// Use the temp dir as the CWD so the relative path works
-	oldWd, _ := os.Getwd()
-	if err := os.Chdir(dir); err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chdir(oldWd)
-
-	fio := &localfileio.LocalFileIO{}
-	err := checkAttachmentSizeLimit(fio, []string{"./small.txt"}, 0)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
 // ---------------------------------------------------------------------------
 // validateInlineCIDs — bidirectional CID consistency
 // ---------------------------------------------------------------------------
@@ -743,10 +690,13 @@ func TestAddInlineImagesToBuilder_EmptyCIDSkipped(t *testing.T) {
 	images := []inlineSourcePart{
 		{ID: "img1", Filename: "logo.png", ContentType: "image/png", CID: "", DownloadURL: srv.URL + "/img1"},
 	}
-	_, _, err := addInlineImagesToBuilder(rt, bld, images)
+	_, _, totalBytes, err := addInlineImagesToBuilder(rt, bld, images)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	if totalBytes != 0 {
+		t.Errorf("expected 0 totalBytes for skipped CID, got %d", totalBytes)
+	}
 }
 
 func TestAddInlineImagesToBuilder_Success(t *testing.T) {
@@ -764,10 +714,13 @@ func TestAddInlineImagesToBuilder_Success(t *testing.T) {
 	images := []inlineSourcePart{
 		{ID: "img1", Filename: "banner.png", ContentType: "image/png", CID: "cid:banner", DownloadURL: srv.URL + "/img1"},
 	}
-	result, _, err := addInlineImagesToBuilder(rt, bld, images)
+	result, _, totalBytes, err := addInlineImagesToBuilder(rt, bld, images)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	if totalBytes != int64(len("imagedata")) {
+		t.Errorf("expected totalBytes=%d, got %d", len("imagedata"), totalBytes)
+	}
 	raw, err := result.BuildBase64URL()
 	if err != nil {
 		t.Fatalf("failed to build EML: %v", err)
@@ -1217,3 +1170,93 @@ func TestValidatePriorityFlag(t *testing.T) {
 		})
 	}
 }
+
+func TestBuildMessageForCompose_InlineNoCID_ClassifiedAsAttachment(t *testing.T) {
+	msg := map[string]interface{}{
+		"message_id": "msg1",
+		"subject":    "test",
+		"attachments": []interface{}{
+			map[string]interface{}{"id": "att1", "filename": "with-cid.png", "is_inline": true, "cid": "cid123", "content_type": "image/png"},
+			map[string]interface{}{"id": "att2", "filename": "no-cid.png", "is_inline": true, "cid": "", "content_type": "image/png"},
+			map[string]interface{}{"id": "att3", "filename": "regular.pdf", "is_inline": false, "content_type": "application/pdf"},
+		},
+	}
+	out := buildMessageForCompose(msg, nil, true)
+	if len(out.Images) != 1 || out.Images[0].ID != "att1" {
+		t.Errorf("expected 1 image (att1), got %d: %+v", len(out.Images), out.Images)
+	}
+	if len(out.Attachments) != 2 {
+		t.Fatalf("expected 2 attachments, got %d: %+v", len(out.Attachments), out.Attachments)
+	}
+	ids := []string{out.Attachments[0].ID, out.Attachments[1].ID}
+	if ids[0] != "att2" || ids[1] != "att3" {
+		t.Errorf("expected attachments [att2, att3], got %v", ids)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// validateComposeInlineAndAttachments
+// ---------------------------------------------------------------------------
+
+func TestValidateComposeInlineAndAttachments(t *testing.T) {
+	chdirTemp(t)
+	fio := &localfileio.LocalFileIO{}
+
+	t.Run("empty flags pass", func(t *testing.T) {
+		if err := validateComposeInlineAndAttachments(fio, "", "", false, ""); err != nil {
+			t.Fatalf("expected nil, got %v", err)
+		}
+	})
+
+	t.Run("inline with plain-text rejected", func(t *testing.T) {
+		err := validateComposeInlineAndAttachments(fio, "", `[{"cid":"c1","file_path":"./img.png"}]`, true, "")
+		if err == nil || !strings.Contains(err.Error(), "--plain-text") {
+			t.Fatalf("expected plain-text rejection, got %v", err)
+		}
+	})
+
+	t.Run("inline with non-HTML body rejected", func(t *testing.T) {
+		err := validateComposeInlineAndAttachments(fio, "", `[{"cid":"c1","file_path":"./img.png"}]`, false, "plain text body")
+		if err == nil || !strings.Contains(err.Error(), "HTML body") {
+			t.Fatalf("expected HTML body rejection, got %v", err)
+		}
+	})
+
+	t.Run("inline with HTML body passes format check", func(t *testing.T) {
+		os.WriteFile("img.png", []byte("png"), 0o644)
+		err := validateComposeInlineAndAttachments(fio, "", `[{"cid":"c1","file_path":"./img.png"}]`, false, "<p>hello</p>")
+		if err != nil {
+			t.Fatalf("expected nil, got %v", err)
+		}
+	})
+
+	t.Run("attach missing file rejected", func(t *testing.T) {
+		err := validateComposeInlineAndAttachments(fio, "nonexistent.pdf", "", false, "")
+		if err == nil || !strings.Contains(err.Error(), "stat") {
+			t.Fatalf("expected stat error for missing file, got %v", err)
+		}
+	})
+
+	t.Run("attach blocked extension rejected", func(t *testing.T) {
+		os.WriteFile("malware.exe", []byte("bad"), 0o644)
+		err := validateComposeInlineAndAttachments(fio, "malware.exe", "", false, "")
+		if err == nil || !strings.Contains(err.Error(), "not allowed") {
+			t.Fatalf("expected blocked extension error, got %v", err)
+		}
+	})
+
+	t.Run("attach valid file passes", func(t *testing.T) {
+		os.WriteFile("report.pdf", []byte("pdf content"), 0o644)
+		err := validateComposeInlineAndAttachments(fio, "report.pdf", "", false, "")
+		if err != nil {
+			t.Fatalf("expected nil, got %v", err)
+		}
+	})
+
+	t.Run("invalid inline JSON rejected", func(t *testing.T) {
+		err := validateComposeInlineAndAttachments(fio, "", "not-json", false, "")
+		if err == nil {
+			t.Fatal("expected error for invalid inline JSON")
+		}
+	})
+}

shortcuts/mail/large_attachment.go

@@ -0,0 +1,859 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package mail
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/larksuite/cli/extension/fileio"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/shortcuts/common"
+	draftpkg "github.com/larksuite/cli/shortcuts/mail/draft"
+	"github.com/larksuite/cli/shortcuts/mail/emlbuilder"
+	"github.com/larksuite/cli/shortcuts/mail/filecheck"
+)
+
+// attachmentFile holds metadata about a local file to be attached.
+type attachmentFile struct {
+	Path        string // relative file path as provided by the user
+	FileName    string // basename
+	Size        int64  // raw file size in bytes
+	SourceIndex int    // original index in the caller's list (e.g. patch op index)
+	Data        []byte // in-memory content; when non-nil, used instead of Path for upload
+}
+
+// classifiedAttachments is the result of classifyAttachments.
+type classifiedAttachments struct {
+	Normal    []attachmentFile // to be embedded in the EML
+	Oversized []attachmentFile // to be uploaded as large attachments
+}
+
+// largeAttachmentResult holds the upload result for a single large attachment.
+type largeAttachmentResult struct {
+	FileName  string
+	FileSize  int64
+	FileToken string
+}
+
+// MaxLargeAttachmentSize is the maximum allowed size for a single large
+// attachment, aligned with the desktop client (3 GB).
+const MaxLargeAttachmentSize = 3 * 1024 * 1024 * 1024 // 3 GB
+
+// largeAttID is the JSON element inside the X-Lms-Large-Attachment-Ids header.
+// The header name itself is defined as draftpkg.LargeAttachmentIDsHeader.
+type largeAttID struct {
+	ID string `json:"id"`
+}
+
+// estimateBase64EMLSize estimates the EML byte cost of embedding a raw file.
+// base64 inflates 3 bytes → 4 chars, plus ~200 bytes for MIME part headers.
+const base64MIMEOverhead = 200
+
+func estimateBase64EMLSize(rawSize int64) int64 {
+	return (rawSize*4+2)/3 + base64MIMEOverhead
+}
+
+// estimateEMLBaseSize estimates the EML size consumed by non-attachment content:
+// headers (~2KB), body text/HTML, and inline images. Each component is
+// accounted for with base64 encoding overhead where applicable.
+//
+// Parameters:
+//   - bodySize: raw size of the text or HTML body in bytes
+//   - inlineFilePaths: paths of inline image files (will be stat'd for size)
+//   - extraBytes: any additional pre-computed EML bytes (e.g. downloaded
+//     original attachments already loaded in memory for forward)
+func estimateEMLBaseSize(fio fileio.FileIO, bodySize int64, inlineFilePaths []string, extraBytes int64) int64 {
+	const headerOverhead = 2048 // generous estimate for all headers + MIME structure
+	total := int64(headerOverhead) + estimateBase64EMLSize(bodySize) + extraBytes
+	for _, p := range inlineFilePaths {
+		if info, err := fio.Stat(p); err == nil {
+			total += estimateBase64EMLSize(info.Size())
+		}
+	}
+	return total
+}
+
+// classifyAttachments splits files into normal (embed in EML) and oversized
+// (upload separately as large attachments).
+//
+// The decision is based on the estimated total EML size: headers + body +
+// inline images + attachments, all base64-encoded. Files are processed in
+// the user-specified order. Once a file would push the EML over MaxEMLSize,
+// it and all subsequent files are classified as oversized.
+func classifyAttachments(files []attachmentFile, emlBaseSize int64) classifiedAttachments {
+	var result classifiedAttachments
+	accumulated := emlBaseSize
+	overflow := false
+
+	for _, f := range files {
+		if overflow {
+			result.Oversized = append(result.Oversized, f)
+			continue
+		}
+		cost := estimateBase64EMLSize(f.Size)
+		if accumulated+cost > emlbuilder.MaxEMLSize {
+			overflow = true
+			result.Oversized = append(result.Oversized, f)
+			continue
+		}
+		accumulated += cost
+		result.Normal = append(result.Normal, f)
+	}
+	return result
+}
+
+// statAttachmentFiles stats each path, checks blocked extensions, and returns
+// attachmentFile metadata.
+func statAttachmentFiles(fio fileio.FileIO, paths []string) ([]attachmentFile, error) {
+	files := make([]attachmentFile, 0, len(paths))
+	for _, p := range paths {
+		if strings.TrimSpace(p) == "" {
+			continue
+		}
+		name := filepath.Base(p)
+		if err := filecheck.CheckBlockedExtension(name); err != nil {
+			return nil, err
+		}
+		info, err := fio.Stat(p)
+		if err != nil {
+			return nil, fmt.Errorf("failed to stat attachment %s: %w", p, err)
+		}
+		files = append(files, attachmentFile{
+			Path:     p,
+			FileName: name,
+			Size:     info.Size(),
+		})
+	}
+	return files, nil
+}
+
+// uploadLargeAttachments uploads oversized files to the mail attachment storage
+// via the medias/upload_* API with parent_type="email".
+func uploadLargeAttachments(ctx context.Context, runtime *common.RuntimeContext, files []attachmentFile) ([]largeAttachmentResult, error) {
+	if len(files) == 0 {
+		return nil, nil
+	}
+	userOpenId := runtime.UserOpenId()
+	if userOpenId == "" {
+		return nil, fmt.Errorf("large attachment upload requires user identity (user open_id not available)")
+	}
+
+	results := make([]largeAttachmentResult, 0, len(files))
+	for _, f := range files {
+		fmt.Fprintf(runtime.IO().ErrOut, "Uploading large attachment: %s (%s)\n", f.FileName, common.FormatSize(f.Size))
+
+		var (
+			fileToken string
+			err       error
+		)
+		if f.Data != nil {
+			fileToken, err = common.UploadDriveMediaAll(runtime, common.DriveMediaUploadAllConfig{
+				FileName:   f.FileName,
+				FileSize:   f.Size,
+				ParentType: "email",
+				ParentNode: &userOpenId,
+				Reader:     bytes.NewReader(f.Data),
+			})
+		} else if f.Size <= common.MaxDriveMediaUploadSinglePartSize {
+			fileToken, err = common.UploadDriveMediaAll(runtime, common.DriveMediaUploadAllConfig{
+				FilePath:   f.Path,
+				FileName:   f.FileName,
+				FileSize:   f.Size,
+				ParentType: "email",
+				ParentNode: &userOpenId,
+			})
+		} else {
+			fileToken, err = common.UploadDriveMediaMultipart(runtime, common.DriveMediaMultipartUploadConfig{
+				FilePath:   f.Path,
+				FileName:   f.FileName,
+				FileSize:   f.Size,
+				ParentType: "email",
+				ParentNode: userOpenId,
+			})
+		}
+		if err != nil {
+			return nil, fmt.Errorf("failed to upload large attachment %s: %w", f.FileName, err)
+		}
+
+		results = append(results, largeAttachmentResult{
+			FileName:  f.FileName,
+			FileSize:  f.Size,
+			FileToken: fileToken,
+		})
+	}
+	return results, nil
+}
+
+// buildLargeAttachmentPreviewURL builds the download/preview URL for a large
+// attachment token. The domain is derived from the CLI's configured endpoint
+// (e.g. open.feishu.cn → www.feishu.cn).
+func buildLargeAttachmentPreviewURL(brand core.LarkBrand, fileToken string) string {
+	ep := core.ResolveEndpoints(brand)
+	host := strings.TrimPrefix(ep.Open, "https://")
+	host = strings.TrimPrefix(host, "http://")
+	mainDomain := strings.TrimPrefix(host, "open.")
+	return "https://www." + mainDomain + "/mail/page/attachment?token=" + url.QueryEscape(fileToken)
+}
+
+// buildLargeAttachmentHTML generates the HTML block for large attachments,
+// matching the desktop client's exportLargeFileArea style.
+//
+// Reference: mail-editor/src/plugins/bigAttachment/export.ts
+// Large attachment HTML templates, matching desktop's exportLargeFileArea
+// (mail-editor/src/plugins/bigAttachment/export.ts).
+//
+// IDs: container = "large-file-area-{9-digit-timestamp}", item = "large-file-item"
+// Colors: title bg = rgb(224, 233, 255), link = rgb(20, 86, 240)
+// Layout: float (not flexbox) for email client compatibility
+const (
+	// %s order: timestamp, title, items
+	largeAttContainerTpl = `<div id="large-file-area-%s" style="border: 1px solid #DEE0E3; margin-bottom: 20px;max-width: 400px; min-width: 160px; border-radius: 8px;">` +
+		`<div style="font-weight: 500; font-size: 16px;line-height: 24px; padding: 8px 16px;background-color: rgb(224, 233, 255); border-top-left-radius: 8px;border-top-right-radius: 8px;">%s</div>` +
+		`%s` + // items
+		`</div>`
+
+	// %s order: icon URL, filename, file size, preview link, token, download text
+	largeAttItemTpl = `<div style="border-top: solid 1px #DEE0E3;padding: 12px;box-sizing: border-box;clear: both;overflow: hidden;display: flex;" id="large-file-item">` +
+		`<div style="float: left; margin-right: 8px; margin-top: 1px; margin-bottom: 1px;">` +
+		`<img src="%s" height="40" width="40" style="height: 40px;width: 40px;"/>` + // icon URL
+		`</div>` +
+		`<div style="overflow: hidden;text-overflow: ellipsis;display: inline-block;width: 290px;float:left; margin-right: 10px;">` +
+		`<div style="white-space: nowrap; overflow: hidden; text-overflow: ellipsis;font-size: 14px;line-height: 22px;color: #1f2329">%s</div>` + // filename
+		`<div style="font-size: 12px; line-height: 20px; color: #8f959e; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">` +
+		`<span style="color: #8f959e;vertical-align: middle;">%s</span>` + // file size
+		`</div>` +
+		`</div>` +
+		`<a href="%s" data-mail-token="%s" style="margin: 10px; text-decoration: none; color: rgb(20, 86, 240); white-space: nowrap; cursor: pointer; line-height: 1.5; float: right; text-align: right; font-size: 14px;">%s</a>` + // preview link, token, download text
+		`</div>`
+
+	iconCDNCN = "https://lf-larkemail.bytetos.com/obj/eden-cn/aultojhaah_npi_spht_ryhs/ljhwZthlaukjlkulzlp/"
+	iconCDNEN = "https://sf16-sg.tiktokcdn.com/obj/eden-sg/aultojhaah_npi_spht_ryhs/ljhwZthlaukjlkulzlp/"
+)
+
+// brandDisplayName returns the product display name used in mail HTML
+// text, aligning with the desktop client's APP_DISPLAY_NAME i18n
+// substitution.
+//
+//   - BrandLark    → "Lark" (same in English and Chinese)
+//   - BrandFeishu  → "飞书" for zh languages, "Feishu" for others
+func brandDisplayName(brand core.LarkBrand, lang string) string {
+	if brand == core.BrandLark {
+		return "Lark"
+	}
+	if strings.HasPrefix(lang, "zh") {
+		return "飞书"
+	}
+	return "Feishu"
+}
+
+func buildLargeAttachmentItems(brand core.LarkBrand, lang string, results []largeAttachmentResult) string {
+	if len(results) == 0 {
+		return ""
+	}
+	downloadText := "Download"
+	if strings.HasPrefix(lang, "zh") {
+		downloadText = "下载"
+	}
+	iconCDN := iconCDNCN
+	if brand == core.BrandLark {
+		iconCDN = iconCDNEN
+	}
+	var items strings.Builder
+	for _, att := range results {
+		fmt.Fprintf(&items, largeAttItemTpl,
+			htmlEscape(iconCDN+fileTypeIcon(att.FileName)),
+			htmlEscape(att.FileName),
+			htmlEscape(common.FormatSize(att.FileSize)),
+			htmlEscape(buildLargeAttachmentPreviewURL(brand, att.FileToken)),
+			htmlEscape(att.FileToken),
+			downloadText,
+		)
+	}
+	return items.String()
+}
+
+func buildLargeAttachmentHTML(brand core.LarkBrand, lang string, results []largeAttachmentResult) string {
+	if len(results) == 0 {
+		return ""
+	}
+	appName := brandDisplayName(brand, lang)
+	title := "Large file from " + appName + " Mail"
+	if strings.HasPrefix(lang, "zh") {
+		title = "来自" + appName + "邮箱的超大附件"
+	}
+	timestamp := fmt.Sprintf("%d", time.Now().UnixMilli())
+	if len(timestamp) > 9 {
+		timestamp = timestamp[:9]
+	}
+	return fmt.Sprintf(largeAttContainerTpl, timestamp, title, buildLargeAttachmentItems(brand, lang, results))
+}
+
+func buildLargeAttachmentPlainText(brand core.LarkBrand, lang string, results []largeAttachmentResult) string {
+	if len(results) == 0 {
+		return ""
+	}
+
+	appName := brandDisplayName(brand, lang)
+	title := "Large file from " + appName + " Mail"
+	downloadText := "Download"
+	if strings.HasPrefix(lang, "zh") {
+		title = "来自" + appName + "邮箱的超大附件"
+		downloadText = "下载"
+	}
+
+	var sb strings.Builder
+	sb.WriteString("\n")
+	sb.WriteString(title)
+	sb.WriteString("\n")
+	for i, att := range results {
+		sb.WriteString(att.FileName)
+		sb.WriteString("\n")
+		sb.WriteString(common.FormatSize(att.FileSize))
+		sb.WriteString("\n")
+		sb.WriteString(downloadText + ": " + buildLargeAttachmentPreviewURL(brand, att.FileToken))
+		if i < len(results)-1 {
+			sb.WriteString("\n\n")
+		} else {
+			sb.WriteString("\n")
+		}
+	}
+	return sb.String()
+}
+
+// fileTypeIcon returns the CDN icon filename for a given attachment filename,
+// matching desktop's AttachmentIconPath (mail-editor/src/plugins/bigAttachment/utils.ts).
+func fileTypeIcon(filename string) string {
+	ext := strings.ToLower(filepath.Ext(filename))
+	if len(ext) > 0 {
+		ext = ext[1:] // strip leading dot
+	}
+	switch ext {
+	case "doc", "docx":
+		return "icon_file_doc.png"
+	case "pdf":
+		return "icon_file_pdf.png"
+	case "ppt", "pptx":
+		return "icon_file_ppt.png"
+	case "xls", "xlsx":
+		return "icon_file_excel.png"
+	case "zip", "rar", "7z", "tar", "gz":
+		return "icon_file_zip.png"
+	case "png", "jpg", "jpeg", "gif", "bmp", "webp", "svg", "ico", "tiff":
+		return "icon_file_image.png"
+	case "mp4", "avi", "mov", "mkv", "wmv", "flv":
+		return "icon_file_video.png"
+	case "mp3", "wav", "flac", "aac", "ogg", "wma":
+		return "icon_file_audio.png"
+	case "txt":
+		return "icon_file_doc.png"
+	case "eml":
+		return "icon_file_eml.png"
+	case "apk":
+		return "icon_file_android.png"
+	case "psd":
+		return "icon_file_ps.png"
+	case "ai":
+		return "icon_file_ai.png"
+	case "sketch":
+		return "icon_file_sketch.png"
+	case "key", "keynote":
+		return "icon_file_keynote.png"
+	case "numbers":
+		return "icon_file_numbers.png"
+	case "pages":
+		return "icon_file_pages.png"
+	default:
+		return "icon_file_unknow.png"
+	}
+}
+
+// processLargeAttachments is the unified entry point for large attachment
+// handling across all mail compose shortcuts (draft-create, reply, forward, send).
+//
+// Parameters:
+//   - htmlBody: the current HTML body string (for quote-aware insertion); empty for plain-text emails
+//   - textBody: the current text body string; empty for HTML emails
+//   - attachPaths: user-specified attachment file paths (from --attach flag)
+//   - extraEMLBytes: EML bytes already accounted for
+//   - extraAttachCount: number of attachments already added to bld
+func processLargeAttachments(
+	ctx context.Context,
+	runtime *common.RuntimeContext,
+	bld emlbuilder.Builder,
+	htmlBody string,
+	textBody string,
+	attachPaths []string,
+	extraEMLBytes int64,
+	extraAttachCount int,
+) (emlbuilder.Builder, error) {
+	totalCount := extraAttachCount + len(attachPaths)
+	if totalCount > MaxAttachmentCount {
+		return bld, fmt.Errorf("attachment count %d exceeds the limit of %d", totalCount, MaxAttachmentCount)
+	}
+
+	files, err := statAttachmentFiles(runtime.FileIO(), attachPaths)
+	if err != nil {
+		return bld, err
+	}
+
+	for _, f := range files {
+		if f.Size > MaxLargeAttachmentSize {
+			return bld, fmt.Errorf("attachment %s (%.1f GB) exceeds the %.0f GB single file limit",
+				f.FileName, float64(f.Size)/1024/1024/1024, float64(MaxLargeAttachmentSize)/1024/1024/1024)
+		}
+	}
+
+	classified := classifyAttachments(files, extraEMLBytes)
+
+	if len(classified.Oversized) == 0 {
+		for _, f := range classified.Normal {
+			bld = bld.AddFileAttachment(f.Path)
+		}
+		return bld, nil
+	}
+
+	if htmlBody == "" && textBody == "" {
+		return bld, fmt.Errorf("large attachments require a body; " +
+			"empty messages cannot include the download link")
+	}
+
+	if runtime.Config == nil || runtime.UserOpenId() == "" {
+		var totalBytes int64
+		for _, f := range files {
+			totalBytes += f.Size
+		}
+		return bld, fmt.Errorf("total attachment size %.1f MB exceeds the 25 MB EML limit; "+
+			"large attachment upload requires user identity (--as user)",
+			float64(totalBytes)/1024/1024)
+	}
+
+	results, err := uploadLargeAttachments(ctx, runtime, classified.Oversized)
+	if err != nil {
+		return bld, err
+	}
+
+	if htmlBody != "" {
+		largeHTML := buildLargeAttachmentHTML(runtime.Config.Brand, resolveLang(runtime), results)
+		bld = bld.HTMLBody([]byte(draftpkg.InsertBeforeQuoteOrAppend(htmlBody, largeHTML)))
+	} else {
+		largeText := buildLargeAttachmentPlainText(runtime.Config.Brand, resolveLang(runtime), results)
+		bld = bld.TextBody([]byte(textBody + largeText))
+	}
+
+	ids := make([]largeAttID, len(results))
+	for i, r := range results {
+		ids[i] = largeAttID{ID: r.FileToken}
+	}
+	idsJSON, err := json.Marshal(ids)
+	if err != nil {
+		return bld, fmt.Errorf("failed to encode large attachment IDs: %w", err)
+	}
+	bld = bld.Header(draftpkg.LargeAttachmentIDsHeader, base64.StdEncoding.EncodeToString(idsJSON))
+
+	for _, f := range classified.Normal {
+		bld = bld.AddFileAttachment(f.Path)
+	}
+
+	fmt.Fprintf(runtime.IO().ErrOut, "  %d normal attachment(s) embedded in EML\n", len(classified.Normal))
+	fmt.Fprintf(runtime.IO().ErrOut, "  %d large attachment(s) uploaded (download links in body)\n", len(classified.Oversized))
+
+	return bld, nil
+}
+
+// ensureLargeAttachmentCards checks whether the snapshot's HTML body is missing
+// download cards for large attachments registered in the header. Drafts read
+// back from the server may have their HTML cards stripped, even though the
+// server-format X-Lark-Large-Attachment header still carries file_name and
+// file_size metadata. This function uses that metadata to reconstruct only the
+// missing cards/text and injects them into the body (HTML or plain text)
+// without duplicating entries that are already present.
+//
+// Must be called BEFORE normalizeLargeAttachmentHeader, because that
+// function converts the server-format header to CLI format and discards
+// file_name/file_size.
+func ensureLargeAttachmentCards(runtime *common.RuntimeContext, snapshot *draftpkg.DraftSnapshot) {
+	summaries := draftpkg.ParseLargeAttachmentSummariesFromHeader(snapshot.Headers)
+	if len(summaries) == 0 {
+		return
+	}
+
+	brand := core.BrandFeishu
+	if runtime.Config != nil {
+		brand = runtime.Config.Brand
+	}
+	lang := "zh_cn"
+	if runtime.Factory != nil {
+		lang = resolveLang(runtime)
+	}
+
+	htmlPart := draftpkg.FindHTMLBodyPart(snapshot.Body)
+	if htmlPart != nil {
+		existingCards := draftpkg.ParseLargeAttachmentItemsFromHTML(string(htmlPart.Body))
+		var missing []largeAttachmentResult
+		for _, s := range summaries {
+			if _, exists := existingCards[s.Token]; !exists {
+				missing = append(missing, largeAttachmentResult{
+					FileName:  s.FileName,
+					FileSize:  s.SizeBytes,
+					FileToken: s.Token,
+				})
+			}
+		}
+		if len(missing) == 0 {
+			return
+		}
+		injectLargeAttachmentHTMLIntoSnapshot(snapshot, brand, lang, missing)
+		return
+	}
+
+	textPart := draftpkg.FindTextBodyPart(snapshot.Body)
+	if textPart != nil {
+		bodyText := string(textPart.Body)
+		var missing []largeAttachmentResult
+		for _, s := range summaries {
+			if !strings.Contains(bodyText, s.Token) {
+				missing = append(missing, largeAttachmentResult{
+					FileName:  s.FileName,
+					FileSize:  s.SizeBytes,
+					FileToken: s.Token,
+				})
+			}
+		}
+		if len(missing) == 0 {
+			return
+		}
+		largeText := buildLargeAttachmentPlainText(brand, lang, missing)
+		injectLargeAttachmentTextIntoSnapshot(snapshot, largeText)
+	}
+}
+
+// preprocessLargeAttachmentsForDraftEdit scans a draft-edit patch for
+// add_attachment ops, classifies the files (normal vs oversized based on
+// the snapshot's current EML size), uploads oversized files, injects the
+// large attachment HTML card into the snapshot's HTML body, and returns
+// the patch with oversized ops removed (normal ops stay for draft.Apply).
+func preprocessLargeAttachmentsForDraftEdit(
+	ctx context.Context,
+	runtime *common.RuntimeContext,
+	snapshot *draftpkg.DraftSnapshot,
+	patch draftpkg.Patch,
+) (draftpkg.Patch, error) {
+	// Reconstruct missing large attachment HTML cards from the server-format
+	// header metadata. Must run before normalizeLargeAttachmentHeader which
+	// discards file_name/file_size.
+	ensureLargeAttachmentCards(runtime, snapshot)
+
+	// Always normalize server-format headers to CLI format so every code
+	// path below (and every early return) sends the format the server
+	// recognizes on write.
+	normalizeLargeAttachmentHeader(snapshot)
+
+	// Collect add_attachment ops and their indices.
+	type attachOp struct {
+		index int
+		path  string
+	}
+	var attachOps []attachOp
+	for i, op := range patch.Ops {
+		if op.Op == "add_attachment" {
+			attachOps = append(attachOps, attachOp{index: i, path: op.Path})
+		}
+	}
+	if len(attachOps) == 0 {
+		return patch, nil
+	}
+
+	// Stat all attachment files.
+	paths := make([]string, len(attachOps))
+	for i, ao := range attachOps {
+		paths[i] = ao.path
+	}
+	files, err := statAttachmentFiles(runtime.FileIO(), paths)
+	if err != nil {
+		return patch, err
+	}
+	for i := range files {
+		files[i].SourceIndex = attachOps[i].index
+	}
+
+	// Check 3GB single file limit.
+	for _, f := range files {
+		if f.Size > MaxLargeAttachmentSize {
+			return patch, fmt.Errorf("attachment %s (%.1f GB) exceeds the %.0f GB single file limit",
+				f.FileName, float64(f.Size)/1024/1024/1024, float64(MaxLargeAttachmentSize)/1024/1024/1024)
+		}
+	}
+
+	// Calculate the snapshot's current EML base size.
+	emlBaseSize := snapshotEMLBaseSize(snapshot)
+
+	// Classify files.
+	classified := classifyAttachments(files, emlBaseSize)
+	if len(classified.Oversized) == 0 {
+		return patch, nil // all fit, let draft.Apply handle them
+	}
+
+	// Guard: large attachment requires at least some body part.
+	hasHTML := draftpkg.FindHTMLBodyPart(snapshot.Body) != nil
+	hasText := draftpkg.FindTextBodyPart(snapshot.Body) != nil
+	if !hasHTML && !hasText {
+		return patch, fmt.Errorf("large attachments require a body; " +
+			"empty drafts cannot include the download link")
+	}
+
+	// Guard: need user identity for upload.
+	if runtime.Config == nil || runtime.UserOpenId() == "" {
+		var totalBytes int64
+		for _, f := range files {
+			totalBytes += f.Size
+		}
+		return patch, fmt.Errorf("total attachment size %.1f MB exceeds the 25 MB EML limit; "+
+			"large attachment upload requires user identity (--as user)",
+			float64(totalBytes)/1024/1024)
+	}
+
+	// Upload oversized files.
+	results, err := uploadLargeAttachments(ctx, runtime, classified.Oversized)
+	if err != nil {
+		return patch, err
+	}
+
+	if hasHTML {
+		injectLargeAttachmentHTMLIntoSnapshot(snapshot, runtime.Config.Brand, resolveLang(runtime), results)
+	} else {
+		largeText := buildLargeAttachmentPlainText(runtime.Config.Brand, resolveLang(runtime), results)
+		injectLargeAttachmentTextIntoSnapshot(snapshot, largeText)
+	}
+
+	// Register large attachment tokens, merging with any existing IDs already
+	// present in the snapshot (from a previous draft-create or draft-edit).
+	// The server returns X-Lark-Large-Attachment on readback, so check both
+	// header names.
+	var existingIDs []largeAttID
+	existingIdx := -1
+	for i, h := range snapshot.Headers {
+		if draftpkg.IsLargeAttachmentHeader(h.Name) {
+			existingIdx = i
+			if decoded, err := base64.StdEncoding.DecodeString(h.Value); err == nil {
+				var raw []json.RawMessage
+				if json.Unmarshal(decoded, &raw) == nil {
+					for _, r := range raw {
+						var entry struct {
+							ID      string `json:"id"`
+							FileKey string `json:"file_key"`
+						}
+						if json.Unmarshal(r, &entry) == nil {
+							tok := entry.ID
+							if tok == "" {
+								tok = entry.FileKey
+							}
+							if tok != "" {
+								existingIDs = append(existingIDs, largeAttID{ID: tok})
+							}
+						}
+					}
+				}
+			}
+			break
+		}
+	}
+	merged := existingIDs
+	for _, r := range results {
+		merged = append(merged, largeAttID{ID: r.FileToken})
+	}
+	idsJSON, err := json.Marshal(merged)
+	if err != nil {
+		return patch, fmt.Errorf("failed to encode large attachment IDs: %w", err)
+	}
+	headerValue := base64.StdEncoding.EncodeToString(idsJSON)
+	if existingIdx >= 0 {
+		snapshot.Headers[existingIdx].Name = draftpkg.LargeAttachmentIDsHeader
+		snapshot.Headers[existingIdx].Value = headerValue
+	} else {
+		snapshot.Headers = append(snapshot.Headers, draftpkg.Header{
+			Name:  draftpkg.LargeAttachmentIDsHeader,
+			Value: headerValue,
+		})
+	}
+
+	// Remove oversized ops from the patch (keep normal ones for draft.Apply).
+	oversizedIndices := make(map[int]bool, len(classified.Oversized))
+	for _, f := range classified.Oversized {
+		oversizedIndices[f.SourceIndex] = true
+	}
+	var filteredOps []draftpkg.PatchOp
+	for i, op := range patch.Ops {
+		if oversizedIndices[i] {
+			continue // skip oversized, already uploaded
+		}
+		filteredOps = append(filteredOps, op)
+	}
+	patch.Ops = filteredOps
+
+	fmt.Fprintf(runtime.IO().ErrOut, "  %d normal attachment(s) in patch\n", len(classified.Normal))
+	fmt.Fprintf(runtime.IO().ErrOut, "  %d large attachment(s) uploaded (download links in body)\n", len(classified.Oversized))
+
+	return patch, nil
+}
+
+// snapshotEMLBaseSize estimates the current EML size of a draft snapshot by
+// summing all part bodies (base64 encoded) plus a header overhead.
+func snapshotEMLBaseSize(snapshot *draftpkg.DraftSnapshot) int64 {
+	const headerOverhead = 2048
+	var total int64 = headerOverhead
+	for _, p := range flattenSnapshotParts(snapshot.Body) {
+		total += estimateBase64EMLSize(int64(len(p.Body)))
+	}
+	return total
+}
+
+// flattenSnapshotParts recursively collects all parts in the MIME tree.
+func flattenSnapshotParts(root *draftpkg.Part) []*draftpkg.Part {
+	if root == nil {
+		return nil
+	}
+	out := []*draftpkg.Part{root}
+	for _, child := range root.Children {
+		out = append(out, flattenSnapshotParts(child)...)
+	}
+	return out
+}
+
+// injectLargeAttachmentHTMLIntoSnapshot adds large attachment items to the
+// snapshot's HTML body. When the body already contains a large-file-area
+// container, new items are appended inside that container (maintaining a
+// single container, matching the desktop client). Otherwise a new
+// container is created and inserted before the quote block (or appended).
+func injectLargeAttachmentHTMLIntoSnapshot(snapshot *draftpkg.DraftSnapshot, brand core.LarkBrand, lang string, results []largeAttachmentResult) {
+	if len(results) == 0 {
+		return
+	}
+	htmlPart := draftpkg.FindHTMLBodyPart(snapshot.Body)
+	if htmlPart == nil {
+		if snapshot.Body != nil {
+			return
+		}
+		snapshot.Body = &draftpkg.Part{
+			MediaType: "text/html",
+			Body:      []byte(buildLargeAttachmentHTML(brand, lang, results)),
+			Dirty:     true,
+		}
+		return
+	}
+
+	currentHTML := string(htmlPart.Body)
+
+	if draftpkg.HTMLContainsLargeAttachment(currentHTML) {
+		itemsHTML := buildLargeAttachmentItems(brand, lang, results)
+		before, card, after := draftpkg.SplitAtLargeAttachment(currentHTML)
+		merged := card[:len(card)-len("</div>")] + itemsHTML + "</div>"
+		htmlPart.Body = []byte(before + merged + after)
+	} else {
+		fullHTML := buildLargeAttachmentHTML(brand, lang, results)
+		htmlPart.Body = []byte(draftpkg.InsertBeforeQuoteOrAppend(currentHTML, fullHTML))
+	}
+	htmlPart.Dirty = true
+}
+
+func injectLargeAttachmentTextIntoSnapshot(snapshot *draftpkg.DraftSnapshot, largeText string) {
+	textPart := draftpkg.FindTextBodyPart(snapshot.Body)
+	if textPart == nil {
+		if snapshot.Body != nil {
+			return
+		}
+		snapshot.Body = &draftpkg.Part{
+			MediaType: "text/plain",
+			Body:      []byte(largeText),
+			Dirty:     true,
+		}
+		return
+	}
+	textPart.Body = append(textPart.Body, []byte(largeText)...)
+	textPart.Dirty = true
+}
+
+// normalizeLargeAttachmentHeader converts server-format X-Lark-Large-Attachment
+// headers to CLI-format X-Lms-Large-Attachment-Ids and removes all server-format
+// headers. This ensures the PUT update always sends the format the server
+// recognizes for write operations.
+func normalizeLargeAttachmentHeader(snapshot *draftpkg.DraftSnapshot) {
+	cliIdx := -1
+	var serverIdxs []int
+	seen := make(map[string]bool)
+	var serverTokens []largeAttID
+
+	for i, h := range snapshot.Headers {
+		if !draftpkg.IsLargeAttachmentHeader(h.Name) {
+			continue
+		}
+		if strings.EqualFold(h.Name, draftpkg.LargeAttachmentIDsHeader) {
+			cliIdx = i
+			continue
+		}
+		serverIdxs = append(serverIdxs, i)
+		decoded, err := base64.StdEncoding.DecodeString(h.Value)
+		if err != nil {
+			continue
+		}
+		var raw []json.RawMessage
+		if json.Unmarshal(decoded, &raw) != nil {
+			continue
+		}
+		for _, r := range raw {
+			var entry struct {
+				ID      string `json:"id"`
+				FileKey string `json:"file_key"`
+			}
+			if json.Unmarshal(r, &entry) == nil {
+				tok := entry.ID
+				if tok == "" {
+					tok = entry.FileKey
+				}
+				if tok != "" && !seen[tok] {
+					seen[tok] = true
+					serverTokens = append(serverTokens, largeAttID{ID: tok})
+				}
+			}
+		}
+	}
+
+	if len(serverIdxs) == 0 {
+		return
+	}
+
+	// Remove server-format headers in reverse order to preserve indices.
+	for j := len(serverIdxs) - 1; j >= 0; j-- {
+		idx := serverIdxs[j]
+		snapshot.Headers = append(snapshot.Headers[:idx], snapshot.Headers[idx+1:]...)
+		if cliIdx > idx {
+			cliIdx--
+		}
+	}
+
+	// If a CLI-format header exists, it is authoritative — keep it as-is.
+	if cliIdx >= 0 {
+		return
+	}
+
+	// No CLI header — convert server tokens into one.
+	if len(serverTokens) == 0 {
+		return
+	}
+	idsJSON, err := json.Marshal(serverTokens)
+	if err != nil {
+		return
+	}
+	snapshot.Headers = append(snapshot.Headers, draftpkg.Header{
+		Name:  draftpkg.LargeAttachmentIDsHeader,
+		Value: base64.StdEncoding.EncodeToString(idsJSON),
+	})
+}

shortcuts/mail/mail_draft_create.go

@@ -96,18 +96,26 @@ var MailDraftCreate = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		rawEML, err := buildRawEMLForDraftCreate(runtime, input, sigResult, priority)
+		rawEML, err := buildRawEMLForDraftCreate(ctx, runtime, input, sigResult, priority)
 		if err != nil {
 			return err
 		}
-		draftID, err := draftpkg.CreateWithRaw(runtime, mailboxID, rawEML)
+		draftResult, err := draftpkg.CreateWithRaw(runtime, mailboxID, rawEML)
 		if err != nil {
 			return fmt.Errorf("create draft failed: %w", err)
 		}
-		out := map[string]interface{}{"draft_id": draftID}
+		out := map[string]interface{}{"draft_id": draftResult.DraftID}
+		if draftResult.Reference != "" {
+			out["reference"] = draftResult.Reference
+		}
 		runtime.OutFormat(out, nil, func(w io.Writer) {
 			fmt.Fprintln(w, "Draft created.")
-			fmt.Fprintf(w, "draft_id: %s\n", draftID)
+			// Intentionally keep +draft-create output minimal: unlike reply/forward/send
+			// draft-save flows, it does not add a follow-up send tip.
+			fmt.Fprintf(w, "draft_id: %s\n", draftResult.DraftID)
+			if reference, _ := out["reference"].(string); reference != "" {
+				fmt.Fprintf(w, "reference: %s\n", reference)
+			}
 		})
 		return nil
 	},
@@ -134,7 +142,7 @@ func parseDraftCreateInput(runtime *common.RuntimeContext) (draftCreateInput, er
 	return input, nil
 }
 
-func buildRawEMLForDraftCreate(runtime *common.RuntimeContext, input draftCreateInput, sigResult *signatureResult, priority string) (string, error) {
+func buildRawEMLForDraftCreate(ctx context.Context, runtime *common.RuntimeContext, input draftCreateInput, sigResult *signatureResult, priority string) (string, error) {
 	senderEmail := resolveComposeSenderEmail(runtime)
 	if senderEmail == "" {
 		return "", fmt.Errorf("unable to determine sender email; please specify --from explicitly")
@@ -164,8 +172,11 @@ func buildRawEMLForDraftCreate(runtime *common.RuntimeContext, input draftCreate
 		return "", output.ErrValidation("%v", err)
 	}
 	var autoResolvedPaths []string
+	var composedHTMLBody string
+	var composedTextBody string
 	if input.PlainText {
-		bld = bld.TextBody([]byte(input.Body))
+		composedTextBody = input.Body
+		bld = bld.TextBody([]byte(composedTextBody))
 	} else if bodyIsHTML(input.Body) || sigResult != nil {
 		htmlBody := input.Body
 		if !bodyIsHTML(input.Body) {
@@ -176,7 +187,8 @@ func buildRawEMLForDraftCreate(runtime *common.RuntimeContext, input draftCreate
 			return "", resolveErr
 		}
 		resolved = injectSignatureIntoBody(resolved, sigResult)
-		bld = bld.HTMLBody([]byte(resolved))
+		composedHTMLBody = resolved
+		bld = bld.HTMLBody([]byte(composedHTMLBody))
 		bld = addSignatureImagesToBuilder(bld, sigResult)
 		var allCIDs []string
 		for _, ref := range refs {
@@ -193,16 +205,17 @@ func buildRawEMLForDraftCreate(runtime *common.RuntimeContext, input draftCreate
 			return "", err
 		}
 	} else {
-		bld = bld.TextBody([]byte(input.Body))
+		composedTextBody = input.Body
+		bld = bld.TextBody([]byte(composedTextBody))
 	}
 	bld = applyPriority(bld, priority)
-	allFilePaths := append(append(splitByComma(input.Attach), inlineSpecFilePaths(inlineSpecs)...), autoResolvedPaths...)
-	if err := checkAttachmentSizeLimit(runtime.FileIO(), allFilePaths, 0); err != nil {
+	allInlinePaths := append(inlineSpecFilePaths(inlineSpecs), autoResolvedPaths...)
+	composedBodySize := int64(len(composedHTMLBody) + len(composedTextBody))
+	emlBase := estimateEMLBaseSize(runtime.FileIO(), composedBodySize, allInlinePaths, 0)
+	bld, err = processLargeAttachments(ctx, runtime, bld, composedHTMLBody, composedTextBody, splitByComma(input.Attach), emlBase, 0)
+	if err != nil {
 		return "", err
 	}
-	for _, path := range splitByComma(input.Attach) {
-		bld = bld.AddFileAttachment(path)
-	}
 	rawEML, err := bld.BuildBase64URL()
 	if err != nil {
 		return "", output.ErrValidation("build EML failed: %v", err)

shortcuts/mail/mail_draft_create_test.go

@@ -4,10 +4,12 @@
 package mail
 
 import (
+	"context"
 	"os"
 	"strings"
 	"testing"
 
+	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/shortcuts/common"
 	"github.com/spf13/cobra"
 )
@@ -33,7 +35,7 @@ func TestBuildRawEMLForDraftCreate_ResolvesLocalImages(t *testing.T) {
 		Body:    `<p>Hello</p><p><img src="./test_image.png" /></p>`,
 	}
 
-	rawEML, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	rawEML, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err != nil {
 		t.Fatalf("buildRawEMLForDraftCreate() error = %v", err)
 	}
@@ -58,7 +60,7 @@ func TestBuildRawEMLForDraftCreate_NoLocalImages(t *testing.T) {
 		Body:    `<p>Hello <b>world</b></p>`,
 	}
 
-	rawEML, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	rawEML, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err != nil {
 		t.Fatalf("buildRawEMLForDraftCreate() error = %v", err)
 	}
@@ -93,12 +95,12 @@ func TestBuildRawEMLForDraftCreate_AutoResolveCountedInSizeLimit(t *testing.T) {
 		Attach:  "./big.txt",
 	}
 
-	_, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	_, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err == nil {
 		t.Fatal("expected size limit error when auto-resolved image + attachment exceed 25MB")
 	}
-	if !strings.Contains(err.Error(), "25 MB") {
-		t.Fatalf("expected 25 MB limit error, got: %v", err)
+	if !strings.Contains(err.Error(), "25 MB") && !strings.Contains(err.Error(), "large attachment") {
+		t.Fatalf("expected size limit or large attachment error, got: %v", err)
 	}
 }
 
@@ -113,7 +115,7 @@ func TestBuildRawEMLForDraftCreate_OrphanedInlineSpecError(t *testing.T) {
 		Inline:  `[{"cid":"orphan","file_path":"./unused.png"}]`,
 	}
 
-	_, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	_, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err == nil {
 		t.Fatal("expected error for orphaned --inline CID not referenced in body")
 	}
@@ -133,7 +135,7 @@ func TestBuildRawEMLForDraftCreate_MissingCIDRefError(t *testing.T) {
 		Inline:  `[{"cid":"present","file_path":"./present.png"}]`,
 	}
 
-	_, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	_, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err == nil {
 		t.Fatal("expected error for missing CID reference")
 	}
@@ -149,7 +151,7 @@ func TestBuildRawEMLForDraftCreate_WithPriority(t *testing.T) {
 		Body:    `<p>Hello</p>`,
 	}
 
-	rawEML, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "1")
+	rawEML, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "1")
 	if err != nil {
 		t.Fatalf("buildRawEMLForDraftCreate() error = %v", err)
 	}
@@ -166,7 +168,7 @@ func TestBuildRawEMLForDraftCreate_NoPriority(t *testing.T) {
 		Body:    `<p>Hello</p>`,
 	}
 
-	rawEML, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	rawEML, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err != nil {
 		t.Fatalf("buildRawEMLForDraftCreate() error = %v", err)
 	}
@@ -187,7 +189,7 @@ func TestBuildRawEMLForDraftCreate_PlainTextSkipsResolve(t *testing.T) {
 		PlainText: true,
 	}
 
-	rawEML, err := buildRawEMLForDraftCreate(newRuntimeWithFrom("sender@example.com"), input, nil, "")
+	rawEML, err := buildRawEMLForDraftCreate(context.Background(), newRuntimeWithFrom("sender@example.com"), input, nil, "")
 	if err != nil {
 		t.Fatalf("buildRawEMLForDraftCreate() error = %v", err)
 	}
@@ -198,3 +200,50 @@ func TestBuildRawEMLForDraftCreate_PlainTextSkipsResolve(t *testing.T) {
 		t.Fatal("plain-text mode should not resolve local images")
 	}
 }
+
+func TestMailDraftCreatePrettyOutputsReference(t *testing.T) {
+	f, stdout, _, reg := mailShortcutTestFactory(t)
+
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/user_mailboxes/me/profile",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"primary_email_address": "me@example.com",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/user_mailboxes/me/drafts",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"draft_id":  "draft_001",
+				"reference": "https://www.feishu.cn/mail?draftId=draft_001",
+			},
+		},
+	})
+
+	err := runMountedMailShortcut(t, MailDraftCreate, []string{
+		"+draft-create",
+		"--subject", "hello",
+		"--body", "world",
+		"--format", "pretty",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("draft create failed: %v", err)
+	}
+
+	out := stdout.String()
+	if !strings.Contains(out, "Draft created.") {
+		t.Fatalf("expected pretty output header, got: %s", out)
+	}
+	if !strings.Contains(out, "draft_id: draft_001") {
+		t.Fatalf("expected draft_id in pretty output, got: %s", out)
+	}
+	if !strings.Contains(out, "reference: https://www.feishu.cn/mail?draftId=draft_001") {
+		t.Fatalf("expected reference in pretty output, got: %s", out)
+	}
+}

shortcuts/mail/mail_draft_edit.go

@@ -111,26 +111,41 @@ var MailDraftEdit = common.Shortcut{
 				}
 			}
 		}
+		// Pre-process add_attachment ops for large attachment support:
+		// extract oversized files, upload them, inject HTML into the snapshot body.
+		patch, err = preprocessLargeAttachmentsForDraftEdit(ctx, runtime, snapshot, patch)
+		if err != nil {
+			return err
+		}
 		dctx := &draftpkg.DraftCtx{FIO: runtime.FileIO()}
-		if err := draftpkg.Apply(dctx, snapshot, patch); err != nil {
-			return output.ErrValidation("apply draft patch failed: %v", err)
+		if len(patch.Ops) > 0 {
+			if err := draftpkg.Apply(dctx, snapshot, patch); err != nil {
+				return output.ErrValidation("apply draft patch failed: %v", err)
+			}
 		}
 		serialized, err := draftpkg.Serialize(snapshot)
 		if err != nil {
 			return output.ErrValidation("serialize draft failed: %v", err)
 		}
-		if err := draftpkg.UpdateWithRaw(runtime, mailboxID, draftID, serialized); err != nil {
+		updateResult, err := draftpkg.UpdateWithRaw(runtime, mailboxID, draftID, serialized)
+		if err != nil {
 			return fmt.Errorf("update draft failed: %w", err)
 		}
 		projection := draftpkg.Project(snapshot)
 		out := map[string]interface{}{
-			"draft_id":   draftID,
+			"draft_id":   updateResult.DraftID,
 			"warning":    "This edit flow has no optimistic locking. If the same draft is changed concurrently, the last writer wins.",
 			"projection": projection,
 		}
+		if updateResult.Reference != "" {
+			out["reference"] = updateResult.Reference
+		}
 		runtime.OutFormat(out, nil, func(w io.Writer) {
 			fmt.Fprintln(w, "Draft updated.")
-			fmt.Fprintf(w, "draft_id: %s\n", draftID)
+			fmt.Fprintf(w, "draft_id: %s\n", updateResult.DraftID)
+			if reference, _ := out["reference"].(string); reference != "" {
+				fmt.Fprintf(w, "reference: %s\n", reference)
+			}
 			if projection.Subject != "" {
 				fmt.Fprintf(w, "subject: %s\n", sanitizeForTerminal(projection.Subject))
 			}
@@ -200,6 +215,13 @@ func executeDraftInspect(runtime *common.RuntimeContext, mailboxID, draftID stri
 					att.PartID, att.FileName, att.ContentType, att.CID)
 			}
 		}
+		if len(projection.LargeAttachmentsSummary) > 0 {
+			fmt.Fprintf(w, "large_attachments (%d):\n", len(projection.LargeAttachmentsSummary))
+			for _, att := range projection.LargeAttachmentsSummary {
+				fmt.Fprintf(w, "  - token=%s  filename=%s  size_bytes=%d\n",
+					att.Token, att.FileName, att.SizeBytes)
+			}
+		}
 		if len(projection.InlineSummary) > 0 {
 			fmt.Fprintf(w, "inline_parts (%d):\n", len(projection.InlineSummary))
 			for _, inl := range projection.InlineSummary {
@@ -337,11 +359,11 @@ func buildDraftEditPatchTemplate() map[string]interface{} {
 			{"op": "add_recipient", "shape": map[string]interface{}{"field": "to|cc|bcc", "address": "string", "name": "string(optional)"}},
 			{"op": "remove_recipient", "shape": map[string]interface{}{"field": "to|cc|bcc", "address": "string"}},
 			{"op": "set_body", "shape": map[string]interface{}{"value": "string (supports <img src=\"./local/path.png\" /> — local paths auto-resolved to inline MIME parts)"}},
-			{"op": "set_reply_body", "shape": map[string]interface{}{"value": "string (user-authored content only, WITHOUT the quote block; the quote block is re-appended automatically; supports <img src=\"./local/path.png\" /> — local paths auto-resolved to inline MIME parts)"}},
+			{"op": "set_reply_body", "shape": map[string]interface{}{"value": "string (user-authored content only, WITHOUT the quote block; quote block, signature, and attachment cards are auto-preserved; supports <img src=\"./local/path.png\" /> — local paths auto-resolved to inline MIME parts)"}},
 			{"op": "set_header", "shape": map[string]interface{}{"name": "string", "value": "string"}},
 			{"op": "remove_header", "shape": map[string]interface{}{"name": "string"}},
 			{"op": "add_attachment", "shape": map[string]interface{}{"path": "string(relative path)"}},
-			{"op": "remove_attachment", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional)", "cid": "string(optional)"}}},
+			{"op": "remove_attachment", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional, for normal attachment)", "cid": "string(optional, for normal attachment)", "token": "string(optional, for large attachment; from large_attachments_summary in --inspect)"}}},
 			{"op": "add_inline", "shape": map[string]interface{}{"path": "string(relative path)", "cid": "string", "filename": "string(optional)", "content_type": "string(optional)"}, "note": "advanced: prefer <img src=\"./path\"> in set_body/set_reply_body instead"},
 			{"op": "replace_inline", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional)", "cid": "string(optional)"}, "path": "string(relative path)", "cid": "string(optional)", "filename": "string(optional)", "content_type": "string(optional)"}},
 			{"op": "remove_inline", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional)", "cid": "string(optional)"}}},
@@ -354,7 +376,7 @@ func buildDraftEditPatchTemplate() map[string]interface{} {
 				"ops": []map[string]interface{}{
 					{"op": "set_subject", "shape": map[string]interface{}{"value": "string"}},
 					{"op": "set_body", "shape": map[string]interface{}{"value": "string (supports <img src=\"./local/path.png\" /> — local paths auto-resolved to inline MIME parts)"}},
-					{"op": "set_reply_body", "shape": map[string]interface{}{"value": "string (user-authored content only, WITHOUT the quote block; the quote block is re-appended automatically; supports <img src=\"./local/path.png\" /> — local paths auto-resolved to inline MIME parts)"}},
+					{"op": "set_reply_body", "shape": map[string]interface{}{"value": "string (user-authored content only, WITHOUT the quote block; quote block, signature, and attachment cards are auto-preserved; supports <img src=\"./local/path.png\" /> — local paths auto-resolved to inline MIME parts)"}},
 				},
 			},
 			{
@@ -376,7 +398,7 @@ func buildDraftEditPatchTemplate() map[string]interface{} {
 				"group": "attachments_and_inline",
 				"ops": []map[string]interface{}{
 					{"op": "add_attachment", "shape": map[string]interface{}{"path": "string(relative path)"}},
-					{"op": "remove_attachment", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional)", "cid": "string(optional)"}}},
+					{"op": "remove_attachment", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional, for normal attachment)", "cid": "string(optional, for normal attachment)", "token": "string(optional, for large attachment; from large_attachments_summary in --inspect)"}}},
 					{"op": "add_inline", "shape": map[string]interface{}{"path": "string(relative path)", "cid": "string", "filename": "string(optional)", "content_type": "string(optional)"}, "note": "advanced: prefer <img src=\"./path\"> in set_body/set_reply_body instead"},
 					{"op": "replace_inline", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional)", "cid": "string(optional)"}, "path": "string(relative path)", "cid": "string(optional)", "filename": "string(optional)", "content_type": "string(optional)"}},
 					{"op": "remove_inline", "shape": map[string]interface{}{"target": map[string]interface{}{"part_id": "string(optional)", "cid": "string(optional)"}}},
@@ -396,9 +418,9 @@ func buildDraftEditPatchTemplate() map[string]interface{} {
 			"Before editing body, run --inspect to check has_quoted_content; if true, use set_reply_body instead of set_body",
 		},
 		"body_edit_decision_guide": []map[string]interface{}{
-			{"situation": "plain draft or non-reply/forward draft", "recommended_op": "set_body — replaces entire body"},
+			{"situation": "plain draft or non-reply/forward draft", "recommended_op": "set_body — replaces user-authored content; signature/attachments auto-preserved"},
 			{"situation": "draft has both text/plain and text/html", "recommended_op": "set_body — updates HTML body and regenerates plain-text summary; pass HTML input because the original main body is text/html"},
-			{"situation": "draft created by +reply or +forward (has_quoted_content=true)", "recommended_op": "set_reply_body — replaces only the user-authored portion and automatically preserves the quoted original message; if user explicitly wants to remove the quote, use set_body instead"},
+			{"situation": "draft created by +reply or +forward (has_quoted_content=true)", "recommended_op": "set_reply_body — replaces only the user-authored portion; quote block, signature, and attachments are automatically preserved. Use set_body if user explicitly wants to remove or modify the quote"},
 		},
 		"notes": []string{
 			"`set_body`/`set_reply_body` support inline images via local file paths: use <img src=\"./local/file.png\" /> in the HTML value — the local path is automatically resolved into an inline MIME part with a generated CID; removing or replacing an <img> tag automatically cleans up or replaces the corresponding MIME part; do NOT use `add_inline` for this; example: {\"op\":\"set_body\",\"value\":\"<div>Hello<img src=\\\"./logo.png\\\" /></div>\"}",
@@ -406,11 +428,13 @@ func buildDraftEditPatchTemplate() map[string]interface{} {
 			"`ops` is executed in order",
 			"all file paths (--patch-file and `path` fields in ops) must be relative — no absolute paths or .. traversal",
 			"all body edits MUST go through --patch-file; there is no --set-body flag",
-			"`set_body` replaces the ENTIRE body including any reply/forward quote block; when the draft has both text/plain and text/html, it updates the HTML body and regenerates the plain-text summary, so the input should be HTML",
-			"`set_reply_body` replaces only the user-authored portion of the body and automatically re-appends the trailing reply/forward quote block (generated by +reply or +forward); the value you pass should contain ONLY the new user-authored content WITHOUT the quote block — the quote block will be re-inserted automatically; if the user wants to modify content INSIDE the quote block, use `set_body` instead for full replacement; if the draft has no quote block, it behaves identically to `set_body`",
+			"`set_body` replaces the user-authored content. It does NOT auto-preserve the old quote block (include one in value if needed, or use `set_reply_body`). Signature, large attachment card, and normal attachment MIME parts are auto-preserved. When the draft has both text/plain and text/html, it updates the HTML body and regenerates the plain-text summary, so the input should be HTML.",
+			"`set_reply_body` replaces only the user-authored portion of the body and automatically re-appends the trailing reply/forward quote block, signature, and large attachment card; the value you pass should contain ONLY the new user-authored content (no quote, no signature, no attachment card). If the user wants to modify content INSIDE the quote block, use `set_body` instead. If the draft has no quote block, it behaves identically to `set_body`.",
 			"`body_kind` only supports text/plain and text/html",
 			"`selector` currently only supports primary",
-			"`remove_attachment` target supports part_id or cid; priority: part_id > cid",
+			"`remove_attachment` target supports part_id (normal attachment), cid (normal attachment), or token (large attachment); priority: part_id > cid > token",
+			"Large attachments are located by token (not part_id/cid). Get tokens from `--inspect`'s `large_attachments_summary`.",
+			"`set_body` and `set_reply_body` automatically preserve signature block and all attachments (normal + large) from the old body. To delete signature/attachments use the dedicated ops: remove_signature, remove_attachment.",
 			"`remove_attachment`/`remove_inline` require part_id or cid; to discover these values, run `+draft-edit --draft-id <id> --inspect` first — the response `projection.attachments_summary` and `projection.inline_summary` list every part with its part_id, cid, and filename",
 			"`add_inline`/`replace_inline`/`remove_inline` are for CID-based inline images",
 			"`replace_inline` keeps the original filename and content_type when those fields are omitted",

shortcuts/mail/mail_draft_edit_reference_test.go

@@ -0,0 +1,124 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package mail
+
+import (
+	"encoding/base64"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/httpmock"
+)
+
+func TestMailDraftEditOutputsReference(t *testing.T) {
+	f, stdout, _, reg := mailShortcutTestFactory(t)
+
+	rawDraft := base64.RawURLEncoding.EncodeToString([]byte(
+		"From: me@example.com\r\n" +
+			"To: alice@example.com\r\n" +
+			"Subject: Original subject\r\n" +
+			"MIME-Version: 1.0\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"\r\n" +
+			"hello\r\n",
+	))
+
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/user_mailboxes/me/drafts/draft_001",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"draft_id": "draft_001",
+				"raw":      rawDraft,
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/user_mailboxes/me/drafts/draft_001",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"draft_id":  "draft_001",
+				"reference": "https://www.feishu.cn/mail?draftId=draft_001",
+			},
+		},
+	})
+
+	err := runMountedMailShortcut(t, MailDraftEdit, []string{
+		"+draft-edit",
+		"--draft-id", "draft_001",
+		"--set-subject", "Updated subject",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("draft edit failed: %v", err)
+	}
+
+	data := decodeShortcutEnvelopeData(t, stdout)
+	if data["draft_id"] != "draft_001" {
+		t.Fatalf("draft_id = %v", data["draft_id"])
+	}
+	if data["reference"] != "https://www.feishu.cn/mail?draftId=draft_001" {
+		t.Fatalf("reference = %v", data["reference"])
+	}
+}
+
+func TestMailDraftEditPrettyOutputsReference(t *testing.T) {
+	f, stdout, _, reg := mailShortcutTestFactory(t)
+
+	rawDraft := base64.RawURLEncoding.EncodeToString([]byte(
+		"From: me@example.com\r\n" +
+			"To: alice@example.com\r\n" +
+			"Subject: Original subject\r\n" +
+			"MIME-Version: 1.0\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"\r\n" +
+			"hello\r\n",
+	))
+
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/user_mailboxes/me/drafts/draft_001",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"draft_id": "draft_001",
+				"raw":      rawDraft,
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/user_mailboxes/me/drafts/draft_001",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"draft_id":  "draft_001",
+				"reference": "https://www.feishu.cn/mail?draftId=draft_001",
+			},
+		},
+	})
+
+	err := runMountedMailShortcut(t, MailDraftEdit, []string{
+		"+draft-edit",
+		"--draft-id", "draft_001",
+		"--set-subject", "Updated subject",
+		"--format", "pretty",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("draft edit failed: %v", err)
+	}
+
+	out := stdout.String()
+	if !strings.Contains(out, "Draft updated.") {
+		t.Fatalf("expected pretty output header, got: %s", out)
+	}
+	if !strings.Contains(out, "draft_id: draft_001") {
+		t.Fatalf("expected draft_id in pretty output, got: %s", out)
+	}
+	if !strings.Contains(out, "reference: https://www.feishu.cn/mail?draftId=draft_001") {
+		t.Fatalf("expected reference in pretty output, got: %s", out)
+	}
+}