docs: reorganize lark doc skill navigation

* feat: add docs im-markdown fetch format

* refactor: tune docs im-markdown conversion

* test: expand docs im-markdown conversion coverage

* refactor: simplify docs im-markdown handlers

* test: cover docs im-markdown edge cases

* fix: expand doc im markdown tag downgrades

* fix: preserve blockquote paragraph breaks

* fix: handle im markdown nested tables and urls

* docs: document im markdown skill usage

* test: cover doc im markdown fetch

* test: strengthen doc fetch error coverage

* fix: fetch doc skill typo

.github/workflows/semantic-review.yml

@@ -47,10 +47,13 @@ jobs:
               throw new Error(`ambiguous workflow_run pull request bindings: ${runPRs.length}`);
             }
             let prNumber = Number(runPRs[0]?.number || 0);
-            let eventBaseSha = runPRs[0]?.base?.sha || "";
+            const eventBaseSha = runPRs[0]?.base?.sha || "";
             const eventHeadSha = runPRs[0]?.head?.sha || "";
-            const targetHeadSha = eventHeadSha || run.head_sha;
+            const targetHeadSha = run.head_sha;
             if (!/^[a-f0-9]{40}$/i.test(targetHeadSha)) throw new Error("invalid PR head sha");
+            if (eventHeadSha && eventHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()) {
+              core.notice("PR quality summary using workflow_run head_sha because workflow_run pull request head differs from the CI run head");
+            }
 
             const factsArtifactPattern = /^quality-gate-facts-([a-f0-9]{40})-([a-f0-9]{40})$/i;
             const { data: artifactData } = await github.rest.actions.listWorkflowRunArtifacts({
@@ -71,11 +74,11 @@ jobs:
               if (artifactHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()) {
                 artifactError = "facts artifact head sha does not match verified PR head sha";
                 factsArtifactName = "";
-              } else if (eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()) {
-                artifactError = "facts artifact base sha does not match workflow_run pull request base sha";
-                factsArtifactName = "";
               } else {
                 artifactBaseSha = parsedBaseSha;
+                if (eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()) {
+                  core.notice("PR quality summary using facts artifact base because workflow_run pull request base differs from the CI facts artifact base");
+                }
               }
             }
             if (!prNumber) {
@@ -123,7 +126,7 @@ jobs:
               core.setOutput("stale", "true");
               return;
             }
-            const baseSha = eventBaseSha || artifactBaseSha || pr.base.sha;
+            const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha;
             if (!/^[a-f0-9]{40}$/i.test(baseSha)) throw new Error("invalid PR base sha");
             if ((eventBaseSha || artifactBaseSha) && pr.base.sha !== baseSha) {
               core.notice("PR quality summary skipped: workflow_run is stale for this PR base");
@@ -255,10 +258,13 @@ jobs:
               throw new Error(`ambiguous workflow_run pull request bindings: ${runPRs.length}`);
             }
             let prNumber = Number(runPRs[0]?.number || 0);
-            let eventBaseSha = runPRs[0]?.base?.sha || "";
+            const eventBaseSha = runPRs[0]?.base?.sha || "";
             const eventHeadSha = runPRs[0]?.head?.sha || "";
-            const targetHeadSha = eventHeadSha || run.head_sha;
+            const targetHeadSha = run.head_sha;
             if (!/^[a-f0-9]{40}$/i.test(targetHeadSha)) throw new Error("invalid PR head sha");
+            if (eventHeadSha && eventHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()) {
+              core.notice("semantic review using workflow_run head_sha because workflow_run pull request head differs from the CI run head");
+            }
 
             const factsArtifactPattern = /^quality-gate-facts-([a-f0-9]{40})-([a-f0-9]{40})$/i;
             const { data: artifactData } = await github.rest.actions.listWorkflowRunArtifacts({
@@ -279,11 +285,11 @@ jobs:
               if (artifactHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()) {
                 artifactError = "facts artifact head sha does not match verified PR head sha";
                 factsArtifactName = "";
-              } else if (eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()) {
-                artifactError = "facts artifact base sha does not match workflow_run pull request base sha";
-                factsArtifactName = "";
               } else {
                 artifactBaseSha = parsedBaseSha;
+                if (eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()) {
+                  core.notice("semantic review using facts artifact base because workflow_run pull request base differs from the CI facts artifact base");
+                }
               }
             }
             if (!prNumber) {
@@ -331,7 +337,7 @@ jobs:
               core.setOutput("stale", "true");
               return;
             }
-            const baseSha = eventBaseSha || artifactBaseSha || pr.base.sha;
+            const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha;
             if (!/^[a-f0-9]{40}$/i.test(baseSha)) throw new Error("invalid PR base sha");
             if ((eventBaseSha || artifactBaseSha) && pr.base.sha !== baseSha) {
               core.notice("semantic review skipped: workflow_run is stale for this PR base");

.gitignore

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

CHANGELOG.md

@@ -2,6 +2,53 @@
 
 All notable changes to this project will be documented in this file.
 
+## [v1.0.57] - 2026-06-23
+
+### Features
+
+- **slides**: Add `+screenshot` to capture slide page images (or render a single `<slide>` XML snippet), returning the local file path instead of Base64 (#1358)
+- **base**: Support record comments (#1043)
+- **search**: Surface search API notices (#1413)
+
+### Bug Fixes
+
+- **mail**: Resolve folder/label filter once per `+triage list` call (#1512)
+- **meta**: Backfill enum value descriptions from options (#1541)
+- **cli**: Add missing CLI headers for git credential helper (#1539)
+
+### Documentation
+
+- **doc**: Refine rich block, path, and block ID guidance (#1508)
+- **mail**: Trim lark-mail skill context (#1527)
+- **drive**: Add permission governance workflow guidance (#1292)
+
+### Build
+
+- **ci**: Bind semantic review to workflow run head (#1551)
+
+## [v1.0.56] - 2026-06-18
+
+### Features
+
+- **apps**: Add `+session-messages-list` for session turn reply messages (#1402)
+
+### Bug Fixes
+
+- **api**: Align API success envelopes (#1489)
+- **base**: Reject out-of-range pagination flags (#1495)
+
+### Refactor
+
+- Retire legacy error envelopes and enforce typed contract (#1449)
+
+### Documentation
+
+- **skills**: Soften lark-doc style guidance (#1463)
+
+### Build
+
+- Add CI quality gate with semantic review
+
 ## [v1.0.55] - 2026-06-16
 
 ### Features
@@ -1189,6 +1236,8 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
+[v1.0.57]: https://github.com/larksuite/cli/releases/tag/v1.0.57
+[v1.0.56]: https://github.com/larksuite/cli/releases/tag/v1.0.56
 [v1.0.55]: https://github.com/larksuite/cli/releases/tag/v1.0.55
 [v1.0.54]: https://github.com/larksuite/cli/releases/tag/v1.0.54
 [v1.0.53]: https://github.com/larksuite/cli/releases/tag/v1.0.53

cmd/config/config_test.go

@@ -285,18 +285,12 @@ func TestConfigInitRun_NonTerminal_NoFlags_RejectsWithHint(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for non-terminal without flags")
 	}
-	if !strings.Contains(err.Error(), "terminal") {
-		t.Errorf("expected error to mention terminal, got: %s", err.Error())
+	msg := err.Error()
+	if !strings.Contains(msg, "--new") {
+		t.Errorf("expected error to mention --new, got: %s", msg)
 	}
-	// Missing-terminal is a failed precondition (valid request, wrong runtime
-	// state), and the actionable guidance lives in the hint.
-	p, ok := errs.ProblemOf(err)
-	if !ok || p.Subtype != errs.SubtypeFailedPrecondition {
-		t.Fatalf("expected subtype=%q, got problem=%+v", errs.SubtypeFailedPrecondition, p)
-	}
-	// Lock the two-step guidance contract: the hint must point at both flags.
-	if !strings.Contains(p.Hint, "--no-wait") || !strings.Contains(p.Hint, "--device-code") {
-		t.Errorf("hint should describe the two-step flow (--no-wait / --device-code), got: %s", p.Hint)
+	if !strings.Contains(msg, "terminal") {
+		t.Errorf("expected error to mention terminal, got: %s", msg)
 	}
 }
 

cmd/config/init.go

@@ -32,13 +32,6 @@ type ConfigInitOptions struct {
 	Brand          string
 	New            bool
 
-	// NoWait initiates a new-app creation and returns immediately with a
-	// device code (non-blocking step 1); DeviceCode completes a creation
-	// previously started with --no-wait (non-blocking step 2). They mirror
-	// `auth login`'s --no-wait / --device-code split.
-	NoWait     bool
-	DeviceCode string
-
 	Lang         string // raw --lang (string for cobra); normalized to canonical/"" in validateInitLang
 	langExplicit bool   // true when --lang was explicitly passed
 
@@ -63,11 +56,9 @@ func NewCmdConfigInit(f *cmdutil.Factory, runF func(*ConfigInitOptions) error) *
 		Short: "Initialize configuration (app-id / app-secret-stdin / brand)",
 		Long: `Initialize configuration (app-id / app-secret-stdin / brand).
 
-For AI agents: prefer the non-blocking two-step flow. Run '--new --no-wait' to
-get a device code and verification URL immediately (printed as JSON), send the
-URL/QR to the user, then run '--device-code <code>' after they confirm to finish.
-The plain '--new' still blocks until the user completes setup in the browser if
-you need the old behavior.
+For AI agents: use --new to create a new app. The command blocks until the user
+completes setup in the browser. Run it in the background and retrieve the
+verification URL from its output.
 
 Inside an Agent context (OPENCLAW_HOME / HERMES_HOME set) this command
 refuses by default — use 'lark-cli config bind' to bind to the Agent's
@@ -90,8 +81,6 @@ if the user explicitly wants a separate app inside the Agent workspace.`,
 	}
 
 	cmd.Flags().BoolVar(&opts.New, "new", false, "create a new app directly (skip mode selection)")
-	cmd.Flags().BoolVar(&opts.NoWait, "no-wait", false, "create a new app but return immediately with a device code; complete later with --device-code (non-blocking, for AI agents)")
-	cmd.Flags().StringVar(&opts.DeviceCode, "device-code", "", "complete a new-app creation started with --no-wait, using its device code")
 	cmd.Flags().StringVar(&opts.AppID, "app-id", "", "App ID (non-interactive)")
 	cmd.Flags().BoolVar(&opts.AppSecretStdin, "app-secret-stdin", false, "Read App Secret from stdin to avoid process list exposure")
 	cmd.Flags().StringVar(&opts.Brand, "brand", "feishu", "feishu or lark (non-interactive, default feishu)")
@@ -143,7 +132,7 @@ func guardAgentWorkspace(opts *ConfigInitOptions) error {
 
 // hasAnyNonInteractiveFlag returns true if any non-interactive flag is set.
 func (o *ConfigInitOptions) hasAnyNonInteractiveFlag() bool {
-	return o.New || o.AppID != "" || o.AppSecretStdin || o.NoWait || o.DeviceCode != ""
+	return o.New || o.AppID != "" || o.AppSecretStdin
 }
 
 // cleanupOldConfig clears keychain entries (AppSecret + UAT) for all apps in existing config except the app whose AppId equals skipAppID.
@@ -319,22 +308,6 @@ func updateExistingProfileWithoutSecret(existing *core.MultiAppConfig, profileNa
 func configInitRun(opts *ConfigInitOptions) error {
 	f := opts.Factory
 
-	// Validate the non-blocking flags before touching stdin so a contradictory
-	// combination (e.g. --no-wait --app-secret-stdin) fails fast instead of
-	// blocking on a stdin read.
-	if opts.NoWait && opts.DeviceCode != "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--no-wait and --device-code cannot be used together").WithParam("--device-code")
-	}
-	if (opts.NoWait || opts.DeviceCode != "") && (opts.AppID != "" || opts.AppSecretStdin) {
-		// Point remediation at whichever non-blocking flag the caller actually
-		// passed (mutual exclusion above guarantees at most one is set here).
-		conflictParam := "--no-wait"
-		if opts.DeviceCode != "" {
-			conflictParam = "--device-code"
-		}
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--no-wait/--device-code create a new app and cannot be combined with --app-id/--app-secret-stdin").WithParam(conflictParam)
-	}
-
 	// Read secret from stdin if --app-secret-stdin is set
 	if opts.AppSecretStdin {
 		scanner := bufio.NewScanner(f.IOStreams.In)
@@ -362,15 +335,6 @@ func configInitRun(opts *ConfigInitOptions) error {
 		}
 	}
 
-	// Non-blocking step 2: complete a creation started with --no-wait.
-	if opts.DeviceCode != "" {
-		return resumeAppRegistration(opts)
-	}
-	// Non-blocking step 1: initiate a new-app creation and return immediately.
-	if opts.NoWait {
-		return initiateNoWaitAppRegistration(opts, existing)
-	}
-
 	// Mode 1: Non-interactive
 	if opts.AppID != "" && opts.appSecret != "" {
 		brand := parseBrand(opts.Brand)
@@ -473,12 +437,9 @@ func configInitRun(opts *ConfigInitOptions) error {
 		return nil
 	}
 
-	// Non-terminal: the request is valid but the runtime state is wrong (no
-	// terminal for interactive mode) — a failed precondition, not a bad
-	// argument. Point the caller at the non-blocking two-step flow.
+	// Non-terminal: cannot run interactive mode, guide user to --new
 	if !f.IOStreams.IsTerminal {
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "config init interactive mode requires a terminal").
-			WithHint("Create a new app non-interactively with the two-step flow: `lark-cli config init --new --no-wait` (prints device_code + verification_url, returns immediately), then `lark-cli config init --device-code <code>` after the user finishes in the browser. Or run `lark-cli config init --new` in a terminal.")
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "config init requires a terminal for interactive mode. Run with --new to create a new app:\n  lark-cli config init --new\nThis command blocks until setup is complete and outputs a verification URL. Run it in the background, then retrieve the URL from its output.")
 	}
 
 	// Mode 5: Legacy interactive (readline fallback)

cmd/config/init_interactive.go

@@ -182,11 +182,6 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 	httpClient := transport.NewHTTPClient(0)
 	authResp, err := larkauth.RequestAppRegistration(httpClient, larkBrand, f.IOStreams.ErrOut)
 	if err != nil {
-		// Pass a lower-layer typed error (e.g. a network/transport error) through
-		// unchanged; only wrap genuinely-untyped failures as invalid_client.
-		if _, ok := errs.ProblemOf(err); ok {
-			return nil, err
-		}
 		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration failed: %v", err).WithCause(err)
 	}
 

cmd/config/init_nowait.go

@@ -1,265 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/larksuite/cli/errs"
-	larkauth "github.com/larksuite/cli/internal/auth"
-	"github.com/larksuite/cli/internal/build"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/transport"
-)
-
-// newRegistrationHTTPClient builds the HTTP client used for app-registration
-// traffic. It is a package var so tests can inject a stub transport.
-var newRegistrationHTTPClient = func() *http.Client { return transport.NewHTTPClient(0) }
-
-// initNoWaitHint is the agent-facing guidance embedded in the --no-wait JSON
-// output, mirroring the two-step contract of `auth login --no-wait`.
-const initNoWaitHint = "**Generate AND display the QR code:** call `lark-cli auth qrcode <verification_url>` and show it (PNG via --output; ASCII via --ascii only if the user asks). " +
-	"**You MUST include the QR image in your response** — generating the file alone is not enough. Output the URL first, then the QR image below it. " +
-	"**Treat verification_url as an opaque string** — do not URL-encode/decode it or add spaces/punctuation. " +
-	"**Hand control back:** make the QR/URL the final message of this turn; do NOT run --device-code in the same turn. Tell the user to come back and notify you after they finish creating the app in the browser. " +
-	"**After the user confirms:** YOU must finish by running lark-cli with the exact arguments in `resume_args`, passing each element as a separate literal argument (do not re-quote or shell-interpret them). It already carries the right flags. " +
-	"**Do NOT cache verification_url or device_code** — run `lark-cli config init --new --no-wait` fresh whenever a new app is needed."
-
-// initiateNoWaitAppRegistration runs the non-blocking first step: request a
-// device code, cache the resume context, print JSON, and return immediately
-// without polling.
-func initiateNoWaitAppRegistration(opts *ConfigInitOptions, existing *core.MultiAppConfig) error {
-	f := opts.Factory
-	brand := parseBrand(opts.Brand)
-
-	httpClient := newRegistrationHTTPClient()
-	authResp, err := larkauth.RequestAppRegistration(httpClient, brand, f.IOStreams.ErrOut)
-	if err != nil {
-		// Pass a lower-layer typed error (e.g. a network/transport error) through
-		// unchanged; only wrap genuinely-untyped failures as invalid_client.
-		if _, ok := errs.ProblemOf(err); ok {
-			return err
-		}
-		return errs.NewConfigError(errs.SubtypeInvalidClient, "app registration failed: %v", err).WithCause(err)
-	}
-
-	rec := initNoWaitRecord{
-		Version:      initNoWaitCacheVersion,
-		Brand:        string(brand),
-		ProfileName:  opts.ProfileName,
-		Lang:         opts.Lang,
-		LangExplicit: opts.langExplicit,
-		Interval:     authResp.Interval,
-		ExpiresAt:    time.Now().Unix() + int64(authResp.ExpiresIn),
-		ConfigDigest: computeConfigDigest(existing),
-	}
-	// The resume step (--device-code) fully depends on this cache to finish
-	// persisting the app — unlike auth login, which can re-derive its scope. So
-	// a cache-write failure is fatal: fail now rather than hand back a
-	// device_code the user can never complete.
-	if err := saveInitNoWaitRecord(authResp.DeviceCode, rec); err != nil {
-		return errs.NewInternalError(errs.SubtypeStorage, "failed to persist the context needed by `config init --device-code`: %v", err).WithCause(err)
-	}
-
-	// Emit the resume step as an argv array rather than a shell string: the
-	// device_code is opaque and may contain spaces or metacharacters, and a
-	// single quoted string can't be both POSIX- and cmd.exe-safe. argv sidesteps
-	// quoting entirely — agents pass each element as a literal argument.
-	// --force-init must be carried along: guardAgentWorkspace runs in RunE
-	// before the cache is read, so resuming without it inside an agent workspace
-	// would be rejected. (Profile name is recovered from the cache.)
-	resumeArgs := []string{"lark-cli", "config", "init", "--device-code", authResp.DeviceCode}
-	if opts.ForceInit {
-		resumeArgs = append(resumeArgs, "--force-init")
-	}
-
-	verificationURL := larkauth.BuildVerificationURL(authResp.VerificationUriComplete, build.Version)
-	data := map[string]interface{}{
-		"verification_url": verificationURL,
-		"device_code":      authResp.DeviceCode,
-		"expires_in":       authResp.ExpiresIn,
-		"resume_args":      resumeArgs,
-		"hint":             initNoWaitHint,
-	}
-	encoder := json.NewEncoder(f.IOStreams.Out)
-	encoder.SetEscapeHTML(false)
-	if err := encoder.Encode(data); err != nil {
-		return errs.NewInternalError(errs.SubtypeSDKError, "failed to write JSON output: %v", err).WithCause(err)
-	}
-	return nil
-}
-
-// resumeAppRegistration runs the non-blocking second step: poll with a device
-// code from a previous --no-wait call, then persist the new app and probe it.
-func resumeAppRegistration(opts *ConfigInitOptions) error {
-	f := opts.Factory
-
-	rec, err := loadInitNoWaitRecord(opts.DeviceCode)
-	if err != nil {
-		// The record exists but could not be read/parsed (permissions, disk,
-		// corruption). The resume step fully depends on this cache, so surface a
-		// storage error instead of the misleading "no pending creation"
-		// validation path — the user should fix local storage, not assume the
-		// device code is bad and throw away a still-valid creation attempt.
-		return errs.NewInternalError(errs.SubtypeStorage, "failed to read the cached resume context: %v", err).WithCause(err)
-	}
-	if rec == nil {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"no pending app creation found for this device code; re-initiate with `lark-cli config init --new --no-wait`").
-			WithParam("--device-code")
-	}
-
-	// Expiry check against the cached absolute deadline (device codes are
-	// short-lived — the registration default is 300s).
-	remaining := rec.ExpiresAt - time.Now().Unix()
-	if remaining <= 0 {
-		_ = removeInitNoWaitRecord(opts.DeviceCode)
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"device code expired; re-initiate with `lark-cli config init --new --no-wait`").
-			WithParam("--device-code")
-	}
-
-	// Drift guard (fast path): bail out before the long poll if the config
-	// already changed since initiation, so we don't waste minutes polling.
-	existing, err := loadConfigForDriftCheck()
-	if err != nil {
-		return err
-	}
-	if computeConfigDigest(existing) != rec.ConfigDigest {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"configuration changed since this app creation was started; re-initiate with `lark-cli config init --new --no-wait` to avoid overwriting it").
-			WithParam("--device-code")
-	}
-
-	interval := rec.Interval
-	if interval <= 0 {
-		interval = 5
-	}
-
-	httpClient := newRegistrationHTTPClient()
-	result, pollErr := pollAppRegistrationResume(opts.Ctx, httpClient, opts.DeviceCode, interval, int(remaining), f.IOStreams.ErrOut)
-	if pollErr != nil {
-		// Clear the cache only on terminal failures (denied / expired /
-		// timed-out). Keep it on cancellation or transient errors so the user
-		// can retry with the same device code while it is still valid.
-		if appRegShouldClearCache(pollErr) {
-			_ = removeInitNoWaitRecord(opts.DeviceCode)
-		}
-		// Pass an already-typed error through unchanged (e.g. the ConfigError
-		// for a missing client_id/secret) instead of downgrading it to
-		// authentication/unknown — matching runCreateAppFlow.
-		if _, ok := errs.ProblemOf(pollErr); ok {
-			return pollErr
-		}
-		return errs.NewAuthenticationError(errs.SubtypeUnknown, "%v", pollErr).WithCause(pollErr)
-	}
-
-	// Re-check drift immediately before persisting. The poll above can block
-	// for minutes while the user finishes in the browser, and a concurrent
-	// process may have changed config.json in that window — saving the stale
-	// pre-poll snapshot would drop those edits. Reload and compare again.
-	existing, err = loadConfigForDriftCheck()
-	if err != nil {
-		return err
-	}
-	if computeConfigDigest(existing) != rec.ConfigDigest {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"configuration changed while the app was being created, so it was not saved (to avoid overwriting that change); re-run `lark-cli config init --new --no-wait`").
-			WithParam("--device-code")
-	}
-
-	// Determine the final brand from the response, falling back to the cached
-	// brand. The cached brand only seeds link generation + this fallback; the
-	// Lark-tenant re-poll inside pollAppRegistrationResume is what actually
-	// detects a Lark tenant.
-	finalBrand := parseBrand(rec.Brand)
-	if result.UserInfo != nil && result.UserInfo.TenantBrand == "lark" {
-		finalBrand = core.BrandLark
-	} else if result.UserInfo != nil && result.UserInfo.TenantBrand == "feishu" {
-		finalBrand = core.BrandFeishu
-	}
-
-	secret, err := core.ForStorage(result.ClientID, core.PlainSecret(result.ClientSecret), f.Keychain)
-	if err != nil {
-		return errs.NewInternalError(errs.SubtypeSDKError, "%v", err).WithCause(err)
-	}
-	if err := saveInitConfig(rec.ProfileName, existing, f, result.ClientID, secret, finalBrand, rec.Lang); err != nil {
-		// Preserve a typed error (e.g. the --name conflict ValidationError) via
-		// the shared helper instead of downgrading everything to storage —
-		// matching the blocking init paths.
-		return wrapSaveConfigError(err)
-	}
-
-	// Config persisted — only now is it safe to drop the resume cache. Clearing
-	// it only after a successful save means a failure in the drift re-check,
-	// ForStorage, or saveInitConfig above leaves the cache intact so the user
-	// can retry `--device-code` (the remote app already exists).
-	_ = removeInitNoWaitRecord(opts.DeviceCode)
-
-	if rec.LangExplicit && rec.Lang != "" {
-		msg := getInitMsg(opts.UILang)
-		fmt.Fprintln(f.IOStreams.ErrOut, fmt.Sprintf(msg.LangPreferenceSet, rec.Lang))
-	}
-
-	output.PrintJson(f.IOStreams.Out, map[string]interface{}{"appId": result.ClientID, "appSecret": "****", "brand": finalBrand})
-	if err := runProbe(opts.Ctx, f, result.ClientID, result.ClientSecret, finalBrand); err != nil {
-		return err
-	}
-	return nil
-}
-
-// pollAppRegistrationResume polls the registration endpoint (feishu first, then
-// the lark endpoint on the tenant_brand=lark special case) and returns the raw
-// error so the caller can classify it for cache-cleanup decisions.
-func pollAppRegistrationResume(ctx context.Context, httpClient *http.Client, deviceCode string, interval, expiresIn int, errOut io.Writer) (*larkauth.AppRegistrationResult, error) {
-	result, err := larkauth.PollAppRegistration(ctx, httpClient, core.BrandFeishu, deviceCode, interval, expiresIn, errOut)
-	if err != nil {
-		return nil, err
-	}
-	// Lark tenant special case: if tenant_brand=lark and no client_secret,
-	// re-poll against the lark endpoint to obtain the secret.
-	if result.ClientSecret == "" && result.UserInfo != nil && result.UserInfo.TenantBrand == "lark" {
-		result, err = larkauth.PollAppRegistration(ctx, httpClient, core.BrandLark, deviceCode, interval, expiresIn, errOut)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if result.ClientID == "" || result.ClientSecret == "" {
-		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration succeeded but missing client_id or client_secret")
-	}
-	return result, nil
-}
-
-// appRegShouldClearCache reports whether the cached resume context should be
-// discarded after a poll outcome. Success and terminal failures (user denied,
-// device code expired, deadline elapsed) clear it; cancellation and transient
-// errors keep it so the user can retry while the device code is still valid.
-func appRegShouldClearCache(err error) bool {
-	if err == nil {
-		return true
-	}
-	return errors.Is(err, larkauth.ErrAppRegDenied) ||
-		errors.Is(err, larkauth.ErrAppRegExpired) ||
-		errors.Is(err, larkauth.ErrAppRegTimeout)
-}
-
-// loadConfigForDriftCheck loads the config for the drift comparison. A missing
-// config (first-time setup) is fine — it yields a nil config and an empty
-// digest. A genuine storage failure (permission denied, corruption) is surfaced
-// as a typed storage error rather than being silently read as "config drift".
-func loadConfigForDriftCheck() (*core.MultiAppConfig, error) {
-	existing, err := core.LoadMultiAppConfig()
-	if err != nil && !errors.Is(err, os.ErrNotExist) {
-		return nil, errs.NewInternalError(errs.SubtypeStorage, "failed to load config for the drift check: %v", err).WithCause(err)
-	}
-	return existing, nil
-}

cmd/config/init_nowait_cache.go

@@ -1,116 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-// initNoWaitCacheVersion is the schema version of the cached init context.
-// Bump it when the record shape changes so stale entries are ignored.
-const initNoWaitCacheVersion = 1
-
-// initNoWaitRecord is the context persisted by `config init --new --no-wait` so
-// that the later `--device-code` step can complete the app creation. It must
-// never hold a secret, verification URL, or full config — only what the resume
-// step needs to finish persisting the new app.
-type initNoWaitRecord struct {
-	Version      int    `json:"version"`
-	Brand        string `json:"brand"`
-	ProfileName  string `json:"profile_name"`
-	Lang         string `json:"lang"`
-	LangExplicit bool   `json:"lang_explicit"`
-	Interval     int    `json:"interval"`
-	ExpiresAt    int64  `json:"expires_at"` // unix seconds; absolute device-code deadline
-	ConfigDigest string `json:"config_digest"`
-}
-
-// initNoWaitCacheDir returns the directory used to persist config init
-// --no-wait context keyed by device_code.
-func initNoWaitCacheDir() string {
-	return filepath.Join(core.GetConfigDir(), "cache", "config_init_nowait")
-}
-
-// initNoWaitCachePath returns the cache file path for a given device_code.
-func initNoWaitCachePath(deviceCode string) string {
-	return filepath.Join(initNoWaitCacheDir(), initNoWaitCacheKey(deviceCode)+".json")
-}
-
-// initNoWaitCacheKey derives a collision-free, filesystem-safe filename token
-// from an opaque device_code. A sha256 hex digest avoids the collisions a
-// character-replacement sanitizer would cause (e.g. "a/b" and "a:b" both
-// mapping to "a_b").
-func initNoWaitCacheKey(deviceCode string) string {
-	sum := sha256.Sum256([]byte(deviceCode))
-	return hex.EncodeToString(sum[:])
-}
-
-// saveInitNoWaitRecord persists the resume context for a device_code.
-func saveInitNoWaitRecord(deviceCode string, rec initNoWaitRecord) error {
-	if err := vfs.MkdirAll(initNoWaitCacheDir(), 0700); err != nil {
-		return err
-	}
-	data, err := json.Marshal(rec)
-	if err != nil {
-		return err
-	}
-	return validate.AtomicWrite(initNoWaitCachePath(deviceCode), data, 0600)
-}
-
-// loadInitNoWaitRecord loads the resume context for a device_code. It returns
-// (nil, nil) when no cache entry exists.
-func loadInitNoWaitRecord(deviceCode string) (*initNoWaitRecord, error) {
-	data, err := vfs.ReadFile(initNoWaitCachePath(deviceCode))
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	var rec initNoWaitRecord
-	if err := json.Unmarshal(data, &rec); err != nil {
-		_ = vfs.Remove(initNoWaitCachePath(deviceCode))
-		return nil, err
-	}
-	if rec.Version != initNoWaitCacheVersion {
-		_ = vfs.Remove(initNoWaitCachePath(deviceCode))
-		return nil, nil
-	}
-	return &rec, nil
-}
-
-// removeInitNoWaitRecord deletes the cache entry for a device_code.
-func removeInitNoWaitRecord(deviceCode string) error {
-	err := vfs.Remove(initNoWaitCachePath(deviceCode))
-	if errors.Is(err, os.ErrNotExist) {
-		return nil
-	}
-	return err
-}
-
-// computeConfigDigest returns a stable digest of the existing config so the
-// resume step can detect drift between initiation and completion. The digest
-// is a hash of config.json content (app IDs, brands, users, secret references)
-// — it contains no plaintext secret and is safe to cache. A nil config and an
-// (unexpected) marshal error both map to the empty digest.
-func computeConfigDigest(existing *core.MultiAppConfig) string {
-	if existing == nil {
-		return ""
-	}
-	data, err := json.Marshal(existing)
-	if err != nil {
-		return ""
-	}
-	sum := sha256.Sum256(data)
-	return hex.EncodeToString(sum[:])
-}

cmd/config/init_nowait_test.go

@@ -1,521 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/larksuite/cli/errs"
-	larkauth "github.com/larksuite/cli/internal/auth"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-// roundTripFunc adapts a function to an http.RoundTripper.
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
-
-// TestNoWait_InitiateThenResume_EndToEnd drives the full two-step flow against a
-// real local HTTP server: initiate writes the on-disk cache, then a SEPARATE
-// resume call polls the same server, succeeds, and persists the new app. Only
-// the device_code + the cache bridge the two invocations — exactly as the two
-// CLI commands would. (A black-box binary E2E of the success path is impossible
-// without a human: endpoints are hardcoded HTTPS and the real device flow needs
-// a browser scan, so this in-process run through httptest is the highest-fidelity
-// autonomous end-to-end.)
-func TestNoWait_InitiateThenResume_EndToEnd(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_ = r.ParseForm()
-		switch r.FormValue("action") {
-		case "begin":
-			_, _ = w.Write([]byte(`{"device_code":"E2E-DEVICE-CODE","user_code":"E2E-UC","verification_uri":"https://example.test/verify","expires_in":600,"interval":1}`))
-		case "poll":
-			_, _ = w.Write([]byte(`{"client_id":"cli_e2e","client_secret":"sec_e2e","user_info":{"tenant_brand":"feishu","open_id":"ou_e2e"}}`))
-		default:
-			http.Error(w, "unexpected action "+r.FormValue("action"), http.StatusBadRequest)
-		}
-	}))
-	defer ts.Close()
-	tsURL, _ := url.Parse(ts.URL)
-
-	// Redirect the registration client to the local test server.
-	orig := newRegistrationHTTPClient
-	newRegistrationHTTPClient = func() *http.Client {
-		return &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-			r.URL.Scheme, r.URL.Host = tsURL.Scheme, tsURL.Host
-			return http.DefaultTransport.RoundTrip(r)
-		})}
-	}
-	t.Cleanup(func() { newRegistrationHTTPClient = orig })
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-
-	// Step 1 — initiate: should print device_code and write the resume cache.
-	initOpts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), Brand: "feishu", New: true, NoWait: true}
-	if err := initiateNoWaitAppRegistration(initOpts, nil); err != nil {
-		t.Fatalf("initiate: %v", err)
-	}
-	var out map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &out); err != nil {
-		t.Fatalf("initiate stdout not JSON: %v; raw=%s", err, stdout.String())
-	}
-	if out["device_code"] != "E2E-DEVICE-CODE" {
-		t.Fatalf("device_code = %v, want E2E-DEVICE-CODE", out["device_code"])
-	}
-	if rec, _ := loadInitNoWaitRecord("E2E-DEVICE-CODE"); rec == nil {
-		t.Fatal("initiate did not write the resume cache")
-	}
-
-	// Step 2 — resume (separate invocation; bridged only by device_code + cache).
-	stdout.Reset()
-	resumeOpts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: "E2E-DEVICE-CODE"}
-	if err := resumeAppRegistration(resumeOpts); err != nil {
-		t.Fatalf("resume: %v", err)
-	}
-
-	// The new app must be persisted to config...
-	cfg, err := core.LoadMultiAppConfig()
-	if err != nil || cfg == nil {
-		t.Fatalf("config not persisted: %v", err)
-	}
-	if app := cfg.CurrentAppConfig(""); app == nil || app.AppId != "cli_e2e" {
-		t.Fatalf("persisted app = %+v, want AppId cli_e2e", app)
-	}
-	// ...the cache cleared after the successful save...
-	if rec, _ := loadInitNoWaitRecord("E2E-DEVICE-CODE"); rec != nil {
-		t.Error("resume should clear the cache after a successful save")
-	}
-	// ...and the success JSON emitted.
-	if !strings.Contains(stdout.String(), "cli_e2e") {
-		t.Errorf("resume stdout missing appId: %s", stdout.String())
-	}
-}
-
-// stubRT returns a single canned HTTP response for every request.
-type stubRT struct {
-	status int
-	body   string
-}
-
-func (s stubRT) RoundTrip(*http.Request) (*http.Response, error) {
-	return &http.Response{StatusCode: s.status, Body: io.NopCloser(strings.NewReader(s.body)), Header: make(http.Header)}, nil
-}
-
-// seqRT returns successive canned responses (last one repeats), for flows that
-// poll more than once (e.g. the Lark-tenant re-poll).
-type seqRT struct {
-	bodies []string
-	i      int
-}
-
-func (s *seqRT) RoundTrip(*http.Request) (*http.Response, error) {
-	idx := s.i
-	if idx >= len(s.bodies) {
-		idx = len(s.bodies) - 1
-	}
-	s.i++
-	return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(s.bodies[idx])), Header: make(http.Header)}, nil
-}
-
-// withStubRegistrationClient swaps the registration HTTP client for the test.
-func withStubRegistrationClient(t *testing.T, rt http.RoundTripper) {
-	t.Helper()
-	orig := newRegistrationHTTPClient
-	newRegistrationHTTPClient = func() *http.Client { return &http.Client{Transport: rt} }
-	t.Cleanup(func() { newRegistrationHTTPClient = orig })
-}
-
-// --- cache round-trip ---
-
-func TestInitNoWaitCache_RoundTrip(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	rec := initNoWaitRecord{
-		Version:      initNoWaitCacheVersion,
-		Brand:        "feishu",
-		ProfileName:  "work",
-		Lang:         "zh_cn",
-		LangExplicit: true,
-		Interval:     5,
-		ExpiresAt:    time.Now().Unix() + 300,
-		ConfigDigest: "abc123",
-	}
-	const dc = "device-code-xyz"
-
-	if err := saveInitNoWaitRecord(dc, rec); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	got, err := loadInitNoWaitRecord(dc)
-	if err != nil {
-		t.Fatalf("load: %v", err)
-	}
-	if got == nil {
-		t.Fatal("load returned nil for a saved record")
-	}
-	if *got != rec {
-		t.Errorf("round-trip mismatch:\n got  %+v\n want %+v", *got, rec)
-	}
-
-	if err := removeInitNoWaitRecord(dc); err != nil {
-		t.Fatalf("remove: %v", err)
-	}
-	got2, err := loadInitNoWaitRecord(dc)
-	if err != nil {
-		t.Fatalf("load after remove: %v", err)
-	}
-	if got2 != nil {
-		t.Errorf("expected nil after remove, got %+v", got2)
-	}
-	// Removing a non-existent record must be a no-op, not an error.
-	if err := removeInitNoWaitRecord(dc); err != nil {
-		t.Errorf("remove of missing record should be nil, got %v", err)
-	}
-}
-
-func TestInitNoWaitCache_LoadMissing(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	got, err := loadInitNoWaitRecord("never-saved")
-	if err != nil {
-		t.Fatalf("load missing: %v", err)
-	}
-	if got != nil {
-		t.Errorf("expected nil for missing record, got %+v", got)
-	}
-}
-
-func TestInitNoWaitCache_VersionMismatchIgnored(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	const dc = "stale-version"
-	rec := initNoWaitRecord{Version: initNoWaitCacheVersion + 1, ExpiresAt: time.Now().Unix() + 300}
-	if err := saveInitNoWaitRecord(dc, rec); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	got, err := loadInitNoWaitRecord(dc)
-	if err != nil {
-		t.Fatalf("load: %v", err)
-	}
-	if got != nil {
-		t.Errorf("expected nil for version mismatch, got %+v", got)
-	}
-	// The stale entry should have been discarded by the load.
-	got2, _ := loadInitNoWaitRecord(dc)
-	if got2 != nil {
-		t.Errorf("stale-version entry was not removed on load")
-	}
-}
-
-func TestInitNoWaitCacheKey(t *testing.T) {
-	// Distinct device codes that a char-replacement sanitizer would collide
-	// ("a/b" and "a:b" -> "a_b") must map to distinct keys.
-	if initNoWaitCacheKey("a/b") == initNoWaitCacheKey("a:b") {
-		t.Error("distinct device codes must not collide on the cache key")
-	}
-	// Deterministic.
-	if initNoWaitCacheKey("xyz") != initNoWaitCacheKey("xyz") {
-		t.Error("cache key must be deterministic")
-	}
-	// sha256 hex: 64 chars, filesystem-safe regardless of input.
-	k := initNoWaitCacheKey("has /, :, ;, spaces and 'quotes'")
-	if len(k) != 64 {
-		t.Errorf("expected 64-char sha256 hex key, got %d: %q", len(k), k)
-	}
-}
-
-// --- config digest ---
-
-func TestComputeConfigDigest(t *testing.T) {
-	if d := computeConfigDigest(nil); d != "" {
-		t.Errorf("nil digest = %q, want empty", d)
-	}
-	cfg1 := &core.MultiAppConfig{Apps: []core.AppConfig{{AppId: "cli_a", Brand: core.BrandFeishu}}}
-	cfg1Dup := &core.MultiAppConfig{Apps: []core.AppConfig{{AppId: "cli_a", Brand: core.BrandFeishu}}}
-	cfg2 := &core.MultiAppConfig{Apps: []core.AppConfig{{AppId: "cli_b", Brand: core.BrandFeishu}}}
-
-	if computeConfigDigest(cfg1) == "" {
-		t.Error("non-nil config digest should be non-empty")
-	}
-	if computeConfigDigest(cfg1) != computeConfigDigest(cfg1Dup) {
-		t.Error("equal configs should produce equal digests")
-	}
-	if computeConfigDigest(cfg1) == computeConfigDigest(cfg2) {
-		t.Error("different configs should produce different digests")
-	}
-}
-
-// --- failure classification for cache cleanup ---
-
-func TestAppRegShouldClearCache(t *testing.T) {
-	cases := []struct {
-		name string
-		err  error
-		want bool
-	}{
-		{"success", nil, true},
-		{"denied", larkauth.ErrAppRegDenied, true},
-		{"expired", larkauth.ErrAppRegExpired, true},
-		{"expired wrapped", fmt.Errorf("%w, please try again", larkauth.ErrAppRegExpired), true},
-		{"timeout", larkauth.ErrAppRegTimeout, true},
-		{"timeout wrapped", fmt.Errorf("%w, please try again", larkauth.ErrAppRegTimeout), true},
-		{"cancelled", larkauth.ErrAppRegCancelled, false},
-		{"transient generic", fmt.Errorf("network boom"), false},
-		{"missing fields", fmt.Errorf("app registration succeeded but missing client_id or client_secret"), false},
-	}
-	for _, c := range cases {
-		if got := appRegShouldClearCache(c.err); got != c.want {
-			t.Errorf("%s: appRegShouldClearCache = %v, want %v", c.name, got, c.want)
-		}
-	}
-}
-
-// --- initiate (stubbed registration client) ---
-
-func TestInitiateNoWaitAppRegistration_WritesCacheAndJSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-	withStubRegistrationClient(t, stubRT{200, `{"device_code":"dc-abc","user_code":"U-1","verification_uri":"https://open.feishu.cn","expires_in":3600,"interval":5}`})
-
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), Brand: "feishu", New: true, NoWait: true, ForceInit: true}
-	if err := initiateNoWaitAppRegistration(opts, nil); err != nil {
-		t.Fatalf("initiate: %v", err)
-	}
-
-	var out map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &out); err != nil {
-		t.Fatalf("stdout not JSON: %v; raw=%s", err, stdout.String())
-	}
-	if out["device_code"] != "dc-abc" {
-		t.Errorf("device_code = %v, want dc-abc", out["device_code"])
-	}
-	args, ok := out["resume_args"].([]interface{})
-	if !ok || len(args) == 0 || args[len(args)-1] != "--force-init" {
-		t.Errorf("resume_args should end with --force-init, got %v", out["resume_args"])
-	}
-
-	rec, _ := loadInitNoWaitRecord("dc-abc")
-	if rec == nil {
-		t.Fatal("cache record not written")
-	}
-	if rec.Brand != "feishu" || rec.Version != initNoWaitCacheVersion {
-		t.Errorf("cache record = %+v", *rec)
-	}
-}
-
-// --- pollAppRegistrationResume (stubbed client) ---
-
-func TestPollAppRegistrationResume_Success(t *testing.T) {
-	c := &http.Client{Transport: stubRT{200, `{"client_id":"cli_x","client_secret":"sec","user_info":{"tenant_brand":"feishu"}}`}}
-	res, err := pollAppRegistrationResume(context.Background(), c, "dc", 0, 60, io.Discard)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if res.ClientID != "cli_x" || res.ClientSecret != "sec" {
-		t.Errorf("got %+v", res)
-	}
-}
-
-func TestPollAppRegistrationResume_MissingSecret(t *testing.T) {
-	c := &http.Client{Transport: stubRT{200, `{"client_id":"cli_x"}`}}
-	if _, err := pollAppRegistrationResume(context.Background(), c, "dc", 0, 60, io.Discard); err == nil {
-		t.Error("expected error when client_secret is missing")
-	}
-}
-
-func TestPollAppRegistrationResume_LarkRetry(t *testing.T) {
-	// First poll (feishu endpoint): lark tenant, no secret -> triggers re-poll
-	// against the lark endpoint, which returns the secret.
-	rt := &seqRT{bodies: []string{
-		`{"client_id":"cli_x","client_secret":"","user_info":{"tenant_brand":"lark"}}`,
-		`{"client_id":"cli_x","client_secret":"larksec","user_info":{"tenant_brand":"lark"}}`,
-	}}
-	res, err := pollAppRegistrationResume(context.Background(), &http.Client{Transport: rt}, "dc", 0, 60, io.Discard)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if res.ClientSecret != "larksec" {
-		t.Errorf("expected lark re-poll to yield the secret, got %+v", res)
-	}
-}
-
-// Full resume happy path: stubbed poll succeeds, the app is persisted, and the
-// cache is cleared. (runProbe hits the factory's mock client, which has no stub
-// and returns an untyped error that runProbe swallows.)
-func TestResumeAppRegistration_Success(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-	withStubRegistrationClient(t, stubRT{200, `{"client_id":"cli_new","client_secret":"sec","user_info":{"tenant_brand":"feishu"}}`})
-
-	const dc = "resume-ok"
-	rec := initNoWaitRecord{
-		Version:      initNoWaitCacheVersion,
-		Brand:        "feishu",
-		Interval:     1, // keep the single poll fast
-		ExpiresAt:    time.Now().Unix() + 300,
-		ConfigDigest: computeConfigDigest(nil),
-	}
-	if err := saveInitNoWaitRecord(dc, rec); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: dc}
-	if err := resumeAppRegistration(opts); err != nil {
-		t.Fatalf("resume: %v", err)
-	}
-
-	cfg, _ := core.LoadMultiAppConfig()
-	if cfg == nil || cfg.CurrentAppConfig("") == nil || cfg.CurrentAppConfig("").AppId != "cli_new" {
-		t.Errorf("config not persisted with new app id: %+v", cfg)
-	}
-	if got, _ := loadInitNoWaitRecord(dc); got != nil {
-		t.Error("cache should be cleared after a successful save")
-	}
-	if !strings.Contains(stdout.String(), "cli_new") {
-		t.Errorf("stdout missing new appId: %s", stdout.String())
-	}
-}
-
-// A profile-name conflict on the resume save path must surface as the typed
-// ValidationError(--name), not be downgraded to an internal/storage error.
-func TestResumeAppRegistration_ProfileNameConflict_PreservesValidationError(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	withStubRegistrationClient(t, stubRT{200, `{"client_id":"cli_new","client_secret":"sec","user_info":{"tenant_brand":"feishu"}}`})
-
-	// Seed a config whose app id collides with the profile name we resume into.
-	seeded := &core.MultiAppConfig{Apps: []core.AppConfig{
-		{AppId: "cli_existing", AppSecret: core.PlainSecret("s"), Brand: core.BrandFeishu},
-	}}
-	if err := core.SaveMultiAppConfig(seeded); err != nil {
-		t.Fatalf("seed config: %v", err)
-	}
-	loaded, _ := core.LoadMultiAppConfig() // digest must match what resume recomputes
-
-	const dc = "conflict-dc"
-	rec := initNoWaitRecord{
-		Version:      initNoWaitCacheVersion,
-		Brand:        "feishu",
-		ProfileName:  "cli_existing", // collides with the existing appId in saveAsProfile
-		Interval:     1,
-		ExpiresAt:    time.Now().Unix() + 300,
-		ConfigDigest: computeConfigDigest(loaded),
-	}
-	if err := saveInitNoWaitRecord(dc, rec); err != nil {
-		t.Fatalf("save cache: %v", err)
-	}
-
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: dc}
-	assertValidationParam(t, resumeAppRegistration(opts), "--name")
-}
-
-// --- flag validation (returns before any network) ---
-
-func TestConfigInitRun_NoWaitAndDeviceCodeMutuallyExclusive(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), NoWait: true, DeviceCode: "x"}
-	assertValidationParam(t, configInitRun(opts), "--device-code")
-}
-
-func TestConfigInitRun_NoWaitWithAppIDRejected(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), NoWait: true, AppID: "cli_x"}
-	assertValidationParam(t, configInitRun(opts), "--no-wait")
-}
-
-// The conflict error must point at the flag the caller actually passed: with
-// --device-code (not --no-wait) + --app-id, remediation should name --device-code.
-func TestConfigInitRun_DeviceCodeWithAppIDReportsDeviceCode(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: "dc", AppID: "cli_x"}
-	assertValidationParam(t, configInitRun(opts), "--device-code")
-}
-
-// --- resume guards (return before any network) ---
-
-func TestResumeAppRegistration_NoCacheEntry(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: "missing-dc"}
-	assertValidationParam(t, resumeAppRegistration(opts), "--device-code")
-}
-
-func TestResumeAppRegistration_ExpiredClearsCache(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	const dc = "expired-dc"
-	rec := initNoWaitRecord{
-		Version:   initNoWaitCacheVersion,
-		Brand:     "feishu",
-		Interval:  5,
-		ExpiresAt: time.Now().Unix() - 10, // already past
-	}
-	if err := saveInitNoWaitRecord(dc, rec); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: dc}
-	assertValidationParam(t, resumeAppRegistration(opts), "--device-code")
-
-	if got, _ := loadInitNoWaitRecord(dc); got != nil {
-		t.Error("expired cache entry should have been removed")
-	}
-}
-
-// A cache file that exists but cannot be parsed is a storage failure, not a
-// "no pending creation" validation error — the user should fix storage rather
-// than assume the device code is bad.
-func TestResumeAppRegistration_CorruptCacheIsStorageError(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	const dc = "corrupt-dc"
-	if err := os.MkdirAll(initNoWaitCacheDir(), 0o700); err != nil {
-		t.Fatalf("mkdir: %v", err)
-	}
-	if err := os.WriteFile(initNoWaitCachePath(dc), []byte("{ not valid json"), 0o600); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: dc}
-	err := resumeAppRegistration(opts)
-	var intErr *errs.InternalError
-	if !errors.As(err, &intErr) {
-		t.Fatalf("expected *errs.InternalError for unreadable cache, got %T: %v", err, err)
-	}
-	if p, ok := errs.ProblemOf(err); !ok || p.Subtype != errs.SubtypeStorage {
-		t.Fatalf("expected subtype=%q, got problem=%+v", errs.SubtypeStorage, p)
-	}
-	if errors.Unwrap(err) == nil {
-		t.Fatal("expected the underlying cache-read failure to be preserved as a cause")
-	}
-}
-
-func TestResumeAppRegistration_ConfigDrift(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	const dc = "drift-dc"
-	rec := initNoWaitRecord{
-		Version:      initNoWaitCacheVersion,
-		Brand:        "feishu",
-		Interval:     5,
-		ExpiresAt:    time.Now().Unix() + 300,
-		ConfigDigest: "stale-digest-that-will-not-match-current-config",
-	}
-	if err := saveInitNoWaitRecord(dc, rec); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), DeviceCode: dc}
-	assertValidationParam(t, resumeAppRegistration(opts), "--device-code")
-}

cmd/event/list_test.go

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

cmd/event/schema_test.go

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

events/im/card_action.go

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

events/im/card_action_test.go

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

events/im/message_receive.go

@@ -23,7 +23,7 @@ type ImMessageReceiveOutput struct {
 	ChatType    string `json:"chat_type,omitempty"    desc:"Conversation type"                                                                                                                                                                   enum:"p2p,group"`
 	MessageType string `json:"message_type,omitempty" desc:"Message type"`
 	SenderID    string `json:"sender_id,omitempty"    desc:"Sender open_id; prefixed with ou_"                                                                                                                                                   kind:"open_id"`
-	Content     string `json:"content,omitempty"      desc:"Message content. For most types (text/post/image/file/audio, etc.) this is pre-rendered human-readable text. For interactive (cards) it stays as the raw JSON string and callers must fromjson to parse it."`
+	Content     string `json:"content,omitempty"      desc:"Message content. For most types (text/post/image/file/audio, etc.) this is pre-rendered human-readable text."`
 }
 
 func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
@@ -55,8 +55,10 @@ func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.Ra
 	}
 
 	msg := envelope.Event.Message
-	content := msg.Content
-	if msg.MessageType != "interactive" {
+	var content string
+	if msg.MessageType == "interactive" {
+		content = convertlib.ConvertInteractiveEventContent(msg.Content, msg.Mentions)
+	} else {
 		content = convertlib.ConvertBodyContent(msg.MessageType, &convertlib.ConvertContext{
 			RawContent: msg.Content,
 			MentionMap: convertlib.BuildMentionKeyMap(msg.Mentions),

events/im/register.go

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

events/register.go

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

events/task/native.go

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

events/task/preconsume.go

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

events/task/preconsume_test.go

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

events/task/register.go

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

events/task/register_test.go

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

internal/auth/app_registration.go

@@ -6,7 +6,6 @@ package auth
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -14,24 +13,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
 )
 
-// Sentinel errors returned by PollAppRegistration so callers can classify a
-// failure (e.g. to decide whether a cached device code should be discarded)
-// via errors.Is without parsing message strings.
-var (
-	// ErrAppRegDenied means the user rejected the app registration.
-	ErrAppRegDenied = errors.New("app registration denied by user")
-	// ErrAppRegExpired means the device code is no longer valid.
-	ErrAppRegExpired = errors.New("device code expired")
-	// ErrAppRegCancelled means polling was cancelled via the context.
-	ErrAppRegCancelled = errors.New("polling was cancelled")
-	// ErrAppRegTimeout means the local polling deadline elapsed.
-	ErrAppRegTimeout = errors.New("app registration timed out")
-)
-
 // AppRegistrationResponse is the response from the app registration begin endpoint.
 type AppRegistrationResponse struct {
 	DeviceCode              string
@@ -79,7 +63,7 @@ func RequestAppRegistration(httpClient *http.Client, brand core.LarkBrand, errOu
 
 	resp, err := httpClient.Do(req)
 	if err != nil {
-		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "app registration request failed: %v", err).WithCause(err)
+		return nil, err
 	}
 	defer resp.Body.Close()
 	logHTTPResponse(resp)
@@ -154,13 +138,13 @@ func PollAppRegistration(ctx context.Context, httpClient *http.Client, brand cor
 	for time.Now().Before(deadline) && attempts < maxPollAttempts {
 		attempts++
 		if ctx.Err() != nil {
-			return nil, ErrAppRegCancelled
+			return nil, fmt.Errorf("polling was cancelled")
 		}
 
 		select {
 		case <-time.After(time.Duration(currentInterval) * time.Second):
 		case <-ctx.Done():
-			return nil, ErrAppRegCancelled
+			return nil, fmt.Errorf("polling was cancelled")
 		}
 
 		form := url.Values{}
@@ -221,9 +205,9 @@ func PollAppRegistration(ctx context.Context, httpClient *http.Client, brand cor
 			fmt.Fprintf(errOut, "[lark-cli] app-registration: slow_down, interval increased to %ds\n", currentInterval)
 			continue
 		case "access_denied":
-			return nil, ErrAppRegDenied
+			return nil, fmt.Errorf("app registration denied by user")
 		case "expired_token", "invalid_grant":
-			return nil, fmt.Errorf("%w, please try again", ErrAppRegExpired)
+			return nil, fmt.Errorf("device code expired, please try again")
 		}
 
 		desc := getStr(data, "error_description")
@@ -239,5 +223,5 @@ func PollAppRegistration(ctx context.Context, httpClient *http.Client, brand cor
 	if attempts >= maxPollAttempts {
 		fmt.Fprintf(errOut, "[lark-cli] [WARN] app-registration: max poll attempts (%d) reached\n", maxPollAttempts)
 	}
-	return nil, fmt.Errorf("%w, please try again", ErrAppRegTimeout)
+	return nil, fmt.Errorf("app registration timed out, please try again")
 }

internal/auth/app_registration_sentinel_test.go

@@ -1,95 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package auth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/core"
-)
-
-// stubRoundTripper returns a canned response for every request.
-type stubRoundTripper struct {
-	status int
-	body   string
-}
-
-func (s stubRoundTripper) RoundTrip(*http.Request) (*http.Response, error) {
-	return &http.Response{
-		StatusCode: s.status,
-		Body:       io.NopCloser(strings.NewReader(s.body)),
-		Header:     make(http.Header),
-	}, nil
-}
-
-// TestAppRegSentinelMessages locks the user-facing message text so the
-// interactive create flow (which renders these via "%v") does not regress when
-// the errors gained errors.Is support.
-func TestAppRegSentinelMessages(t *testing.T) {
-	cases := map[string]string{
-		ErrAppRegDenied.Error():                                      "app registration denied by user",
-		ErrAppRegCancelled.Error():                                   "polling was cancelled",
-		fmt.Errorf("%w, please try again", ErrAppRegExpired).Error(): "device code expired, please try again",
-		fmt.Errorf("%w, please try again", ErrAppRegTimeout).Error(): "app registration timed out, please try again",
-	}
-	for got, want := range cases {
-		if got != want {
-			t.Errorf("message = %q, want %q", got, want)
-		}
-	}
-}
-
-// TestPollAppRegistration_Classifies verifies that terminal poll outcomes are
-// returned as the matching sentinel error (interval 0 keeps the test fast).
-func TestPollAppRegistration_Classifies(t *testing.T) {
-	cases := []struct {
-		name string
-		body string
-		want error
-	}{
-		{"access_denied", `{"error":"access_denied"}`, ErrAppRegDenied},
-		{"expired_token", `{"error":"expired_token"}`, ErrAppRegExpired},
-		{"invalid_grant", `{"error":"invalid_grant"}`, ErrAppRegExpired},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			client := &http.Client{Transport: stubRoundTripper{status: 200, body: c.body}}
-			_, err := PollAppRegistration(context.Background(), client, core.BrandFeishu, "dc", 0, 60, io.Discard)
-			if !errors.Is(err, c.want) {
-				t.Fatalf("err = %v, want errors.Is(%v)", err, c.want)
-			}
-		})
-	}
-}
-
-func TestPollAppRegistration_Success(t *testing.T) {
-	body := `{"client_id":"cli_x","client_secret":"sec","user_info":{"tenant_brand":"feishu","open_id":"ou_1"}}`
-	client := &http.Client{Transport: stubRoundTripper{status: 200, body: body}}
-	res, err := PollAppRegistration(context.Background(), client, core.BrandFeishu, "dc", 0, 60, io.Discard)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if res.ClientID != "cli_x" || res.ClientSecret != "sec" {
-		t.Errorf("got client_id=%q secret=%q, want cli_x/sec", res.ClientID, res.ClientSecret)
-	}
-	if res.UserInfo == nil || res.UserInfo.TenantBrand != "feishu" {
-		t.Errorf("user info not parsed: %+v", res.UserInfo)
-	}
-}
-
-func TestPollAppRegistration_CancelledContext(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel() // cancel up front
-	client := &http.Client{Transport: stubRoundTripper{status: 200, body: `{"error":"authorization_pending"}`}}
-	_, err := PollAppRegistration(ctx, client, core.BrandFeishu, "dc", 0, 60, io.Discard)
-	if !errors.Is(err, ErrAppRegCancelled) {
-		t.Fatalf("err = %v, want errors.Is(ErrAppRegCancelled)", err)
-	}
-}

internal/binding/audit.go

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

internal/binding/audit_unix.go

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

internal/binding/audit_windows.go

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

internal/binding/audit_windows_test.go

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

internal/meta/normalize.go

@@ -113,7 +113,8 @@ type EnumOption struct {
 }
 
 // EnumOptions returns the field's allowed values paired with their descriptions
-// — from enum, or from options when enum is absent — coerced to the canonical
+// — from enum (with descriptions backfilled from options when the field carries
+// both forms), or from options when enum is absent — coerced to the canonical
 // type and ordered: numeric and boolean values are sorted; string values keep
 // source order (which can encode priority). Uncoercible literals are dropped.
 // Returns nil when the field declares no enum constraint.
@@ -122,9 +123,14 @@ func (f Field) EnumOptions() []EnumOption {
 	var out []EnumOption
 	switch {
 	case len(f.Enum) > 0:
+		// key by raw literal so enum "1" and option 1 align across JSON types
+		desc := make(map[string]string, len(f.Options))
+		for _, o := range f.Options {
+			desc[fmt.Sprintf("%v", o.Value)] = o.Description
+		}
 		for _, e := range f.Enum {
 			if v, ok := coerceLiteral(ct, e); ok {
-				out = append(out, EnumOption{Value: v})
+				out = append(out, EnumOption{Value: v, Description: desc[fmt.Sprintf("%v", e)]})
 			}
 		}
 	case len(f.Options) > 0:

internal/meta/normalize_test.go

@@ -80,6 +80,39 @@ func TestField_EnumOptions(t *testing.T) {
 	}
 }
 
+func TestField_EnumOptions_BothEnumAndOptions(t *testing.T) {
+	// enum is the value set; descriptions backfilled from options, empty where absent
+	f := Field{Type: "string", Enum: []any{"1", "2", "3", "4", "6"}, Options: []Option{
+		{Value: "1", Description: "from"},
+		{Value: "2", Description: "to"},
+		{Value: "6", Description: "subject"},
+	}}
+	want := []EnumOption{
+		{Value: "1", Description: "from"},
+		{Value: "2", Description: "to"},
+		{Value: "3", Description: ""},
+		{Value: "4", Description: ""},
+		{Value: "6", Description: "subject"},
+	}
+	if got := f.EnumOptions(); !reflect.DeepEqual(got, want) {
+		t.Errorf("EnumOptions(enum+options) = %+v, want %+v", got, want)
+	}
+
+	// enum values stored as strings match option values stored as numbers
+	fi := Field{Type: "integer", Enum: []any{"10", "2", "1"}, Options: []Option{
+		{Value: 1, Description: "one"},
+		{Value: 2, Description: "two"},
+	}}
+	wantI := []EnumOption{
+		{Value: int64(1), Description: "one"},
+		{Value: int64(2), Description: "two"},
+		{Value: int64(10), Description: ""},
+	}
+	if got := fi.EnumOptions(); !reflect.DeepEqual(got, wantI) {
+		t.Errorf("EnumOptions(integer enum+options) = %+v, want %+v", got, wantI)
+	}
+}
+
 func TestField_Enum_NumberAndBoolean(t *testing.T) {
 	// number: string-stored floats coerced to float64 and numerically sorted
 	if got := (Field{Type: "number", Enum: []any{"2.5", "1.5", "10"}}).EnumValues(); !reflect.DeepEqual(got, []any{1.5, 2.5, float64(10)}) {

internal/schema/assembler_test.go

@@ -472,6 +472,18 @@ func TestConvert_EnumDescriptions(t *testing.T) {
 	if bare.EnumDescriptions != nil {
 		t.Errorf("bare enum must have nil EnumDescriptions, got %v", bare.EnumDescriptions)
 	}
+
+	// enum + options both present -> enumDescriptions backfilled, aligned, "" where absent
+	both := Convert(meta.Field{Type: "string", Enum: []any{"1", "2", "3"}, Options: []meta.Option{
+		{Value: "1", Description: "from"},
+		{Value: "2", Description: "to"},
+	}})
+	if !reflect.DeepEqual(both.Enum, []interface{}{"1", "2", "3"}) {
+		t.Errorf("both Enum = %v", both.Enum)
+	}
+	if !reflect.DeepEqual(both.EnumDescriptions, []string{"from", "to", ""}) {
+		t.Errorf("both EnumDescriptions = %v, want [from to \"\"] aligned with enum", both.EnumDescriptions)
+	}
 }
 
 func TestBuildMeta_AffordanceFromMethod(t *testing.T) {

package.json

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

scripts/fetch_meta.py

@@ -89,7 +89,7 @@ def main():
     count = len(data.get("services", []))
     print(f"fetch-meta: OK, {count} services from remote API", file=sys.stderr)
 
-    with open(OUT_PATH, "w") as fp:
+    with open(OUT_PATH, "w", encoding="utf-8", newline="\n") as fp:
         json.dump(data, fp, ensure_ascii=False, indent=2)
         fp.write("\n")
 

scripts/semantic-review-workflow.test.sh

@@ -179,7 +179,10 @@ fi
 require_in_step "$summary_verify_step" 'workflowPath !== ".github/workflows/ci.yml"' "PR quality summary must verify the triggering workflow path"
 require_in_step "$summary_verify_step" 'run.event !== "pull_request"' "PR quality summary must only handle pull_request workflow_run events"
 require_in_step "$summary_verify_step" 'run.repository.id !== context.payload.repository.id' "PR quality summary must verify workflow_run repository id"
+require_in_step "$summary_verify_step" 'const targetHeadSha = run.head_sha' "PR quality summary must use the CI run head SHA as the verified PR head"
+require_in_step "$summary_verify_step" 'eventHeadSha && eventHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()' "PR quality summary should tolerate mutable workflow_run PR head metadata"
 require_in_step "$summary_verify_step" 'factsArtifactPattern' "PR quality summary should use the base-bound facts artifact name when available"
+require_in_step "$summary_verify_step" 'const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha' "PR quality summary must prefer the CI-time artifact base SHA"
 require_in_step "$summary_verify_step" 'core.setOutput("artifact_error"' "PR quality summary must expose artifact binding failures"
 require_in_step "$summary_artifact_step" 'factsArtifactName' "PR quality summary artifact step must use the verified facts artifact binding"
 require_in_step "$summary_extract_facts_step" 'SEMANTIC_REVIEW_DECISION_OUT' "PR quality summary artifact verifier must write an infrastructure decision on verifier failure"
@@ -198,8 +201,9 @@ require_in_step "$verify_step" 'workflowPath !== ".github/workflows/ci.yml"' "se
 require_in_step "$verify_step" 'run.repository.id !== context.payload.repository.id' "semantic-review must verify workflow_run repository id"
 require_in_step "$verify_step" 'run.event !== "pull_request"' "semantic-review must only handle pull_request workflow_run events"
 require_in_step "$verify_step" 'run.conclusion !== "success"' "semantic-review must only consume successful CI runs"
-require_in_step "$verify_step" 'const eventHeadSha = runPRs[0]?.head?.sha || ""' "semantic-review must prefer workflow_run PR head when GitHub provides it"
-require_in_step "$verify_step" 'const targetHeadSha = eventHeadSha || run.head_sha' "semantic-review target PR head must come from the workflow_run event"
+require_in_step "$verify_step" 'const eventHeadSha = runPRs[0]?.head?.sha || ""' "semantic-review should inspect workflow_run PR head metadata"
+require_in_step "$verify_step" 'const targetHeadSha = run.head_sha' "semantic-review target PR head must come from the completed CI run"
+require_in_step "$verify_step" 'eventHeadSha && eventHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()' "semantic-review should tolerate mutable workflow_run PR head metadata"
 require_in_step "$verify_step" 'factsArtifactPattern' "semantic-review must use a base-bound facts artifact name"
 require_in_step "$verify_step" 'listWorkflowRunArtifacts' "semantic-review must read the workflow_run artifacts before resolving fallback base SHA"
 require_in_step "$verify_step" 'artifactHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()' "semantic-review must not let the artifact choose a different PR head"
@@ -210,8 +214,8 @@ require_in_step "$verify_step" 'commit_sha: targetHeadSha' "semantic-review fall
 require_in_step "$verify_step" 'github.rest.pulls.list' "semantic-review must have a pull-list fallback when commit association is empty"
 require_in_step "$verify_step" 'candidatePRs.length > 1' "semantic-review must fail closed when commit-to-PR fallback is ambiguous"
 require_in_step "$verify_step" 'pr.head.sha !== targetHeadSha' "semantic-review must skip stale PR heads"
-require_in_step "$verify_step" 'eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()' "semantic-review must reject mismatched event and artifact base SHAs"
-require_in_step "$verify_step" 'const baseSha = eventBaseSha || artifactBaseSha' "semantic-review fallback must use the CI-time artifact base SHA"
+require_in_step "$verify_step" 'eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()' "semantic-review should tolerate mutable workflow_run PR base metadata"
+require_in_step "$verify_step" 'const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha' "semantic-review must prefer the CI-time artifact base SHA"
 require_in_step "$verify_step" 'pr.base.sha !== baseSha' "semantic-review must skip stale PR bases"
 require_in_step "$verify_step" 'core.setOutput("run_id"' "semantic-review must pass verified workflow run id to publisher"
 require_in_step "$verify_step" 'core.setOutput("head_repo_id"' "semantic-review must pass verified head repo id"

shortcuts/apps/apps_html_publish.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"path/filepath"
 	"strings"
 
 	"github.com/larksuite/cli/extension/fileio"
@@ -84,6 +85,9 @@ var AppsHTMLPublish = common.Shortcut{
 			// for dry-run "advisory preview" semantics).
 			dry.Set("validation_error", err.Error())
 		}
+		if hits := oversizeHTMLFiles(candidates); len(hits) > 0 {
+			dry.Set("oversize_html", hits)
+		}
 		dry.Set("file_count", len(candidates))
 		var totalSize int64
 		names := make([]string, 0, len(candidates))
@@ -140,18 +144,22 @@ type appsHTMLPublishSpec struct {
 // per-environment .env.* files for every stage).
 const maxSensitiveListInError = 5
 
+// truncatedJoin joins items with ", ", capping at max entries and appending
+// "(and N more)" for the remainder, so an inline error list stays readable when
+// a payload has many hits.
+func truncatedJoin(items []string, max int) string {
+	if len(items) <= max {
+		return strings.Join(items, ", ")
+	}
+	return strings.Join(items[:max], ", ") + fmt.Sprintf(" (and %d more)", len(items)-max)
+}
+
 // sensitiveCandidatesError builds the Validate-time rejection when --path
 // contains credential files and --allow-sensitive was not set.
 func sensitiveCandidatesError(hits []string) error {
-	var sample string
-	if len(hits) <= maxSensitiveListInError {
-		sample = strings.Join(hits, ", ")
-	} else {
-		sample = strings.Join(hits[:maxSensitiveListInError], ", ") +
-			fmt.Sprintf(" (and %d more)", len(hits)-maxSensitiveListInError)
-	}
 	return appsValidationParamError("--path",
-		"--path contains %d credential file(s) that should not be published: %s", len(hits), sample).
+		"--path contains %d credential file(s) that should not be published: %s",
+		len(hits), truncatedJoin(hits, maxSensitiveListInError)).
 		WithHint("remove these files from the publish payload, OR pass --allow-sensitive if shipping them is intentional (e.g. a docs site demoing credential-file formats)")
 }
 
@@ -168,6 +176,30 @@ var maxHTMLPublishTarballBytes int64 = 20 * 1024 * 1024
 // Mutable for tests.
 var maxHTMLPublishRawBytes int64 = 200 * 1024 * 1024
 
+// maxHTMLPublishSingleHTMLFileBytes 单个 .html 文件上限，对齐妙搭服务端 10MB 约束。
+// 用 var 而非 const，便于单测调小覆盖拦截路径。
+var maxHTMLPublishSingleHTMLFileBytes int64 = 10 * 1024 * 1024
+
+// oversizeHTMLFiles 返回 candidates 中扩展名为 .html（大小写不敏感）且单个 Size 超过
+// maxHTMLPublishSingleHTMLFileBytes 的 RelPath 列表。只针对 .html 文件，不波及图片/字体/JS。
+func oversizeHTMLFiles(candidates []htmlPublishCandidate) []string {
+	var hits []string
+	for _, c := range candidates {
+		if strings.EqualFold(filepath.Ext(c.RelPath), ".html") && c.Size > maxHTMLPublishSingleHTMLFileBytes {
+			hits = append(hits, c.RelPath)
+		}
+	}
+	return hits
+}
+
+// oversizeHTMLFilesError 构造单文件超限的 Validate 风格拒绝。
+func oversizeHTMLFilesError(hits []string) error {
+	return appsValidationParamError("--path",
+		"--path contains %d HTML file(s) exceeding the %d bytes (10MB) per-file limit: %s",
+		len(hits), maxHTMLPublishSingleHTMLFileBytes, truncatedJoin(hits, maxSensitiveListInError)).
+		WithHint("split or trim oversized HTML file(s); the 10MB cap applies to each single .html file")
+}
+
 // ensureIndexHTML 要求 walker 抓到的 candidates 里必须含 index.html。
 // 目录形态：根目录下必须有 index.html。
 // 单文件形态：文件名必须就是 index.html。
@@ -190,6 +222,9 @@ func runHTMLPublish(ctx context.Context, fio fileio.FileIO, publisher appsHTMLPu
 	if err := ensureIndexHTML(candidates); err != nil {
 		return nil, err
 	}
+	if hits := oversizeHTMLFiles(candidates); len(hits) > 0 {
+		return nil, oversizeHTMLFilesError(hits)
+	}
 	var rawTotal int64
 	for _, c := range candidates {
 		rawTotal += c.Size

shortcuts/apps/apps_html_publish_test.go

@@ -503,3 +503,82 @@ func TestRunHTMLPublish_RejectsOversizeRawCandidates(t *testing.T) {
 		t.Fatalf("client must not be called when raw cap hit")
 	}
 }
+
+func TestOversizeHTMLFiles(t *testing.T) {
+	orig := maxHTMLPublishSingleHTMLFileBytes
+	maxHTMLPublishSingleHTMLFileBytes = 100
+	defer func() { maxHTMLPublishSingleHTMLFileBytes = orig }()
+
+	cands := []htmlPublishCandidate{
+		{RelPath: "index.html", Size: 50},
+		{RelPath: "big.html", Size: 4096},
+		{RelPath: "BIG.HTML", Size: 4096}, // 大小写不敏感
+		{RelPath: "huge.png", Size: 9000}, // 非 .html，忽略
+	}
+	hits := oversizeHTMLFiles(cands)
+	if len(hits) != 2 {
+		t.Fatalf("hits=%v, want [big.html BIG.HTML]", hits)
+	}
+	for _, h := range hits {
+		if h == "huge.png" || h == "index.html" {
+			t.Fatalf("unexpected hit %q", h)
+		}
+	}
+}
+
+func TestMaxHTMLPublishSingleHTMLFileBytes_Default(t *testing.T) {
+	if maxHTMLPublishSingleHTMLFileBytes != 10*1024*1024 {
+		t.Fatalf("default=%d, want %d (10MiB)", maxHTMLPublishSingleHTMLFileBytes, 10*1024*1024)
+	}
+}
+
+func TestRunHTMLPublish_RejectsOversizeHTMLFile(t *testing.T) {
+	orig := maxHTMLPublishSingleHTMLFileBytes
+	maxHTMLPublishSingleHTMLFileBytes = 100
+	defer func() { maxHTMLPublishSingleHTMLFileBytes = orig }()
+
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("<html></html>"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "big.html"), []byte(strings.Repeat("x", 4096)), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	fake := &fakeAppsHTMLPublishClient{}
+	_, err := runHTMLPublish(context.Background(), newTestFIO(), fake, appsHTMLPublishSpec{AppID: "app_x", Path: dir})
+	if err == nil {
+		t.Fatalf("expected per-file oversize error")
+	}
+	problem := requireAppsValidationProblem(t, err)
+	if !strings.Contains(problem.Message, "big.html") || !strings.Contains(problem.Message, "10MB") {
+		t.Fatalf("message=%q, want contains 'big.html' and '10MB'", problem.Message)
+	}
+	if problem.Hint == "" {
+		t.Fatalf("expected non-empty hint")
+	}
+	if len(fake.calls) != 0 {
+		t.Fatalf("client must not be called when an HTML file is oversize")
+	}
+}
+
+func TestRunHTMLPublish_IgnoresOversizeNonHTML(t *testing.T) {
+	// 单 .html 上限调小，但超限文件是 .png → 不被本护栏拦截，正常发布。
+	orig := maxHTMLPublishSingleHTMLFileBytes
+	maxHTMLPublishSingleHTMLFileBytes = 100
+	defer func() { maxHTMLPublishSingleHTMLFileBytes = orig }()
+
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("<html></html>"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "big.png"), []byte(strings.Repeat("x", 4096)), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	fake := &fakeAppsHTMLPublishClient{resp: &htmlPublishResponse{URL: "https://miaoda/app_x"}}
+	if _, err := runHTMLPublish(context.Background(), newTestFIO(), fake, appsHTMLPublishSpec{AppID: "app_x", Path: dir}); err != nil {
+		t.Fatalf("non-html oversize must not be blocked by the .html cap: %v", err)
+	}
+	if len(fake.calls) != 1 {
+		t.Fatalf("client should be called; calls=%v", fake.calls)
+	}
+}

shortcuts/apps/apps_init.go

@@ -99,7 +99,14 @@ var AppsInit = common.Shortcut{
 			dry.Set("dir_error", err.Error())
 			dir = defaultCloneDir(appID)
 		} else if isAlreadyInitialized(dir) {
-			dry.Set("already_initialized", true)
+			if existing, e := ensureInitDirMatchesApp(dir, appID); e != nil {
+				if existing != "" {
+					dry.Set("app_id_mismatch", existing)
+				}
+				dry.Set("dir_error", e.Error())
+			} else {
+				dry.Set("already_initialized", true)
+			}
 		} else if e := ensureEmptyDir(dir); e != nil {
 			dry.Set("dir_error", e.Error())
 		}
@@ -199,6 +206,61 @@ func isAlreadyInitialized(dir string) bool {
 	return err == nil && !info.IsDir()
 }
 
+// readMetaAppID 读取 <dir>/.spark/meta.json 的 app_id，用于判断目标目录是否同一个妙搭应用。
+// 返回 (appID, isSparkProject, err)：
+//   - meta.json 不存在             → ("", false, nil)   非妙搭工程
+//   - 读取/解析失败（损坏/不可读）  → ("", false, err)   无法确认是否妙搭工程
+//   - 解析成功                     → (trim 后的 app_id, true, nil)（app_id 缺失/为空时为 ""）
+func readMetaAppID(dir string) (string, bool, error) {
+	b, err := os.ReadFile(filepath.Join(dir, metaRelPath)) //nolint:forbidigo // shortcuts cannot import internal/vfs (depguard rule shortcuts-no-vfs); path is under the validated clone dir, and FileIO.Open rejects absolute paths.
+	if os.IsNotExist(err) {
+		return "", false, nil
+	}
+	if err != nil {
+		return "", false, appsFileIOError(err, "read %s failed: %v", metaRelPath, err)
+	}
+	var m struct {
+		AppID string `json:"app_id"`
+	}
+	if err := json.Unmarshal(b, &m); err != nil {
+		return "", false, appsFileIOError(err, "parse %s failed: %v", metaRelPath, err)
+	}
+	return strings.TrimSpace(m.AppID), true, nil
+}
+
+// ensureInitDirMatchesApp 校验「已存在的目标目录」能否被 appID 安全复用：
+//   - 不是妙搭工程（无 meta.json）        → nil（交给 ensureEmptyDir 判空/非空）
+//   - 是妙搭工程且 app_id 与 appID 一致    → nil（走已初始化短路，复用本地代码）
+//   - 是妙搭工程但 app_id 不一致（含为空）  → 报错，提示换目录
+//   - meta.json 损坏/不可读，无法确认      → 报错（fail closed），提示换目录
+//
+// 返回值 existing 是目录里已存在的 app_id（仅"已是另一个 app"的拒绝场景非空），供调用方在
+// dry-run 里回填 app_id_mismatch，避免二次读 meta.json。
+func ensureInitDirMatchesApp(dir, appID string) (existing string, err error) {
+	existing, isSpark, readErr := readMetaAppID(dir)
+	if readErr != nil {
+		return "", appsValidationParamError("--dir",
+			"target directory %q already exists but its %s is unreadable or corrupted; cannot confirm it belongs to app %s, refusing to use it",
+			dir, metaRelPath, appID).
+			WithHint("choose a different --dir, or repair/remove the directory, before running +init").
+			WithCause(readErr)
+	}
+	if !isSpark || existing == appID {
+		return existing, nil
+	}
+	if existing == "" {
+		// meta 存在但缺 app_id：更可能是同一应用上次 +init 中断留下的半成品，而非另一个 app。
+		return "", appsValidationParamError("--dir",
+			"target directory %q has a %s without an app_id; cannot confirm it belongs to app %s, refusing to use it",
+			dir, metaRelPath, appID).
+			WithHint("remove the directory and re-run +init, or choose a different --dir")
+	}
+	return existing, appsValidationParamError("--dir",
+		"target directory %q is already initialized for a different app (%s); refusing to initialize app %s into it",
+		dir, existing, appID).
+		WithHint("choose a different --dir (or cd into the matching project) before running +init")
+}
+
 // ensureMetaAppID patches <dir>/.spark/meta.json to include app_id when the file
 // exists but lacks (or has an empty) app_id. Other fields are preserved. When
 // the file does not exist, this is a no-op (we never create it).
@@ -378,6 +440,11 @@ func appsInitExecute(ctx context.Context, rctx *common.RuntimeContext) error {
 		return err
 	}
 
+	// 异 app 目录护栏：拒绝把当前 app 初始化进另一个 app 的已初始化工程。
+	if _, err := ensureInitDirMatchesApp(dir, appID); err != nil {
+		return err
+	}
+
 	// Already-initialized short-circuit: a dir containing .spark/meta.json is an
 	// initialized app repo -> skip clone/scaffold/commit, but still refresh
 	// the local env so a re-run picks up the latest startup env vars.

shortcuts/apps/apps_init_test.go

@@ -363,7 +363,7 @@ func TestAppsInit_AlreadyInitialized_ShortCircuit(t *testing.T) {
 	if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(`{"app_id":"whatever"}`), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(`{"app_id":"app_x"}`), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{"env-pull": envPullOK(filepath.Join(abs, ".env.local"))}}
@@ -394,6 +394,40 @@ func TestAppsInit_AlreadyInitialized_ShortCircuit(t *testing.T) {
 	}
 }
 
+func TestAppsInit_AlreadyInitialized_AppIDMismatch(t *testing.T) {
+	dir := relCloneDir(t)
+	if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	// 目录是 app_other 的工程，却用 --app-id app_x 初始化 → 必须报错且不拉 env。
+	if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(`{"app_id":"app_other"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	f := &fakeCommandRunner{}
+	withFakeRunner(t, f)
+	factory, stdout, _ := newAppsExecuteFactory(t)
+	err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_x", "--dir", dir, "--as", "user"}, factory, stdout)
+	if err == nil {
+		t.Fatal("mismatched app_id must error")
+	}
+	problem := requireAppsValidationProblem(t, err)
+	if problem.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype=%q, want %q", problem.Subtype, errs.SubtypeInvalidArgument)
+	}
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) || ve.Param != "--dir" {
+		t.Fatalf("expected *errs.ValidationError with Param=--dir, got %T param=%v", err, ve)
+	}
+	if !strings.Contains(problem.Message, "different app") {
+		t.Fatalf("message=%q, want 'different app'", problem.Message)
+	}
+	for _, c := range f.calls {
+		if containsAll(c, "+env-pull") || containsAll(c, "git", "clone") {
+			t.Errorf("mismatch must not run env-pull/clone; got %v", f.calls)
+		}
+	}
+}
+
 func TestAppsInit_HappyPathCleanTree(t *testing.T) {
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{
 		"credential-init": credInitOK("http://u:t@h/app_x.git"),
@@ -1468,6 +1502,125 @@ func TestAppsInit_Description_IsAboutCode(t *testing.T) {
 	}
 }
 
+func TestReadMetaAppID(t *testing.T) {
+	writeMeta := func(t *testing.T, content string) string {
+		t.Helper()
+		dir := t.TempDir()
+		if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(content), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		return dir
+	}
+
+	// 不存在 meta.json → ("", false, nil)
+	if got, ok, err := readMetaAppID(t.TempDir()); ok || got != "" || err != nil {
+		t.Fatalf("no meta: got (%q,%v,%v), want (\"\",false,nil)", got, ok, err)
+	}
+	// 存在且有 app_id → (app_id, true, nil)
+	if got, ok, err := readMetaAppID(writeMeta(t, `{"app_id":"app_a"}`)); !ok || got != "app_a" || err != nil {
+		t.Fatalf("with app_id: got (%q,%v,%v), want (\"app_a\",true,nil)", got, ok, err)
+	}
+	// 存在但 app_id 空 → ("", true, nil)
+	if got, ok, err := readMetaAppID(writeMeta(t, `{"name":"x"}`)); !ok || got != "" || err != nil {
+		t.Fatalf("empty app_id: got (%q,%v,%v), want (\"\",true,nil)", got, ok, err)
+	}
+	// 存在但坏 JSON → ("", false, err)（无法确认）
+	if got, ok, err := readMetaAppID(writeMeta(t, `{not json`)); ok || got != "" || err == nil {
+		t.Fatalf("bad json: got (%q,%v,err=%v), want (\"\",false,non-nil)", got, ok, err)
+	}
+}
+
+func TestEnsureInitDirMatchesApp(t *testing.T) {
+	writeMeta := func(t *testing.T, content string) string {
+		t.Helper()
+		dir := t.TempDir()
+		if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(content), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		return dir
+	}
+
+	// 无 meta（非妙搭工程）→ nil（交给 ensureEmptyDir）
+	if _, err := ensureInitDirMatchesApp(t.TempDir(), "app_x"); err != nil {
+		t.Fatalf("no meta should pass: %v", err)
+	}
+	// 同 app_id → (app_id, nil)（走已初始化短路）
+	if existing, err := ensureInitDirMatchesApp(writeMeta(t, `{"app_id":"app_x"}`), "app_x"); err != nil || existing != "app_x" {
+		t.Fatalf("same app should pass: existing=%q err=%v", existing, err)
+	}
+
+	// 不同 app_id → error（换目录），返回 existing=app_other；断言 typed metadata（subtype/param）
+	existing, errMismatch := ensureInitDirMatchesApp(writeMeta(t, `{"app_id":"app_other"}`), "app_x")
+	if errMismatch == nil {
+		t.Fatal("different app should error")
+	}
+	if existing != "app_other" {
+		t.Fatalf("mismatch should return existing app_id, got %q", existing)
+	}
+	problem := requireAppsValidationProblem(t, errMismatch) // 已校验 Category==Validation
+	if problem.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("subtype=%q, want %q", problem.Subtype, errs.SubtypeInvalidArgument)
+	}
+	var ve *errs.ValidationError
+	if !errors.As(errMismatch, &ve) {
+		t.Fatalf("expected *errs.ValidationError, got %T", errMismatch)
+	}
+	if ve.Param != "--dir" {
+		t.Fatalf("param=%q, want --dir", ve.Param)
+	}
+	if !strings.Contains(problem.Message, "different app") || !strings.Contains(problem.Message, "app_other") {
+		t.Fatalf("message=%q, want 'different app' and 'app_other'", problem.Message)
+	}
+	if !strings.Contains(problem.Hint, "different --dir") {
+		t.Fatalf("hint=%q, want 'different --dir'", problem.Hint)
+	}
+
+	// 空 app_id（缺 app_id 标记的半成品）→ error，独立文案（非 "different app"），返回 existing=""
+	emptyExisting, errEmpty := ensureInitDirMatchesApp(writeMeta(t, `{"name":"x"}`), "app_x")
+	if errEmpty == nil {
+		t.Fatal("empty meta app_id should error (cannot confirm same app)")
+	}
+	if emptyExisting != "" {
+		t.Fatalf("empty app_id should return existing=\"\", got %q", emptyExisting)
+	}
+	pEmpty := requireAppsValidationProblem(t, errEmpty)
+	if pEmpty.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("empty subtype=%q, want %q", pEmpty.Subtype, errs.SubtypeInvalidArgument)
+	}
+	if !strings.Contains(pEmpty.Message, "without an app_id") {
+		t.Fatalf("empty app_id should have its own message, msg=%q", pEmpty.Message)
+	}
+	if strings.Contains(pEmpty.Message, "different app") {
+		t.Fatalf("empty app_id must not reuse the different-app wording, msg=%q", pEmpty.Message)
+	}
+
+	// meta 损坏/不可读 → error（fail closed），返回 existing=""
+	badExisting, errBad := ensureInitDirMatchesApp(writeMeta(t, `{not json`), "app_x")
+	if errBad == nil {
+		t.Fatal("corrupted meta should fail closed")
+	}
+	if badExisting != "" {
+		t.Fatalf("corrupted should return existing=\"\", got %q", badExisting)
+	}
+	pBad := requireAppsValidationProblem(t, errBad)
+	if pBad.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("corrupted subtype=%q, want %q", pBad.Subtype, errs.SubtypeInvalidArgument)
+	}
+	if !strings.Contains(pBad.Message, "unreadable or corrupted") {
+		t.Fatalf("corrupted meta msg=%q, want 'unreadable or corrupted'", pBad.Message)
+	}
+	var veBad *errs.ValidationError
+	if !errors.As(errBad, &veBad) || veBad.Param != "--dir" {
+		t.Fatalf("corrupted: expected ValidationError Param=--dir, got %T param=%v", errBad, veBad)
+	}
+}
+
 // TestRunScaffold_SubprocessFailureIsExternalTool pins the typed
 // classification of an external-tool failure: a failing git subprocess
 // surfaces as internal/external_tool with the cause preserved.

shortcuts/apps/git_credential.go

@@ -17,6 +17,7 @@ import (
 	"text/tabwriter"
 	"time"
 
+	"github.com/google/uuid"
 	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
 	"github.com/spf13/cobra"
 
@@ -32,6 +33,7 @@ import (
 )
 
 const gitCredentialIssuePath = apiBasePath + "/apps/:app_id/git_info"
+const gitCredentialHelperReportedShortcut = appsService + ":+git-credential-helper"
 
 // gitCredentialIssueHint is the actionable next-step attached to a failed
 // Git-credential issuance. A 5xx is flagged retryable separately at the call site.
@@ -302,7 +304,12 @@ func (i factoryIssuer) Issue(ctx context.Context, appID string, profile gitcred.
 		HttpMethod: http.MethodGet,
 		ApiPath:    issuePath(appID),
 	}
-	resp, err := ac.DoSDKRequest(ctx, req, core.AsUser)
+	ctx = contextWithGitCredentialHelperShortcut(ctx)
+	var opts []larkcore.RequestOptionFunc
+	if optFn := cmdutil.ShortcutHeaderOpts(ctx); optFn != nil {
+		opts = append(opts, optFn)
+	}
+	resp, err := ac.DoSDKRequest(ctx, req, core.AsUser, opts...)
 	data, err := parseIssueCredentialData(resp, err, errclass.ClassifyContext{
 		Brand:    string(cfg.Brand),
 		AppID:    cfg.AppID,
@@ -314,6 +321,13 @@ func (i factoryIssuer) Issue(ctx context.Context, appID string, profile gitcred.
 	return issuedFromData(appID, data)
 }
 
+func contextWithGitCredentialHelperShortcut(ctx context.Context) context.Context {
+	if _, ok := cmdutil.ShortcutNameFromContext(ctx); ok {
+		return ctx
+	}
+	return cmdutil.ContextWithShortcut(ctx, gitCredentialHelperReportedShortcut, uuid.New().String())
+}
+
 func runGitCredentialHelper(ctx context.Context, f *cmdutil.Factory, appID, action string) error {
 	if f == nil || f.IOStreams == nil {
 		return nil

shortcuts/apps/git_credential_test.go

@@ -825,7 +825,7 @@ func TestRunGitCredentialHelperActions(t *testing.T) {
 func TestFactoryIssuerBranches(t *testing.T) {
 	factory, _, reg := newAppsExecuteFactory(t)
 	expiresAt := time.Now().Add(24 * time.Hour).Unix()
-	reg.Register(&httpmock.Stub{
+	issueStub := &httpmock.Stub{
 		Method: "GET",
 		URL:    "/open-apis/spark/v1/apps/app_xxx/git_info",
 		Body: map[string]interface{}{
@@ -836,7 +836,8 @@ func TestFactoryIssuerBranches(t *testing.T) {
 				"StatusCode": 0,
 			},
 		},
-	})
+	}
+	reg.Register(issueStub)
 	issued, err := (factoryIssuer{f: factory}).Issue(context.Background(), "app_xxx", gitcred.ProfileContext{})
 	if err != nil {
 		t.Fatalf("factory issuer returned error: %v", err)
@@ -844,6 +845,12 @@ func TestFactoryIssuerBranches(t *testing.T) {
 	if issued.PAT != "pat-token" {
 		t.Fatalf("PAT = %q", issued.PAT)
 	}
+	if got := issueStub.CapturedHeaders.Get(cmdutil.HeaderShortcut); got != gitCredentialHelperReportedShortcut {
+		t.Fatalf("%s = %q, want %q", cmdutil.HeaderShortcut, got, gitCredentialHelperReportedShortcut)
+	}
+	if got := issueStub.CapturedHeaders.Get(cmdutil.HeaderExecutionId); got == "" {
+		t.Fatalf("%s header missing", cmdutil.HeaderExecutionId)
+	}
 
 	factory.Config = func() (*core.CliConfig, error) { return nil, errors.New("config failed") }
 	if _, err := (factoryIssuer{f: factory}).Issue(context.Background(), "app_xxx", gitcred.ProfileContext{}); err == nil {
@@ -880,6 +887,20 @@ func TestFactoryIssuerBranches(t *testing.T) {
 	}
 }
 
+func TestContextWithGitCredentialHelperShortcutPreservesExistingShortcut(t *testing.T) {
+	ctx := cmdutil.ContextWithShortcut(context.Background(), "apps:+git-credential-init", "exec-existing")
+	got := contextWithGitCredentialHelperShortcut(ctx)
+
+	name, ok := cmdutil.ShortcutNameFromContext(got)
+	if !ok || name != "apps:+git-credential-init" {
+		t.Fatalf("shortcut = %q ok=%v, want existing shortcut", name, ok)
+	}
+	executionID, ok := cmdutil.ExecutionIdFromContext(got)
+	if !ok || executionID != "exec-existing" {
+		t.Fatalf("execution id = %q ok=%v, want existing execution id", executionID, ok)
+	}
+}
+
 func TestGitCredentialHelpersAndParsers(t *testing.T) {
 	if issuePath(" app/with space ") != "/open-apis/spark/v1/apps/app%2Fwith%20space/git_info" {
 		t.Fatalf("issuePath escaped incorrectly: %s", issuePath(" app/with space "))

shortcuts/base/base_resolve.go

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

shortcuts/base/base_resolve_test.go

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

shortcuts/base/base_shortcuts_test.go

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

shortcuts/base/shortcuts.go

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

shortcuts/common/drive_media_upload_typed_test.go

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

shortcuts/common/mcp_client_test.go

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

shortcuts/common/runner.go

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

shortcuts/common/runner_args_test.go

@@ -4,9 +4,12 @@
 package common
 
 import (
+	"context"
+	"reflect"
 	"strings"
 	"testing"
 
+	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/spf13/cobra"
 )
 
@@ -19,6 +22,7 @@ func TestRejectPositionalArgs_WithArgs(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for positional arg, got nil")
 	}
+	// rejectPositionalArgs returns a raw fmt.Errorf via cobra's PositionalArgs contract — not a typed envelope, message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "positional arguments are not supported") {
 		t.Errorf("expected positional args rejection message, got: %v", err)
 	}
@@ -36,6 +40,7 @@ func TestRejectPositionalArgs_MultipleArgs(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for multiple positional args, got nil")
 	}
+	// rejectPositionalArgs returns a raw fmt.Errorf via cobra's PositionalArgs contract — not a typed envelope, message-substring assertion is intentional.
 	if !strings.Contains(err.Error(), "positional arguments are not supported") {
 		t.Errorf("unexpected error message: %v", err)
 	}
@@ -56,3 +61,29 @@ func TestRejectPositionalArgs_NoArgs(t *testing.T) {
 		t.Fatalf("expected no error for empty args, got: %v", err)
 	}
 }
+
+func TestShortcutFlagIntArray(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	parent := &cobra.Command{Use: "root"}
+	var got []int
+	shortcut := Shortcut{
+		Service:     "slides",
+		Command:     "+screenshot",
+		Description: "capture screenshots",
+		Flags: []Flag{
+			{Name: "slide-number", Type: "int_array"},
+		},
+		Execute: func(ctx context.Context, runtime *RuntimeContext) error {
+			got = runtime.IntArray("slide-number")
+			return nil
+		},
+	}
+	shortcut.Mount(parent, f)
+	parent.SetArgs([]string{"+screenshot", "--as", "user", "--slide-number", "1", "--slide-number", "2,3"})
+	if err := parent.Execute(); err != nil {
+		t.Fatalf("Execute() error = %v", err)
+	}
+	if want := []int{1, 2, 3}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("slide-number = %#v, want %#v", got, want)
+	}
+}

shortcuts/common/runner_botinfo_test.go

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

shortcuts/common/runner_input_test.go

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

shortcuts/common/runner_jq_test.go

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

shortcuts/common/typed_error_assertions_test.go

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

shortcuts/common/types.go

@@ -18,7 +18,7 @@ const (
 // Flag describes a CLI flag for a shortcut.
 type Flag struct {
 	Name     string // flag name (e.g. "calendar-id")
-	Type     string // "string" (default) | "bool" | "int" | "float64" | "string_array" | "string_slice"
+	Type     string // "string" (default) | "bool" | "int" | "float64" | "int_array" | "string_array" | "string_slice"
 	Default  string // default value as string
 	Desc     string // help text
 	Hidden   bool   // hidden from --help, still readable at runtime

shortcuts/contact/contact_search_user.go

@@ -85,6 +85,7 @@ type searchUserAPIData struct {
 	Items     []searchUserAPIItem `json:"items"`
 	HasMore   bool                `json:"has_more"`
 	PageToken string              `json:"page_token"`
+	Notice    string              `json:"notice"`
 }
 
 type searchUserAPIItem struct {
@@ -126,6 +127,7 @@ type searchUser struct {
 type searchUserResponse struct {
 	Users   []searchUser `json:"users"`
 	HasMore bool         `json:"has_more"`
+	Notice  string       `json:"notice,omitempty"`
 }
 
 var ContactSearchUser = common.Shortcut{
@@ -189,6 +191,7 @@ var ContactSearchUser = common.Shortcut{
 	Execute: executeSearchUser,
 }
 
+// executeSearchUser dispatches contact search to single-query or fanout mode.
 func executeSearchUser(ctx context.Context, runtime *common.RuntimeContext) error {
 	if strings.TrimSpace(runtime.Str("queries")) != "" {
 		return executeSearchUserFanout(ctx, runtime)
@@ -196,6 +199,7 @@ func executeSearchUser(ctx context.Context, runtime *common.RuntimeContext) erro
 	return executeSearchUserSingle(ctx, runtime)
 }
 
+// executeSearchUserSingle performs one contact search and preserves server notices.
 func executeSearchUserSingle(ctx context.Context, runtime *common.RuntimeContext) error {
 	body, err := buildSearchUserBody(runtime)
 	if err != nil {
@@ -222,7 +226,7 @@ func executeSearchUserSingle(ctx context.Context, runtime *common.RuntimeContext
 	}
 
 	users, hasMore := projectUsers(respData, runtime.Str("lang"), runtime.Config.Brand)
-	out := searchUserResponse{Users: users, HasMore: hasMore}
+	out := searchUserResponse{Users: users, HasMore: hasMore, Notice: respData.Notice}
 
 	runtime.OutFormat(out, &output.Meta{Count: len(users)}, func(w io.Writer) {
 		if len(users) == 0 {

shortcuts/contact/contact_search_user_fanout.go

@@ -45,22 +45,17 @@ type fanoutResult struct {
 	Query   string
 	Users   []searchUser
 	HasMore bool
+	Notice  string
 	ErrMsg  string // empty = success
 	Err     error  // original failure, kept for typed all-failed propagation
 }
 
-// isFanoutSummaryFormat gates the per-fanout stderr summary line. Includes csv
-// because that summary lives on stderr and never corrupts the csv stream on
-// stdout — single-query mode keeps the narrower isHumanReadableFormat predicate
-// for its refine hint, so adding csv here doesn't regress that path.
+// isFanoutSummaryFormat gates the per-fanout stderr summary line.
 func isFanoutSummaryFormat(format string) bool {
 	return format == "pretty" || format == "table" || format == "csv"
 }
 
-// runOneQuery converts every failure mode (transport, HTTP status, parse,
-// API code) into an ErrMsg string instead of returning a Go error. The
-// fanout dispatcher (Task 6) relies on this so a single failed query never
-// short-circuits the remaining workers.
+// runOneQuery converts one fanout request into either users or an error summary.
 func runOneQuery(ctx context.Context, runtime *common.RuntimeContext, index int, query string,
 	filter *searchUserAPIFilter) fanoutResult {
 	// Pre-check ctx so queued workers see cancellation before issuing a
@@ -94,9 +89,10 @@ func runOneQuery(ctx context.Context, runtime *common.RuntimeContext, index int,
 	}
 
 	users, hasMore := projectUsers(respData, runtime.Str("lang"), runtime.Config.Brand)
-	return fanoutResult{Index: index, Query: query, Users: users, HasMore: hasMore}
+	return fanoutResult{Index: index, Query: query, Users: users, HasMore: hasMore, Notice: respData.Notice}
 }
 
+// fanoutErrorResult records a failed fanout query without stopping other workers.
 func fanoutErrorResult(index int, query string, err error) fanoutResult {
 	if err == nil {
 		return fanoutResult{Index: index, Query: query}
@@ -113,17 +109,16 @@ type querySummary struct {
 	Query   string `json:"query"`
 	Error   string `json:"error,omitempty"`
 	HasMore bool   `json:"has_more"`
+	Notice  string `json:"notice,omitempty"`
 }
 
 type fanoutResponse struct {
 	Users   []fanoutUser   `json:"users"`
 	Queries []querySummary `json:"queries"`
+	Notice  string         `json:"notice,omitempty"`
 }
 
-// buildFanoutResponse walks results by Index (input order), flattens users[]
-// with matched_query, lists every input in queries[] (including successes),
-// and returns an error only when every query failed. The error wraps the
-// first failing query's ErrMsg so the CLI exits non-zero on full failure.
+// buildFanoutResponse flattens ordered fanout results and fails only when all queries fail.
 func buildFanoutResponse(queries []string, results []fanoutResult) (*fanoutResponse, error) {
 	indexed := make([]fanoutResult, len(queries))
 	for _, r := range results {
@@ -142,6 +137,7 @@ func buildFanoutResponse(queries []string, results []fanoutResult) (*fanoutRespo
 			Query:   queries[i],
 			Error:   r.ErrMsg,
 			HasMore: r.HasMore,
+			Notice:  r.Notice,
 		})
 		if r.ErrMsg != "" {
 			failed++
@@ -152,6 +148,9 @@ func buildFanoutResponse(queries []string, results []fanoutResult) (*fanoutRespo
 			}
 			continue
 		}
+		if out.Notice == "" {
+			out.Notice = r.Notice
+		}
 		for _, u := range r.Users {
 			out.Users = append(out.Users, fanoutUser{searchUser: u, MatchedQuery: queries[i]})
 		}

shortcuts/contact/contact_search_user_test.go

@@ -562,6 +562,7 @@ func mountAndRun(t *testing.T, s common.Shortcut, args []string, f *cmdutil.Fact
 	return parent.Execute()
 }
 
+// searchUserStub returns a representative user search response with a notice.
 func searchUserStub() *httpmock.Stub {
 	return &httpmock.Stub{
 		Method: "POST",
@@ -569,6 +570,7 @@ func searchUserStub() *httpmock.Stub {
 		Body: map[string]interface{}{
 			"code": 0, "msg": "ok",
 			"data": map[string]interface{}{
+				"notice": "The query is too long and has been truncated to the first 50 characters for search.",
 				"items": []interface{}{
 					map[string]interface{}{
 						"id": "ou_a",
@@ -590,6 +592,7 @@ func searchUserStub() *httpmock.Stub {
 	}
 }
 
+// TestSearchUser_Integration_PrettyRendersExpectedColumns verifies human output columns.
 func TestSearchUser_Integration_PrettyRendersExpectedColumns(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	reg.Register(searchUserStub())
@@ -614,6 +617,7 @@ func TestSearchUser_Integration_PrettyRendersExpectedColumns(t *testing.T) {
 	}
 }
 
+// TestSearchUser_Integration_JSONStructuredFields verifies normalized JSON and notices.
 func TestSearchUser_Integration_JSONStructuredFields(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	reg.Register(searchUserStub())
@@ -631,6 +635,9 @@ func TestSearchUser_Integration_JSONStructuredFields(t *testing.T) {
 	if !ok {
 		t.Fatalf("envelope.data: expected object, got %v\nraw=%s", got["data"], stdout.String())
 	}
+	if data["notice"] != "The query is too long and has been truncated to the first 50 characters for search." {
+		t.Fatalf("data.notice = %v", data["notice"])
+	}
 	users, _ := data["users"].([]interface{})
 	if len(users) != 1 {
 		t.Fatalf("users: expected 1, got %d (output=%s)", len(users), stdout.String())
@@ -1358,6 +1365,7 @@ func TestSearchUser_Integration_NoAutoPaginationFlags(t *testing.T) {
 	}
 }
 
+// TestFanout_FilterAppliedToEachQuery verifies shared fanout filters reach every request.
 func TestFanout_FilterAppliedToEachQuery(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	stub := &httpmock.Stub{
@@ -1399,6 +1407,7 @@ func TestFanout_FilterAppliedToEachQuery(t *testing.T) {
 	}
 }
 
+// TestFanout_PartialFailure_ExitZero verifies partial fanout failures keep notices.
 func TestFanout_PartialFailure_ExitZero(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	reg.Register(&httpmock.Stub{
@@ -1406,6 +1415,7 @@ func TestFanout_PartialFailure_ExitZero(t *testing.T) {
 		BodyFilter: func(b []byte) bool { return strings.Contains(string(b), `"alice"`) },
 		Body: map[string]interface{}{"code": 0, "msg": "ok",
 			"data": map[string]interface{}{
+				"notice":   "The query is too long and has been truncated to the first 50 characters for search.",
 				"items":    []interface{}{map[string]interface{}{"id": "ou_a"}},
 				"has_more": false,
 			}},
@@ -1432,10 +1442,17 @@ func TestFanout_PartialFailure_ExitZero(t *testing.T) {
 	if len(users) != 1 {
 		t.Errorf("users: expected 1 (alice), got %d; stdout=%s", len(users), stdout.String())
 	}
+	if data["notice"] != "The query is too long and has been truncated to the first 50 characters for search." {
+		t.Fatalf("data.notice = %v", data["notice"])
+	}
 	queries := data["queries"].([]interface{})
 	if len(queries) != 2 {
 		t.Fatalf("queries: expected 2, got %d", len(queries))
 	}
+	q0 := queries[0].(map[string]interface{})
+	if q0["notice"] != "The query is too long and has been truncated to the first 50 characters for search." {
+		t.Fatalf("queries[0].notice = %v", q0["notice"])
+	}
 	q1 := queries[1].(map[string]interface{})
 	if !strings.HasPrefix(q1["error"].(string), "HTTP 500") {
 		t.Errorf("queries[1].error: got %q", q1["error"])

shortcuts/doc/doc_resource_cover.go

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

shortcuts/doc/doc_resource_cover_test.go

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

shortcuts/doc/docs_fetch_im_markdown.go

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

shortcuts/doc/docs_fetch_v2.go

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

shortcuts/doc/docs_fetch_v2_test.go

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

shortcuts/doc/docs_search.go

@@ -74,6 +74,9 @@ var DocsSearch = common.Shortcut{
 			"page_token": data["page_token"],
 			"results":    normalizedItems,
 		}
+		if notice, _ := data["notice"].(string); notice != "" {
+			resultData["notice"] = notice
+		}
 
 		runtime.OutFormat(resultData, &output.Meta{Count: len(normalizedItems)}, func(w io.Writer) {
 			if len(normalizedItems) == 0 {

shortcuts/doc/docs_search_test.go

@@ -7,8 +7,48 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/httpmock"
 )
 
+// TestDocsSearchExecutePassesThroughNotice verifies docs +search preserves notices.
+func TestDocsSearchExecutePassesThroughNotice(t *testing.T) {
+	const notice = "The query is too long and has been truncated to the first 50 characters for search."
+
+	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-search-notice"))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/search/v2/doc_wiki/search",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"notice":     notice,
+				"res_units":  []interface{}{},
+				"total":      0,
+				"has_more":   false,
+				"page_token": "",
+			},
+		},
+	})
+
+	if err := mountAndRunDocs(t, DocsSearch, []string{"+search", "--query", "incident", "--format", "json", "--as", "user"}, f, stdout); err != nil {
+		t.Fatalf("DocsSearch.Execute() error = %v", err)
+	}
+	reg.Verify(t)
+
+	var env map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
+		t.Fatalf("json.Unmarshal(stdout) error = %v\nstdout=%s", err, stdout.String())
+	}
+	data, _ := env["data"].(map[string]interface{})
+	if got, _ := data["notice"].(string); got != notice {
+		t.Fatalf("data.notice = %q, want %q; data=%#v", got, notice, data)
+	}
+}
+
+// TestAddIsoTimeFieldsSupportsJSONNumber verifies JSON numbers get ISO fields.
 func TestAddIsoTimeFieldsSupportsJSONNumber(t *testing.T) {
 	t.Parallel()
 

shortcuts/drive/drive_add_comment.go

@@ -121,7 +121,7 @@ const (
 var DriveAddComment = common.Shortcut{
 	Service:     "drive",
 	Command:     "+add-comment",
-	Description: "Add a comment to doc/docx/file/sheet/slides; file targets support selected extensions and full comments only",
+	Description: "Add a comment to doc/docx/file/sheet/slides/base(bitable); file targets support selected extensions and full comments only",
 	Risk:        "write",
 	Scopes: []string{
 		"drive:drive.metadata:readonly",
@@ -131,12 +131,12 @@ var DriveAddComment = common.Shortcut{
 	},
 	AuthTypes: []string{"user", "bot"},
 	Flags: []common.Flag{
-		{Name: "doc", Desc: "document URL/token, file URL/token, sheet/slides URL, or wiki URL that resolves to doc/docx/file/sheet/slides", Required: true},
-		{Name: "type", Desc: "document type: doc, docx, file, sheet, slides (required when --doc is a bare token; auto-detected for URLs)", Enum: []string{"doc", "docx", "file", "sheet", "slides"}},
+		{Name: "doc", Desc: "document URL/token, file URL/token, sheet/slides/base/bitable URL, or wiki URL that resolves to doc/docx/file/sheet/slides/base(bitable)", Required: true},
+		{Name: "type", Desc: "document type: doc, docx, file, sheet, slides, bitable, base (required when --doc is a bare token; auto-detected for URLs; use bitable as the wire value, base is accepted as a compatibility alias)", Enum: []string{"doc", "docx", "file", "sheet", "slides", "bitable", "base"}},
 		{Name: "content", Desc: "reply_elements JSON string", Required: true, Input: []string{common.File, common.Stdin}},
 		{Name: "full-comment", Type: "bool", Desc: "create a full-document comment; also the default when no location is provided"},
 		{Name: "selection-with-ellipsis", Desc: "target content locator (plain text or 'start...end')"},
-		{Name: "block-id", Desc: "for docx: anchor block ID; for sheet: <sheetId>!<cell> (e.g. a281f9!D6); for slides: <slide-block-type>!<xml-id> (e.g. shape!bPq)"},
+		{Name: "block-id", Desc: "for docx: anchor block ID; for sheet: <sheetId>!<cell>; for slides: <slide-block-type>!<xml-id>; for base(bitable): <table-id>!<record-id>!<view-id>"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		docRef, err := parseCommentDocRef(runtime.Str("doc"), runtime.Str("type"))
@@ -148,6 +148,17 @@ var DriveAddComment = common.Shortcut{
 			return err
 		}
 
+		if docRef.Kind == "base" {
+			if runtime.Bool("full-comment") {
+				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--full-comment is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>").WithParam("--full-comment")
+			}
+			if strings.TrimSpace(runtime.Str("selection-with-ellipsis")) != "" {
+				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--selection-with-ellipsis is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>").WithParam("--selection-with-ellipsis")
+			}
+			_, err := parseBaseCommentAnchor(runtime)
+			return err
+		}
+
 		// Sheet comment validation.
 		if docRef.Kind == "sheet" {
 			blockID := strings.TrimSpace(runtime.Str("block-id"))
@@ -188,7 +199,7 @@ var DriveAddComment = common.Shortcut{
 			return validateFileCommentMode(mode, "")
 		}
 		if mode == commentModeLocal && docRef.Kind == "doc" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, and slides; old doc format only supports full comments")
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, slides, and base(bitable); old doc format only supports full comments")
 		}
 
 		return nil
@@ -215,6 +226,23 @@ var DriveAddComment = common.Shortcut{
 			resolvedToken = target.FileToken
 		}
 
+		if resolvedKind == "base" {
+			anchor, err := parseBaseCommentAnchor(runtime)
+			if err != nil {
+				return common.NewDryRunAPI().Set("error", err.Error())
+			}
+			commentBody := buildBaseCommentCreateV2Request(replyElements, anchor)
+			desc := "1-step request: create base(bitable) record-local comment"
+			if isWiki {
+				desc = "2-step orchestration: resolve wiki -> create base(bitable) record-local comment"
+			}
+			return common.NewDryRunAPI().
+				Desc(desc).
+				POST("/open-apis/drive/v1/files/:file_token/new_comments").
+				Body(commentBody).
+				Set("file_token", resolvedToken)
+		}
+
 		// Sheet comment dry-run.
 		if resolvedKind == "sheet" {
 			anchor, _ := parseSheetCellRef(blockID)
@@ -352,6 +380,14 @@ var DriveAddComment = common.Shortcut{
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		// Sheet comment: direct URL or token fast path.
 		docRef, _ := parseCommentDocRef(runtime.Str("doc"), runtime.Str("type"))
+		if docRef.Kind == "base" {
+			return executeBaseComment(runtime, resolvedCommentTarget{
+				DocID:      docRef.Token,
+				FileToken:  docRef.Token,
+				FileType:   "base",
+				ResolvedBy: "base",
+			})
+		}
 		if docRef.Kind == "sheet" {
 			return executeSheetComment(runtime, docRef)
 		}
@@ -375,6 +411,9 @@ var DriveAddComment = common.Shortcut{
 		if target.FileType == "slides" {
 			return executeSlidesComment(runtime, commentDocRef{Kind: "slides", Token: target.FileToken})
 		}
+		if target.FileType == "base" {
+			return executeBaseComment(runtime, target)
+		}
 		if target.FileType == "file" {
 			return executeFileComment(runtime, target)
 		}
@@ -482,6 +521,12 @@ func parseCommentDocRef(input, docType string) (commentDocRef, error) {
 	if token, ok := extractURLToken(raw, "/sheets/"); ok {
 		return commentDocRef{Kind: "sheet", Token: token}, nil
 	}
+	if token, ok := extractURLToken(raw, "/base/"); ok {
+		return commentDocRef{Kind: "base", Token: token}, nil
+	}
+	if token, ok := extractURLToken(raw, "/bitable/"); ok {
+		return commentDocRef{Kind: "base", Token: token}, nil
+	}
 	if token, ok := extractURLToken(raw, "/file/"); ok {
 		return commentDocRef{Kind: "file", Token: token}, nil
 	}
@@ -495,7 +540,7 @@ func parseCommentDocRef(input, docType string) (commentDocRef, error) {
 		return commentDocRef{Kind: "doc", Token: token}, nil
 	}
 	if strings.Contains(raw, "://") {
-		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a doc/docx/file/sheet/slides URL, a token with --type, or a wiki URL that resolves to doc/docx/file/sheet/slides", raw).WithParam("--doc")
+		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a doc/docx/file/sheet/slides/base/bitable URL, a token with --type, or a wiki URL that resolves to doc/docx/file/sheet/slides/base(bitable)", raw).WithParam("--doc")
 	}
 	if strings.ContainsAny(raw, "/?#") {
 		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a token with --type, or a wiki URL", raw).WithParam("--doc")
@@ -504,7 +549,10 @@ func parseCommentDocRef(input, docType string) (commentDocRef, error) {
 	// Bare token: --type is required.
 	docType = strings.TrimSpace(docType)
 	if docType == "" {
-		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--type is required when --doc is a bare token (allowed values: doc, docx, file, sheet, slides)").WithParam("--type")
+		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--type is required when --doc is a bare token (allowed values: doc, docx, file, sheet, slides, bitable, base; use bitable as the wire value, base is accepted as a compatibility alias)").WithParam("--type")
+	}
+	if docType == "bitable" || docType == "base" {
+		return commentDocRef{Kind: "base", Token: raw}, nil
 	}
 	return commentDocRef{Kind: docType, Token: raw}, nil
 }
@@ -515,11 +563,11 @@ func resolveCommentTarget(ctx context.Context, runtime *common.RuntimeContext, i
 		return resolvedCommentTarget{}, err
 	}
 
-	if docRef.Kind == "docx" || docRef.Kind == "doc" || docRef.Kind == "file" || docRef.Kind == "sheet" || docRef.Kind == "slides" {
+	if docRef.Kind == "docx" || docRef.Kind == "doc" || docRef.Kind == "file" || docRef.Kind == "sheet" || docRef.Kind == "slides" || docRef.Kind == "base" {
 		if mode == commentModeLocal {
 			switch docRef.Kind {
 			case "doc":
-				return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, and slides; old doc format only supports full comments")
+				return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, slides, and base(bitable); old doc format only supports full comments")
 			case "file":
 				if err := validateFileCommentMode(mode, ""); err != nil {
 					return resolvedCommentTarget{}, err
@@ -557,6 +605,22 @@ func resolveCommentTarget(ctx context.Context, runtime *common.RuntimeContext, i
 	if objType == "slides" && strings.TrimSpace(runtime.Str("selection-with-ellipsis")) != "" {
 		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but --selection-with-ellipsis is not applicable for slide comments; use --block-id <slide-block-type>!<xml-id>", objType)
 	}
+	if objType == "bitable" || objType == "base" {
+		if runtime.Bool("full-comment") {
+			return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but --full-comment is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>", objType).WithParam("--full-comment")
+		}
+		if strings.TrimSpace(runtime.Str("selection-with-ellipsis")) != "" {
+			return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but --selection-with-ellipsis is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>", objType).WithParam("--selection-with-ellipsis")
+		}
+		fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to base: %s\n", common.MaskToken(objToken))
+		return resolvedCommentTarget{
+			DocID:      objToken,
+			FileToken:  objToken,
+			FileType:   "base",
+			ResolvedBy: "wiki",
+			WikiToken:  docRef.Token,
+		}, nil
+	}
 	if objType == "sheet" {
 		// Sheet comments are handled via the sheet fast path in Execute.
 		fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to %s: %s\n", objType, common.MaskToken(objToken))
@@ -592,10 +656,10 @@ func resolveCommentTarget(ctx context.Context, runtime *common.RuntimeContext, i
 		}, nil
 	}
 	if mode == commentModeLocal && objType != "docx" {
-		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but local comments only support docx, sheet, and slides; for sheet use --block-id <sheetId>!<cell>, for slides use --block-id <slide-block-type>!<xml-id>", objType)
+		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but local comments only support docx, sheet, slides, and base(bitable); for sheet use --block-id <sheetId>!<cell>, for slides use --block-id <slide-block-type>!<xml-id>, for base use --block-id <table-id>!<record-id>!<view-id>", objType)
 	}
 	if mode == commentModeFull && objType != "docx" && objType != "doc" {
-		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but comments only support doc/docx/file/sheet/slides", objType)
+		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but comments only support doc/docx/file/sheet/slides/base(bitable)", objType)
 	}
 
 	fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to %s: %s\n", objType, common.MaskToken(objToken))
@@ -787,6 +851,12 @@ type sheetAnchor struct {
 	Row     int
 }
 
+type baseAnchor struct {
+	BlockID      string
+	BaseRecordID string
+	BaseViewID   string
+}
+
 func buildCommentCreateV2Request(fileType, blockID, slideBlockType string, replyElements []map[string]interface{}, sheet *sheetAnchor) map[string]interface{} {
 	body := map[string]interface{}{
 		"file_type":      fileType,
@@ -813,6 +883,18 @@ func buildCommentCreateV2Request(fileType, blockID, slideBlockType string, reply
 	return body
 }
 
+func buildBaseCommentCreateV2Request(replyElements []map[string]interface{}, anchor baseAnchor) map[string]interface{} {
+	return map[string]interface{}{
+		"file_type":      "bitable",
+		"reply_elements": replyElements,
+		"anchor": map[string]interface{}{
+			"block_id":       anchor.BlockID,
+			"base_record_id": anchor.BaseRecordID,
+			"base_view_id":   anchor.BaseViewID,
+		},
+	}
+}
+
 func anchorBlockIDForDryRun(blockID string) string {
 	if strings.TrimSpace(blockID) != "" {
 		return strings.TrimSpace(blockID)
@@ -820,6 +902,26 @@ func anchorBlockIDForDryRun(blockID string) string {
 	return "<anchor_block_id>"
 }
 
+func parseBaseCommentAnchor(runtime *common.RuntimeContext) (baseAnchor, error) {
+	blockID := strings.TrimSpace(runtime.Str("block-id"))
+	if blockID == "" {
+		return baseAnchor{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--block-id is required for base(bitable) record-local comments (format: <table-id>!<record-id>!<view-id>, e.g. tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R)").WithParam("--block-id")
+	}
+	return parseBaseBlockRef(blockID)
+}
+
+func parseBaseBlockRef(blockID string) (baseAnchor, error) {
+	parts := strings.Split(strings.TrimSpace(blockID), "!")
+	if len(parts) != 3 || strings.TrimSpace(parts[0]) == "" || strings.TrimSpace(parts[1]) == "" || strings.TrimSpace(parts[2]) == "" {
+		return baseAnchor{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "base(bitable) record-local comments require --block-id in <table-id>!<record-id>!<view-id> format, e.g. tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R").WithParam("--block-id")
+	}
+	return baseAnchor{
+		BlockID:      strings.TrimSpace(parts[0]),
+		BaseRecordID: strings.TrimSpace(parts[1]),
+		BaseViewID:   strings.TrimSpace(parts[2]),
+	}, nil
+}
+
 func parseSlidesBlockRef(blockID string) (string, string, error) {
 	blockID = strings.TrimSpace(blockID)
 	if blockID == "" {
@@ -1030,6 +1132,53 @@ func executeSheetComment(runtime *common.RuntimeContext, docRef commentDocRef) e
 	return nil
 }
 
+func executeBaseComment(runtime *common.RuntimeContext, target resolvedCommentTarget) error {
+	replyElements, err := parseCommentReplyElements(runtime.Str("content"))
+	if err != nil {
+		return err
+	}
+	anchor, err := parseBaseCommentAnchor(runtime)
+	if err != nil {
+		return err
+	}
+
+	requestPath := fmt.Sprintf("/open-apis/drive/v1/files/%s/new_comments", validate.EncodePathSegment(target.FileToken))
+	requestBody := buildBaseCommentCreateV2Request(replyElements, anchor)
+
+	fmt.Fprintf(runtime.IO().ErrOut, "Creating base(bitable) record-local comment in %s (table=%s, record=%s, view=%s)\n",
+		common.MaskToken(target.FileToken), anchor.BlockID, anchor.BaseRecordID, anchor.BaseViewID)
+
+	data, err := runtime.CallAPITyped("POST", requestPath, nil, requestBody)
+	if err != nil {
+		return err
+	}
+
+	out := map[string]interface{}{
+		"file_token":     target.FileToken,
+		"file_type":      "bitable",
+		"resolved_by":    target.ResolvedBy,
+		"comment_mode":   "base_record",
+		"base_block_id":  anchor.BlockID,
+		"base_record_id": anchor.BaseRecordID,
+		"base_view_id":   anchor.BaseViewID,
+	}
+	if commentID := data["comment_id"]; commentID != nil {
+		out["comment_id"] = commentID
+	}
+	if replyID := data["reply_id"]; replyID != nil {
+		out["reply_id"] = replyID
+	}
+	if createdAt := firstPresentValue(data, "created_at", "create_time"); createdAt != nil {
+		out["created_at"] = createdAt
+	}
+	if target.WikiToken != "" {
+		out["wiki_token"] = target.WikiToken
+	}
+
+	runtime.Out(out, nil)
+	return nil
+}
+
 func executeFileComment(runtime *common.RuntimeContext, target resolvedCommentTarget) error {
 	replyElements, err := parseCommentReplyElements(runtime.Str("content"))
 	if err != nil {

shortcuts/drive/drive_add_comment_test.go

@@ -133,6 +133,20 @@ func TestParseCommentDocRef(t *testing.T) {
 			wantKind:  "file",
 			wantToken: "fileToken",
 		},
+		{
+			name:      "raw token with type bitable",
+			input:     "baseToken",
+			docType:   "bitable",
+			wantKind:  "base",
+			wantToken: "baseToken",
+		},
+		{
+			name:      "raw token with type base alias",
+			input:     "baseToken",
+			docType:   "base",
+			wantKind:  "base",
+			wantToken: "baseToken",
+		},
 		{
 			name:    "raw token without type",
 			input:   "xxxxxx",
@@ -156,6 +170,18 @@ func TestParseCommentDocRef(t *testing.T) {
 			wantKind:  "file",
 			wantToken: "boxcn123",
 		},
+		{
+			name:      "base url",
+			input:     "https://example.larksuite.com/base/baseToken123?table=tbl1",
+			wantKind:  "base",
+			wantToken: "baseToken123",
+		},
+		{
+			name:      "bitable url",
+			input:     "https://example.larksuite.com/bitable/baseToken456?table=tbl1",
+			wantKind:  "base",
+			wantToken: "baseToken456",
+		},
 		{
 			name:    "unsupported url",
 			input:   "https://example.com/not-a-doc",
@@ -726,6 +752,35 @@ func TestBuildCommentCreateV2RequestSheetOverridesBlockID(t *testing.T) {
 	}
 }
 
+func TestBuildBaseCommentCreateV2Request(t *testing.T) {
+	t.Parallel()
+	replyElements := []map[string]interface{}{
+		{"type": "text", "text": "base comment"},
+	}
+	got := buildBaseCommentCreateV2Request(replyElements, baseAnchor{
+		BlockID:      "tbl9mp6fj9kDKHQV",
+		BaseRecordID: "recBIBgGmb",
+		BaseViewID:   "vewc46MG1R",
+	})
+
+	if got["file_type"] != "bitable" {
+		t.Fatalf("expected file_type bitable, got %#v", got["file_type"])
+	}
+	anchor, ok := got["anchor"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("expected anchor map, got %#v", got["anchor"])
+	}
+	if anchor["block_id"] != "tbl9mp6fj9kDKHQV" {
+		t.Fatalf("expected block_id tbl9mp6fj9kDKHQV, got %#v", anchor["block_id"])
+	}
+	if anchor["base_record_id"] != "recBIBgGmb" {
+		t.Fatalf("expected base_record_id recBIBgGmb, got %#v", anchor["base_record_id"])
+	}
+	if anchor["base_view_id"] != "vewc46MG1R" {
+		t.Fatalf("expected base_view_id vewc46MG1R, got %#v", anchor["base_view_id"])
+	}
+}
+
 // ── Sheet cell ref parsing tests ────────────────────────────────────────────
 
 func TestParseSheetCellRef(t *testing.T) {
@@ -985,6 +1040,78 @@ func TestFileCommentValidateRejectsSelectionWithEllipsis(t *testing.T) {
 	}
 }
 
+func TestBaseCommentValidateMissingBlockID(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+	err := mountAndRunDrive(t, DriveAddComment, []string{
+		"+add-comment",
+		"--doc", "https://example.larksuite.com/base/baseToken",
+		"--content", `[{"type":"text","text":"test"}]`,
+		"--as", "user",
+	}, f, stdout)
+	if err == nil || !strings.Contains(err.Error(), "--block-id is required") {
+		t.Fatalf("expected block-id required error, got: %v", err)
+	}
+}
+
+func TestBaseCommentValidateMalformedBlockID(t *testing.T) {
+	cases := []string{
+		"tbl9mp6fj9kDKHQV",
+		"tbl9mp6fj9kDKHQV!recBIBgGmb",
+		"tbl9mp6fj9kDKHQV!!vewc46MG1R",
+	}
+	for _, blockID := range cases {
+		t.Run(blockID, func(t *testing.T) {
+			f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+			err := mountAndRunDrive(t, DriveAddComment, []string{
+				"+add-comment",
+				"--doc", "https://example.larksuite.com/base/baseToken",
+				"--content", `[{"type":"text","text":"test"}]`,
+				"--block-id", blockID,
+				"--as", "user",
+			}, f, stdout)
+			if err == nil || !strings.Contains(err.Error(), "<table-id>!<record-id>!<view-id>") {
+				t.Fatalf("expected block-id format error, got: %v", err)
+			}
+		})
+	}
+}
+
+func TestBaseCommentValidateRejectsIncompatibleFlags(t *testing.T) {
+	cases := []struct {
+		name    string
+		args    []string
+		wantErr string
+	}{
+		{
+			name:    "full comment",
+			args:    []string{"--full-comment"},
+			wantErr: "--full-comment is not applicable for base(bitable) comments",
+		},
+		{
+			name:    "selection",
+			args:    []string{"--selection-with-ellipsis", "some text"},
+			wantErr: "--selection-with-ellipsis is not applicable for base(bitable) comments",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+			args := []string{
+				"+add-comment",
+				"--doc", "https://example.larksuite.com/base/baseToken",
+				"--content", `[{"type":"text","text":"test"}]`,
+				"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
+				"--as", "user",
+			}
+			args = append(args, tc.args...)
+			err := mountAndRunDrive(t, DriveAddComment, args, f, stdout)
+			if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
+				t.Fatalf("expected %q error, got: %v", tc.wantErr, err)
+			}
+		})
+	}
+}
+
 // ── Slides comment execute tests ────────────────────────────────────────────
 
 func TestSlidesCommentExecuteSuccess(t *testing.T) {
@@ -1195,6 +1322,87 @@ func TestSheetCommentViaWikiMissingBlockID(t *testing.T) {
 	}
 }
 
+func TestBaseCommentExecuteSuccess(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	createStub := &httpmock.Stub{
+		Method: "POST", URL: "/open-apis/drive/v1/files/baseToken/new_comments",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "success",
+			"data": map[string]interface{}{
+				"comment_id": "baseComment123",
+				"reply_id":   "baseReply123",
+				"created_at": 1700000000,
+			},
+		},
+	}
+	reg.Register(createStub)
+	err := mountAndRunDrive(t, DriveAddComment, []string{
+		"+add-comment",
+		"--doc", "https://example.larksuite.com/base/baseToken",
+		"--content", `[{"type":"text","text":"请看这条记录"}]`,
+		"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
+		"--as", "user",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	var requestBody map[string]interface{}
+	if err := json.Unmarshal(createStub.CapturedBody, &requestBody); err != nil {
+		t.Fatalf("failed to decode captured body: %v\nbody:\n%s", err, string(createStub.CapturedBody))
+	}
+	if got := mustStringField(t, requestBody, "file_type", "request.file_type"); got != "bitable" {
+		t.Fatalf("request file_type = %q, want bitable", got)
+	}
+	anchor := mustMapValue(t, requestBody["anchor"], "request.anchor")
+	if got := mustStringField(t, anchor, "block_id", "request.anchor.block_id"); got != "tbl9mp6fj9kDKHQV" {
+		t.Fatalf("request block_id = %q, want tbl9mp6fj9kDKHQV", got)
+	}
+	if got := mustStringField(t, anchor, "base_record_id", "request.anchor.base_record_id"); got != "recBIBgGmb" {
+		t.Fatalf("request base_record_id = %q, want recBIBgGmb", got)
+	}
+	if got := mustStringField(t, anchor, "base_view_id", "request.anchor.base_view_id"); got != "vewc46MG1R" {
+		t.Fatalf("request base_view_id = %q, want vewc46MG1R", got)
+	}
+
+	out := decodeJSONMap(t, stdout.String())
+	data := mustMapValue(t, out["data"], "data")
+	if got := mustStringField(t, data, "file_type", "data.file_type"); got != "bitable" {
+		t.Fatalf("stdout file_type = %q, want bitable\nstdout:\n%s", got, stdout.String())
+	}
+	if got := mustStringField(t, data, "comment_mode", "data.comment_mode"); got != "base_record" {
+		t.Fatalf("stdout comment_mode = %q, want base_record\nstdout:\n%s", got, stdout.String())
+	}
+	if got := mustStringField(t, data, "reply_id", "data.reply_id"); got != "baseReply123" {
+		t.Fatalf("stdout reply_id = %q, want baseReply123\nstdout:\n%s", got, stdout.String())
+	}
+}
+
+func TestBaseCommentExecuteBareToken(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "POST", URL: "/open-apis/drive/v1/files/baseBareToken/new_comments",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "success",
+			"data": map[string]interface{}{"comment_id": "baseBareComment"},
+		},
+	})
+	err := mountAndRunDrive(t, DriveAddComment, []string{
+		"+add-comment",
+		"--doc", "baseBareToken",
+		"--type", "bitable",
+		"--content", `[{"type":"text","text":"ok"}]`,
+		"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
+		"--as", "user",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(stdout.String(), "baseBareComment") {
+		t.Fatalf("stdout missing comment_id: %s", stdout.String())
+	}
+}
+
 func TestFileCommentExecuteSuccess(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
@@ -1433,6 +1641,40 @@ func TestDryRunSlidesDirectURL(t *testing.T) {
 	}
 }
 
+func TestDryRunBaseDirectURL(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
+	err := mountAndRunDrive(t, DriveAddComment, []string{
+		"+add-comment",
+		"--doc", "https://example.larksuite.com/base/baseToken",
+		"--content", `[{"type":"text","text":"test"}]`,
+		"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
+		"--dry-run", "--as", "user",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(stdout.String(), "record-local comment") {
+		t.Fatalf("dry-run output missing record-local comment: %s", stdout.String())
+	}
+	out := decodeJSONMap(t, stdout.String())
+	api := mustSliceValue(t, out["api"], "api")
+	call := mustMapValue(t, api[0], "api[0]")
+	body := mustMapValue(t, call["body"], "api[0].body")
+	anchor := mustMapValue(t, body["anchor"], "api[0].body.anchor")
+	if got := mustStringField(t, body, "file_type", "api[0].body.file_type"); got != "bitable" {
+		t.Fatalf("dry-run body.file_type = %q, want bitable\nstdout:\n%s", got, stdout.String())
+	}
+	if got := mustStringField(t, anchor, "block_id", "api[0].body.anchor.block_id"); got != "tbl9mp6fj9kDKHQV" {
+		t.Fatalf("dry-run body.anchor.block_id = %q, want tbl9mp6fj9kDKHQV\nstdout:\n%s", got, stdout.String())
+	}
+	if got := mustStringField(t, anchor, "base_record_id", "api[0].body.anchor.base_record_id"); got != "recBIBgGmb" {
+		t.Fatalf("dry-run body.anchor.base_record_id = %q, want recBIBgGmb\nstdout:\n%s", got, stdout.String())
+	}
+	if got := mustStringField(t, anchor, "base_view_id", "api[0].body.anchor.base_view_id"); got != "vewc46MG1R" {
+		t.Fatalf("dry-run body.anchor.base_view_id = %q, want vewc46MG1R\nstdout:\n%s", got, stdout.String())
+	}
+}
+
 func TestDryRunWikiResolvesToSlides(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
@@ -1636,25 +1878,92 @@ func TestResolveWikiToDocxFullComment(t *testing.T) {
 	}
 }
 
-func TestResolveWikiToUnsupportedType(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/wiki/v2/spaces/get_node",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "success",
-			"data": map[string]interface{}{
-				"node": map[string]interface{}{"obj_type": "bitable", "obj_token": "bitToken"},
-			},
+func TestResolveWikiToBaseComment(t *testing.T) {
+	for _, objType := range []string{"bitable", "base"} {
+		t.Run(objType, func(t *testing.T) {
+			f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+			reg.Register(&httpmock.Stub{
+				Method: "GET", URL: "/open-apis/wiki/v2/spaces/get_node",
+				Body: map[string]interface{}{
+					"code": 0, "msg": "success",
+					"data": map[string]interface{}{
+						"node": map[string]interface{}{"obj_type": objType, "obj_token": "bitToken"},
+					},
+				},
+			})
+			reg.Register(&httpmock.Stub{
+				Method: "POST", URL: "/open-apis/drive/v1/files/bitToken/new_comments",
+				Body: map[string]interface{}{
+					"code": 0, "msg": "success",
+					"data": map[string]interface{}{"comment_id": "wikiBaseComment", "reply_id": "wikiBaseReply"},
+				},
+			})
+			err := mountAndRunDrive(t, DriveAddComment, []string{
+				"+add-comment",
+				"--doc", "https://example.larksuite.com/wiki/wikiToken",
+				"--content", `[{"type":"text","text":"test"}]`,
+				"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
+				"--as", "user",
+			}, f, stdout)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if !strings.Contains(stdout.String(), "wikiBaseComment") {
+				t.Fatalf("stdout missing comment_id: %s", stdout.String())
+			}
+			out := decodeJSONMap(t, stdout.String())
+			data := mustMapValue(t, out["data"], "data")
+			if got := mustStringField(t, data, "file_type", "data.file_type"); got != "bitable" {
+				t.Fatalf("stdout file_type = %q, want bitable\nstdout:\n%s", got, stdout.String())
+			}
+			if got := mustStringField(t, data, "wiki_token", "data.wiki_token"); got != "wikiToken" {
+				t.Fatalf("stdout wiki_token = %q, want wikiToken\nstdout:\n%s", got, stdout.String())
+			}
+		})
+	}
+}
+
+func TestResolveWikiToBaseRejectsIncompatibleFlags(t *testing.T) {
+	cases := []struct {
+		name    string
+		args    []string
+		wantErr string
+	}{
+		{
+			name:    "full comment",
+			args:    []string{"--full-comment"},
+			wantErr: "--full-comment is not applicable for base(bitable) comments",
 		},
-	})
-	err := mountAndRunDrive(t, DriveAddComment, []string{
-		"+add-comment",
-		"--doc", "https://example.larksuite.com/wiki/wikiToken",
-		"--content", `[{"type":"text","text":"test"}]`,
-		"--as", "user",
-	}, f, stdout)
-	if err == nil || !strings.Contains(err.Error(), "only support doc/docx/file/sheet/slides") {
-		t.Fatalf("expected unsupported type error, got: %v", err)
+		{
+			name:    "selection",
+			args:    []string{"--selection-with-ellipsis", "some text"},
+			wantErr: "--selection-with-ellipsis is not applicable for base(bitable) comments",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+			reg.Register(&httpmock.Stub{
+				Method: "GET", URL: "/open-apis/wiki/v2/spaces/get_node",
+				Body: map[string]interface{}{
+					"code": 0, "msg": "success",
+					"data": map[string]interface{}{
+						"node": map[string]interface{}{"obj_type": "bitable", "obj_token": "bitToken"},
+					},
+				},
+			})
+			args := []string{
+				"+add-comment",
+				"--doc", "https://example.larksuite.com/wiki/wikiToken",
+				"--content", `[{"type":"text","text":"test"}]`,
+				"--as", "user",
+			}
+			args = append(args, tc.args...)
+			err := mountAndRunDrive(t, DriveAddComment, args, f, stdout)
+			if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
+				t.Fatalf("expected %q error, got: %v", tc.wantErr, err)
+			}
+		})
 	}
 }
 
@@ -1735,7 +2044,7 @@ func TestDocOldFormatLocalCommentRejected(t *testing.T) {
 		"--block-id", "blk_123",
 		"--as", "user",
 	}, f, stdout)
-	if err == nil || !strings.Contains(err.Error(), "only support docx, sheet, and slides") {
+	if err == nil || !strings.Contains(err.Error(), "only support docx, sheet, slides, and base(bitable)") {
 		t.Fatalf("expected local comment rejection for old doc, got: %v", err)
 	}
 }

shortcuts/drive/drive_export.go

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

shortcuts/drive/drive_export_test.go

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

shortcuts/drive/drive_import.go

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

shortcuts/drive/drive_search.go

@@ -149,6 +149,9 @@ var DriveSearch = common.Shortcut{
 			"page_token": data["page_token"],
 			"results":    normalizedItems,
 		}
+		if notice, _ := data["notice"].(string); notice != "" {
+			resultData["notice"] = notice
+		}
 
 		runtime.OutFormat(resultData, &output.Meta{Count: len(normalizedItems)}, func(w io.Writer) {
 			renderDriveSearchTable(w, data, normalizedItems)

shortcuts/drive/drive_search_test.go

@@ -14,12 +14,49 @@ import (
 	"time"
 
 	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/errclass"
+	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/internal/output"
 )
 
-// TestClampOpenedTimeWindow covers the 3-month / 1-year boundary logic that
-// narrows --opened-since / --opened-until and generates the multi-slice notice.
+// TestDriveSearchExecutePassesThroughNotice verifies drive +search preserves notices.
+func TestDriveSearchExecutePassesThroughNotice(t *testing.T) {
+	const notice = "The query is too long and has been truncated to the first 50 characters for search."
+
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/search/v2/doc_wiki/search",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"notice":     notice,
+				"res_units":  []interface{}{},
+				"total":      0,
+				"has_more":   false,
+				"page_token": "",
+			},
+		},
+	})
+
+	if err := mountAndRunDrive(t, DriveSearch, []string{"+search", "--query", "incident", "--format", "json", "--as", "user"}, f, stdout); err != nil {
+		t.Fatalf("DriveSearch.Execute() error = %v", err)
+	}
+	reg.Verify(t)
+
+	var env map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
+		t.Fatalf("json.Unmarshal(stdout) error = %v\nstdout=%s", err, stdout.String())
+	}
+	data, _ := env["data"].(map[string]interface{})
+	if got, _ := data["notice"].(string); got != notice {
+		t.Fatalf("data.notice = %q, want %q; data=%#v", got, notice, data)
+	}
+}
+
+// TestClampOpenedTimeWindow covers opened-time clamping and slice notices.
 func TestClampOpenedTimeWindow(t *testing.T) {
 	t.Parallel()
 

shortcuts/im/builders_test.go

@@ -26,9 +26,7 @@ func mustMarshalDryRun(t *testing.T, v interface{}) string {
 	return string(b)
 }
 
-// newTestRuntimeContext builds a *common.RuntimeContext backed by a cobra
-// command whose flags are populated from the provided string and bool maps,
-// for unit-testing shortcut bodies, validators, and dry-run shapes.
+// newTestRuntimeContext builds a RuntimeContext with string and bool test flags.
 func newTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlags map[string]bool) *common.RuntimeContext {
 	t.Helper()
 
@@ -59,9 +57,38 @@ func newTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlag
 	return &common.RuntimeContext{Cmd: cmd}
 }
 
-// newMessagesSearchTestRuntimeContext is the messages-search variant of
-// newTestRuntimeContext: registers the search-specific --page-size flag
-// before applying caller-provided values.
+// newChatSearchTestRuntimeContext builds a chat-search RuntimeContext with typed flags.
+func newChatSearchTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlags map[string]bool) *common.RuntimeContext {
+	t.Helper()
+
+	cmd := &cobra.Command{Use: "test"}
+	cmd.Flags().Int("page-size", 20, "")
+	for name := range stringFlags {
+		if name == "page-size" {
+			continue
+		}
+		cmd.Flags().String(name, "", "")
+	}
+	for name := range boolFlags {
+		cmd.Flags().Bool(name, false, "")
+	}
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("ParseFlags() error = %v", err)
+	}
+	for name, val := range stringFlags {
+		if err := cmd.Flags().Set(name, val); err != nil {
+			t.Fatalf("Flags().Set(%q) error = %v", name, err)
+		}
+	}
+	for name, val := range boolFlags {
+		if err := cmd.Flags().Set(name, map[bool]string{true: "true", false: "false"}[val]); err != nil {
+			t.Fatalf("Flags().Set(%q) error = %v", name, err)
+		}
+	}
+	return &common.RuntimeContext{Cmd: cmd}
+}
+
+// newMessagesSearchTestRuntimeContext builds a messages-search RuntimeContext.
 func newMessagesSearchTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlags map[string]bool) *common.RuntimeContext {
 	t.Helper()
 
@@ -231,6 +258,7 @@ func TestIsMediaKey(t *testing.T) {
 	}
 }
 
+// TestShortcutValidateBranches covers direct shortcut validation branches.
 func TestShortcutValidateBranches(t *testing.T) {
 
 	t.Run("ImChatCreate valid", func(t *testing.T) {
@@ -297,7 +325,7 @@ func TestShortcutValidateBranches(t *testing.T) {
 	})
 
 	t.Run("ImChatSearch invalid page size", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
+		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
 			"query":     "ok",
 			"page-size": "0",
 		}, nil)
@@ -307,12 +335,13 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})
 
-	t.Run("ImChatSearch query too long", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
-			"query": strings.Repeat("q", 65),
+	t.Run("ImChatSearch allows long query for server-side notice", func(t *testing.T) {
+		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
+			"query":     strings.Repeat("q", 81),
+			"page-size": "20",
 		}, nil)
 		err := ImChatSearch.Validate(context.Background(), runtime)
-		if err == nil || !strings.Contains(err.Error(), "--query exceeds the maximum of 64 characters") {
+		if err != nil {
 			t.Fatalf("ImChatSearch.Validate() error = %v", err)
 		}
 	})
@@ -440,6 +469,29 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})
 
+	t.Run("ImMessagesSend audio rejects non-opus local file", func(t *testing.T) {
+		runtime := newTestRuntimeContext(t, map[string]string{
+			"chat-id": "oc_123",
+			"audio":   "./voice.mp3",
+		}, nil)
+		err := ImMessagesSend.Validate(context.Background(), runtime)
+		if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
+			t.Fatalf("ImMessagesSend.Validate() error = %v", err)
+		}
+	})
+
+	t.Run("ImMessagesSend audio accepts opus and ogg local files", func(t *testing.T) {
+		for _, audio := range []string{"./voice.opus", "./voice.ogg"} {
+			runtime := newTestRuntimeContext(t, map[string]string{
+				"chat-id": "oc_123",
+				"audio":   audio,
+			}, nil)
+			if err := ImMessagesSend.Validate(context.Background(), runtime); err != nil {
+				t.Fatalf("ImMessagesSend.Validate(%q) unexpected error = %v", audio, err)
+			}
+		}
+	})
+
 	t.Run("ImMessagesSend conflicting explicit msg-type", func(t *testing.T) {
 		runtime := newTestRuntimeContext(t, map[string]string{
 			"chat-id":  "oc_123",
@@ -463,6 +515,17 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})
 
+	t.Run("ImMessagesReply audio rejects non-opus local file", func(t *testing.T) {
+		runtime := newTestRuntimeContext(t, map[string]string{
+			"message-id": "om_123",
+			"audio":      "./voice.mp3",
+		}, nil)
+		err := ImMessagesReply.Validate(context.Background(), runtime)
+		if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
+			t.Fatalf("ImMessagesReply.Validate() error = %v", err)
+		}
+	})
+
 	t.Run("ImThreadsMessagesList invalid thread", func(t *testing.T) {
 		runtime := newTestRuntimeContext(t, map[string]string{
 			"thread": "bad_thread",
@@ -607,6 +670,7 @@ func TestShortcutValidateBranches(t *testing.T) {
 	})
 }
 
+// TestMessagesSearchPaginationConfig verifies page-all and page-limit behavior.
 func TestMessagesSearchPaginationConfig(t *testing.T) {
 	t.Run("default single page", func(t *testing.T) {
 		runtime := newMessagesSearchTestRuntimeContext(t, nil, nil)
@@ -650,8 +714,7 @@ func TestMessagesSearchPaginationConfig(t *testing.T) {
 	})
 }
 
-// TestShortcutDryRunShapes verifies that each shortcut's DryRun function
-// produces the expected API path, query parameters, and request body.
+// TestShortcutDryRunShapes verifies shortcut dry-run API paths and payloads.
 func TestShortcutDryRunShapes(t *testing.T) {
 	t.Run("ImChatCreate dry run includes params and body", func(t *testing.T) {
 		cmd := &cobra.Command{Use: "test"}
@@ -674,19 +737,19 @@ func TestShortcutDryRunShapes(t *testing.T) {
 	})
 
 	t.Run("ImChatSearch dry run includes built params", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
+		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
 			"query":      "team-alpha",
 			"page-size":  "50",
 			"page-token": "next_page",
 		}, nil)
 		got := mustMarshalDryRun(t, ImChatSearch.DryRun(context.Background(), runtime))
-		if !strings.Contains(got, `"/open-apis/im/v2/chats/search"`) || !strings.Contains(got, `"page_size":20`) || !strings.Contains(got, `"query":"\"team-alpha\""`) {
+		if !strings.Contains(got, `"/open-apis/im/v2/chats/search"`) || !strings.Contains(got, `"page_size":50`) || !strings.Contains(got, `"query":"\"team-alpha\""`) {
 			t.Fatalf("ImChatSearch.DryRun() = %s", got)
 		}
 	})
 
 	t.Run("ImChatSearch dry run still works with --exclude-muted set", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
+		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
 			"query": "team-alpha",
 		}, map[string]bool{
 			"exclude-muted": true,

shortcuts/im/convert_lib/card_userdsl_test.go

@@ -0,0 +1,993 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package convertlib
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestConvertInteractiveEventContent(t *testing.T) {
+	// invalid JSON → fallback
+	if got := ConvertInteractiveEventContent("not-json", nil); got != "[interactive card]" {
+		t.Fatalf("invalid JSON = %q, want [interactive card]", got)
+	}
+	// missing user_dsl → fallback
+	if got := ConvertInteractiveEventContent(`{"other":"field"}`, nil); got != "[interactive card]" {
+		t.Fatalf("missing user_dsl = %q, want [interactive card]", got)
+	}
+	// empty user_dsl → fallback
+	if got := ConvertInteractiveEventContent(`{"user_dsl":""}`, nil); got != "[interactive card]" {
+		t.Fatalf("empty user_dsl = %q, want [interactive card]", got)
+	}
+	// user_dsl that is not a string (wrong type) → fallback
+	if got := ConvertInteractiveEventContent(`{"user_dsl":123}`, nil); got != "[interactive card]" {
+		t.Fatalf("non-string user_dsl = %q, want [interactive card]", got)
+	}
+	// valid user-2 card → <card> output
+	userDsl := `{"schema":"2.0","header":{"title":{"tag":"plain_text","content":"Hello"}},"body":{"elements":[{"tag":"markdown","content":"world"}]}}`
+	rawContent := `{"user_dsl":"` + strings.ReplaceAll(userDsl, `"`, `\"`) + `"}`
+	got := ConvertInteractiveEventContent(rawContent, nil)
+	if !strings.HasPrefix(got, `<card title="Hello">`) {
+		t.Fatalf("valid card = %q, want prefix <card title=\"Hello\">", got)
+	}
+	if !strings.Contains(got, "world") {
+		t.Fatalf("valid card = %q, want to contain 'world'", got)
+	}
+}
+
+func makeMentionCard(mdContent string) string {
+	obj := map[string]interface{}{
+		"schema": "2.0",
+		"header": map[string]interface{}{
+			"title": map[string]interface{}{"tag": "plain_text", "content": "T"},
+		},
+		"body": map[string]interface{}{
+			"elements": []interface{}{
+				map[string]interface{}{"tag": "markdown", "content": mdContent},
+			},
+		},
+	}
+	dslBytes, _ := json.Marshal(obj)
+	raw, _ := json.Marshal(map[string]interface{}{"user_dsl": string(dslBytes)})
+	return string(raw)
+}
+
+func TestConvertInteractiveEventContentMentions(t *testing.T) {
+	mentions := []interface{}{
+		map[string]interface{}{
+			"key":  "@_user_1",
+			"name": "test-user",
+			"id":   map[string]interface{}{"open_id": "fake-uid-001"},
+		},
+	}
+
+	// quoted attrs: mention_key="key"
+	got := ConvertInteractiveEventContent(makeMentionCard(`hi <at mention_key="@_user_1">n</at> done`), mentions)
+	if !strings.Contains(got, "@test-user(fake-uid-001)") {
+		t.Fatalf("quoted mention_key not resolved, got: %s", got)
+	}
+
+	// unquoted attrs (real Lark format): <at id=ou_xxx mention_key=@_user_1></at>
+	got = ConvertInteractiveEventContent(makeMentionCard(`hi <at id=fake-uid-001 mention_key=@_user_1></at> done`), mentions)
+	if !strings.Contains(got, "@test-user(fake-uid-001)") {
+		t.Fatalf("unquoted mention_key not resolved, got: %s", got)
+	}
+
+	// mentions_key variant (unquoted)
+	got = ConvertInteractiveEventContent(makeMentionCard(`hi <at mentions_key=@_user_1></at> done`), mentions)
+	if !strings.Contains(got, "@test-user(fake-uid-001)") {
+		t.Fatalf("unquoted mentions_key not resolved, got: %s", got)
+	}
+
+	// degradation 1: no mention_key/mentions_key attr → fall back to @id (unquoted)
+	got = ConvertInteractiveEventContent(makeMentionCard(`hi <at id=fake-uid-001></at> done`), mentions)
+	if !strings.Contains(got, "@fake-uid-001") {
+		t.Fatalf("no mention_key unquoted: expected @id fallback, got: %s", got)
+	}
+
+	// degradation 2: mention_key not found in mentions → fall back to @id
+	got = ConvertInteractiveEventContent(makeMentionCard(`hi <at id=fake-uid-001 mention_key=@_unknown></at> done`), mentions)
+	if !strings.Contains(got, "@fake-uid-001") {
+		t.Fatalf("key not in mentions: expected @id fallback, got: %s", got)
+	}
+
+	// multi-mention: ids=id1,id2,id3 mentions_key=k1,,k3
+	// k1 hits → @name(id1), k2 empty → @id2 fallback, k3 not found → @id3 fallback
+	got = ConvertInteractiveEventContent(
+		makeMentionCard(`<at ids=fake-uid-001,fake-uid-002,fake-uid-003 mentions_key=@_user_1,,@_unknown></at>`),
+		mentions,
+	)
+	want := "@test-user(fake-uid-001)@fake-uid-002@fake-uid-003"
+	if !strings.Contains(got, want) {
+		t.Fatalf("multi-mention unquoted: want %q in output, got: %s", want, got)
+	}
+}
+
+func TestUserDslConverterSchema(t *testing.T) {
+	c := &userDslConverter{}
+
+	// user-2.ts: schema field present, header at root, body.elements
+	schema2 := cardObj{
+		"schema": "2.0",
+		"header": cardObj{
+			"title":    cardObj{"tag": "plain_text", "content": "Schema2 Title"},
+			"subtitle": cardObj{"tag": "plain_text", "content": "Sub"},
+		},
+		"body": cardObj{
+			"elements": []interface{}{
+				cardObj{"tag": "markdown", "content": "body text"},
+			},
+		},
+	}
+	got := c.convert(schema2)
+	if got != "<card title=\"Schema2 Title\" subtitle=\"Sub\">\nbody text\n</card>" {
+		t.Fatalf("schema2 = %q", got)
+	}
+
+	// user-1.ts: no schema field, i18n_header.zh_cn, elements at root
+	schema1 := cardObj{
+		"i18n_header": cardObj{
+			"zh_cn": cardObj{
+				"title": cardObj{"tag": "plain_text", "content": "Schema1 Title"},
+			},
+		},
+		"elements": []interface{}{
+			cardObj{"tag": "hr"},
+		},
+	}
+	got = c.convert(schema1)
+	if got != "<card title=\"Schema1 Title\">\n---\n</card>" {
+		t.Fatalf("schema1 = %q", got)
+	}
+
+	// user-1.ts: no schema, direct header (real Lark event format)
+	schema1Direct := cardObj{
+		"header": cardObj{
+			"title":    cardObj{"tag": "plain_text", "content": "Direct Header Title"},
+			"subtitle": cardObj{"tag": "plain_text", "content": "Direct Sub"},
+		},
+		"elements": []interface{}{
+			cardObj{"tag": "markdown", "content": "direct body"},
+		},
+	}
+	got = c.convert(schema1Direct)
+	if got != "<card title=\"Direct Header Title\" subtitle=\"Direct Sub\">\ndirect body\n</card>" {
+		t.Fatalf("schema1 direct header = %q", got)
+	}
+
+	// no header, no elements → fallback
+	got = c.convert(cardObj{})
+	if got != "[interactive card]" {
+		t.Fatalf("empty card = %q, want [interactive card]", got)
+	}
+
+	// card with title only → valid (not "[interactive card]")
+	titleOnly := cardObj{
+		"schema": "2.0",
+		"header": cardObj{"title": cardObj{"tag": "plain_text", "content": "TitleOnly"}},
+		"body":   cardObj{"elements": []interface{}{}},
+	}
+	got = c.convert(titleOnly)
+	if !strings.Contains(got, "TitleOnly") {
+		t.Fatalf("title-only card = %q, want to contain TitleOnly", got)
+	}
+}
+
+func TestUserDslConverterDispatch(t *testing.T) {
+	c := &userDslConverter{}
+
+	tests := []struct {
+		name     string
+		elem     cardObj
+		want     string
+		contains string
+	}{
+		{
+			name: "plain_text",
+			elem: cardObj{"tag": "plain_text", "content": "hello"},
+			want: "hello",
+		},
+		{
+			name: "markdown",
+			elem: cardObj{"tag": "markdown", "content": "**bold**"},
+			want: "**bold**",
+		},
+		{
+			name: "hr",
+			elem: cardObj{"tag": "hr"},
+			want: "---",
+		},
+		{
+			name: "br",
+			elem: cardObj{"tag": "br"},
+			want: "\n",
+		},
+		{
+			name: "img with img_key",
+			elem: cardObj{
+				"tag":     "img",
+				"img_key": "img_v3_abc",
+				"alt":     cardObj{"tag": "plain_text", "content": "Banner"},
+			},
+			want: "🖼️ Banner(img_key:img_v3_abc)",
+		},
+		{
+			name: "img_combination",
+			elem: cardObj{
+				"tag": "img_combination",
+				"img_list": []interface{}{
+					cardObj{"img_key": "k1"},
+					cardObj{"img_key": "k2"},
+				},
+			},
+			want: "🖼️ 2 image(s)(keys:k1,k2)",
+		},
+		{
+			name: "button with behaviors default_url",
+			elem: cardObj{
+				"tag":  "button",
+				"text": cardObj{"tag": "plain_text", "content": "Open"},
+				"behaviors": []interface{}{
+					cardObj{"type": "open_url", "default_url": "https://example.com"},
+				},
+			},
+			want: "[Open](https://example.com)",
+		},
+		{
+			name: "button disabled",
+			elem: cardObj{
+				"tag":      "button",
+				"text":     cardObj{"tag": "plain_text", "content": "Nope"},
+				"disabled": true,
+			},
+			want: "[Nope ✗]",
+		},
+		{
+			name: "button no url",
+			elem: cardObj{
+				"tag":  "button",
+				"text": cardObj{"tag": "plain_text", "content": "Submit"},
+			},
+			want: "[Submit]",
+		},
+		{
+			name: "action wrapper (user-1 style)",
+			elem: cardObj{
+				"tag": "action",
+				"actions": []interface{}{
+					cardObj{"tag": "button", "text": cardObj{"tag": "plain_text", "content": "A"}},
+					cardObj{"tag": "button", "text": cardObj{"tag": "plain_text", "content": "B"}},
+				},
+			},
+			want: "[A] [B]",
+		},
+		{
+			name: "overflow",
+			elem: cardObj{
+				"tag": "overflow",
+				"options": []interface{}{
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Edit"}},
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Delete"}},
+				},
+			},
+			want: "⋮ Edit, Delete",
+		},
+		{
+			name: "select_static no selection",
+			elem: cardObj{
+				"tag": "select_static",
+				"options": []interface{}{
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Option1"}, "value": "1"},
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Option2"}, "value": "2"},
+				},
+			},
+			want: "{Option1 / Option2 ▼}",
+		},
+		{
+			name: "select_static with initial_option",
+			elem: cardObj{
+				"tag":            "select_static",
+				"initial_option": "2",
+				"options": []interface{}{
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Option1"}, "value": "1"},
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Option2"}, "value": "2"},
+				},
+			},
+			want: "{Option1 / ✓Option2}",
+		},
+		{
+			name: "multi_select_static with selected_values",
+			elem: cardObj{
+				"tag":             "multi_select_static",
+				"selected_values": []interface{}{"A"},
+				"options": []interface{}{
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "OptA"}, "value": "A"},
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "OptB"}, "value": "B"},
+				},
+			},
+			want: "{✓OptA / OptB}(multi)",
+		},
+		{
+			name: "select_person no options no selection shows placeholder",
+			elem: cardObj{
+				"tag":         "select_person",
+				"placeholder": cardObj{"tag": "plain_text", "content": "请选择"},
+			},
+			want: "{请选择 ▼}",
+		},
+		{
+			name: "select_person with initial_option synthesizes from ID",
+			elem: cardObj{
+				"tag":            "select_person",
+				"initial_option": "fake-open-id-001",
+			},
+			want: "{✓fake-open-id-001}",
+		},
+		{
+			name: "multi_select_person with selected_values shows IDs and multi",
+			elem: cardObj{
+				"tag":             "multi_select_person",
+				"selected_values": []interface{}{"fake-open-id-001", "fake-open-id-002"},
+			},
+			want: "{✓fake-open-id-001 / ✓fake-open-id-002}(multi)",
+		},
+		{
+			name: "multi_select_person no selection shows placeholder",
+			elem: cardObj{
+				"tag":         "multi_select_person",
+				"placeholder": cardObj{"tag": "plain_text", "content": "添加人员"},
+			},
+			want: "{添加人员 ▼}(multi)",
+		},
+		{
+			name: "input with default_value",
+			elem: cardObj{
+				"tag":           "input",
+				"label":         cardObj{"tag": "plain_text", "content": "Reason"},
+				"default_value": "prefilled",
+			},
+			want: "Reason: prefilled___",
+		},
+		{
+			name: "input with placeholder",
+			elem: cardObj{
+				"tag":         "input",
+				"placeholder": cardObj{"tag": "plain_text", "content": "Type here"},
+			},
+			want: "Type here_____",
+		},
+		{
+			name: "date_picker with initial_date",
+			elem: cardObj{
+				"tag":          "date_picker",
+				"initial_date": "2026-01-01",
+			},
+			want: "📅 2026-01-01",
+		},
+		{
+			name: "date_picker placeholder",
+			elem: cardObj{
+				"tag":         "date_picker",
+				"placeholder": cardObj{"tag": "plain_text", "content": "Pick date"},
+			},
+			want: "📅 Pick date",
+		},
+		{
+			name: "picker_time with initial_time",
+			elem: cardObj{
+				"tag":          "picker_time",
+				"initial_time": "14:30",
+			},
+			want: "🕐 14:30",
+		},
+		{
+			name: "checker unchecked",
+			elem: cardObj{
+				"tag":  "checker",
+				"text": cardObj{"tag": "plain_text", "content": "Task A"},
+			},
+			want: "[ ] Task A",
+		},
+		{
+			name: "checker checked",
+			elem: cardObj{
+				"tag":     "checker",
+				"checked": true,
+				"text":    cardObj{"tag": "plain_text", "content": "Task B"},
+			},
+			want: "[x] Task B",
+		},
+		{
+			name: "chart with chart_spec",
+			elem: cardObj{
+				"tag": "chart",
+				"chart_spec": cardObj{
+					"title":  cardObj{"text": "Sales"},
+					"type":   "bar",
+					"xField": "month",
+					"yField": "value",
+					"data": cardObj{"values": []interface{}{
+						cardObj{"month": "Jan", "value": float64(10)},
+						cardObj{"month": "Feb", "value": float64(20)},
+					}},
+				},
+			},
+			want: "📊 Sales (Bar chart)\nSummary: Jan:10, Feb:20",
+		},
+		{
+			name: "chart with compound xField array",
+			elem: cardObj{
+				"tag": "chart",
+				"chart_spec": cardObj{
+					"title":  cardObj{"text": "Sales"},
+					"type":   "bar",
+					"xField": []interface{}{"month", "category"},
+					"yField": "value",
+					"data": cardObj{"values": []interface{}{
+						cardObj{"month": "Jan", "category": "A", "value": float64(10)},
+						cardObj{"month": "Feb", "category": "B", "value": float64(20)},
+					}},
+				},
+			},
+			want: "📊 Sales (Bar chart)\nSummary: Jan:10, Feb:20",
+		},
+		{
+			name: "chart no custom title uses type name",
+			elem: cardObj{
+				"tag": "chart",
+				"chart_spec": cardObj{
+					"type":          "pie",
+					"categoryField": "label",
+					"valueField":    "val",
+					"data": cardObj{"values": []interface{}{
+						cardObj{"label": "A", "val": float64(1)},
+					}},
+				},
+			},
+			want: "📊 Pie chart\nSummary: A:1",
+		},
+		{
+			name: "chart vchart array data format",
+			elem: cardObj{
+				"tag": "chart",
+				"chart_spec": cardObj{
+					"type":   "bar",
+					"xField": "x",
+					"yField": "y",
+					"data": []interface{}{
+						cardObj{"id": "s1", "values": []interface{}{
+							cardObj{"x": "Jan", "y": float64(5)},
+						}},
+						cardObj{"id": "s2", "values": []interface{}{
+							cardObj{"x": "Feb", "y": float64(8)},
+						}},
+					},
+				},
+			},
+			want: "📊 Bar chart\nSummary: Jan:5, Feb:8",
+		},
+		{
+			name: "text_tag",
+			elem: cardObj{
+				"tag":  "text_tag",
+				"text": cardObj{"tag": "plain_text", "content": "新功能"},
+			},
+			want: "「新功能」",
+		},
+		{
+			name: "avatar with user_id",
+			elem: cardObj{"tag": "avatar", "user_id": "fake-open-id-001"},
+			want: "👤(id:fake-open-id-001)",
+		},
+		{
+			name: "avatar no user_id",
+			elem: cardObj{"tag": "avatar"},
+			want: "👤",
+		},
+		{
+			name: "select_img no selection",
+			elem: cardObj{
+				"tag": "select_img",
+				"options": []interface{}{
+					cardObj{"value": "v1", "img_key": "img_k1"},
+					cardObj{"value": "v2", "img_key": "img_k2"},
+				},
+			},
+			want: "{🖼️ Image 1(v1)(img_key:img_k1) / 🖼️ Image 2(v2)(img_key:img_k2)}",
+		},
+		{
+			name: "select_img with selected",
+			elem: cardObj{
+				"tag":             "select_img",
+				"selected_values": []interface{}{"v1"},
+				"options": []interface{}{
+					cardObj{"value": "v1", "img_key": "img_k1"},
+					cardObj{"value": "v2", "img_key": "img_k2"},
+				},
+			},
+			want: "{✓🖼️ Image 1(v1)(img_key:img_k1) / 🖼️ Image 2(v2)(img_key:img_k2)}",
+		},
+		{
+			name: "repeat delegates to elements",
+			elem: cardObj{
+				"tag": "repeat",
+				"elements": []interface{}{
+					cardObj{"tag": "markdown", "content": "item A"},
+					cardObj{"tag": "markdown", "content": "item B"},
+				},
+			},
+			want: "item A\nitem B",
+		},
+		{
+			name: "audio with file_key",
+			elem: cardObj{"tag": "audio", "file_key": "file_abc123"},
+			want: "🎵 Audio(key:file_abc123)",
+		},
+		{
+			name: "audio fallback audio_id",
+			elem: cardObj{"tag": "audio", "audio_id": "audio_xyz"},
+			want: "🎵 Audio(key:audio_xyz)",
+		},
+		{
+			name: "video with file_key",
+			elem: cardObj{"tag": "video", "file_key": "video_abc"},
+			want: "🎬 Video(key:video_abc)",
+		},
+		{
+			name: "custom_icon returns empty",
+			elem: cardObj{"tag": "custom_icon", "img_key": "some_key"},
+			want: "",
+		},
+		{
+			name: "standard_icon returns empty",
+			elem: cardObj{"tag": "standard_icon", "token": "alarm_outlined"},
+			want: "",
+		},
+		{
+			name: "button disabled with disabled_tips",
+			elem: cardObj{
+				"tag":           "button",
+				"text":          cardObj{"tag": "plain_text", "content": "Submit"},
+				"disabled":      true,
+				"disabled_tips": cardObj{"tag": "plain_text", "content": "Not allowed"},
+			},
+			want: "[Submit ✗](tips:\"Not allowed\")",
+		},
+		{
+			name: "button with confirm",
+			elem: cardObj{
+				"tag":  "button",
+				"text": cardObj{"tag": "plain_text", "content": "Delete"},
+				"confirm": cardObj{
+					"title": cardObj{"tag": "plain_text", "content": "确认"},
+					"text":  cardObj{"tag": "plain_text", "content": "不可撤销"},
+				},
+			},
+			want: "[Delete](confirm:\"确认: 不可撤销\")",
+		},
+		{
+			name: "overflow with url",
+			elem: cardObj{
+				"tag": "overflow",
+				"options": []interface{}{
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Open"}, "url": "https://example.com"},
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Copy"}, "value": "copy"},
+				},
+			},
+			want: "⋮ [Open](https://example.com), Copy(copy)",
+		},
+		{
+			name: "select_static with initial_index",
+			elem: cardObj{
+				"tag":           "select_static",
+				"initial_index": float64(1),
+				"options": []interface{}{
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "First"}, "value": "a"},
+					cardObj{"text": cardObj{"tag": "plain_text", "content": "Second"}, "value": "b"},
+				},
+			},
+			want: "{First / ✓Second}",
+		},
+		{
+			name: "div text with notation size",
+			elem: cardObj{
+				"tag": "div",
+				"text": cardObj{
+					"tag":       "plain_text",
+					"content":   "小字注释",
+					"text_size": "notation",
+				},
+			},
+			want: "📝 小字注释",
+		},
+		{
+			name: "form",
+			elem: cardObj{
+				"tag": "form",
+				"elements": []interface{}{
+					cardObj{"tag": "markdown", "content": "fill this"},
+				},
+			},
+			want: "<form>\nfill this\n</form>",
+		},
+		{
+			name: "collapsible_panel collapsed",
+			elem: cardObj{
+				"tag":      "collapsible_panel",
+				"expanded": false,
+				"header":   cardObj{"title": cardObj{"tag": "plain_text", "content": "Details"}},
+				"elements": []interface{}{
+					cardObj{"tag": "markdown", "content": "inner"},
+				},
+			},
+			want: "▶ Details\n    inner\n▲",
+		},
+		{
+			name: "collapsible_panel expanded",
+			elem: cardObj{
+				"tag":      "collapsible_panel",
+				"expanded": true,
+				"header":   cardObj{"title": cardObj{"tag": "plain_text", "content": "Details"}},
+				"elements": []interface{}{
+					cardObj{"tag": "markdown", "content": "inner"},
+				},
+			},
+			want: "▼ Details\n    inner\n▲",
+		},
+		{
+			name: "interactive_container with behaviors",
+			elem: cardObj{
+				"tag": "interactive_container",
+				"behaviors": []interface{}{
+					cardObj{"type": "open_url", "default_url": "https://example.com"},
+				},
+				"elements": []interface{}{
+					cardObj{"tag": "markdown", "content": "Click here"},
+				},
+			},
+			want: "<clickable url=\"https://example.com\">\nClick here\n</clickable>",
+		},
+		{
+			name: "interactive_container no url",
+			elem: cardObj{
+				"tag": "interactive_container",
+				"elements": []interface{}{
+					cardObj{"tag": "markdown", "content": "No link"},
+				},
+			},
+			want: "<clickable>\nNo link\n</clickable>",
+		},
+		{
+			name: "column_set with buttons → space-joined",
+			elem: cardObj{
+				"tag": "column_set",
+				"columns": []interface{}{
+					cardObj{"tag": "column", "elements": []interface{}{
+						cardObj{"tag": "button", "text": cardObj{"tag": "plain_text", "content": "X"}},
+					}},
+					cardObj{"tag": "column", "elements": []interface{}{
+						cardObj{"tag": "button", "text": cardObj{"tag": "plain_text", "content": "Y"}},
+					}},
+				},
+			},
+			want: "[X] [Y]",
+		},
+		{
+			name: "person",
+			elem: cardObj{"tag": "person", "user_id": "fake-open-id-002"},
+			want: "fake-open-id-002",
+		},
+		{
+			name: "unknown tag fallback to content",
+			elem: cardObj{"tag": "mystery", "content": "mystery content"},
+			want: "mystery content",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := c.convertElement(tt.elem, 0)
+			if tt.contains != "" {
+				if !strings.Contains(got, tt.contains) {
+					t.Fatalf("convertElement(%s) = %q, want to contain %q", tt.name, got, tt.contains)
+				}
+				return
+			}
+			if got != tt.want {
+				t.Fatalf("convertElement(%s) = %q, want %q", tt.name, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestUserDslExtractButtonURL(t *testing.T) {
+	c := &userDslConverter{}
+
+	// direct url field wins first
+	got := c.extractButtonURL(cardObj{
+		"url":       "https://example.com/direct",
+		"multi_url": cardObj{"url": "https://example.com/multi"},
+		"behaviors": []interface{}{
+			cardObj{"type": "open_url", "default_url": "https://example.com/behavior"},
+		},
+	})
+	if got != "https://example.com/direct" {
+		t.Fatalf("direct url = %q, want https://example.com/direct", got)
+	}
+
+	// multi_url.url when no direct url
+	got = c.extractButtonURL(cardObj{
+		"multi_url": cardObj{"url": "https://example.com/multi"},
+		"behaviors": []interface{}{
+			cardObj{"type": "open_url", "default_url": "https://example.com/behavior"},
+		},
+	})
+	if got != "https://example.com/multi" {
+		t.Fatalf("multi_url = %q, want https://example.com/multi", got)
+	}
+
+	// behaviors default_url as last resort
+	got = c.extractButtonURL(cardObj{
+		"behaviors": []interface{}{
+			cardObj{"type": "open_url", "default_url": "https://example.com/behavior"},
+		},
+	})
+	if got != "https://example.com/behavior" {
+		t.Fatalf("behaviors = %q, want https://example.com/behavior", got)
+	}
+
+	// non-open_url behavior is ignored
+	got = c.extractButtonURL(cardObj{
+		"behaviors": []interface{}{
+			cardObj{"type": "callback", "default_url": "https://example.com/callback"},
+		},
+	})
+	if got != "" {
+		t.Fatalf("non-open_url = %q, want empty", got)
+	}
+
+	// no url anywhere → empty
+	got = c.extractButtonURL(cardObj{"text": cardObj{"content": "No URL"}})
+	if got != "" {
+		t.Fatalf("no url = %q, want empty", got)
+	}
+}
+
+func TestUserDslExtractTableCellValue(t *testing.T) {
+	c := &userDslConverter{}
+
+	// nil
+	if got := c.extractUserDslTableCellValue(nil); got != "" {
+		t.Fatalf("nil = %q, want empty", got)
+	}
+	// string
+	if got := c.extractUserDslTableCellValue("hello"); got != "hello" {
+		t.Fatalf("string = %q, want 'hello'", got)
+	}
+	// float64 integer
+	if got := c.extractUserDslTableCellValue(float64(42)); got != "42" {
+		t.Fatalf("int float = %q, want '42'", got)
+	}
+	// float64 decimal
+	if got := c.extractUserDslTableCellValue(float64(3.14)); got != "3.14" {
+		t.Fatalf("float = %q, want '3.14'", got)
+	}
+	// []interface{} with text tags → 「text」 format
+	got := c.extractUserDslTableCellValue([]interface{}{
+		cardObj{"text": "S2", "color": "blue"},
+		cardObj{"text": "M1", "color": "red"},
+	})
+	if got != "「S2」 「M1」" {
+		t.Fatalf("tag array = %q, want '「S2」 「M1」'", got)
+	}
+	// cardObj with content field
+	got = c.extractUserDslTableCellValue(cardObj{"content": "cell content"})
+	if got != "cell content" {
+		t.Fatalf("cardObj with content = %q, want 'cell content'", got)
+	}
+}
+
+func TestUserDslConvertTable(t *testing.T) {
+	c := &userDslConverter{}
+
+	got := c.convertTable(cardObj{
+		"columns": []interface{}{
+			cardObj{"display_name": "客户名称", "name": "customer_name"},
+			cardObj{"display_name": "规模", "name": "scale"},
+			cardObj{"display_name": "金额", "name": "arr"},
+		},
+		"rows": []interface{}{
+			cardObj{
+				"customer_name": "飞书科技",
+				"scale":         []interface{}{cardObj{"text": "S2", "color": "blue"}},
+				"arr":           float64(16800),
+			},
+		},
+	})
+	want := "| 客户名称 | 规模 | 金额 |\n|------|------|------|\n| 飞书科技 | 「S2」 | 16800 |"
+	if got != want {
+		t.Fatalf("convertTable() = %q, want %q", got, want)
+	}
+
+	// no columns → empty
+	if got := c.convertTable(cardObj{}); got != "" {
+		t.Fatalf("no columns = %q, want empty", got)
+	}
+}
+
+func TestLarkMdMentionResolution(t *testing.T) {
+	mentions := []interface{}{
+		map[string]interface{}{
+			"key":  "@_user_1",
+			"name": "test-user",
+			"id":   map[string]interface{}{"open_id": "fake-uid-001"},
+		},
+	}
+
+	// lark_md in div.text — the real Lark event format (C01 case)
+	card := map[string]interface{}{
+		"elements": []interface{}{
+			map[string]interface{}{
+				"tag": "div",
+				"text": map[string]interface{}{
+					"tag":     "lark_md",
+					"content": "Hello <at id=fake-uid-001></at> check this.",
+				},
+			},
+		},
+	}
+	dslBytes, _ := json.Marshal(card)
+	raw, _ := json.Marshal(map[string]interface{}{"user_dsl": string(dslBytes)})
+	got := ConvertInteractiveEventContent(string(raw), mentions)
+	if strings.Contains(got, "<at") {
+		t.Fatalf("div.text lark_md: raw <at> tag not resolved, got: %s", got)
+	}
+	if !strings.Contains(got, "@fake-uid-001") {
+		t.Fatalf("div.text lark_md: @id not in output, got: %s", got)
+	}
+
+	// lark_md in note.elements (C02 case)
+	card = map[string]interface{}{
+		"elements": []interface{}{
+			map[string]interface{}{
+				"tag": "note",
+				"elements": []interface{}{
+					map[string]interface{}{
+						"tag":     "lark_md",
+						"content": "Note: <at id=fake-uid-001></at> check.",
+					},
+				},
+			},
+		},
+	}
+	dslBytes, _ = json.Marshal(card)
+	raw, _ = json.Marshal(map[string]interface{}{"user_dsl": string(dslBytes)})
+	got = ConvertInteractiveEventContent(string(raw), mentions)
+	if strings.Contains(got, "<at") {
+		t.Fatalf("note lark_md: raw <at> tag not resolved, got: %s", got)
+	}
+	if !strings.Contains(got, "@fake-uid-001") {
+		t.Fatalf("note lark_md: @id not in output, got: %s", got)
+	}
+
+	// mention_key resolution via mentions map
+	card = map[string]interface{}{
+		"elements": []interface{}{
+			map[string]interface{}{
+				"tag": "div",
+				"text": map[string]interface{}{
+					"tag":     "lark_md",
+					"content": `Hi <at mention_key="@_user_1">n</at> done.`,
+				},
+			},
+		},
+	}
+	dslBytes, _ = json.Marshal(card)
+	raw, _ = json.Marshal(map[string]interface{}{"user_dsl": string(dslBytes)})
+	got = ConvertInteractiveEventContent(string(raw), mentions)
+	if !strings.Contains(got, "@test-user(fake-uid-001)") {
+		t.Fatalf("div.text lark_md mention_key: want @test-user(fake-uid-001), got: %s", got)
+	}
+}
+
+func TestConvertUserDslCardEndToEnd(t *testing.T) {
+	// user-2.ts format — matches structure of docs/user-dsl/user-example-2.json
+	schema2JSON := `{
+		"schema": "2.0",
+		"header": {
+			"title": {"tag": "plain_text", "content": "飞书卡片组件展示"},
+			"template": "blue"
+		},
+		"body": {
+			"elements": [
+				{"tag": "markdown", "content": "### 基础文本"},
+				{"tag": "hr"},
+				{
+					"tag": "img",
+					"img_key": "img_v3_02122_abc",
+					"alt": {"tag": "plain_text", "content": "示例图片"}
+				},
+				{
+					"tag": "button",
+					"text": {"tag": "plain_text", "content": "主要按钮"},
+					"behaviors": [{"type": "open_url", "default_url": "https://example.com"}]
+				},
+				{
+					"tag": "table",
+					"columns": [
+						{"display_name": "名称", "name": "name"},
+						{"display_name": "数值", "name": "value"}
+					],
+					"rows": [
+						{"name": "项目A", "value": 100},
+						{"name": "项目B", "value": 200}
+					]
+				}
+			]
+		}
+	}`
+
+	got := convertUserDslCard(schema2JSON, nil)
+
+	if !strings.HasPrefix(got, `<card title="飞书卡片组件展示">`) {
+		t.Fatalf("e2e schema2: missing card title prefix, got: %s", got)
+	}
+	if !strings.Contains(got, "### 基础文本") {
+		t.Fatal("e2e schema2: missing markdown content")
+	}
+	if !strings.Contains(got, "---") {
+		t.Fatal("e2e schema2: missing hr")
+	}
+	if !strings.Contains(got, "🖼️ 示例图片(img_key:img_v3_02122_abc)") {
+		t.Fatalf("e2e schema2: missing image, got: %s", got)
+	}
+	if !strings.Contains(got, "[主要按钮](https://example.com)") {
+		t.Fatalf("e2e schema2: missing button, got: %s", got)
+	}
+	if !strings.Contains(got, "| 名称 | 数值 |") {
+		t.Fatal("e2e schema2: missing table header")
+	}
+	if !strings.Contains(got, "| 项目A | 100 |") {
+		t.Fatalf("e2e schema2: missing table row, got: %s", got)
+	}
+	if !strings.HasSuffix(got, "</card>") {
+		t.Fatalf("e2e schema2: missing </card> suffix, got: %s", got)
+	}
+
+	// user-1.ts format
+	schema1JSON := `{
+		"i18n_header": {
+			"zh_cn": {
+				"title": {"tag": "plain_text", "content": "Schema1 卡片"},
+				"template": "blue"
+			}
+		},
+		"elements": [
+			{"tag": "markdown", "content": "Hello **World**"},
+			{
+				"tag": "action",
+				"actions": [
+					{
+						"tag": "button",
+						"text": {"tag": "plain_text", "content": "跳转"},
+						"behaviors": [{"type": "open_url", "default_url": "https://example.com"}]
+					}
+				]
+			}
+		]
+	}`
+
+	got = convertUserDslCard(schema1JSON, nil)
+	if !strings.HasPrefix(got, `<card title="Schema1 卡片">`) {
+		t.Fatalf("e2e schema1: missing card title, got: %s", got)
+	}
+	if !strings.Contains(got, "Hello **World**") {
+		t.Fatal("e2e schema1: missing markdown")
+	}
+	if !strings.Contains(got, "[跳转](https://example.com)") {
+		t.Fatalf("e2e schema1: missing button, got: %s", got)
+	}
+}

shortcuts/im/convert_lib/helpers_test.go

@@ -122,7 +122,7 @@ func TestExtractPostBlocksText(t *testing.T) {
 	}
 
 	got := extractPostBlocksText(blocks)
-	want := "hello @Alice [docs](https://example.com)\n[Image: img_123]"
+	want := "hello @Alice [docs](https://example.com)\n![Image](img_123)"
 	if got != want {
 		t.Fatalf("extractPostBlocksText() = %q, want %q", got, want)
 	}

shortcuts/im/convert_lib/text.go

@@ -39,16 +39,16 @@ func (postConverter) Convert(ctx *ConvertContext) string {
 	if title, _ := body["title"].(string); title != "" {
 		parts = append(parts, title)
 	}
-	if blocks, _ := body["content"].([]interface{}); len(blocks) > 0 {
-		for _, para := range blocks {
-			elems, _ := para.([]interface{})
-			var line strings.Builder
-			for _, el := range elems {
-				elem, _ := el.(map[string]interface{})
-				line.WriteString(renderPostElem(elem))
-			}
-			parts = append(parts, line.String())
+	// Prefer content_v2 blocks; fallback to content blocks
+	blocks := selectContentBlocks(body)
+	for _, para := range blocks {
+		elems, _ := para.([]interface{})
+		var line strings.Builder
+		for _, el := range elems {
+			elem, _ := el.(map[string]interface{})
+			line.WriteString(renderPostElem(elem))
 		}
+		parts = append(parts, line.String())
 	}
 
 	result := strings.TrimSpace(strings.Join(parts, "\n"))
@@ -58,6 +58,17 @@ func (postConverter) Convert(ctx *ConvertContext) string {
 	return ResolveMentionKeys(result, ctx.MentionMap)
 }
 
+// selectContentBlocks returns content_v2 blocks when present and non-empty;
+// otherwise falls back to content blocks. This implements the content_v2
+// priority rule for post messages.
+func selectContentBlocks(body map[string]interface{}) []interface{} {
+	if v2, ok := body["content_v2"].([]interface{}); ok && len(v2) > 0 {
+		return v2
+	}
+	blocks, _ := body["content"].([]interface{})
+	return blocks
+}
+
 func unwrapPostLocale(parsed map[string]interface{}) map[string]interface{} {
 	if _, ok := parsed["content"]; ok {
 		return parsed
@@ -114,10 +125,14 @@ func renderPostElem(el map[string]interface{}) string {
 		var rendered string
 		switch {
 		case userId == "@_all" || userId == "all":
-			rendered = "@all"
+			rendered = `<at user_id="all"></at>`
 		default:
 			if name, _ := el["user_name"].(string); name != "" {
-				rendered = "@" + name
+				if userId != "" && strings.HasPrefix(userId, "ou") {
+					rendered = fmt.Sprintf(`<at user_id="%s">%s</at>`, userId, name)
+				} else {
+					rendered = "@" + name
+				}
 			} else {
 				rendered = "@" + userId
 			}
@@ -138,7 +153,7 @@ func renderPostElem(el map[string]interface{}) string {
 	case "img":
 		key, _ := el["image_key"].(string)
 		if key != "" {
-			return fmt.Sprintf("[Image: %s]", key)
+			return fmt.Sprintf("![Image](%s)", key)
 		}
 		return "[Image]"
 	case "media":

shortcuts/im/convert_lib/text_test.go

@@ -93,9 +93,13 @@ func TestRenderPostElem(t *testing.T) {
 	}{
 		{name: "text", el: map[string]interface{}{"tag": "text", "text": "hello"}, want: "hello"},
 		{name: "link", el: map[string]interface{}{"tag": "a", "text": "doc", "href": "https://example.com"}, want: "[doc](https://example.com)"},
-		{name: "mention all", el: map[string]interface{}{"tag": "at", "user_id": "@_all"}, want: "@all"},
-		{name: "mention user", el: map[string]interface{}{"tag": "at", "user_name": "Alice"}, want: "@Alice"},
-		{name: "image", el: map[string]interface{}{"tag": "img", "image_key": "img_123"}, want: "[Image: img_123]"},
+		{name: "mention all", el: map[string]interface{}{"tag": "at", "user_id": "@_all"}, want: `<at user_id="all"></at>`},
+		{name: "mention user with id", el: map[string]interface{}{"tag": "at", "user_id": "ou_user_1", "user_name": "Alice"}, want: `<at user_id="ou_user_1">Alice</at>`},
+		{name: "mention user name only", el: map[string]interface{}{"tag": "at", "user_name": "Alice"}, want: "@Alice"},
+		{name: "mention user id only", el: map[string]interface{}{"tag": "at", "user_id": "@_user_1"}, want: "@@_user_1"},
+		{name: "image", el: map[string]interface{}{"tag": "img", "image_key": "img_123"}, want: "![Image](img_123)"},
+		{name: "image no key", el: map[string]interface{}{"tag": "img"}, want: "[Image]"},
+		{name: "md text", el: map[string]interface{}{"tag": "md", "text": "##### 标题\n\n<at user_id=\"ou_xxx\">Alice</at> 你好"}, want: "##### 标题\n\n<at user_id=\"ou_xxx\">Alice</at> 你好"},
 		{name: "media", el: map[string]interface{}{"tag": "media", "file_key": "file_123"}, want: "[Media: file_123]"},
 		{name: "code block", el: map[string]interface{}{"tag": "code_block", "language": "go", "text": "fmt.Println(1)"}, want: "\n```go\nfmt.Println(1)\n```\n"},
 		{name: "hr", el: map[string]interface{}{"tag": "hr"}, want: "\n---\n"},
@@ -144,3 +148,87 @@ func TestRenderPostElemEmotionStyleMd(t *testing.T) {
 		})
 	}
 }
+
+func TestSelectContentBlocks(t *testing.T) {
+	tests := []struct {
+		name string
+		body map[string]interface{}
+		want int
+	}{
+		{
+			name: "content_v2 present and non-empty",
+			body: map[string]interface{}{
+				"content":    []interface{}{[]interface{}{map[string]interface{}{"tag": "text", "text": "old"}}},
+				"content_v2": []interface{}{[]interface{}{map[string]interface{}{"tag": "md", "text": "new"}}},
+			},
+			want: 1,
+		},
+		{
+			name: "content_v2 empty array",
+			body: map[string]interface{}{
+				"content":    []interface{}{[]interface{}{map[string]interface{}{"tag": "text", "text": "old"}}},
+				"content_v2": []interface{}{},
+			},
+			want: 1,
+		},
+		{
+			name: "content_v2 nil",
+			body: map[string]interface{}{
+				"content": []interface{}{[]interface{}{map[string]interface{}{"tag": "text", "text": "old"}}},
+			},
+			want: 1,
+		},
+		{
+			name: "content_v2 wrong type",
+			body: map[string]interface{}{
+				"content":    []interface{}{[]interface{}{map[string]interface{}{"tag": "text", "text": "old"}}},
+				"content_v2": "not_an_array",
+			},
+			want: 1,
+		},
+		{
+			name: "both missing",
+			body: map[string]interface{}{},
+			want: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := selectContentBlocks(tt.body)
+			if len(got) != tt.want {
+				t.Fatalf("selectContentBlocks() len = %d, want %d", len(got), tt.want)
+			}
+		})
+	}
+}
+
+func TestPostConverterConvertContentV2(t *testing.T) {
+	// AC-M1-H1: content_v2 present → use content_v2 blocks (md passthrough)
+	ctx := &ConvertContext{
+		RawContent: `{"content_v2":[[{"tag":"md","text":"##### 标题\n\n<at user_id=\"ou_xxx\">Alice</at> 你好"}]],"content":[[{"tag":"text","text":"old path"}]]}`,
+	}
+	want := "##### 标题\n\n<at user_id=\"ou_xxx\">Alice</at> 你好"
+	if got := (postConverter{}).Convert(ctx); got != want {
+		t.Fatalf("postConverter.Convert(content_v2) = %q, want %q", got, want)
+	}
+
+	// AC-M1-H2: no content_v2 → use content blocks with new at/img format
+	ctx2 := &ConvertContext{
+		RawContent: `{"content":[[{"tag":"at","user_id":"ou_xxx","user_name":"Bob"},{"tag":"text","text":" "},{"tag":"img","image_key":"img_123"}]]}`,
+		Mentions:   []interface{}{map[string]interface{}{"key": "ou_xxx", "id": "ou_bob", "name": "Bob"}},
+	}
+	want2 := `<at user_id="ou_xxx">Bob</at> ![Image](img_123)`
+	if got := (postConverter{}).Convert(ctx2); got != want2 {
+		t.Fatalf("postConverter.Convert(content) = %q, want %q", got, want2)
+	}
+
+	// AC-M1-E1: content_v2 empty → fallback to content
+	ctx3 := &ConvertContext{
+		RawContent: `{"content_v2":[],"content":[[{"tag":"text","text":"fallback path"}]]}`,
+	}
+	want3 := "fallback path"
+	if got := (postConverter{}).Convert(ctx3); got != want3 {
+		t.Fatalf("postConverter.Convert(empty content_v2) = %q, want %q", got, want3)
+	}
+}

shortcuts/im/helpers.go

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

shortcuts/im/helpers_test.go

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

shortcuts/im/im_chat_search.go

@@ -29,7 +29,7 @@ var ImChatSearch = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	HasFormat:   true,
 	Flags: []common.Flag{
-		{Name: "query", Desc: "search keyword (max 64 chars)"},
+		{Name: "query", Desc: "search keyword (server may return data.notice for overly long input)"},
 		{Name: "search-types", Desc: "chat types, comma-separated (private, external, public_joined, public_not_joined)"},
 		{Name: "chat-modes", Desc: "filter by chat mode, comma-separated (group, topic)"},
 		{Name: "member-ids", Desc: "filter by member open_ids, comma-separated"},
@@ -50,7 +50,7 @@ var ImChatSearch = common.Shortcut{
 			Params(params).
 			Body(body)
 	},
-	// Validate enforces query/member-ids presence, --query rune cap, search-types
+	// Validate enforces query/member-ids presence, search-types
 	// enum, --member-ids count and format, and --page-size bounds.
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		query := runtime.Str("query")
@@ -58,9 +58,6 @@ var ImChatSearch = common.Shortcut{
 		if query == "" && memberIDs == "" {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--query and --member-ids cannot both be empty; provide at least one (e.g. --query \"team-name\" or --member-ids \"ou_xxx\")")
 		}
-		if query != "" && len([]rune(query)) > 64 {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--query exceeds the maximum of 64 characters (got %d)", len([]rune(query))).WithParam("--query")
-		}
 		if st := runtime.Str("search-types"); st != "" {
 			allowed := map[string]struct{}{
 				"private":           {},
@@ -151,6 +148,9 @@ var ImChatSearch = common.Shortcut{
 			"has_more":   hasMore,
 			"page_token": pageToken,
 		}
+		if notice, _ := resData["notice"].(string); notice != "" {
+			outData["notice"] = notice
+		}
 		if mfOut.Meta.Applied != "" {
 			outData["filter"] = MuteFilterMetaToMap(mfOut.Meta)
 		}

shortcuts/im/im_messages_reply.go

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

shortcuts/im/im_messages_search.go

@@ -91,7 +91,7 @@ var ImMessagesSearch = common.Shortcut{
 			return err
 		}
 
-		rawItems, hasMore, nextPageToken, truncatedByLimit, pageLimit, err := searchMessages(runtime, req)
+		rawItems, hasMore, nextPageToken, truncatedByLimit, pageLimit, notice, err := searchMessages(runtime, req)
 		if err != nil {
 			return err
 		}
@@ -103,6 +103,9 @@ var ImMessagesSearch = common.Shortcut{
 				"has_more":   hasMore,
 				"page_token": nextPageToken,
 			}
+			if notice != "" {
+				outData["notice"] = notice
+			}
 			runtime.OutFormat(outData, nil, func(w io.Writer) {
 				fmt.Fprintln(w, "No matching messages found.")
 			})
@@ -131,6 +134,9 @@ var ImMessagesSearch = common.Shortcut{
 				"page_token":  nextPageToken,
 				"note":        "failed to fetch message details, returning ID list only",
 			}
+			if notice != "" {
+				outData["notice"] = notice
+			}
 			runtime.OutFormat(outData, nil, func(w io.Writer) {
 				fmt.Fprintf(w, "Found %d messages (failed to fetch details):\n", len(messageIds))
 				for _, id := range messageIds {
@@ -206,6 +212,9 @@ var ImMessagesSearch = common.Shortcut{
 			"has_more":   hasMore,
 			"page_token": nextPageToken,
 		}
+		if notice != "" {
+			outData["notice"] = notice
+		}
 		runtime.OutFormat(outData, nil, func(w io.Writer) {
 			if len(enriched) == 0 {
 				fmt.Fprintln(w, "No matching messages found.")
@@ -377,6 +386,7 @@ func buildMessagesSearchRequest(runtime *common.RuntimeContext) (*messagesSearch
 	}, nil
 }
 
+// messagesSearchPaginationConfig derives auto-pagination mode and page limit.
 func messagesSearchPaginationConfig(runtime *common.RuntimeContext) (autoPaginate bool, pageLimit int) {
 	autoPaginate = runtime.Bool("page-all")
 	if runtime.Cmd != nil && runtime.Cmd.Flags().Changed("page-limit") {
@@ -392,7 +402,8 @@ func messagesSearchPaginationConfig(runtime *common.RuntimeContext) (autoPaginat
 	return autoPaginate, pageLimit
 }
 
-func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest) ([]interface{}, bool, string, bool, int, error) {
+// searchMessages fetches message search pages and returns the first server notice.
+func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest) ([]interface{}, bool, string, bool, int, string, error) {
 	autoPaginate, pageLimit := messagesSearchPaginationConfig(runtime)
 	pageToken := ""
 	if tokens := req.params["page_token"]; len(tokens) > 0 {
@@ -410,6 +421,7 @@ func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest)
 		lastPageToken    string
 		truncatedByLimit bool
 		pageCount        int
+		notice           string
 	)
 
 	for {
@@ -423,9 +435,12 @@ func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest)
 
 		searchData, err := runtime.DoAPIJSONTyped(http.MethodPost, "/open-apis/im/v1/messages/search", params, req.body)
 		if err != nil {
-			return nil, false, "", false, pageLimit, err
+			return nil, false, "", false, pageLimit, "", err
 		}
 
+		if notice == "" {
+			notice, _ = searchData["notice"].(string)
+		}
 		items, _ := searchData["items"].([]interface{})
 		allItems = append(allItems, items...)
 		lastHasMore, lastPageToken = common.PaginationMeta(searchData)
@@ -441,9 +456,10 @@ func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest)
 		pageToken = lastPageToken
 	}
 
-	return allItems, lastHasMore, lastPageToken, truncatedByLimit, pageLimit, nil
+	return allItems, lastHasMore, lastPageToken, truncatedByLimit, pageLimit, notice, nil
 }
 
+// batchMGetMessages fetches message details in API-sized batches.
 func batchMGetMessages(runtime *common.RuntimeContext, messageIds []string) ([]interface{}, error) {
 	var items []interface{}
 	for _, batch := range chunkStrings(messageIds, messagesSearchMGetBatchSize) {
@@ -457,6 +473,7 @@ func batchMGetMessages(runtime *common.RuntimeContext, messageIds []string) ([]i
 	return items, nil
 }
 
+// batchQueryChatContexts fetches chat metadata best-effort for message rows.
 func batchQueryChatContexts(runtime *common.RuntimeContext, chatIds []string) map[string]map[string]interface{} {
 	chatContexts := map[string]map[string]interface{}{}
 	// Best-effort: a failed chunk only loses its own entries.
@@ -466,6 +483,7 @@ func batchQueryChatContexts(runtime *common.RuntimeContext, chatIds []string) ma
 	return chatContexts
 }
 
+// chunkStrings splits a string slice into fixed-size batches.
 func chunkStrings(items []string, chunkSize int) [][]string {
 	if len(items) == 0 || chunkSize <= 0 {
 		return nil

shortcuts/im/im_messages_send.go

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

shortcuts/im/im_search_notice_test.go

@@ -0,0 +1,129 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package im
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/shortcuts/common"
+	"github.com/spf13/cobra"
+)
+
+// TestImChatSearchExecutePassesThroughNotice verifies chat search notice output.
+func TestImChatSearchExecutePassesThroughNotice(t *testing.T) {
+	const notice = "The query is too long and has been truncated to the first 50 characters for search."
+	longQuery := strings.Repeat("q", 81)
+
+	runtime := newBotShortcutRuntime(t, shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		if !strings.Contains(req.URL.Path, "/open-apis/im/v2/chats/search") {
+			return nil, fmt.Errorf("unexpected request: %s", req.URL.String())
+		}
+		var body map[string]interface{}
+		if err := json.NewDecoder(req.Body).Decode(&body); err != nil {
+			return nil, fmt.Errorf("decode request body: %w", err)
+		}
+		if got, _ := body["query"].(string); got != longQuery {
+			return nil, fmt.Errorf("body.query = %q, want %q", got, longQuery)
+		}
+		return shortcutJSONResponse(200, map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"notice":     notice,
+				"items":      []interface{}{},
+				"total":      0,
+				"has_more":   false,
+				"page_token": "",
+			},
+		}), nil
+	}))
+	runtime.Cmd = newChatSearchNoticeTestCommand(t, longQuery)
+	runtime.Format = "json"
+
+	if err := ImChatSearch.Execute(context.Background(), runtime); err != nil {
+		t.Fatalf("ImChatSearch.Execute() error = %v", err)
+	}
+
+	data := decodeShortcutData(t, runtime)
+	if got, _ := data["notice"].(string); got != notice {
+		t.Fatalf("data.notice = %q, want %q; data=%#v", got, notice, data)
+	}
+}
+
+// TestImMessagesSearchExecutePassesThroughNotice verifies message search notice output.
+func TestImMessagesSearchExecutePassesThroughNotice(t *testing.T) {
+	const notice = "The query is too long and has been truncated to the first 50 characters for search."
+
+	runtime := newMessagesSearchRuntime(t, map[string]string{
+		"query": "incident",
+	}, nil, shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		if !strings.Contains(req.URL.Path, "/open-apis/im/v1/messages/search") {
+			return nil, fmt.Errorf("unexpected request: %s", req.URL.String())
+		}
+		return shortcutJSONResponse(200, map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"notice":     notice,
+				"items":      []interface{}{},
+				"has_more":   false,
+				"page_token": "",
+			},
+		}), nil
+	}))
+	runtime.Format = "json"
+
+	if err := ImMessagesSearch.Execute(context.Background(), runtime); err != nil {
+		t.Fatalf("ImMessagesSearch.Execute() error = %v", err)
+	}
+
+	data := decodeShortcutData(t, runtime)
+	if got, _ := data["notice"].(string); got != notice {
+		t.Fatalf("data.notice = %q, want %q; data=%#v", got, notice, data)
+	}
+}
+
+// newChatSearchNoticeTestCommand builds a typed chat-search command for notice tests.
+func newChatSearchNoticeTestCommand(t *testing.T, query string) *cobra.Command {
+	t.Helper()
+
+	cmd := &cobra.Command{Use: "test"}
+	for _, name := range []string{"query", "search-types", "member-ids", "sort-by", "page-token"} {
+		cmd.Flags().String(name, "", "")
+	}
+	for _, name := range []string{"is-manager", "disable-search-by-user", "exclude-muted"} {
+		cmd.Flags().Bool(name, false, "")
+	}
+	cmd.Flags().Int("page-size", 20, "")
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("ParseFlags() error = %v", err)
+	}
+	if err := cmd.Flags().Set("query", query); err != nil {
+		t.Fatalf("Flags().Set(query) error = %v", err)
+	}
+	return cmd
+}
+
+// decodeShortcutData extracts the JSON envelope data object from shortcut output.
+func decodeShortcutData(t *testing.T, runtime *common.RuntimeContext) map[string]interface{} {
+	t.Helper()
+
+	out, ok := runtime.Factory.IOStreams.Out.(*bytes.Buffer)
+	if !ok {
+		t.Fatalf("stdout buffer has type %T", runtime.Factory.IOStreams.Out)
+	}
+	var env map[string]interface{}
+	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
+		t.Fatalf("json.Unmarshal(stdout) error = %v\nstdout=%s", err, out.String())
+	}
+	data, ok := env["data"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("envelope data missing or wrong type: %#v", env)
+	}
+	return data
+}

shortcuts/mail/mail_triage.go

@@ -159,6 +159,7 @@ var MailTriage = common.Shortcut{
 		var messages []map[string]interface{}
 		var hasMore bool
 		var nextPageToken string
+		var notice string
 
 		useSearch, err := resolveTriagePath(parsed, query, filter)
 		if err != nil {
@@ -189,6 +190,9 @@ var MailTriage = common.Shortcut{
 				if err != nil {
 					return err
 				}
+				if notice == "" {
+					notice, _ = searchData["notice"].(string)
+				}
 				pageMessages := buildTriageMessagesFromSearchItems(searchData["items"])
 				messages = append(messages, pageMessages...)
 				pageHasMore, _ := searchData["has_more"].(bool)
@@ -282,8 +286,14 @@ var MailTriage = common.Shortcut{
 				"has_more":   hasMore,
 				"page_token": nextPageToken,
 			}
+			if notice != "" {
+				outData["notice"] = notice
+			}
 			output.PrintJson(runtime.IO().Out, outData)
 		default: // "table"
+			if notice != "" {
+				fmt.Fprintf(runtime.IO().ErrOut, "notice: %s\n", notice)
+			}
 			if len(messages) == 0 {
 				fmt.Fprintln(runtime.IO().ErrOut, "No messages found.")
 				return nil
@@ -760,13 +770,7 @@ func buildListParams(runtime *common.RuntimeContext, mailboxID string, f triageF
 				params["folder_id"] = folderIDFromFilter
 			}
 		} else {
-			resolved, err := resolveFolderID(runtime, mailboxID, folderIDFromFilter)
-			if err != nil {
-				return nil, err
-			}
-			if resolved != "" {
-				params["folder_id"] = resolved
-			}
+			params["folder_id"] = folderIDFromFilter
 		}
 	} else if folderFromFilter != "" {
 		if dryRun {
@@ -776,13 +780,7 @@ func buildListParams(runtime *common.RuntimeContext, mailboxID string, f triageF
 				params["folder_id"] = folderFromFilter
 			}
 		} else {
-			resolved, err := resolveFolderName(runtime, mailboxID, folderFromFilter)
-			if err != nil {
-				return nil, err
-			}
-			if resolved != "" {
-				params["folder_id"] = resolved
-			}
+			params["folder_id"] = folderFromFilter
 		}
 	}
 
@@ -801,13 +799,7 @@ func buildListParams(runtime *common.RuntimeContext, mailboxID string, f triageF
 				params["label_id"] = labelIDFromFilter
 			}
 		} else {
-			resolved, err := resolveLabelID(runtime, mailboxID, labelIDFromFilter)
-			if err != nil {
-				return nil, err
-			}
-			if resolved != "" {
-				params["label_id"] = resolved
-			}
+			params["label_id"] = labelIDFromFilter
 		}
 	} else if labelFromFilter != "" {
 		if dryRun {
@@ -817,13 +809,7 @@ func buildListParams(runtime *common.RuntimeContext, mailboxID string, f triageF
 				params["label_id"] = labelFromFilter
 			}
 		} else {
-			resolved, err := resolveLabelName(runtime, mailboxID, labelFromFilter)
-			if err != nil {
-				return nil, err
-			}
-			if resolved != "" {
-				params["label_id"] = resolved
-			}
+			params["label_id"] = labelFromFilter
 		}
 	}
 

shortcuts/mail/mail_triage_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 
 	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/shortcuts/common"
@@ -974,7 +975,11 @@ func TestBuildListParamsDryRunOnlyUnread(t *testing.T) {
 func TestBuildListParamsDryRunFolderAlias(t *testing.T) {
 	rt := runtimeForMailTriageTest(t, nil)
 	f := triageFilter{Folder: "sent"}
-	got, err := buildListParams(rt, "me", f, 20, "", true)
+	resolved, err := resolveListFilter(rt, "me", f, true)
+	if err != nil {
+		t.Fatalf("resolveListFilter: %v", err)
+	}
+	got, err := buildListParams(rt, "me", resolved, 20, "", true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -983,10 +988,30 @@ func TestBuildListParamsDryRunFolderAlias(t *testing.T) {
 	}
 }
 
+func TestBuildListParamsDryRunCustomFolderPreservesInput(t *testing.T) {
+	rt := runtimeForMailTriageTest(t, nil)
+	f := triageFilter{Folder: "team-folder"}
+	resolved, err := resolveListFilter(rt, "me", f, true)
+	if err != nil {
+		t.Fatalf("resolveListFilter: %v", err)
+	}
+	got, err := buildListParams(rt, "me", resolved, 20, "", true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got["folder_id"] != "team-folder" {
+		t.Fatalf("expected dry-run folder_id=team-folder, got %v", got["folder_id"])
+	}
+}
+
 func TestBuildListParamsDryRunLabelAlias(t *testing.T) {
 	rt := runtimeForMailTriageTest(t, nil)
 	f := triageFilter{Label: "flagged"}
-	got, err := buildListParams(rt, "me", f, 10, "", true)
+	resolved, err := resolveListFilter(rt, "me", f, true)
+	if err != nil {
+		t.Fatalf("resolveListFilter: %v", err)
+	}
+	got, err := buildListParams(rt, "me", resolved, 10, "", true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -995,6 +1020,25 @@ func TestBuildListParamsDryRunLabelAlias(t *testing.T) {
 	}
 }
 
+func TestBuildListParamsDryRunCustomLabelPreservesInput(t *testing.T) {
+	rt := runtimeForMailTriageTest(t, nil)
+	f := triageFilter{Label: "custom-label"}
+	resolved, err := resolveListFilter(rt, "me", f, true)
+	if err != nil {
+		t.Fatalf("resolveListFilter: %v", err)
+	}
+	got, err := buildListParams(rt, "me", resolved, 10, "", true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := got["folder_id"]; ok {
+		t.Fatalf("folder_id should not be set when label is specified, got %v", got["folder_id"])
+	}
+	if got["label_id"] != "custom-label" {
+		t.Fatalf("expected dry-run label_id=custom-label, got %v", got["label_id"])
+	}
+}
+
 // --- buildSearchParams additional coverage ---
 
 func TestBuildSearchParamsAllFilterFields(t *testing.T) {
@@ -1478,14 +1522,16 @@ func boolPtr(v bool) *bool { return &v }
 
 // --- mailbox_id preservation tests ---
 
+// TestMailTriageStructuredOutputPreservesMailboxID verifies mailbox and notice metadata.
 func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 	tests := []struct {
-		name      string
-		mailbox   string
-		format    string
-		args      []string
-		register  func(*httpmock.Registry, string)
-		wantCount int
+		name       string
+		mailbox    string
+		format     string
+		args       []string
+		register   func(*httpmock.Registry, string)
+		wantCount  int
+		wantNotice string
 	}{
 		{
 			name:    "list json default mailbox",
@@ -1522,9 +1568,10 @@ func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 			register: func(reg *httpmock.Registry, mailbox string) {
 				registerMailTriageSearchStub(reg, mailbox, []interface{}{
 					mailTriageSearchItem("search_pub_001", "Shared search"),
-				}, false, "")
+				}, false, "", "The query is too long and has been truncated to the first 50 characters for search.")
 			},
-			wantCount: 1,
+			wantCount:  1,
+			wantNotice: "The query is too long and has been truncated to the first 50 characters for search.",
 		},
 		{
 			name:    "empty list json keeps top-level mailbox",
@@ -1559,6 +1606,9 @@ func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 			if data["mailbox_id"] != tt.mailbox {
 				t.Fatalf("top-level mailbox_id mismatch: got %v, want %q", data["mailbox_id"], tt.mailbox)
 			}
+			if tt.wantNotice != "" && data["notice"] != tt.wantNotice {
+				t.Fatalf("notice mismatch: got %v, want %q", data["notice"], tt.wantNotice)
+			}
 			messages := mailTriageMessagesFromOutput(t, data)
 			if len(messages) != tt.wantCount {
 				t.Fatalf("message count mismatch: got %d, want %d", len(messages), tt.wantCount)
@@ -1572,6 +1622,7 @@ func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 	}
 }
 
+// TestMailTriageMissingMessageMetadataStillGetsMailboxID verifies fallback rows keep mailbox IDs.
 func TestMailTriageMissingMessageMetadataStillGetsMailboxID(t *testing.T) {
 	f, stdout, _, reg := mailShortcutTestFactory(t)
 	defer reg.Verify(t)
@@ -1604,6 +1655,7 @@ func TestMailTriageMissingMessageMetadataStillGetsMailboxID(t *testing.T) {
 	}
 }
 
+// TestMailTriageTableOutputPreservesMailboxContext verifies public mailbox table hints.
 func TestMailTriageTableOutputPreservesMailboxContext(t *testing.T) {
 	tests := []struct {
 		name              string
@@ -1654,6 +1706,33 @@ func TestMailTriageTableOutputPreservesMailboxContext(t *testing.T) {
 	}
 }
 
+// TestMailTriageDefaultTableOutputPrintsSearchNoticeToStderr verifies stderr notices.
+func TestMailTriageDefaultTableOutputPrintsSearchNoticeToStderr(t *testing.T) {
+	const notice = "The query is too long and has been truncated to the first 50 characters for search."
+
+	f, stdout, stderr, reg := mailShortcutTestFactory(t)
+	defer reg.Verify(t)
+
+	registerMailTriageSearchStub(reg, "me", []interface{}{
+		mailTriageSearchItem("msg_search_notice", "Search notice result"),
+	}, false, "", notice)
+
+	if err := runMountedMailShortcut(t, MailTriage, []string{
+		"+triage",
+		"--query", strings.Repeat("q", 81),
+	}, f, stdout); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if out := stdout.String(); !strings.Contains(out, "msg_search_notice") {
+		t.Fatalf("stdout should contain table row, got:\n%s", out)
+	}
+	if errOut := stderr.String(); !strings.Contains(errOut, "notice: "+notice) {
+		t.Fatalf("stderr should contain search notice, got:\n%s", errOut)
+	}
+}
+
+// decodeMailTriageJSONOutput decodes structured triage output for assertions.
 func decodeMailTriageJSONOutput(t *testing.T, stdout interface{ Bytes() []byte }) map[string]interface{} {
 	t.Helper()
 	var data map[string]interface{}
@@ -1663,6 +1742,7 @@ func decodeMailTriageJSONOutput(t *testing.T, stdout interface{ Bytes() []byte }
 	return data
 }
 
+// mailTriageMessagesFromOutput extracts triage messages as object maps.
 func mailTriageMessagesFromOutput(t *testing.T, data map[string]interface{}) []map[string]interface{} {
 	t.Helper()
 	rawMessages, ok := data["messages"].([]interface{})
@@ -1715,7 +1795,8 @@ func registerMailTriageBatchStub(reg *httpmock.Registry, mailbox string, message
 	})
 }
 
-func registerMailTriageSearchStub(reg *httpmock.Registry, mailbox string, items []interface{}, hasMore bool, pageToken string) {
+// registerMailTriageSearchStub registers a mailbox search response for triage tests.
+func registerMailTriageSearchStub(reg *httpmock.Registry, mailbox string, items []interface{}, hasMore bool, pageToken string, notices ...string) {
 	data := map[string]interface{}{
 		"items":    items,
 		"has_more": hasMore,
@@ -1723,6 +1804,9 @@ func registerMailTriageSearchStub(reg *httpmock.Registry, mailbox string, items
 	if pageToken != "" {
 		data["page_token"] = pageToken
 	}
+	if len(notices) > 0 && notices[0] != "" {
+		data["notice"] = notices[0]
+	}
 	reg.Register(&httpmock.Stub{
 		Method: "POST",
 		URL:    mailboxPath(mailbox, "search"),
@@ -1751,3 +1835,137 @@ func mailTriageSearchItem(messageID, subject string) map[string]interface{} {
 		},
 	}
 }
+
+// registerMailTriageFoldersListStub registers a NON-reusable stub for the
+// mailbox folders list API. Because it is non-reusable, any second hit returns
+// "httpmock: no stub for GET .../folders" — which is exactly the assertion we
+// use to prove resolveListFilter runs once and buildListParams does NOT
+// re-resolve. folderID/folderName is the single custom folder the API reports.
+func registerMailTriageFoldersListStub(reg *httpmock.Registry, mailbox, folderID, folderName string) {
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    mailboxPath(mailbox, "folders"),
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{
+						"id":   folderID,
+						"name": folderName,
+					},
+				},
+			},
+		},
+	})
+}
+
+// registerMailTriageListPageStub registers one page of the messages list API,
+// disambiguated from sibling pages by a URL substring unique to that page
+// (e.g. "page_size=5" for page 1 vs "page_size=2" for page 2). The substring
+// must NOT depend on query-param ordering: map iteration makes param order
+// nondeterministic, so prefer a value-only token like "page_size=N" (the N
+// differs per page because pageSize = maxCount - fetched_so_far). Non-reusable
+// so reg.Verify catches under- or over-consumption.
+func registerMailTriageListPageStub(reg *httpmock.Registry, urlSubstring string, items []string, hasMore bool, pageToken string) {
+	data := map[string]interface{}{
+		"items":    items,
+		"has_more": hasMore,
+	}
+	if pageToken != "" {
+		data["page_token"] = pageToken
+	}
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    urlSubstring,
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": data,
+		},
+	})
+}
+
+// TestMailTriageCustomFolderResolvesOnceAcrossListPages is the regression test
+// for the bug where buildListParams re-called resolveFolderID on every list
+// page, turning "resolve once" into "1 + page_count" folder-list API calls and
+// easily tripping rate limits.
+//
+// Setup: a custom folder filter that forces resolveListFilter to hit the
+// folders list API once (to map folder name "team-folder" to folder_id), then two
+// messages-list pages. The folders list stub is non-reusable, so if
+// buildListParams re-resolves, the second hit fails with "no stub". The
+// messages-list stubs are page-specific (disambiguated by page_size in the
+// URL), so both pages are served and Verify asserts each fired exactly once.
+func TestMailTriageCustomFolderResolvesOnceAcrossListPages(t *testing.T) {
+	f, stdout, _, reg := mailShortcutTestFactory(t)
+	defer reg.Verify(t)
+
+	// listMailboxFolders (called once by resolveListFilter) gates on the
+	// mail:user_mailbox.folder:read scope, which the default test token does
+	// not carry. Re-store the token with that scope appended so the folders
+	// API call is actually exercised (and thus the non-reusable folders stub
+	// is the load-bearing "exactly once" assertion).
+	const folderScope = "mail:user_mailbox.folder:read"
+	cfg := mailTestConfig()
+	if stored := auth.GetStoredToken(cfg.AppID, cfg.UserOpenId); stored != nil {
+		if !strings.Contains(stored.Scope, folderScope) {
+			stored.Scope = stored.Scope + " " + folderScope
+			if err := auth.SetStoredToken(stored); err != nil {
+				t.Fatalf("re-store token with folder scope: %v", err)
+			}
+		}
+	}
+
+	const (
+		mailbox    = "me"
+		folderName = "team-folder"
+		folderID   = "fld_custom_team"
+		page2Token = "tok_page2"
+	)
+	// --max 5 with listPageMax=20 → pageSize = 5-0 = 5 on page 1, then 5-3 = 2
+	// on page 2. The page_size query value disambiguates the two list stubs.
+	page1IDs := []string{"msg_a", "msg_b", "msg_c"}
+	page2IDs := []string{"msg_d", "msg_e"}
+
+	// Folders list: registered exactly once, non-reusable. Any second folder
+	// lookup (the bug) fails the test with "no stub for GET .../folders".
+	registerMailTriageFoldersListStub(reg, mailbox, folderID, folderName)
+	// Messages list, page 1: 3 ids, has_more, hands off a page-2 token. The
+	// page_size value (5 = maxCount - 0) is unique to page 1; page 2 uses 2.
+	registerMailTriageListPageStub(reg, "page_size=5", page1IDs, true, page2Token)
+	// Messages list, page 2: 2 ids, terminal.
+	registerMailTriageListPageStub(reg, "page_size=2", page2IDs, false, "")
+	// Batch metadata fetch for all 5 ids.
+	registerMailTriageBatchStub(reg, mailbox, []map[string]interface{}{
+		mailTriageBatchMessage("msg_a", "Subject A"),
+		mailTriageBatchMessage("msg_b", "Subject B"),
+		mailTriageBatchMessage("msg_c", "Subject C"),
+		mailTriageBatchMessage("msg_d", "Subject D"),
+		mailTriageBatchMessage("msg_e", "Subject E"),
+	})
+
+	args := []string{
+		"+triage",
+		"--as", "user",
+		"--mailbox", mailbox,
+		"--filter", `{"folder":"` + folderName + `"}`,
+		"--max", "5",
+		"--format", "json",
+	}
+	if err := runMountedMailShortcut(t, MailTriage, args, f, stdout); err != nil {
+		t.Fatalf("unexpected error running +triage (likely a second folders API call — the bug): %v", err)
+	}
+
+	data := decodeMailTriageJSONOutput(t, stdout)
+	messages := mailTriageMessagesFromOutput(t, data)
+	if len(messages) != 5 {
+		t.Fatalf("expected 5 messages across 2 pages, got %d (stdout=%s)", len(messages), stdout.String())
+	}
+	if got := data["has_more"]; got != false {
+		t.Fatalf("expected has_more=false after exhausting pages, got %v", got)
+	}
+	// All registered stubs (1 folders + 2 list pages + 1 batch_get) are
+	// non-reusable; reg.Verify (deferred above) asserts each was matched
+	// exactly once. Combined with the non-reusable folders stub, this is the
+	// proof that the folders list API was called exactly once across both
+	// pages — the core invariant the fix restores.
+}

shortcuts/minutes/minutes_search.go

@@ -308,6 +308,9 @@ var MinutesSearch = common.Shortcut{
 			"has_more":   data["has_more"],
 			"page_token": data["page_token"],
 		}
+		if notice, _ := data["notice"].(string); notice != "" {
+			outData["notice"] = notice
+		}
 
 		runtime.OutFormat(outData, &output.Meta{Count: len(rows)}, func(w io.Writer) {
 			if len(rows) == 0 {

shortcuts/minutes/minutes_search_test.go

@@ -609,6 +609,8 @@ func TestMinutesSearchExecuteShowsPaginationHintForTableFormat(t *testing.T) {
 func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 	t.Parallel()
 
+	const notice = "The query is too long and has been truncated to the first 50 characters for search."
+
 	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
 	reg.Register(&httpmock.Stub{
 		Method: "POST",
@@ -617,6 +619,7 @@ func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 			"code": 0,
 			"msg":  "ok",
 			"data": map[string]interface{}{
+				"notice": notice,
 				"items": []interface{}{
 					nil,
 					map[string]interface{}{
@@ -641,6 +644,9 @@ func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 	reg.Verify(t)
 
 	var envelope struct {
+		Data struct {
+			Notice string `json:"notice"`
+		} `json:"data"`
 		Meta struct {
 			Count int `json:"count"`
 		} `json:"meta"`
@@ -651,6 +657,9 @@ func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 	if envelope.Meta.Count != 1 {
 		t.Fatalf("meta.count = %d, want 1", envelope.Meta.Count)
 	}
+	if envelope.Data.Notice != notice {
+		t.Fatalf("data.notice = %q, want %q", envelope.Data.Notice, notice)
+	}
 }
 
 // TestMinuteSearchFieldExtractors verifies field extractors read populated metadata correctly.

shortcuts/okr/okr_batch_create.go

@@ -0,0 +1,385 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+// batchCreateKR represents a key result in the batch create input.
+type batchCreateKR struct {
+	Text    string   `json:"text"`
+	Mention []string `json:"mention,omitempty"`
+}
+
+// batchCreateObjective represents an objective in the batch create input.
+type batchCreateObjective struct {
+	Text    string          `json:"text"`
+	Mention []string        `json:"mention,omitempty"`
+	KRs     []batchCreateKR `json:"krs,omitempty"`
+}
+
+// createdObjective tracks a created objective and its KR IDs for output.
+// KRs are automatically deleted by the backend when the objective is deleted (no need to delete them separately during rollback).
+type createdObjective struct {
+	ObjectiveID string
+	KRIDs       []string // for output response only, not used in rollback
+}
+
+// parseBatchCreateInput parses and validates the JSON input.
+func parseBatchCreateInput(input string) ([]batchCreateObjective, error) {
+	var objectives []batchCreateObjective
+	if err := json.Unmarshal([]byte(input), &objectives); err != nil {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--input must be valid JSON array: %s", err).WithParam("--input").WithCause(err)
+	}
+	if len(objectives) == 0 {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--input must contain at least one objective").WithParam("--input")
+	}
+	for i, obj := range objectives {
+		if strings.TrimSpace(obj.Text) == "" {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "objective[%d].text is required and cannot be empty", i).WithParam("--input")
+		}
+		for j, kr := range obj.KRs {
+			if strings.TrimSpace(kr.Text) == "" {
+				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "objective[%d].krs[%d].text is required and cannot be empty", i, j).WithParam("--input")
+			}
+		}
+	}
+	return objectives, nil
+}
+
+// buildContentBlock converts text and mentions to a ContentBlock.
+func buildContentBlock(text string, mentions []string) *ContentBlock {
+	elements := make([]ContentParagraphElement, 0, len(mentions)+1)
+
+	// Add text element
+	textElem := ContentParagraphElement{
+		ParagraphElementType: ParagraphElementTypeTextRun.Ptr(),
+		TextRun: &ContentTextRun{
+			Text: &text,
+		},
+	}
+	elements = append(elements, textElem)
+
+	// Add mention elements
+	for _, mention := range mentions {
+		mentionElem := ContentParagraphElement{
+			ParagraphElementType: ParagraphElementTypeMention.Ptr(),
+			Mention: &ContentMention{
+				UserID: &mention,
+			},
+		}
+		elements = append(elements, mentionElem)
+	}
+
+	return &ContentBlock{
+		Blocks: []ContentBlockElement{
+			{
+				BlockElementType: BlockElementTypeParagraph.Ptr(),
+				Paragraph: &ContentParagraph{
+					Elements: elements,
+				},
+			},
+		},
+	}
+}
+
+// createObjective calls the API to create an objective.
+func createObjective(ctx context.Context, runtime *common.RuntimeContext, cycleID, userIDType string, obj batchCreateObjective) (string, error) {
+	content := buildContentBlock(obj.Text, obj.Mention)
+	body := map[string]interface{}{
+		"content": content,
+	}
+	queryParams := map[string]interface{}{
+		"cycle_id":     cycleID,
+		"user_id_type": userIDType,
+	}
+
+	path := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives", cycleID)
+	data, err := runtime.CallAPITyped("POST", path, queryParams, body)
+	if err != nil {
+		return "", wrapOkrNetworkErr(err, "failed to create objective")
+	}
+
+	objectiveID, ok := data["objective_id"].(string)
+	if !ok {
+		return "", errs.NewInternalError(errs.SubtypeUnknown, "create objective response missing objective_id")
+	}
+	return objectiveID, nil
+}
+
+// createKR calls the API to create a key result.
+func createKR(ctx context.Context, runtime *common.RuntimeContext, objectiveID, userIDType string, kr batchCreateKR) (string, error) {
+	content := buildContentBlock(kr.Text, kr.Mention)
+	body := map[string]interface{}{
+		"content": content,
+	}
+	queryParams := map[string]interface{}{
+		"objective_id": objectiveID,
+		"user_id_type": userIDType,
+	}
+
+	path := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results", objectiveID)
+	data, err := runtime.CallAPITyped("POST", path, queryParams, body)
+	if err != nil {
+		return "", wrapOkrNetworkErr(err, "failed to create key result")
+	}
+
+	krID, ok := data["key_result_id"].(string)
+	if !ok {
+		return "", errs.NewInternalError(errs.SubtypeUnknown, "create key result response missing key_result_id")
+	}
+	return krID, nil
+}
+
+// deleteObjective deletes an objective (used for rollback).
+func deleteObjective(ctx context.Context, runtime *common.RuntimeContext, objectiveID string) error {
+	queryParams := map[string]interface{}{
+		"objective_id": objectiveID,
+		"yes":          true,
+	}
+	path := fmt.Sprintf("/open-apis/okr/v2/objectives/%s", objectiveID)
+	_, err := runtime.CallAPITyped("DELETE", path, queryParams, nil)
+	if err != nil {
+		return wrapOkrNetworkErr(err, "failed to delete objective %s during rollback", objectiveID)
+	}
+	return nil
+}
+
+// rollback deletes created objectives in reverse order.
+// KRs are automatically deleted by the backend when the objective is deleted.
+func rollback(ctx context.Context, runtime *common.RuntimeContext, created []createdObjective) []error {
+	var errsList []error
+
+	// Iterate in reverse order
+	for i := len(created) - 1; i >= 0; i-- {
+		obj := created[i]
+
+		// Delete the objective (backend automatically deletes its KRs)
+		if err := deleteObjective(ctx, runtime, obj.ObjectiveID); err != nil {
+			//nolint:forbidigo // intermediate wrap for rollback error collection; final error is typed via buildRollbackError
+			errsList = append(errsList, fmt.Errorf("objective %s: %w", obj.ObjectiveID, err))
+		}
+
+		// Rate limiting between deletions
+		if i > 0 {
+			time.Sleep(500 * time.Millisecond)
+		}
+	}
+
+	return errsList
+}
+
+// OKRBatchCreate batch creates objectives and their key results.
+var OKRBatchCreate = common.Shortcut{
+	Service:     "okr",
+	Command:     "+batch-create",
+	Description: "Batch create OKR objectives and key results with rollback on failure",
+	Risk:        "write",
+	Scopes:      []string{"okr:okr.content:writeonly"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "cycle-id", Desc: "OKR cycle ID (int64)", Required: true},
+		{Name: "input", Desc: "JSON array of objectives: [{\"text\":\"...\",\"mention\":[\"...\"],\"krs\":[{\"text\":\"...\",\"mention\":[\"...\"]}]}]", Input: []string{common.File, common.Stdin}, Required: true},
+		{Name: "user-id-type", Default: "open_id", Desc: "user ID type: open_id | union_id | user_id"},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		cycleID := runtime.Str("cycle-id")
+		if id, err := strconv.ParseInt(cycleID, 10, 64); err != nil || id <= 0 {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--cycle-id must be a positive int64").WithParam("--cycle-id")
+		}
+
+		input := runtime.Str("input")
+		if err := common.RejectDangerousCharsTyped("--input", input); err != nil {
+			return err
+		}
+		if _, err := parseBatchCreateInput(input); err != nil {
+			return err
+		}
+
+		idType := runtime.Str("user-id-type")
+		if idType != "open_id" && idType != "union_id" && idType != "user_id" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--user-id-type must be one of: open_id | union_id | user_id").WithParam("--user-id-type")
+		}
+
+		return nil
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		cycleID := runtime.Str("cycle-id")
+		userIDType := runtime.Str("user-id-type")
+		objectives, _ := parseBatchCreateInput(runtime.Str("input"))
+
+		apis := common.NewDryRunAPI()
+
+		for i, obj := range objectives {
+			// Objective creation
+			objContent := buildContentBlock(obj.Text, obj.Mention)
+			objBody := map[string]interface{}{
+				"content": objContent,
+			}
+			objParams := map[string]interface{}{
+				"cycle_id":     cycleID,
+				"user_id_type": userIDType,
+			}
+			objPath := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives", cycleID)
+			apis = apis.
+				POST(objPath).
+				Params(objParams).
+				Body(objBody).
+				Desc(fmt.Sprintf("Create objective[%d]: %s", i, obj.Text))
+
+			// KR creations
+			for j, kr := range obj.KRs {
+				krContent := buildContentBlock(kr.Text, kr.Mention)
+				krBody := map[string]interface{}{
+					"content": krContent,
+				}
+				krParams := map[string]interface{}{
+					"objective_id": "<objective_id_from_previous_call>",
+					"user_id_type": userIDType,
+				}
+				krPath := "/open-apis/okr/v2/objectives/<objective_id>/key_results"
+				apis = apis.
+					POST(krPath).
+					Params(krParams).
+					Body(krBody).
+					Desc(fmt.Sprintf("Create objective[%d].krs[%d]: %s", i, j, kr.Text))
+			}
+		}
+
+		return apis
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		cycleID := runtime.Str("cycle-id")
+		userIDType := runtime.Str("user-id-type")
+		objectives, err := parseBatchCreateInput(runtime.Str("input"))
+		if err != nil {
+			return err
+		}
+
+		var created []createdObjective
+
+		for i, obj := range objectives {
+			// Rate limiting between objectives
+			if i > 0 {
+				time.Sleep(500 * time.Millisecond)
+			}
+
+			// Create objective
+			objectiveID, err := createObjective(ctx, runtime, cycleID, userIDType, obj)
+			if err != nil {
+				if len(created) == 0 {
+					return err
+				}
+				rollbackErrs := rollback(ctx, runtime, created)
+				return buildRollbackError(err, rollbackErrs, created)
+			}
+
+			createdObj := createdObjective{
+				ObjectiveID: objectiveID,
+			}
+
+			// Create KRs
+			for j, kr := range obj.KRs {
+				// Rate limiting between KRs
+				if j > 0 {
+					time.Sleep(500 * time.Millisecond)
+				}
+
+				krID, err := createKR(ctx, runtime, objectiveID, userIDType, kr)
+				if err != nil {
+					created = append(created, createdObj)
+					rollbackErrs := rollback(ctx, runtime, created)
+					return buildRollbackError(err, rollbackErrs, created)
+				}
+
+				createdObj.KRIDs = append(createdObj.KRIDs, krID)
+			}
+
+			created = append(created, createdObj)
+		}
+
+		// Build response
+		respCreated := make([]map[string]interface{}, 0, len(created))
+		for _, obj := range created {
+			respCreated = append(respCreated, map[string]interface{}{
+				"objective_id": obj.ObjectiveID,
+				"krs":          obj.KRIDs,
+			})
+		}
+
+		result := map[string]interface{}{
+			"ok":   true,
+			"data": map[string]interface{}{"created": respCreated},
+		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Successfully created %d objective(s)\n", len(created))
+			for i, obj := range created {
+				fmt.Fprintf(w, "Objective[%d] ID: %s (%d KR(s))\n", i, obj.ObjectiveID, len(obj.KRIDs))
+				for j, krID := range obj.KRIDs {
+					fmt.Fprintf(w, "  KR[%d] ID: %s\n", j, krID)
+				}
+			}
+		})
+
+		return nil
+	},
+}
+
+// buildRollbackError constructs an error that includes both the original failure
+// and any rollback failures, with a list of residual IDs that could not be cleaned up.
+// KRs are automatically deleted by the backend when the objective is deleted, so we only
+// need to track objective IDs for residual cleanup.
+func buildRollbackError(originalErr error, rollbackErrs []error, created []createdObjective) error {
+	var residualIDs []string
+
+	// Only collect residual IDs when rollback had failures
+	// If rollback succeeded (len(rollbackErrs) == 0), all objectives were deleted
+	if len(rollbackErrs) > 0 {
+		for _, obj := range created {
+			residualIDs = append(residualIDs, fmt.Sprintf("objective:%s", obj.ObjectiveID))
+		}
+	}
+
+	msg := fmt.Sprintf("batch create failed, rolling back: %v", originalErr)
+	if len(rollbackErrs) > 0 {
+		var rollbackMsgs []string
+		for _, e := range rollbackErrs {
+			rollbackMsgs = append(rollbackMsgs, e.Error())
+		}
+		msg += fmt.Sprintf("; rollback also had %d failure(s): %s", len(rollbackErrs), strings.Join(rollbackMsgs, "; "))
+	}
+	if len(residualIDs) > 0 {
+		msg += fmt.Sprintf("; residual objectives that may need manual cleanup (KRs auto-deleted with objective): %s", strings.Join(residualIDs, ", "))
+	}
+
+	// Preserve the original error's type information if it's already a typed error
+	if prob, ok := errs.ProblemOf(originalErr); ok {
+		switch prob.Category {
+		case errs.CategoryAPI:
+			return errs.NewAPIError(prob.Subtype, "%s", msg).WithCause(originalErr)
+		case errs.CategoryNetwork:
+			return errs.NewNetworkError(prob.Subtype, "%s", msg).WithCause(originalErr)
+		case errs.CategoryValidation:
+			return errs.NewValidationError(prob.Subtype, "%s", msg).WithCause(originalErr)
+		case errs.CategoryInternal:
+			return errs.NewInternalError(prob.Subtype, "%s", msg).WithCause(originalErr)
+		default:
+			return errs.NewInternalError(prob.Subtype, "%s", msg).WithCause(originalErr)
+		}
+	}
+
+	return errs.NewInternalError(errs.SubtypeUnknown, "%s", msg).WithCause(originalErr)
+}

shortcuts/okr/okr_batch_create_test.go

@@ -0,0 +1,593 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"bytes"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/spf13/cobra"
+)
+
+func batchCreateTestConfig(t *testing.T) *core.CliConfig {
+	t.Helper()
+	return &core.CliConfig{
+		AppID:     "test-okr-batch-create",
+		AppSecret: "secret-okr-batch-create",
+		Brand:     core.BrandFeishu,
+	}
+}
+
+func runBatchCreateShortcut(t *testing.T, f *cmdutil.Factory, stdout *bytes.Buffer, args []string) error {
+	t.Helper()
+	parent := &cobra.Command{Use: "okr"}
+	OKRBatchCreate.Mount(parent, f)
+	parent.SetArgs(args)
+	parent.SilenceErrors = true
+	parent.SilenceUsage = true
+	if stdout != nil {
+		stdout.Reset()
+	}
+	return parent.Execute()
+}
+
+const validBatchCreateInput = `[
+  {"text":"Objective 1","mention":["ou_123"],"krs":[{"text":"KR 1.1","mention":["ou_456"]}]},
+  {"text":"Objective 2","krs":[{"text":"KR 2.1"},{"text":"KR 2.2"}]}
+]`
+
+// --- Validate tests ---
+
+func TestBatchCreateValidate_MissingCycleID(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--input", validBatchCreateInput,
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "cycle-id") {
+		t.Fatalf("expected --cycle-id required error, got: %v", err)
+	}
+}
+
+func TestBatchCreateValidate_InvalidCycleID(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "abc",
+		"--input", validBatchCreateInput,
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --cycle-id")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--cycle-id" {
+		t.Fatalf("expected param --cycle-id, got %q", validationErr.Param)
+	}
+}
+
+func TestBatchCreateValidate_MissingInput(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "input") {
+		t.Fatalf("expected --input required error, got: %v", err)
+	}
+}
+
+func TestBatchCreateValidate_InvalidInputJSON(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", "not-json",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --input JSON")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--input" {
+		t.Fatalf("expected param --input, got %q", validationErr.Param)
+	}
+}
+
+func TestBatchCreateValidate_EmptyInputArray(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", "[]",
+	})
+	if err == nil {
+		t.Fatal("expected error for empty --input array")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--input" {
+		t.Fatalf("expected param --input, got %q", validationErr.Param)
+	}
+}
+
+func TestBatchCreateValidate_EmptyObjectiveText(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", `[{"text":"","krs":[{"text":"KR 1"}]}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for empty objective text")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--input" {
+		t.Fatalf("expected param --input, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "objective[0].text") {
+		t.Fatalf("expected error to mention objective[0].text, got: %v", err)
+	}
+}
+
+func TestBatchCreateValidate_EmptyKRText(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", `[{"text":"Obj 1","krs":[{"text":""}]}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for empty KR text")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--input" {
+		t.Fatalf("expected param --input, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "objective[0].krs[0].text") {
+		t.Fatalf("expected error to mention objective[0].krs[0].text, got: %v", err)
+	}
+}
+
+func TestBatchCreateValidate_InvalidUserIDType(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", validBatchCreateInput,
+		"--user-id-type", "invalid",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --user-id-type")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--user-id-type" {
+		t.Fatalf("expected param --user-id-type, got %q", validationErr.Param)
+	}
+}
+
+func TestBatchCreateValidate_Valid(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"objective_id": "100",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/objectives/100/key_results",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"key_result_id": "200",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"objective_id": "101",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/objectives/101/key_results",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"key_result_id": "201",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/objectives/101/key_results",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"key_result_id": "202",
+			},
+		},
+	})
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", validBatchCreateInput,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// --- DryRun tests ---
+
+func TestBatchCreateDryRun(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", validBatchCreateInput,
+		"--dry-run",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	output := stdout.String()
+	if !strings.Contains(output, "/open-apis/okr/v2/cycles/123/objectives") {
+		t.Fatalf("dry-run output should contain objective creation API path, got: %s", output)
+	}
+	if !strings.Contains(output, "POST") {
+		t.Fatalf("dry-run output should contain POST method, got: %s", output)
+	}
+	if !strings.Contains(output, "/open-apis/okr/v2/objectives/") || !strings.Contains(output, "/key_results") {
+		t.Fatalf("dry-run output should contain KR creation API path, got: %s", output)
+	}
+	// Verify content is in the body
+	if !strings.Contains(output, "Objective 1") {
+		t.Fatalf("dry-run output should contain objective text, got: %s", output)
+	}
+	if !strings.Contains(output, "KR 1.1") {
+		t.Fatalf("dry-run output should contain KR text, got: %s", output)
+	}
+}
+
+// --- Execute tests ---
+
+func TestBatchCreateExecute_Success(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"objective_id": "100",
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/objectives/100/key_results",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"key_result_id": "200",
+			},
+		},
+	})
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", `[{"text":"Obj 1","krs":[{"text":"KR 1"}]}]`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify output
+	data := decodeEnvelope(t, stdout)
+	ok, _ := data["ok"].(bool)
+	if !ok {
+		t.Fatal("expected ok=true in output")
+	}
+	dataField, _ := data["data"].(map[string]interface{})
+	created, _ := dataField["created"].([]interface{})
+	if len(created) != 1 {
+		t.Fatalf("expected 1 created objective, got %d", len(created))
+	}
+	obj, _ := created[0].(map[string]interface{})
+	if obj["objective_id"] != "100" {
+		t.Fatalf("expected objective_id=100, got %v", obj["objective_id"])
+	}
+	krs, _ := obj["krs"].([]interface{})
+	if len(krs) != 1 || krs[0] != "200" {
+		t.Fatalf("expected krs=[200], got %v", krs)
+	}
+}
+
+func TestBatchCreateExecute_APIErrorOnObjective(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Status: 400,
+		Body: map[string]interface{}{
+			"code": 1001001,
+			"msg":  "invalid parameters",
+		},
+	})
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", `[{"text":"Obj 1"}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for API failure")
+	}
+	// Should be a typed error from the API
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != "api" {
+		t.Fatalf("expected api category, got %q", prob.Category)
+	}
+}
+
+func TestBatchCreateExecute_APIErrorOnKR_TriggersRollback(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	// First objective creation succeeds
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"objective_id": "100",
+			},
+		},
+	})
+	// KR creation fails
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/objectives/100/key_results",
+		Status: 400,
+		Body: map[string]interface{}{
+			"code": 1001001,
+			"msg":  "invalid parameters",
+		},
+	})
+	// Rollback: delete the created objective
+	reg.Register(&httpmock.Stub{
+		Method: "DELETE",
+		URL:    "/open-apis/okr/v2/objectives/100",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"objective_id": "100",
+			},
+		},
+	})
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", `[{"text":"Obj 1","krs":[{"text":"KR 1"}]}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for KR creation failure")
+	}
+	// Error should mention rollback
+	if !strings.Contains(err.Error(), "rolling back") && !strings.Contains(err.Error(), "rollback") {
+		t.Fatalf("expected error to mention rollback, got: %v", err)
+	}
+	// Assert typed error metadata
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryAPI {
+		t.Fatalf("expected api category (preserved from original error), got %q", prob.Category)
+	}
+	// Assert cause preservation
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("expected error to wrap APIError, got: %T", err)
+	}
+	if !errors.Is(err, apiErr) {
+		t.Fatal("expected errors.Is to find the wrapped APIError")
+	}
+}
+
+func TestBatchCreateExecute_RollbackDeleteFails(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, batchCreateTestConfig(t))
+	// Objective creation succeeds
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"objective_id": "100",
+			},
+		},
+	})
+	// KR creation fails
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/okr/v2/objectives/100/key_results",
+		Status: 400,
+		Body: map[string]interface{}{
+			"code": 1001001,
+			"msg":  "invalid parameters",
+		},
+	})
+	// Rollback delete also fails
+	reg.Register(&httpmock.Stub{
+		Method: "DELETE",
+		URL:    "/open-apis/okr/v2/objectives/100",
+		Status: 500,
+		Body: map[string]interface{}{
+			"code": 9999999,
+			"msg":  "internal error",
+		},
+	})
+	err := runBatchCreateShortcut(t, f, stdout, []string{
+		"+batch-create",
+		"--cycle-id", "123",
+		"--input", `[{"text":"Obj 1","krs":[{"text":"KR 1"}]}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for KR creation failure")
+	}
+	// Error should mention residual resources
+	if !strings.Contains(err.Error(), "residual") && !strings.Contains(err.Error(), "manual cleanup") {
+		t.Fatalf("expected error to mention residual resources, got: %v", err)
+	}
+	if !strings.Contains(err.Error(), "objective:100") {
+		t.Fatalf("expected error to list residual objective ID, got: %v", err)
+	}
+}
+
+// --- Unit tests for helper functions ---
+
+func TestParseBatchCreateInput_Valid(t *testing.T) {
+	t.Parallel()
+	input := `[{"text":"Obj 1","mention":["ou_123"],"krs":[{"text":"KR 1","mention":["ou_456"]}]}]`
+	objs, err := parseBatchCreateInput(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(objs) != 1 {
+		t.Fatalf("expected 1 objective, got %d", len(objs))
+	}
+	if objs[0].Text != "Obj 1" {
+		t.Fatalf("expected text 'Obj 1', got %q", objs[0].Text)
+	}
+	if len(objs[0].Mention) != 1 || objs[0].Mention[0] != "ou_123" {
+		t.Fatalf("expected mention ['ou_123'], got %v", objs[0].Mention)
+	}
+	if len(objs[0].KRs) != 1 {
+		t.Fatalf("expected 1 KR, got %d", len(objs[0].KRs))
+	}
+	if objs[0].KRs[0].Text != "KR 1" {
+		t.Fatalf("expected KR text 'KR 1', got %q", objs[0].KRs[0].Text)
+	}
+}
+
+func TestBuildContentBlock(t *testing.T) {
+	t.Parallel()
+	cb := buildContentBlock("Test text", []string{"ou_123", "ou_456"})
+	if cb == nil {
+		t.Fatal("expected non-nil ContentBlock")
+	}
+	if len(cb.Blocks) != 1 {
+		t.Fatalf("expected 1 block, got %d", len(cb.Blocks))
+	}
+	block := cb.Blocks[0]
+	if block.BlockElementType == nil || *block.BlockElementType != BlockElementTypeParagraph {
+		t.Fatalf("expected paragraph block type")
+	}
+	if block.Paragraph == nil {
+		t.Fatal("expected non-nil paragraph")
+	}
+	// Should have 3 elements: 1 text + 2 mentions
+	if len(block.Paragraph.Elements) != 3 {
+		t.Fatalf("expected 3 paragraph elements, got %d", len(block.Paragraph.Elements))
+	}
+	// First element should be textRun
+	if block.Paragraph.Elements[0].ParagraphElementType == nil ||
+		*block.Paragraph.Elements[0].ParagraphElementType != ParagraphElementTypeTextRun {
+		t.Fatal("expected first element to be textRun")
+	}
+	if block.Paragraph.Elements[0].TextRun == nil || *block.Paragraph.Elements[0].TextRun.Text != "Test text" {
+		t.Fatalf("expected text 'Test text', got %v", block.Paragraph.Elements[0].TextRun)
+	}
+	// Second and third should be mentions
+	for i := 1; i <= 2; i++ {
+		if block.Paragraph.Elements[i].ParagraphElementType == nil ||
+			*block.Paragraph.Elements[i].ParagraphElementType != ParagraphElementTypeMention {
+			t.Fatalf("expected element %d to be mention", i)
+		}
+	}
+}

shortcuts/okr/okr_indicator_update.go

@@ -0,0 +1,178 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+// parseIndicatorValue parses and validates the indicator value.
+func parseIndicatorValue(valueStr string) (float64, error) {
+	value, err := strconv.ParseFloat(valueStr, 64)
+	if err != nil {
+		return 0, errs.NewValidationError(errs.SubtypeInvalidArgument, "--value must be a number between -99999999999 and 99999999999").WithParam("--value").WithCause(err)
+	}
+	if math.IsNaN(value) || math.IsInf(value, 0) || value < -99999999999 || value > 99999999999 {
+		return 0, errs.NewValidationError(errs.SubtypeInvalidArgument, "--value must be a number between -99999999999 and 99999999999").WithParam("--value")
+	}
+	return value, nil
+}
+
+// fetchIndicatorID fetches the indicator ID for an objective or key result.
+// The indicators.list API returns a single indicator object (not a list),
+// which always exists (may be a default empty indicator).
+func fetchIndicatorID(ctx context.Context, runtime *common.RuntimeContext, level string, id string) (string, error) {
+	var path string
+	var params map[string]interface{}
+
+	if level == "objective" {
+		path = fmt.Sprintf("/open-apis/okr/v2/objectives/%s/indicators", id)
+		params = map[string]interface{}{"page_size": 100}
+	} else {
+		path = fmt.Sprintf("/open-apis/okr/v2/key_results/%s/indicators", id)
+		params = map[string]interface{}{"page_size": 100}
+	}
+
+	data, err := runtime.CallAPITyped("GET", path, params, nil)
+	if err != nil {
+		return "", wrapOkrNetworkErr(err, "failed to fetch indicators")
+	}
+
+	// Parse response to get indicator ID
+	// Response format: {"indicator": {"id": "...", ...}} (single object, not a list)
+	indicator, ok := data["indicator"].(map[string]interface{})
+	if !ok {
+		return "", errs.NewInternalError(errs.SubtypeUnknown, "indicator field not found in response")
+	}
+
+	indicatorID, ok := indicator["id"].(string)
+	if !ok || indicatorID == "" {
+		return "", errs.NewInternalError(errs.SubtypeUnknown, "indicator ID not found or empty")
+	}
+
+	return indicatorID, nil
+}
+
+// OKRIndicatorUpdate updates the current value of an indicator for an objective or key result.
+var OKRIndicatorUpdate = common.Shortcut{
+	Service:     "okr",
+	Command:     "+indicator-update",
+	Description: "Update the indicator current value for an objective or key result",
+	Risk:        "write",
+	Scopes:      []string{"okr:okr.content:writeonly"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "level", Desc: "level to update: objective | key-result, Required.", Enum: []string{"objective", "key-result"}},
+		{Name: "id", Desc: "objective or key result ID (int64), Required."},
+		{Name: "value", Desc: "new current value for the indicator (number), Required."},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		level := runtime.Str("level")
+		if level == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--level is required").WithParam("--level")
+		}
+		if level != "objective" && level != "key-result" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--level must be one of: objective | key-result").WithParam("--level")
+		}
+
+		id := runtime.Str("id")
+		if id == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--id is required").WithParam("--id")
+		}
+		if _, err := strconv.ParseInt(id, 10, 64); err != nil {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--id must be a valid int64").WithParam("--id")
+		}
+		if runtime.Str("value") == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--value is required").WithParam("--value")
+		}
+		if _, err := parseIndicatorValue(runtime.Str("value")); err != nil {
+			return err
+		}
+
+		return nil
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		level := runtime.Str("level")
+		id := runtime.Str("id")
+		value, _ := parseIndicatorValue(runtime.Str("value"))
+
+		apis := common.NewDryRunAPI()
+
+		var listPath string
+		if level == "objective" {
+			listPath = fmt.Sprintf("/open-apis/okr/v2/objectives/%s/indicators", id)
+		} else {
+			listPath = fmt.Sprintf("/open-apis/okr/v2/key_results/%s/indicators", id)
+		}
+
+		// First API: fetch indicator list
+		apis = apis.
+			GET(listPath).
+			Params(map[string]interface{}{"page_size": 100}).
+			Desc(fmt.Sprintf("Fetch indicators for the %s to get indicator ID", level))
+
+		// Second API: patch indicator value
+		patchPath := "/open-apis/okr/v2/indicators/:indicator_id"
+		patchBody := map[string]interface{}{
+			"current_value": value,
+		}
+		apis = apis.
+			PATCH(patchPath).
+			Body(patchBody).
+			Set("indicator_id", "<indicator_id_from_list>").
+			Desc("Update indicator current value")
+
+		return apis
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		level := runtime.Str("level")
+		id := runtime.Str("id")
+		value, err := parseIndicatorValue(runtime.Str("value"))
+		if err != nil {
+			return err
+		}
+
+		// Step 1: Fetch indicator ID
+		indicatorID, err := fetchIndicatorID(ctx, runtime, level, id)
+		if err != nil {
+			return err
+		}
+
+		// Step 2: Update indicator value
+		patchPath := fmt.Sprintf("/open-apis/okr/v2/indicators/%s", indicatorID)
+		patchBody := map[string]interface{}{
+			"current_value": value,
+		}
+
+		_, err = runtime.CallAPITyped("PATCH", patchPath, nil, patchBody)
+		if err != nil {
+			return wrapOkrNetworkErr(err, "failed to update indicator value")
+		}
+
+		// Build response
+		result := map[string]interface{}{
+			"indicator_id":  indicatorID,
+			"current_value": value,
+			"level":         level,
+			"target_id":     id,
+		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Updated Indicator [%s]\n", indicatorID)
+			fmt.Fprintf(w, "  Level: %s\n", level)
+			fmt.Fprintf(w, "  Target ID: %s\n", id)
+			fmt.Fprintf(w, "  Current Value: %v\n", value)
+		})
+
+		return nil
+	},
+}

shortcuts/okr/okr_indicator_update_test.go

@@ -0,0 +1,391 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/spf13/cobra"
+)
+
+func indicatorUpdateTestConfig(t *testing.T) *core.CliConfig {
+	t.Helper()
+	return &core.CliConfig{
+		AppID:     "test-okr-indicator-update",
+		AppSecret: "secret-okr-indicator-update",
+		Brand:     core.BrandFeishu,
+	}
+}
+
+func runIndicatorUpdateShortcut(t *testing.T, f *cmdutil.Factory, stdout *bytes.Buffer, args []string) error {
+	t.Helper()
+	parent := &cobra.Command{Use: "okr"}
+	OKRIndicatorUpdate.Mount(parent, f)
+	parent.SetArgs(args)
+	parent.SilenceErrors = true
+	parent.SilenceUsage = true
+	if stdout != nil {
+		stdout.Reset()
+	}
+	return parent.Execute()
+}
+
+// --- Validate tests ---
+
+func TestIndicatorUpdateValidate_MissingLevel(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--id", "123",
+		"--value", "50",
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "level") {
+		t.Fatalf("expected --level required error, got: %v", err)
+	}
+}
+
+func TestIndicatorUpdateValidate_InvalidLevel(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "invalid",
+		"--id", "123",
+		"--value", "50",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid level")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--level" {
+		t.Fatalf("expected param --level, got %q", validationErr.Param)
+	}
+}
+
+func TestIndicatorUpdateValidate_MissingID(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--value", "50",
+	})
+	if err == nil || !strings.Contains(err.Error(), "id") {
+		t.Fatalf("expected --id required error, got: %v", err)
+	}
+}
+
+func TestIndicatorUpdateValidate_InvalidID(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "not-a-number",
+		"--value", "50",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid id")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--id" {
+		t.Fatalf("expected param --id, got %q", validationErr.Param)
+	}
+}
+
+func TestIndicatorUpdateValidate_MissingValue(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "123",
+	})
+	if err == nil || !strings.Contains(err.Error(), "value") {
+		t.Fatalf("expected --value required error, got: %v", err)
+	}
+}
+
+func TestIndicatorUpdateValidate_InvalidValue(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "123",
+		"--value", "not-a-number",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid value")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--value" {
+		t.Fatalf("expected param --value, got %q", validationErr.Param)
+	}
+}
+
+func TestIndicatorUpdateValidate_Valid(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	// Mock fetch indicators
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/objectives/123/indicators",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"indicator": map[string]interface{}{
+					"id": "ind-456",
+				},
+			},
+		},
+	})
+	// Mock patch indicator
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/okr/v2/indicators/ind-456",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+		},
+	})
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "123",
+		"--value", "75.5",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// --- Execute tests ---
+
+func TestIndicatorUpdateExecute_Objectives_Success(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	// Mock fetch indicators
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/objectives/123/indicators",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"indicator": map[string]interface{}{
+					"id": "ind-456",
+				},
+			},
+		},
+	})
+	// Mock patch indicator
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/okr/v2/indicators/ind-456",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+		},
+		BodyFilter: func(body []byte) bool {
+			var data map[string]interface{}
+			if err := json.Unmarshal(body, &data); err != nil {
+				return false
+			}
+			val, ok := data["current_value"].(float64)
+			return ok && val == 75.5
+		},
+	})
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "123",
+		"--value", "75.5",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestIndicatorUpdateExecute_KeyResults_Success(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	// Mock fetch indicators
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/key_results/456/indicators",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"indicator": map[string]interface{}{
+					"id": "ind-789",
+				},
+			},
+		},
+	})
+	// Mock patch indicator
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/okr/v2/indicators/ind-789",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+		},
+	})
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "key-result",
+		"--id", "456",
+		"--value", "100",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestIndicatorUpdateExecute_FetchAPIError(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	// Mock fetch indicators - API error
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/objectives/123/indicators",
+		Body: map[string]interface{}{
+			"code": 9999,
+			"msg":  "fetch error",
+		},
+	})
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "123",
+		"--value", "50",
+	})
+	if err == nil {
+		t.Fatal("expected error for fetch API failure")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryAPI {
+		t.Fatalf("expected CategoryAPI, got %q", prob.Category)
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("expected error to be *errs.APIError, got: %T", err)
+	}
+	if !errors.Is(err, apiErr) {
+		t.Fatal("errors.Is should find the APIError in the chain")
+	}
+}
+
+func TestIndicatorUpdateExecute_PatchAPIError(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, indicatorUpdateTestConfig(t))
+	// Mock fetch indicators
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/objectives/123/indicators",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"indicator": map[string]interface{}{
+					"id": "ind-456",
+				},
+			},
+		},
+	})
+	// Mock patch indicator - API error
+	reg.Register(&httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/okr/v2/indicators/ind-456",
+		Body: map[string]interface{}{
+			"code": 9999,
+			"msg":  "patch error",
+		},
+	})
+	err := runIndicatorUpdateShortcut(t, f, stdout, []string{
+		"+indicator-update",
+		"--level", "objective",
+		"--id", "123",
+		"--value", "50",
+	})
+	if err == nil {
+		t.Fatal("expected error for patch API failure")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryAPI {
+		t.Fatalf("expected CategoryAPI, got %q", prob.Category)
+	}
+	var apiErr *errs.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("expected error to be *errs.APIError, got: %T", err)
+	}
+	if !errors.Is(err, apiErr) {
+		t.Fatal("errors.Is should find the APIError in the chain")
+	}
+}
+
+// --- parseIndicatorValue tests ---
+
+func TestParseIndicatorValue_Valid(t *testing.T) {
+	t.Parallel()
+	tests := []string{"0", "100", "75.5", "-10", "0.001", "99999999999"}
+	for _, v := range tests {
+		result, err := parseIndicatorValue(v)
+		if err != nil {
+			t.Fatalf("expected no error for %q, got: %v", v, err)
+		}
+		_ = result
+	}
+}
+
+func TestParseIndicatorValue_Invalid(t *testing.T) {
+	t.Parallel()
+	tests := []string{"", "abc", "1e100000", "100000000000"}
+	for _, v := range tests {
+		_, err := parseIndicatorValue(v)
+		if err == nil {
+			t.Fatalf("expected error for %q", v)
+		}
+	}
+}

shortcuts/okr/okr_reorder.go

@@ -0,0 +1,448 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+// reorderItem is the interface for items that have an ID.
+type reorderItem interface {
+	GetID() string
+}
+
+// reorderOp represents a single reorder operation.
+type reorderOp struct {
+	ID       string `json:"id"`
+	Position int32  `json:"position"`
+}
+
+// parseReorderOps parses and validates the --ops JSON array.
+func parseReorderOps(opsStr string) ([]reorderOp, error) {
+	var ops []reorderOp
+	if err := json.Unmarshal([]byte(opsStr), &ops); err != nil {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--ops must be valid JSON array: %s", err).WithParam("--ops").WithCause(err)
+	}
+	if len(ops) == 0 {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--ops must contain at least one operation").WithParam("--ops")
+	}
+
+	seen := make(map[string]bool)
+	seenPos := make(map[int32]bool)
+	for i, op := range ops {
+		if strings.TrimSpace(op.ID) == "" {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "ops[%d].id is required and cannot be empty", i).WithParam("--ops")
+		}
+		if op.Position <= 0 {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "ops[%d].position must be a positive integer", i).WithParam("--ops")
+		}
+		if seen[op.ID] {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "duplicate id %q in --ops", op.ID).WithParam("--ops")
+		}
+		if seenPos[op.Position] {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "duplicate position %d in --ops", op.Position).WithParam("--ops")
+		}
+		seen[op.ID] = true
+		seenPos[op.Position] = true
+	}
+	return ops, nil
+}
+
+// fetchObjectives fetches all objectives in a cycle.
+func fetchObjectives(ctx context.Context, runtime *common.RuntimeContext, cycleID string) ([]Objective, error) {
+	queryParams := map[string]interface{}{"page_size": "100"}
+	var objectives []Objective
+	page := 0
+
+	for {
+		if page > 0 {
+			select {
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			case <-time.After(500 * time.Millisecond):
+			}
+		}
+		page++
+
+		path := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives", cycleID)
+		data, err := runtime.CallAPITyped("GET", path, queryParams, nil)
+		if err != nil {
+			return nil, wrapOkrNetworkErr(err, "failed to fetch objectives")
+		}
+
+		itemsRaw, _ := data["items"].([]interface{})
+		for _, item := range itemsRaw {
+			raw, err := json.Marshal(item)
+			if err != nil {
+				continue
+			}
+			var obj Objective
+			if err := json.Unmarshal(raw, &obj); err != nil {
+				continue
+			}
+			objectives = append(objectives, obj)
+		}
+
+		hasMore, pageToken := common.PaginationMeta(data)
+		if !hasMore || pageToken == "" {
+			break
+		}
+		queryParams["page_token"] = pageToken
+	}
+
+	// Sort objectives by position
+	sort.Slice(objectives, func(i, j int) bool {
+		pi := int32(0)
+		if objectives[i].Position != nil {
+			pi = *objectives[i].Position
+		}
+		pj := int32(0)
+		if objectives[j].Position != nil {
+			pj = *objectives[j].Position
+		}
+		return pi < pj
+	})
+
+	return objectives, nil
+}
+
+// fetchKeyResults fetches all key results for an objective.
+func fetchKeyResults(ctx context.Context, runtime *common.RuntimeContext, objectiveID string) ([]KeyResult, error) {
+	queryParams := map[string]interface{}{"page_size": "100"}
+	var keyResults []KeyResult
+	page := 0
+
+	for {
+		if page > 0 {
+			select {
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			case <-time.After(500 * time.Millisecond):
+			}
+		}
+		page++
+
+		path := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results", objectiveID)
+		data, err := runtime.CallAPITyped("GET", path, queryParams, nil)
+		if err != nil {
+			return nil, wrapOkrNetworkErr(err, "failed to fetch key results")
+		}
+
+		itemsRaw, _ := data["items"].([]interface{})
+		for _, item := range itemsRaw {
+			raw, err := json.Marshal(item)
+			if err != nil {
+				continue
+			}
+			var kr KeyResult
+			if err := json.Unmarshal(raw, &kr); err != nil {
+				continue
+			}
+			keyResults = append(keyResults, kr)
+		}
+
+		hasMore, pageToken := common.PaginationMeta(data)
+		if !hasMore || pageToken == "" {
+			break
+		}
+		queryParams["page_token"] = pageToken
+	}
+
+	// Sort key results by position
+	sort.Slice(keyResults, func(i, j int) bool {
+		pi := int32(0)
+		if keyResults[i].Position != nil {
+			pi = *keyResults[i].Position
+		}
+		pj := int32(0)
+		if keyResults[j].Position != nil {
+			pj = *keyResults[j].Position
+		}
+		return pi < pj
+	})
+
+	return keyResults, nil
+}
+
+// buildReorderedIDs builds the complete ordered ID list from current items and reorder ops.
+// Positions are treated as 1-indexed placement keys stored in a map (safe for large values).
+// Items are first placed at user-specified positions, remaining items fill empty slots
+// in original order starting from position 1, and final output is sorted by position.
+func buildReorderedIDs[T reorderItem](items []T, ops []reorderOp, total int) ([]string, error) {
+	// Create a map of ID to current position
+	idToPos := make(map[string]int)
+	for i, item := range items {
+		idToPos[item.GetID()] = i
+	}
+
+	// Validate all ops IDs exist
+	for _, op := range ops {
+		if _, ok := idToPos[op.ID]; !ok {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "id %q not found in current list", op.ID).WithParam("--ops")
+		}
+	}
+
+	// Use map to store position -> ID (1-indexed, safe for large position values)
+	posToID := make(map[int]string)
+	used := make(map[string]bool)
+	for _, op := range ops {
+		posToID[int(op.Position)] = op.ID
+		used[op.ID] = true
+	}
+
+	// Collect unused items in original order
+	var unused []string
+	for _, item := range items {
+		id := item.GetID()
+		if !used[id] {
+			unused = append(unused, id)
+		}
+	}
+
+	// Fill empty slots starting from position 1, in original order
+	unusedIdx := 0
+	for pos := 1; unusedIdx < len(unused); pos++ {
+		if _, occupied := posToID[pos]; !occupied {
+			posToID[pos] = unused[unusedIdx]
+			unusedIdx++
+		}
+	}
+
+	// Collect all positions, sort them, and build result in position order
+	positions := make([]int, 0, len(posToID))
+	for pos := range posToID {
+		positions = append(positions, pos)
+	}
+	sort.Ints(positions)
+
+	result := make([]string, 0, len(positions))
+	for _, pos := range positions {
+		result = append(result, posToID[pos])
+	}
+
+	return result, nil
+}
+
+// GetID implements the interface for Objective.
+func (o Objective) GetID() string { return o.ID }
+
+// GetID implements the interface for KeyResult.
+func (k KeyResult) GetID() string { return k.ID }
+
+// OKRReorder adjusts the position of objectives or key results.
+var OKRReorder = common.Shortcut{
+	Service:     "okr",
+	Command:     "+reorder",
+	Description: "Adjust the position (order) of OKR objectives or key results",
+	Risk:        "write",
+	Scopes:      []string{"okr:okr.content:writeonly"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "level", Desc: "level to reorder: objective | key-result, Required.", Enum: []string{"objective", "key-result"}},
+		{Name: "cycle-id", Desc: "OKR cycle ID (int64), Required."},
+		{Name: "objective-id", Desc: "objective ID (required when --level=key-result)"},
+		{Name: "ops", Desc: "JSON array of reorder operations: [{\"id\":\"...\",\"position\":1}], Required.", Input: []string{common.File, common.Stdin}},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		level := runtime.Str("level")
+		if strings.TrimSpace(level) == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--level is required").WithParam("--level")
+		}
+		if level != "objective" && level != "key-result" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--level must be one of: objective | key-result").WithParam("--level")
+		}
+
+		cycleID := runtime.Str("cycle-id")
+		if strings.TrimSpace(cycleID) == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--cycle-id is required").WithParam("--cycle-id")
+		}
+		if id, err := strconv.ParseInt(cycleID, 10, 64); err != nil || id <= 0 {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--cycle-id must be a positive int64").WithParam("--cycle-id")
+		}
+
+		if level == "key-result" {
+			objID := runtime.Str("objective-id")
+			if objID == "" {
+				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--objective-id is required when --level=key-result").WithParam("--objective-id")
+			}
+			if id, err := strconv.ParseInt(objID, 10, 64); err != nil || id <= 0 {
+				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--objective-id must be a positive int64").WithParam("--objective-id")
+			}
+		}
+
+		opsStr := runtime.Str("ops")
+		if strings.TrimSpace(opsStr) == "" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--ops is required").WithParam("--ops")
+		}
+		if err := common.RejectDangerousCharsTyped("--ops", opsStr); err != nil {
+			return err
+		}
+		if _, err := parseReorderOps(opsStr); err != nil {
+			return err
+		}
+
+		return nil
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		level := runtime.Str("level")
+		cycleID := runtime.Str("cycle-id")
+		objectiveID := runtime.Str("objective-id")
+		ops, _ := parseReorderOps(runtime.Str("ops"))
+
+		apis := common.NewDryRunAPI()
+
+		if level == "objective" {
+			// First fetch objectives
+			listParams := map[string]interface{}{
+				"page_size": 100,
+			}
+			listPath := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives", cycleID)
+			apis = apis.
+				GET(listPath).
+				Params(listParams).
+				Desc("Fetch all objectives in the cycle to determine current order")
+
+			// Then reorder
+			reorderParams := map[string]interface{}{
+				"cycle_id": cycleID,
+			}
+			// Build sample body with placeholder IDs
+			objectiveIDs := make([]string, 0, len(ops))
+			for _, op := range ops {
+				objectiveIDs = append(objectiveIDs, op.ID)
+			}
+			reorderBody := map[string]interface{}{
+				"objective_ids": objectiveIDs,
+			}
+			reorderPath := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives_position", cycleID)
+			apis = apis.
+				PUT(reorderPath).
+				Params(reorderParams).
+				Body(reorderBody).
+				Desc("Update objective positions (full list sent, not just changes)")
+		} else {
+			// key-result level
+			listParams := map[string]interface{}{
+				"page_size": 100,
+			}
+			listPath := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results", objectiveID)
+			apis = apis.
+				GET(listPath).
+				Params(listParams).
+				Desc("Fetch all key results for the objective to determine current order")
+
+			reorderParams := map[string]interface{}{
+				"objective_id": objectiveID,
+			}
+			// Build sample body with placeholder IDs
+			keyResultIDs := make([]string, 0, len(ops))
+			for _, op := range ops {
+				keyResultIDs = append(keyResultIDs, op.ID)
+			}
+			reorderBody := map[string]interface{}{
+				"key_result_ids": keyResultIDs,
+			}
+			reorderPath := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results_position", objectiveID)
+			apis = apis.
+				PUT(reorderPath).
+				Params(reorderParams).
+				Body(reorderBody).
+				Desc("Update key result positions (full list sent, not just changes)")
+		}
+
+		return apis
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		level := runtime.Str("level")
+		cycleID := runtime.Str("cycle-id")
+		objectiveID := runtime.Str("objective-id")
+		ops, err := parseReorderOps(runtime.Str("ops"))
+		if err != nil {
+			return err
+		}
+
+		var reorderedIDs []string
+		var total int
+
+		if level == "objective" {
+			objectives, err := fetchObjectives(ctx, runtime, cycleID)
+			if err != nil {
+				return err
+			}
+			total = len(objectives)
+
+			reorderedIDs, err = buildReorderedIDs(objectives, ops, total)
+			if err != nil {
+				return err
+			}
+
+			// Submit reorder
+			params := map[string]interface{}{
+				"cycle_id": cycleID,
+			}
+			body := map[string]interface{}{
+				"objective_ids": reorderedIDs,
+			}
+			path := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives_position", cycleID)
+			_, err = runtime.CallAPITyped("PUT", path, params, body)
+			if err != nil {
+				return wrapOkrNetworkErr(err, "failed to update objective positions")
+			}
+		} else {
+			// key-result level
+			keyResults, err := fetchKeyResults(ctx, runtime, objectiveID)
+			if err != nil {
+				return err
+			}
+			total = len(keyResults)
+
+			reorderedIDs, err = buildReorderedIDs(keyResults, ops, total)
+			if err != nil {
+				return err
+			}
+
+			// Submit reorder
+			params := map[string]interface{}{
+				"objective_id": objectiveID,
+			}
+			body := map[string]interface{}{
+				"key_result_ids": reorderedIDs,
+			}
+			path := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results_position", objectiveID)
+			_, err = runtime.CallAPITyped("PUT", path, params, body)
+			if err != nil {
+				return wrapOkrNetworkErr(err, "failed to update key result positions")
+			}
+		}
+
+		// Build response
+		result := map[string]interface{}{
+			"level":    level,
+			"cycle_id": cycleID,
+			"total":    total,
+			"ordered":  reorderedIDs,
+		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Successfully reordered %d %s(s)\n", total, level)
+			fmt.Fprintln(w, "New order:")
+			for i, id := range reorderedIDs {
+				fmt.Fprintf(w, "  Position %d: %s\n", i+1, id)
+			}
+		})
+
+		return nil
+	},
+}

shortcuts/okr/okr_reorder_test.go

@@ -0,0 +1,712 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/spf13/cobra"
+)
+
+// testReorderItem implements reorderItem for testing.
+type testReorderItem struct {
+	id string
+}
+
+func (t testReorderItem) GetID() string { return t.id }
+
+func reorderTestConfig(t *testing.T) *core.CliConfig {
+	t.Helper()
+	return &core.CliConfig{
+		AppID:     "test-okr-reorder",
+		AppSecret: "secret-okr-reorder",
+		Brand:     core.BrandFeishu,
+	}
+}
+
+func runReorderShortcut(t *testing.T, f *cmdutil.Factory, stdout *bytes.Buffer, args []string) error {
+	t.Helper()
+	parent := &cobra.Command{Use: "okr"}
+	OKRReorder.Mount(parent, f)
+	parent.SetArgs(args)
+	parent.SilenceErrors = true
+	parent.SilenceUsage = true
+	if stdout != nil {
+		stdout.Reset()
+	}
+	return parent.Execute()
+}
+
+// --- Validate tests ---
+
+func TestReorderValidate_MissingLevel(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":1}]`,
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "level") {
+		t.Fatalf("expected --level required error, got: %v", err)
+	}
+}
+
+func TestReorderValidate_InvalidLevel(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "invalid",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":1}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --level")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--level" {
+		t.Fatalf("expected param --level, got %q", validationErr.Param)
+	}
+}
+
+func TestReorderValidate_MissingCycleID(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--ops", `[{"id":"1","position":1}]`,
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "cycle-id") {
+		t.Fatalf("expected --cycle-id required error, got: %v", err)
+	}
+}
+
+func TestReorderValidate_MissingObjectiveIDForKRLevel(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "key-result",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":1}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for missing --objective-id when --level=key-result")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--objective-id" {
+		t.Fatalf("expected param --objective-id, got %q", validationErr.Param)
+	}
+}
+
+func TestReorderValidate_MissingOps(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "ops") {
+		t.Fatalf("expected --ops required error, got: %v", err)
+	}
+}
+
+func TestReorderValidate_InvalidOpsJSON(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", "not-json",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --ops JSON")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--ops" {
+		t.Fatalf("expected param --ops, got %q", validationErr.Param)
+	}
+}
+
+func TestReorderValidate_EmptyOpsArray(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", "[]",
+	})
+	if err == nil {
+		t.Fatal("expected error for empty --ops array")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--ops" {
+		t.Fatalf("expected param --ops, got %q", validationErr.Param)
+	}
+}
+
+func TestReorderValidate_DuplicateID(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":1},{"id":"1","position":2}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for duplicate id in --ops")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--ops" {
+		t.Fatalf("expected param --ops, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "duplicate id") {
+		t.Fatalf("expected error to mention duplicate id, got: %v", err)
+	}
+}
+
+func TestReorderValidate_DuplicatePosition(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":1},{"id":"2","position":1}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for duplicate position in --ops")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--ops" {
+		t.Fatalf("expected param --ops, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "duplicate position") {
+		t.Fatalf("expected error to mention duplicate position, got: %v", err)
+	}
+}
+
+func TestReorderValidate_NegativePosition(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":0}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for position <= 0")
+	}
+	_, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	validationErr, ok := err.(*errs.ValidationError)
+	if !ok {
+		t.Fatalf("expected ValidationError, got: %T", err)
+	}
+	if validationErr.Param != "--ops" {
+		t.Fatalf("expected param --ops, got %q", validationErr.Param)
+	}
+}
+
+// --- DryRun tests ---
+
+func TestReorderDryRun_Objectives(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":2},{"id":"2","position":1}]`,
+		"--dry-run",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	output := stdout.String()
+	if !strings.Contains(output, "/open-apis/okr/v2/cycles/123/objectives") {
+		t.Fatalf("dry-run output should contain objectives list API path, got: %s", output)
+	}
+	if !strings.Contains(output, "GET") {
+		t.Fatalf("dry-run output should contain GET method for list, got: %s", output)
+	}
+	if !strings.Contains(output, "/open-apis/okr/v2/cycles/123/objectives_position") {
+		t.Fatalf("dry-run output should contain position update API path, got: %s", output)
+	}
+	if !strings.Contains(output, "PUT") {
+		t.Fatalf("dry-run output should contain PUT method for update, got: %s", output)
+	}
+	if !strings.Contains(output, "objective_ids") {
+		t.Fatalf("dry-run output should contain objective_ids in body, got: %s", output)
+	}
+}
+
+func TestReorderDryRun_KeyResults(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, _ := cmdutil.TestFactory(t, reorderTestConfig(t))
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "key-result",
+		"--cycle-id", "123",
+		"--objective-id", "456",
+		"--ops", `[{"id":"1","position":2},{"id":"2","position":1}]`,
+		"--dry-run",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	output := stdout.String()
+	if !strings.Contains(output, "/open-apis/okr/v2/objectives/456/key_results") {
+		t.Fatalf("dry-run output should contain key_results list API path, got: %s", output)
+	}
+	if !strings.Contains(output, "/open-apis/okr/v2/objectives/456/key_results_position") {
+		t.Fatalf("dry-run output should contain key_results position update API path, got: %s", output)
+	}
+	if !strings.Contains(output, "key_result_ids") {
+		t.Fatalf("dry-run output should contain key_result_ids in body, got: %s", output)
+	}
+}
+
+// --- Execute tests ---
+
+func TestReorderExecute_Objectives_Success(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, reorderTestConfig(t))
+	// Mock fetch objectives
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "1", "position": 1, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "2", "position": 2, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "3", "position": 3, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	// Mock reorder
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives_position",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "3", "position": 1},
+					map[string]interface{}{"id": "1", "position": 2},
+					map[string]interface{}{"id": "2", "position": 3},
+				},
+			},
+		},
+	})
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"3","position":1}]`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify output
+	data := decodeEnvelope(t, stdout)
+	if data["level"] != "objective" {
+		t.Fatalf("expected level=objective, got %v", data["level"])
+	}
+	if data["cycle_id"] != "123" {
+		t.Fatalf("expected cycle_id=123, got %v", data["cycle_id"])
+	}
+	ordered, _ := data["ordered"].([]interface{})
+	if len(ordered) != 3 {
+		t.Fatalf("expected 3 items in ordered list, got %d", len(ordered))
+	}
+	// First should be 3, then 1, then 2
+	if ordered[0] != "3" || ordered[1] != "1" || ordered[2] != "2" {
+		t.Fatalf("expected ordered [3,1,2], got %v", ordered)
+	}
+}
+
+func TestReorderExecute_KeyResults_Success(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, reorderTestConfig(t))
+	// Mock fetch key results
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/objectives/456/key_results",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "kr1", "position": 1, "objective_id": "456", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "kr2", "position": 2, "objective_id": "456", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	// Mock reorder
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/open-apis/okr/v2/objectives/456/key_results_position",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "kr2", "position": 1},
+					map[string]interface{}{"id": "kr1", "position": 2},
+				},
+			},
+		},
+	})
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "key-result",
+		"--cycle-id", "123",
+		"--objective-id", "456",
+		"--ops", `[{"id":"kr2","position":1}]`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify output
+	data := decodeEnvelope(t, stdout)
+	if data["level"] != "key-result" {
+		t.Fatalf("expected level=key-result, got %v", data["level"])
+	}
+	if data["cycle_id"] != "123" {
+		t.Fatalf("expected cycle_id=123, got %v", data["cycle_id"])
+	}
+	ordered, _ := data["ordered"].([]interface{})
+	if len(ordered) != 2 {
+		t.Fatalf("expected 2 items in ordered list, got %d", len(ordered))
+	}
+	if ordered[0] != "kr2" || ordered[1] != "kr1" {
+		t.Fatalf("expected ordered [kr2,kr1], got %v", ordered)
+	}
+}
+
+func TestReorderExecute_PositionOutOfRange(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, reorderTestConfig(t))
+	// Mock fetch objectives (only 2 items)
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "1", "position": 1, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "2", "position": 2, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives_position",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+		},
+		BodyFilter: func(body []byte) bool {
+			var data map[string]interface{}
+			if err := json.Unmarshal(body, &data); err != nil {
+				return false
+			}
+			ids, ok := data["objective_ids"].([]interface{})
+			if !ok || len(ids) != 2 {
+				return false
+			}
+			// position 5 should be clamped to position 2 (last), so order is [2, 1]
+			return ids[0] == "2" && ids[1] == "1"
+		},
+	})
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"1","position":5}]`, // position 5 exceeds total of 2, should clamp to last
+	})
+	if err != nil {
+		t.Fatalf("unexpected error for out-of-range position (should clamp): %v", err)
+	}
+}
+
+func TestReorderExecute_IDNotFound(t *testing.T) {
+	t.Parallel()
+	f, stdout, _, reg := cmdutil.TestFactory(t, reorderTestConfig(t))
+	// Mock fetch objectives
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "1", "position": 1, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "2", "position": 2, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	err := runReorderShortcut(t, f, stdout, []string{
+		"+reorder",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--ops", `[{"id":"999","position":1}]`, // ID 999 doesn't exist
+	})
+	if err == nil {
+		t.Fatal("expected error for non-existent ID")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--ops" {
+		t.Fatalf("expected param --ops, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "not found") {
+		t.Fatalf("expected error to mention not found, got: %v", err)
+	}
+}
+
+// --- Unit tests for helper functions ---
+
+func TestParseReorderOps_Valid(t *testing.T) {
+	t.Parallel()
+	ops, err := parseReorderOps(`[{"id":"1","position":2},{"id":"2","position":1}]`)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(ops) != 2 {
+		t.Fatalf("expected 2 ops, got %d", len(ops))
+	}
+	if ops[0].ID != "1" || ops[0].Position != 2 {
+		t.Fatalf("expected op[0] = {1,2}, got %+v", ops[0])
+	}
+	if ops[1].ID != "2" || ops[1].Position != 1 {
+		t.Fatalf("expected op[1] = {2,1}, got %+v", ops[1])
+	}
+}
+
+func TestBuildReorderedIDs(t *testing.T) {
+	t.Parallel()
+	items := []Objective{
+		{ID: "1"},
+		{ID: "2"},
+		{ID: "3"},
+		{ID: "4"},
+	}
+	ops := []reorderOp{
+		{ID: "4", Position: 1},
+		{ID: "2", Position: 3},
+	}
+	result, err := buildReorderedIDs(items, ops, 4)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// Expected: 4 at pos1, 1 at pos2 (unchanged), 2 at pos3, 3 at pos4
+	expected := []string{"4", "1", "2", "3"}
+	if len(result) != len(expected) {
+		t.Fatalf("expected %d items, got %d", len(expected), len(result))
+	}
+	for i, id := range expected {
+		if result[i] != id {
+			t.Fatalf("expected result[%d] = %q, got %q", i, id, result[i])
+		}
+	}
+}
+
+func TestBuildReorderedIDs_SingleClampToEnd(t *testing.T) {
+	t.Parallel()
+	items := []testReorderItem{
+		{id: "1"}, {id: "2"}, {id: "3"}, {id: "4"},
+	}
+	ops := []reorderOp{
+		{ID: "1", Position: 99}, // position 99 exceeds total of 4, should clamp to last
+	}
+	result, err := buildReorderedIDs(items, ops, 4)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// Expected: 2 at pos1, 3 at pos2, 4 at pos3, 1 at pos4 (clamped)
+	expected := []string{"2", "3", "4", "1"}
+	for i, id := range expected {
+		if result[i] != id {
+			t.Fatalf("expected result[%d] = %q, got %q", i, id, result[i])
+		}
+	}
+}
+
+func TestBuildReorderedIDs_MultipleClampToEnd(t *testing.T) {
+	t.Parallel()
+	items := []testReorderItem{
+		{id: "1"}, {id: "2"}, {id: "3"}, {id: "4"}, {id: "5"},
+	}
+	ops := []reorderOp{
+		{ID: "1", Position: 10}, // position 10 exceeds total of 5
+		{ID: "2", Position: 20}, // position 20 exceeds total of 5
+	}
+	result, err := buildReorderedIDs(items, ops, 5)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// Expected: 3 at pos1, 4 at pos2, 5 at pos3, 1 at pos4 (clamped, pos10 < pos20), 2 at pos5 (clamped)
+	expected := []string{"3", "4", "5", "1", "2"}
+	for i, id := range expected {
+		if result[i] != id {
+			t.Fatalf("expected result[%d] = %q, got %q", i, id, result[i])
+		}
+	}
+}
+
+func TestBuildReorderedIDs_MixedClamp(t *testing.T) {
+	t.Parallel()
+	items := []testReorderItem{
+		{id: "1"}, {id: "2"}, {id: "3"}, {id: "4"}, {id: "5"},
+	}
+	ops := []reorderOp{
+		{ID: "5", Position: 1},  // normal position
+		{ID: "1", Position: 99}, // clamped to end
+		{ID: "2", Position: 50}, // clamped to end, but position 50 < 99, so comes before 1
+	}
+	result, err := buildReorderedIDs(items, ops, 5)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// Expected: 5 at pos1, 3 at pos2, 4 at pos3, 2 at pos4 (clamped pos50), 1 at pos5 (clamped pos99)
+	expected := []string{"5", "3", "4", "2", "1"}
+	for i, id := range expected {
+		if result[i] != id {
+			t.Fatalf("expected result[%d] = %q, got %q", i, id, result[i])
+		}
+	}
+}
+
+func TestBuildReorderedIDs_LargePositionSafe(t *testing.T) {
+	t.Parallel()
+	items := []testReorderItem{
+		{id: "1"}, {id: "2"}, {id: "3"},
+	}
+	// Very large position should not cause memory issues with map-based implementation
+	ops := []reorderOp{
+		{ID: "1", Position: 100000000}, // 10^8, would be dangerous with slice
+	}
+	result, err := buildReorderedIDs(items, ops, 3)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// Expected: 2 at pos1, 3 at pos2, 1 at pos3 (clamped to end)
+	expected := []string{"2", "3", "1"}
+	for i, id := range expected {
+		if result[i] != id {
+			t.Fatalf("expected result[%d] = %q, got %q", i, id, result[i])
+		}
+	}
+}

shortcuts/okr/okr_weight.go

@@ -0,0 +1,490 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+// weightItem is the interface for items that have ID and weight.
+type weightItem interface {
+	GetID() string
+	GetWeight() float64
+}
+
+// weightOp represents a single weight assignment.
+type weightOp struct {
+	ID     string  `json:"id"`
+	Weight float64 `json:"weight"`
+}
+
+// parseWeightOps parses and validates the --weights JSON array.
+func parseWeightOps(weightsStr string) ([]weightOp, error) {
+	var ops []weightOp
+	if err := json.Unmarshal([]byte(weightsStr), &ops); err != nil {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--weights must be valid JSON array: %s", err).WithParam("--weights").WithCause(err)
+	}
+	if len(ops) == 0 {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--weights must contain at least one weight assignment").WithParam("--weights")
+	}
+
+	seen := make(map[string]bool)
+	var sum float64
+	for i, op := range ops {
+		if strings.TrimSpace(op.ID) == "" {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "weights[%d].id is required and cannot be empty", i).WithParam("--weights")
+		}
+		if op.Weight < 0 {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "weights[%d].weight must be non-negative", i).WithParam("--weights")
+		}
+		if op.Weight > 1 {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "weights[%d].weight must be <= 1", i).WithParam("--weights")
+		}
+		// Check for at most 3 decimal places
+		if math.Round(op.Weight*1000)/1000 != op.Weight {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "weights[%d].weight must have at most 3 decimal places", i).WithParam("--weights")
+		}
+		if seen[op.ID] {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "duplicate id %q in --weights", op.ID).WithParam("--weights")
+		}
+		seen[op.ID] = true
+		sum += op.Weight
+	}
+
+	// Sum must be <= 1
+	if sum > 1+1e-9 {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "sum of weights must be <= 1, got %.6f", sum).WithParam("--weights")
+	}
+
+	return ops, nil
+}
+
+// formatWeight formats a fixed-point weight value as a json.Number with exactly 3 decimal places.
+// This ensures precise JSON serialization and avoids float64 precision issues.
+func formatWeight(fp int64) json.Number {
+	return json.Number(fmt.Sprintf("%d.%03d", fp/1000, fp%1000))
+}
+
+// normalizeWeights normalizes weights using fixed-point arithmetic (×1000).
+//   - Specified weights are used as-is (already validated to 3 decimal places).
+//   - Remaining weight (1 - sum_specified) is distributed to unspecified items
+//     proportionally based on their original weights.
+//   - Fixed-point arithmetic ensures exact sum = 1, with residual added to the last item.
+//   - Weights are returned as json.Number to avoid float64 precision issues in JSON serialization.
+func normalizeWeights[T weightItem](
+	items []T,
+	ops []weightOp,
+) ([]map[string]interface{}, error) {
+	const scale = 1000 // fixed-point scale for 3 decimal places
+
+	// Build map of specified weights (as fixed-point integers)
+	specified := make(map[string]int64)
+	var specifiedSum int64
+	for _, op := range ops {
+		fp := int64(math.Round(op.Weight * scale))
+		specified[op.ID] = fp
+		specifiedSum += fp
+	}
+
+	// Calculate remaining weight to distribute (as fixed-point)
+	remaining := scale - specifiedSum
+	if remaining < 0 {
+		return nil, errs.NewInternalError(errs.SubtypeUnknown, "weight calculation error: remaining weight is negative")
+	}
+
+	// Collect unspecified items and their original weights
+	type itemWithWeight struct {
+		item T
+		fp   int64 // original weight as fixed-point
+	}
+	var unspecified []itemWithWeight
+	var originalUnspecifiedSum int64
+
+	for _, item := range items {
+		id := item.GetID()
+		if _, ok := specified[id]; ok {
+			continue
+		}
+		origWeight := item.GetWeight()
+		if origWeight < 0 {
+			origWeight = 0
+		}
+		fp := int64(math.Round(origWeight * scale))
+		unspecified = append(unspecified, itemWithWeight{item: item, fp: fp})
+		originalUnspecifiedSum += fp
+	}
+
+	// Distribute remaining weight proportionally
+	result := make([]map[string]interface{}, 0, len(items))
+	var resultSum int64
+
+	// First add specified items in original order
+	for _, item := range items {
+		id := item.GetID()
+		if fp, ok := specified[id]; ok {
+			result = append(result, map[string]interface{}{
+				"id":     id,
+				"weight": formatWeight(fp),
+			})
+			resultSum += fp
+		}
+	}
+
+	// Then distribute to unspecified items
+	if len(unspecified) > 0 && remaining > 0 {
+		if originalUnspecifiedSum == 0 {
+			// All original weights are zero, distribute evenly
+			perItem := remaining / int64(len(unspecified))
+			residual := remaining - perItem*int64(len(unspecified))
+
+			for i, uw := range unspecified {
+				fp := perItem
+				// Add residual to the last unspecified item
+				if i == len(unspecified)-1 {
+					fp += residual
+				}
+				result = append(result, map[string]interface{}{
+					"id":     uw.item.GetID(),
+					"weight": formatWeight(fp),
+				})
+				resultSum += fp
+			}
+		} else {
+			// Distribute proportionally based on original weights
+			var distributed int64
+			for i, uw := range unspecified {
+				var fp int64
+				if i == len(unspecified)-1 {
+					// Last item gets the remainder to ensure exact sum
+					fp = remaining - distributed
+				} else {
+					// Proportional distribution
+					fp = int64(float64(remaining) * float64(uw.fp) / float64(originalUnspecifiedSum))
+					distributed += fp
+				}
+				result = append(result, map[string]interface{}{
+					"id":     uw.item.GetID(),
+					"weight": formatWeight(fp),
+				})
+				resultSum += fp
+			}
+		}
+	} else if remaining > 0 {
+		// All items were specified, add residual to the last item
+		if len(result) > 0 {
+			lastIdx := len(result) - 1
+			// Parse current weight as fixed-point and add residual
+			var lastFP int64
+			if lastWeight, ok := result[lastIdx]["weight"].(json.Number); ok {
+				if f, err := lastWeight.Float64(); err == nil {
+					lastFP = int64(math.Round(f * scale))
+				}
+			}
+			result[lastIdx]["weight"] = formatWeight(lastFP + remaining)
+			resultSum += remaining
+		}
+	}
+
+	// Verify sum is exactly 1.0
+	if resultSum != scale {
+		return nil, errs.NewInternalError(errs.SubtypeUnknown,
+			"weight normalization error: sum is %.6f, expected 1.0", float64(resultSum)/scale)
+	}
+
+	return result, nil
+}
+
+// GetWeight implements the interface for Objective.
+func (o Objective) GetWeight() float64 {
+	if o.Weight == nil {
+		return 0
+	}
+	return *o.Weight
+}
+
+// GetWeight implements the interface for KeyResult.
+func (k KeyResult) GetWeight() float64 {
+	if k.Weight == nil {
+		return 0
+	}
+	return *k.Weight
+}
+
+// OKRWeight adjusts the weight of objectives or key results.
+var OKRWeight = common.Shortcut{
+	Service:     "okr",
+	Command:     "+weight",
+	Description: "Adjust the weight of OKR objectives or key results",
+	Risk:        "write",
+	Scopes:      []string{"okr:okr.content:writeonly"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "level", Desc: "level to adjust: objective | key-result", Enum: []string{"objective", "key-result"}, Required: true},
+		{Name: "cycle-id", Desc: "OKR cycle ID (int64)", Required: true},
+		{Name: "objective-id", Desc: "objective ID (required when --level=key-result)"},
+		{Name: "weights", Desc: "JSON array of weight assignments: [{\"id\":\"...\",\"weight\":0.5}]", Input: []string{common.File, common.Stdin}, Required: true},
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		level := runtime.Str("level")
+		if level != "objective" && level != "key-result" {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--level must be one of: objective | key-result").WithParam("--level")
+		}
+
+		cycleID := runtime.Str("cycle-id")
+		if id, err := strconv.ParseInt(cycleID, 10, 64); err != nil || id <= 0 {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--cycle-id must be a positive int64").WithParam("--cycle-id")
+		}
+
+		if level == "key-result" {
+			objID := runtime.Str("objective-id")
+			if objID == "" {
+				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--objective-id is required when --level=key-result").WithParam("--objective-id")
+			}
+			if id, err := strconv.ParseInt(objID, 10, 64); err != nil || id <= 0 {
+				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--objective-id must be a positive int64").WithParam("--objective-id")
+			}
+		}
+
+		weightsStr := runtime.Str("weights")
+		if err := common.RejectDangerousCharsTyped("--weights", weightsStr); err != nil {
+			return err
+		}
+		if _, err := parseWeightOps(weightsStr); err != nil {
+			return err
+		}
+
+		return nil
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		level := runtime.Str("level")
+		cycleID := runtime.Str("cycle-id")
+		objectiveID := runtime.Str("objective-id")
+		ops, _ := parseWeightOps(runtime.Str("weights"))
+
+		apis := common.NewDryRunAPI()
+
+		if level == "objective" {
+			// First fetch objectives
+			listParams := map[string]interface{}{
+				"page_size": 100,
+			}
+			listPath := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives", cycleID)
+			apis = apis.
+				GET(listPath).
+				Params(listParams).
+				Desc("Fetch all objectives in the cycle to get current weights for normalization")
+
+			// Then update weights
+			weightParams := map[string]interface{}{
+				"cycle_id": cycleID,
+			}
+			// Build sample body
+			objectiveWeights := make([]map[string]interface{}, 0, len(ops))
+			for _, op := range ops {
+				objectiveWeights = append(objectiveWeights, map[string]interface{}{
+					"objective_id": op.ID,
+					"weight":       op.Weight,
+				})
+			}
+			weightBody := map[string]interface{}{
+				"objective_weights": objectiveWeights,
+			}
+			weightPath := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives_weight", cycleID)
+			apis = apis.
+				PUT(weightPath).
+				Params(weightParams).
+				Body(weightBody).
+				Desc("Update objective weights (full list sent after normalization)")
+		} else {
+			// key-result level
+			listParams := map[string]interface{}{
+				"page_size": 100,
+			}
+			listPath := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results", objectiveID)
+			apis = apis.
+				GET(listPath).
+				Params(listParams).
+				Desc("Fetch all key results for the objective to get current weights for normalization")
+
+			weightParams := map[string]interface{}{
+				"objective_id": objectiveID,
+			}
+			// Build sample body
+			keyResultWeights := make([]map[string]interface{}, 0, len(ops))
+			for _, op := range ops {
+				keyResultWeights = append(keyResultWeights, map[string]interface{}{
+					"key_result_id": op.ID,
+					"weight":        op.Weight,
+				})
+			}
+			weightBody := map[string]interface{}{
+				"key_result_weights": keyResultWeights,
+			}
+			weightPath := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results_weight", objectiveID)
+			apis = apis.
+				PUT(weightPath).
+				Params(weightParams).
+				Body(weightBody).
+				Desc("Update key result weights (full list sent after normalization)")
+		}
+
+		return apis
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		level := runtime.Str("level")
+		cycleID := runtime.Str("cycle-id")
+		objectiveID := runtime.Str("objective-id")
+		ops, err := parseWeightOps(runtime.Str("weights"))
+		if err != nil {
+			return err
+		}
+
+		var normalizedWeights []map[string]interface{}
+		var total int
+
+		if level == "objective" {
+			objectives, err := fetchObjectives(ctx, runtime, cycleID)
+			if err != nil {
+				return err
+			}
+			total = len(objectives)
+
+			// Validate all specified IDs exist
+			objIDs := make(map[string]bool)
+			for _, obj := range objectives {
+				objIDs[obj.ID] = true
+			}
+			for _, op := range ops {
+				if !objIDs[op.ID] {
+					return errs.NewValidationError(errs.SubtypeInvalidArgument, "objective id %q not found in cycle", op.ID).WithParam("--weights")
+				}
+			}
+
+			normalizedWeights, err = normalizeWeights(objectives, ops)
+			if err != nil {
+				return err
+			}
+
+			// Build position map for sorting
+			posMap := make(map[string]int32)
+			for _, obj := range objectives {
+				if obj.Position != nil {
+					posMap[obj.ID] = *obj.Position
+				}
+			}
+
+			// Submit weight update
+			params := map[string]interface{}{
+				"cycle_id": cycleID,
+			}
+			objectiveWeights := make([]map[string]interface{}, 0, len(normalizedWeights))
+			for _, w := range normalizedWeights {
+				objectiveWeights = append(objectiveWeights, map[string]interface{}{
+					"objective_id": w["id"],
+					"weight":       w["weight"],
+				})
+			}
+			// Sort by position to match API requirements
+			sort.Slice(objectiveWeights, func(i, j int) bool {
+				idI := objectiveWeights[i]["objective_id"].(string)
+				idJ := objectiveWeights[j]["objective_id"].(string)
+				return posMap[idI] < posMap[idJ]
+			})
+			body := map[string]interface{}{
+				"objective_weights": objectiveWeights,
+			}
+			path := fmt.Sprintf("/open-apis/okr/v2/cycles/%s/objectives_weight", cycleID)
+			_, err = runtime.CallAPITyped("PUT", path, params, body)
+			if err != nil {
+				return wrapOkrNetworkErr(err, "failed to update objective weights")
+			}
+		} else {
+			// key-result level
+			keyResults, err := fetchKeyResults(ctx, runtime, objectiveID)
+			if err != nil {
+				return err
+			}
+			total = len(keyResults)
+
+			// Validate all specified IDs exist
+			krIDs := make(map[string]bool)
+			for _, kr := range keyResults {
+				krIDs[kr.ID] = true
+			}
+			for _, op := range ops {
+				if !krIDs[op.ID] {
+					return errs.NewValidationError(errs.SubtypeInvalidArgument, "key_result id %q not found in objective", op.ID).WithParam("--weights")
+				}
+			}
+
+			normalizedWeights, err = normalizeWeights(keyResults, ops)
+			if err != nil {
+				return err
+			}
+
+			// Build position map for sorting
+			posMap := make(map[string]int32)
+			for _, kr := range keyResults {
+				if kr.Position != nil {
+					posMap[kr.ID] = *kr.Position
+				}
+			}
+
+			// Submit weight update
+			params := map[string]interface{}{
+				"objective_id": objectiveID,
+			}
+			keyResultWeights := make([]map[string]interface{}, 0, len(normalizedWeights))
+			for _, w := range normalizedWeights {
+				keyResultWeights = append(keyResultWeights, map[string]interface{}{
+					"key_result_id": w["id"],
+					"weight":        w["weight"],
+				})
+			}
+			// Sort by position to match API requirements
+			sort.Slice(keyResultWeights, func(i, j int) bool {
+				idI := keyResultWeights[i]["key_result_id"].(string)
+				idJ := keyResultWeights[j]["key_result_id"].(string)
+				return posMap[idI] < posMap[idJ]
+			})
+			body := map[string]interface{}{
+				"key_result_weights": keyResultWeights,
+			}
+			path := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results_weight", objectiveID)
+			_, err = runtime.CallAPITyped("PUT", path, params, body)
+			if err != nil {
+				return wrapOkrNetworkErr(err, "failed to update key result weights")
+			}
+		}
+
+		// Build response
+		result := map[string]interface{}{
+			"level":    level,
+			"cycle_id": cycleID,
+			"total":    total,
+			"weights":  normalizedWeights,
+		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Successfully updated weights for %d %s(s)\n", total, level)
+			fmt.Fprintln(w, "Weights:")
+			for _, weightEntry := range normalizedWeights {
+				fmt.Fprintf(w, "  %s: %v\n", weightEntry["id"], weightEntry["weight"])
+			}
+		})
+
+		return nil
+	},
+}

shortcuts/okr/okr_weight_test.go

@@ -0,0 +1,747 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package okr
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"math"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/spf13/cobra"
+)
+
+// getWeightFloat extracts a float64 weight from either float64 or json.Number.
+func getWeightFloat(v interface{}) float64 {
+	switch val := v.(type) {
+	case float64:
+		return val
+	case json.Number:
+		f, _ := val.Float64()
+		return f
+	default:
+		return 0
+	}
+}
+
+func weightTestConfig(t *testing.T) *core.CliConfig {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	return &core.CliConfig{
+		AppID:     "test-okr-weight",
+		AppSecret: "secret-okr-weight",
+		Brand:     core.BrandFeishu,
+	}
+}
+
+func runWeightShortcut(t *testing.T, f *cmdutil.Factory, stdout *bytes.Buffer, args []string) error {
+	t.Helper()
+	parent := &cobra.Command{Use: "okr"}
+	OKRWeight.Mount(parent, f)
+	parent.SetArgs(args)
+	parent.SilenceErrors = true
+	parent.SilenceUsage = true
+	if stdout != nil {
+		stdout.Reset()
+	}
+	return parent.Execute()
+}
+
+// --- Validate tests ---
+
+func TestWeightValidate_MissingLevel(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.5}]`,
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "level") {
+		t.Fatalf("expected --level required error, got: %v", err)
+	}
+}
+
+func TestWeightValidate_InvalidLevel(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "invalid",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.5}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --level")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--level" {
+		t.Fatalf("expected param --level, got %q", validationErr.Param)
+	}
+}
+
+func TestWeightValidate_MissingCycleID(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--weights", `[{"id":"1","weight":0.5}]`,
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "cycle-id") {
+		t.Fatalf("expected --cycle-id required error, got: %v", err)
+	}
+}
+
+func TestWeightValidate_MissingObjectiveIDForKRLevel(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "key-result",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.5}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for missing --objective-id when --level=key-result")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--objective-id" {
+		t.Fatalf("expected param --objective-id, got %q", validationErr.Param)
+	}
+}
+
+func TestWeightValidate_MissingWeights(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+	})
+	// cobra Required:true reports flag name without "--" prefix
+	if err == nil || !strings.Contains(err.Error(), "weights") {
+		t.Fatalf("expected --weights required error, got: %v", err)
+	}
+}
+
+func TestWeightValidate_InvalidWeightsJSON(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", "not-json",
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid --weights JSON")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+}
+
+func TestWeightValidate_EmptyWeightsArray(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", "[]",
+	})
+	if err == nil {
+		t.Fatal("expected error for empty --weights array")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+}
+
+func TestWeightValidate_NegativeWeight(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":-0.1}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for negative weight")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "non-negative") {
+		t.Fatalf("expected error to mention non-negative, got: %v", err)
+	}
+}
+
+func TestWeightValidate_WeightGreaterThanOne(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":1.5}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for weight > 1")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+}
+
+func TestWeightValidate_TooManyDecimalPlaces(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.1234}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for weight with more than 3 decimal places")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "3 decimal places") {
+		t.Fatalf("expected error to mention 3 decimal places, got: %v", err)
+	}
+}
+
+func TestWeightValidate_SumGreaterThanOne(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.6},{"id":"2","weight":0.5}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for sum of weights > 1")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "sum of weights") {
+		t.Fatalf("expected error to mention sum of weights, got: %v", err)
+	}
+}
+
+func TestWeightValidate_DuplicateID(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.3},{"id":"1","weight":0.4}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for duplicate id in --weights")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "duplicate id") {
+		t.Fatalf("expected error to mention duplicate id, got: %v", err)
+	}
+}
+
+// --- DryRun tests ---
+
+func TestWeightDryRun_Objectives(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.5},{"id":"2","weight":0.5}]`,
+		"--dry-run",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	output := stdout.String()
+	if !strings.Contains(output, "/open-apis/okr/v2/cycles/123/objectives") {
+		t.Fatalf("dry-run output should contain objectives list API path, got: %s", output)
+	}
+	if !strings.Contains(output, "GET") {
+		t.Fatalf("dry-run output should contain GET method for list, got: %s", output)
+	}
+	if !strings.Contains(output, "/open-apis/okr/v2/cycles/123/objectives_weight") {
+		t.Fatalf("dry-run output should contain weight update API path, got: %s", output)
+	}
+	if !strings.Contains(output, "PUT") {
+		t.Fatalf("dry-run output should contain PUT method for update, got: %s", output)
+	}
+	if !strings.Contains(output, "objective_weights") {
+		t.Fatalf("dry-run output should contain objective_weights in body, got: %s", output)
+	}
+}
+
+func TestWeightDryRun_KeyResults(t *testing.T) {
+	f, stdout, _, _ := cmdutil.TestFactory(t, weightTestConfig(t))
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "key-result",
+		"--cycle-id", "123",
+		"--objective-id", "456",
+		"--weights", `[{"id":"kr1","weight":0.5},{"id":"kr2","weight":0.5}]`,
+		"--dry-run",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	output := stdout.String()
+	if !strings.Contains(output, "/open-apis/okr/v2/objectives/456/key_results") {
+		t.Fatalf("dry-run output should contain key_results list API path, got: %s", output)
+	}
+	if !strings.Contains(output, "/open-apis/okr/v2/objectives/456/key_results_weight") {
+		t.Fatalf("dry-run output should contain key_results weight update API path, got: %s", output)
+	}
+	if !strings.Contains(output, "key_result_weights") {
+		t.Fatalf("dry-run output should contain key_result_weights in body, got: %s", output)
+	}
+}
+
+// --- Execute tests ---
+
+func TestWeightExecute_Objectives_Success(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, weightTestConfig(t))
+	// Mock fetch objectives
+	w1 := 0.5
+	w2 := 0.5
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "1", "weight": &w1, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "2", "weight": &w2, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	// Mock weight update
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives_weight",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "1", "weight": 0.7},
+					map[string]interface{}{"id": "2", "weight": 0.3},
+				},
+			},
+		},
+	})
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"1","weight":0.7}]`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify output
+	data := decodeEnvelope(t, stdout)
+	if data["level"] != "objective" {
+		t.Fatalf("expected level=objective, got %v", data["level"])
+	}
+	if data["cycle_id"] != "123" {
+		t.Fatalf("expected cycle_id=123, got %v", data["cycle_id"])
+	}
+	weights, _ := data["weights"].([]interface{})
+	if len(weights) != 2 {
+		t.Fatalf("expected 2 items in weights list, got %d", len(weights))
+	}
+
+	// Verify sum is exactly 1.0
+	var sum float64
+	for _, w := range weights {
+		wm, _ := w.(map[string]interface{})
+		weightVal := getWeightFloat(wm["weight"])
+		sum += weightVal
+	}
+	if math.Abs(sum-1.0) > 1e-9 {
+		t.Fatalf("expected sum of weights = 1.0, got %.10f", sum)
+	}
+}
+
+func TestWeightExecute_KeyResults_Success(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, weightTestConfig(t))
+	// Mock fetch key results
+	w1 := 0.3
+	w2 := 0.3
+	w3 := 0.4
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/objectives/456/key_results",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "kr1", "weight": &w1, "objective_id": "456", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "kr2", "weight": &w2, "objective_id": "456", "owner": map[string]interface{}{"owner_type": "user"}},
+					map[string]interface{}{"id": "kr3", "weight": &w3, "objective_id": "456", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	// Mock weight update
+	reg.Register(&httpmock.Stub{
+		Method: "PUT",
+		URL:    "/open-apis/okr/v2/objectives/456/key_results_weight",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{},
+			},
+		},
+	})
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "key-result",
+		"--cycle-id", "123",
+		"--objective-id", "456",
+		"--weights", `[{"id":"kr1","weight":0.5}]`,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify output
+	data := decodeEnvelope(t, stdout)
+	if data["level"] != "key-result" {
+		t.Fatalf("expected level=key-result, got %v", data["level"])
+	}
+	if data["cycle_id"] != "123" {
+		t.Fatalf("expected cycle_id=123, got %v", data["cycle_id"])
+	}
+	weights, _ := data["weights"].([]interface{})
+
+	// Verify sum is exactly 1.0
+	var sum float64
+	for _, w := range weights {
+		wm, _ := w.(map[string]interface{})
+		weightVal := getWeightFloat(wm["weight"])
+		sum += weightVal
+	}
+	if math.Abs(sum-1.0) > 1e-9 {
+		t.Fatalf("expected sum of weights = 1.0, got %.10f", sum)
+	}
+}
+
+func TestWeightExecute_IDNotFound(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, weightTestConfig(t))
+	// Mock fetch objectives
+	w1 := 0.5
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/okr/v2/cycles/123/objectives",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"items": []interface{}{
+					map[string]interface{}{"id": "1", "weight": &w1, "cycle_id": "123", "owner": map[string]interface{}{"owner_type": "user"}},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	err := runWeightShortcut(t, f, stdout, []string{
+		"+weight",
+		"--level", "objective",
+		"--cycle-id", "123",
+		"--weights", `[{"id":"999","weight":0.5}]`,
+	})
+	if err == nil {
+		t.Fatal("expected error for non-existent ID")
+	}
+	prob, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed error, got: %v", err)
+	}
+	if prob.Category != errs.CategoryValidation {
+		t.Fatalf("expected CategoryValidation, got %q", prob.Category)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected error to be *errs.ValidationError, got: %T", err)
+	}
+	if !errors.Is(err, validationErr) {
+		t.Fatal("errors.Is should find the ValidationError in the chain")
+	}
+	if validationErr.Param != "--weights" {
+		t.Fatalf("expected param --weights, got %q", validationErr.Param)
+	}
+	if !strings.Contains(err.Error(), "not found") {
+		t.Fatalf("expected error to mention not found, got: %v", err)
+	}
+}
+
+// --- Unit tests for helper functions ---
+
+func TestParseWeightOps_Valid(t *testing.T) {
+	ops, err := parseWeightOps(`[{"id":"1","weight":0.3},{"id":"2","weight":0.7}]`)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(ops) != 2 {
+		t.Fatalf("expected 2 ops, got %d", len(ops))
+	}
+	if ops[0].ID != "1" || math.Abs(ops[0].Weight-0.3) > 1e-9 {
+		t.Fatalf("expected op[0] = {1,0.3}, got %+v", ops[0])
+	}
+	if ops[1].ID != "2" || math.Abs(ops[1].Weight-0.7) > 1e-9 {
+		t.Fatalf("expected op[1] = {2,0.7}, got %+v", ops[1])
+	}
+}
+
+func TestNormalizeWeights_AllSpecified(t *testing.T) {
+	w1 := 0.0
+	w2 := 0.0
+	items := []Objective{
+		{ID: "1", Weight: &w1},
+		{ID: "2", Weight: &w2},
+	}
+	ops := []weightOp{
+		{ID: "1", Weight: 0.3},
+		{ID: "2", Weight: 0.7},
+	}
+	result, err := normalizeWeights(items, ops)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(result) != 2 {
+		t.Fatalf("expected 2 results, got %d", len(result))
+	}
+	// Sum should be exactly 1.0
+	var sum float64
+	for _, r := range result {
+		sum += getWeightFloat(r["weight"])
+	}
+	if math.Abs(sum-1.0) > 1e-9 {
+		t.Fatalf("expected sum = 1.0, got %.10f", sum)
+	}
+}
+
+func TestNormalizeWeights_PartialSpecified_Proportional(t *testing.T) {
+	w1 := 0.5
+	w2 := 0.3
+	w3 := 0.2
+	items := []Objective{
+		{ID: "1", Weight: &w1},
+		{ID: "2", Weight: &w2},
+		{ID: "3", Weight: &w3},
+	}
+	ops := []weightOp{
+		{ID: "1", Weight: 0.4}, // Specify 0.4 for item 1
+	}
+	result, err := normalizeWeights(items, ops)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(result) != 3 {
+		t.Fatalf("expected 3 results, got %d", len(result))
+	}
+	// Sum should be exactly 1.0
+	var sum float64
+	for _, r := range result {
+		sum += getWeightFloat(r["weight"])
+	}
+	if math.Abs(sum-1.0) > 1e-9 {
+		t.Fatalf("expected sum = 1.0, got %.10f", sum)
+	}
+	// Item 1 should have weight 0.4
+	var item1Weight float64
+	for _, r := range result {
+		if r["id"] == "1" {
+			item1Weight = getWeightFloat(r["weight"])
+			break
+		}
+	}
+	if math.Abs(item1Weight-0.4) > 1e-9 {
+		t.Fatalf("expected item 1 weight = 0.4, got %.10f", item1Weight)
+	}
+}
+
+func TestNormalizeWeights_ZeroOriginalWeights(t *testing.T) {
+	w1 := 0.0
+	w2 := 0.0
+	items := []Objective{
+		{ID: "1", Weight: &w1},
+		{ID: "2", Weight: &w2},
+	}
+	ops := []weightOp{
+		{ID: "1", Weight: 0.5},
+	}
+	result, err := normalizeWeights(items, ops)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(result) != 2 {
+		t.Fatalf("expected 2 results, got %d", len(result))
+	}
+	// Sum should be exactly 1.0
+	var sum float64
+	for _, r := range result {
+		sum += getWeightFloat(r["weight"])
+	}
+	if math.Abs(sum-1.0) > 1e-9 {
+		t.Fatalf("expected sum = 1.0, got %.10f", sum)
+	}
+	// When original weights are zero, remaining should be distributed evenly
+	var item2Weight float64
+	for _, r := range result {
+		if r["id"] == "2" {
+			item2Weight = getWeightFloat(r["weight"])
+			break
+		}
+	}
+	if math.Abs(item2Weight-0.5) > 1e-9 {
+		t.Fatalf("expected item 2 weight = 0.5 (even distribution), got %.10f", item2Weight)
+	}
+}

shortcuts/okr/shortcuts.go

@@ -18,5 +18,9 @@ func Shortcuts() []common.Shortcut {
 		OKRUpdateProgressRecord,
 		OKRDeleteProgressRecord,
 		OKRUploadImage,
+		OKRBatchCreate,
+		OKRReorder,
+		OKRWeight,
+		OKRIndicatorUpdate,
 	}
 }

shortcuts/sheets/batch_op_contract_test.go

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

shortcuts/sheets/batch_op_dispatch.go

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

shortcuts/sheets/csv_put_guard_test.go

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

shortcuts/sheets/csv_put_range_alias_test.go

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