feat:edit slides

.gitignore

@@ -27,9 +27,6 @@ Thumbs.db
 # Go
 docs/ref
 docs/
-!tests/cli_e2e/docs/
-!tests/cli_e2e/docs/*.go
-!tests/cli_e2e/docs/*.md
 vendor/
 
 

CHANGELOG.md

@@ -2,78 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.65] - 2026-07-03
-
-### Features
-
-- **doc**: Add `+history-list`, `+history-revert`, and `+history-revert-status` shortcuts for document version history (#1612)
-
-### Bug Fixes
-
-- **minutes**: `+speaker-replace` no longer refetches the speaker list — `--from-speaker-id` is passed through as-is (#1731)
-
-### Documentation
-
-- **drive**: Document 30-char query limit for `+search` (#1560)
-- **doc**: Add mindnote guidance to lark-doc skill (#1581)
-- **doc**: Sync lark-doc skill content from online-doc (#1701)
-
-## [v1.0.64] - 2026-07-02
-
-### Features
-
-- **im**: Upgrade card send to Card 2.0 with full component reference (#1688)
-- **im**: Add `+chat-members-list` shortcut for member listing (#1398)
-- **okr**: Semi-plain text format with mention position preservation and `patch` shortcut (#1671)
-
-### Bug Fixes
-
-- **cli**: Point permission-apply link at official `/page/scope-apply` entry (#1722)
-- **cli**: Improve secure label error handling (#1707)
-- **cli**: Reduce public content token false positives
-- **cli**: Increase npm registry fetch timeout to 15s during update check (#1724)
-- **doc**: Align word statistics compound tokens (#1706)
-
-### Documentation
-
-- **approval**: Add detailed command-to-reference mapping for the approval skill (#1630)
-- **doc**: Support `reference_map` in docs (#1690)
-- **slides**: Refresh generation guidance — add constraints, drop template toolchain, and inline lint XML fixtures
-
-## [v1.0.62] - 2026-07-01
-
-### Features
-
-- **vc**: Add meeting message send shortcut (#1643)
-- **doc**: Add document word statistics helper (#1697)
-- **cli**: Interactive upgrade prompt for bare `lark-cli` invocation (#1498)
-- **install**: Fail closed when `checksums.txt` is missing during install (#1503)
-
-### Bug Fixes
-
-- **drive**: Improve batch failure handling for push/pull/sync (#1703)
-- **base**: Support JSON array input for field create (#1661)
-- **task**: Expose completion state in `my tasks` output (#1641)
-- **cli**: Reduce public content credential false positives (#1700)
-
-## [v1.0.61] - 2026-06-30
-
-### Features
-
-- **apps**: Add `db`, `file`, `openapi-key` and observability shortcuts (#1596)
-- **identity**: Add `whoami` command showing effective identity (#1666)
-- **docs**: Add reference map flags (#1547)
-
-### Bug Fixes
-
-- **identity**: Correct identity diagnosis under external credential providers (#1693)
-- **cli**: Harden git credential error handling (#1676)
-
-### Documentation
-
-- **doc**: Guide document copy skill usage (#1673)
-- **doc**: Fix lark-doc media token examples (#1662)
-
 ## [v1.0.60] - 2026-06-29
 
 ### Features
@@ -1371,10 +1299,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[v1.0.65]: https://github.com/larksuite/cli/releases/tag/v1.0.65
-[v1.0.64]: https://github.com/larksuite/cli/releases/tag/v1.0.64
-[v1.0.62]: https://github.com/larksuite/cli/releases/tag/v1.0.62
-[v1.0.61]: https://github.com/larksuite/cli/releases/tag/v1.0.61
 [v1.0.60]: https://github.com/larksuite/cli/releases/tag/v1.0.60
 [v1.0.59]: https://github.com/larksuite/cli/releases/tag/v1.0.59
 [v1.0.58]: https://github.com/larksuite/cli/releases/tag/v1.0.58

README.md

@@ -233,24 +233,6 @@ lark-cli api POST /open-apis/im/v1/messages --params '{"receive_id_type":"chat_i
 --format csv       # Comma-separated values
 ```
 
-### JSON Output Contract
-
-With `--format json` (the default), success and error envelopes are distinct.
-
-Success goes to **stdout**, exit code `0`:
-
-```json
-{ "ok": true, "identity": "user", "data": { "guid": "..." }, "meta": { "count": 1 } }
-```
-
-Errors go to **stderr**, non-zero exit code:
-
-```json
-{ "ok": false, "identity": "user", "error": { "type": "api", "subtype": "...", "code": 99991679, "message": "...", "hint": "..." } }
-```
-
-To check whether a command succeeded, test `ok == true` (or the exit code) — **not** `code == 0`. Unlike raw OpenAPI responses (`{"code": 0, "msg": "ok", ...}`), the success envelope carries no `code` or `msg` field; `code` appears only inside `error` as the upstream OpenAPI code. See [errs/ERROR_CONTRACT.md](errs/ERROR_CONTRACT.md) for the full error taxonomy.
-
 ### Pagination
 
 ```bash

README.zh.md

@@ -234,24 +234,6 @@ lark-cli api POST /open-apis/im/v1/messages --params '{"receive_id_type":"chat_i
 --format csv       # 逗号分隔值
 ```
 
-### JSON 输出契约
-
-`--format json`（默认）下，成功与错误的信封结构不同。
-
-成功信封写入 **stdout**，退出码 0：
-
-```json
-{ "ok": true, "identity": "user", "data": { "guid": "..." }, "meta": { "count": 1 } }
-```
-
-错误信封写入 **stderr**，退出码非 0：
-
-```json
-{ "ok": false, "identity": "user", "error": { "type": "api", "subtype": "...", "code": 99991679, "message": "...", "hint": "..." } }
-```
-
-判断命令是否成功，请检查 `ok == true`（或进程退出码），**不要用 `code == 0`**。与原始 OpenAPI 响应（`{"code": 0, "msg": "ok", ...}`）不同，成功信封没有 `code` 和 `msg` 字段；`code` 只出现在错误信封的 `error` 内，含义是上游 OpenAPI 的 numeric code。完整错误分类见 [errs/ERROR_CONTRACT.md](errs/ERROR_CONTRACT.md)。
-
 ### 分页
 
 ```bash

cmd/api/api_test.go

@@ -20,28 +20,13 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func newTestApiCmd(f *cmdutil.Factory, runF func(*APIOptions) error) *cobra.Command {
-	cmd := NewCmdApi(f, runF)
-	cmd.SilenceErrors = true
-	cmd.SilenceUsage = true
-	return cmd
-}
-
-func newTestRootCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:           "lark-cli",
-		SilenceErrors: true,
-		SilenceUsage:  true,
-	}
-}
-
 func TestApiCmd_FlagParsing(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -69,7 +54,7 @@ func TestApiCmd_DryRun(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--dry-run"})
 	err := cmd.Execute()
 	if err != nil {
@@ -92,7 +77,7 @@ func TestApiCmd_NullParamsWithPageSize(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--params", "null", "--page-size", "50", "--as", "bot", "--dry-run"})
 	if err := cmd.Execute(); err != nil {
 		t.Fatalf("--params null with --page-size should not error, got: %v", err)
@@ -113,7 +98,7 @@ func TestApiCmd_BotMode(t *testing.T) {
 		Body: map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{"result": "success"}},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot"})
 	err := cmd.Execute()
 	if err != nil {
@@ -140,7 +125,7 @@ func TestApiCmd_MissingArgs(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET"}) // missing path
 	err := cmd.Execute()
 	if err == nil {
@@ -153,7 +138,7 @@ func TestApiCmd_InvalidParamsJSON(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--params", "{bad"})
 	err := cmd.Execute()
 	if err == nil {
@@ -166,7 +151,7 @@ func TestApiValidArgsFunction(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	fn := cmd.ValidArgsFunction
 
 	tests := []struct {
@@ -232,7 +217,7 @@ func TestNewCmdApi_StrictModeHidesAsFlag(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu, SupportedIdentities: 2,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	flag := cmd.Flags().Lookup("as")
 	if flag == nil {
 		t.Fatal("expected --as flag to be registered")
@@ -251,7 +236,7 @@ func TestApiCmd_PageLimitDefault(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -270,7 +255,7 @@ func TestApiCmd_ParamsAndDataBothStdinConflict(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"POST", "/open-apis/test", "--as", "bot", "--params", "-", "--data", "-"})
 	err := cmd.Execute()
 	if err == nil {
@@ -287,7 +272,7 @@ func TestApiCmd_OutputAndPageAllConflict(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return apiRun(opts)
 	})
@@ -312,7 +297,7 @@ func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
 		ContentType: "application/octet-stream",
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/drive/v1/files/xxx/download", "--as", "bot"})
 	err := cmd.Execute()
 	if err != nil {
@@ -343,7 +328,7 @@ func TestApiCmd_PageAll_NonBatchAPI_FallbackToJSON(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users/u123", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := cmd.Execute()
 	if err != nil {
@@ -383,7 +368,7 @@ func TestApiCmd_PageAll_NonBatchAPI_ErrorStillOutputsJSON(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/im/v1/chats/oc_xxx/announcement", "--as", "bot", "--page-all"})
 	err := cmd.Execute()
 	// Should return an error
@@ -424,7 +409,7 @@ func TestApiCmd_PageAll_BatchAPI_StreamsItems(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := cmd.Execute()
 	if err != nil {
@@ -463,7 +448,7 @@ func TestApiCmd_PageAll_StreamBusinessErrorDoesNotDumpJSON(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := cmd.Execute()
 	if err == nil {
@@ -498,7 +483,7 @@ func TestApiCmd_PageAll_BatchAPI_DefaultJSONEnvelope(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all"})
 	if err := cmd.Execute(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -564,8 +549,8 @@ func TestApiCmd_PageAll_DefaultJSONRunsContentSafety(t *testing.T) {
 		},
 	})
 
-	root := newTestRootCmd()
-	root.AddCommand(newTestApiCmd(f, nil))
+	root := &cobra.Command{Use: "lark-cli"}
+	root.AddCommand(NewCmdApi(f, nil))
 	root.SetArgs([]string{"api", "GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all"})
 	if err := root.Execute(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -615,8 +600,8 @@ func TestApiCmd_PageAll_StreamFormatRunsContentSafety(t *testing.T) {
 		},
 	})
 
-	root := newTestRootCmd()
-	root.AddCommand(newTestApiCmd(f, nil))
+	root := &cobra.Command{Use: "lark-cli"}
+	root.AddCommand(NewCmdApi(f, nil))
 	root.SetArgs([]string{"api", "GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	if err := root.Execute(); err != nil {
 		t.Fatalf("unexpected error: %v", err)
@@ -671,8 +656,8 @@ func TestApiCmd_PageAll_StreamFormatBlockSkipsBlockedPage(t *testing.T) {
 		},
 	})
 
-	root := newTestRootCmd()
-	root.AddCommand(newTestApiCmd(f, nil))
+	root := &cobra.Command{Use: "lark-cli"}
+	root.AddCommand(NewCmdApi(f, nil))
 	root.SetArgs([]string{"api", "GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "ndjson"})
 	err := root.Execute()
 	if err == nil {
@@ -736,7 +721,7 @@ func TestApiCmd_JqFlag_Parsing(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -756,7 +741,7 @@ func TestApiCmd_JqFlag_ShortForm(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -775,7 +760,7 @@ func TestApiCmd_JqAndOutputConflict(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--jq", ".data", "--output", "file.bin"})
@@ -806,7 +791,7 @@ func TestApiCmd_JqFilter_AppliesExpression(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/test/jq", "--as", "bot", "--jq", ".data.items[].name"})
 	err := cmd.Execute()
 	if err != nil {
@@ -827,7 +812,7 @@ func TestApiCmd_JqAndFormatConflict(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--jq", ".data", "--format", "ndjson"})
@@ -845,7 +830,7 @@ func TestApiCmd_JqInvalidExpression(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--jq", "invalid["})
@@ -874,7 +859,7 @@ func TestApiCmd_PageAll_WithJq(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--jq", ".data.items[].id"})
 	err := cmd.Execute()
 	if err != nil {
@@ -895,7 +880,7 @@ func TestApiCmd_MethodUppercase(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -914,7 +899,7 @@ func TestApiCmd_FileFlagParsing(t *testing.T) {
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})
@@ -932,7 +917,7 @@ func TestApiCmd_FileAndOutputConflict(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"POST", "/open-apis/test", "--as", "bot", "--file", "photo.jpg", "--output", "out.json"})
@@ -949,7 +934,7 @@ func TestApiCmd_FileWithGET(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--file", "photo.jpg"})
@@ -966,7 +951,7 @@ func TestApiCmd_FileStdinConflictWithData(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		return apiRun(opts)
 	})
 	cmd.SetArgs([]string{"POST", "/open-apis/test", "--as", "bot", "--file", "-", "--data", "-"})
@@ -989,7 +974,7 @@ func TestApiCmd_DryRunWithFile(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"POST", "/open-apis/im/v1/images", "--file", "image=" + tmpFile, "--data", `{"image_type":"message"}`, "--dry-run", "--as", "bot"})
 	err := cmd.Execute()
 	if err != nil {
@@ -1030,7 +1015,7 @@ func TestApiCmd_PermissionError_DerivesFirstClassFields(t *testing.T) {
 		},
 	})
 
-	cmd := newTestApiCmd(f, nil)
+	cmd := NewCmdApi(f, nil)
 	cmd.SetArgs([]string{"GET", "/open-apis/docx/v1/documents/test", "--as", "bot"})
 	err := cmd.Execute()
 	if err == nil {
@@ -1056,7 +1041,7 @@ func TestApiCmd_JsonFlag_Accepted(t *testing.T) {
 	})
 
 	var gotOpts *APIOptions
-	cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+	cmd := NewCmdApi(f, func(opts *APIOptions) error {
 		gotOpts = opts
 		return nil
 	})

cmd/build.go

@@ -214,9 +214,6 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 	groupRootCommands(rootCmd)
 
 	installUnknownSubcommandGuard(rootCmd)
-	// Bare `lark-cli` in an interactive terminal offers an interactive upgrade
-	// before printing help; non-bare invocations and non-TTY are unaffected.
-	installRootUpgradePrompt(f, rootCmd)
 
 	if mode := f.ResolveStrictMode(ctx); mode.IsActive() && !cfg.skipStrictMode {
 		pruneForStrictMode(rootCmd, mode)

cmd/doctor/doctor.go

@@ -129,10 +129,7 @@ func doctorRun(opts *DoctorOptions) error {
 	if diagnostics.Bot.Available || diagnostics.User.Available {
 		checks = append(checks, pass("identity_ready", "at least one identity is available"))
 	} else {
-		// No hint: this only summarizes the two checks above, which already carry
-		// the source-appropriate remediation. A command here would be redundant,
-		// or wrong (`auth status` is blocked under an external provider).
-		checks = append(checks, fail("identity_ready", "no usable bot or user identity is available", ""))
+		checks = append(checks, fail("identity_ready", "no usable bot or user identity is available", "run: lark-cli auth status --verify"))
 	}
 
 	// ── 4 & 5. Endpoint reachability ──

cmd/doctor/doctor_test.go

@@ -4,19 +4,14 @@
 package doctor
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
-	"net/http"
-	"strings"
 	"testing"
 
 	"github.com/spf13/cobra"
 
-	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
 )
 
 func TestNewCmdDoctor_FlagParsing(t *testing.T) {
@@ -145,84 +140,14 @@ func TestDoctorRun_SplitsBotAndMissingUserIdentity(t *testing.T) {
 }
 
 func assertCheck(t *testing.T, checks []checkResult, name, status string) {
-	t.Helper()
-	if got := findCheck(t, checks, name); got.Status != status {
-		t.Fatalf("%s status = %q, want %q", name, got.Status, status)
-	}
-}
-
-func findCheck(t *testing.T, checks []checkResult, name string) checkResult {
 	t.Helper()
 	for _, check := range checks {
 		if check.Name == name {
-			return check
+			if check.Status != status {
+				t.Fatalf("%s status = %q, want %q", name, check.Status, status)
+			}
+			return
 		}
 	}
 	t.Fatalf("check %q not found in %#v", name, checks)
-	return checkResult{}
-}
-
-type fakeExtProvider struct {
-	name    string
-	account *extcred.Account
-}
-
-func (p *fakeExtProvider) Name() string { return p.name }
-func (p *fakeExtProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
-	return p.account, nil
-}
-func (p *fakeExtProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
-	return nil, nil
-}
-
-// Under an external credential provider with no usable identity, the
-// identity_ready hint must not point at `auth status` (blocked there); the
-// per-identity checks already carry the source-appropriate escalation.
-func TestDoctor_ExternalProvider_IdentityReadyHintNotBlockedCommand(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
-		CurrentApp: "default",
-		Apps:       []core.AppConfig{{Name: "default", AppId: "cli_x", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu}},
-	}); err != nil {
-		t.Fatalf("SaveMultiAppConfig() error = %v", err)
-	}
-
-	// Provider serves neither identity: bot unsupported, user supported but not
-	// signed in → both unavailable → identity_ready fails.
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandFeishu, SupportedIdentities: uint8(extcred.SupportsUser)}
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}}},
-		nil, nil,
-		func() (*http.Client, error) { return nil, nil },
-	)
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{
-		Config:     func() (*core.CliConfig, error) { return cfg, nil },
-		Credential: cred,
-		IOStreams:  &cmdutil.IOStreams{Out: out, ErrOut: &bytes.Buffer{}},
-	}
-
-	if err := doctorRun(&DoctorOptions{Factory: f, Ctx: context.Background(), Offline: true}); err == nil {
-		t.Fatalf("doctorRun() = nil, want failure when no identity is available")
-	}
-	var got struct {
-		Checks []checkResult `json:"checks"`
-	}
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("json.Unmarshal() error = %v\n%s", err, out.String())
-	}
-
-	ready := findCheck(t, got.Checks, "identity_ready")
-	if ready.Status != "fail" {
-		t.Fatalf("identity_ready status = %q, want fail", ready.Status)
-	}
-	// The summary defers to the per-identity checks; it carries no hint of its
-	// own (a command here would be wrong under an external provider).
-	if ready.Hint != "" {
-		t.Fatalf("identity_ready should carry no hint, got %q", ready.Hint)
-	}
-	user := findCheck(t, got.Checks, "user_identity")
-	if !strings.Contains(user.Hint, "external") || strings.Contains(user.Hint, "auth login") {
-		t.Fatalf("user_identity hint not external-appropriate: %q", user.Hint)
-	}
 }

cmd/root_integration_test.go

@@ -103,10 +103,6 @@ func parseTypedEnvelope(t *testing.T, stderr *bytes.Buffer) typedErrorEnvelope {
 }
 
 func buildStrictModeIntegrationRootCmd(t *testing.T, f *cmdutil.Factory) *cobra.Command {
-	return buildStrictModeIntegrationRootCmdWithSetup(t, f, nil)
-}
-
-func buildStrictModeIntegrationRootCmdWithSetup(t *testing.T, f *cmdutil.Factory, setup func(*cobra.Command)) *cobra.Command {
 	t.Helper()
 	rootCmd := &cobra.Command{Use: "lark-cli"}
 	rootCmd.SilenceErrors = true
@@ -119,9 +115,6 @@ func buildStrictModeIntegrationRootCmdWithSetup(t *testing.T, f *cmdutil.Factory
 	rootCmd.AddCommand(api.NewCmdApi(f, nil))
 	service.RegisterServiceCommands(rootCmd, f)
 	shortcuts.RegisterShortcuts(rootCmd, f)
-	if setup != nil {
-		setup(rootCmd)
-	}
 	if mode := f.ResolveStrictMode(context.Background()); mode.IsActive() {
 		pruneForStrictMode(rootCmd, mode)
 	}
@@ -362,16 +355,10 @@ func TestIntegration_StrictModeBot_ProfileOverride_ServiceExplicitUserReturnsEnv
 
 func TestIntegration_StrictModeUser_ProfileOverride_ServiceBotOnlyMethodReturnsEnvelope(t *testing.T) {
 	f, stdout, stderr := newStrictModeDefaultFactory(t, "target", core.StrictModeUser)
-	rootCmd := buildStrictModeIntegrationRootCmdWithSetup(t, f, func(rootCmd *cobra.Command) {
-		fixture := &cobra.Command{Use: "strict-fixture"}
-		botOnly := &cobra.Command{Use: "bot-only", RunE: func(*cobra.Command, []string) error { return nil }}
-		cmdutil.SetSupportedIdentities(botOnly, []string{"bot"})
-		fixture.AddCommand(botOnly)
-		rootCmd.AddCommand(fixture)
-	})
+	rootCmd := buildStrictModeIntegrationRootCmd(t, f)
 
 	code := executeRootIntegration(t, f, rootCmd, []string{
-		"strict-fixture", "bot-only",
+		"im", "images", "create", "--data", `{"image_type":"message","image":"x"}`, "--dry-run",
 	})
 
 	if code != output.ExitValidation {

cmd/root_upgrade.go

@@ -1,90 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/internal/build"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/update"
-	"github.com/spf13/cobra"
-)
-
-// runRootUpgrade locates the registered `update` subcommand and runs it, so the
-// interactive root-command upgrade reuses exactly `lark-cli update` behavior
-// (install-method detection, output, error handling). Package-level var so
-// tests can stub it and avoid real network / self-update.
-var runRootUpgrade = func(cmd *cobra.Command) {
-	for _, c := range cmd.Root().Commands() {
-		if c.Name() == "update" && c.RunE != nil {
-			_ = c.RunE(c, nil) // update prints its own output/errors; swallow here
-			return
-		}
-	}
-}
-
-// isBareRootInvocation reports whether this is a bare `lark-cli` (no subcommand,
-// no flags) — the only invocation that triggers the interactive upgrade prompt.
-// Mirrors unknownSubcommandRunE's "bare group prints help" branch: args empty
-// AND no flag tokens in the raw invocation.
-func isBareRootInvocation(args []string) bool {
-	return len(args) == 0 && len(flagTokensInArgs(rawInvocationArgs)) == 0
-}
-
-// readYes reads one line and reports whether it is an affirmative y/yes.
-// EOF / empty / anything else → false (default No, matching the [y/N] prompt).
-func readYes(r io.Reader) bool {
-	line, _ := bufio.NewReader(r).ReadString('\n')
-	switch strings.ToLower(strings.TrimSpace(line)) {
-	case "y", "yes":
-		return true
-	default:
-		return false
-	}
-}
-
-// offerRootUpgrade prompts for an interactive upgrade when running bare
-// `lark-cli` in an interactive terminal with a cached newer version. Every
-// failure is swallowed — it must never affect help output or the exit code.
-func offerRootUpgrade(f *cmdutil.Factory, cmd *cobra.Command) {
-	ios := f.IOStreams
-	// Gates 1/2/3: need to read stdin AND show the prompt on stderr, and require
-	// stdout TTY too so this only fires in a pure foreground terminal session.
-	if !ios.IsTerminal || !ios.OutIsTerminal || !ios.StderrIsTerminal {
-		return
-	}
-	// Gate 4: cached newer version. CheckCached applies opt-out (shouldSkip)
-	// and the IsNewer/semver validation chain; it reads the on-disk cache that
-	// the 24h-throttled RefreshCache maintains (CheckCached itself has no TTL).
-	info := update.CheckCached(build.Version)
-	if info == nil {
-		return
-	}
-	fmt.Fprintf(ios.ErrOut, "lark-cli %s available (current %s). Upgrade now? [y/N]: ", info.Latest, info.Current)
-	if !readYes(ios.In) {
-		return
-	}
-	runRootUpgrade(cmd)
-}
-
-// installRootUpgradePrompt wraps the root command's RunE (set to
-// unknownSubcommandRunE by installUnknownSubcommandGuard) so a bare `lark-cli`
-// invocation offers an interactive upgrade before printing help. Non-bare
-// invocations are passed straight through, unchanged.
-func installRootUpgradePrompt(f *cmdutil.Factory, root *cobra.Command) {
-	inner := root.RunE
-	if inner == nil {
-		return
-	}
-	root.RunE = func(cmd *cobra.Command, args []string) error {
-		if isBareRootInvocation(args) {
-			offerRootUpgrade(f, cmd)
-		}
-		return inner(cmd, args)
-	}
-}

cmd/root_upgrade_test.go

@@ -1,191 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/larksuite/cli/internal/build"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/spf13/cobra"
-)
-
-func writeUpdateState(t *testing.T, dir, latest string) {
-	t.Helper()
-	data := fmt.Sprintf(`{"latest_version":%q,"checked_at":%d}`, latest, time.Now().Unix())
-	if err := os.WriteFile(filepath.Join(dir, "update-state.json"), []byte(data), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestReadYes(t *testing.T) {
-	cases := map[string]bool{
-		"y\n": true, "Y\n": true, "yes\n": true, "YES\n": true, " y \n": true,
-		"n\n": false, "\n": false, "": false, "nope\n": false, "yeah\n": false,
-	}
-	for in, want := range cases {
-		if got := readYes(strings.NewReader(in)); got != want {
-			t.Errorf("readYes(%q) = %v, want %v", in, got, want)
-		}
-	}
-}
-
-func TestIsBareRootInvocation(t *testing.T) {
-	orig := rawInvocationArgs
-	t.Cleanup(func() { rawInvocationArgs = orig })
-
-	rawInvocationArgs = nil
-	if !isBareRootInvocation([]string{}) {
-		t.Error("empty args + no raw flag tokens should be bare")
-	}
-	rawInvocationArgs = []string{"--profile", "x"}
-	if isBareRootInvocation([]string{}) {
-		t.Error("flag token present → not bare")
-	}
-	rawInvocationArgs = nil
-	if isBareRootInvocation([]string{"im"}) {
-		t.Error("positional arg → not bare")
-	}
-}
-
-func TestOfferRootUpgrade(t *testing.T) {
-	origV := build.Version
-	build.Version = "1.0.0" // release version so shouldSkip()==false
-	t.Cleanup(func() { build.Version = origV })
-
-	origRun := runRootUpgrade
-	t.Cleanup(func() { runRootUpgrade = origRun })
-
-	// This test builds a Factory literal (no NewDefault), so it never runs
-	// workspace detection; pin the process-global workspace to Local so
-	// statePath() resolves under LARKSUITE_CLI_CONFIG_DIR rather than a stale
-	// subdir inherited from a prior test in the package.
-	origWS := core.CurrentWorkspace()
-	t.Cleanup(func() { core.SetCurrentWorkspace(origWS) })
-	core.SetCurrentWorkspace(core.WorkspaceLocal)
-
-	cases := []struct {
-		name                string
-		in, out, err        bool
-		input               string
-		latest              string // "" → no state file (CheckCached nil)
-		optOut              bool
-		wantPrompt, wantRun bool
-	}{
-		{"all-tty+y", true, true, true, "y\n", "2.0.0", false, true, true},
-		{"all-tty+yes", true, true, true, "yes\n", "2.0.0", false, true, true},
-		{"all-tty+n", true, true, true, "n\n", "2.0.0", false, true, false},
-		{"all-tty+empty", true, true, true, "\n", "2.0.0", false, true, false},
-		{"all-tty+eof", true, true, true, "", "2.0.0", false, true, false},
-		{"stdin-not-tty", false, true, true, "y\n", "2.0.0", false, false, false},
-		{"stdout-not-tty", true, false, true, "y\n", "2.0.0", false, false, false},
-		{"stderr-not-tty", true, true, false, "y\n", "2.0.0", false, false, false},
-		{"no-newer-version", true, true, true, "y\n", "", false, false, false},
-		{"already-latest", true, true, true, "y\n", "1.0.0", false, false, false}, // post-upgrade: current == cached latest → no prompt
-		{"cache-older-than-current", true, true, true, "y\n", "0.9.0", false, false, false},
-		{"opt-out", true, true, true, "y\n", "2.0.0", true, false, false},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			dir := t.TempDir()
-			t.Setenv("LARKSUITE_CLI_CONFIG_DIR", dir)
-			// Clear env that update.shouldSkip treats as "suppress" so the
-			// test is deterministic regardless of host (GitHub Actions sets
-			// CI=true, which would otherwise suppress the prompt).
-			t.Setenv("CI", "")
-			t.Setenv("BUILD_NUMBER", "")
-			t.Setenv("RUN_ID", "")
-			t.Setenv("LARKSUITE_CLI_NO_UPDATE_NOTIFIER", "")
-			if tc.latest != "" {
-				writeUpdateState(t, dir, tc.latest)
-			}
-			if tc.optOut {
-				t.Setenv("LARKSUITE_CLI_NO_UPDATE_NOTIFIER", "1")
-			}
-			called := false
-			runRootUpgrade = func(*cobra.Command) { called = true }
-
-			var errBuf bytes.Buffer
-			f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{
-				In:               strings.NewReader(tc.input),
-				Out:              &bytes.Buffer{},
-				ErrOut:           &errBuf,
-				IsTerminal:       tc.in,
-				OutIsTerminal:    tc.out,
-				StderrIsTerminal: tc.err,
-			}}
-			offerRootUpgrade(f, &cobra.Command{})
-
-			gotPrompt := strings.Contains(errBuf.String(), "available")
-			if gotPrompt != tc.wantPrompt {
-				t.Errorf("prompt: got %v want %v (stderr=%q)", gotPrompt, tc.wantPrompt, errBuf.String())
-			}
-			if called != tc.wantRun {
-				t.Errorf("runRootUpgrade called: got %v want %v", called, tc.wantRun)
-			}
-		})
-	}
-}
-
-func TestInstallRootUpgradePromptPreservesInner(t *testing.T) {
-	orig := rawInvocationArgs
-	t.Cleanup(func() { rawInvocationArgs = orig })
-	rawInvocationArgs = nil
-
-	innerCalls := 0
-	root := &cobra.Command{Use: "lark-cli"}
-	root.RunE = func(cmd *cobra.Command, args []string) error { innerCalls++; return nil }
-
-	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{
-		In: strings.NewReader(""), Out: &bytes.Buffer{}, ErrOut: &bytes.Buffer{},
-	}}
-	installRootUpgradePrompt(f, root)
-
-	if err := root.RunE(root, []string{}); err != nil {
-		t.Fatalf("bare RunE err = %v", err)
-	}
-	if err := root.RunE(root, []string{"im"}); err != nil {
-		t.Fatalf("non-bare RunE err = %v", err)
-	}
-	if innerCalls != 2 {
-		t.Errorf("inner RunE should run for both bare and non-bare, got %d", innerCalls)
-	}
-}
-
-// TestRunRootUpgradeDispatchesToUpdate covers the real runRootUpgrade dispatch
-// path (not the stub used elsewhere): from any command it must locate the
-// registered "update" subcommand via cmd.Root() and invoke its RunE.
-func TestRunRootUpgradeDispatchesToUpdate(t *testing.T) {
-	root := &cobra.Command{Use: "lark-cli"}
-	ran := 0
-	root.AddCommand(&cobra.Command{Use: "update", RunE: func(*cobra.Command, []string) error { ran++; return nil }})
-	child := &cobra.Command{Use: "im"}
-	root.AddCommand(child)
-
-	runRootUpgrade(child) // child.Root() resolves to root, which has "update"
-
-	if ran != 1 {
-		t.Errorf("runRootUpgrade should locate and run update's RunE once, got %d", ran)
-	}
-}
-
-// TestInstallRootUpgradePromptNilInnerNoop covers the inner == nil guard:
-// when root has no RunE, installRootUpgradePrompt must not wrap it.
-func TestInstallRootUpgradePromptNilInnerNoop(t *testing.T) {
-	root := &cobra.Command{Use: "lark-cli"} // RunE is nil
-	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{
-		In: strings.NewReader(""), Out: &bytes.Buffer{}, ErrOut: &bytes.Buffer{},
-	}}
-	installRootUpgradePrompt(f, root)
-	if root.RunE != nil {
-		t.Error("installRootUpgradePrompt must not wrap a nil RunE (inner==nil guard)")
-	}
-}

cmd/schema/schema.go

@@ -65,13 +65,13 @@ func NewCmdSchema(f *cmdutil.Factory, runF func(*SchemaOptions) error) *cobra.Co
 	return cmd
 }
 
-// completeSchemaPath is a thin adapter over the schema catalog's Complete.
-// It uses the same source as schema execution so completion candidates match
-// what `schema` can resolve.
+// completeSchemaPath is a thin adapter over the embedded catalog's Complete.
+// It uses the embedded source so completion candidates match what `schema`
+// execution can resolve (both overlay-free).
 func completeSchemaPath(f *cmdutil.Factory) func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
 	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		mode := f.ResolveStrictMode(cmd.Context())
-		completions, noSpace := registry.SchemaCatalog().Complete(args, toComplete, registry.FilterForStrictMode(mode))
+		completions, noSpace := registry.EmbeddedCatalog().Complete(args, toComplete, registry.FilterForStrictMode(mode))
 		directive := cobra.ShellCompDirectiveNoFileComp
 		if noSpace {
 			directive |= cobra.ShellCompDirectiveNoSpace
@@ -86,19 +86,13 @@ func schemaRun(opts *SchemaOptions) error {
 	return runSchema(out, apicatalog.ParsePath(opts.Args), mode)
 }
 
-// runSchema resolves the path through the schema catalog and renders the
+// runSchema resolves the path through the embedded catalog and renders the
 // matching envelope(s). The catalog owns navigation (Resolve + MethodRefs) and
 // schema owns rendering (Envelope/Envelopes); this adapter only chooses the
 // output shape — a single resolved method renders as one envelope object,
 // anything broader as an array — and maps resolve failures to hints.
 func runSchema(out io.Writer, parts []string, mode core.StrictMode) error {
-	catalog := registry.SchemaCatalog()
-	if len(catalog.Services()) == 0 {
-		// No embedded metadata and the runtime fallback is empty too: offline
-		// with a cold cache, remote meta off, or an unwritable cache dir.
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "No API metadata available").
-			WithHint("this binary has no embedded API metadata; run any command with network access to the open platform once so metadata can be fetched and cached")
-	}
+	catalog := registry.EmbeddedCatalog()
 	target, err := catalog.Resolve(parts)
 	if err != nil {
 		return resolveError(err)

cmd/update/update.go

@@ -102,8 +102,7 @@ func NewCmdUpdate(f *cmdutil.Factory) *cobra.Command {
 		Long: `Update lark-cli to the latest version.
 
 Detects the installation method automatically:
-  - npm install:  runs npm install -g @larksuite/cli@<version>
-  - pnpm install: runs pnpm add -g @larksuite/cli@<version>
+  - npm install: runs npm install -g @larksuite/cli@<version>
   - manual/other: shows GitHub Releases download URL
 
 Use --json for structured output (for AI agents and scripts).
@@ -165,7 +164,7 @@ func updateRun(opts *UpdateOptions) error {
 	if !detect.CanAutoUpdate() {
 		return doManualUpdate(opts, io, cur, latest, detect, updater)
 	}
-	return doAutoUpdate(opts, io, cur, latest, detect, updater)
+	return doNpmUpdate(opts, io, cur, latest, updater)
 }
 
 // --- Output helpers ---
@@ -227,23 +226,12 @@ func doManualUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest stri
 	fmt.Fprintf(io.ErrOut, "To update manually, download the latest release:\n")
 	fmt.Fprintf(io.ErrOut, "  Release:   %s\n", releaseURL(latest))
 	fmt.Fprintf(io.ErrOut, "  Changelog: %s\n", changelogURL())
-	if detect.Method == selfupdate.InstallPnpm {
-		fmt.Fprintf(io.ErrOut, "\nOr install via pnpm (note: skills will not be synced):\n  pnpm add -g %s@%s\n  pnpm dlx skills add larksuite/cli -y -g   # sync skills separately\n", selfupdate.NpmPackage, latest)
-	} else {
-		fmt.Fprintf(io.ErrOut, "\nOr install via npm (note: skills will not be synced):\n  npm install -g %s@%s\n  npx skills add larksuite/cli -y -g   # sync skills separately\n", selfupdate.NpmPackage, latest)
-	}
+	fmt.Fprintf(io.ErrOut, "\nOr install via npm (note: skills will not be synced):\n  npm install -g %s@%s\n  npx skills add larksuite/cli -y -g   # sync skills separately\n", selfupdate.NpmPackage, latest)
 	emitSkillsTextHints(io, skillsResult)
 	return nil
 }
 
-func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string, detect selfupdate.DetectResult, updater *selfupdate.Updater) error {
-	pm := "npm"
-	install := updater.RunNpmInstall
-	if detect.Method == selfupdate.InstallPnpm {
-		pm = "pnpm"
-		install = updater.RunPnpmInstall
-	}
-
+func doNpmUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string, updater *selfupdate.Updater) error {
 	restore, err := updater.PrepareSelfReplace()
 	if err != nil {
 		return reportError(opts, io, "update_error",
@@ -251,19 +239,19 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 	}
 
 	if !opts.JSON {
-		fmt.Fprintf(io.ErrOut, "Updating lark-cli %s %s %s via %s ...\n", cur, symArrow(), latest, pm)
+		fmt.Fprintf(io.ErrOut, "Updating lark-cli %s %s %s via npm ...\n", cur, symArrow(), latest)
 	}
 
-	npmResult := install(latest)
+	npmResult := updater.RunNpmInstall(latest)
 	if npmResult.Err != nil {
 		restore()
 		combined := npmResult.CombinedOutput()
 		if opts.JSON {
 			output.PrintJson(io.Out, map[string]interface{}{
 				"ok": false, "error": map[string]interface{}{
-					"type": "update_error", "message": fmt.Sprintf("%s install failed: %s", pm, npmResult.Err),
+					"type": "update_error", "message": fmt.Sprintf("npm install failed: %s", npmResult.Err),
 					"detail": selfupdate.Truncate(combined, maxNpmOutput),
-					"hint":   permissionHint(combined, pm),
+					"hint":   permissionHint(combined),
 				},
 			})
 			return output.ErrBare(output.ExitAPI)
@@ -275,7 +263,7 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 			fmt.Fprint(io.ErrOut, npmResult.Stderr.String())
 		}
 		fmt.Fprintf(io.ErrOut, "\n%s Update failed: %s\n", symFail(), npmResult.Err)
-		if hint := permissionHint(combined, pm); hint != "" {
+		if hint := permissionHint(combined); hint != "" {
 			fmt.Fprintf(io.ErrOut, "  %s\n", hint)
 		}
 		return output.ErrBare(output.ExitAPI)
@@ -286,7 +274,7 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 	if err := updater.VerifyBinary(latest); err != nil {
 		restore()
 		msg := fmt.Sprintf("new binary verification failed: %s", err)
-		hint := verificationFailureHint(updater, latest, pm)
+		hint := verificationFailureHint(updater, latest)
 		if opts.JSON {
 			output.PrintJson(io.Out, map[string]interface{}{
 				"ok":    false,
@@ -316,33 +304,23 @@ func doAutoUpdate(opts *UpdateOptions, io *cmdutil.IOStreams, cur, latest string
 	fmt.Fprintf(io.ErrOut, "\n%s Successfully updated lark-cli from %s to %s\n", symOK(), cur, latest)
 	fmt.Fprintf(io.ErrOut, "  Changelog: %s\n", changelogURL())
 	if skillsResult != nil {
-		skillsPM := "npx"
-		if detect.Method == selfupdate.InstallPnpm && detect.PnpmAvailable {
-			skillsPM = "pnpm dlx"
-		}
-		fmt.Fprintf(io.ErrOut, "\nUpdating skills via %s ...\n", skillsPM)
+		fmt.Fprintf(io.ErrOut, "\nUpdating skills ...\n")
 	}
 	emitSkillsTextHints(io, skillsResult)
 	return nil
 }
 
-func permissionHint(pmOutput, pm string) string {
-	if !strings.Contains(pmOutput, "EACCES") || isWindows() {
-		return ""
+func permissionHint(npmOutput string) string {
+	if strings.Contains(npmOutput, "EACCES") && !isWindows() {
+		return "Permission denied. Try: sudo lark-cli update, or adjust your npm global prefix: https://docs.npmjs.com/resolving-eacces-permissions-errors"
 	}
-	if pm == "pnpm" {
-		return "Permission denied. Ensure your pnpm global directory is writable — re-run `pnpm setup`, or see https://pnpm.io/pnpm-cli"
-	}
-	return "Permission denied. Try: sudo lark-cli update, or adjust your npm global prefix: https://docs.npmjs.com/resolving-eacces-permissions-errors"
+	return ""
 }
 
-func verificationFailureHint(updater *selfupdate.Updater, latest, pm string) string {
+func verificationFailureHint(updater *selfupdate.Updater, latest string) string {
 	if updater.CanRestorePreviousVersion() {
 		return "the previous version has been restored"
 	}
-	if pm == "pnpm" {
-		return fmt.Sprintf("automatic rollback is unavailable on this platform; reinstall manually (skills will not be synced): pnpm add -g %s@%s && pnpm dlx skills add larksuite/cli -y -g, or download %s", selfupdate.NpmPackage, latest, releaseURL(latest))
-	}
 	return fmt.Sprintf("automatic rollback is unavailable on this platform; reinstall manually (skills will not be synced): npm install -g %s@%s && npx skills add larksuite/cli -y -g, or download %s", selfupdate.NpmPackage, latest, releaseURL(latest))
 }
 

cmd/update/update_test.go

@@ -57,27 +57,6 @@ func mockDetectAndNpm(t *testing.T, result selfupdate.DetectResult, npmFn func(s
 	t.Cleanup(func() { newUpdater = origNew })
 }
 
-// mockDetectAndPnpm mirrors mockDetectAndNpm but wires the pnpm install path
-// and fails the test if the npm install path is invoked.
-func mockDetectAndPnpm(t *testing.T, result selfupdate.DetectResult, pnpmFn func(string) *selfupdate.NpmResult) {
-	t.Helper()
-	origNew := newUpdater
-	newUpdater = func() *selfupdate.Updater {
-		u := selfupdate.New()
-		u.DetectOverride = func() selfupdate.DetectResult { return result }
-		u.PnpmInstallOverride = pnpmFn
-		u.NpmInstallOverride = func(string) *selfupdate.NpmResult {
-			t.Errorf("npm install must not be called for a pnpm install")
-			return &selfupdate.NpmResult{}
-		}
-		u.VerifyOverride = func(string) error { return nil }
-		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
-		u.SkillsCommandOverride = successfulSkillsCommand()
-		return u
-	}
-	t.Cleanup(func() { newUpdater = origNew })
-}
-
 func successfulSkillsIndexFetch() func() *selfupdate.NpmResult {
 	return func() *selfupdate.NpmResult {
 		r := &selfupdate.NpmResult{}
@@ -102,110 +81,6 @@ func successfulSkillsCommand() func(args ...string) *selfupdate.NpmResult {
 	}
 }
 
-func TestUpdatePnpm_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _ := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{"--json"})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetectAndPnpm(t,
-		selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: true},
-		func(string) *selfupdate.NpmResult { return &selfupdate.NpmResult{} },
-	)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if out := stdout.String(); !strings.Contains(out, `"action": "updated"`) {
-		t.Errorf("expected updated in output, got: %s", out)
-	}
-}
-
-func TestUpdatePnpm_Human(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, stderr := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetectAndPnpm(t,
-		selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: true},
-		func(string) *selfupdate.NpmResult { return &selfupdate.NpmResult{} },
-	)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	out := stderr.String()
-	if !strings.Contains(out, "via pnpm") {
-		t.Errorf("expected 'via pnpm' in stderr, got: %s", out)
-	}
-	if !strings.Contains(out, "Updating skills via pnpm dlx ...") {
-		t.Errorf("expected skills sync to report pnpm dlx launcher, got: %s", out)
-	}
-	if !strings.Contains(out, "Successfully updated") {
-		t.Errorf("expected success message, got: %s", out)
-	}
-}
-
-func TestUpdatePnpm_InstallError_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _ := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{"--json"})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetectAndPnpm(t,
-		selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: true},
-		func(string) *selfupdate.NpmResult { return &selfupdate.NpmResult{Err: errors.New("pnpm boom")} },
-	)
-	err := cmd.Execute()
-	if err == nil {
-		t.Fatal("expected error exit")
-	}
-	if out := stdout.String(); !strings.Contains(out, `"ok": false`) || !strings.Contains(out, "update_error") {
-		t.Errorf("expected failure envelope, got: %s", out)
-	}
-	if out := stdout.String(); !strings.Contains(out, "pnpm install failed") {
-		t.Errorf("expected message to report pnpm as the package manager, got: %s", out)
-	}
-}
-
-func TestUpdatePnpm_Unavailable_ManualFallback(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, stderr := newTestFactory(t)
-	cmd := NewCmdUpdate(f)
-	cmd.SetArgs([]string{})
-	origFetch := fetchLatest
-	fetchLatest = func() (string, error) { return "2.0.0", nil }
-	defer func() { fetchLatest = origFetch }()
-	origVersion := currentVersion
-	currentVersion = func() string { return "1.0.0" }
-	defer func() { currentVersion = origVersion }()
-	mockDetect(t, selfupdate.DetectResult{Method: selfupdate.InstallPnpm, ResolvedPath: "/x/node_modules/.pnpm/@larksuite+cli@1.0.0/node_modules/@larksuite/cli/bin/lark-cli", PnpmAvailable: false})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	out := stderr.String()
-	if !strings.Contains(out, "installed via pnpm, but pnpm is not available in PATH") {
-		t.Errorf("expected pnpm manual reason, got: %s", out)
-	}
-	if !strings.Contains(out, "pnpm add -g") {
-		t.Errorf("expected pnpm add -g hint, got: %s", out)
-	}
-}
-
 func TestNormalizeVersion(t *testing.T) {
 	tests := []struct {
 		input string
@@ -391,9 +266,6 @@ func TestUpdateNpm_Human(t *testing.T) {
 	if !strings.Contains(out, "Successfully updated") {
 		t.Errorf("expected success message in stderr, got: %s", out)
 	}
-	if !strings.Contains(out, "Updating skills via npx ...") {
-		t.Errorf("expected skills sync to report npx launcher for npm install, got: %s", out)
-	}
 }
 
 func TestUpdateForce_JSON(t *testing.T) {
@@ -867,9 +739,9 @@ func TestPermissionHint(t *testing.T) {
 	origOS := currentOS
 	defer func() { currentOS = origOS }()
 
-	// Linux + npm: EACCES should produce a hint with npm prefix guidance.
+	// Linux: EACCES should produce a hint with npm prefix guidance.
 	currentOS = "linux"
-	hint := permissionHint("EACCES: permission denied, access '/usr/local/lib'", "npm")
+	hint := permissionHint("EACCES: permission denied, access '/usr/local/lib'")
 	if !strings.Contains(hint, "npm global prefix") {
 		t.Errorf("expected npm prefix hint on linux, got: %s", hint)
 	}
@@ -877,25 +749,16 @@ func TestPermissionHint(t *testing.T) {
 		t.Errorf("should not suggest raw sudo npm install, got: %s", hint)
 	}
 
-	// Linux + pnpm: EACCES should point at pnpm setup, not npm prefix/sudo.
-	pnpmHint := permissionHint("EACCES: permission denied, access '/Users/x/Library/pnpm'", "pnpm")
-	if !strings.Contains(pnpmHint, "pnpm setup") {
-		t.Errorf("expected pnpm setup hint, got: %s", pnpmHint)
-	}
-	if strings.Contains(pnpmHint, "npm global prefix") || strings.Contains(pnpmHint, "sudo") {
-		t.Errorf("pnpm hint must not reference npm prefix or sudo, got: %s", pnpmHint)
-	}
-
 	// Windows: EACCES hint is suppressed (no EACCES on Windows).
 	currentOS = "windows"
-	hint = permissionHint("EACCES: permission denied", "npm")
+	hint = permissionHint("EACCES: permission denied")
 	if hint != "" {
 		t.Errorf("expected empty hint on Windows, got: %s", hint)
 	}
 
 	// Non-EACCES error: always empty.
 	currentOS = "linux"
-	if got := permissionHint("some other error", "npm"); got != "" {
+	if got := permissionHint("some other error"); got != "" {
 		t.Errorf("expected empty hint for non-EACCES, got: %s", got)
 	}
 }

cmd/whoami/whoami.go

@@ -5,6 +5,8 @@ package whoami
 
 import (
 	"context"
+	"fmt"
+	"io"
 
 	"github.com/spf13/cobra"
 
@@ -15,13 +17,6 @@ import (
 )
 
 // whoamiResult is the structured output of `lark-cli whoami`.
-//
-// The self-vs-delegated distinction is carried by `identity`: a bot identity is
-// the app acting as itself; a user identity is the app acting *on behalf of* a
-// person (calls are attributed to that user, who is not necessarily present).
-// onBehalfOf only *names* that person and so appears only once a user is
-// resolved — a user identity that is not signed in still has identity "user"
-// but no onBehalfOf yet. Do not read "no onBehalfOf" as "self"; read `identity`.
 type whoamiResult struct {
 	Profile        string         `json:"profile"`
 	AppID          string         `json:"appId"`
@@ -31,44 +26,34 @@ type whoamiResult struct {
 	IdentitySource string         `json:"identitySource"`
 	Available      bool           `json:"available"`
 	TokenStatus    string         `json:"tokenStatus"`
-	OnBehalfOf     *delegatedUser `json:"onBehalfOf,omitempty"`
+	OpenID         string         `json:"openId,omitempty"`
+	UserName       string         `json:"userName,omitempty"`
 	Hint           string         `json:"hint,omitempty"`
 }
 
-// delegatedUser is the user a user-identity acts on behalf of.
-type delegatedUser struct {
-	UserName string `json:"userName,omitempty"`
-	OpenID   string `json:"openId,omitempty"`
-}
-
 // Options holds inputs for the whoami command.
 type Options struct {
 	Factory *cmdutil.Factory
 	As      string
+	JSON    bool
 }
 
 // NewCmdWhoami creates the top-level whoami command. It reports the identity
 // that the next API call would actually use (resolved via Factory.ResolveAs),
-// together with the active profile, app, and token status. Output is always
-// JSON — whoami is consumed by agents. With the built-in credential path it is
-// local-only; when an external credential provider manages tokens, resolving
-// the identity may contact that provider.
+// together with the active profile, app, and token status. It is local-only:
+// no network calls are made.
 func NewCmdWhoami(f *cmdutil.Factory) *cobra.Command {
 	opts := &Options{Factory: f}
 	cmd := &cobra.Command{
 		Use:   "whoami",
-		Short: "Show the current effective identity, app, profile, and token status (JSON)",
+		Short: "Show the current effective identity, app, profile, and token status",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return whoamiRun(cmd, opts)
 		},
 	}
 	cmdutil.DisableAuthCheck(cmd)
 	cmdutil.AddAPIIdentityFlag(context.Background(), cmd, f, &opts.As)
-	// Output is always JSON. Accept (and ignore) --json so existing
-	// `whoami --json` callers don't break; hide it to avoid implying a non-JSON
-	// mode exists.
-	cmd.Flags().Bool("json", true, "deprecated: output is always JSON")
-	_ = cmd.Flags().MarkHidden("json")
+	cmd.Flags().BoolVar(&opts.JSON, "json", false, "structured JSON output")
 	cmdutil.SetRisk(cmd, "read")
 	return cmd
 }
@@ -82,11 +67,10 @@ func whoamiRun(cmd *cobra.Command, opts *Options) error {
 	ctx := cmd.Context()
 	flagAs := core.Identity(opts.As)
 	as := f.ResolveAs(ctx, cmd, flagAs)
-	// Validate as a real API call does (strict mode, then identity) so whoami
-	// can't preview an identity the next call would refuse.
-	if err := f.CheckStrictMode(ctx, as); err != nil {
-		return err
-	}
+	// Reject an explicit --as that does not resolve to a usable identity, so a
+	// typo like `--as admin` fails clearly instead of echoing back a bogus
+	// identity. Keeps the §5.1 invariant (identity is always user or bot) and
+	// matches how api/service/shortcut commands validate the resolved identity.
 	if err := f.CheckIdentity(as, []string{"user", "bot"}); err != nil {
 		return err
 	}
@@ -98,7 +82,11 @@ func whoamiRun(cmd *cobra.Command, opts *Options) error {
 	)
 	diag := identitydiag.Diagnose(ctx, f, cfg, false)
 	res := buildResult(cfg, as, source, diag)
-	output.PrintJson(f.IOStreams.Out, res)
+	if opts.JSON {
+		output.PrintJson(f.IOStreams.Out, res)
+		return nil
+	}
+	formatPretty(f.IOStreams.Out, res)
 	return nil
 }
 
@@ -106,18 +94,17 @@ func whoamiRun(cmd *cobra.Command, opts *Options) error {
 // Mirrors Factory.ResolveAs precedence: explicit flag wins; otherwise an
 // auto-detected result means auto-detect; otherwise a strict-mode forced
 // identity means strict-mode; otherwise it came from configured default-as.
-// Values are snake_case to match the other enum fields (e.g. tokenStatus).
 func resolveSource(changedAs bool, flagAs core.Identity, autoDetected bool, strictForced core.Identity) string {
 	if changedAs && (flagAs == core.AsUser || flagAs == core.AsBot) {
 		return "flag"
 	}
 	if autoDetected {
-		return "auto_detect"
+		return "auto-detect"
 	}
 	if strictForced != "" {
-		return "strict_mode"
+		return "strict-mode"
 	}
-	return "default_as"
+	return "default-as"
 }
 
 // buildResult maps the resolved identity and local diagnostics into the output.
@@ -135,29 +122,46 @@ func buildResult(cfg *core.CliConfig, as core.Identity, source string, diag iden
 		Identity:       string(as),
 		IdentitySource: source,
 	}
-	// Use the diagnosed hint as-is: it is tailored to the credential source, so
-	// it never says "auth login" when that is blocked under an external provider.
 	switch as {
 	case core.AsBot:
 		res.Available = diag.Bot.Available
 		res.TokenStatus = diag.Bot.Status
 		if !diag.Bot.Available {
-			res.Hint = diag.Bot.Hint
+			res.Hint = "Bot identity not configured. Set app secret or bot token (see `lark-cli config --help`)."
 		}
 	default: // user
 		res.Available = diag.User.Available
-		// Use Status (not the raw TokenStatus) so the vocab matches the bot
-		// branch: "ready" means usable for both. available stays the canonical
-		// usable signal; tokenStatus is the readable state behind it.
-		res.TokenStatus = diag.User.Status
-		// Set onBehalfOf only when a user is actually resolved; an unresolved
-		// user identity (not signed in) has no one to act on behalf of yet.
-		if diag.User.UserName != "" || diag.User.OpenID != "" {
-			res.OnBehalfOf = &delegatedUser{UserName: diag.User.UserName, OpenID: diag.User.OpenID}
+		res.OpenID = diag.User.OpenID
+		res.UserName = diag.User.UserName
+		res.TokenStatus = diag.User.TokenStatus
+		if res.TokenStatus == "" {
+			res.TokenStatus = "missing"
 		}
 		if !diag.User.Available {
-			res.Hint = diag.User.Hint
+			res.Hint = "No usable user token. Run `lark-cli auth login`."
 		}
 	}
 	return res
 }
+
+// formatPretty writes the human-readable one-glance summary.
+func formatPretty(w io.Writer, r *whoamiResult) {
+	fmt.Fprintf(w, "Profile:  %s (%s, %s)\n", r.Profile, r.AppID, r.Brand)
+	fmt.Fprintf(w, "Identity: %s (%s)\n", r.Identity, r.IdentitySource)
+	if r.Identity == string(core.AsUser) && r.UserName != "" {
+		if r.OpenID != "" {
+			fmt.Fprintf(w, "User:     %s (%s)\n", r.UserName, r.OpenID)
+		} else {
+			fmt.Fprintf(w, "User:     %s\n", r.UserName)
+		}
+	}
+	token := r.TokenStatus
+	if !r.Available && r.Hint != "" {
+		token = r.TokenStatus + " — " + r.Hint
+	}
+	// Write the label and value as separate %s args rather than one combined
+	// literal. A single label-colon-value literal trips the public-content
+	// credential scanner as a false-positive credential assignment; splitting
+	// the args avoids it while producing identical output.
+	fmt.Fprintf(w, "%s%s\n", "Token:    ", token)
+}

cmd/whoami/whoami_test.go

@@ -5,19 +5,15 @@ package whoami
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"net/http"
 	"strings"
 	"testing"
 
 	"github.com/larksuite/cli/errs"
-	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/identitydiag"
 )
 
@@ -32,10 +28,10 @@ func TestResolveSource(t *testing.T) {
 	}{
 		{"explicit flag user", true, core.AsUser, false, "", "flag"},
 		{"explicit flag bot", true, core.AsBot, false, "", "flag"},
-		{"flag auto falls through to auto-detect", true, core.AsAuto, true, "", "auto_detect"},
-		{"auto detected", false, "", true, "", "auto_detect"},
-		{"strict mode", false, "", false, core.AsBot, "strict_mode"},
-		{"default_as", false, "", false, "", "default_as"},
+		{"flag auto falls through to auto-detect", true, core.AsAuto, true, "", "auto-detect"},
+		{"auto detected", false, "", true, "", "auto-detect"},
+		{"strict mode", false, "", false, core.AsBot, "strict-mode"},
+		{"default-as", false, "", false, "", "default-as"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -50,19 +46,18 @@ func TestResolveSource(t *testing.T) {
 func TestBuildResult_UserValid(t *testing.T) {
 	cfg := &core.CliConfig{ProfileName: "my-app", AppID: "cli_x", Brand: core.BrandLark, DefaultAs: core.AsAuto}
 	diag := identitydiag.Result{
-		User: identitydiag.Identity{Available: true, Status: "ready", TokenStatus: "valid", OpenID: "ou_x", UserName: "Alice"},
+		User: identitydiag.Identity{Available: true, TokenStatus: "valid", OpenID: "ou_x", UserName: "Alice"},
 	}
-	r := buildResult(cfg, core.AsUser, "auto_detect", diag)
+	r := buildResult(cfg, core.AsUser, "auto-detect", diag)
 
-	if r.Identity != "user" || r.IdentitySource != "auto_detect" {
+	if r.Identity != "user" || r.IdentitySource != "auto-detect" {
 		t.Fatalf("identity/source = %q/%q", r.Identity, r.IdentitySource)
 	}
-	// tokenStatus mirrors the unified Status vocab ("ready"), not the raw "valid".
-	if !r.Available || r.TokenStatus != "ready" {
+	if !r.Available || r.TokenStatus != "valid" {
 		t.Fatalf("available=%v status=%q", r.Available, r.TokenStatus)
 	}
-	if r.OnBehalfOf == nil || r.OnBehalfOf.OpenID != "ou_x" || r.OnBehalfOf.UserName != "Alice" {
-		t.Fatalf("onBehalfOf = %#v, want Alice/ou_x", r.OnBehalfOf)
+	if r.OpenID != "ou_x" || r.UserName != "Alice" {
+		t.Fatalf("openId/userName = %q/%q", r.OpenID, r.UserName)
 	}
 	if r.Hint != "" {
 		t.Fatalf("hint = %q, want empty", r.Hint)
@@ -75,9 +70,9 @@ func TestBuildResult_UserValid(t *testing.T) {
 func TestBuildResult_UserMissingToken(t *testing.T) {
 	cfg := &core.CliConfig{ProfileName: "p", AppID: "cli_x", Brand: core.BrandLark}
 	diag := identitydiag.Result{
-		User: identitydiag.Identity{Available: false, Status: "missing", Hint: "run: lark-cli auth login --help"}, // never logged in
+		User: identitydiag.Identity{Available: false, TokenStatus: ""}, // never logged in
 	}
-	r := buildResult(cfg, core.AsUser, "auto_detect", diag)
+	r := buildResult(cfg, core.AsUser, "auto-detect", diag)
 
 	if r.Available {
 		t.Fatalf("available = true, want false")
@@ -85,10 +80,8 @@ func TestBuildResult_UserMissingToken(t *testing.T) {
 	if r.TokenStatus != "missing" {
 		t.Fatalf("tokenStatus = %q, want missing", r.TokenStatus)
 	}
-	// whoami renders the diagnosed hint verbatim (single source of truth) so it
-	// stays correct for the external-provider path without whoami knowing about it.
-	if r.Hint != diag.User.Hint {
-		t.Fatalf("hint = %q, want propagated %q", r.Hint, diag.User.Hint)
+	if r.Hint == "" {
+		t.Fatalf("hint empty, want guidance")
 	}
 	if r.DefaultAs != "auto" {
 		t.Fatalf("defaultAs = %q, want auto (empty normalized)", r.DefaultAs)
@@ -100,16 +93,16 @@ func TestBuildResult_BotReady(t *testing.T) {
 	diag := identitydiag.Result{
 		Bot: identitydiag.Identity{Available: true, Status: "ready"},
 	}
-	r := buildResult(cfg, core.AsBot, "default_as", diag)
+	r := buildResult(cfg, core.AsBot, "default-as", diag)
 
-	if r.Identity != "bot" || r.IdentitySource != "default_as" {
+	if r.Identity != "bot" || r.IdentitySource != "default-as" {
 		t.Fatalf("identity/source = %q/%q", r.Identity, r.IdentitySource)
 	}
 	if !r.Available || r.TokenStatus != "ready" {
 		t.Fatalf("available=%v status=%q", r.Available, r.TokenStatus)
 	}
-	if r.OnBehalfOf != nil {
-		t.Fatalf("bot must not carry onBehalfOf: %#v", r.OnBehalfOf)
+	if r.OpenID != "" || r.UserName != "" {
+		t.Fatalf("bot must not carry openId/userName: %#v", r)
 	}
 	if r.Hint != "" {
 		t.Fatalf("hint = %q, want empty", r.Hint)
@@ -119,9 +112,9 @@ func TestBuildResult_BotReady(t *testing.T) {
 func TestBuildResult_BotNotConfigured(t *testing.T) {
 	cfg := &core.CliConfig{ProfileName: "p", AppID: "cli_x", Brand: core.BrandFeishu}
 	diag := identitydiag.Result{
-		Bot: identitydiag.Identity{Available: false, Status: "not_configured", Hint: "run: lark-cli config --help"},
+		Bot: identitydiag.Identity{Available: false, Status: "not_configured"},
 	}
-	r := buildResult(cfg, core.AsBot, "auto_detect", diag)
+	r := buildResult(cfg, core.AsBot, "auto-detect", diag)
 
 	if r.Available {
 		t.Fatalf("available = true, want false")
@@ -129,8 +122,58 @@ func TestBuildResult_BotNotConfigured(t *testing.T) {
 	if r.TokenStatus != "not_configured" {
 		t.Fatalf("tokenStatus = %q, want not_configured", r.TokenStatus)
 	}
-	if r.Hint != diag.Bot.Hint {
-		t.Fatalf("hint = %q, want propagated %q", r.Hint, diag.Bot.Hint)
+	if r.Hint == "" {
+		t.Fatalf("hint empty, want guidance")
+	}
+}
+
+func TestFormatPretty_User(t *testing.T) {
+	var buf bytes.Buffer
+	formatPretty(&buf, &whoamiResult{
+		Profile: "my-app", AppID: "cli_x", Brand: core.BrandLark,
+		Identity: "user", IdentitySource: "auto-detect",
+		Available: true, TokenStatus: "valid", OpenID: "ou_x", UserName: "Alice",
+	})
+	out := buf.String()
+	for _, want := range []string{
+		"Profile:  my-app (cli_x, lark)",
+		"Identity: user (auto-detect)",
+		"User:     Alice (ou_x)",
+		"Token:    valid",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("output missing %q\n--- got ---\n%s", want, out)
+		}
+	}
+}
+
+func TestFormatPretty_BotNoUserLine(t *testing.T) {
+	var buf bytes.Buffer
+	formatPretty(&buf, &whoamiResult{
+		Profile: "p", AppID: "cli_x", Brand: core.BrandFeishu,
+		Identity: "bot", IdentitySource: "default-as",
+		Available: true, TokenStatus: "ready",
+	})
+	out := buf.String()
+	if strings.Contains(out, "User:") {
+		t.Errorf("bot output must not contain User: line\n%s", out)
+	}
+	if !strings.Contains(out, "Identity: bot (default-as)") || !strings.Contains(out, "Token:    ready") {
+		t.Errorf("unexpected bot output:\n%s", out)
+	}
+}
+
+func TestFormatPretty_UnavailableShowsHint(t *testing.T) {
+	var buf bytes.Buffer
+	formatPretty(&buf, &whoamiResult{
+		Profile: "p", AppID: "cli_x", Brand: core.BrandLark,
+		Identity: "user", IdentitySource: "auto-detect",
+		Available: false, TokenStatus: "missing",
+		Hint: "No usable user token. Run `lark-cli auth login`.",
+	})
+	out := buf.String()
+	if !strings.Contains(out, "Token:    missing — No usable user token.") {
+		t.Errorf("expected token line with hint, got:\n%s", out)
 	}
 }
 
@@ -140,7 +183,7 @@ func TestWhoami_BotJSON(t *testing.T) {
 	})
 
 	cmd := NewCmdWhoami(f)
-	cmd.SetArgs([]string{}) // bare whoami: output is always JSON, no flag needed
+	cmd.SetArgs([]string{"--json"})
 	if err := cmd.Execute(); err != nil {
 		t.Fatalf("Execute() error = %v", err)
 	}
@@ -161,8 +204,8 @@ func TestWhoami_BotJSON(t *testing.T) {
 	if got.IdentitySource == "" {
 		t.Fatalf("identitySource empty")
 	}
-	if got.OnBehalfOf != nil {
-		t.Fatalf("bot (self) must not carry onBehalfOf: %#v", got.OnBehalfOf)
+	if got.OpenID != "" {
+		t.Fatalf("bot must not carry openId: %q", got.OpenID)
 	}
 }
 
@@ -213,108 +256,3 @@ func TestWhoami_ConfigErrorPropagates(t *testing.T) {
 		t.Fatalf("Execute() error = %v, want it to wrap %v", err, wantErr)
 	}
 }
-
-func TestWhoami_StrictModeRejectsCrossIdentity(t *testing.T) {
-	// Bot-only account → strict mode bot. A real `--as user` call would be
-	// rejected by CheckStrictMode; whoami must reject it identically rather than
-	// previewing a user identity the next call would refuse.
-	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
-		ProfileName: "p", AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-		SupportedIdentities: 2, // bot only
-	})
-	cmd := NewCmdWhoami(f)
-	cmd.SetArgs([]string{"--as", "user", "--json"})
-	err := cmd.Execute()
-	if err == nil {
-		t.Fatalf("Execute() with --as user under strict bot = nil, want strict-mode rejection")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("error type = %T, want *errs.ValidationError: %v", err, err)
-	}
-}
-
-type fakeExtProvider struct {
-	name    string
-	account *extcred.Account
-}
-
-func (p *fakeExtProvider) Name() string { return p.name }
-func (p *fakeExtProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
-	return p.account, nil
-}
-func (p *fakeExtProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
-	return nil, nil // no UAT served locally; whoami runs with verify=false
-}
-
-func externalWhoamiFactory(cfg *core.CliConfig) (*cmdutil.Factory, *bytes.Buffer) {
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: cfg.AppID}}},
-		nil, nil,
-		func() (*http.Client, error) { return nil, nil },
-	)
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{
-		Config:     func() (*core.CliConfig, error) { return cfg, nil },
-		Credential: cred,
-		IOStreams:  &cmdutil.IOStreams{Out: out, ErrOut: &bytes.Buffer{}},
-	}
-	return f, out
-}
-
-// Regression for the external-provider blind spot: with credentials managed by
-// an extension provider, a signed-in user must read as available, and an
-// unavailable identity must not be told to "auth login" (which is blocked).
-func TestWhoami_ExternalProvider_UserReady(t *testing.T) {
-	cfg := &core.CliConfig{
-		ProfileName: "p", AppID: "cli_x", Brand: core.BrandFeishu,
-		SupportedIdentities: uint8(extcred.SupportsAll), UserOpenId: "ou_x", UserName: "Alice",
-	}
-	f, out := externalWhoamiFactory(cfg)
-
-	cmd := NewCmdWhoami(f)
-	cmd.SetArgs([]string{"--as", "user", "--json"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("Execute() error = %v", err)
-	}
-	var got whoamiResult
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("Unmarshal: %v\n%s", err, out.String())
-	}
-	if got.Identity != "user" || !got.Available || got.TokenStatus != "ready" {
-		t.Fatalf("got %#v, want user/available/ready", got)
-	}
-	if got.OnBehalfOf == nil || got.OnBehalfOf.UserName != "Alice" || got.OnBehalfOf.OpenID != "ou_x" {
-		t.Fatalf("onBehalfOf = %#v, want Alice/ou_x (delegated)", got.OnBehalfOf)
-	}
-	if got.Hint != "" {
-		t.Fatalf("hint = %q, want empty when available", got.Hint)
-	}
-}
-
-func TestWhoami_ExternalProvider_UserHintNotKeychain(t *testing.T) {
-	cfg := &core.CliConfig{
-		ProfileName: "p", AppID: "cli_x", Brand: core.BrandFeishu,
-		SupportedIdentities: uint8(extcred.SupportsUser), // user supported but not signed in
-	}
-	f, out := externalWhoamiFactory(cfg)
-
-	cmd := NewCmdWhoami(f)
-	cmd.SetArgs([]string{"--as", "user", "--json"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("Execute() error = %v", err)
-	}
-	var got whoamiResult
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("Unmarshal: %v\n%s", err, out.String())
-	}
-	if got.Identity != "user" || got.Available {
-		t.Fatalf("got identity=%q available=%v, want user/false", got.Identity, got.Available)
-	}
-	if strings.Contains(got.Hint, "auth login") {
-		t.Fatalf("hint must not point at auth login under external provider: %q", got.Hint)
-	}
-	if !strings.Contains(got.Hint, "external") {
-		t.Fatalf("hint should explain external management: %q", got.Hint)
-	}
-}

errs/ERROR_CONTRACT.md

@@ -72,28 +72,6 @@ other category. `error.type` is `"policy"`, `error.subtype` is one of
 `challenge_required` / `access_denied`, and process exit is `6` via
 `CategoryPolicy`.
 
-### Success envelope (stdout)
-
-For contrast: success responses render to **stdout** as an
-`output.Envelope` (`internal/output/envelope.go`), exit code `0`:
-
-```json
-{
-  "ok": true,
-  "identity": "user",
-  "data": { "guid": "e297d3d0-..." },
-  "meta": { "count": 1 }
-}
-```
-
-Consumers must branch on `ok` (or the process exit code). The success
-envelope has **no top-level `code` or `msg` field** — `code` exists only
-inside `error`, where it is the upstream numeric code (invariant 4).
-Wrappers that follow the raw OpenAPI convention and test `code == 0`
-will misclassify every successful call as a failure, which is
-especially dangerous around write commands (e.g. retrying a create that
-already succeeded).
-
 ## Categories
 
 | Category | When | Exit | Typed struct |

errs/types_test.go

@@ -319,7 +319,7 @@ func TestPermissionError_FullChain(t *testing.T) {
 		WithHint("run: lark-cli auth login --scope %q", "mail:user_mailbox.message:send").
 		WithMissingScopes("mail:user_mailbox.message:send").
 		WithIdentity("user").
-		WithConsoleURL("https://open.feishu.cn/page/scope-apply?clientID=cli_xxx&scopes=mail:user_mailbox.message:send")
+		WithConsoleURL("https://open.feishu.cn/app/cli_xxx/auth")
 
 	if got.Category != errs.CategoryAuthorization {
 		t.Errorf("Category = %q, want %q", got.Category, errs.CategoryAuthorization)
@@ -419,7 +419,7 @@ func TestBuilder_WireFormat(t *testing.T) {
 		WithHint("run lark-cli auth login --scope calendar:event:create").
 		WithMissingScopes("calendar:event:create").
 		WithIdentity("user").
-		WithConsoleURL("https://open.feishu.cn/page/scope-apply?clientID=cli_xxx&scopes=calendar:event:create")
+		WithConsoleURL("https://open.feishu.cn/app/cli_xxx/auth")
 
 	buf, err := json.Marshal(e)
 	if err != nil {
@@ -439,7 +439,7 @@ func TestBuilder_WireFormat(t *testing.T) {
 		"hint":           "run lark-cli auth login --scope calendar:event:create",
 		"log_id":         "20260520-0a1b2c3d",
 		"identity":       "user",
-		"console_url":    "https://open.feishu.cn/page/scope-apply?clientID=cli_xxx&scopes=calendar:event:create",
+		"console_url":    "https://open.feishu.cn/app/cli_xxx/auth",
 		"missing_scopes": []any{"calendar:event:create"},
 	}
 	for k, want := range wantFields {

internal/affordance/affordance.go

@@ -77,10 +77,14 @@ func loadService(service string) map[string]json.RawMessage {
 // space→dot fallback covers domains where the two already coincide.
 func commandFormResolver(service string) func(string) string {
 	byForm := map[string]string{}
-	if svc, ok := registry.SchemaCatalog().Service(service); ok {
+	for _, svc := range registry.EmbeddedServicesTyped() {
+		if svc.Name != service {
+			continue
+		}
 		for _, ref := range apicatalog.ServiceMethods(svc, nil) {
 			byForm[strings.Join(ref.CommandPath()[1:], " ")] = ref.Method.ID
 		}
+		break
 	}
 	return func(h string) string {
 		h = strings.TrimSpace(h)

internal/cmdutil/iostreams.go

@@ -18,9 +18,6 @@ type IOStreams struct {
 	Out        io.Writer
 	ErrOut     io.Writer
 	IsTerminal bool
-	// OutIsTerminal reports whether Out is an interactive terminal. Mirrors
-	// IsTerminal; computed once in NewIOStreams and assignable directly in tests.
-	OutIsTerminal bool
 	// StderrIsTerminal reports whether ErrOut is an interactive terminal.
 	// Advisory warnings written to stderr (e.g. the proxy notice) gate on this
 	// so they stay out of non-interactive output (pipes, CI, agent runs).
@@ -30,24 +27,19 @@ type IOStreams struct {
 }
 
 // NewIOStreams builds an IOStreams from arbitrary readers/writers.
-// IsTerminal / OutIsTerminal / StderrIsTerminal are each derived from the
-// underlying *os.File of in / out / errOut respectively; non-file
-// readers/writers (bytes.Buffer, strings.Reader, …) yield false.
+// IsTerminal / StderrIsTerminal are derived from in's / errOut's underlying
+// *os.File, if any; non-file streams (bytes.Buffer, strings.Reader, …) yield
+// false.
 func NewIOStreams(in io.Reader, out, errOut io.Writer) *IOStreams {
-	fileIsTerminal := func(v any) bool {
-		if f, ok := v.(*os.File); ok {
-			return term.IsTerminal(int(f.Fd()))
-		}
-		return false
+	isTerminal := false
+	if f, ok := in.(*os.File); ok {
+		isTerminal = term.IsTerminal(int(f.Fd()))
 	}
-	return &IOStreams{
-		In:               in,
-		Out:              out,
-		ErrOut:           errOut,
-		IsTerminal:       fileIsTerminal(in),
-		OutIsTerminal:    fileIsTerminal(out),
-		StderrIsTerminal: fileIsTerminal(errOut),
+	stderrIsTerminal := false
+	if f, ok := errOut.(*os.File); ok {
+		stderrIsTerminal = term.IsTerminal(int(f.Fd()))
 	}
+	return &IOStreams{In: in, Out: out, ErrOut: errOut, IsTerminal: isTerminal, StderrIsTerminal: stderrIsTerminal}
 }
 
 // SystemIO creates an IOStreams wired to the process's standard file descriptors.

internal/cmdutil/iostreams_test.go

@@ -1,31 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"bytes"
-	"os"
-	"testing"
-)
-
-func TestNewIOStreamsTerminalFlagsNonFile(t *testing.T) {
-	s := NewIOStreams(&bytes.Buffer{}, &bytes.Buffer{}, &bytes.Buffer{})
-	if s.IsTerminal || s.OutIsTerminal || s.StderrIsTerminal {
-		t.Errorf("non-file streams must not be terminals: in=%v out=%v err=%v",
-			s.IsTerminal, s.OutIsTerminal, s.StderrIsTerminal)
-	}
-}
-
-func TestNewIOStreamsTerminalFlagsPipe(t *testing.T) {
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-	defer w.Close()
-	s := NewIOStreams(r, w, w)
-	if s.OutIsTerminal || s.StderrIsTerminal {
-		t.Errorf("os.Pipe must not be a terminal: out=%v err=%v", s.OutIsTerminal, s.StderrIsTerminal)
-	}
-}

internal/cmdutil/secheader.go

@@ -6,10 +6,12 @@ package cmdutil
 import (
 	"context"
 	"net/http"
+	"os"
 	"reflect"
 	"runtime/debug"
 	"strings"
 	"sync"
+	"unicode"
 
 	"github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/extension/fileio"
@@ -38,6 +40,8 @@ const (
 	BuildKindUnknown  = "unknown"
 
 	officialModulePath = "github.com/larksuite/cli"
+
+	agentTraceMaxLen = 1024
 )
 
 // UserAgentValue returns the User-Agent value: "lark-cli/{version}".
@@ -45,6 +49,25 @@ func UserAgentValue() string {
 	return SourceValue + "/" + build.Version
 }
 
+// AgentTraceValue returns a header-safe value from the
+// LARKSUITE_CLI_AGENT_TRACE environment variable. It trims
+// surrounding whitespace, rejects values containing any Unicode
+// control character or exceeding agentTraceMaxLen, and returns ""
+// for any invalid or empty value. Callers can use the result
+// directly in HTTP headers without further sanitisation.
+func AgentTraceValue() string {
+	v := strings.TrimSpace(os.Getenv(envvars.CliAgentTrace))
+	if v == "" || len(v) > agentTraceMaxLen {
+		return ""
+	}
+	for _, r := range v {
+		if unicode.IsControl(r) {
+			return ""
+		}
+	}
+	return v
+}
+
 // BaseSecurityHeaders returns headers that every request must carry.
 func BaseSecurityHeaders() http.Header {
 	h := make(http.Header)
@@ -52,7 +75,7 @@ func BaseSecurityHeaders() http.Header {
 	h.Set(HeaderVersion, build.Version)
 	h.Set(HeaderBuild, DetectBuildKind())
 	h.Set(HeaderUserAgent, UserAgentValue())
-	if v := envvars.AgentTrace(); v != "" {
+	if v := AgentTraceValue(); v != "" {
 		h.Set(HeaderAgentTrace, v)
 	}
 	return h

internal/cmdutil/secheader_test.go

@@ -6,6 +6,7 @@ package cmdutil
 import (
 	"context"
 	"net/http"
+	"strings"
 	"testing"
 
 	"github.com/larksuite/cli/extension/credential"
@@ -263,9 +264,88 @@ func TestBaseSecurityHeaders_AllRequiredHeaders(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-// HeaderAgentTrace injection (via BaseSecurityHeaders)
+// AgentTraceValue / HeaderAgentTrace
 // ---------------------------------------------------------------------------
 
+func TestAgentTraceValue_EmptyWhenEnvUnset(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty when env unset", got)
+	}
+}
+
+func TestAgentTraceValue_ReturnsCleanValue(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "trace-abc-123")
+	if got := AgentTraceValue(); got != "trace-abc-123" {
+		t.Fatalf("AgentTraceValue() = %q, want %q", got, "trace-abc-123")
+	}
+}
+
+func TestAgentTraceValue_TrimsWhitespace(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "  trace-trim  ")
+	if got := AgentTraceValue(); got != "trace-trim" {
+		t.Fatalf("AgentTraceValue() = %q, want %q (whitespace trimmed)", got, "trace-trim")
+	}
+}
+
+func TestAgentTraceValue_OnlyWhitespace_ReturnsEmpty(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "   ")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty for whitespace-only value", got)
+	}
+}
+
+func TestAgentTraceValue_RejectsCRLF(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "val\r\nX-Evil: attack")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty for CR/LF value", got)
+	}
+}
+
+func TestAgentTraceValue_RejectsLF(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "val\nX-Evil: attack")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty for LF value", got)
+	}
+}
+
+func TestAgentTraceValue_RejectsTab(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "val\tinjected")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty for tab value", got)
+	}
+}
+
+func TestAgentTraceValue_RejectsControlChar(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "val\x01injected")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty for control char value", got)
+	}
+}
+
+func TestAgentTraceValue_RejectsDEL(t *testing.T) {
+	t.Setenv(envvars.CliAgentTrace, "val\x7finjected")
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() = %q, want empty for DEL value", got)
+	}
+}
+
+func TestAgentTraceValue_RejectsOverlongValue(t *testing.T) {
+	longVal := strings.Repeat("a", agentTraceMaxLen+1)
+	t.Setenv(envvars.CliAgentTrace, longVal)
+	if got := AgentTraceValue(); got != "" {
+		t.Fatalf("AgentTraceValue() returned non-empty for %d-byte value (max %d)", len(longVal), agentTraceMaxLen)
+	}
+}
+
+func TestAgentTraceValue_AcceptsMaxLengthValue(t *testing.T) {
+	val := strings.Repeat("a", agentTraceMaxLen)
+	t.Setenv(envvars.CliAgentTrace, val)
+	if got := AgentTraceValue(); got != val {
+		t.Fatalf("AgentTraceValue() = %q, want %d-byte value accepted", got, agentTraceMaxLen)
+	}
+}
+
 func TestBaseSecurityHeaders_NoAgentTraceHeaderWhenEnvUnset(t *testing.T) {
 	t.Setenv(envvars.CliAgentTrace, "")
 	h := BaseSecurityHeaders()

internal/envvars/envvars.go

@@ -19,7 +19,6 @@ const (
 	// Content safety scanning mode
 	CliContentSafetyMode = "LARKSUITE_CLI_CONTENT_SAFETY_MODE"
 
-	CliAgentName  = "LARKSUITE_CLI_AGENT_NAME"
 	CliAgentTrace = "LARKSUITE_CLI_AGENT_TRACE"
 
 	CliProxyEnable  = "LARKSUITE_CLI_PROXY_ENABLE"

internal/envvars/read.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package envvars
-
-import (
-	"os"
-	"strings"
-	"unicode"
-)
-
-const (
-	agentNameMaxLen  = 128
-	agentTraceMaxLen = 1024
-)
-
-func AgentName() string {
-	return sanitizeSingleLine(os.Getenv(CliAgentName), agentNameMaxLen)
-}
-
-func AgentTrace() string {
-	return sanitizeSingleLine(os.Getenv(CliAgentTrace), agentTraceMaxLen)
-}
-
-func sanitizeSingleLine(raw string, maxLen int) string {
-	v := strings.TrimSpace(raw)
-	if v == "" || len(v) > maxLen {
-		return ""
-	}
-	for _, r := range v {
-		if unicode.IsControl(r) {
-			return ""
-		}
-	}
-	return v
-}

internal/envvars/read_test.go

@@ -1,131 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package envvars
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestAgentName_EmptyWhenEnvUnset(t *testing.T) {
-	t.Setenv(CliAgentName, "")
-	if got := AgentName(); got != "" {
-		t.Fatalf("AgentName() = %q, want empty when env unset", got)
-	}
-}
-
-func TestAgentName_ReturnsCleanValue(t *testing.T) {
-	t.Setenv(CliAgentName, "claude-code")
-	if got := AgentName(); got != "claude-code" {
-		t.Fatalf("AgentName() = %q, want %q", got, "claude-code")
-	}
-}
-
-func TestAgentName_TrimsWhitespace(t *testing.T) {
-	t.Setenv(CliAgentName, "  cursor  ")
-	if got := AgentName(); got != "cursor" {
-		t.Fatalf("AgentName() = %q, want %q (whitespace trimmed)", got, "cursor")
-	}
-}
-
-func TestAgentName_RejectsCRLFInjection(t *testing.T) {
-	t.Setenv(CliAgentName, "agent\r\nX-Evil: attack")
-	if got := AgentName(); got != "" {
-		t.Fatalf("AgentName() = %q, want empty for CR/LF value", got)
-	}
-}
-
-func TestAgentName_RejectsControlChar(t *testing.T) {
-	t.Setenv(CliAgentName, "agent\x01injected")
-	if got := AgentName(); got != "" {
-		t.Fatalf("AgentName() = %q, want empty for control char value", got)
-	}
-}
-
-func TestAgentName_RejectsOverlongValue(t *testing.T) {
-	longVal := strings.Repeat("a", agentNameMaxLen+1)
-	t.Setenv(CliAgentName, longVal)
-	if got := AgentName(); got != "" {
-		t.Fatalf("AgentName() returned non-empty for %d-byte value (max %d)", len(longVal), agentNameMaxLen)
-	}
-}
-
-func TestAgentTrace_EmptyWhenEnvUnset(t *testing.T) {
-	t.Setenv(CliAgentTrace, "")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty when env unset", got)
-	}
-}
-
-func TestAgentTrace_ReturnsCleanValue(t *testing.T) {
-	t.Setenv(CliAgentTrace, "trace-abc-123")
-	if got := AgentTrace(); got != "trace-abc-123" {
-		t.Fatalf("AgentTrace() = %q, want %q", got, "trace-abc-123")
-	}
-}
-
-func TestAgentTrace_TrimsWhitespace(t *testing.T) {
-	t.Setenv(CliAgentTrace, "  trace-trim  ")
-	if got := AgentTrace(); got != "trace-trim" {
-		t.Fatalf("AgentTrace() = %q, want %q (whitespace trimmed)", got, "trace-trim")
-	}
-}
-
-func TestAgentTrace_OnlyWhitespace_ReturnsEmpty(t *testing.T) {
-	t.Setenv(CliAgentTrace, "   ")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty for whitespace-only value", got)
-	}
-}
-
-func TestAgentTrace_RejectsCRLF(t *testing.T) {
-	t.Setenv(CliAgentTrace, "val\r\nX-Evil: attack")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty for CR/LF value", got)
-	}
-}
-
-func TestAgentTrace_RejectsLF(t *testing.T) {
-	t.Setenv(CliAgentTrace, "val\nX-Evil: attack")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty for LF value", got)
-	}
-}
-
-func TestAgentTrace_RejectsTab(t *testing.T) {
-	t.Setenv(CliAgentTrace, "val\tinjected")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty for tab value", got)
-	}
-}
-
-func TestAgentTrace_RejectsControlChar(t *testing.T) {
-	t.Setenv(CliAgentTrace, "val\x01injected")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty for control char value", got)
-	}
-}
-
-func TestAgentTrace_RejectsDEL(t *testing.T) {
-	t.Setenv(CliAgentTrace, "val\x7finjected")
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() = %q, want empty for DEL value", got)
-	}
-}
-
-func TestAgentTrace_RejectsOverlongValue(t *testing.T) {
-	longVal := strings.Repeat("a", agentTraceMaxLen+1)
-	t.Setenv(CliAgentTrace, longVal)
-	if got := AgentTrace(); got != "" {
-		t.Fatalf("AgentTrace() returned non-empty for %d-byte value (max %d)", len(longVal), agentTraceMaxLen)
-	}
-}
-
-func TestAgentTrace_AcceptsMaxLengthValue(t *testing.T) {
-	val := strings.Repeat("a", agentTraceMaxLen)
-	t.Setenv(CliAgentTrace, val)
-	if got := AgentTrace(); got != val {
-		t.Fatalf("AgentTrace() = %q, want %d-byte value accepted", got, agentTraceMaxLen)
-	}
-}

internal/errclass/classify.go

@@ -10,14 +10,12 @@ import (
 	"strings"
 
 	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/core"
 )
 
 // ClassifyContext is the contextual data BuildAPIError uses to populate
 // identity-aware fields on typed errors (PermissionError.Identity / ConsoleURL).
-// Brand and Identity are plain strings at this boundary; ConsoleURL normalizes
-// Brand through core.ParseBrand, so callers can pass a raw brand string without
-// coupling this contract to core's brand enum.
+// Identity is a plain string ("user" / "bot" / "") so this package does not
+// depend on internal/core (which would create an import cycle).
 type ClassifyContext struct {
 	Brand    string // "feishu" | "lark" — drives console_url host
 	AppID    string // placed in console_url
@@ -446,27 +444,28 @@ func extractMissingScopes(resp map[string]any) []string {
 	return out
 }
 
-// ConsoleURL composes the Feishu/Lark open-platform application-scope apply
-// page URL (the official open-pages `/page/scope-apply` entry), suitable for
-// PermissionError.ConsoleURL. Empty appID → empty string. Empty scopes list
-// returns the page carrying only clientID; otherwise scopes are joined with
-// commas in the `scopes` query parameter so the console can pre-select them.
+// ConsoleURL composes the Feishu/Lark open-platform scope-grant console URL,
+// suitable for PermissionError.ConsoleURL. Empty appID → empty string. Empty
+// scopes list returns the bare /auth landing page; scopes are joined with
+// commas in the `q` query parameter so the console can pre-select them.
 //
 // brand is "feishu" or "lark"; unknown values default to feishu.
 func ConsoleURL(brand, appID string, scopes []string) string {
 	if appID == "" {
 		return ""
 	}
-	// QueryEscape both values — clientID and scopes both sit in the query
-	// string, and untrusted content must not be able to inject extra query
-	// parameters via `&`/`#`. The brand→host mapping is owned by core so the
-	// open-platform base URL stays a single source of truth.
-	base := fmt.Sprintf("%s/page/scope-apply?clientID=%s",
-		core.ResolveOpenBaseURL(core.ParseBrand(brand)), url.QueryEscape(appID))
-	if len(scopes) == 0 {
-		return base
+	host := "open.feishu.cn"
+	if brand == "lark" {
+		host = "open.larksuite.com"
 	}
-	return base + "&scopes=" + url.QueryEscape(strings.Join(scopes, ","))
+	// PathEscape on appID — it sits in the URL path. QueryEscape on the
+	// comma-joined scopes — they sit in the `?q=` value, and untrusted scope
+	// content must not be able to inject extra query parameters via `&`/`#`.
+	pathID := url.PathEscape(appID)
+	if len(scopes) == 0 {
+		return fmt.Sprintf("https://%s/app/%s/auth", host, pathID)
+	}
+	return fmt.Sprintf("https://%s/app/%s/auth?q=%s", host, pathID, url.QueryEscape(strings.Join(scopes, ",")))
 }
 
 func intFromAny(v any) int {

internal/errclass/classify_test.go

@@ -422,8 +422,8 @@ func TestConsoleURL_FeishuBrand(t *testing.T) {
 	if !ok {
 		t.Fatalf("expected *errs.PermissionError, got %T", err)
 	}
-	if !strings.Contains(pe.ConsoleURL, "open.feishu.cn/page/scope-apply?clientID=cli_a123") {
-		t.Fatalf("ConsoleURL = %q, want open.feishu.cn scope-apply page", pe.ConsoleURL)
+	if !strings.Contains(pe.ConsoleURL, "open.feishu.cn/app/cli_a123") {
+		t.Fatalf("ConsoleURL = %q, want open.feishu.cn prefix", pe.ConsoleURL)
 	}
 }
 
@@ -434,8 +434,8 @@ func TestConsoleURL_LarkBrand(t *testing.T) {
 	if !ok {
 		t.Fatalf("expected *errs.PermissionError, got %T", err)
 	}
-	if !strings.Contains(pe.ConsoleURL, "open.larksuite.com/page/scope-apply?clientID=cli_a123") {
-		t.Fatalf("ConsoleURL = %q, want open.larksuite.com scope-apply page", pe.ConsoleURL)
+	if !strings.Contains(pe.ConsoleURL, "open.larksuite.com/app/cli_a123") {
+		t.Fatalf("ConsoleURL = %q, want open.larksuite.com prefix", pe.ConsoleURL)
 	}
 }
 
@@ -485,35 +485,35 @@ func TestConsoleURL_EscapesDangerousChars(t *testing.T) {
 			name:      "ampersand in scope smuggles extra param",
 			appID:     "cli_good",
 			scopes:    []string{"scope&evil=injected"},
-			wantInURL: []string{"scopes=scope%26evil%3Dinjected"},
-			denyInURL: []string{"scopes=scope&evil=injected"},
+			wantInURL: []string{"q=scope%26evil%3Dinjected"},
+			denyInURL: []string{"q=scope&evil=injected"},
 		},
 		{
 			name:      "hash in scope splits fragment",
 			appID:     "cli_good",
 			scopes:    []string{"scope#fragment"},
-			wantInURL: []string{"scopes=scope%23fragment"},
-			denyInURL: []string{"scopes=scope#fragment"},
+			wantInURL: []string{"q=scope%23fragment"},
+			denyInURL: []string{"q=scope#fragment"},
 		},
 		{
 			name:      "question mark in appID prematurely opens query",
 			appID:     "good?q=injected",
 			scopes:    []string{"docx:document"},
-			wantInURL: []string{"clientID=good%3Fq%3Dinjected"},
-			denyInURL: []string{"clientID=good?q=injected"},
+			wantInURL: []string{"/app/good%3Fq=injected/auth"},
+			denyInURL: []string{"/app/good?q=injected/auth"},
 		},
 		{
 			name:      "hash in appID truncates URL",
 			appID:     "good#fragment",
 			scopes:    []string{"docx:document"},
-			wantInURL: []string{"clientID=good%23fragment"},
-			denyInURL: []string{"clientID=good#fragment"},
+			wantInURL: []string{"/app/good%23fragment/auth"},
+			denyInURL: []string{"/app/good#fragment/auth"},
 		},
 		{
-			name:      "slash in appID does not open a new path segment",
+			name:      "slash in appID escapes path segment",
 			appID:     "good/extra/segment",
 			scopes:    []string{"docx:document"},
-			wantInURL: []string{"clientID=good%2Fextra%2Fsegment"},
+			wantInURL: []string{"/app/good%2Fextra%2Fsegment/auth"},
 		},
 	}
 
@@ -553,8 +553,8 @@ func TestPermissionError_NoViolations(t *testing.T) {
 	if pe.MissingScopes != nil {
 		t.Errorf("MissingScopes should be nil; got %v", pe.MissingScopes)
 	}
-	if !strings.HasSuffix(pe.ConsoleURL, "/page/scope-apply?clientID=cli_a123") {
-		t.Errorf("ConsoleURL (no scopes) = %q, want trailing /page/scope-apply?clientID=cli_a123", pe.ConsoleURL)
+	if !strings.HasSuffix(pe.ConsoleURL, "/app/cli_a123/auth") {
+		t.Errorf("ConsoleURL (no scopes) = %q, want trailing /app/cli_a123/auth", pe.ConsoleURL)
 	}
 }
 
@@ -758,7 +758,7 @@ func TestBuildPermissionHint_AppMissingScopeRoutesToConsole(t *testing.T) {
 	// at the app level — re-authenticating cannot fix it. The hint must
 	// point to the developer console regardless of caller identity, or
 	// agents will loop on `auth login` forever.
-	consoleURL := "https://open.feishu.cn/page/scope-apply?clientID=cli_x&scopes=contact%3Acontact"
+	consoleURL := "https://open.feishu.cn/app/cli_x/auth?q=contact%3Acontact"
 	for _, identity := range []string{"user", "bot", ""} {
 		got := errclass.PermissionHint([]string{"contact:contact"}, identity, errs.SubtypeAppScopeNotApplied, consoleURL)
 		if !strings.Contains(got, "developer console") {

internal/errclass/codemeta_drive.go

@@ -10,22 +10,8 @@ import "github.com/larksuite/cli/errs"
 // ambiguous codes fall back to CategoryAPI via BuildAPIError.
 // BuildAPIError consumes this map via mergeCodeMeta + LookupCodeMeta.
 var driveCodeMeta = map[int]CodeMeta{
-	1061001:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeServerError, Retryable: true}, // Drive "unknown error"
-	1061002:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // params error
-	1061004:   {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied},   // forbidden
-	1061007:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},                     // file has been deleted
-	1061043:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},                // file size beyond limit
-	1061044:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},                     // parent folder does not exist (upload)
-	1061101:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},                // file quota exceeded
-	1062009:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // actual size inconsistent with declared size
-	1063001:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // secure label invalid parameter
-	1063002:   {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied},   // secure label permission denied
-	1063013:   {Category: errs.CategoryValidation, Subtype: errs.SubtypeFailedPrecondition},    // secure label downgrade requires approval
-	1069302:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // comment endpoint "Invalid or missing parameters"
-	99992402:  {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // platform field validation failed
-	9499:      {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // invalid parameter type in JSON field
-	2200:      {Category: errs.CategoryAPI, Subtype: errs.SubtypeServerError, Retryable: true}, // Drive tenant/internal errors
-	233523001: {Category: errs.CategoryAPI, Subtype: errs.SubtypeServerError, Retryable: true}, // Drive/docs transient server error
+	1061044: {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},          // parent folder does not exist (upload)
+	1069302: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters}, // comment endpoint "Invalid or missing parameters"
 }
 
 func init() { mergeCodeMeta(driveCodeMeta, "drive") }

internal/errclass/codemeta_drive_test.go

@@ -27,13 +27,6 @@ func TestLookupCodeMeta_DriveCodes(t *testing.T) {
 		// 1069302: comment endpoint's opaque "Invalid or missing parameters"
 		// (shortcuts/drive/drive_add_comment.go) → API-side parameter rejection.
 		{1069302, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
-		// Secure label endpoint codes observed from drive +secure-label-update
-		// failure telemetry.
-		{1063001, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
-		{1063002, errs.CategoryAuthorization, errs.SubtypePermissionDenied, false},
-		{1063013, errs.CategoryValidation, errs.SubtypeFailedPrecondition, false},
-		{99992402, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
-		{9499, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
 	}
 	for _, tc := range cases {
 		t.Run(fmt.Sprintf("%d", tc.code), func(t *testing.T) {

internal/errclass/codemeta_test.go

@@ -102,62 +102,6 @@ func TestLookupCodeMeta_RetryableRateLimit(t *testing.T) {
 	}
 }
 
-func TestLookupCodeMeta_DrivePushCodes(t *testing.T) {
-	cases := []struct {
-		code        int
-		wantCat     errs.Category
-		wantSubtype errs.Subtype
-		wantRetry   bool
-	}{
-		{1061001, errs.CategoryAPI, errs.SubtypeServerError, true},
-		{1061002, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
-		{1061004, errs.CategoryAuthorization, errs.SubtypePermissionDenied, false},
-		{1061007, errs.CategoryAPI, errs.SubtypeNotFound, false},
-		{1061043, errs.CategoryAPI, errs.SubtypeQuotaExceeded, false},
-		{1061101, errs.CategoryAPI, errs.SubtypeQuotaExceeded, false},
-		{1062009, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
-		{2200, errs.CategoryAPI, errs.SubtypeServerError, true},
-		{233523001, errs.CategoryAPI, errs.SubtypeServerError, true},
-	}
-	for _, tc := range cases {
-		t.Run(fmt.Sprintf("%d", tc.code), func(t *testing.T) {
-			got, ok := LookupCodeMeta(tc.code)
-			if !ok {
-				t.Fatalf("LookupCodeMeta(%d) ok=false, want true", tc.code)
-			}
-			if got.Category != tc.wantCat || got.Subtype != tc.wantSubtype || got.Retryable != tc.wantRetry {
-				t.Fatalf("LookupCodeMeta(%d) = %+v, want Category=%v Subtype=%v Retryable=%v",
-					tc.code, got, tc.wantCat, tc.wantSubtype, tc.wantRetry)
-			}
-		})
-	}
-}
-
-func TestLookupCodeMeta_WikiCodes(t *testing.T) {
-	cases := []struct {
-		code        int
-		wantCat     errs.Category
-		wantSubtype errs.Subtype
-		wantRetry   bool
-	}{
-		{131002, errs.CategoryAPI, errs.SubtypeInvalidParameters, false},
-		{131005, errs.CategoryAPI, errs.SubtypeNotFound, false},
-		{131006, errs.CategoryAuthorization, errs.SubtypePermissionDenied, false},
-	}
-	for _, tc := range cases {
-		t.Run(fmt.Sprintf("%d", tc.code), func(t *testing.T) {
-			got, ok := LookupCodeMeta(tc.code)
-			if !ok {
-				t.Fatalf("LookupCodeMeta(%d) ok=false, want true", tc.code)
-			}
-			if got.Category != tc.wantCat || got.Subtype != tc.wantSubtype || got.Retryable != tc.wantRetry {
-				t.Fatalf("LookupCodeMeta(%d) = %+v, want Category=%v Subtype=%v Retryable=%v",
-					tc.code, got, tc.wantCat, tc.wantSubtype, tc.wantRetry)
-			}
-		})
-	}
-}
-
 func TestLookupCodeMeta_Unknown(t *testing.T) {
 	_, ok := LookupCodeMeta(999999)
 	if ok {

internal/errclass/codemeta_wiki.go

@@ -1,17 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package errclass
-
-import "github.com/larksuite/cli/errs"
-
-// wikiCodeMeta holds wiki-service Lark code -> CodeMeta mappings observed from
-// wiki shortcut failure telemetry. Keep these to wiki-wide meanings only; add
-// command-specific recovery guidance at the shortcut layer.
-var wikiCodeMeta = map[int]CodeMeta{
-	131002: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // param err: space_id is not int / invalid page_token
-	131005: {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},                   // wiki node / space not found
-	131006: {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied}, // wiki space/node read permission denied
-}
-
-func init() { mergeCodeMeta(wikiCodeMeta, "wiki") }

internal/identitydiag/diagnostics.go

@@ -13,7 +13,6 @@ import (
 	"strings"
 	"time"
 
-	extcred "github.com/larksuite/cli/extension/credential"
 	larkauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
@@ -62,131 +61,12 @@ func Diagnose(ctx context.Context, f *cmdutil.Factory, cfg *core.CliConfig, veri
 	if ctx == nil {
 		ctx = context.Background()
 	}
-	// An external provider mints tokens on demand and blocks interactive auth,
-	// so the built-in keychain heuristics and "auth login" hints don't apply.
-	if provider := activeExternalProvider(ctx, f); provider != "" {
-		return diagnoseExternal(ctx, f, cfg, provider, verify)
-	}
 	return Result{
 		Bot:  diagnoseBot(ctx, f, cfg, verify),
 		User: diagnoseUser(ctx, f, cfg, verify),
 	}
 }
 
-// activeExternalProvider returns the active extension provider name, or "".
-// An error degrades to the built-in path: an unreachable provider would already
-// have failed the f.Config() that produced cfg.
-func activeExternalProvider(ctx context.Context, f *cmdutil.Factory) string {
-	if f == nil || f.Credential == nil {
-		return ""
-	}
-	name, err := f.Credential.ActiveExtensionProviderName(ctx)
-	if err != nil {
-		return ""
-	}
-	return name
-}
-
-func diagnoseExternal(ctx context.Context, f *cmdutil.Factory, cfg *core.CliConfig, provider string, verify bool) Result {
-	if cfg == nil || cfg.AppID == "" {
-		notConfigured := Identity{
-			Status:  StatusNotConfigured,
-			Message: "not configured (missing app config)",
-			Hint:    externalCredentialHint(provider),
-		}
-		return Result{Bot: notConfigured, User: notConfigured}
-	}
-	// SupportedIdentities == 0 is "unspecified" — treat as both, per CanBot.
-	ids := extcred.IdentitySupport(cfg.SupportedIdentities)
-	supportsBot := cfg.SupportedIdentities == 0 || ids.Has(extcred.SupportsBot)
-	supportsUser := cfg.SupportedIdentities == 0 || ids.Has(extcred.SupportsUser)
-	return Result{
-		Bot:  diagnoseExternalBot(ctx, f, cfg, provider, supportsBot, verify),
-		User: diagnoseExternalUser(ctx, f, cfg, provider, supportsUser, verify),
-	}
-}
-
-func diagnoseExternalBot(ctx context.Context, f *cmdutil.Factory, cfg *core.CliConfig, provider string, supported, verify bool) Identity {
-	if !supported {
-		return notProvidedExternally("Bot", provider)
-	}
-	id := Identity{Status: StatusReady, Available: true, Message: "Bot identity: ready (provided by " + provider + ")"}
-	if !verify {
-		return id
-	}
-	token, err := resolveBotToken(ctx, f, cfg)
-	if err != nil {
-		return externalVerifyFailed(id, "Bot", provider, err)
-	}
-	info, err := fetchBotInfo(ctx, f, cfg, token)
-	if err != nil {
-		return externalVerifyFailed(id, "Bot", provider, err)
-	}
-	id.Verified = boolPtr(true)
-	id.OpenID = info.OpenID
-	id.AppName = info.AppName
-	return id
-}
-
-func diagnoseExternalUser(ctx context.Context, f *cmdutil.Factory, cfg *core.CliConfig, provider string, supported, verify bool) Identity {
-	if !supported {
-		return notProvidedExternally("User", provider)
-	}
-	// enrichUserInfo populates UserOpenId only after the provider returns and
-	// verifies a UAT (and clears it on failure), so a resolved open id is the
-	// external analogue of a keychain token being present.
-	if cfg.UserOpenId == "" {
-		return Identity{
-			Status:  StatusMissing,
-			Message: "User identity: not signed in via credential source " + provider,
-			Hint:    externalCredentialHint(provider),
-		}
-	}
-	id := Identity{
-		Status:      StatusReady,
-		Available:   true,
-		TokenStatus: StatusReady,
-		UserName:    cfg.UserName,
-		OpenID:      cfg.UserOpenId,
-		Message:     "User identity: ready (provided by " + provider + ")",
-	}
-	if !verify {
-		return id
-	}
-	if _, err := f.Credential.ResolveToken(ctx, credential.NewTokenSpec(core.AsUser, cfg.AppID)); err != nil {
-		return externalVerifyFailed(id, "User", provider, err)
-	}
-	id.Verified = boolPtr(true)
-	return id
-}
-
-func notProvidedExternally(label, provider string) Identity {
-	return Identity{
-		Status:  StatusNotConfigured,
-		Message: label + " identity: not provided by credential source " + provider,
-		Hint:    externalCredentialHint(provider),
-	}
-}
-
-// externalVerifyFailed flips id to verify-failed, keeping any identity fields
-// (open id, user name) already resolved before the probe.
-func externalVerifyFailed(id Identity, label, provider string, err error) Identity {
-	id.Available = false
-	id.Verified = boolPtr(false)
-	id.Status = StatusVerifyFailed
-	id.TokenStatus = ""
-	id.Message = label + " identity: verify failed: " + err.Error()
-	id.Hint = externalCredentialHint(provider)
-	return id
-}
-
-// externalCredentialHint reports the constraint, not a remediation: the
-// identity is the provider's to manage, not lark-cli's to fix. What to do about
-// it is the caller's call — there may be no user to ask.
-func externalCredentialHint(provider string) string {
-	return fmt.Sprintf("managed by the external credential provider %q and cannot be configured via lark-cli", provider)
-}
-
 func diagnoseBot(ctx context.Context, f *cmdutil.Factory, cfg *core.CliConfig, verify bool) Identity {
 	if cfg == nil || cfg.AppID == "" {
 		return Identity{

internal/identitydiag/diagnostics_test.go

@@ -10,11 +10,9 @@ import (
 	"testing"
 	"time"
 
-	extcred "github.com/larksuite/cli/extension/credential"
 	larkauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/zalando/go-keyring"
 )
@@ -350,136 +348,3 @@ func TestDiagnose_UserIdentityNeedsRefresh(t *testing.T) {
 		t.Fatalf("token status = %q, want needs_refresh", got.User.TokenStatus)
 	}
 }
-
-// fakeExtProvider is a minimal credential.extcred.Provider for exercising the
-// external-credential diagnosis path. account makes the provider "active";
-// token (when set) satisfies ResolveToken during verify.
-type fakeExtProvider struct {
-	name    string
-	account *extcred.Account
-	token   *extcred.Token
-}
-
-func (p *fakeExtProvider) Name() string { return p.name }
-func (p *fakeExtProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
-	return p.account, nil
-}
-func (p *fakeExtProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
-	return p.token, nil
-}
-
-func externalFactory(prov *fakeExtProvider, cfg *core.CliConfig) *cmdutil.Factory {
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{prov}, nil, nil,
-		func() (*http.Client, error) { return nil, nil },
-	)
-	return &cmdutil.Factory{
-		Config:     func() (*core.CliConfig, error) { return cfg, nil },
-		Credential: cred,
-		IOStreams:  &cmdutil.IOStreams{},
-	}
-}
-
-// assertExternalHint locks the contract that an external-provider hint never
-// points at interactive commands blocked under an external provider.
-func assertExternalHint(t *testing.T, hint string) {
-	t.Helper()
-	if hint == "" {
-		t.Fatalf("hint empty, want external guidance")
-	}
-	for _, blocked := range []string{"auth login", "config --help"} {
-		if strings.Contains(hint, blocked) {
-			t.Fatalf("hint %q must not point at %q (blocked under external provider)", hint, blocked)
-		}
-	}
-	if !strings.Contains(hint, "external") {
-		t.Fatalf("hint %q should explain credentials are external", hint)
-	}
-}
-
-func TestDiagnose_External_UserReady(t *testing.T) {
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandFeishu, SupportedIdentities: uint8(extcred.SupportsAll), UserOpenId: "ou_x", UserName: "Alice"}
-	f := externalFactory(&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}}, cfg)
-
-	got := Diagnose(context.Background(), f, cfg, false)
-	// The bug this guards: the built-in path read the keychain (empty under an
-	// external provider) and reported the user as missing. Now availability
-	// follows the resolved account, so a signed-in user reads as ready.
-	if !got.User.Available || got.User.Status != StatusReady || got.User.TokenStatus != StatusReady {
-		t.Fatalf("user = %#v, want ready/available", got.User)
-	}
-	if got.User.OpenID != "ou_x" || got.User.UserName != "Alice" {
-		t.Fatalf("user identity = %#v", got.User)
-	}
-	if got.User.Hint != "" {
-		t.Fatalf("hint = %q, want empty when available", got.User.Hint)
-	}
-	if !got.Bot.Available || got.Bot.Status != StatusReady {
-		t.Fatalf("bot = %#v, want ready/available", got.Bot)
-	}
-}
-
-func TestDiagnose_External_UserNotSignedIn(t *testing.T) {
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandFeishu, SupportedIdentities: uint8(extcred.SupportsAll)}
-	f := externalFactory(&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}}, cfg)
-
-	got := Diagnose(context.Background(), f, cfg, false)
-	if got.User.Available || got.User.Status != StatusMissing {
-		t.Fatalf("user = %#v, want missing/unavailable", got.User)
-	}
-	assertExternalHint(t, got.User.Hint)
-}
-
-func TestDiagnose_External_BotOnly(t *testing.T) {
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandFeishu, SupportedIdentities: uint8(extcred.SupportsBot), UserOpenId: "ou_x"}
-	f := externalFactory(&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}}, cfg)
-
-	got := Diagnose(context.Background(), f, cfg, false)
-	if !got.Bot.Available || got.Bot.Status != StatusReady {
-		t.Fatalf("bot = %#v, want ready/available", got.Bot)
-	}
-	// Provider declares bot-only: user is unavailable even though an open id is
-	// present, and the hint is external (not "auth login").
-	if got.User.Available || got.User.Status != StatusNotConfigured {
-		t.Fatalf("user = %#v, want not_configured/unavailable", got.User)
-	}
-	assertExternalHint(t, got.User.Hint)
-}
-
-func TestDiagnose_External_UserOnly(t *testing.T) {
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandLark, SupportedIdentities: uint8(extcred.SupportsUser), UserOpenId: "ou_x", UserName: "Bob"}
-	f := externalFactory(&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}}, cfg)
-
-	got := Diagnose(context.Background(), f, cfg, false)
-	if !got.User.Available || got.User.Status != StatusReady {
-		t.Fatalf("user = %#v, want ready/available", got.User)
-	}
-	if got.Bot.Available || got.Bot.Status != StatusNotConfigured {
-		t.Fatalf("bot = %#v, want not_configured/unavailable", got.Bot)
-	}
-	assertExternalHint(t, got.Bot.Hint)
-}
-
-func TestDiagnose_External_VerifyUserResolvesToken(t *testing.T) {
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandFeishu, SupportedIdentities: uint8(extcred.SupportsUser), UserOpenId: "ou_x", UserName: "Alice"}
-	f := externalFactory(&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}, token: &extcred.Token{Value: "ext-uat"}}, cfg)
-
-	got := Diagnose(context.Background(), f, cfg, true)
-	if !got.User.Available || got.User.Verified == nil || !*got.User.Verified {
-		t.Fatalf("user = %#v, want available and verified", got.User)
-	}
-}
-
-func TestDiagnose_External_VerifyUserTokenUnavailable(t *testing.T) {
-	cfg := &core.CliConfig{AppID: "cli_x", Brand: core.BrandFeishu, SupportedIdentities: uint8(extcred.SupportsUser), UserOpenId: "ou_x"}
-	f := externalFactory(&fakeExtProvider{name: "corp-sso", account: &extcred.Account{AppID: "cli_x"}}, cfg)
-
-	got := Diagnose(context.Background(), f, cfg, true)
-	if got.User.Available || got.User.Status != StatusVerifyFailed {
-		t.Fatalf("user = %#v, want verify_failed/unavailable", got.User)
-	}
-	if got.User.Verified == nil || *got.User.Verified {
-		t.Fatalf("verified = %v, want false", got.User.Verified)
-	}
-	assertExternalHint(t, got.User.Hint)
-}

internal/qualitygate/publiccontent/rules.go

@@ -52,9 +52,6 @@ func isPlaceholderValue(value string) bool {
 	normalized := strings.ToLower(trimmed)
 	if normalized == "" ||
 		normalized == "=" ||
-		printfPlaceholderValue(normalized) ||
-		htmlEntityAnglePlaceholder(normalized) ||
-		starMaskedPlaceholder(normalized) ||
 		percentWrappedPlaceholder(normalized) ||
 		angleWrappedPlaceholder(normalized) ||
 		urlWithAnglePlaceholder(normalized) ||
@@ -64,28 +61,9 @@ func isPlaceholderValue(value string) bool {
 	return namedPlaceholderValue(normalized)
 }
 
-func htmlEntityAnglePlaceholder(value string) bool {
-	if !strings.HasPrefix(value, "<") || !strings.HasSuffix(value, ">") {
-		return false
-	}
-	return anglePlaceholderIdentifier(strings.TrimSuffix(strings.TrimPrefix(value, "<"), ">"))
-}
-
-func starMaskedPlaceholder(value string) bool {
-	var stars int
-	for _, r := range value {
-		if r == '*' {
-			stars++
-			continue
-		}
-		return false
-	}
-	return stars >= 3
-}
-
 func namedPlaceholderValue(value string) bool {
 	switch value {
-	case "...", "***", "****", "placeholder", "redacted", "<redacted>", "xxxx", "test-secret", "test-token", "dry-run", "dry_run":
+	case "...", "placeholder", "redacted", "<redacted>", "xxxx", "test-secret":
 		return true
 	}
 	return strings.Contains(value, "cli_example") ||
@@ -93,15 +71,6 @@ func namedPlaceholderValue(value string) bool {
 		conventionalNamedPlaceholderValue(value)
 }
 
-func printfPlaceholderValue(value string) bool {
-	switch value {
-	case "%d", "%s", "%q", "%v", "%w", "%x", "%T":
-		return true
-	default:
-		return false
-	}
-}
-
 func allXPlaceholder(value string) bool {
 	if len(value) < 4 {
 		return false

internal/qualitygate/publiccontent/scan.go

@@ -7,7 +7,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"math"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -55,9 +54,8 @@ func scanText(file, source, text string, detectorFile bool) []Finding {
 			keyName, _ := normalizedCredentialAssignmentKey(match[0])
 			if value == "" ||
 				isNonSecretLiteralValue(value) ||
-				isBenignCodeCredentialExpression(file, line, match[0], value) ||
+				isBenignCodeCredentialExpression(file, value) ||
 				isPlaceholderValue(value) ||
-				isPermissionScopeIdentifierAssignment(keyName, value) ||
 				isResourceTokenPlaceholderAssignment(keyName, value) {
 				continue
 			}
@@ -79,15 +77,12 @@ func scanText(file, source, text string, detectorFile bool) []Finding {
 			out = append(out, newFinding("public_content_bearer_header", file, lineNo, source, "Authorization: Bearer <redacted>"))
 		}
 		for _, match := range credentialURLRE.FindAllString(line, -1) {
-			if isPlaceholderCredentialURL(file, match) {
+			if isPlaceholderCredentialURL(match) {
 				continue
 			}
 			out = append(out, newFinding("public_content_credential_url", file, lineNo, source, redactCredentialURL(match)))
 		}
 		for _, match := range privateIPv4RE.FindAllString(line, -1) {
-			if !warnForPrivateIPv4(file) {
-				continue
-			}
 			out = append(out, newFinding("public_content_private_ipv4", file, lineNo, source, match))
 		}
 		if source == "branch" && automationBranchRE.MatchString(line) {
@@ -134,9 +129,6 @@ func isCredentialAssignmentMatch(match string) bool {
 	if isBenignTokenField(name) && !credentialShapedValue(value) {
 		return false
 	}
-	if isWeakTokenCredentialKey(name) && !weakTokenValueLooksCredentialLike(value) {
-		return false
-	}
 	return isExplicitCredentialKey(name)
 }
 
@@ -274,7 +266,7 @@ func isResourceTokenPlaceholderAssignment(key, value string) bool {
 	case key == "retry_without_token" && numericStringPlaceholderValue(value):
 		return true
 	case tokenLikePlaceholderKey(key):
-		return tokenLikePlaceholderValue(key, value)
+		return tokenLikePlaceholderValue(value)
 	default:
 		return false
 	}
@@ -286,16 +278,12 @@ func tokenLikePlaceholderKey(key string) bool {
 		strings.HasSuffix(key, "-token")
 }
 
-func tokenLikePlaceholderValue(key, value string) bool {
+func tokenLikePlaceholderValue(value string) bool {
 	normalized := strings.ToLower(strings.Trim(value, `"'`))
 	if normalized == "" || credentialShapedIdentifier(normalized) {
 		return false
 	}
-	if authCredentialTokenKey(key) {
-		return false
-	}
 	return resourceTokenPlaceholderValue(value) ||
-		maskedTokenFixturePlaceholderValue(key, normalized) ||
 		isPlaceholderValue(value) ||
 		normalized == "token" ||
 		strings.Contains(normalized, "...") ||
@@ -305,149 +293,6 @@ func tokenLikePlaceholderValue(key, value string) bool {
 		strings.HasPrefix(normalized, ".")
 }
 
-func maskedTokenFixturePlaceholderValue(key, value string) bool {
-	if authCredentialTokenKey(key) {
-		return false
-	}
-	var stars, alnum int
-	for _, r := range value {
-		switch {
-		case r == '*':
-			stars++
-		case (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9'):
-			alnum++
-		default:
-			return false
-		}
-	}
-	return stars >= 6 && alnum > 0
-}
-
-func isWeakTokenCredentialKey(key string) bool {
-	if authCredentialTokenKey(key) || isStrongTokenCredentialKey(key) {
-		return false
-	}
-	return key == "token" ||
-		strings.HasSuffix(key, "_token") ||
-		strings.HasSuffix(key, "-token")
-}
-
-func isStrongTokenCredentialKey(key string) bool {
-	parts := credentialKeyParts(strings.ReplaceAll(strings.ToLower(key), "-", "_"))
-	for _, phrase := range [][2]string{
-		{"access", "token"},
-		{"refresh", "token"},
-		{"auth", "token"},
-		{"bearer", "token"},
-		{"session", "token"},
-		{"service", "token"},
-		{"bot", "token"},
-		{"api", "token"},
-		{"secret", "token"},
-	} {
-		if hasAdjacentCredentialParts(parts, phrase[0], phrase[1]) {
-			return true
-		}
-	}
-	return false
-}
-
-func weakTokenValueLooksCredentialLike(value string) bool {
-	normalized := strings.ToLower(strings.Trim(value, `"'<>`))
-	if normalized == "" ||
-		isNonSecretLiteralValue(value) ||
-		isPlaceholderValue(value) {
-		return false
-	}
-	candidate := unwrapCredentialValue(normalized)
-	return credentialShapedIdentifier(candidate) ||
-		highEntropyCredentialValue(candidate) ||
-		commandSubstitutionLooksCredentialLike(normalized) ||
-		(strings.Contains(normalized, "://") &&
-			urlRemainderLooksCredentialLike(removeAnglePlaceholders(normalized)))
-}
-
-func unwrapCredentialValue(value string) string {
-	value = strings.TrimSpace(strings.Trim(value, `"'<>`))
-	if strings.HasPrefix(value, "${{") && strings.HasSuffix(value, "}}") {
-		value = strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(value, "${{"), "}}"))
-	}
-	value = strings.TrimPrefix(value, "$")
-	value = strings.Trim(value, "%")
-	return strings.TrimSpace(value)
-}
-
-func highEntropyCredentialValue(value string) bool {
-	if len(value) < 32 {
-		return false
-	}
-	var hasLetter, hasDigit bool
-	for _, r := range value {
-		switch {
-		case r >= 'a' && r <= 'z':
-			hasLetter = true
-		case r >= '0' && r <= '9':
-			hasDigit = true
-		case r == '_' || r == '-' || r == '.' || r == '=':
-		default:
-			return false
-		}
-	}
-	return hasLetter && hasDigit && shannonEntropy(value) >= 3.5
-}
-
-func shannonEntropy(value string) float64 {
-	if value == "" {
-		return 0
-	}
-	counts := map[rune]int{}
-	for _, r := range value {
-		counts[r]++
-	}
-	var entropy float64
-	length := float64(len([]rune(value)))
-	for _, count := range counts {
-		p := float64(count) / length
-		entropy -= p * log2(p)
-	}
-	return entropy
-}
-
-func log2(value float64) float64 {
-	return math.Log(value) / math.Ln2
-}
-
-func authCredentialTokenKey(key string) bool {
-	switch strings.ReplaceAll(strings.ToLower(key), "-", "_") {
-	case "access_token",
-		"api_token",
-		"bot_token",
-		"refresh_token",
-		"secret_token",
-		"session_token",
-		"service_token",
-		"bearer_token",
-		"auth_token",
-		"authorization_token",
-		"id_token":
-		return true
-	default:
-		return false
-	}
-}
-
-func isPermissionScopeIdentifierAssignment(key, value string) bool {
-	if !strings.HasSuffix(key, "_token") {
-		return false
-	}
-	switch strings.ToLower(strings.Trim(value, `"',;`)) {
-	case "read", "write", "modify", "readonly", "get_as_user":
-		return true
-	default:
-		return false
-	}
-}
-
 func idempotencyTokenPlaceholderValue(value string) bool {
 	return numericStringPlaceholderValue(value) || uuidStringPlaceholderValue(value)
 }
@@ -488,87 +333,20 @@ func numericStringPlaceholderValue(value string) bool {
 	return true
 }
 
-func isBenignCodeCredentialExpression(file, line, match, value string) bool {
+func isBenignCodeCredentialExpression(file, value string) bool {
 	normalized := strings.TrimSpace(value)
 	if strings.HasPrefix(normalized, "regexp.MustCompile(") {
 		return true
 	}
-	if !sourceCodeFile(file) || credentialShapedValue(value) {
+	if !sourceCodeFile(file) || quotedLiteral(value) || credentialShapedValue(value) {
 		return false
 	}
-	if rhs, ok := sourceCodeTypedCredentialRHS(line, match); ok {
-		return isBenignTypedCredentialRHS(rhs)
-	}
-	rawValueQuoted := credentialAssignmentRawValueQuoted(match)
-	if sourceCodeLiteralLooksNonSecret(normalized, !rawValueQuoted) {
-		return true
-	}
-	if sourceCodeFormatStringLiteral(normalized) && sourceCodeFormatArgumentContext(line, match) {
-		return true
-	}
-	if strings.Contains(match, "+") {
-		return true
-	}
-	if rawValueQuoted {
-		return false
-	}
-	if quotedLiteral(value) {
-		return sourceCodeLiteralLooksNonSecret(value, false)
-	}
 	return codeReferenceExpression(normalized)
 }
 
-func sourceCodeTypedCredentialRHS(line, match string) (string, bool) {
-	idx := strings.Index(line, match)
-	if idx < 0 {
-		return "", false
-	}
-	key, ok := credentialAssignmentKey(match)
-	if !ok {
-		return "", false
-	}
-	rest := strings.TrimSpace(line[idx+len(key):])
-	if !strings.HasPrefix(rest, ":") {
-		return "", false
-	}
-	typeAndRHS := strings.TrimSpace(strings.TrimPrefix(rest, ":"))
-	assignmentIdx := strings.Index(typeAndRHS, "=")
-	if assignmentIdx < 0 {
-		return "", false
-	}
-	return strings.TrimSpace(typeAndRHS[assignmentIdx+1:]), true
-}
-
-func isBenignTypedCredentialRHS(value string) bool {
-	value = strings.TrimRight(strings.TrimSpace(value), ",;")
-	if value == "" || isNonSecretLiteralValue(value) || isPlaceholderValue(value) {
-		return true
-	}
-	if credentialShapedValue(value) {
-		return false
-	}
-	if sourceCodeLiteralLooksNonSecret(value, !quotedLiteral(value)) {
-		return true
-	}
-	if quotedLiteral(value) {
-		return false
-	}
-	return codeReferenceExpression(value)
-}
-
-func credentialAssignmentRawValueQuoted(match string) bool {
-	key, ok := credentialAssignmentKey(match)
-	if !ok {
-		return false
-	}
-	rest := strings.TrimSpace(strings.TrimPrefix(match[len(key):], ":"))
-	rest = strings.TrimSpace(strings.TrimPrefix(rest, "="))
-	return strings.HasPrefix(rest, `"`) || strings.HasPrefix(rest, `'`)
-}
-
 func sourceCodeFile(file string) bool {
 	switch filepath.Ext(file) {
-	case ".go", ".js", ".jsx", ".py", ".ts", ".tsx":
+	case ".go", ".py":
 		return true
 	default:
 		return false
@@ -582,147 +360,7 @@ func quotedLiteral(value string) bool {
 			(strings.HasPrefix(normalized, `'`) && strings.HasSuffix(normalized, `'`)))
 }
 
-func sourceCodeLiteralLooksNonSecret(value string, allowNumeric bool) bool {
-	literal := strings.Trim(strings.TrimSpace(value), `"'`)
-	if strings.HasPrefix(literal, "/") {
-		return true
-	}
-	return (allowNumeric && numericStringPlaceholderValue(literal)) ||
-		sourceCodeEnvVarNameLiteral(literal) ||
-		sourceCodeAttributeNameLiteral(literal) ||
-		sourceCodeFakeOrPlaceholderLiteral(literal) ||
-		sourceCodeCredentialTermLiteral(literal) ||
-		sourceCodeCredentialPrefixLiteral(literal) ||
-		sourceCodeVocabularyLiteral(literal) ||
-		sourceCodeSchemaTypeLiteral(literal) ||
-		benignCredentialStatusLiteral(literal)
-}
-
-func sourceCodeFormatArgumentContext(line, match string) bool {
-	idx := strings.Index(line, match)
-	if idx < 0 {
-		return false
-	}
-	prefix := line[:idx]
-	if semicolon := strings.LastIndex(prefix, ";"); semicolon >= 0 {
-		prefix = prefix[semicolon+1:]
-	}
-	return strings.Contains(prefix, "fmt.") ||
-		strings.Contains(prefix, "log.") ||
-		strings.Contains(prefix, "printf(") ||
-		strings.Contains(prefix, "Printf(") ||
-		strings.Contains(prefix, "Errorf(") ||
-		strings.Contains(prefix, "Fprintf(")
-}
-
-func sourceCodeFormatStringLiteral(value string) bool {
-	for i := 0; i < len(value)-1; i++ {
-		if value[i] != '%' {
-			continue
-		}
-		if value[i+1] == '%' {
-			i++
-			continue
-		}
-		j := i + 1
-		for j < len(value) && strings.ContainsRune("#+- 0.0123456789", rune(value[j])) {
-			j++
-		}
-		if j < len(value) && strings.ContainsRune("vTtbcdoOqxXUeEfFgGspw", rune(value[j])) {
-			return true
-		}
-	}
-	return false
-}
-
-func sourceCodeEnvVarNameLiteral(value string) bool {
-	if value == "" || !strings.Contains(value, "_") {
-		return false
-	}
-	var hasCredentialMarker bool
-	for _, r := range value {
-		switch {
-		case r >= 'A' && r <= 'Z':
-		case r >= '0' && r <= '9':
-		case r == '_':
-		default:
-			return false
-		}
-	}
-	for _, marker := range []string{"TOKEN", "SECRET", "KEY", "PASSWORD", "PASSWD"} {
-		if strings.Contains(value, marker) {
-			hasCredentialMarker = true
-			break
-		}
-	}
-	return hasCredentialMarker
-}
-
-func sourceCodeAttributeNameLiteral(value string) bool {
-	normalized := strings.ToLower(value)
-	return strings.HasPrefix(normalized, "data-") && delimitedPlaceholderIdentifier(normalized)
-}
-
-func sourceCodeFakeOrPlaceholderLiteral(value string) bool {
-	normalized := strings.ToLower(value)
-	return strings.HasPrefix(normalized, "fake_") ||
-		strings.HasPrefix(normalized, "fake-") ||
-		strings.Contains(normalized, "placeholder") ||
-		(strings.Contains(normalized, "<") && strings.Contains(normalized, ">"))
-}
-
-func sourceCodeCredentialTermLiteral(value string) bool {
-	normalized := strings.ToLower(strings.ReplaceAll(value, "-", "_"))
-	return conventionalCredentialPlaceholderName(normalized)
-}
-
-func sourceCodeCredentialPrefixLiteral(value string) bool {
-	switch strings.ToLower(value) {
-	case "appsecret:":
-		return true
-	default:
-		return false
-	}
-}
-
-func sourceCodeVocabularyLiteral(value string) bool {
-	switch strings.ToLower(value) {
-	case "bot", "tenant", "user":
-		return true
-	default:
-		return false
-	}
-}
-
-func sourceCodeSchemaTypeLiteral(value string) bool {
-	normalized := strings.ToLower(value)
-	return normalized == "string" || strings.HasPrefix(normalized, "string(")
-}
-
-func benignCredentialStatusLiteral(value string) bool {
-	normalized := strings.ToLower(strings.ReplaceAll(value, "-", "_"))
-	if !delimitedPlaceholderIdentifier(normalized) {
-		return false
-	}
-	for _, marker := range []string{
-		"bad_fmt",
-		"expired",
-		"format",
-		"invalid",
-		"missing",
-		"permission",
-		"status",
-		"type",
-	} {
-		if strings.Contains(normalized, marker) {
-			return true
-		}
-	}
-	return false
-}
-
 func codeReferenceExpression(value string) bool {
-	value = strings.TrimRight(strings.TrimSpace(value), ";")
 	if value == "" {
 		return false
 	}
@@ -731,10 +369,7 @@ func codeReferenceExpression(value string) bool {
 			return true
 		}
 	}
-	if !codeIdentifier(value) {
-		return false
-	}
-	return codeIdentifier(value)
+	return codeIdentifier(value) && !credentialNameFragment(value)
 }
 
 func codeIdentifier(value string) bool {
@@ -751,6 +386,16 @@ func codeIdentifier(value string) bool {
 	return true
 }
 
+func credentialNameFragment(value string) bool {
+	normalized := strings.ToLower(value)
+	for _, marker := range []string{"secret", "token", "password", "passwd", "key"} {
+		if strings.Contains(normalized, marker) {
+			return true
+		}
+	}
+	return false
+}
+
 func isNonSecretLiteralValue(value string) bool {
 	switch strings.ToLower(strings.TrimSpace(strings.Trim(value, `"'`))) {
 	case "true", "false", "null", "nil", "{", "[":
@@ -952,7 +597,7 @@ func looksLikeEqualityComparison(value string) bool {
 	return strings.HasPrefix(strings.TrimSpace(value), "=")
 }
 
-func isPlaceholderCredentialURL(file, raw string) bool {
+func isPlaceholderCredentialURL(raw string) bool {
 	userInfo, ok := credentialURLUserInfo(raw)
 	if !ok {
 		return false
@@ -961,8 +606,7 @@ func isPlaceholderCredentialURL(file, raw string) bool {
 	if !ok {
 		return false
 	}
-	return credentialURLPasswordPlaceholder(password) ||
-		(sourceOrTestFixtureFile(file) && credentialURLPasswordFixture(password))
+	return credentialURLPasswordPlaceholder(password)
 }
 
 func credentialURLPasswordPlaceholder(password string) bool {
@@ -976,46 +620,6 @@ func credentialURLPasswordPlaceholder(password string) bool {
 	return angleWrappedPlaceholder(decoded) || percentWrappedPlaceholder(decoded)
 }
 
-func credentialURLPasswordFixture(password string) bool {
-	normalized := strings.ToLower(strings.Trim(password, `"'`))
-	switch normalized {
-	case "p",
-		"pass",
-		"password",
-		"pat_abc",
-		"pw",
-		"s3cret",
-		"secret",
-		"t":
-		return true
-	default:
-		return false
-	}
-}
-
-func sourceOrTestFixtureFile(file string) bool {
-	normalized := filepath.ToSlash(file)
-	return sourceCodeFile(normalized) ||
-		strings.HasPrefix(normalized, "testdata/") ||
-		strings.HasPrefix(normalized, "fixtures/") ||
-		strings.Contains(normalized, "/testdata/") ||
-		strings.Contains(normalized, "/fixtures/")
-}
-
-func warnForPrivateIPv4(file string) bool {
-	normalized := filepath.ToSlash(file)
-	if sourceOrTestFixtureFile(normalized) {
-		return false
-	}
-	switch filepath.Ext(normalized) {
-	case ".md", ".mdx", ".txt", ".json", ".yaml", ".yml", ".toml", ".env":
-		return true
-	default:
-		return strings.HasPrefix(normalized, "docs/") ||
-			strings.HasPrefix(normalized, "skills/")
-	}
-}
-
 func credentialURLUserInfo(raw string) (string, bool) {
 	schemeIdx := strings.Index(raw, "://")
 	if schemeIdx < 0 {

internal/qualitygate/publiccontent/scan_test.go

@@ -61,19 +61,6 @@ func TestScanFileWarnsForPrivateIPv4Examples(t *testing.T) {
 	}
 }
 
-func TestScanFileAllowsPrivateIPv4SourceFixtures(t *testing.T) {
-	got := ScanFile("internal/transport/warn_test.go", []byte(strings.Join([]string{
-		`proxy := "http://user:pass@10.0.0.1:3128"`,
-		`target := "socks5://admin:secret@172.16.0.1:1080"`,
-		`host := "192.168.0.10"`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_private_ipv4" {
-			t.Fatalf("private IPv4 source fixtures should not be public content findings: %#v", got)
-		}
-	}
-}
-
 func TestSemanticCandidateRequiresSpecificRiskSignals(t *testing.T) {
 	benign := semanticCandidate("docs/network.md", "file", "For a local lab, use RFC1918 example host 192.168."+"0.10 only.", 1)
 	if len(benign) != 0 {
@@ -645,45 +632,6 @@ func TestScanFileAllowsCredentialURLPlaceholders(t *testing.T) {
 	}
 }
 
-func TestScanFileAllowsCredentialURLFixtures(t *testing.T) {
-	got := ScanFile("fixtures/network_test.go", []byte(strings.Join([]string{
-		`proxy := "http://user:pass@proxy:8080"`,
-		`repo := "https://u:t@h/r.git"`,
-		`target := "https://attacker:pw@open.feishu.cn"`,
-		`proxy := "http://admin:s3cret@127.0.0.1:3128"`,
-		`repo := "http://x-token:PAT_abc@git.host/app_x.git"`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_credential_url" {
-			t.Fatalf("credential URL fixtures should not be credential URL findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileAllowsRootCredentialURLFixtures(t *testing.T) {
-	got := ScanFile("fixtures/network.md", []byte(strings.Join([]string{
-		`proxy: http://user:pass@proxy:8080`,
-		`repo: https://u:t@h/r.git`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_credential_url" {
-			t.Fatalf("root credential URL fixtures should not be credential URL findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileAllowsRootPrivateIPv4Fixtures(t *testing.T) {
-	got := ScanFile("testdata/network.md", []byte(strings.Join([]string{
-		`endpoint: http://10.0.0.1:8080`,
-		`redis: 192.168.1.10:6379`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_private_ipv4" {
-			t.Fatalf("root private IPv4 fixtures should not be private IPv4 findings: %#v", got)
-		}
-	}
-}
-
 func TestScanFileDetectsCredentialURLsWithRedactedSubstringPasswords(t *testing.T) {
 	got := ScanFile("docs/config.yaml", []byte("DATABASE_URL=postgres://user:notredactedreal@example.invalid/db\n"))
 	for _, item := range got {
@@ -700,7 +648,6 @@ func TestScanFileDetectsCredentialURLsWithPlaceholderUserAndRealPassword(t *test
 		"DATABASE_URL=postgres://<user>:real-secret@example.invalid/db",
 		"DATABASE_URL=postgres://<user>:" + stripeLike + "@example.invalid/db",
 		"URL=https://<user>:real-secret@example.invalid/path",
-		"REPO=https://x-token:" + stripeLike + "@git.host/app.git",
 	}, "\n")+"\n"))
 	var count int
 	for _, item := range got {
@@ -714,8 +661,8 @@ func TestScanFileDetectsCredentialURLsWithPlaceholderUserAndRealPassword(t *test
 			}
 		}
 	}
-	if count != 4 {
-		t.Fatalf("placeholder-user credential URL findings = %d, want 4: %#v", count, got)
+	if count != 3 {
+		t.Fatalf("placeholder-user credential URL findings = %d, want 3: %#v", count, got)
 	}
 }
 
@@ -777,68 +724,6 @@ func TestScanFileAllowsBenignJSONTokenFields(t *testing.T) {
 	}
 }
 
-func TestScanFileAllowsWeakTokenFieldsWithoutCredentialEvidence(t *testing.T) {
-	got := ScanFile("docs/resource-tokens.md", []byte(strings.Join([]string{
-		`{"token":"img_abc123"}`,
-		`{"token":"img_live_secret"}`,
-		`{"token":"img_prod_key"}`,
-		`token=ab********cd`,
-		`{"image_token":"img_live_secret"}`,
-		`{"data_mail_token":"mail_abc123"}`,
-		`{"whiteboard_token":"board_v3_example"}`,
-		`{"want_token":"token from callback"}`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("weak token fields without credential evidence should not be credential findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileDetectsWeakTokenFieldsWithHighConfidenceCredentialValues(t *testing.T) {
-	githubToken := "ghp_" + "1234567890abcdef1234567890abcdef1234"
-	stripeToken := "sk_" + "live_1234567890abcdef"
-	randomToken := strings.Join([]string{
-		"a1b2c3d4",
-		"e5f6g7h8",
-		"i9j0k1l2",
-		"m3n4p5q6",
-	}, "")
-	got := ScanFile("docs/config.md", []byte(strings.Join([]string{
-		`{"token":"` + githubToken + `"}`,
-		`token=` + stripeToken,
-		`{"image_token":"` + githubToken + `"}`,
-		`{"token":"` + randomToken + `"}`,
-	}, "\n")+"\n"))
-	var count int
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 4 {
-		t.Fatalf("high-confidence weak token credential findings = %d, want 4: %#v", count, got)
-	}
-}
-
-func TestScanFileDetectsStrongAuthTokenKeysWithFixtureLikeValues(t *testing.T) {
-	got := ScanFile("docs/config.md", []byte(strings.Join([]string{
-		`{"access_token":"img_abc123"}`,
-		`{"api_token":"img_live_secret"}`,
-		`{"service_token":"ab********cd"}`,
-		`{"bot_token":"board_v3_example"}`,
-	}, "\n")+"\n"))
-	var count int
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 4 {
-		t.Fatalf("strong auth token key findings = %d, want 4: %#v", count, got)
-	}
-}
-
 func TestScanFileAllowsTestFixtureSecretValues(t *testing.T) {
 	got := ScanFile("fixtures/calendar_meeting_test.go", []byte(`AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,`+"\n"))
 	for _, item := range got {
@@ -885,172 +770,6 @@ func TestScanFileAllowsPythonArgumentTokens(t *testing.T) {
 	}
 }
 
-func TestScanFileAllowsPythonCredentialTypeAnnotations(t *testing.T) {
-	got := ScanFile("fixtures/doc_word_stat.py", []byte(strings.Join([]string{
-		"class Counter:",
-		"    def __init__(self) -> None:",
-		"        self._token_kind: TokenKind | None = None",
-		"        self.access_token: AccessToken | None = None",
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("python credential-shaped type annotations should not be credential findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileAllowsSourceCodeCredentialNonSecretLiterals(t *testing.T) {
-	got := ScanFile("fixtures/auth_paths.go", []byte(strings.Join([]string{
-		`const PathOAuthTokenV2 = "/open-apis/authen/v2/oauth/token"`,
-		`return fmt.Errorf("failed to remove token: %v", err)`,
-		`const LarkErrTokenMissing = "token_missing"`,
-		`const LarkErrTokenExpired = 99991677`,
-		`const CliAppSecret = "LARKSUITE_CLI_APP_SECRET"`,
-		`const LargeAttachmentTokenAttr = "data-mail-token"`,
-		`const fakeOfficeTokenPrefix = "fake_office_"`,
-		`fmt.Fprintf(w, "  - token=%s  filename=%s\n", att.Token, att.FileName)`,
-		`tokenTypeHint := "access_token"`,
-		`const TokenTenant Token = "tenant"`,
-		`const secretKeyPrefix = "appsecret:"`,
-		`output.PrintJson(out, map[string]interface{}{"appSecret": "****"})`,
-		`return &credential.TokenResult{Token: "test-token"}, nil`,
-		`fmt.Fprintf(w, "password=%s\n", pat)`,
-		`text += "(img_token:" + imgToken + ")"`,
-		`map[string]interface{}{"token": "string(optional, from inspect)"}`,
-		`this.token = token;`,
-		`// AppSecret: "appsecret:<appId>"`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("source code non-secret literals should not be credential findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileAllowsCredentialLikePublicPlaceholders(t *testing.T) {
-	got := ScanFile("fixtures/placeholders.md", []byte(strings.Join([]string{
-		`app_secret=***`,
-		`{"token":"&lt;wiki_token&gt;"}`,
-		`{"token":"Pgrrwvr***********UnRb"}`,
-		`"scope_name": "auth:user_access_token:read"`,
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("public placeholders and scope identifiers should not be credential findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileDetectsPartiallyMaskedCredentialValues(t *testing.T) {
-	got := ScanFile("fixtures/config.md", []byte(strings.Join([]string{
-		"client_secret=realprefix***realsuffix",
-		"client_secret=ab********cd",
-		"access_token=ab********cd",
-		"refresh_token=realprefix********realsuffix",
-	}, "\n")+"\n"))
-	var count int
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 4 {
-		t.Fatalf("partially masked credential findings = %d, want 4: %#v", count, got)
-	}
-}
-
-func TestScanFileAllowsDryRunCredentialPlaceholders(t *testing.T) {
-	got := ScanFile("fixtures/ci.yml", []byte(strings.Join([]string{
-		"LARKSUITE_CLI_APP_SECRET=dry-run",
-		"client_secret: dry_run",
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("dry-run credential placeholders should not be credential findings: %#v", got)
-		}
-	}
-}
-
-func TestScanFileDetectsTypedCredentialAssignmentsWithSecretRHS(t *testing.T) {
-	cases := []struct {
-		name string
-		file string
-		text string
-	}{
-		{
-			name: "typescript simple secret",
-			file: "fixtures/source_secret.ts",
-			text: `const clientSecret: string = "real-client-secret-value"`,
-		},
-		{
-			name: "typescript numeric password",
-			file: "fixtures/source_secret.ts",
-			text: `const password: string = "12345678901234567890"`,
-		},
-		{
-			name: "typescript union secret",
-			file: "fixtures/source_secret.ts",
-			text: `const clientSecret: string | undefined = "real-client-secret-value"`,
-		},
-		{
-			name: "python simple secret",
-			file: "fixtures/source_secret.py",
-			text: `self.client_secret: str = "real-client-secret-value"`,
-		},
-		{
-			name: "python union secret",
-			file: "fixtures/source_secret.py",
-			text: `self.client_secret: str | None = "real-client-secret-value"`,
-		},
-		{
-			name: "python optional secret",
-			file: "fixtures/source_secret.py",
-			text: `self.client_secret: Optional[str] = "real-client-secret-value"`,
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := ScanFile(tc.file, []byte(tc.text+"\n"))
-			if !findingRules(got)["public_content_generic_credential"] {
-				t.Fatalf("typed credential assignment should be reported: %#v", got)
-			}
-		})
-	}
-}
-
-func TestScanFileDetectsCredentialShapedSourceCodeLiterals(t *testing.T) {
-	githubToken := "ghp_" + "1234567890abcdef1234567890abcdef1234"
-	got := ScanFile("fixtures/source_secret.go", []byte(strings.Join([]string{
-		`const ClientSecret = "real-client-secret-value"`,
-		`const GithubToken = "` + githubToken + `"`,
-		`const Password = "12345678901234567890"`,
-		`const ClientSecretNumber = "12345678901234567890"`,
-		`const ClientSecretFormat = "abc%sdefreal"`,
-		`fmt.Println("done"); const ClientSecret = "abc%sdefreal"`,
-	}, "\n")+"\n"))
-	var count int
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			count++
-		}
-	}
-	if count != 6 {
-		t.Fatalf("source code credential-shaped literal findings = %d, want 6: %#v", count, got)
-	}
-}
-
-func TestScanFileAllowsPrintfCredentialPlaceholders(t *testing.T) {
-	got := ScanFile("fixtures/placeholders.md", []byte(strings.Join([]string{
-		"client_secret=%s",
-		"access_token=%v",
-	}, "\n")+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("printf placeholders should not be credential findings: %#v", got)
-		}
-	}
-}
-
 func TestScanFileAllowsEllipsisCredentialPlaceholders(t *testing.T) {
 	got := ScanFile("fixtures/lark-doc-fetch.md", []byte(strings.Join([]string{
 		`<img token="..." url="https://..." width="..." height="..."/>`,
@@ -1167,12 +886,10 @@ func TestScanFileDetectsCredentialShapedTokenLikePlaceholderValues(t *testing.T)
 	}
 }
 
-func TestScanFileAllowsNonFixtureResourceTokenValues(t *testing.T) {
+func TestScanFileDetectsNonFixtureMinuteTokenValues(t *testing.T) {
 	got := ScanFile("fixtures/minutes_search_test.go", []byte(`{"token":"minute_real_secret"}`+"\n"))
-	for _, item := range got {
-		if item.Rule == "public_content_generic_credential" {
-			t.Fatalf("resource-like bare token value should not be credential finding: %#v", got)
-		}
+	if !findingRules(got)["public_content_generic_credential"] {
+		t.Fatalf("non-fixture minute token should be credential finding: %#v", got)
 	}
 }
 

internal/registry/catalog.go

@@ -6,7 +6,8 @@ package registry
 import "github.com/larksuite/cli/internal/apicatalog"
 
 // EmbeddedCatalog returns a navigation catalog over the embedded (overlay-free)
-// metadata — deterministic across machines, for golden tests and schema lint.
+// metadata — deterministic across machines, for `lark-cli schema`, golden tests
+// and schema lint.
 func EmbeddedCatalog() apicatalog.Catalog {
 	return apicatalog.New(apicatalog.SourceEmbedded, EmbeddedServicesTyped())
 }
@@ -17,14 +18,3 @@ func EmbeddedCatalog() apicatalog.Catalog {
 func RuntimeCatalog() apicatalog.Catalog {
 	return apicatalog.New(apicatalog.SourceRuntime, ServicesTyped())
 }
-
-// SchemaCatalog returns the embedded catalog when metadata is compiled in,
-// otherwise the merged runtime catalog. Binaries built from the bare Go module
-// embed only the empty meta_data_default.json stub, so the embedded view has
-// nothing to resolve; the merged view is the only data such binaries have.
-func SchemaCatalog() apicatalog.Catalog {
-	if len(EmbeddedServicesTyped()) > 0 {
-		return EmbeddedCatalog()
-	}
-	return RuntimeCatalog()
-}

internal/registry/catalog_test.go

@@ -1,67 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package registry
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/larksuite/cli/internal/apicatalog"
-)
-
-// swapEmbeddedMeta replaces the compiled-in metadata bytes for one test and
-// restores them (with a full state reset) on cleanup.
-func swapEmbeddedMeta(t *testing.T, data []byte) {
-	t.Helper()
-	resetInit()
-	orig := embeddedMetaJSON
-	embeddedMetaJSON = data
-	t.Cleanup(func() {
-		waitBackgroundRefresh()
-		embeddedMetaJSON = orig
-		resetInit()
-	})
-}
-
-func TestSchemaCatalog_EmbeddedWhenCompiledIn(t *testing.T) {
-	swapEmbeddedMeta(t, testCacheJSON("embedded_svc"))
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_REMOTE_META", "off")
-
-	c := SchemaCatalog()
-
-	if c.Source() != apicatalog.SourceEmbedded {
-		t.Fatalf("Source = %q, want %q", c.Source(), apicatalog.SourceEmbedded)
-	}
-	if _, ok := c.Service("embedded_svc"); !ok {
-		t.Fatal("expected embedded_svc from embedded metadata")
-	}
-}
-
-// TestSchemaCatalog_FallsBackToRuntimeWhenNoEmbedded simulates a binary built
-// from the bare Go module (plugin builds): only the empty meta_data_default.json
-// stub is compiled in, so SchemaCatalog must serve the merged runtime view that
-// Init seeds via sync fetch.
-func TestSchemaCatalog_FallsBackToRuntimeWhenNoEmbedded(t *testing.T) {
-	swapEmbeddedMeta(t, embeddedMetaDataDefaultJSON)
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_REMOTE_META", "on")
-
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
-		w.Write(testEnvelopeJSON("remote_svc"))
-	}))
-	defer ts.Close()
-	testMetaURL = ts.URL
-
-	c := SchemaCatalog()
-
-	if c.Source() != apicatalog.SourceRuntime {
-		t.Fatalf("Source = %q, want %q", c.Source(), apicatalog.SourceRuntime)
-	}
-	if _, ok := c.Service("remote_svc"); !ok {
-		t.Fatal("expected remote_svc from runtime fallback")
-	}
-}

internal/registry/loader.go

@@ -15,7 +15,6 @@ import (
 
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/meta"
-	"github.com/larksuite/cli/internal/update"
 )
 
 //go:embed scope_priorities.json scope_overrides.json
@@ -86,9 +85,7 @@ func InitWithBrand(brand core.LarkBrand) {
 			brandChanged := metaErr == nil && cm.Brand != "" && cm.Brand != string(brand)
 
 			if !brandChanged {
-				// After a CLI upgrade the embedded data can be fresher than an old
-				// cache; an equal/older cache must not shadow it.
-				if cached, err := loadCachedMerged(); err == nil && update.IsNewer(cached.Version, embeddedVersion) {
+				if cached, err := loadCachedMerged(); err == nil {
 					overlayMergedServices(cached)
 				}
 			}

internal/registry/loader_test.go

@@ -1,102 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package registry
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/meta"
-)
-
-// seedCache writes a cache file + cache meta for one service whose Title is
-// marker, tagged with the given top-level data version and brand.
-func seedCache(t *testing.T, dir, name, marker, version, brand string) {
-	t.Helper()
-	cDir := filepath.Join(dir, "cache")
-	if err := os.MkdirAll(cDir, 0700); err != nil {
-		t.Fatal(err)
-	}
-	reg := MergedRegistry{
-		Version:  version,
-		Services: []meta.Service{{Name: name, Version: "cache", Title: marker}},
-	}
-	data, _ := json.Marshal(reg)
-	if err := os.WriteFile(filepath.Join(cDir, "remote_meta.json"), data, 0644); err != nil {
-		t.Fatal(err)
-	}
-	cm := CacheMeta{LastCheckAt: time.Now().Unix(), Version: version, Brand: brand}
-	mData, _ := json.Marshal(cm)
-	if err := os.WriteFile(filepath.Join(cDir, "remote_meta.meta.json"), mData, 0644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// initWithCache runs a fresh feishu-brand init with remote on, a high TTL and a
-// recent LastCheckAt (so no refresh fires), embedded meta at embeddedVer and a
-// pre-seeded cache at cacheVer — the overlay version gate is the only variable.
-func initWithCache(t *testing.T, embeddedVer, cacheVer string) {
-	t.Helper()
-	embedded, _ := json.Marshal(MergedRegistry{
-		Version:  embeddedVer,
-		Services: []meta.Service{{Name: "svc", Version: "embedded", Title: "EMBEDDED"}},
-	})
-	swapEmbeddedMeta(t, embedded)
-	tmp := t.TempDir()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
-	t.Setenv("LARKSUITE_CLI_REMOTE_META", "on")
-	t.Setenv("LARKSUITE_CLI_META_TTL", "3600")
-	seedCache(t, tmp, "svc", "CACHE", cacheVer, "feishu")
-	InitWithBrand(core.BrandFeishu)
-}
-
-func titleOf(t *testing.T, name string) string {
-	t.Helper()
-	svc, ok := ServiceTyped(name)
-	if !ok {
-		t.Fatalf("service %q not loaded", name)
-	}
-	return svc.Title
-}
-
-func TestOverlayGate_EqualVersion_UsesEmbedded(t *testing.T) {
-	initWithCache(t, "1.0.0", "1.0.0")
-	if got := titleOf(t, "svc"); got != "EMBEDDED" {
-		t.Errorf("equal version: got %q, want EMBEDDED (cache must not overlay)", got)
-	}
-}
-
-func TestOverlayGate_OlderCache_UsesEmbedded(t *testing.T) {
-	initWithCache(t, "2.0.0", "1.0.0")
-	if got := titleOf(t, "svc"); got != "EMBEDDED" {
-		t.Errorf("older cache: got %q, want EMBEDDED", got)
-	}
-}
-
-func TestOverlayGate_NewerCache_OverlaysCache(t *testing.T) {
-	initWithCache(t, "1.0.0", "2.0.0")
-	if got := titleOf(t, "svc"); got != "CACHE" {
-		t.Errorf("newer cache: got %q, want CACHE", got)
-	}
-}
-
-func TestOverlayGate_UnparseableCacheVersion_UsesEmbedded(t *testing.T) {
-	initWithCache(t, "1.0.0", "not-a-semver")
-	if got := titleOf(t, "svc"); got != "EMBEDDED" {
-		t.Errorf("unparseable cache version: got %q, want EMBEDDED", got)
-	}
-}
-
-func TestOverlayGate_StubEmbedded_OverlaysRealCache(t *testing.T) {
-	// The bare-module stub baseline is "0.0.0"; a real cache version must win so
-	// plugin builds without compiled meta_data.json still get remote data.
-	initWithCache(t, "0.0.0", "1.0.0")
-	if got := titleOf(t, "svc"); got != "CACHE" {
-		t.Errorf("stub-embedded baseline: got %q, want CACHE", got)
-	}
-}

internal/registry/remote_test.go

@@ -72,11 +72,9 @@ func hasEmbeddedServices() bool {
 }
 
 // testRegistry returns a minimal MergedRegistry with one service.
-// The version is a real semver newer than the embedded stub baseline ("0.0.0")
-// so cache overlay passes the version gate in InitWithBrand.
 func testRegistry(name string) MergedRegistry {
 	return MergedRegistry{
-		Version: "1.0.0",
+		Version: "test-1.0",
 		Services: []meta.Service{
 			{
 				Name:        name,
@@ -162,7 +160,7 @@ func TestRemoteOff_SkipsRemoteLogic(t *testing.T) {
 }
 
 func TestCacheHit_WithinTTL(t *testing.T) {
-	swapEmbeddedMeta(t, nil) // overlay must depend only on the cache version, not the ambient embedded meta
+	resetInit()
 	tmp := t.TempDir()
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
 	t.Setenv("LARKSUITE_CLI_REMOTE_META", "on")
@@ -199,7 +197,7 @@ func TestCacheHit_WithinTTL(t *testing.T) {
 }
 
 func TestNetworkError_SilentDegradation(t *testing.T) {
-	swapEmbeddedMeta(t, nil) // overlay must depend only on the cache version, not the ambient embedded meta
+	resetInit()
 	tmp := t.TempDir()
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
 	t.Setenv("LARKSUITE_CLI_REMOTE_META", "on")
@@ -373,8 +371,8 @@ func TestFetchRemoteMerged_200(t *testing.T) {
 	if data == nil {
 		t.Fatal("expected non-nil data")
 	}
-	if reg.Version != "1.0.0" {
-		t.Errorf("expected version 1.0.0, got %s", reg.Version)
+	if reg.Version != "test-1.0" {
+		t.Errorf("expected version test-1.0, got %s", reg.Version)
 	}
 }
 

internal/registry/scope_hint.go

@@ -59,9 +59,13 @@ func BuildConsoleScopeURL(brand core.LarkBrand, appID, scope string) string {
 	if appID == "" || scope == "" {
 		return ""
 	}
+	host := "open.feishu.cn"
+	if brand == core.BrandLark {
+		host = "open.larksuite.com"
+	}
 	return fmt.Sprintf(
-		"%s/page/scope-apply?clientID=%s&scopes=%s",
-		core.ResolveOpenBaseURL(brand),
+		"https://%s/page/scope-apply?clientID=%s&scopes=%s",
+		host,
 		url.QueryEscape(appID),
 		url.QueryEscape(scope),
 	)

internal/selfupdate/updater.go

@@ -32,7 +32,6 @@ type InstallMethod int
 
 const (
 	InstallNpm InstallMethod = iota
-	InstallPnpm
 	InstallManual
 )
 
@@ -54,32 +53,22 @@ var (
 
 // DetectResult holds installation detection results.
 type DetectResult struct {
-	Method        InstallMethod
-	ResolvedPath  string
-	NpmAvailable  bool
-	PnpmAvailable bool
+	Method       InstallMethod
+	ResolvedPath string
+	NpmAvailable bool
 }
 
 // CanAutoUpdate returns true if the CLI can update itself automatically.
 func (d DetectResult) CanAutoUpdate() bool {
-	switch d.Method {
-	case InstallNpm:
-		return d.NpmAvailable
-	case InstallPnpm:
-		return d.PnpmAvailable
-	}
-	return false
+	return d.Method == InstallNpm && d.NpmAvailable
 }
 
 // ManualReason returns a human-readable explanation of why auto-update is unavailable.
 func (d DetectResult) ManualReason() string {
-	switch {
-	case d.Method == InstallNpm && !d.NpmAvailable:
+	if d.Method == InstallNpm && !d.NpmAvailable {
 		return "installed via npm, but npm is not available in PATH"
-	case d.Method == InstallPnpm && !d.PnpmAvailable:
-		return "installed via pnpm, but pnpm is not available in PATH"
 	}
-	return "not installed via npm or pnpm"
+	return "not installed via npm"
 }
 
 // NpmResult holds the result of an npm install or skills update execution.
@@ -103,7 +92,6 @@ func (r *NpmResult) CombinedOutput() string {
 type Updater struct {
 	DetectOverride           func() DetectResult
 	NpmInstallOverride       func(version string) *NpmResult
-	PnpmInstallOverride      func(version string) *NpmResult
 	SkillsIndexFetchOverride func() *NpmResult
 	SkillsCommandOverride    func(args ...string) *NpmResult
 	VerifyOverride           func(expectedVersion string) error
@@ -113,38 +101,17 @@ type Updater struct {
 	// running binary is successfully renamed to .old. Used by
 	// CanRestorePreviousVersion to report whether rollback is possible.
 	backupCreated bool
-
-	// detectCache memoizes the first real DetectInstallMethod result. How this
-	// binary was installed cannot change during a single process, so caching is
-	// the correct semantics — and it is required for correctness: the update
-	// flow mutates the install (pnpm add -g / npm install -g) before syncing
-	// skills, so a re-detection at skills time could resolve a now-stale
-	// os.Executable path and misclassify. Seeded pre-update by the first call
-	// (updateRun), it keeps the post-update skills launcher consistent with the
-	// launcher reported to the user. Not goroutine-safe; the update flow is
-	// sequential.
-	detectCache *DetectResult
 }
 
 // New creates an Updater with default (real) behavior.
 func New() *Updater { return &Updater{} }
 
-// DetectInstallMethod determines how the CLI was installed and whether the
-// owning package manager is available for auto-update.
+// DetectInstallMethod determines how the CLI was installed and whether
+// npm is available for auto-update.
 func (u *Updater) DetectInstallMethod() DetectResult {
 	if u.DetectOverride != nil {
 		return u.DetectOverride()
 	}
-	if u.detectCache != nil {
-		return *u.detectCache
-	}
-	result := u.detectInstallMethod()
-	u.detectCache = &result
-	return result
-}
-
-// detectInstallMethod performs the real (uncached) detection.
-func (u *Updater) detectInstallMethod() DetectResult {
 	exe, err := vfs.Executable()
 	if err != nil {
 		return DetectResult{Method: InstallManual}
@@ -153,54 +120,24 @@ func (u *Updater) detectInstallMethod() DetectResult {
 	if err != nil {
 		return DetectResult{Method: InstallManual, ResolvedPath: exe}
 	}
-	_, npmErr := exec.LookPath("npm")
-	_, pnpmErr := exec.LookPath("pnpm")
-	return detectFromResolved(resolved, npmErr == nil, pnpmErr == nil)
-}
 
-// detectFromResolved classifies the resolved binary path into an install
-// method and records package-manager availability. Split out from
-// DetectInstallMethod so the classification is unit-testable without touching
-// the filesystem or PATH.
-func detectFromResolved(resolved string, npmOnPath, pnpmOnPath bool) DetectResult {
 	method := InstallManual
 	if strings.Contains(resolved, "node_modules") {
-		if containsPnpmMarker(resolved) {
-			method = InstallPnpm
-		} else {
-			method = InstallNpm
-		}
+		method = InstallNpm
 	}
-	d := DetectResult{Method: method, ResolvedPath: resolved}
-	switch method {
-	case InstallNpm:
-		d.NpmAvailable = npmOnPath
-	case InstallPnpm:
-		d.PnpmAvailable = pnpmOnPath
-	}
-	return d
-}
 
-// containsPnpmMarker reports whether the resolved binary path belongs to a
-// pnpm-managed install. pnpm exposes two layouts: the classic virtual store
-// (a ".pnpm" directory segment) and the global content-addressable store,
-// whose resolved path runs through pnpm's home directory (e.g.
-// "~/Library/pnpm/store/v11/links/...") — a "pnpm" segment immediately
-// followed by "store". Matching only these two shapes (rather than any bare
-// "pnpm" segment) avoids misclassifying an npm install that merely lives under
-// a directory named "pnpm". Windows separators are normalized to "/" so the
-// classification is OS-independent and unit-testable anywhere.
-func containsPnpmMarker(p string) bool {
-	parts := strings.Split(strings.ReplaceAll(p, `\`, "/"), "/")
-	for i, part := range parts {
-		if part == ".pnpm" {
-			return true
-		}
-		if part == "pnpm" && i+1 < len(parts) && parts[i+1] == "store" {
-			return true
+	npmAvailable := false
+	if method == InstallNpm {
+		if _, err := exec.LookPath("npm"); err == nil {
+			npmAvailable = true
 		}
 	}
-	return false
+
+	return DetectResult{
+		Method:       method,
+		ResolvedPath: resolved,
+		NpmAvailable: npmAvailable,
+	}
 }
 
 // RunNpmInstall executes npm install -g @larksuite/cli@<version>.
@@ -226,29 +163,6 @@ func (u *Updater) RunNpmInstall(version string) *NpmResult {
 	return r
 }
 
-// RunPnpmInstall executes pnpm add -g @larksuite/cli@<version>.
-func (u *Updater) RunPnpmInstall(version string) *NpmResult {
-	if u.PnpmInstallOverride != nil {
-		return u.PnpmInstallOverride(version)
-	}
-	r := &NpmResult{}
-	pnpmPath, err := exec.LookPath("pnpm")
-	if err != nil {
-		r.Err = fmt.Errorf("pnpm not found in PATH: %w", err)
-		return r
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), npmInstallTimeout)
-	defer cancel()
-	cmd := exec.CommandContext(ctx, pnpmPath, "add", "-g", NpmPackage+"@"+version)
-	cmd.Stdout = &r.Stdout
-	cmd.Stderr = &r.Stderr
-	r.Err = cmd.Run()
-	if ctx.Err() == context.DeadlineExceeded {
-		r.Err = fmt.Errorf("pnpm install timed out after %s", npmInstallTimeout)
-	}
-	return r
-}
-
 func (u *Updater) ListOfficialSkillsIndex() *NpmResult {
 	if u.SkillsIndexFetchOverride != nil {
 		return u.SkillsIndexFetchOverride()
@@ -347,40 +261,19 @@ func (u *Updater) runSkillsInstall(source string, nameList []string) *NpmResult
 	return u.runSkillsCommand(args...)
 }
 
-// skillsInvocation decides how to launch the `skills` CLI. When the lark-cli
-// itself was installed via pnpm and pnpm is available, it uses `pnpm dlx` so
-// pnpm-only environments (pnpm's standalone installer bundles Node without
-// putting npm/npx on PATH) can still sync skills after a self-update.
-// Otherwise it uses `npx`. The npx auto-confirm flag "-y", when present as the
-// leading arg, maps to `pnpm dlx`'s default non-interactive behavior and is
-// dropped for the pnpm launcher. Kept pure (no exec/PATH access) so the
-// launcher selection is unit-testable on any platform.
-func skillsInvocation(method InstallMethod, pnpmAvailable bool, args []string) (launcher string, rest []string) {
-	if method == InstallPnpm && pnpmAvailable {
-		r := args
-		if len(r) > 0 && r[0] == "-y" {
-			r = r[1:]
-		}
-		return "pnpm", append([]string{"dlx"}, r...)
-	}
-	return "npx", args
-}
-
 func (u *Updater) runSkillsCommand(args ...string) *NpmResult {
 	if u.SkillsCommandOverride != nil {
 		return u.SkillsCommandOverride(args...)
 	}
 	r := &NpmResult{}
-	det := u.DetectInstallMethod()
-	launcher, cmdArgs := skillsInvocation(det.Method, det.PnpmAvailable, args)
-	binPath, err := exec.LookPath(launcher)
+	npxPath, err := exec.LookPath("npx")
 	if err != nil {
-		r.Err = fmt.Errorf("%s not found in PATH: %w", launcher, err)
+		r.Err = fmt.Errorf("npx not found in PATH: %w", err)
 		return r
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), skillsUpdateTimeout)
 	defer cancel()
-	cmd := exec.CommandContext(ctx, binPath, cmdArgs...)
+	cmd := exec.CommandContext(ctx, npxPath, args...)
 	cmd.Stdout = &r.Stdout
 	cmd.Stderr = &r.Stderr
 	r.Err = cmd.Run()

internal/selfupdate/updater_test.go

@@ -371,147 +371,3 @@ func TestListOfficialSkillsFallsBack(t *testing.T) {
 		t.Fatalf("fallback call = %q, want larksuite/cli --list", called[1])
 	}
 }
-
-func TestContainsPnpmMarker(t *testing.T) {
-	cases := []struct {
-		path string
-		want bool
-	}{
-		// Classic virtual-store layout (.pnpm segment).
-		{"/Users/x/Library/pnpm/global/5/node_modules/.pnpm/@larksuite+cli@1.0.44/node_modules/@larksuite/cli/bin/lark-cli", true},
-		{`C:\Users\x\AppData\Local\pnpm\global\5\node_modules\.pnpm\@larksuite+cli@1.0.44\node_modules\@larksuite\cli\bin\lark-cli.exe`, true},
-		// Global content-addressable store layout (pnpm 11): resolved path runs
-		// through the pnpm home store, a "pnpm" segment with no ".pnpm".
-		{"/Users/x/Library/pnpm/store/v11/links/@larksuite/cli/1.0.59/abc123/node_modules/@larksuite/cli/bin/lark-cli", true},
-		{"/home/x/.local/share/pnpm/store/v10/@larksuite/cli/node_modules/@larksuite/cli/bin/lark-cli", true},
-		{`C:\Users\x\AppData\Local\pnpm\store\v11\links\@larksuite\cli\node_modules\@larksuite\cli\bin\lark-cli.exe`, true},
-		// npm and non-package installs — no pnpm/.pnpm segment.
-		{"/usr/local/lib/node_modules/@larksuite/cli/bin/lark-cli", false},
-		{"/usr/local/bin/lark-cli", false},
-		// Substrings that must NOT match: segment must be exactly .pnpm, or
-		// "pnpm" immediately followed by "store".
-		{"/opt/homebrew/.pnpmfoo/node_modules/@larksuite/cli/bin/lark-cli", false},
-		{"/opt/pnpmfoo/node_modules/@larksuite/cli/bin/lark-cli", false},
-		// A bare "pnpm" directory NOT followed by "store" (e.g. an npm install
-		// living under a dir named pnpm) must not be misclassified as pnpm.
-		{"/opt/pnpm/lib/node_modules/@larksuite/cli/bin/lark-cli", false},
-	}
-	for _, c := range cases {
-		if got := containsPnpmMarker(c.path); got != c.want {
-			t.Errorf("containsPnpmMarker(%q) = %v, want %v", c.path, got, c.want)
-		}
-	}
-}
-
-func TestDetectInstallMethod_Pnpm(t *testing.T) {
-	u := &Updater{DetectOverride: nil}
-	u.DetectOverride = func() DetectResult {
-		// Exercise the real classification by feeding a resolved path via a small shim.
-		return detectFromResolved("/x/node_modules/.pnpm/@larksuite+cli@1.0.44/node_modules/@larksuite/cli/bin/lark-cli", true, true)
-	}
-	got := u.DetectInstallMethod()
-	if got.Method != InstallPnpm {
-		t.Errorf("Method = %v, want InstallPnpm", got.Method)
-	}
-	if !got.PnpmAvailable {
-		t.Errorf("PnpmAvailable = false, want true")
-	}
-}
-
-func TestDetectInstallMethod_NpmVsManual(t *testing.T) {
-	if m := detectFromResolved("/usr/local/lib/node_modules/@larksuite/cli/bin/lark-cli", true, false).Method; m != InstallNpm {
-		t.Errorf("npm path Method = %v, want InstallNpm", m)
-	}
-	if m := detectFromResolved("/usr/local/bin/lark-cli", false, false).Method; m != InstallManual {
-		t.Errorf("manual path Method = %v, want InstallManual", m)
-	}
-}
-
-func TestCanAutoUpdate_Pnpm(t *testing.T) {
-	if !(DetectResult{Method: InstallPnpm, PnpmAvailable: true}).CanAutoUpdate() {
-		t.Error("pnpm available should CanAutoUpdate")
-	}
-	if (DetectResult{Method: InstallPnpm, PnpmAvailable: false}).CanAutoUpdate() {
-		t.Error("pnpm unavailable should not CanAutoUpdate")
-	}
-}
-
-func TestManualReason_Pnpm(t *testing.T) {
-	if got := (DetectResult{Method: InstallPnpm, NpmAvailable: false, PnpmAvailable: false}).ManualReason(); got != "installed via pnpm, but pnpm is not available in PATH" {
-		t.Errorf("pnpm reason = %q", got)
-	}
-	if got := (DetectResult{Method: InstallManual}).ManualReason(); got != "not installed via npm or pnpm" {
-		t.Errorf("manual reason = %q", got)
-	}
-}
-
-func TestRunPnpmInstall_Override(t *testing.T) {
-	u := &Updater{PnpmInstallOverride: func(version string) *NpmResult {
-		r := &NpmResult{}
-		r.Stdout.WriteString("added @larksuite/cli@" + version)
-		return r
-	}}
-	got := u.RunPnpmInstall("2.0.0")
-	if got.Err != nil {
-		t.Fatalf("unexpected err: %v", got.Err)
-	}
-	if !strings.Contains(got.CombinedOutput(), "2.0.0") {
-		t.Errorf("output = %q, want version echoed", got.CombinedOutput())
-	}
-}
-
-func TestRunPnpmInstall_Error(t *testing.T) {
-	wantErr := errors.New("boom")
-	u := &Updater{PnpmInstallOverride: func(string) *NpmResult { return &NpmResult{Err: wantErr} }}
-	if got := u.RunPnpmInstall("2.0.0"); !errors.Is(got.Err, wantErr) {
-		t.Errorf("err = %v, want %v", got.Err, wantErr)
-	}
-}
-
-func TestSkillsInvocation(t *testing.T) {
-	addArgs := []string{"-y", "skills", "add", "https://open.feishu.cn", "-g", "-y"}
-	cases := []struct {
-		name          string
-		method        InstallMethod
-		pnpmAvailable bool
-		args          []string
-		wantLauncher  string
-		wantRest      []string
-	}{
-		{"pnpm install + pnpm available → pnpm dlx, drop leading -y", InstallPnpm, true, addArgs,
-			"pnpm", []string{"dlx", "skills", "add", "https://open.feishu.cn", "-g", "-y"}},
-		{"pnpm install but pnpm unavailable → npx unchanged", InstallPnpm, false, addArgs,
-			"npx", addArgs},
-		{"npm install → npx unchanged", InstallNpm, false, addArgs,
-			"npx", addArgs},
-		{"manual install → npx unchanged", InstallManual, false, []string{"-y", "skills", "ls", "-g"},
-			"npx", []string{"-y", "skills", "ls", "-g"}},
-		{"pnpm without a leading -y → prepend dlx only", InstallPnpm, true, []string{"skills", "ls", "-g"},
-			"pnpm", []string{"dlx", "skills", "ls", "-g"}},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			gotLauncher, gotRest := skillsInvocation(c.method, c.pnpmAvailable, c.args)
-			if gotLauncher != c.wantLauncher {
-				t.Errorf("launcher = %q, want %q", gotLauncher, c.wantLauncher)
-			}
-			if strings.Join(gotRest, " ") != strings.Join(c.wantRest, " ") {
-				t.Errorf("rest = %v, want %v", gotRest, c.wantRest)
-			}
-		})
-	}
-}
-
-// TestDetectInstallMethod_Caches locks the fix for the post-update re-detection
-// hazard: DetectInstallMethod must return the first (pre-update) detection on
-// subsequent calls, so the skills launcher chosen after the binary is replaced
-// stays consistent with what was detected — and reported — before the update.
-func TestDetectInstallMethod_Caches(t *testing.T) {
-	u := New()
-	cached := DetectResult{Method: InstallPnpm, PnpmAvailable: true, ResolvedPath: "/x/pnpm/store/v11/links/@larksuite/cli/1.0.0/node_modules/@larksuite/cli/bin/lark-cli"}
-	u.detectCache = &cached
-	got := u.DetectInstallMethod()
-	if got.Method != InstallPnpm || !got.PnpmAvailable {
-		t.Errorf("expected cached pnpm result to be returned, got %+v", got)
-	}
-}

internal/update/update.go

@@ -25,7 +25,7 @@ import (
 const (
 	registryURL  = "https://registry.npmjs.org/@larksuite/cli/latest"
 	cacheTTL     = 24 * time.Hour
-	fetchTimeout = 15 * time.Second
+	fetchTimeout = 5 * time.Second
 	stateFile    = "update-state.json"
 	maxBody      = 256 << 10 // 256 KB
 

package.json

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

shortcuts/base/base_dryrun_ops_test.go

@@ -89,18 +89,6 @@ func TestDryRunFieldOps(t *testing.T) {
 	)
 	assertDryRunContains(t, dryRunFieldGet(ctx, rt), "GET /open-apis/base/v3/bases/app_x/tables/tbl_1/fields/fld_1")
 	assertDryRunContains(t, dryRunFieldCreate(ctx, rt), "POST /open-apis/base/v3/bases/app_x/tables/tbl_1/fields")
-
-	arrayRT := newBaseTestRuntime(
-		map[string]string{
-			"base-token": "app_x",
-			"table-id":   "tbl_1",
-			"json":       `[{"name":"A","type":"text"},{"name":"B","type":"text"}]`,
-		},
-		nil,
-		nil,
-	)
-	assertDryRunContains(t, dryRunFieldCreate(ctx, arrayRT), `"name":"A"`, `"name":"B"`)
-
 	assertDryRunContains(t, dryRunFieldUpdate(ctx, rt), "PUT /open-apis/base/v3/bases/app_x/tables/tbl_1/fields/fld_1")
 	assertDryRunContains(t, dryRunFieldDelete(ctx, rt), "DELETE /open-apis/base/v3/bases/app_x/tables/tbl_1/fields/fld_1")
 	assertDryRunContains(t, dryRunFieldSearchOptions(ctx, rt), "GET /open-apis/base/v3/bases/app_x/tables/tbl_1/fields/fld_1/options", "offset=3", "limit=30", "query=open")

shortcuts/base/base_execute_test.go

@@ -830,6 +830,11 @@ func TestBaseObjectJSONShortcutsRejectArrayInDryRun(t *testing.T) {
 		shortcut common.Shortcut
 		args     []string
 	}{
+		{
+			name:     "field create",
+			shortcut: BaseFieldCreate,
+			args:     []string{"+field-create", "--base-token", "app_x", "--table-id", "tbl_x", "--json", `[]`, "--dry-run"},
+		},
 		{
 			name:     "field update",
 			shortcut: BaseFieldUpdate,
@@ -1097,54 +1102,6 @@ func TestBaseFieldExecuteCRUD(t *testing.T) {
 		}
 	})
 
-	t.Run("create array sequentially", func(t *testing.T) {
-		oldDelay := fieldCreateBatchDelay
-		fieldCreateBatchDelay = 0
-		t.Cleanup(func() { fieldCreateBatchDelay = oldDelay })
-
-		factory, stdout, reg := newExecuteFactory(t)
-		firstStub := &httpmock.Stub{
-			Method: "POST",
-			URL:    "/open-apis/base/v3/bases/app_x/tables/tbl_x/fields",
-			BodyFilter: func(body []byte) bool {
-				return strings.Contains(string(body), `"name":"A"`)
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"data": map[string]interface{}{"id": "fld_a", "name": "A", "type": "text"},
-			},
-		}
-		secondStub := &httpmock.Stub{
-			Method: "POST",
-			URL:    "/open-apis/base/v3/bases/app_x/tables/tbl_x/fields",
-			BodyFilter: func(body []byte) bool {
-				return strings.Contains(string(body), `"name":"B"`)
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"data": map[string]interface{}{"id": "fld_b", "name": "B", "type": "text"},
-			},
-		}
-		reg.Register(firstStub)
-		reg.Register(secondStub)
-
-		err := runShortcut(t, BaseFieldCreate, []string{"+field-create", "--base-token", "app_x", "--table-id", "tbl_x", "--json", `[{"name":"A","type":"text"},{"name":"B","type":"text"}]`}, factory, stdout)
-		if err != nil {
-			t.Fatalf("err=%v", err)
-		}
-		data := decodeBaseEnvelope(t, stdout)
-		if data["created"] != true || data["total"] != float64(2) {
-			t.Fatalf("unexpected output: %#v", data)
-		}
-		fields, _ := data["fields"].([]interface{})
-		if len(fields) != 2 {
-			t.Fatalf("fields len=%d output=%#v", len(fields), data)
-		}
-		if !strings.Contains(string(firstStub.CapturedBody), `"name":"A"`) || !strings.Contains(string(secondStub.CapturedBody), `"name":"B"`) {
-			t.Fatalf("unexpected request bodies: %s / %s", firstStub.CapturedBody, secondStub.CapturedBody)
-		}
-	})
-
 	t.Run("delete", func(t *testing.T) {
 		factory, stdout, reg := newExecuteFactory(t)
 		reg.Register(&httpmock.Stub{

shortcuts/base/base_shortcuts_test.go

@@ -1060,15 +1060,6 @@ func TestBaseFieldValidate(t *testing.T) {
 	if err := BaseFieldCreate.Validate(ctx, newBaseTestRuntime(map[string]string{"base-token": "b", "table-id": "t", "json": "{"}, nil, nil)); err == nil || !strings.Contains(err.Error(), "--json invalid JSON object") {
 		t.Fatalf("err=%v", err)
 	}
-	if err := BaseFieldCreate.Validate(ctx, newBaseTestRuntime(map[string]string{"base-token": "b", "table-id": "t", "json": `[{"name":"a","type":"text"},{"name":"b","type":"text"}]`}, nil, nil)); err != nil {
-		t.Fatalf("array create validate err=%v", err)
-	}
-	if err := BaseFieldCreate.Validate(ctx, newBaseTestRuntime(map[string]string{"base-token": "b", "table-id": "t", "json": `[{"name":"a","type":"text"},1]`}, nil, nil)); err == nil || !strings.Contains(err.Error(), "--json item 2 must be an object") {
-		t.Fatalf("err=%v", err)
-	}
-	if err := BaseFieldCreate.Validate(ctx, newBaseTestRuntime(map[string]string{"base-token": "b", "table-id": "t", "json": `[{"name":"a","type":"formula"}]`}, nil, nil)); err == nil || !strings.Contains(err.Error(), "--i-have-read-guide is required") {
-		t.Fatalf("err=%v", err)
-	}
 	if err := BaseFieldCreate.Validate(ctx, newBaseTestRuntime(map[string]string{"base-token": "b", "table-id": "t", "json": `{"name":"f1","type":"formula"}`}, nil, nil)); err == nil || !strings.Contains(err.Error(), "--i-have-read-guide is required") {
 		t.Fatalf("err=%v", err)
 	}

shortcuts/base/field_ops.go

@@ -6,13 +6,10 @@ package base
 import (
 	"context"
 	"strings"
-	"time"
 
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-var fieldCreateBatchDelay = time.Second
-
 func dryRunFieldList(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 	offset := runtime.Int("offset")
 	if offset < 0 {
@@ -36,14 +33,12 @@ func dryRunFieldGet(_ context.Context, runtime *common.RuntimeContext) *common.D
 
 func dryRunFieldCreate(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 	pc := newParseCtx(runtime)
-	bodies, _ := parseFieldCreateBodies(pc, runtime.Str("json"))
-	dr := common.NewDryRunAPI().
+	body, _ := parseJSONObject(pc, runtime.Str("json"), "json")
+	return common.NewDryRunAPI().
+		POST("/open-apis/base/v3/bases/:base_token/tables/:table_id/fields").
+		Body(body).
 		Set("base_token", runtime.Str("base-token")).
 		Set("table_id", baseTableID(runtime))
-	for _, body := range bodies {
-		dr.POST("/open-apis/base/v3/bases/:base_token/tables/:table_id/fields").Body(body)
-	}
-	return dr
 }
 
 func dryRunFieldUpdate(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
@@ -100,16 +95,11 @@ func validateFormulaLookupGuideAck(runtime *common.RuntimeContext, command strin
 }
 
 func validateFieldCreate(runtime *common.RuntimeContext) error {
-	bodies, err := parseFieldCreateBodies(newParseCtx(runtime), runtime.Str("json"))
+	body, err := validateFieldJSON(runtime)
 	if err != nil {
 		return err
 	}
-	for _, body := range bodies {
-		if err := validateFormulaLookupGuideAck(runtime, "+field-create", body); err != nil {
-			return err
-		}
-	}
-	return nil
+	return validateFormulaLookupGuideAck(runtime, "+field-create", body)
 }
 
 func validateFieldUpdate(runtime *common.RuntimeContext) error {
@@ -150,38 +140,17 @@ func executeFieldGet(runtime *common.RuntimeContext) error {
 }
 
 func executeFieldCreate(runtime *common.RuntimeContext) error {
-	bodies, err := parseFieldCreateBodies(newParseCtx(runtime), runtime.Str("json"))
+	pc := newParseCtx(runtime)
+	body, err := parseJSONObject(pc, runtime.Str("json"), "json")
 	if err != nil {
 		return err
 	}
-	fields := make([]interface{}, 0, len(bodies))
-	for idx, body := range bodies {
-		if idx > 0 && fieldCreateBatchDelay > 0 {
-			time.Sleep(fieldCreateBatchDelay)
-		}
-		data, err := baseV3Call(runtime, "POST", baseV3Path("bases", runtime.Str("base-token"), "tables", baseTableID(runtime), "fields"), nil, body)
-		if err != nil {
-			return err
-		}
-		fields = append(fields, data)
-	}
-	if len(fields) == 1 {
-		runtime.Out(map[string]interface{}{"field": fields[0], "created": true}, nil)
-		return nil
-	}
-	runtime.Out(map[string]interface{}{"fields": fields, "created": true, "total": len(fields)}, nil)
-	return nil
-}
-
-func parseFieldCreateBodies(pc *parseCtx, raw string) ([]map[string]interface{}, error) {
-	bodies, err := parseObjectList(pc, raw, "json")
+	data, err := baseV3Call(runtime, "POST", baseV3Path("bases", runtime.Str("base-token"), "tables", baseTableID(runtime), "fields"), nil, body)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if len(bodies) == 0 {
-		return nil, baseFlagErrorf("--json must contain at least one field JSON object")
-	}
-	return bodies, nil
+	runtime.Out(map[string]interface{}{"field": data, "created": true}, nil)
+	return nil
 }
 
 func executeFieldUpdate(runtime *common.RuntimeContext) error {

shortcuts/calendar/calendar_create.go

@@ -67,26 +67,6 @@ func parseAttendees(attendeesStr string, currentUserId string) ([]map[string]str
 	return attendees, nil
 }
 
-func attendeesIncludeRoom(attendees []map[string]string) bool {
-	for _, attendee := range attendees {
-		if attendee["type"] == "resource" || attendee["room_id"] != "" {
-			return true
-		}
-	}
-	return false
-}
-
-func guideApprovalRoomReasonError(err error, attendees []map[string]string) error {
-	if err == nil || !attendeesIncludeRoom(attendees) {
-		return err
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok || !strings.Contains(strings.ToLower(p.Hint), "approval_reason") {
-		return err
-	}
-	return withStepContext(err, "approval meeting rooms require attendees[].approval_reason; calendar +create does not expose this low-frequency field. Create the event with the raw API flow, then use `lark-cli calendar event.attendees create --as user` with attendees[].approval_reason for the room attendee.")
-}
-
 var CalendarCreate = common.Shortcut{
 	Service:     "calendar",
 	Command:     "+create",
@@ -245,7 +225,6 @@ var CalendarCreate = common.Shortcut{
 					"need_notification": true,
 				})
 			if err != nil {
-				err = guideApprovalRoomReasonError(err, attendees)
 				// Rollback: delete the event
 				_, rollbackErr := runtime.CallAPITyped("DELETE",
 					fmt.Sprintf("/open-apis/calendar/v4/calendars/%s/events/%s", validate.EncodePathSegment(calendarId), validate.EncodePathSegment(eventId)),

shortcuts/calendar/calendar_test.go

@@ -673,76 +673,6 @@ func TestCreate_WithAttendees_InvalidParamsWithDetail_RollsBack(t *testing.T) {
 	}
 }
 
-func TestCreate_ApprovalRoomMissingReason_GuidesRawAttendeesAPI(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, defaultConfig())
-
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/calendar/v4/calendars/cal_test123/events",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"event": map[string]interface{}{
-					"event_id":   "evt_approval_room",
-					"summary":    "Approval Room",
-					"start_time": map[string]interface{}{"timestamp": "1742515200"},
-					"end_time":   map[string]interface{}{"timestamp": "1742518800"},
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/events/evt_approval_room/attendees",
-		Body: map[string]interface{}{
-			"code": codeInvalidParamsWithDetail,
-			"msg":  "invalid params",
-			"error": map[string]interface{}{
-				"details": []interface{}{
-					map[string]interface{}{"value": "attendees[0].approval_reason is required for approval meeting rooms"},
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "DELETE",
-		URL:    "/events/evt_approval_room",
-		Body:   map[string]interface{}{"code": 0, "msg": "ok"},
-	})
-
-	err := mountAndRun(t, CalendarCreate, []string{
-		"+create",
-		"--summary", "Approval Room",
-		"--start", "2025-03-21T00:00:00+08:00",
-		"--end", "2025-03-21T01:00:00+08:00",
-		"--calendar-id", "cal_test123",
-		"--attendee-ids", "omm_room1",
-		"--as", "user",
-	}, f, nil)
-
-	if err == nil {
-		t.Fatal("expected error for approval room missing approval_reason, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("ProblemOf returned !ok for %T", err)
-	}
-	if p.Category != errs.CategoryAPI {
-		t.Errorf("category=%q, want %q", p.Category, errs.CategoryAPI)
-	}
-	if p.Subtype != errs.SubtypeInvalidParameters {
-		t.Errorf("subtype=%q, want %q", p.Subtype, errs.SubtypeInvalidParameters)
-	}
-	if p.Code != codeInvalidParamsWithDetail {
-		t.Errorf("code=%d, want %d", p.Code, codeInvalidParamsWithDetail)
-	}
-	for _, want := range []string{"approval_reason", "calendar event.attendees create", "--as user", "rolled back successfully"} {
-		if !strings.Contains(p.Hint, want) {
-			t.Errorf("hint should contain %q, got: %q", want, p.Hint)
-		}
-	}
-}
-
 // When the add-attendees call fails AND the rollback DELETE also fails, the
 // primary error stays the add failure (classification preserved) and the Hint
 // must surface BOTH the rollback failure reason and the orphan event_id so the

shortcuts/doc/doc_media_upload.go

@@ -23,8 +23,8 @@ var DocMediaUpload = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "file", Desc: "local file path (files > 20MB use multipart upload automatically)", Required: true},
-		{Name: "parent-type", Desc: "parent type: docx_image | docx_file | whiteboard | mindnote_image", Required: true},
-		{Name: "parent-node", Desc: "parent node ID (block_id for docx, board_token for whiteboard, mindnote token for mindnote)", Required: true},
+		{Name: "parent-type", Desc: "parent type: docx_image | docx_file | whiteboard", Required: true},
+		{Name: "parent-node", Desc: "parent node ID (block_id for docx, board_token for whiteboard)", Required: true},
 		{Name: "doc-id", Desc: "document ID (for drive_route_token)"},
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {

shortcuts/doc/docs_create_v2.go

@@ -18,7 +18,6 @@ func v2CreateFlags() []common.Flag {
 	return []common.Flag{
 		{Name: "title", Desc: "document title; when provided, the CLI prepends it to --content as <title>...</title> so the title wins over later content titles"},
 		{Name: "content", Desc: "document body; XML by default or Markdown when --doc-format markdown. " + docsContentSkillHelp + "; use --help for the latest command flags", Input: []string{common.File, common.Stdin}},
-		{Name: "reference-map", Desc: docsReferenceMapFlagDesc, Input: []string{common.File, common.Stdin}},
 		{Name: "doc-format", Desc: "content format; xml is default and supports richer DocxXML blocks, markdown imports plain Markdown", Default: "xml", Enum: []string{"xml", "markdown"}},
 		{Name: "parent-token", Desc: "parent folder token or wiki node token; mutually exclusive with --parent-position"},
 		{Name: "parent-position", Desc: "parent position such as my_library; mutually exclusive with --parent-token"},
@@ -33,8 +32,8 @@ func validateCreateV2(_ context.Context, runtime *common.RuntimeContext) error {
 	if runtime.Changed("title") && title == "" {
 		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--title must not be empty").WithParam("--title")
 	}
-	if err := validateDocsV2ReferenceMapFlags(runtime); err != nil {
-		return err
+	if runtime.Str("content") == "" && title == "" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content is required unless --title is provided").WithParam("--content")
 	}
 	if runtime.Str("parent-token") != "" && runtime.Str("parent-position") != "" {
 		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--parent-token and --parent-position are mutually exclusive").WithParams(
@@ -42,21 +41,11 @@ func validateCreateV2(_ context.Context, runtime *common.RuntimeContext) error {
 			errs.InvalidParam{Name: "--parent-position", Reason: "mutually exclusive with --parent-token"},
 		)
 	}
-	if runtime.Str("content") == "" && title == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content is required unless --title is provided").WithParam("--content")
-	}
-	if runtime.Str("content") != "" {
-		_, err := resolveDocsV2ContentReferenceMap(runtime)
-		return err
-	}
 	return nil
 }
 
 func dryRunCreateV2(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-	body, err := buildCreateBodyWithHTML5ReferenceMap(runtime)
-	if err != nil {
-		return common.NewDryRunAPI().Set("error", err.Error())
-	}
+	body := buildCreateBody(runtime)
 	desc := "OpenAPI: create document"
 	if runtime.IsBot() {
 		desc += ". After document creation succeeds in bot mode, the CLI will also try to grant the current CLI user full_access (可管理权限) on the new document."
@@ -68,10 +57,7 @@ func dryRunCreateV2(_ context.Context, runtime *common.RuntimeContext) *common.D
 }
 
 func executeCreateV2(_ context.Context, runtime *common.RuntimeContext) error {
-	body, err := buildCreateBodyWithHTML5ReferenceMap(runtime)
-	if err != nil {
-		return err
-	}
+	body := buildCreateBody(runtime)
 
 	data, err := doDocAPI(runtime, "POST", "/open-apis/docs_ai/v1/documents", body)
 	if err != nil {
@@ -100,10 +86,7 @@ func buildCreateBody(runtime *common.RuntimeContext) map[string]interface{} {
 }
 
 func buildCreateContent(runtime *common.RuntimeContext) string {
-	return buildCreateContentWithBody(runtime, runtime.Str("content"))
-}
-
-func buildCreateContentWithBody(runtime *common.RuntimeContext, content string) string {
+	content := runtime.Str("content")
 	title := strings.TrimSpace(runtime.Str("title"))
 	if title == "" {
 		return content

shortcuts/doc/docs_fetch_v2.go

@@ -14,7 +14,7 @@ import (
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-const docsFetchExtraParam = `{"enable_user_cite_reference_map":true,"return_html5_block_data":true}`
+const docsFetchExtraParam = `{"enable_user_cite_reference_map":true}`
 
 // v2FetchFlags returns the flag definitions for the v2 (OpenAPI) fetch path.
 func v2FetchFlags() []common.Flag {
@@ -71,9 +71,6 @@ func executeFetchV2(_ context.Context, runtime *common.RuntimeContext) error {
 	if err != nil {
 		return err
 	}
-	if err := processHTML5BlockReferenceMapForFetch(runtime, effectiveFetchFormat(runtime), ref.Token, data); err != nil {
-		return err
-	}
 	if warning := addFetchDetailDowngradeWarning(runtime, data); warning != "" && runtime.Format == "pretty" {
 		fmt.Fprintf(runtime.IO().ErrOut, "warning: %s\n", warning)
 	}

shortcuts/doc/docs_fetch_v2_test.go

@@ -505,14 +505,14 @@ func TestBuildFetchBodyIncludesFetchExtraParamByDefault(t *testing.T) {
 	if got["enable_user_cite_reference_map"] != true {
 		t.Fatalf("enable_user_cite_reference_map = %#v, want true in %#v", got["enable_user_cite_reference_map"], got)
 	}
-	if got["return_html5_block_data"] != true {
-		t.Fatalf("return_html5_block_data = %#v, want true in %#v", got["return_html5_block_data"], got)
+	if _, ok := got["return_html5_block_data"]; ok {
+		t.Fatalf("extra_param should not request html5 block data: %#v", got)
 	}
 	if _, ok := got["reference_map_mode"]; ok {
 		t.Fatalf("extra_param should not use legacy reference_map_mode: %#v", got)
 	}
-	if len(got) != 2 {
-		t.Fatalf("extra_param should only contain fetch reference_map and html5 data toggles: %#v", got)
+	if len(got) != 1 {
+		t.Fatalf("extra_param should only contain fetch reference_map toggle: %#v", got)
 	}
 }
 
@@ -579,46 +579,6 @@ func TestDocsFetchIMMarkdownRequestsMarkdownFromAPI(t *testing.T) {
 	}
 }
 
-func TestDocsFetchIMMarkdownIgnoresHTML5BlockInsideCodeFence(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-fetch-im-markdown-code-fence"))
-	registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents/doxcnFetchIMMarkdownFence/fetch", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcnFetchIMMarkdownFence",
-			"revision_id": float64(1),
-			"content":     "```xml\n<html5-block data-ref=\"html5_1\"></html5-block>\n```\n",
-		},
-	})
-
-	err := mountAndRunDocs(t, DocsFetch, []string{
-		"+fetch",
-		"--doc", "doxcnFetchIMMarkdownFence",
-		"--doc-format", "im-markdown",
-		"--format", "json",
-		"--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())
-	}
-	if errField, ok := envelope["error"]; ok {
-		t.Fatalf("fetch output should not contain error: %#v", errField)
-	}
-	data, _ := envelope["data"].(map[string]interface{})
-	doc, _ := data["document"].(map[string]interface{})
-	content, _ := doc["content"].(string)
-	if !strings.Contains(content, "```xml\n<html5-block data-ref=\"html5_1\"></html5-block>\n```") {
-		t.Fatalf("fenced html5-block should stay in content, got:\n%s", content)
-	}
-	if _, ok := doc["reference_map"]; ok {
-		t.Fatalf("fenced html5-block should not create reference_map side effects: %#v", doc["reference_map"])
-	}
-}
-
 func TestDocsFetchMarkdownDetailDowngradesToSimple(t *testing.T) {
 	t.Parallel()
 

shortcuts/doc/docs_history.go

@@ -1,261 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package doc
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-type docsHistoryListSpec struct {
-	Doc       documentRef
-	PageSize  int
-	PageToken string
-}
-
-type docsHistoryRevertSpec struct {
-	Doc              documentRef
-	HistoryVersionID string
-	WaitTimeoutMs    int
-}
-
-type docsHistoryRevertStatusSpec struct {
-	Doc    documentRef
-	TaskID string
-}
-
-func parseDocsHistoryDocRef(raw, shortcut string) (documentRef, error) {
-	ref, err := parseDocumentRef(raw)
-	if err != nil {
-		return documentRef{}, err
-	}
-	if ref.Kind == "doc" {
-		return documentRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "docs %s only supports docx documents; use a docx token/URL or a wiki URL that resolves to docx", shortcut).WithParam("--doc")
-	}
-	return ref, nil
-}
-
-func validateDocsHistoryPageSize(pageSize int) error {
-	if pageSize < 1 || pageSize > 20 {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --page-size %d: must be between 1 and 20", pageSize).WithParam("--page-size")
-	}
-	return nil
-}
-
-func validateDocsHistoryVersionID(historyVersionID string) error {
-	version, err := strconv.ParseInt(strings.TrimSpace(historyVersionID), 10, 64)
-	if err != nil {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--history-version-id must be a positive integer string returned by docs +history-list").WithParam("--history-version-id").WithCause(err)
-	}
-	if version <= 0 {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--history-version-id must be a positive integer string returned by docs +history-list").WithParam("--history-version-id")
-	}
-	return nil
-}
-
-func validateDocsHistoryWaitTimeout(timeoutMs int) error {
-	if timeoutMs < 0 || timeoutMs > 30000 {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --wait-timeout-ms %d: must be between 0 and 30000", timeoutMs).WithParam("--wait-timeout-ms")
-	}
-	return nil
-}
-
-func docsHistoryListParams(spec docsHistoryListSpec) map[string]interface{} {
-	params := map[string]interface{}{
-		"page_size": spec.PageSize,
-	}
-	if spec.PageToken != "" {
-		params["page_token"] = spec.PageToken
-	}
-	return params
-}
-
-func docsHistoryRevertBody(spec docsHistoryRevertSpec) map[string]interface{} {
-	return map[string]interface{}{
-		"history_version_id": spec.HistoryVersionID,
-		"wait_timeout_ms":    spec.WaitTimeoutMs,
-	}
-}
-
-func docsHistoryStatusParams(spec docsHistoryRevertStatusSpec) map[string]interface{} {
-	return map[string]interface{}{
-		"task_id": spec.TaskID,
-	}
-}
-
-func docsHistoryAPIPath(docToken, suffix string) string {
-	return fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/%s", validate.EncodePathSegment(docToken), suffix)
-}
-
-var DocsHistoryList = common.Shortcut{
-	Service:     "docs",
-	Command:     "+history-list",
-	Description: "List Lark document history versions",
-	Risk:        "read",
-	Scopes:      []string{"docx:document:readonly"},
-	AuthTypes:   []string{"user", "bot"},
-	PostMount:   installDocsShortcutHelp("+history-list"),
-	Flags: []common.Flag{
-		{Name: "doc", Desc: "document URL or token", Required: true},
-		{Name: "page-size", Type: "int", Default: "20", Desc: "history entries to return, range 1-20"},
-		{Name: "page-token", Desc: "pagination token from the previous page's page_token"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if _, err := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-list"); err != nil {
-			return err
-		}
-		return validateDocsHistoryPageSize(runtime.Int("page-size"))
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		ref, _ := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-list")
-		spec := docsHistoryListSpec{
-			Doc:       ref,
-			PageSize:  runtime.Int("page-size"),
-			PageToken: strings.TrimSpace(runtime.Str("page-token")),
-		}
-		return common.NewDryRunAPI().
-			Desc("OpenAPI: list document history versions").
-			GET("/open-apis/docs_ai/v1/documents/:document_id/histories").
-			Set("document_id", spec.Doc.Token).
-			Params(docsHistoryListParams(spec))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		ref, _ := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-list")
-		spec := docsHistoryListSpec{
-			Doc:       ref,
-			PageSize:  runtime.Int("page-size"),
-			PageToken: strings.TrimSpace(runtime.Str("page-token")),
-		}
-
-		data, err := runtime.CallAPITyped(
-			http.MethodGet,
-			docsHistoryAPIPath(spec.Doc.Token, "histories"),
-			docsHistoryListParams(spec),
-			nil,
-		)
-		if err != nil {
-			return err
-		}
-		runtime.OutRaw(data, nil)
-		return nil
-	},
-}
-
-var DocsHistoryRevert = common.Shortcut{
-	Service:     "docs",
-	Command:     "+history-revert",
-	Description: "Revert a Lark document to a historical version",
-	Risk:        "write",
-	Scopes:      []string{"docx:document:write_only", "docx:document:readonly"},
-	AuthTypes:   []string{"user", "bot"},
-	PostMount:   installDocsShortcutHelp("+history-revert"),
-	Flags: []common.Flag{
-		{Name: "doc", Desc: "document URL or token", Required: true},
-		{Name: "history-version-id", Desc: "history_version_id from docs +history-list to revert to", Required: true},
-		{Name: "wait-timeout-ms", Type: "int", Default: "30000", Desc: "milliseconds to wait for revert completion before returning, range 0-30000"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if _, err := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-revert"); err != nil {
-			return err
-		}
-		if err := validateDocsHistoryVersionID(runtime.Str("history-version-id")); err != nil {
-			return err
-		}
-		return validateDocsHistoryWaitTimeout(runtime.Int("wait-timeout-ms"))
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		ref, _ := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-revert")
-		spec := docsHistoryRevertSpec{
-			Doc:              ref,
-			HistoryVersionID: strings.TrimSpace(runtime.Str("history-version-id")),
-			WaitTimeoutMs:    runtime.Int("wait-timeout-ms"),
-		}
-		return common.NewDryRunAPI().
-			Desc("OpenAPI: revert document history").
-			POST("/open-apis/docs_ai/v1/documents/:document_id/history/revert").
-			Set("document_id", spec.Doc.Token).
-			Body(docsHistoryRevertBody(spec))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		ref, _ := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-revert")
-		spec := docsHistoryRevertSpec{
-			Doc:              ref,
-			HistoryVersionID: strings.TrimSpace(runtime.Str("history-version-id")),
-			WaitTimeoutMs:    runtime.Int("wait-timeout-ms"),
-		}
-
-		data, err := runtime.CallAPITyped(
-			http.MethodPost,
-			docsHistoryAPIPath(spec.Doc.Token, "history/revert"),
-			nil,
-			docsHistoryRevertBody(spec),
-		)
-		if err != nil {
-			return err
-		}
-		runtime.OutRaw(data, nil)
-		return nil
-	},
-}
-
-var DocsHistoryRevertStatus = common.Shortcut{
-	Service:     "docs",
-	Command:     "+history-revert-status",
-	Description: "Get Lark document history revert task status",
-	Risk:        "read",
-	Scopes:      []string{"docx:document:readonly"},
-	AuthTypes:   []string{"user", "bot"},
-	PostMount:   installDocsShortcutHelp("+history-revert-status"),
-	Flags: []common.Flag{
-		{Name: "doc", Desc: "document URL or token", Required: true},
-		{Name: "task-id", Desc: "task_id returned by docs +history-revert", Required: true},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if _, err := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-revert-status"); err != nil {
-			return err
-		}
-		if strings.TrimSpace(runtime.Str("task-id")) == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--task-id is required").WithParam("--task-id")
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		ref, _ := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-revert-status")
-		spec := docsHistoryRevertStatusSpec{
-			Doc:    ref,
-			TaskID: strings.TrimSpace(runtime.Str("task-id")),
-		}
-		return common.NewDryRunAPI().
-			Desc("OpenAPI: get document history revert status").
-			GET("/open-apis/docs_ai/v1/documents/:document_id/history/revert_status").
-			Set("document_id", spec.Doc.Token).
-			Params(docsHistoryStatusParams(spec))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		ref, _ := parseDocsHistoryDocRef(runtime.Str("doc"), "+history-revert-status")
-		spec := docsHistoryRevertStatusSpec{
-			Doc:    ref,
-			TaskID: strings.TrimSpace(runtime.Str("task-id")),
-		}
-
-		data, err := runtime.CallAPITyped(
-			http.MethodGet,
-			docsHistoryAPIPath(spec.Doc.Token, "history/revert_status"),
-			docsHistoryStatusParams(spec),
-			nil,
-		)
-		if err != nil {
-			return err
-		}
-		runtime.OutRaw(data, nil)
-		return nil
-	},
-}

shortcuts/doc/docs_history_test.go

@@ -1,340 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package doc
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"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 TestDocsHistoryValidation(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name      string
-		shortcut  common.Shortcut
-		args      []string
-		param     string
-		category  errs.Category
-		subtype   errs.Subtype
-		wantCause bool
-	}{
-		{
-			name:     "list rejects legacy doc URL",
-			shortcut: DocsHistoryList,
-			args:     []string{"+history-list", "--doc", "https://example.feishu.cn/doc/old_doc", "--as", "bot"},
-			param:    "--doc",
-			category: errs.CategoryValidation,
-			subtype:  errs.SubtypeInvalidArgument,
-		},
-		{
-			name:     "list rejects invalid page size",
-			shortcut: DocsHistoryList,
-			args:     []string{"+history-list", "--doc", "doxcnHistory", "--page-size", "0", "--as", "bot"},
-			param:    "--page-size",
-			category: errs.CategoryValidation,
-			subtype:  errs.SubtypeInvalidArgument,
-		},
-		{
-			name:      "revert rejects non-numeric history version id",
-			shortcut:  DocsHistoryRevert,
-			args:      []string{"+history-revert", "--doc", "doxcnHistory", "--history-version-id", "abc", "--as", "bot"},
-			param:     "--history-version-id",
-			category:  errs.CategoryValidation,
-			subtype:   errs.SubtypeInvalidArgument,
-			wantCause: true,
-		},
-		{
-			name:     "revert rejects non-positive history version id",
-			shortcut: DocsHistoryRevert,
-			args:     []string{"+history-revert", "--doc", "doxcnHistory", "--history-version-id", "0", "--as", "bot"},
-			param:    "--history-version-id",
-			category: errs.CategoryValidation,
-			subtype:  errs.SubtypeInvalidArgument,
-		},
-		{
-			name:     "revert rejects invalid wait timeout",
-			shortcut: DocsHistoryRevert,
-			args:     []string{"+history-revert", "--doc", "doxcnHistory", "--history-version-id", "10", "--wait-timeout-ms", "30001", "--as", "bot"},
-			param:    "--wait-timeout-ms",
-			category: errs.CategoryValidation,
-			subtype:  errs.SubtypeInvalidArgument,
-		},
-		{
-			name:     "status rejects empty task id",
-			shortcut: DocsHistoryRevertStatus,
-			args:     []string{"+history-revert-status", "--doc", "doxcnHistory", "--task-id", "", "--as", "bot"},
-			param:    "--task-id",
-			category: errs.CategoryValidation,
-			subtype:  errs.SubtypeInvalidArgument,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			f, stdout, _, _ := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-history-validation"))
-			err := mountAndRunDocs(t, tt.shortcut, tt.args, f, stdout)
-			if err == nil {
-				t.Fatal("expected validation error, got nil")
-			}
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("error is not typed: %T %v", err, err)
-			}
-			if problem.Category != tt.category {
-				t.Fatalf("category = %q, want %q (err: %v)", problem.Category, tt.category, err)
-			}
-			if problem.Subtype != tt.subtype {
-				t.Fatalf("subtype = %q, want %q (err: %v)", problem.Subtype, tt.subtype, err)
-			}
-			var validationErr *errs.ValidationError
-			if !errors.As(err, &validationErr) {
-				t.Fatalf("expected validation error, got %T: %v", err, err)
-			}
-			if validationErr.Param != tt.param {
-				t.Fatalf("param = %q, want %q (err: %v)", validationErr.Param, tt.param, err)
-			}
-			if tt.wantCause && errors.Unwrap(err) == nil {
-				t.Fatalf("expected wrapped cause, got nil (err: %v)", err)
-			}
-		})
-	}
-}
-
-func TestDocsHistoryDryRun(t *testing.T) {
-	t.Parallel()
-
-	listCmd := newDocsHistoryRuntimeCmd(t, DocsHistoryList, map[string]string{
-		"doc":        "doxcnHistoryDryRun",
-		"page-size":  "5",
-		"page-token": "page_token_1",
-	})
-	listDry := decodeDocDryRun(t, DocsHistoryList.DryRun(context.Background(), common.TestNewRuntimeContext(listCmd, nil)))
-	if got, want := listDry.API[0].URL, "/open-apis/docs_ai/v1/documents/doxcnHistoryDryRun/histories"; got != want {
-		t.Fatalf("list dry-run URL = %q, want %q", got, want)
-	}
-	if got := int(listDry.API[0].Params["page_size"].(float64)); got != 5 {
-		t.Fatalf("list page_size = %d, want 5", got)
-	}
-	if got := listDry.API[0].Params["page_token"]; got != "page_token_1" {
-		t.Fatalf("list page_token = %#v, want page_token_1", got)
-	}
-
-	revertCmd := newDocsHistoryRuntimeCmd(t, DocsHistoryRevert, map[string]string{
-		"doc":                "doxcnHistoryDryRun",
-		"history-version-id": "42",
-		"wait-timeout-ms":    "30000",
-	})
-	revertDry := decodeDocDryRun(t, DocsHistoryRevert.DryRun(context.Background(), common.TestNewRuntimeContext(revertCmd, nil)))
-	if got, want := revertDry.API[0].URL, "/open-apis/docs_ai/v1/documents/doxcnHistoryDryRun/history/revert"; got != want {
-		t.Fatalf("revert dry-run URL = %q, want %q", got, want)
-	}
-	if got := revertDry.API[0].Body["history_version_id"]; got != "42" {
-		t.Fatalf("revert history_version_id = %#v, want 42", got)
-	}
-	if got := int(revertDry.API[0].Body["wait_timeout_ms"].(float64)); got != 30000 {
-		t.Fatalf("revert wait_timeout_ms = %d, want 30000", got)
-	}
-
-	statusCmd := newDocsHistoryRuntimeCmd(t, DocsHistoryRevertStatus, map[string]string{
-		"doc":     "doxcnHistoryDryRun",
-		"task-id": "task_1",
-	})
-	statusDry := decodeDocDryRun(t, DocsHistoryRevertStatus.DryRun(context.Background(), common.TestNewRuntimeContext(statusCmd, nil)))
-	if got, want := statusDry.API[0].URL, "/open-apis/docs_ai/v1/documents/doxcnHistoryDryRun/history/revert_status"; got != want {
-		t.Fatalf("status dry-run URL = %q, want %q", got, want)
-	}
-	if got := statusDry.API[0].Params["task_id"]; got != "task_1" {
-		t.Fatalf("status task_id = %#v, want task_1", got)
-	}
-}
-
-func TestDocsHistoryExecuteList(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-history-list"))
-	stub := &httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/docs_ai/v1/documents/doxcnHistory/histories",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"entries": []interface{}{
-					map[string]interface{}{
-						"revision_id":        float64(42),
-						"history_version_id": "11",
-						"edit_time":          "1780000000",
-						"type":               float64(1),
-						"editor_ids":         []interface{}{"ou_1"},
-					},
-				},
-				"has_more":   true,
-				"page_token": "page_token_2",
-			},
-		},
-	}
-	reg.Register(stub)
-
-	err := mountAndRunDocs(t, DocsHistoryList, []string{
-		"+history-list",
-		"--doc", "doxcnHistory",
-		"--page-size", "5",
-		"--page-token", "page_token_1",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := decodeDocsHistoryEnvelope(t, stdout)
-	if got := data["page_token"]; got != "page_token_2" {
-		t.Fatalf("page_token = %#v, want page_token_2", got)
-	}
-	entries, _ := data["entries"].([]interface{})
-	if len(entries) != 1 {
-		t.Fatalf("entries = %#v, want one entry", data["entries"])
-	}
-}
-
-func TestDocsHistoryExecuteRevert(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-history-revert"))
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/docs_ai/v1/documents/doxcnHistory/history/revert",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"task_id":            "task_1",
-				"status":             "running",
-				"history_version_id": "42",
-				"poll_after_ms":      float64(10000),
-			},
-		},
-	}
-	reg.Register(stub)
-
-	err := mountAndRunDocs(t, DocsHistoryRevert, []string{
-		"+history-revert",
-		"--doc", "doxcnHistory",
-		"--history-version-id", "42",
-		"--wait-timeout-ms", "0",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var body map[string]interface{}
-	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
-		t.Fatalf("decode revert body: %v\nraw=%s", err, stub.CapturedBody)
-	}
-	if got := body["history_version_id"]; got != "42" {
-		t.Fatalf("history_version_id = %#v, want 42", got)
-	}
-	if got := int(body["wait_timeout_ms"].(float64)); got != 0 {
-		t.Fatalf("wait_timeout_ms = %d, want 0", got)
-	}
-
-	data := decodeDocsHistoryEnvelope(t, stdout)
-	if got := data["task_id"]; got != "task_1" {
-		t.Fatalf("task_id = %#v, want task_1", got)
-	}
-}
-
-func TestDocsHistoryExecuteRevertStatus(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-history-status"))
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/docs_ai/v1/documents/doxcnHistory/history/revert_status",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"status":              "partial_failed",
-				"history_version_id":  "11",
-				"failed_block_tokens": []interface{}{"blk_1"},
-			},
-		},
-	})
-
-	err := mountAndRunDocs(t, DocsHistoryRevertStatus, []string{
-		"+history-revert-status",
-		"--doc", "doxcnHistory",
-		"--task-id", "task_1",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := decodeDocsHistoryEnvelope(t, stdout)
-	if got := data["status"]; got != "partial_failed" {
-		t.Fatalf("status = %#v, want partial_failed", got)
-	}
-	if got := data["history_version_id"]; got != "11" {
-		t.Fatalf("history_version_id = %#v, want 11", got)
-	}
-	failed, _ := data["failed_block_tokens"].([]interface{})
-	if len(failed) != 1 || failed[0] != "blk_1" {
-		t.Fatalf("failed_block_tokens = %#v, want [blk_1]", data["failed_block_tokens"])
-	}
-}
-
-func newDocsHistoryRuntimeCmd(t *testing.T, shortcut common.Shortcut, values map[string]string) *cobra.Command {
-	t.Helper()
-
-	cmd := &cobra.Command{Use: shortcut.Command}
-	for _, flag := range shortcut.Flags {
-		switch flag.Type {
-		case "int":
-			cmd.Flags().Int(flag.Name, 0, flag.Desc)
-		default:
-			cmd.Flags().String(flag.Name, flag.Default, flag.Desc)
-		}
-	}
-	for name, value := range values {
-		if err := cmd.Flags().Set(name, value); err != nil {
-			t.Fatalf("set --%s: %v", name, err)
-		}
-	}
-	return cmd
-}
-
-func decodeDocsHistoryEnvelope(t *testing.T, stdout *bytes.Buffer) map[string]interface{} {
-	t.Helper()
-
-	var envelope map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
-		t.Fatalf("decode envelope: %v\nraw=%s", err, stdout.String())
-	}
-	data, _ := envelope["data"].(map[string]interface{})
-	if data == nil {
-		t.Fatalf("missing data in envelope: %#v", envelope)
-	}
-	return data
-}
-
-func TestDocsHistoryURLValidationMessage(t *testing.T) {
-	t.Parallel()
-
-	_, err := parseDocsHistoryDocRef("https://example.feishu.cn/doc/old_doc", "+history-list")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), "only supports docx documents") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}

shortcuts/doc/docs_update_test.go

@@ -5,7 +5,6 @@ package doc
 import (
 	"context"
 	"errors"
-	"os"
 	"strings"
 	"testing"
 
@@ -64,39 +63,6 @@ func TestDocsUpdateDryRunIgnoresAPIVersionCompatFlag(t *testing.T) {
 	}
 }
 
-func TestBuildUpdateBodyWithHTML5ReferenceMapReportsPathError(t *testing.T) {
-	t.Parallel()
-
-	runtime := newUpdateShortcutTestRuntime(t, "", map[string]string{
-		"content": `<html5-block path="@missing.html"></html5-block>`,
-	})
-
-	_, err := buildUpdateBodyWithHTML5ReferenceMap(runtime)
-	if err == nil {
-		t.Fatal("buildUpdateBodyWithHTML5ReferenceMap() succeeded, want error")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("ProblemOf() ok = false for %T (%v)", err, err)
-	}
-	if p.Category != errs.CategoryValidation {
-		t.Fatalf("category = %q, want %q", p.Category, errs.CategoryValidation)
-	}
-	if p.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype = %q, want %q", p.Subtype, errs.SubtypeInvalidArgument)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("error type = %T, want *errs.ValidationError", err)
-	}
-	if validationErr.Param != "path" {
-		t.Fatalf("param = %q, want path", validationErr.Param)
-	}
-	if !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("error should preserve os.ErrNotExist cause, got: %v", err)
-	}
-}
-
 func TestDocsUpdateV2ReferenceMapFlagIsPublicFileInput(t *testing.T) {
 	t.Parallel()
 

shortcuts/doc/docs_update_v2.go

@@ -24,9 +24,7 @@ var validCommandsV2 = map[string]bool{
 	"append":                  true,
 }
 
-const docsReferenceMapFlagDesc = "结构化 `reference_map` JSON object；必须与 `--content` 一起使用。普通写入优先把结构写在正文里；`--reference-map` 主要用于保留或回放已有 `document.reference_map`。支持直接 JSON、`@reference-map.json`（相对路径）或 `-` 从 stdin 读取。"
-
-const docsUpdateReferenceMapFlagDesc = docsReferenceMapFlagDesc
+const docsUpdateReferenceMapFlagDesc = "结构化 `reference_map` JSON object；当 `--content` 使用正文外部载荷 / 引用映射时与内容一起传给服务，支持直接 JSON、`@reference-map.json`（相对路径）或 `-` 从 stdin 读取。通常用于回写已有 `document.reference_map`。"
 
 // v2UpdateFlags returns the flag definitions for the v2 (OpenAPI) update path.
 func v2UpdateFlags() []common.Flag {
@@ -117,20 +115,13 @@ func validateUpdateV2(_ context.Context, runtime *common.RuntimeContext) error {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--command append requires --content").WithParam("--content")
 		}
 	}
-	if content != "" {
-		_, err := resolveDocsV2ContentReferenceMap(runtime)
-		return err
-	}
 	return nil
 }
 
 func dryRunUpdateV2(_ context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 	// Validate has already accepted --doc; parseDocumentRef cannot fail here.
 	ref, _ := parseDocumentRef(runtime.Str("doc"))
-	body, err := buildUpdateBodyWithHTML5ReferenceMap(runtime)
-	if err != nil {
-		return common.NewDryRunAPI().Set("error", err.Error())
-	}
+	body, _ := buildUpdateBodyWithReferenceMap(runtime)
 	apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s", ref.Token)
 	return common.NewDryRunAPI().
 		PUT(apiPath).
@@ -143,7 +134,7 @@ func executeUpdateV2(_ context.Context, runtime *common.RuntimeContext) error {
 	ref, _ := parseDocumentRef(runtime.Str("doc"))
 
 	apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s", ref.Token)
-	body, err := buildUpdateBodyWithHTML5ReferenceMap(runtime)
+	body, err := buildUpdateBodyWithReferenceMap(runtime)
 	if err != nil {
 		return err
 	}

shortcuts/doc/html5_block_resources.go

@@ -1,696 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package doc
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"io"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const (
-	html5BlockTag             = "html5-block"
-	html5BlockPathAttr        = "path"
-	html5BlockDataRefAttr     = "data-ref"
-	html5BlockDataAttr        = "data"
-	html5BlockReferenceRoot   = "doc-fetch-resources"
-	html5BlockReferenceMaxRaw = 1024
-)
-
-var (
-	html5BlockStartTagPattern = regexp.MustCompile(`(?is)<html5-block\b[^>]*>`)
-	html5BlockElementPattern  = regexp.MustCompile(`(?is)<html5-block\b[^>]*>(.*?)</html5-block>`)
-	html5BlockSafeNamePattern = regexp.MustCompile(`^[A-Za-z0-9._-]+$`)
-)
-
-type html5BlockReferenceEntry struct {
-	Data   string `json:"data,omitempty"`
-	Path   string `json:"path,omitempty"`
-	UserID string `json:"user_id,omitempty"`
-}
-
-type html5BlockReferenceMap map[string]map[string]html5BlockReferenceEntry
-
-type docsV2WriteInput struct {
-	Content      string
-	ReferenceMap map[string]interface{}
-}
-
-type html5BlockAttr struct {
-	Name  string
-	Value string
-}
-
-type html5BlockStartTag struct {
-	Attrs       []html5BlockAttr
-	SelfClosing bool
-}
-
-func buildCreateBodyWithHTML5ReferenceMap(runtime *common.RuntimeContext) (map[string]interface{}, error) {
-	body := buildCreateBody(runtime)
-	if runtime.Str("content") == "" && !runtime.Changed("reference-map") {
-		return body, nil
-	}
-	input, err := resolveDocsV2ContentReferenceMap(runtime)
-	if err != nil {
-		return nil, err
-	}
-	body["content"] = buildCreateContentWithBody(runtime, input.Content)
-	if len(input.ReferenceMap) > 0 {
-		body["reference_map"] = input.ReferenceMap
-	}
-	return body, nil
-}
-
-func buildUpdateBodyWithHTML5ReferenceMap(runtime *common.RuntimeContext) (map[string]interface{}, error) {
-	body := buildUpdateBody(runtime)
-	input, err := resolveDocsV2ContentReferenceMap(runtime)
-	if err != nil {
-		return nil, err
-	}
-	if input.Content != "" {
-		body["content"] = input.Content
-	}
-	if len(input.ReferenceMap) > 0 {
-		body["reference_map"] = input.ReferenceMap
-	}
-	return body, nil
-}
-
-func validateDocsV2ReferenceMapFlags(runtime *common.RuntimeContext) error {
-	if runtime.Changed("reference-map") && runtime.Str("content") == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--reference-map requires --content").WithParam("--reference-map")
-	}
-	return nil
-}
-
-func resolveDocsV2ContentReferenceMap(runtime *common.RuntimeContext) (docsV2WriteInput, error) {
-	input := docsV2WriteInput{Content: runtime.Str("content")}
-	if raw := runtime.Str("reference-map"); strings.TrimSpace(raw) != "" {
-		refMap, err := parseReferenceMapObject(raw, "--reference-map")
-		if err != nil {
-			return docsV2WriteInput{}, err
-		}
-		input.ReferenceMap = refMap
-	}
-	return prepareDocsV2WriteInput(runtime, input)
-}
-
-func prepareDocsV2WriteInput(runtime *common.RuntimeContext, input docsV2WriteInput) (docsV2WriteInput, error) {
-	refMap := cloneReferenceMapObject(input.ReferenceMap)
-	html5RefMap, err := html5ReferenceMapFromObject(refMap)
-	if err != nil {
-		return docsV2WriteInput{}, err
-	}
-
-	content, html5RefMap, err := prepareHTML5BlockWriteContent(runtime, runtime.Str("doc-format"), input.Content, html5RefMap)
-	if err != nil {
-		return docsV2WriteInput{}, err
-	}
-	if err := resolveReferenceMapPaths(runtime, html5RefMap); err != nil {
-		return docsV2WriteInput{}, err
-	}
-	refMap = mergeHTML5ReferenceMap(refMap, html5RefMap)
-	return docsV2WriteInput{
-		Content:      content,
-		ReferenceMap: refMap,
-	}, nil
-}
-
-func parseReferenceMapObject(raw string, label string) (map[string]interface{}, error) {
-	if len(bytes.TrimSpace([]byte(raw))) == 0 || string(bytes.TrimSpace([]byte(raw))) == "null" {
-		return nil, nil
-	}
-	var refMap map[string]interface{}
-	if err := json.Unmarshal([]byte(raw), &refMap); err != nil {
-		return nil, common.ValidationErrorf("%s is not valid reference_map JSON: %v", label, err).WithParam(label).WithCause(err)
-	}
-	return refMap, nil
-}
-
-func parseHTML5BlockReferenceMapBytes(raw []byte, label string) (html5BlockReferenceMap, error) {
-	if len(bytes.TrimSpace(raw)) == 0 || string(bytes.TrimSpace(raw)) == "null" {
-		return nil, nil
-	}
-	var refMap html5BlockReferenceMap
-	if err := json.Unmarshal(raw, &refMap); err != nil {
-		return nil, common.ValidationErrorf("%s is not valid reference_map JSON: %v", label, err).WithParam(label).WithCause(err)
-	}
-	return compactReferenceMap(refMap), nil
-}
-
-func prepareHTML5BlockWriteContent(runtime *common.RuntimeContext, format string, content string, refMap html5BlockReferenceMap) (string, html5BlockReferenceMap, error) {
-	if !strings.Contains(content, "<html5-block") {
-		return content, compactReferenceMap(refMap), nil
-	}
-	if err := validateHTML5BlockWriteElementBodies(format, content); err != nil {
-		return "", nil, err
-	}
-
-	refMap = cloneReferenceMap(refMap)
-	if refMap == nil {
-		refMap = html5BlockReferenceMap{}
-	}
-	ensureReferenceGroup(refMap, html5BlockTag)
-	nextRef := nextHTML5BlockRef(refMap)
-
-	rewrite := func(segment string) (string, error) {
-		return rewriteHTML5BlockStartTags(segment, func(raw string) (string, error) {
-			tag, err := parseHTML5BlockStartTag(raw)
-			if err != nil {
-				return "", common.ValidationErrorf("invalid html5-block tag: %v", err).WithParam("html5-block")
-			}
-			if tag.hasAttr(html5BlockDataAttr) {
-				return "", common.ValidationErrorf("html5-block data is reserved for SDK internals; use data-ref with reference_map or path=\"@relative.html\"").WithParam("html5-block")
-			}
-
-			pathValue, hasPath := tag.attr(html5BlockPathAttr)
-			dataRef, hasDataRef := tag.attr(html5BlockDataRefAttr)
-			if hasPath && hasDataRef {
-				return "", common.ValidationErrorf("html5-block cannot contain both path and data-ref").WithParam("html5-block")
-			}
-			if hasDataRef {
-				ref := strings.TrimSpace(dataRef)
-				if ref == "" {
-					return "", common.ValidationErrorf("html5-block data-ref cannot be empty").WithParam("data-ref")
-				}
-				if _, ok := refMap[html5BlockTag][ref]; !ok {
-					return "", common.ValidationErrorf("reference_map.%s.%s is required for html5-block data-ref", html5BlockTag, ref).WithParam("reference_map")
-				}
-				return tag.render(false), nil
-			}
-			if !hasPath {
-				return "", common.ValidationErrorf("html5-block requires path=\"@relative.html\" or data-ref with reference_map").WithParam("html5-block")
-			}
-
-			data, err := readHTML5BlockPath(runtime, pathValue, "html5-block path")
-			if err != nil {
-				return "", err
-			}
-			ref := nextRef()
-			refMap[html5BlockTag][ref] = html5BlockReferenceEntry{Data: data}
-			tag.removeAttrs(html5BlockPathAttr, html5BlockDataRefAttr, html5BlockDataAttr)
-			tag.Attrs = append(tag.Attrs, html5BlockAttr{Name: html5BlockDataRefAttr, Value: ref})
-			return tag.render(false), nil
-		})
-	}
-
-	var (
-		out string
-		err error
-	)
-	if strings.TrimSpace(format) == "markdown" {
-		out = applyOutsideCodeFences(content, func(segment string) string {
-			if err != nil {
-				return segment
-			}
-			outSegment, rewriteErr := rewrite(segment)
-			if rewriteErr != nil {
-				err = rewriteErr
-				return segment
-			}
-			return outSegment
-		})
-	} else {
-		out, err = rewrite(content)
-	}
-	if err != nil {
-		return "", nil, err
-	}
-	return out, compactReferenceMap(refMap), nil
-}
-
-func validateHTML5BlockWriteElementBodies(format string, content string) error {
-	validateSegment := func(segment string) error {
-		matches := html5BlockElementPattern.FindAllStringSubmatchIndex(segment, -1)
-		for _, match := range matches {
-			if len(match) < 4 || match[2] < 0 || match[3] < 0 {
-				continue
-			}
-			if strings.TrimSpace(segment[match[2]:match[3]]) != "" {
-				return common.ValidationErrorf("html5-block content must be loaded from path=\"@relative.html\" or reference_map; remove content between <html5-block> and </html5-block>").WithParam("html5-block")
-			}
-		}
-		return nil
-	}
-
-	if strings.TrimSpace(format) != "markdown" {
-		return validateSegment(content)
-	}
-
-	var validateErr error
-	_ = applyOutsideCodeFences(content, func(segment string) string {
-		if validateErr != nil {
-			return segment
-		}
-		validateErr = validateSegment(segment)
-		return segment
-	})
-	return validateErr
-}
-
-func processHTML5BlockReferenceMapForFetch(runtime *common.RuntimeContext, format string, docToken string, data map[string]interface{}) error {
-	doc, _ := data["document"].(map[string]interface{})
-	if doc == nil {
-		return nil
-	}
-	content, _ := doc["content"].(string)
-	if !hasProcessableHTML5Block(format, content) {
-		return nil
-	}
-
-	refMap, err := referenceMapFromDocument(doc)
-	if err != nil {
-		return err
-	}
-	group := refMap[html5BlockTag]
-	if group == nil {
-		return common.ValidationErrorf("document.reference_map.%s is required for fetched html5-block content", html5BlockTag).WithParam("reference_map")
-	}
-
-	if err := validateFetchedHTML5BlockRefs(format, content, refMap); err != nil {
-		return err
-	}
-
-	changed := false
-	for ref, entry := range group {
-		if entry.Data == "" || len([]byte(entry.Data)) <= html5BlockReferenceMaxRaw {
-			continue
-		}
-		relPath, err := writeHTML5BlockReferenceFile(runtime, docToken, ref, entry.Data)
-		if err != nil {
-			return err
-		}
-		entry.Data = ""
-		entry.Path = "@" + filepath.ToSlash(relPath)
-		group[ref] = entry
-		changed = true
-	}
-	if changed {
-		doc["reference_map"] = refMap
-	}
-	return nil
-}
-
-func referenceMapFromDocument(doc map[string]interface{}) (html5BlockReferenceMap, error) {
-	raw, ok := doc["reference_map"]
-	if !ok || raw == nil {
-		return nil, common.ValidationErrorf("document.reference_map is required for fetched html5-block content").WithParam("reference_map")
-	}
-	refMap, err := referenceMapFromValue(raw, "document.reference_map")
-	if err != nil {
-		return nil, err
-	}
-	if len(refMap) == 0 {
-		return nil, common.ValidationErrorf("document.reference_map is required for fetched html5-block content").WithParam("reference_map")
-	}
-	return refMap, nil
-}
-
-func referenceMapFromValue(value interface{}, label string) (html5BlockReferenceMap, error) {
-	if typed, ok := value.(html5BlockReferenceMap); ok {
-		return compactReferenceMap(typed), nil
-	}
-	raw, err := json.Marshal(value)
-	if err != nil {
-		return nil, common.ValidationErrorf("%s is not valid reference_map JSON: %v", label, err).WithParam("reference_map").WithCause(err)
-	}
-	return parseHTML5BlockReferenceMapBytes(raw, label)
-}
-
-func validateFetchedHTML5BlockRefs(format string, content string, refMap html5BlockReferenceMap) error {
-	validateSegment := func(segment string) error {
-		_, err := rewriteHTML5BlockStartTags(segment, func(raw string) (string, error) {
-			tag, parseErr := parseHTML5BlockStartTag(raw)
-			if parseErr != nil {
-				return raw, common.ValidationErrorf("invalid html5-block tag in fetched content: %v", parseErr).WithParam("html5-block")
-			}
-			ref, ok := tag.attr(html5BlockDataRefAttr)
-			if !ok || strings.TrimSpace(ref) == "" {
-				return raw, common.ValidationErrorf("fetched html5-block is missing data-ref; cannot resolve HTML reference").WithParam("html5-block")
-			}
-			ref = strings.TrimSpace(ref)
-			if _, ok := refMap[html5BlockTag][ref]; !ok {
-				return raw, common.ValidationErrorf("document.reference_map.%s.%s is missing; cannot resolve html5-block. Re-run fetch or check that the upstream document.reference_map field includes this ref.", html5BlockTag, ref).WithParam("reference_map")
-			}
-			return raw, nil
-		})
-		return err
-	}
-
-	if strings.TrimSpace(format) != "markdown" {
-		return validateSegment(content)
-	}
-	var validateErr error
-	_ = applyOutsideCodeFences(content, func(segment string) string {
-		if validateErr != nil {
-			return segment
-		}
-		validateErr = validateSegment(segment)
-		return segment
-	})
-	return validateErr
-}
-
-func resolveReferenceMapPaths(runtime *common.RuntimeContext, refMap html5BlockReferenceMap) error {
-	for typ, group := range refMap {
-		for ref, entry := range group {
-			if strings.TrimSpace(entry.Path) == "" {
-				continue
-			}
-			if entry.Data != "" {
-				return common.ValidationErrorf("reference_map.%s.%s must use either data or path, not both", typ, ref).WithParam("reference_map")
-			}
-			data, err := readHTML5BlockPath(runtime, entry.Path, fmt.Sprintf("reference_map.%s.%s.path", typ, ref))
-			if err != nil {
-				return err
-			}
-			entry.Data = data
-			entry.Path = ""
-			group[ref] = entry
-		}
-	}
-	return nil
-}
-
-func readHTML5BlockPath(runtime *common.RuntimeContext, pathValue string, label string) (string, error) {
-	pathRaw := strings.TrimSpace(pathValue)
-	if !strings.HasPrefix(pathRaw, "@") {
-		return "", common.ValidationErrorf("%s %q must start with @, for example @widget.html", label, pathValue).WithParam("path")
-	}
-	relPath := strings.TrimSpace(strings.TrimPrefix(pathRaw, "@"))
-	if relPath == "" {
-		return "", common.ValidationErrorf("%s cannot be empty after @", label).WithParam("path")
-	}
-	clean := filepath.Clean(relPath)
-	if filepath.IsAbs(clean) || clean == "." || clean == ".." || strings.HasPrefix(clean, ".."+string(filepath.Separator)) {
-		return "", common.ValidationErrorf("%s %q must be a relative path within the current working directory", label, pathValue).WithParam("path")
-	}
-	if strings.ToLower(filepath.Ext(clean)) != ".html" {
-		return "", common.ValidationErrorf("%s %q must point to a .html file", label, pathValue).WithParam("path")
-	}
-	data, err := cmdutil.ReadInputFile(runtime.FileIO(), clean)
-	if err != nil {
-		return "", common.ValidationErrorf("%s %q cannot be read from the current working directory; check that the file exists relative to where lark-cli is running: %v", label, clean, err).WithParam("path").WithCause(err)
-	}
-	return string(data), nil
-}
-
-func hasProcessableHTML5Block(format string, content string) bool {
-	if !strings.Contains(content, "<html5-block") {
-		return false
-	}
-	if strings.TrimSpace(format) != "markdown" {
-		return true
-	}
-	found := false
-	_ = applyOutsideCodeFences(content, func(segment string) string {
-		if strings.Contains(segment, "<html5-block") {
-			found = true
-		}
-		return segment
-	})
-	return found
-}
-
-func applyOutsideCodeFences(content string, fn func(segment string) string) string {
-	var out strings.Builder
-	var segment strings.Builder
-	inFence := false
-
-	flush := func() {
-		if segment.Len() == 0 {
-			return
-		}
-		out.WriteString(fn(segment.String()))
-		segment.Reset()
-	}
-
-	for _, line := range strings.SplitAfter(content, "\n") {
-		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "```") || strings.HasPrefix(trimmed, "~~~") {
-			if !inFence {
-				flush()
-				inFence = true
-			} else {
-				inFence = false
-			}
-			out.WriteString(line)
-			continue
-		}
-		if inFence {
-			out.WriteString(line)
-		} else {
-			segment.WriteString(line)
-		}
-	}
-	flush()
-	return out.String()
-}
-
-func cloneReferenceMap(refMap html5BlockReferenceMap) html5BlockReferenceMap {
-	if len(refMap) == 0 {
-		return nil
-	}
-	out := make(html5BlockReferenceMap, len(refMap))
-	for typ, group := range refMap {
-		if len(group) == 0 {
-			continue
-		}
-		outGroup := make(map[string]html5BlockReferenceEntry, len(group))
-		for ref, entry := range group {
-			outGroup[ref] = entry
-		}
-		out[typ] = outGroup
-	}
-	return out
-}
-
-func cloneReferenceMapObject(refMap map[string]interface{}) map[string]interface{} {
-	if len(refMap) == 0 {
-		return nil
-	}
-	out := make(map[string]interface{}, len(refMap))
-	for key, value := range refMap {
-		out[key] = value
-	}
-	return out
-}
-
-func html5ReferenceMapFromObject(refMap map[string]interface{}) (html5BlockReferenceMap, error) {
-	if len(refMap) == 0 {
-		return nil, nil
-	}
-	group, ok := refMap[html5BlockTag]
-	if !ok || group == nil {
-		return nil, nil
-	}
-	return referenceMapFromValue(map[string]interface{}{html5BlockTag: group}, "reference_map."+html5BlockTag)
-}
-
-func mergeHTML5ReferenceMap(refMap map[string]interface{}, html5RefMap html5BlockReferenceMap) map[string]interface{} {
-	group := html5RefMap[html5BlockTag]
-	if len(group) == 0 {
-		return refMap
-	}
-	if refMap == nil {
-		refMap = map[string]interface{}{}
-	}
-	refMap[html5BlockTag] = group
-	return refMap
-}
-
-func compactReferenceMap(refMap html5BlockReferenceMap) html5BlockReferenceMap {
-	if len(refMap) == 0 {
-		return nil
-	}
-	out := make(html5BlockReferenceMap, len(refMap))
-	for typ, group := range refMap {
-		if len(group) == 0 {
-			continue
-		}
-		out[typ] = group
-	}
-	if len(out) == 0 {
-		return nil
-	}
-	return out
-}
-
-func ensureReferenceGroup(refMap html5BlockReferenceMap, typ string) {
-	if refMap[typ] == nil {
-		refMap[typ] = map[string]html5BlockReferenceEntry{}
-	}
-}
-
-func nextHTML5BlockRef(refMap html5BlockReferenceMap) func() string {
-	next := 1
-	return func() string {
-		for {
-			ref := fmt.Sprintf("html5_%d", next)
-			next++
-			if _, exists := refMap[html5BlockTag][ref]; !exists {
-				return ref
-			}
-		}
-	}
-}
-
-func writeHTML5BlockReferenceFile(runtime *common.RuntimeContext, docToken string, ref string, html string) (string, error) {
-	if !isSafeHTML5BlockResourceName(docToken) {
-		return "", common.ValidationErrorf("document_id %q cannot be used as a resource directory name", docToken).WithParam("document_id")
-	}
-	if !isSafeHTML5BlockResourceName(ref) {
-		return "", common.ValidationErrorf("html5-block data-ref %q cannot be used as a file name", ref).WithParam("data-ref")
-	}
-	relPath := filepath.Join(html5BlockReferenceRoot, docToken, ref+".html")
-	data := []byte(html)
-	_, err := runtime.FileIO().Save(relPath, fileio.SaveOptions{
-		ContentType:   "text/html; charset=utf-8",
-		ContentLength: int64(len(data)),
-	}, bytes.NewReader(data))
-	if err != nil {
-		if errors.Is(err, fileio.ErrPathValidation) {
-			return "", common.ValidationErrorf("cannot write html5-block reference file %q: %v", relPath, err).WithParam("reference_map").WithCause(err)
-		}
-		return "", errs.NewInternalError(errs.SubtypeFileIO, "cannot write html5-block reference file %q: %v", relPath, err).WithCause(err)
-	}
-	return relPath, nil
-}
-
-func isSafeHTML5BlockResourceName(name string) bool {
-	return name != "." && name != ".." && html5BlockSafeNamePattern.MatchString(name)
-}
-
-func rewriteHTML5BlockStartTags(content string, fn func(raw string) (string, error)) (string, error) {
-	var rewriteErr error
-	out := html5BlockStartTagPattern.ReplaceAllStringFunc(content, func(raw string) string {
-		if rewriteErr != nil {
-			return raw
-		}
-		rewritten, err := fn(raw)
-		if err != nil {
-			rewriteErr = err
-			return raw
-		}
-		return rewritten
-	})
-	if rewriteErr != nil {
-		return "", rewriteErr
-	}
-	return out, nil
-}
-
-func parseHTML5BlockStartTag(raw string) (html5BlockStartTag, error) {
-	trimmed := strings.TrimSpace(raw)
-	selfClosing := strings.HasSuffix(trimmed, "/>")
-	decoder := xml.NewDecoder(strings.NewReader(raw))
-	for {
-		tok, err := decoder.Token()
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				break
-			}
-			return html5BlockStartTag{}, err
-		}
-		start, ok := tok.(xml.StartElement)
-		if !ok {
-			continue
-		}
-		if start.Name.Local != html5BlockTag {
-			return html5BlockStartTag{}, fmt.Errorf("expected <%s>, got <%s>", html5BlockTag, start.Name.Local) //nolint:forbidigo // intermediate parse helper; callers wrap with typed validation errors.
-		}
-		attrs := make([]html5BlockAttr, 0, len(start.Attr))
-		for _, attr := range start.Attr {
-			attrs = append(attrs, html5BlockAttr{Name: attr.Name.Local, Value: attr.Value})
-		}
-		return html5BlockStartTag{Attrs: attrs, SelfClosing: selfClosing}, nil
-	}
-	return html5BlockStartTag{}, fmt.Errorf("missing start element") //nolint:forbidigo // intermediate parse helper; callers wrap with typed validation errors.
-}
-
-func (t html5BlockStartTag) attr(name string) (string, bool) {
-	for _, attr := range t.Attrs {
-		if attr.Name == name {
-			return attr.Value, true
-		}
-	}
-	return "", false
-}
-
-func (t html5BlockStartTag) hasAttr(name string) bool {
-	_, ok := t.attr(name)
-	return ok
-}
-
-func (t *html5BlockStartTag) removeAttrs(names ...string) {
-	remove := make(map[string]struct{}, len(names))
-	for _, name := range names {
-		remove[name] = struct{}{}
-	}
-	attrs := t.Attrs[:0]
-	for _, attr := range t.Attrs {
-		if _, ok := remove[attr.Name]; ok {
-			continue
-		}
-		attrs = append(attrs, attr)
-	}
-	t.Attrs = attrs
-}
-
-func (t html5BlockStartTag) render(selfClosing bool) string {
-	var b strings.Builder
-	b.WriteByte('<')
-	b.WriteString(html5BlockTag)
-	for _, attr := range t.Attrs {
-		b.WriteByte(' ')
-		b.WriteString(attr.Name)
-		b.WriteString(`="`)
-		b.WriteString(escapeXMLAttr(attr.Value))
-		b.WriteByte('"')
-	}
-	if selfClosing {
-		b.WriteString("/>")
-	} else {
-		b.WriteByte('>')
-	}
-	if t.SelfClosing && !selfClosing {
-		b.WriteString("</")
-		b.WriteString(html5BlockTag)
-		b.WriteByte('>')
-	}
-	return b.String()
-}
-
-func escapeXMLAttr(value string) string {
-	var b strings.Builder
-	for _, r := range value {
-		switch r {
-		case '&':
-			b.WriteString("&amp;")
-		case '<':
-			b.WriteString("&lt;")
-		case '>':
-			b.WriteString("&gt;")
-		case '"':
-			b.WriteString("&quot;")
-		case '\'':
-			b.WriteString("&apos;")
-		default:
-			b.WriteRune(r)
-		}
-	}
-	return b.String()
-}

shortcuts/doc/html5_block_resources_test.go

@@ -1,563 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package doc
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-func TestDocsV2ReferenceMapFlagIsPublicFileInput(t *testing.T) {
-	for name, flags := range map[string][]common.Flag{
-		"create": v2CreateFlags(),
-		"update": v2UpdateFlags(),
-	} {
-		t.Run(name, func(t *testing.T) {
-			flag := findDocsTestFlag(flags, "reference-map")
-			if flag.Name == "" {
-				t.Fatal("reference-map flag not found")
-			}
-			if flag.Hidden {
-				t.Fatal("reference-map flag should be public")
-			}
-			if !hasDocsTestInput(flag, common.File) || !hasDocsTestInput(flag, common.Stdin) {
-				t.Fatalf("reference-map Input = %#v, want file and stdin", flag.Input)
-			}
-			if !strings.Contains(flag.Desc, "@reference-map.json") {
-				t.Fatalf("reference-map help should mention @file support, got %q", flag.Desc)
-			}
-		})
-	}
-}
-
-func TestDocsV2InputFlagIsNotAvailable(t *testing.T) {
-	for name, flags := range map[string][]common.Flag{
-		"create": v2CreateFlags(),
-		"update": v2UpdateFlags(),
-	} {
-		t.Run(name, func(t *testing.T) {
-			for _, flag := range flags {
-				if flag.Name == "input" {
-					t.Fatalf("%s should not expose input flag", name)
-				}
-			}
-		})
-	}
-}
-
-func TestDocsUpdateV2ReferenceMapPreservesGenericGroups(t *testing.T) {
-	t.Parallel()
-
-	runtime := newUpdateShortcutTestRuntime(t, "", map[string]string{
-		"command":       "append",
-		"content":       `<p><widget data-ref="r1"></widget></p>`,
-		"reference-map": `{"widget":{"r1":{"label":"widget-ref-value"}}}`,
-	})
-	body, err := buildUpdateBodyWithHTML5ReferenceMap(runtime)
-	if err != nil {
-		t.Fatalf("buildUpdateBodyWithHTML5ReferenceMap: %v", err)
-	}
-
-	refMap, ok := body["reference_map"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("reference_map = %#v, want object", body["reference_map"])
-	}
-	widget, _ := refMap["widget"].(map[string]interface{})
-	r1, _ := widget["r1"].(map[string]interface{})
-	if got := r1["label"]; got != "widget-ref-value" {
-		t.Fatalf("reference_map.widget.r1.label = %#v, want widget-ref-value; body=%#v", got, body)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockReferenceMapFromPath(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile("widget.html", []byte("<html><body>hello</body></html>"), 0o600); err != nil {
-		t.Fatalf("WriteFile() error: %v", err)
-	}
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-	stub := registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_new_doc",
-			"revision_id": float64(1),
-		},
-	})
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<title>demo</title><html5-block path="@widget.html"></html5-block>`,
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	body := decodeRequestBody(t, stub.CapturedBody)
-	if got := body["content"].(string); !strings.Contains(got, `<html5-block data-ref="html5_1"></html5-block>`) {
-		t.Fatalf("content was not rewritten with data-ref: %s", got)
-	}
-	refMap := decodeHTML5ReferenceMap(t, body["reference_map"])
-	if got := refMap[html5BlockTag]["html5_1"].Data; got != "<html><body>hello</body></html>" {
-		t.Fatalf("reference_map html data = %q", got)
-	}
-	if _, ok := body["resources"]; ok {
-		t.Fatalf("request body must not use resources: %#v", body)
-	}
-}
-
-func findDocsTestFlag(flags []common.Flag, name string) common.Flag {
-	for _, flag := range flags {
-		if flag.Name == name {
-			return flag
-		}
-	}
-	return common.Flag{}
-}
-
-func hasDocsTestInput(flag common.Flag, input string) bool {
-	for _, item := range flag.Input {
-		if item == input {
-			return true
-		}
-	}
-	return false
-}
-
-func TestDocsUpdateV2HTML5BlockReferenceMapFromPath(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile("widget.html", []byte("<section>updated</section>"), 0o600); err != nil {
-		t.Fatalf("WriteFile() error: %v", err)
-	}
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-html5-update"))
-	stub := registerDocsAIStub(reg, "PUT", "/open-apis/docs_ai/v1/documents/doxcn_doc", map[string]interface{}{
-		"document": map[string]interface{}{
-			"revision_id": float64(2),
-			"new_blocks": []interface{}{
-				map[string]interface{}{
-					"block_type":  "html5-block",
-					"block_id":    "blk_html5",
-					"block_token": "boardXXXX",
-				},
-			},
-		},
-		"result": "success",
-	})
-
-	err := mountAndRunDocs(t, DocsUpdate, []string{
-		"+update",
-		"--api-version", "v2",
-		"--doc", "doxcn_doc",
-		"--command", "append",
-		"--content", `<html5-block path="@widget.html"></html5-block>`,
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	body := decodeRequestBody(t, stub.CapturedBody)
-	if got := body["content"].(string); got != `<html5-block data-ref="html5_1"></html5-block>` {
-		t.Fatalf("content = %q", got)
-	}
-	refMap := decodeHTML5ReferenceMap(t, body["reference_map"])
-	if got := refMap[html5BlockTag]["html5_1"].Data; got != "<section>updated</section>" {
-		t.Fatalf("reference_map html data = %q", got)
-	}
-
-	var envelope map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
-		t.Fatalf("decode stdout: %v\n%s", err, stdout.String())
-	}
-	data, _ := envelope["data"].(map[string]interface{})
-	doc, _ := data["document"].(map[string]interface{})
-	if blocks, _ := doc["new_blocks"].([]interface{}); len(blocks) != 1 {
-		t.Fatalf("new_blocks not preserved in stdout: %#v", doc)
-	}
-}
-
-func TestDocsFetchV2HTML5BlockKeepsSmallReferenceMapInline(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-html5-fetch"))
-	registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents/doxcn_fetch/fetch", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_fetch",
-			"revision_id": float64(3),
-			"content":     `<docx><html5-block data-ref="html5_1"></html5-block></docx>`,
-			"reference_map": map[string]interface{}{
-				"html5-block": map[string]interface{}{
-					"html5_1": map[string]interface{}{"data": "<html><main>fetched</main></html>"},
-				},
-			},
-		},
-		"tips": "must_read_html_code",
-	})
-
-	err := mountAndRunDocs(t, DocsFetch, []string{
-		"+fetch",
-		"--api-version", "v2",
-		"--doc", "doxcn_fetch",
-		"--format", "json",
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	written := filepath.Join(dir, html5BlockReferenceRoot, "doxcn_fetch", "html5_1.html")
-	if _, err := os.Stat(written); err == nil {
-		t.Fatalf("small html should stay inline, got file %s", written)
-	}
-
-	var envelope map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
-		t.Fatalf("decode stdout: %v\n%s", err, stdout.String())
-	}
-	data, _ := envelope["data"].(map[string]interface{})
-	doc, _ := data["document"].(map[string]interface{})
-	if got := doc["content"].(string); !strings.Contains(got, `<html5-block data-ref="html5_1"></html5-block>`) {
-		t.Fatalf("content should keep data-ref: %s", got)
-	}
-	refMap := decodeHTML5ReferenceMap(t, doc["reference_map"])
-	if got := refMap[html5BlockTag]["html5_1"].Data; got != "<html><main>fetched</main></html>" {
-		t.Fatalf("reference_map html data = %q", got)
-	}
-	if _, ok := doc["resources"]; ok {
-		t.Fatalf("fetch output must not use resources: %#v", doc)
-	}
-	if _, ok := data["suggestions"]; ok {
-		t.Fatalf("CLI must not add suggestions; service tips is enough: %#v", data["suggestions"])
-	}
-	if got := data["tips"]; got != "must_read_html_code" {
-		t.Fatalf("tips should be preserved from service response, got %#v", got)
-	}
-}
-
-func TestDocsFetchV2HTML5BlockLargeReferenceMapUsesPath(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-
-	largeHTML := "<html><main>" + strings.Repeat("x", html5BlockReferenceMaxRaw+1) + "</main></html>"
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-html5-fetch-large"))
-	registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents/doxcn_fetch/fetch", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_fetch",
-			"revision_id": float64(3),
-			"content":     `<docx><html5-block data-ref="html5_1"></html5-block></docx>`,
-			"reference_map": map[string]interface{}{
-				"html5-block": map[string]interface{}{
-					"html5_1": map[string]interface{}{"data": largeHTML},
-				},
-			},
-		},
-	})
-
-	err := mountAndRunDocs(t, DocsFetch, []string{
-		"+fetch",
-		"--api-version", "v2",
-		"--doc", "doxcn_fetch",
-		"--format", "json",
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	written := filepath.Join(dir, html5BlockReferenceRoot, "doxcn_fetch", "html5_1.html")
-	raw, err := os.ReadFile(written)
-	if err != nil {
-		t.Fatalf("ReadFile(%s) error: %v", written, err)
-	}
-	if string(raw) != largeHTML {
-		t.Fatalf("materialized html = %q", raw)
-	}
-
-	var envelope map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
-		t.Fatalf("decode stdout: %v\n%s", err, stdout.String())
-	}
-	data, _ := envelope["data"].(map[string]interface{})
-	doc, _ := data["document"].(map[string]interface{})
-	if got := doc["content"].(string); strings.Contains(got, `path="@`) || !strings.Contains(got, `data-ref="html5_1"`) {
-		t.Fatalf("content should keep data-ref and not path: %s", got)
-	}
-	refMap := decodeHTML5ReferenceMap(t, doc["reference_map"])
-	entry := refMap[html5BlockTag]["html5_1"]
-	if entry.Data != "" || entry.Path != "@doc-fetch-resources/doxcn_fetch/html5_1.html" {
-		t.Fatalf("large html should be represented as path, got %#v", entry)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockReferenceMapAdvancedInput(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-	stub := registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_new_doc",
-			"revision_id": float64(1),
-		},
-	})
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<html5-block data-ref="html5_1"></html5-block>`,
-		"--reference-map", `{"html5-block":{"html5_1":{"data":"<html></html>"}}}`,
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	body := decodeRequestBody(t, stub.CapturedBody)
-	if got := body["content"].(string); got != `<html5-block data-ref="html5_1"></html5-block>` {
-		t.Fatalf("content = %q", got)
-	}
-	refMap := decodeHTML5ReferenceMap(t, body["reference_map"])
-	if got := refMap[html5BlockTag]["html5_1"].Data; got != "<html></html>" {
-		t.Fatalf("reference_map html data = %q", got)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockReferenceMapFromFile(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile("reference-map.json", []byte(`{"html5-block":{"html5_1":{"data":"<html>from file</html>"}}}`), 0o600); err != nil {
-		t.Fatalf("WriteFile(reference-map.json) error: %v", err)
-	}
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-	stub := registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_new_doc",
-			"revision_id": float64(1),
-		},
-	})
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<html5-block data-ref="html5_1"></html5-block>`,
-		"--reference-map", "@reference-map.json",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	body := decodeRequestBody(t, stub.CapturedBody)
-	refMap := decodeHTML5ReferenceMap(t, body["reference_map"])
-	if got := refMap[html5BlockTag]["html5_1"].Data; got != "<html>from file</html>" {
-		t.Fatalf("reference_map html data = %q", got)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockRejectsMissingReferenceMap(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<html5-block data-ref="html5_1"></html5-block>`,
-		"--as", "user",
-	})
-	if err == nil || !strings.Contains(err.Error(), `reference_map.html5-block.html5_1 is required`) {
-		t.Fatalf("expected missing reference_map error, got: %v", err)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockRejectsInternalDataAttr(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<html5-block data="PGh0bWw+PC9odG1sPg=="></html5-block>`,
-		"--as", "user",
-	})
-	if err == nil || !strings.Contains(err.Error(), `html5-block data is reserved for SDK internals`) {
-		t.Fatalf("expected internal data attr error, got: %v", err)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockPathReadFailure(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	f, stdout, _, _ := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<html5-block path="@missing.html"></html5-block>`,
-		"--as", "user",
-	})
-	if err == nil || !strings.Contains(err.Error(), `html5-block path "missing.html" cannot be read from the current working directory`) {
-		t.Fatalf("expected path read error, got: %v", err)
-	}
-}
-
-func TestDocsCreateV2HTML5BlockRejectsInlineContent(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile("widget.html", []byte("<section>from file</section>"), 0o600); err != nil {
-		t.Fatalf("WriteFile() error: %v", err)
-	}
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--content", `<html5-block path="@widget.html"><section>inline</section></html5-block>`,
-		"--as", "user",
-	})
-	if err == nil || !strings.Contains(err.Error(), `html5-block content must be loaded from path="@relative.html"`) {
-		t.Fatalf("expected inline content error, got: %v", err)
-	}
-}
-
-func TestDocsFetchV2MissingHTML5BlockReferenceFails(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsTestConfigWithAppID("docs-html5-fetch-missing"))
-	registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents/doxcn_fetch/fetch", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_fetch",
-			"revision_id": float64(3),
-			"content":     `<docx><html5-block data-ref="html5_missing"></html5-block></docx>`,
-			"reference_map": map[string]interface{}{
-				"html5-block": map[string]interface{}{
-					"html5_1": map[string]interface{}{"data": "<html></html>"},
-				},
-			},
-		},
-	})
-
-	err := mountAndRunDocs(t, DocsFetch, []string{
-		"+fetch",
-		"--api-version", "v2",
-		"--doc", "doxcn_fetch",
-		"--format", "json",
-		"--as", "user",
-	}, f, stdout)
-	if err == nil || !strings.Contains(err.Error(), "Re-run fetch or check that the upstream document.reference_map field includes this ref") {
-		t.Fatalf("expected missing reference_map error, got: %v", err)
-	}
-}
-
-func TestHTML5BlockMarkdownCodeFenceIsIgnored(t *testing.T) {
-	for _, fence := range []string{"```", "~~~"} {
-		t.Run(fence, func(t *testing.T) {
-			content := fence + "xml\n<html5-block data-ref=\"html5_1\"></html5-block>\n" + fence + "\n"
-			if hasProcessableHTML5Block("markdown", content) {
-				t.Fatalf("html5-block inside markdown code fence should be ignored")
-			}
-		})
-	}
-}
-
-func TestWriteHTML5BlockReferenceFileRejectsDotNames(t *testing.T) {
-	runtime := newFetchShortcutTestRuntime(t, "", nil)
-	tests := []struct {
-		name     string
-		docToken string
-		ref      string
-		want     string
-	}{
-		{name: "dot doc token", docToken: ".", ref: "html5_1", want: "document_id"},
-		{name: "dotdot doc token", docToken: "..", ref: "html5_1", want: "document_id"},
-		{name: "dot ref", docToken: "doxcn_fetch", ref: ".", want: "data-ref"},
-		{name: "dotdot ref", docToken: "doxcn_fetch", ref: "..", want: "data-ref"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := writeHTML5BlockReferenceFile(runtime, tt.docToken, tt.ref, "<html></html>")
-			if err == nil || !strings.Contains(err.Error(), tt.want) {
-				t.Fatalf("writeHTML5BlockReferenceFile() error = %v, want %q", err, tt.want)
-			}
-		})
-	}
-}
-
-func TestPrepareHTML5BlockWriteContentMarkdownRaw(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-	if err := os.WriteFile("widget.html", []byte("<html><body>markdown</body></html>"), 0o600); err != nil {
-		t.Fatalf("WriteFile() error: %v", err)
-	}
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, docsCreateTestConfig(t, ""))
-	stub := registerDocsAIStub(reg, "POST", "/open-apis/docs_ai/v1/documents", map[string]interface{}{
-		"document": map[string]interface{}{
-			"document_id": "doxcn_new_doc",
-			"revision_id": float64(1),
-		},
-	})
-
-	err := runDocsCreateShortcut(t, f, stdout, []string{
-		"+create",
-		"--api-version", "v2",
-		"--doc-format", "markdown",
-		"--content", "before\n<html5-block path=\"@widget.html\"></html5-block>\nafter",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	body := decodeRequestBody(t, stub.CapturedBody)
-	if got := body["content"].(string); !strings.Contains(got, `<html5-block data-ref="html5_1"></html5-block>`) {
-		t.Fatalf("content was not rewritten: %s", got)
-	}
-	refMap := decodeHTML5ReferenceMap(t, body["reference_map"])
-	if got := refMap[html5BlockTag]["html5_1"].Data; got != "<html><body>markdown</body></html>" {
-		t.Fatalf("reference_map html data = %q", got)
-	}
-}
-
-func registerDocsAIStub(reg *httpmock.Registry, method string, url string, data map[string]interface{}) *httpmock.Stub {
-	stub := &httpmock.Stub{
-		Method: method,
-		URL:    url,
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": data,
-		},
-	}
-	reg.Register(stub)
-	return stub
-}
-
-func decodeRequestBody(t *testing.T, raw []byte) map[string]interface{} {
-	t.Helper()
-	var body map[string]interface{}
-	if err := json.Unmarshal(bytes.TrimSpace(raw), &body); err != nil {
-		t.Fatalf("decode request body: %v\n%s", err, raw)
-	}
-	return body
-}
-
-func decodeHTML5ReferenceMap(t *testing.T, raw interface{}) html5BlockReferenceMap {
-	t.Helper()
-	data, err := json.Marshal(raw)
-	if err != nil {
-		t.Fatalf("marshal reference_map: %v\n%#v", err, raw)
-	}
-	var refMap html5BlockReferenceMap
-	if err := json.Unmarshal(data, &refMap); err != nil {
-		t.Fatalf("decode reference_map: %v\n%s", err, data)
-	}
-	return refMap
-}

shortcuts/doc/shortcuts.go

@@ -31,8 +31,6 @@ func docsSkillReadCommandForShortcut(shortcut string) string {
 		return docsSkillReadCommand + " references/lark-doc-fetch.md"
 	case "update":
 		return docsSkillReadCommand + " references/lark-doc-update.md"
-	case "history-list", "history-revert", "history-revert-status":
-		return docsSkillReadCommand + " references/lark-doc-history.md"
 	default:
 		return docsSkillReadCommand
 	}
@@ -46,12 +44,6 @@ func docsHelpCommandForShortcut(shortcut string) string {
 		return "lark-cli docs +fetch --help"
 	case "update":
 		return "lark-cli docs +update --help"
-	case "history-list":
-		return "lark-cli docs +history-list --help"
-	case "history-revert":
-		return "lark-cli docs +history-revert --help"
-	case "history-revert-status":
-		return "lark-cli docs +history-revert-status --help"
 	default:
 		return "lark-cli docs --help"
 	}
@@ -64,9 +56,6 @@ func Shortcuts() []common.Shortcut {
 		DocsCreate,
 		DocsFetch,
 		DocsUpdate,
-		DocsHistoryList,
-		DocsHistoryRevert,
-		DocsHistoryRevertStatus,
 		DocMediaInsert,
 		DocMediaUpload,
 		DocMediaPreview,

shortcuts/drive/drive_import_common.go

@@ -8,7 +8,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"path/filepath"
-	"strconv"
 	"strings"
 	"time"
 
@@ -29,8 +28,6 @@ const (
 	driveImport500MBFileSizeLimit int64 = 500 * 1024 * 1024
 	driveImport600MBFileSizeLimit int64 = 600 * 1024 * 1024
 	driveImport800MBFileSizeLimit int64 = 800 * 1024 * 1024
-
-	driveImportConcurrentOperationHint = "This import conflict means another operation is running in the same Drive location. Run batch imports to the same folder/root or target bitable serially. Wait a few seconds before retrying each failed import; retry each failed item at most 3 times, then stop and report the conflict."
 )
 
 // driveImportExtToDocTypes defines which source file extensions can be imported
@@ -50,8 +47,6 @@ var driveImportExtToDocTypes = map[string][]string{
 	"pptx":     {"slides"},
 }
 
-var driveImportConcurrentOperationCodes = []int{232140101, 232140100, 233523001}
-
 // driveImportSpec contains the user-facing import inputs after normalization.
 type driveImportSpec struct {
 	FilePath    string
@@ -432,7 +427,11 @@ func pollDriveImportTask(runtime *common.RuntimeContext, ticket string) (driveIm
 			return status, true, nil
 		}
 		if status.Failed() {
-			return status, false, driveImportFailureError(status)
+			msg := strings.TrimSpace(status.JobErrorMsg)
+			if msg == "" {
+				msg = status.StatusLabel()
+			}
+			return status, false, errs.NewAPIError(errs.SubtypeServerError, "import failed with status %d: %s", status.JobStatus, msg)
 		}
 	}
 	if !hadSuccessfulPoll && lastErr != nil {
@@ -441,40 +440,3 @@ func pollDriveImportTask(runtime *common.RuntimeContext, ticket string) (driveIm
 
 	return lastStatus, false, nil
 }
-
-func driveImportFailureError(status driveImportStatus) *errs.APIError {
-	msg := strings.TrimSpace(status.JobErrorMsg)
-	if msg == "" {
-		msg = status.StatusLabel()
-	}
-
-	apiErr := errs.NewAPIError(errs.SubtypeServerError, "import failed with status %d: %s", status.JobStatus, msg)
-	if code, ok := driveImportConcurrentOperationCode(msg); ok {
-		apiErr = apiErr.WithCode(code).WithRetryable().WithHint(driveImportConcurrentOperationHint)
-	}
-	return apiErr
-}
-
-func driveImportConcurrentOperationCode(msg string) (int, bool) {
-	for _, code := range driveImportConcurrentOperationCodes {
-		codeText := strconv.Itoa(code)
-		for idx := strings.Index(msg, codeText); idx >= 0; {
-			end := idx + len(codeText)
-			if (idx == 0 || !isASCIIDigit(msg[idx-1])) && (end == len(msg) || !isASCIIDigit(msg[end])) {
-				return code, true
-			}
-
-			nextStart := idx + 1
-			next := strings.Index(msg[nextStart:], codeText)
-			if next < 0 {
-				break
-			}
-			idx = nextStart + next
-		}
-	}
-	return 0, false
-}
-
-func isASCIIDigit(ch byte) bool {
-	return ch >= '0' && ch <= '9'
-}

shortcuts/drive/drive_import_common_test.go

@@ -7,7 +7,6 @@ import (
 	"bytes"
 	"errors"
 	"os"
-	"strconv"
 	"strings"
 	"testing"
 
@@ -212,82 +211,6 @@ func TestDriveImportStatusPendingWithoutToken(t *testing.T) {
 	}
 }
 
-func TestDriveImportFailureErrorAddsConcurrentOperationGuidance(t *testing.T) {
-	t.Parallel()
-
-	for _, code := range driveImportConcurrentOperationCodes {
-		t.Run(strconv.Itoa(code), func(t *testing.T) {
-			t.Parallel()
-
-			err := driveImportFailureError(driveImportStatus{
-				JobStatus:   3,
-				JobErrorMsg: "call CreateObjNode return error code, code: " + strconv.Itoa(code) + ", message:",
-			})
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("expected typed error, got %T", err)
-			}
-			if problem.Category != errs.CategoryAPI {
-				t.Fatalf("category = %q, want %q", problem.Category, errs.CategoryAPI)
-			}
-			if problem.Subtype != errs.SubtypeServerError {
-				t.Fatalf("subtype = %q, want %q", problem.Subtype, errs.SubtypeServerError)
-			}
-			if problem.Code != code {
-				t.Fatalf("code = %d, want %d", problem.Code, code)
-			}
-			if !problem.Retryable {
-				t.Fatal("expected retryable error")
-			}
-			if problem.Hint != driveImportConcurrentOperationHint {
-				t.Fatalf("hint = %q, want %q", problem.Hint, driveImportConcurrentOperationHint)
-			}
-		})
-	}
-}
-
-func TestDriveImportFailureErrorLeavesOtherFailuresUnchanged(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name string
-		msg  string
-	}{
-		{
-			name: "ordinary failure",
-			msg:  "unsupported conversion",
-		},
-		{
-			name: "longer numeric code containing known code",
-			msg:  "call CreateObjNode return error code, code: 12321401012, message:",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			err := driveImportFailureError(driveImportStatus{
-				JobStatus:   3,
-				JobErrorMsg: tt.msg,
-			})
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("expected typed error, got %T", err)
-			}
-			if problem.Code != 0 {
-				t.Fatalf("code = %d, want 0", problem.Code)
-			}
-			if problem.Retryable {
-				t.Fatal("expected non-concurrency failure to remain non-retryable")
-			}
-			if problem.Hint != "" {
-				t.Fatalf("hint = %q, want empty", problem.Hint)
-			}
-		})
-	}
-}
-
 func TestDriveImportTimeoutReturnsFollowUpCommand(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{

shortcuts/drive/drive_pull.go

@@ -37,16 +37,11 @@ const (
 )
 
 type drivePullItem struct {
-	RelPath    string `json:"rel_path"`
-	FileToken  string `json:"file_token,omitempty"`
-	SourceID   string `json:"source_id,omitempty"`
-	Action     string `json:"action"`
-	Error      string `json:"error,omitempty"`
-	Phase      string `json:"phase,omitempty"`
-	ErrorClass string `json:"error_class,omitempty"`
-	Code       int    `json:"code,omitempty"`
-	Subtype    string `json:"subtype,omitempty"`
-	Retryable  *bool  `json:"retryable,omitempty"`
+	RelPath   string `json:"rel_path"`
+	FileToken string `json:"file_token,omitempty"`
+	SourceID  string `json:"source_id,omitempty"`
+	Action    string `json:"action"`
+	Error     string `json:"error,omitempty"`
 }
 
 type drivePullTarget struct {
@@ -184,7 +179,6 @@ var DrivePull = common.Shortcut{
 
 		var downloaded, skipped, failed, deletedLocal int
 		downloadFailed := 0
-		aborted := false
 		items := make([]drivePullItem, 0)
 
 		// Deterministic iteration order for output stability.
@@ -195,9 +189,6 @@ var DrivePull = common.Shortcut{
 		sort.Strings(downloadablePaths)
 
 		for _, rel := range downloadablePaths {
-			if aborted {
-				break
-			}
 			targetFile := remoteFiles[rel]
 			downloadToken := targetFile.DownloadToken
 			itemFileToken := targetFile.ItemFileToken
@@ -213,9 +204,13 @@ var DrivePull = common.Shortcut{
 				// pre-existing file under --if-exists=skip silently
 				// hides the conflict. Surface as a failure.
 				if info.IsDir() {
-					conflictErr := errs.NewValidationError(errs.SubtypeFailedPrecondition, "local path is a directory, remote is a regular file: %s", target)
-					item, _ := drivePullFailedItem(rel, itemFileToken, itemSourceID, "failed", "local", conflictErr)
-					items = append(items, item)
+					items = append(items, drivePullItem{
+						RelPath:   rel,
+						FileToken: itemFileToken,
+						SourceID:  itemSourceID,
+						Action:    "failed",
+						Error:     fmt.Sprintf("local path is a directory, remote is a regular file: %s", target),
+					})
 					failed++
 					downloadFailed++
 					continue
@@ -228,15 +223,9 @@ var DrivePull = common.Shortcut{
 			}
 
 			if err := drivePullDownload(ctx, runtime, downloadToken, target, targetFile.ModifiedTime); err != nil {
-				item, terminal := drivePullFailedItem(rel, itemFileToken, itemSourceID, "failed", "download", err)
-				items = append(items, item)
+				items = append(items, drivePullItem{RelPath: rel, FileToken: itemFileToken, SourceID: itemSourceID, Action: "failed", Error: err.Error()})
 				failed++
 				downloadFailed++
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +pull after terminal %s failure: %v\n", item.Phase, err)
-					break
-				}
 				continue
 			}
 			items = append(items, drivePullItem{RelPath: rel, FileToken: itemFileToken, SourceID: itemSourceID, Action: "downloaded"})
@@ -262,8 +251,7 @@ var DrivePull = common.Shortcut{
 			for _, absPath := range localAbsPaths {
 				rel, relErr := filepath.Rel(safeRoot, absPath)
 				if relErr != nil {
-					item, _ := drivePullFailedItem(absPath, "", "", "delete_failed", "delete_local", relErr)
-					items = append(items, item)
+					items = append(items, drivePullItem{RelPath: absPath, Action: "delete_failed", Error: relErr.Error()})
 					failed++
 					continue
 				}
@@ -283,9 +271,7 @@ var DrivePull = common.Shortcut{
 				// acceptable here. Shortcuts cannot import internal/vfs
 				// directly (depguard rule shortcuts-no-vfs).
 				if err := os.Remove(absPath); err != nil { //nolint:forbidigo // see comment above
-					deleteErr := errs.NewInternalError(errs.SubtypeFileIO, "delete local %q: %s", rel, err).WithCause(err)
-					item, _ := drivePullFailedItem(rel, "", "", "delete_failed", "delete_local", deleteErr)
-					items = append(items, item)
+					items = append(items, drivePullItem{RelPath: rel, Action: "delete_failed", Error: err.Error()})
 					failed++
 					continue
 				}
@@ -300,7 +286,6 @@ var DrivePull = common.Shortcut{
 				"skipped":       skipped,
 				"failed":        failed,
 				"deleted_local": deletedLocal,
-				"aborted":       aborted,
 			},
 			"items": items,
 		}
@@ -332,23 +317,6 @@ var DrivePull = common.Shortcut{
 	},
 }
 
-func drivePullFailedItem(relPath, fileToken, sourceID, action, phase string, err error) (drivePullItem, bool) {
-	decision := driveClassifyBatchFailure(err)
-	item := drivePullItem{
-		RelPath:    relPath,
-		FileToken:  fileToken,
-		SourceID:   sourceID,
-		Action:     action,
-		Error:      err.Error(),
-		Phase:      phase,
-		ErrorClass: decision.Class,
-		Code:       decision.Code,
-		Subtype:    decision.Subtype,
-		Retryable:  driveBoolPtr(decision.Retryable),
-	}
-	return item, decision.Terminal
-}
-
 // drivePullDownload streams one Drive file into the local mirror target and
 // then best-effort aligns the local mtime to Drive's modified_time.
 func drivePullDownload(ctx context.Context, runtime *common.RuntimeContext, fileToken, target, remoteModifiedTime string) error {

shortcuts/drive/drive_pull_test.go

@@ -1032,66 +1032,6 @@ func TestDrivePullDownloadFailureSkipsDeleteLocalAndExitsNonZero(t *testing.T) {
 	}
 }
 
-func TestDrivePullAbortsAfterDownloadForbidden(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"files": []interface{}{
-					map[string]interface{}{"token": "tok_a", "name": "a.txt", "type": "file"},
-					map[string]interface{}{"token": "tok_b", "name": "b.txt", "type": "file"},
-				},
-				"has_more": false,
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method:  "GET",
-		URL:     "/open-apis/drive/v1/files/tok_a/download",
-		Status:  http.StatusForbidden,
-		RawBody: []byte("forbidden"),
-	})
-
-	err := mountAndRunDrive(t, DrivePull, []string{
-		"+pull",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	assertDrivePullPartialFailure(t, err)
-
-	summary, items := splitDrivePullStdout(t, stdout.Bytes())
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["rel_path"] != "a.txt" || item["phase"] != "download" || item["error_class"] != "permission_denied" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item["code"] != float64(http.StatusForbidden) || item["retryable"] != false {
-		t.Fatalf("unexpected failure classification: %#v", item)
-	}
-	if _, statErr := os.Stat(filepath.Join("local", "b.txt")); !os.IsNotExist(statErr) {
-		t.Fatalf("b.txt should not be downloaded after terminal permission failure; stat err=%v", statErr)
-	}
-}
-
 // TestDrivePullDeleteLocalDoesNotEscapeViaSymlinkParentRef is the
 // regression for the "link/.." escape applied to --delete-local — the
 // most dangerous variant, since the bug would otherwise let the kernel

shortcuts/drive/drive_push.go

@@ -29,27 +29,12 @@ const (
 )
 
 type drivePushItem struct {
-	RelPath    string `json:"rel_path"`
-	FileToken  string `json:"file_token,omitempty"`
-	Action     string `json:"action"`
-	Version    string `json:"version,omitempty"`
-	SizeBytes  int64  `json:"size_bytes,omitempty"`
-	Error      string `json:"error,omitempty"`
-	Hint       string `json:"hint,omitempty"`
-	Phase      string `json:"phase,omitempty"`
-	ErrorClass string `json:"error_class,omitempty"`
-	Code       int    `json:"code,omitempty"`
-	Subtype    string `json:"subtype,omitempty"`
-	Retryable  *bool  `json:"retryable,omitempty"`
-}
-
-type driveBatchFailureDecision struct {
-	Class     string
-	Code      int
-	Subtype   string
-	Retryable bool
-	Terminal  bool
-	Hint      string
+	RelPath   string `json:"rel_path"`
+	FileToken string `json:"file_token,omitempty"`
+	Action    string `json:"action"`
+	Version   string `json:"version,omitempty"`
+	SizeBytes int64  `json:"size_bytes,omitempty"`
+	Error     string `json:"error,omitempty"`
 }
 
 // DrivePush is a one-way, file-level mirror from a local directory onto a
@@ -242,7 +227,6 @@ var DrivePush = common.Shortcut{
 		// locally and now on Drive too), which is the worst-of-both-worlds
 		// outcome the review flagged.
 		uploadFailed := false
-		aborted := false
 
 		// folderCache holds rel_path → folder_token. Seeded from the remote
 		// listing (so we don't recreate folders that already exist) and
@@ -264,15 +248,9 @@ var DrivePush = common.Shortcut{
 				continue
 			}
 			if _, ensureErr := drivePushEnsureFolder(ctx, runtime, folderToken, relDir, folderCache); ensureErr != nil {
-				item, terminal := drivePushFailedItem(relDir, "", "failed", "create_folder", 0, ensureErr)
-				items = append(items, item)
+				items = append(items, drivePushItem{RelPath: relDir, Action: "failed", Error: ensureErr.Error()})
 				failed++
 				uploadFailed = true
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +push after terminal %s failure: %v\n", item.Phase, ensureErr)
-					break
-				}
 				continue
 			}
 			items = append(items, drivePushItem{RelPath: relDir, FileToken: folderCache[relDir], Action: "folder_created"})
@@ -288,9 +266,6 @@ var DrivePush = common.Shortcut{
 
 		for _, rel := range localPaths {
 			localFile := localFiles[rel]
-			if uploadFailed && aborted {
-				break
-			}
 
 			if entry, ok := remoteFiles[rel]; ok {
 				if drivePushShouldSkipExisting(localFile, entry, ifExists) {
@@ -300,15 +275,9 @@ var DrivePush = common.Shortcut{
 				}
 				parentToken, parentErr := drivePushEnsureParentToken(ctx, runtime, folderToken, rel, folderCache)
 				if parentErr != nil {
-					item, terminal := drivePushFailedItem(rel, entry.FileToken, "failed", "create_folder", localFile.Size, parentErr)
-					items = append(items, item)
+					items = append(items, drivePushItem{RelPath: rel, FileToken: entry.FileToken, Action: "failed", SizeBytes: localFile.Size, Error: parentErr.Error()})
 					failed++
 					uploadFailed = true
-					if terminal {
-						aborted = true
-						fmt.Fprintf(runtime.IO().ErrOut, "Aborting +push after terminal %s failure: %v\n", item.Phase, parentErr)
-						break
-					}
 					continue
 				}
 				token, version, upErr := drivePushUploadFile(ctx, runtime, localFile, entry.FileToken, parentToken)
@@ -332,15 +301,9 @@ var DrivePush = common.Shortcut{
 					if failedToken == "" {
 						failedToken = entry.FileToken
 					}
-					item, terminal := drivePushFailedItem(rel, failedToken, "failed", "upload", localFile.Size, upErr)
-					items = append(items, item)
+					items = append(items, drivePushItem{RelPath: rel, FileToken: failedToken, Action: "failed", SizeBytes: localFile.Size, Error: upErr.Error()})
 					failed++
 					uploadFailed = true
-					if terminal {
-						aborted = true
-						fmt.Fprintf(runtime.IO().ErrOut, "Aborting +push after terminal %s failure: %v\n", item.Phase, upErr)
-						break
-					}
 					continue
 				}
 				items = append(items, drivePushItem{RelPath: rel, FileToken: token, Action: "overwritten", Version: version, SizeBytes: localFile.Size})
@@ -351,28 +314,16 @@ var DrivePush = common.Shortcut{
 			parentRel := drivePushParentRel(rel)
 			parentToken, ensureErr := drivePushEnsureFolder(ctx, runtime, folderToken, parentRel, folderCache)
 			if ensureErr != nil {
-				item, terminal := drivePushFailedItem(rel, "", "failed", "create_folder", localFile.Size, ensureErr)
-				items = append(items, item)
+				items = append(items, drivePushItem{RelPath: rel, Action: "failed", SizeBytes: localFile.Size, Error: ensureErr.Error()})
 				failed++
 				uploadFailed = true
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +push after terminal %s failure: %v\n", item.Phase, ensureErr)
-					break
-				}
 				continue
 			}
 			token, _, upErr := drivePushUploadFile(ctx, runtime, localFile, "", parentToken)
 			if upErr != nil {
-				item, terminal := drivePushFailedItem(rel, "", "failed", "upload", localFile.Size, upErr)
-				items = append(items, item)
+				items = append(items, drivePushItem{RelPath: rel, Action: "failed", SizeBytes: localFile.Size, Error: upErr.Error()})
 				failed++
 				uploadFailed = true
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +push after terminal %s failure: %v\n", item.Phase, upErr)
-					break
-				}
 				continue
 			}
 			items = append(items, drivePushItem{RelPath: rel, FileToken: token, Action: "uploaded", SizeBytes: localFile.Size})
@@ -399,11 +350,7 @@ var DrivePush = common.Shortcut{
 			}
 			sort.Strings(remoteRelPaths)
 
-			abortDelete := false
 			for _, rel := range remoteRelPaths {
-				if abortDelete {
-					break
-				}
 				keepToken := ""
 				if _, ok := localFiles[rel]; ok {
 					if chosen, ok := remoteFiles[rel]; ok {
@@ -415,19 +362,8 @@ var DrivePush = common.Shortcut{
 						continue
 					}
 					if err := drivePushDeleteFile(ctx, runtime, entry.FileToken); err != nil {
-						if drivePushIsAlreadyDeleted(err) {
-							items = append(items, drivePushItem{RelPath: rel, FileToken: entry.FileToken, Action: "already_deleted"})
-							continue
-						}
-						item, terminal := drivePushFailedItem(rel, entry.FileToken, "delete_failed", "delete", 0, err)
-						items = append(items, item)
+						items = append(items, drivePushItem{RelPath: rel, FileToken: entry.FileToken, Action: "delete_failed", Error: err.Error()})
 						failed++
-						if terminal {
-							aborted = true
-							fmt.Fprintf(runtime.IO().ErrOut, "Aborting +push after terminal %s failure: %v\n", item.Phase, err)
-							abortDelete = true
-							break
-						}
 						continue
 					}
 					items = append(items, drivePushItem{RelPath: rel, FileToken: entry.FileToken, Action: "deleted_remote"})
@@ -442,7 +378,6 @@ var DrivePush = common.Shortcut{
 				"skipped":        skipped,
 				"failed":         failed,
 				"deleted_remote": deletedRemote,
-				"aborted":        aborted,
 			},
 			"items": items,
 		}
@@ -572,83 +507,6 @@ func drivePushShouldSkipSmart(localFile drivePushLocalFile, remoteFile driveRemo
 	return cmp >= 0
 }
 
-func drivePushFailedItem(relPath, fileToken, action, phase string, sizeBytes int64, err error) (drivePushItem, bool) {
-	decision := driveClassifyBatchFailure(err)
-	item := drivePushItem{
-		RelPath:    relPath,
-		FileToken:  fileToken,
-		Action:     action,
-		SizeBytes:  sizeBytes,
-		Error:      err.Error(),
-		Hint:       decision.Hint,
-		Phase:      phase,
-		ErrorClass: decision.Class,
-		Code:       decision.Code,
-		Subtype:    decision.Subtype,
-		Retryable:  driveBoolPtr(decision.Retryable),
-	}
-	return item, decision.Terminal
-}
-
-func driveBoolPtr(v bool) *bool {
-	return &v
-}
-
-func driveClassifyBatchFailure(err error) driveBatchFailureDecision {
-	decision := driveBatchFailureDecision{Class: "unknown", Retryable: errs.IsRetryable(err)}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		return decision
-	}
-	decision.Code = problem.Code
-	decision.Subtype = string(problem.Subtype)
-	decision.Retryable = problem.Retryable
-
-	switch {
-	case problem.Category == errs.CategoryAuthorization && problem.Code == 99991672:
-		decision.Class = "app_scope_missing"
-		decision.Terminal = true
-	case problem.Category == errs.CategoryAuthorization && problem.Code == 99991679:
-		decision.Class = "user_scope_missing"
-		decision.Terminal = true
-	case problem.Category == errs.CategoryAuthorization && problem.Subtype == errs.SubtypePermissionDenied:
-		decision.Class = "permission_denied"
-		decision.Terminal = true
-	case problem.Category == errs.CategoryNetwork && problem.Code == http.StatusForbidden:
-		decision.Class = "permission_denied"
-		decision.Terminal = true
-	case problem.Subtype == errs.SubtypeInvalidParameters || problem.Code == 1061002:
-		decision.Class = "invalid_api_parameters"
-		decision.Terminal = true
-	case problem.Subtype == errs.SubtypeRateLimit || problem.Code == 99991400:
-		decision.Class = "rate_limited"
-		decision.Terminal = true
-	case problem.Subtype == errs.SubtypeQuotaExceeded || problem.Code == 1061043:
-		decision.Class = "file_size_limit"
-	case problem.Code == 1062009:
-		decision.Class = "upload_size_mismatch"
-	case problem.Code == 1061044:
-		decision.Class = "parent_node_missing"
-		decision.Terminal = true
-		decision.Hint = "The destination parent folder no longer exists or is not visible. Verify --folder-token, folder permissions, and whether a parent directory was deleted during push before retrying."
-	case problem.Subtype == errs.SubtypeNotFound || problem.Code == 1061007:
-		decision.Class = "remote_not_found"
-	case problem.Subtype == errs.SubtypeServerError || problem.Code == 1061001 || problem.Code == 2200:
-		decision.Class = "server_error"
-		decision.Terminal = true
-	case problem.Subtype == errs.SubtypeFailedPrecondition:
-		decision.Class = "local_file_changed"
-	default:
-		decision.Class = string(problem.Subtype)
-	}
-	return decision
-}
-
-func drivePushIsAlreadyDeleted(err error) bool {
-	problem, ok := errs.ProblemOf(err)
-	return ok && problem.Code == 1061007
-}
-
 func drivePushRemoteViews(entries []driveRemoteEntry, duplicateRemote string) (map[string]driveRemoteEntry, map[string]driveRemoteEntry, map[string][]driveRemoteEntry, error) {
 	remoteFiles := make(map[string]driveRemoteEntry, len(entries))
 	remoteFolders := make(map[string]driveRemoteEntry, len(entries))
@@ -742,12 +600,6 @@ func drivePushEnsureParentToken(ctx context.Context, runtime *common.RuntimeCont
 // the three-step prepare/part/finish flow, which mirrors drive +upload's
 // existing multipart logic.
 func drivePushUploadFile(ctx context.Context, runtime *common.RuntimeContext, file drivePushLocalFile, existingToken, parentToken string) (string, string, error) {
-	if err := drivePushValidateUploadRequest(file, existingToken, parentToken); err != nil {
-		return "", "", err
-	}
-	if err := drivePushVerifyLocalSnapshot(runtime, file); err != nil {
-		return "", "", err
-	}
 	if file.Size > common.MaxDriveMediaUploadSinglePartSize {
 		token, err := drivePushUploadMultipart(ctx, runtime, file, existingToken, parentToken)
 		// Multipart finish does not return version on the existing
@@ -760,44 +612,6 @@ func drivePushUploadFile(ctx context.Context, runtime *common.RuntimeContext, fi
 	return drivePushUploadAll(ctx, runtime, file, existingToken, parentToken)
 }
 
-func drivePushValidateUploadRequest(file drivePushLocalFile, existingToken, parentToken string) error {
-	if strings.TrimSpace(file.FileName) == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "cannot upload %q: file name is empty", file.RelPath)
-	}
-	if file.Size < 0 {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "cannot upload %q: file size is negative", file.RelPath)
-	}
-	if strings.TrimSpace(parentToken) == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "cannot upload %q: parent folder token is empty", file.RelPath)
-	}
-	if err := validate.ResourceName(parentToken, "parent_node"); err != nil {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "cannot upload %q: %s", file.RelPath, err)
-	}
-	if existingToken != "" {
-		if err := validate.ResourceName(existingToken, "file_token"); err != nil {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "cannot overwrite %q: %s", file.RelPath, err)
-		}
-	}
-	return nil
-}
-
-func drivePushVerifyLocalSnapshot(runtime *common.RuntimeContext, file drivePushLocalFile) error {
-	info, err := runtime.FileIO().Stat(file.OpenPath)
-	if err != nil {
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "local file changed during push: %s is no longer readable: %v", file.RelPath, err).WithCause(err)
-	}
-	if !info.Mode().IsRegular() {
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "local file changed during push: %s is no longer a regular file", file.RelPath)
-	}
-	if info.Size() != file.Size {
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "local file changed during push: %s snapshot size no longer matches", file.RelPath)
-	}
-	if modTimer, ok := info.(interface{ ModTime() time.Time }); ok && !modTimer.ModTime().Equal(file.ModTime) {
-		return errs.NewValidationError(errs.SubtypeFailedPrecondition, "local file changed during push: %s snapshot modtime no longer matches", file.RelPath)
-	}
-	return nil
-}
-
 func drivePushUploadAll(_ context.Context, runtime *common.RuntimeContext, file drivePushLocalFile, existingToken, parentToken string) (string, string, error) {
 	f, err := runtime.FileIO().Open(file.OpenPath)
 	if err != nil {

shortcuts/drive/drive_push_test.go

@@ -5,10 +5,8 @@ package drive
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"io"
-	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
@@ -16,14 +14,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/extension/fileio"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/shortcuts/common"
-	"github.com/spf13/cobra"
 )
 
 // countingOpenProvider wraps a fileio.Provider and counts FileIO.Open
@@ -656,141 +652,6 @@ func TestDrivePushDeleteRemoteSkipsOnlineDocs(t *testing.T) {
 	}
 }
 
-func TestDrivePushDeleteRemoteAbortsAfterTerminalFailure(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"files": []interface{}{
-					map[string]interface{}{"token": "tok_a", "name": "a.txt", "type": "file"},
-					map[string]interface{}{"token": "tok_b", "name": "b.txt", "type": "file"},
-				},
-				"has_more": false,
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "DELETE",
-		URL:    "/open-apis/drive/v1/files/tok_a",
-		Body: map[string]interface{}{
-			"code": 1061004,
-			"msg":  "forbidden",
-		},
-	})
-	// No DELETE stub for tok_b: terminal delete failure must stop before it.
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--delete-remote",
-		"--yes",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) || pfErr.Code != output.ExitAPI {
-		t.Fatalf("expected ExitAPI *output.PartialFailureError, got %T %v", err, err)
-	}
-
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if got := summary["deleted_remote"]; got != float64(0) {
-		t.Fatalf("summary.deleted_remote = %v, want 0", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["action"] != "delete_failed" || item["phase"] != "delete" || item["error_class"] != "permission_denied" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item["code"] != float64(1061004) || item["retryable"] != false {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	for _, item := range items {
-		if item["file_token"] == "tok_b" {
-			t.Fatalf("terminal delete failure must abort before tok_b, got items=%#v", items)
-		}
-	}
-}
-
-func TestDrivePushDeleteRemoteTreatsAlreadyDeletedAsNoop(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"files": []interface{}{
-					map[string]interface{}{"token": "tok_orphan", "name": "orphan.txt", "type": "file"},
-				},
-				"has_more": false,
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "DELETE",
-		URL:    "/open-apis/drive/v1/files/tok_orphan",
-		Body: map[string]interface{}{
-			"code": 1061007,
-			"msg":  "file has been delete.",
-		},
-	})
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--delete-remote",
-		"--yes",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("already-deleted remote should be an idempotent success, got: %v\nstdout: %s", err, stdout.String())
-	}
-
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(0) {
-		t.Fatalf("summary.failed = %v, want 0", got)
-	}
-	if got := summary["deleted_remote"]; got != float64(0) {
-		t.Fatalf("summary.deleted_remote = %v, want 0 because CLI did not delete it in this run", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["action"] != "already_deleted" || item["file_token"] != "tok_orphan" {
-		t.Fatalf("unexpected already-deleted item: %#v", item)
-	}
-}
-
 func TestDrivePushNewestOverwritesChosenDuplicateAndDeletesSibling(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 
@@ -1025,22 +886,21 @@ func TestDrivePushOverwriteWithoutVersionFails(t *testing.T) {
 		t.Errorf("expected ExitAPI (%d), got code=%d", output.ExitAPI, pfErr.Code)
 	}
 
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Errorf("summary.failed = %v, want 1", got)
+	out := stdout.String()
+	// summary.failed should reflect the missing version; summary.uploaded
+	// should not pretend the overwrite succeeded.
+	if !strings.Contains(out, `"failed": 1`) {
+		t.Errorf("expected failed=1, got: %s", out)
 	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	if got, _ := items[0]["error"].(string); !strings.Contains(got, "no version") {
-		t.Errorf("items[0].error = %q, want missing-version message", got)
+	if !strings.Contains(out, "no version") {
+		t.Errorf("expected error about missing version in items[].error, got: %s", out)
 	}
 	// Pin the token-stability contract: the failed item must surface the
 	// token returned by upload_all (tok_keep_new), NOT the fallback
 	// entry.FileToken (tok_keep). Without this, a regression that always
 	// uses entry.FileToken on failure would slip through.
-	if got := items[0]["file_token"]; got != "tok_keep_new" {
-		t.Errorf("items[0].file_token = %v, want tok_keep_new", got)
+	if !strings.Contains(out, `"file_token": "tok_keep_new"`) {
+		t.Errorf("expected failed item to surface upload_all's returned file_token (tok_keep_new), got: %s", out)
 	}
 }
 
@@ -1102,385 +962,24 @@ func TestDrivePushOverwritePartialSuccessSurfacesReturnedToken(t *testing.T) {
 		t.Fatalf("expected ExitAPI from *output.PartialFailureError, got %T %v", err, err)
 	}
 
+	out := stdout.String()
 	// Partial failure reports an ok:false result envelope on stdout (not a
 	// misleading ok:true) while still carrying BOTH the succeeded and failed
 	// items — consistent with the pre-change payload. The failed side is
 	// asserted via "failed": 1 and the succeeded side via tok_keep_partial.
-	envelope := decodeDrivePushStdout(t, stdout.Bytes())
-	if envelope.OK {
-		t.Fatalf("partial failure must emit ok=false; stdout=%s", stdout.String())
+	if !strings.Contains(out, `"ok": false`) {
+		t.Errorf("partial failure must emit an ok:false result envelope, got: %s", out)
 	}
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Errorf("summary.failed = %v, want 1", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
+	if !strings.Contains(out, `"failed": 1`) {
+		t.Errorf("expected failed=1, got: %s", out)
 	}
 	// The freshly returned token must be the one in items[].file_token,
 	// not the stale entry.FileToken (tok_keep_old).
-	if got := items[0]["file_token"]; got != "tok_keep_partial" {
-		t.Errorf("items[0].file_token = %v, want tok_keep_partial", got)
+	if !strings.Contains(out, `"file_token": "tok_keep_partial"`) {
+		t.Errorf("expected items[].file_token to surface upload_all's returned token (tok_keep_partial), got: %s", out)
 	}
-	if got := items[0]["file_token"]; got == "tok_keep_old" {
-		t.Errorf("must NOT fall back to entry.FileToken when upload_all returned a token; item=%#v", items[0])
-	}
-}
-
-func TestDrivePushAbortsAfterUploadParamsError(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join("local", "a.txt"), []byte("A"), 0o644); err != nil {
-		t.Fatalf("WriteFile a: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join("local", "b.txt"), []byte("B"), 0o644); err != nil {
-		t.Fatalf("WriteFile b: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"files": []interface{}{}, "has_more": false},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/files/upload_all",
-		Body: map[string]interface{}{
-			"code": 1061002,
-			"msg":  "params error.",
-		},
-	})
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["rel_path"] != "a.txt" || item["phase"] != "upload" || item["error_class"] != "invalid_api_parameters" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item["code"] != float64(1061002) || item["subtype"] != "invalid_parameters" || item["retryable"] != false {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	for _, item := range items {
-		if item["rel_path"] == "b.txt" {
-			t.Fatalf("terminal upload params error must abort before b.txt, got items=%#v", items)
-		}
-	}
-}
-
-func TestDrivePushAbortsAfterUploadParentNodeMissing(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join("local", "a.txt"), []byte("A"), 0o644); err != nil {
-		t.Fatalf("WriteFile a: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join("local", "b.txt"), []byte("B"), 0o644); err != nil {
-		t.Fatalf("WriteFile b: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"files": []interface{}{}, "has_more": false},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/files/upload_all",
-		Body: map[string]interface{}{
-			"code": 1061044,
-			"msg":  "parent node not exist.",
-		},
-	})
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["rel_path"] != "a.txt" || item["phase"] != "upload" || item["error_class"] != "parent_node_missing" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item["code"] != float64(1061044) || item["subtype"] != "not_found" || item["retryable"] != false {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	if got, _ := item["hint"].(string); !strings.Contains(got, "--folder-token") || !strings.Contains(got, "parent") {
-		t.Fatalf("hint should point at the destination parent folder, got item=%#v", item)
-	}
-	for _, item := range items {
-		if item["rel_path"] == "b.txt" {
-			t.Fatalf("parent-node missing must abort before b.txt, got items=%#v", items)
-		}
-	}
-}
-
-func TestDrivePushAbortsAfterCreateFolderMissingScope(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll(filepath.Join("local", "a"), 0o755); err != nil {
-		t.Fatalf("MkdirAll a: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Join("local", "b"), 0o755); err != nil {
-		t.Fatalf("MkdirAll b: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"files": []interface{}{}, "has_more": false},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/files/create_folder",
-		Body: map[string]interface{}{
-			"code": 99991672,
-			"msg":  "Access denied. One of the following scopes is required: [drive:drive, space:folder:create].",
-		},
-	})
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["rel_path"] != "a" || item["phase"] != "create_folder" || item["error_class"] != "app_scope_missing" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item["code"] != float64(99991672) || item["retryable"] != false {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	for _, item := range items {
-		if item["rel_path"] == "b" {
-			t.Fatalf("missing folder-create scope must abort before b, got items=%#v", items)
-		}
-	}
-}
-
-func TestDrivePushDetectsLocalFileChangedBeforeUpload(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-	localPath := filepath.Join("local", "changing.txt")
-	if err := os.WriteFile(localPath, []byte("before"), 0o644); err != nil {
-		t.Fatalf("WriteFile: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		OnMatch: func(req *http.Request) {
-			if err := os.WriteFile(localPath, []byte("after-change"), 0o644); err != nil {
-				t.Fatalf("mutate local file: %v", err)
-			}
-		},
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"files": []interface{}{}, "has_more": false},
-		},
-	})
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if got := summary["aborted"]; got != false {
-		t.Fatalf("summary.aborted = %v, want false", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["error_class"] != "local_file_changed" || item["subtype"] != "failed_precondition" || item["retryable"] != false {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	if got, _ := item["error"].(string); !strings.Contains(got, "local file changed during push") {
-		t.Fatalf("items[0].error = %q, want local-change message", got)
-	}
-	if strings.Contains(stdout.String(), "httpmock: no stub") {
-		t.Fatalf("upload_all was called after local snapshot changed:\n%s", stdout.String())
-	}
-
-	problemErr := drivePushVerifyLocalSnapshot(common.TestNewRuntimeContext(&cobra.Command{Use: "drive +push"}, &core.CliConfig{}), drivePushLocalFile{
-		RelPath:  "missing.txt",
-		OpenPath: filepath.Join("local", "missing.txt"),
-		FileName: "missing.txt",
-		Size:     1,
-		ModTime:  time.Now(),
-	})
-	problem, ok := errs.ProblemOf(problemErr)
-	if !ok {
-		t.Fatalf("ProblemOf(snapshot error) ok=false, err=%T %v", problemErr, problemErr)
-	}
-	if problem.Subtype != errs.SubtypeFailedPrecondition {
-		t.Fatalf("snapshot error subtype = %q, want %q", problem.Subtype, errs.SubtypeFailedPrecondition)
-	}
-	if problem.Category != errs.CategoryValidation {
-		t.Fatalf("snapshot error category = %q, want %q", problem.Category, errs.CategoryValidation)
-	}
-	if errors.Unwrap(problemErr) == nil {
-		t.Fatalf("snapshot error cause was not preserved")
-	}
-}
-
-func TestDrivePushDetectsSameSizeLocalFileChangedBeforeUpload(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-	localPath := filepath.Join("local", "changing.txt")
-	if err := os.WriteFile(localPath, []byte("before"), 0o644); err != nil {
-		t.Fatalf("WriteFile: %v", err)
-	}
-	originalModTime := time.Unix(100, 0)
-	changedModTime := time.Unix(200, 0)
-	if err := os.Chtimes(localPath, originalModTime, originalModTime); err != nil {
-		t.Fatalf("Chtimes original: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		OnMatch: func(req *http.Request) {
-			if err := os.WriteFile(localPath, []byte("AFTER!"), 0o644); err != nil {
-				t.Fatalf("mutate local file: %v", err)
-			}
-			if err := os.Chtimes(localPath, changedModTime, changedModTime); err != nil {
-				t.Fatalf("Chtimes changed: %v", err)
-			}
-		},
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"files": []interface{}{}, "has_more": false},
-		},
-	})
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["rel_path"] != "changing.txt" || item["error_class"] != "local_file_changed" || item["subtype"] != "failed_precondition" {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	if got, _ := item["error"].(string); !strings.Contains(got, "snapshot modtime no longer matches") {
-		t.Fatalf("items[0].error = %q, want modtime mismatch", got)
-	}
-	if strings.Contains(stdout.String(), "httpmock: no stub") {
-		t.Fatalf("upload_all was called after local snapshot changed:\n%s", stdout.String())
+	if strings.Contains(out, `"file_token": "tok_keep_old"`) {
+		t.Errorf("must NOT fall back to entry.FileToken when upload_all returned a token; got: %s", out)
 	}
 }
 
@@ -1614,32 +1113,6 @@ func TestDrivePushExitsZeroOnCleanRun(t *testing.T) {
 	}
 }
 
-type drivePushStdoutEnvelope struct {
-	OK   bool `json:"ok"`
-	Data struct {
-		Summary map[string]interface{}   `json:"summary"`
-		Items   []map[string]interface{} `json:"items"`
-	} `json:"data"`
-}
-
-func decodeDrivePushStdout(t *testing.T, stdout []byte) drivePushStdoutEnvelope {
-	t.Helper()
-	var envelope drivePushStdoutEnvelope
-	if err := json.Unmarshal(stdout, &envelope); err != nil {
-		t.Fatalf("unmarshal stdout: %v\nraw=%s", err, string(stdout))
-	}
-	return envelope
-}
-
-func splitDrivePushStdout(t *testing.T, stdout []byte) (map[string]interface{}, []map[string]interface{}) {
-	t.Helper()
-	envelope := decodeDrivePushStdout(t, stdout)
-	if envelope.Data.Summary == nil {
-		t.Fatalf("stdout missing data.summary; raw=%s", string(stdout))
-	}
-	return envelope.Data.Summary, envelope.Data.Items
-}
-
 // TestDrivePushUploadsSiblingWhenRemoteSameNameIsNativeDoc pins the
 // behavior when a local regular file shares its rel_path with a Lark
 // native cloud document on Drive (sheet/docx/bitable/...).

shortcuts/drive/drive_search.go

@@ -72,10 +72,10 @@ var DriveSearch = common.Shortcut{
 	Description: "Search Lark docs, Wiki, and spreadsheet files with flat filters (Search v2: doc_wiki/search)",
 	Risk:        "read",
 	Scopes:      []string{"search:docs:read"},
-	AuthTypes:   []string{"user", "bot"},
+	AuthTypes:   []string{"user"},
 	HasFormat:   true,
 	Flags: []common.Flag{
-		{Name: "query", Desc: "search keyword (may be empty to browse by filter only); max 30 characters by Unicode code point (CJK counts 1 each), over 30 the server rejects with 99992402 field validation failed"},
+		{Name: "query", Desc: "search keyword (may be empty to browse by filter only)"},
 
 		{Name: "mine", Type: "bool", Desc: "restrict to docs I own (server-side owner semantic, NOT original creator; uses current user's open_id)"},
 		{Name: "creator-ids", Desc: "comma-separated owner open_ids (API field is creator_ids but matched by owner); mutually exclusive with --mine"},

shortcuts/drive/drive_secure_label.go

@@ -6,7 +6,6 @@ package drive
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/validate"
@@ -18,13 +17,6 @@ const (
 	secureLabelUpdateScope = "docs:secure_label:write_only"
 )
 
-type secureLabelOperation string
-
-const (
-	secureLabelOperationList   secureLabelOperation = "list"
-	secureLabelOperationUpdate secureLabelOperation = "update"
-)
-
 var secureLabelTypes = permApplyTypes
 
 // DriveSecureLabelList lists secure labels available to the current user.
@@ -36,9 +28,6 @@ var DriveSecureLabelList = common.Shortcut{
 	Scopes:      []string{secureLabelReadScope},
 	AuthTypes:   []string{"user"},
 	HasFormat:   true,
-	Tips: []string{
-		"Use the `id` field from this command as --label-id for +secure-label-update; do not use the display name.",
-	},
 	Flags: []common.Flag{
 		{Name: "page-size", Type: "int", Default: "10", Desc: "page size, 1-10"},
 		{Name: "page-token", Desc: "pagination token from previous response"},
@@ -64,7 +53,7 @@ var DriveSecureLabelList = common.Shortcut{
 			nil,
 		)
 		if err != nil {
-			return decorateSecureLabelError(err, secureLabelOperationList)
+			return err
 		}
 		runtime.OutFormat(data, nil, nil)
 		return nil
@@ -79,21 +68,13 @@ var DriveSecureLabelUpdate = common.Shortcut{
 	Risk:        "write",
 	Scopes:      []string{secureLabelUpdateScope},
 	AuthTypes:   []string{"user"},
-	Tips: []string{
-		"Pass the numeric label id returned by +secure-label-list; display names like Public(D) are rejected.",
-		"Downgrading a secure label may require approval; retrying the same request will not bypass approval.",
-		"When updating many files, serialize requests and back off on rate_limit errors.",
-	},
 	Flags: []common.Flag{
 		{Name: "token", Desc: "target file token or document URL (docx/sheets/base/file/wiki/doc/mindnote/slides)", Required: true},
 		{Name: "type", Desc: "target type; auto-inferred from URL when omitted", Enum: secureLabelTypes},
 		{Name: "label-id", Desc: "secure label ID to set", Required: true},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if _, _, err := resolveSecureLabelTarget(runtime.Str("token"), runtime.Str("type")); err != nil {
-			return err
-		}
-		_, err := normalizeSecureLabelID(runtime.Str("label-id"))
+		_, _, err := resolveSecureLabelTarget(runtime.Str("token"), runtime.Str("type"))
 		return err
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
@@ -101,15 +82,11 @@ var DriveSecureLabelUpdate = common.Shortcut{
 		if err != nil {
 			return common.NewDryRunAPI().Set("error", err.Error())
 		}
-		labelID, err := normalizeSecureLabelID(runtime.Str("label-id"))
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
 		return common.NewDryRunAPI().
 			Desc("Update Drive secure label").
 			PATCH("/open-apis/drive/v2/files/:file_token/secure_label").
 			Params(map[string]interface{}{"type": docType}).
-			Body(map[string]interface{}{"id": labelID}).
+			Body(map[string]interface{}{"id": runtime.Str("label-id")}).
 			Set("file_token", token)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -117,18 +94,14 @@ var DriveSecureLabelUpdate = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		labelID, err := normalizeSecureLabelID(runtime.Str("label-id"))
-		if err != nil {
-			return err
-		}
-		body := map[string]interface{}{"id": labelID}
+		body := map[string]interface{}{"id": runtime.Str("label-id")}
 		data, err := runtime.CallAPITyped("PATCH",
 			fmt.Sprintf("/open-apis/drive/v2/files/%s/secure_label", validate.EncodePathSegment(token)),
 			map[string]interface{}{"type": docType},
 			body,
 		)
 		if err != nil {
-			return decorateSecureLabelError(err, secureLabelOperationUpdate)
+			return err
 		}
 		runtime.Out(data, nil)
 		return nil
@@ -149,70 +122,3 @@ func buildSecureLabelListParams(runtime *common.RuntimeContext) map[string]inter
 func resolveSecureLabelTarget(raw, explicitType string) (token, docType string, err error) {
 	return resolvePermApplyTarget(raw, explicitType)
 }
-
-// normalizeSecureLabelID trims a label id and rejects display names before the
-// request reaches Drive, where they otherwise surface as opaque JSON errors.
-func normalizeSecureLabelID(raw string) (string, error) {
-	labelID := strings.TrimSpace(raw)
-	if labelID == "" {
-		return "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--label-id is required").
-			WithParam("--label-id")
-	}
-	for _, r := range labelID {
-		if r < '0' || r > '9' {
-			return "", errs.NewValidationError(errs.SubtypeInvalidArgument, "--label-id must be a numeric secure label ID, not a display name: %q", raw).
-				WithParam("--label-id").
-				WithHint("run `lark-cli drive +secure-label-list` and pass the numeric `id` value; do not pass label names like `Public(D)`")
-		}
-	}
-	return labelID, nil
-}
-
-// decorateSecureLabelError appends command-aware recovery guidance while
-// preserving upstream/classifier hints already attached to the typed error.
-func decorateSecureLabelError(err error, operation secureLabelOperation) error {
-	if err == nil {
-		return nil
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		return err
-	}
-	guidance := secureLabelErrorGuidance(p.Code, operation)
-	if guidance == "" {
-		return err
-	}
-	if p.Hint == "" {
-		p.Hint = guidance
-	} else if !strings.Contains(p.Hint, guidance) {
-		p.Hint = p.Hint + "; " + guidance
-	}
-	return err
-}
-
-// secureLabelErrorGuidance returns recovery guidance for secure-label API
-// failures whose generic code-level classification needs command context.
-func secureLabelErrorGuidance(code int, operation secureLabelOperation) string {
-	switch code {
-	case 99991400:
-		if operation == secureLabelOperationUpdate {
-			return "secure label updates are rate limited; retry later with exponential backoff and serialize bulk updates"
-		}
-		return "secure label listing is rate limited; retry later with exponential backoff"
-	case 1063013:
-		if operation == secureLabelOperationUpdate {
-			return "secure label downgrade requires approval; request approval or choose a non-downgrade label before retrying"
-		}
-	case 1063002:
-		if operation == secureLabelOperationUpdate {
-			return "the current user lacks permission to update this file's secure label; use a user with file and security-label permission"
-		}
-		return "the current user lacks permission to list secure labels; use a user with security-label read permission"
-	case 1063001, 99992402, 9499:
-		if operation == secureLabelOperationUpdate {
-			return "check --token/--type and pass a secure label ID from `lark-cli drive +secure-label-list`, not the display name"
-		}
-		return "check secure label list parameters such as --page-size, --page-token, and --lang"
-	}
-	return ""
-}

shortcuts/drive/drive_secure_label_test.go

@@ -5,11 +5,9 @@ package drive
 
 import (
 	"encoding/json"
-	"errors"
 	"strings"
 	"testing"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/httpmock"
 )
@@ -92,54 +90,13 @@ func TestDriveSecureLabelList_ExecuteSuccess(t *testing.T) {
 	}
 }
 
-func TestDriveSecureLabelList_RateLimitPreservesUpstreamHint(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v2/my_secure_labels?page_size=10",
-		Status: 429,
-		Body: map[string]interface{}{
-			"code": 99991400,
-			"msg":  "rate limit exceeded",
-			"error": map[string]interface{}{
-				"details": []interface{}{
-					map[string]interface{}{"value": "server says slow down"},
-				},
-			},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveSecureLabelList, []string{
-		"+secure-label-list",
-		"--as", "user",
-	}, f, nil)
-	if err == nil {
-		t.Fatal("expected rate limit error")
-	}
-	var apiErr *errs.APIError
-	if !errors.As(err, &apiErr) {
-		t.Fatalf("expected APIError, got %T: %v", err, err)
-	}
-	if apiErr.Subtype != errs.SubtypeRateLimit || apiErr.Code != 99991400 || !apiErr.Retryable {
-		t.Fatalf("problem = %+v, want code=99991400 subtype=rate_limit retryable=true", apiErr.Problem)
-	}
-	for _, want := range []string{"server says slow down", "secure label listing is rate limited"} {
-		if !strings.Contains(apiErr.Hint, want) {
-			t.Fatalf("hint missing %q: %q", want, apiErr.Hint)
-		}
-	}
-	if strings.Contains(apiErr.Hint, "updates are rate limited") {
-		t.Fatalf("list hint should not use update-specific wording: %q", apiErr.Hint)
-	}
-}
-
 func TestDriveSecureLabelUpdate_DryRunInfersTypeFromURL(t *testing.T) {
 	t.Parallel()
 	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
 	err := mountAndRunDrive(t, DriveSecureLabelUpdate, []string{
 		"+secure-label-update",
 		"--token", "https://example.feishu.cn/docx/doxTok123?from=share",
-		"--label-id", " 7217780879644737539 ",
+		"--label-id", "7217780879644737539",
 		"--dry-run", "--as", "user",
 	}, f, stdout)
 	if err != nil {
@@ -175,7 +132,7 @@ func TestDriveSecureLabelUpdate_ExecuteSuccess(t *testing.T) {
 		"+secure-label-update",
 		"--token", "doxTok123",
 		"--type", "docx",
-		"--label-id", " 7217780879644737539 ",
+		"--label-id", "7217780879644737539",
 		"--as", "user",
 	}, f, stdout)
 	if err != nil {
@@ -191,32 +148,7 @@ func TestDriveSecureLabelUpdate_ExecuteSuccess(t *testing.T) {
 	}
 }
 
-func TestDriveSecureLabelUpdate_RejectsDisplayNameAsLabelID(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
-	err := mountAndRunDrive(t, DriveSecureLabelUpdate, []string{
-		"+secure-label-update",
-		"--token", "doxTok123",
-		"--type", "docx",
-		"--label-id", "Public(D)",
-		"--as", "user",
-	}, f, stdout)
-	if err == nil {
-		t.Fatal("expected label id validation error")
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("expected ValidationError, got %T: %v", err, err)
-	}
-	if validationErr.Param != "--label-id" {
-		t.Fatalf("Param = %q, want --label-id", validationErr.Param)
-	}
-	if !strings.Contains(validationErr.Hint, "+secure-label-list") {
-		t.Fatalf("hint missing list guidance: %q", validationErr.Hint)
-	}
-}
-
-func TestDriveSecureLabelUpdate_DowngradeApprovalReturnsFailedPrecondition(t *testing.T) {
+func TestDriveSecureLabelUpdate_DowngradeApprovalReturnsAPIError(t *testing.T) {
 	f, _, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
 		Method: "PATCH",
@@ -237,78 +169,7 @@ func TestDriveSecureLabelUpdate_DowngradeApprovalReturnsFailedPrecondition(t *te
 	if err == nil {
 		t.Fatal("expected 1063013 error")
 	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("expected ValidationError, got %T: %v", err, err)
-	}
-	if validationErr.Subtype != errs.SubtypeFailedPrecondition || validationErr.Code != 1063013 {
-		t.Fatalf("problem = %+v, want code=1063013 subtype=failed_precondition", validationErr.Problem)
-	}
-	if !strings.Contains(validationErr.Hint, "approval") {
-		t.Fatalf("hint missing approval guidance: %q", validationErr.Hint)
-	}
-}
-
-func TestDriveSecureLabelUpdate_InvalidJSONTypeGetsLabelHint(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH",
-		URL:    "/open-apis/drive/v2/files/doxTok123/secure_label",
-		Status: 400,
-		Body: map[string]interface{}{
-			"code": 9499, "msg": "Invalid parameter type in json: id",
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveSecureLabelUpdate, []string{
-		"+secure-label-update",
-		"--token", "https://example.feishu.cn/docx/doxTok123",
-		"--label-id", "7217780879644737539",
-		"--as", "user",
-	}, f, nil)
-	if err == nil {
-		t.Fatal("expected 9499 error")
-	}
-	var apiErr *errs.APIError
-	if !errors.As(err, &apiErr) {
-		t.Fatalf("expected APIError, got %T: %v", err, err)
-	}
-	if apiErr.Subtype != errs.SubtypeInvalidParameters || apiErr.Code != 9499 {
-		t.Fatalf("problem = %+v, want code=9499 subtype=invalid_parameters", apiErr.Problem)
-	}
-	if !strings.Contains(apiErr.Hint, "+secure-label-list") {
-		t.Fatalf("hint missing secure label list guidance: %q", apiErr.Hint)
-	}
-}
-
-func TestDriveSecureLabelUpdate_RateLimitIsRetryableWithBackoffHint(t *testing.T) {
-	f, _, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH",
-		URL:    "/open-apis/drive/v2/files/doxTok123/secure_label",
-		Status: 429,
-		Body: map[string]interface{}{
-			"code": 99991400, "msg": "rate limit exceeded",
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveSecureLabelUpdate, []string{
-		"+secure-label-update",
-		"--token", "https://example.feishu.cn/docx/doxTok123",
-		"--label-id", "7217780879644737539",
-		"--as", "user",
-	}, f, nil)
-	if err == nil {
-		t.Fatal("expected rate limit error")
-	}
-	var apiErr *errs.APIError
-	if !errors.As(err, &apiErr) {
-		t.Fatalf("expected APIError, got %T: %v", err, err)
-	}
-	if apiErr.Subtype != errs.SubtypeRateLimit || apiErr.Code != 99991400 || !apiErr.Retryable {
-		t.Fatalf("problem = %+v, want code=99991400 subtype=rate_limit retryable=true", apiErr.Problem)
-	}
-	if !strings.Contains(apiErr.Hint, "backoff") {
-		t.Fatalf("hint missing backoff guidance: %q", apiErr.Hint)
+	if !strings.Contains(err.Error(), "Security label downgrade requires approval") {
+		t.Fatalf("expected raw API error message, got: %v", err)
 	}
 }

shortcuts/drive/drive_sync.go

@@ -25,21 +25,12 @@ const (
 	driveSyncOnConflictAsk        = "ask"
 )
 
-func driveSyncActionScopes() []string {
-	return []string{"drive:file:download", "drive:file:upload", "space:folder:create"}
-}
-
 type driveSyncItem struct {
-	RelPath    string `json:"rel_path"`
-	FileToken  string `json:"file_token,omitempty"`
-	Action     string `json:"action"`
-	Direction  string `json:"direction,omitempty"` // "pull" or "push"
-	Error      string `json:"error,omitempty"`
-	Phase      string `json:"phase,omitempty"`
-	ErrorClass string `json:"error_class,omitempty"`
-	Code       int    `json:"code,omitempty"`
-	Subtype    string `json:"subtype,omitempty"`
-	Retryable  *bool  `json:"retryable,omitempty"`
+	RelPath   string `json:"rel_path"`
+	FileToken string `json:"file_token,omitempty"`
+	Action    string `json:"action"`
+	Direction string `json:"direction,omitempty"` // "pull" or "push"
+	Error     string `json:"error,omitempty"`
 }
 
 // DriveSync performs a two-way sync between a local directory and a Drive
@@ -75,7 +66,6 @@ var DriveSync = common.Shortcut{
 		"Default --on-conflict=remote-wins pulls the remote version when both sides changed a file. Use local-wins to push instead, keep-both to rename and keep both copies, or ask for interactive resolution.",
 		"Pass --quick for faster best-effort diff detection using modified_time instead of SHA-256 hash (no remote file downloads needed during diffing).",
 		"Because +sync acts on the diff, --quick can still pull, overwrite, or rename files when timestamps differ even if file contents are actually unchanged.",
-		"Actual sync execution pre-flights download, upload, and folder-create scopes before listing or walking, so missing grants fail before any partial sync can start.",
 		"Only entries with type=file are synced; online docs (docx, sheet, bitable, mindnote, slides) and shortcuts are skipped.",
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
@@ -120,8 +110,10 @@ var DriveSync = common.Shortcut{
 			duplicateRemote = driveDuplicateRemoteFail
 		}
 		quick := runtime.Bool("quick")
-		if err := runtime.EnsureScopes(driveSyncActionScopes()); err != nil {
-			return err
+		if !quick {
+			if err := runtime.EnsureScopes([]string{"drive:file:download"}); err != nil {
+				return err
+			}
 		}
 
 		safeRoot, err := validate.SafeInputPath(localDir)
@@ -268,9 +260,20 @@ var DriveSync = common.Shortcut{
 
 		// --- Phase 2: Execute sync operations ---
 		var pulled, pushed, skipped, failed int
-		aborted := false
 		items := make([]driveSyncItem, 0)
 
+		if quick && driveSyncNeedsDownloadScope(newRemote, modified, conflictResolutions) {
+			if err := runtime.EnsureScopes([]string{"drive:file:download"}); err != nil {
+				return err
+			}
+		}
+		plannedUploads := driveSyncPlannedUploadPaths(newLocal, modified, conflictResolutions)
+		if len(plannedUploads) > 0 {
+			if err := runtime.EnsureScopes([]string{"drive:file:upload"}); err != nil {
+				return err
+			}
+		}
+
 		// Build push infrastructure: local walk for push + remote views + folder cache.
 		folderCache := map[string]string{"": folderToken}
 		for relDir, entry := range remoteFolders {
@@ -284,24 +287,21 @@ var DriveSync = common.Shortcut{
 			return err
 		}
 
+		if driveSyncNeedsCreateScope(plannedUploads, localDirs, folderCache) {
+			if err := runtime.EnsureScopes([]string{"space:folder:create"}); err != nil {
+				return err
+			}
+		}
+
 		// Mirror local directory structure first (same as +push), so
 		// empty local directories are not silently dropped.
 		for _, relDir := range localDirs {
-			if aborted {
-				break
-			}
 			if _, alreadyRemote := folderCache[relDir]; alreadyRemote {
 				continue
 			}
 			if _, ensureErr := drivePushEnsureFolder(ctx, runtime, folderToken, relDir, folderCache); ensureErr != nil {
-				item, terminal := driveSyncFailedItem(relDir, "", "failed", "push", "create_folder", ensureErr)
-				items = append(items, item)
+				items = append(items, driveSyncItem{RelPath: relDir, Action: "failed", Direction: "push", Error: ensureErr.Error()})
 				failed++
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, ensureErr)
-					break
-				}
 				continue
 			}
 			items = append(items, driveSyncItem{RelPath: relDir, FileToken: folderCache[relDir], Action: "folder_created", Direction: "push"})
@@ -310,9 +310,6 @@ var DriveSync = common.Shortcut{
 
 		// 2a. Pull new_remote files.
 		for _, entry := range newRemote {
-			if aborted {
-				break
-			}
 			targetFile, ok := pullRemoteFiles[entry.RelPath]
 			if !ok {
 				// Non-file type (doc, shortcut, etc.) — skip.
@@ -320,14 +317,8 @@ var DriveSync = common.Shortcut{
 			}
 			target := filepath.Join(rootRelToCwd, entry.RelPath)
 			if err := drivePullDownload(ctx, runtime, targetFile.DownloadToken, target, targetFile.ModifiedTime); err != nil {
-				item, terminal := driveSyncFailedItem(entry.RelPath, entry.FileToken, "failed", "pull", "download", err)
-				items = append(items, item)
+				items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: entry.FileToken, Action: "failed", Direction: "pull", Error: err.Error()})
 				failed++
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, err)
-					break
-				}
 				continue
 			}
 			items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: entry.FileToken, Action: "downloaded", Direction: "pull"})
@@ -336,9 +327,6 @@ var DriveSync = common.Shortcut{
 
 		// 2b. Push new_local files.
 		for _, entry := range newLocal {
-			if aborted {
-				break
-			}
 			localFile, ok := pushLocalFiles[entry.RelPath]
 			if !ok {
 				items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "skipped", Direction: "push", Error: "local file disappeared during sync"})
@@ -348,26 +336,14 @@ var DriveSync = common.Shortcut{
 			parentRel := drivePushParentRel(entry.RelPath)
 			parentToken, ensureErr := drivePushEnsureFolder(ctx, runtime, folderToken, parentRel, folderCache)
 			if ensureErr != nil {
-				item, terminal := driveSyncFailedItem(entry.RelPath, "", "failed", "push", "create_folder", ensureErr)
-				items = append(items, item)
+				items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "failed", Direction: "push", Error: ensureErr.Error()})
 				failed++
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, ensureErr)
-					break
-				}
 				continue
 			}
 			token, _, upErr := drivePushUploadFile(ctx, runtime, localFile, "", parentToken)
 			if upErr != nil {
-				item, terminal := driveSyncFailedItem(entry.RelPath, token, "failed", "push", "upload", upErr)
-				items = append(items, item)
+				items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "failed", Direction: "push", Error: upErr.Error()})
 				failed++
-				if terminal {
-					aborted = true
-					fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, upErr)
-					break
-				}
 				continue
 			}
 			items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: token, Action: "uploaded", Direction: "push"})
@@ -376,9 +352,6 @@ var DriveSync = common.Shortcut{
 
 		// 2c. Resolve modified files by --on-conflict strategy.
 		for _, entry := range modified {
-			if aborted {
-				break
-			}
 			remoteFile := remoteFiles[entry.RelPath]
 			localFile, hasLocal := pushLocalFiles[entry.RelPath]
 			if !hasLocal {
@@ -406,14 +379,8 @@ var DriveSync = common.Shortcut{
 				}
 				target := filepath.Join(rootRelToCwd, entry.RelPath)
 				if err := drivePullDownload(ctx, runtime, targetFile.DownloadToken, target, targetFile.ModifiedTime); err != nil {
-					item, terminal := driveSyncFailedItem(entry.RelPath, entry.FileToken, "failed", "pull", "download", err)
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: entry.FileToken, Action: "failed", Direction: "pull", Error: err.Error()})
 					failed++
-					if terminal {
-						aborted = true
-						fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, err)
-						break
-					}
 					continue
 				}
 				items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: entry.FileToken, Action: "downloaded", Direction: "pull"})
@@ -429,14 +396,8 @@ var DriveSync = common.Shortcut{
 				}
 				parentToken, parentErr := drivePushEnsureFolder(ctx, runtime, folderToken, drivePushParentRel(entry.RelPath), folderCache)
 				if parentErr != nil {
-					item, terminal := driveSyncFailedItem(entry.RelPath, existingToken, "failed", "push", "create_folder", parentErr)
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: existingToken, Action: "failed", Direction: "push", Error: parentErr.Error()})
 					failed++
-					if terminal {
-						aborted = true
-						fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, parentErr)
-						break
-					}
 					continue
 				}
 				token, _, upErr := drivePushUploadFile(ctx, runtime, localFile, existingToken, parentToken)
@@ -450,14 +411,8 @@ var DriveSync = common.Shortcut{
 					if failedToken == "" {
 						failedToken = existingToken
 					}
-					item, terminal := driveSyncFailedItem(entry.RelPath, failedToken, "failed", "push", "upload", upErr)
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: failedToken, Action: "failed", Direction: "push", Error: upErr.Error()})
 					failed++
-					if terminal {
-						aborted = true
-						fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, upErr)
-						break
-					}
 					continue
 				}
 				items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: token, Action: "overwritten", Direction: "push"})
@@ -478,8 +433,7 @@ var DriveSync = common.Shortcut{
 				}
 				suffixedRel, err := relPathWithUniqueFileTokenSuffix(entry.RelPath, remoteFile.FileToken, occupied)
 				if err != nil {
-					item, _ := driveSyncFailedItem(entry.RelPath, "", "failed", "conflict", "conflict", err)
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "failed", Direction: "conflict", Error: err.Error()})
 					failed++
 					continue
 				}
@@ -487,9 +441,7 @@ var DriveSync = common.Shortcut{
 				oldAbsPath := filepath.Join(safeRoot, filepath.FromSlash(entry.RelPath))
 				newAbsPath := filepath.Join(safeRoot, filepath.FromSlash(suffixedRel))
 				if err := os.Rename(oldAbsPath, newAbsPath); err != nil { //nolint:forbidigo // shortcuts cannot import internal/vfs (depguard rule shortcuts-no-vfs); safeRoot is validated.
-					renameErr := errs.NewInternalError(errs.SubtypeFileIO, "rename local: %s", err).WithCause(err)
-					item, _ := driveSyncFailedItem(entry.RelPath, "", "failed", "conflict", "conflict", renameErr)
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "failed", Direction: "conflict", Error: fmt.Sprintf("rename local: %s", err)})
 					failed++
 					continue
 				}
@@ -502,31 +454,19 @@ var DriveSync = common.Shortcut{
 					if rollbackErr != nil {
 						errMsg += "; rollback failed: " + rollbackErr.Error()
 					}
-					notFoundErr := errs.NewAPIError(errs.SubtypeNotFound, "%s", errMsg)
-					item, _ := driveSyncFailedItem(entry.RelPath, "", "failed", "pull", "download", notFoundErr)
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "failed", Direction: "pull", Error: errMsg})
 					failed++
 					continue
 				}
 				target := filepath.Join(rootRelToCwd, entry.RelPath)
 				if err := drivePullDownload(ctx, runtime, targetFile.DownloadToken, target, targetFile.ModifiedTime); err != nil {
-					downloadErr := err
 					rollbackErr := driveSyncRollbackRenamedLocal(oldAbsPath, newAbsPath)
 					errMsg := err.Error()
 					if rollbackErr != nil {
 						errMsg += "; rollback failed: " + rollbackErr.Error()
 					}
-					item, terminal := driveSyncFailedItem(entry.RelPath, entry.FileToken, "failed", "pull", "download", downloadErr)
-					if rollbackErr != nil {
-						item.Error = errMsg
-					}
-					items = append(items, item)
+					items = append(items, driveSyncItem{RelPath: entry.RelPath, FileToken: entry.FileToken, Action: "failed", Direction: "pull", Error: errMsg})
 					failed++
-					if terminal {
-						aborted = true
-						fmt.Fprintf(runtime.IO().ErrOut, "Aborting +sync after terminal %s failure: %v\n", item.Phase, downloadErr)
-						break
-					}
 					continue
 				}
 				items = append(items, driveSyncItem{RelPath: entry.RelPath, Action: "renamed_local", Direction: "conflict"})
@@ -552,7 +492,6 @@ var DriveSync = common.Shortcut{
 				"pushed":  pushed,
 				"skipped": skipped,
 				"failed":  failed,
-				"aborted": aborted,
 			},
 			"items": items,
 		}
@@ -581,23 +520,6 @@ func driveSyncStatusRemoteFiles(pullRemoteFiles map[string]drivePullTarget) map[
 	return remoteFiles
 }
 
-func driveSyncFailedItem(relPath, fileToken, action, direction, phase string, err error) (driveSyncItem, bool) {
-	decision := driveClassifyBatchFailure(err)
-	item := driveSyncItem{
-		RelPath:    relPath,
-		FileToken:  fileToken,
-		Action:     action,
-		Direction:  direction,
-		Error:      err.Error(),
-		Phase:      phase,
-		ErrorClass: decision.Class,
-		Code:       decision.Code,
-		Subtype:    decision.Subtype,
-		Retryable:  driveBoolPtr(decision.Retryable),
-	}
-	return item, decision.Terminal
-}
-
 // driveSyncAskConflict prompts the user for a conflict resolution strategy
 // for a single file. Returns the strategy string, or empty string if the
 // user chose to skip.
@@ -636,6 +558,51 @@ func driveSyncAskConflict(relPath string, runtime *common.RuntimeContext) (strin
 	}
 }
 
+func driveSyncNeedsDownloadScope(newRemote, modified []driveStatusEntry, conflictResolutions map[string]string) bool {
+	if len(newRemote) > 0 {
+		return true
+	}
+	for _, entry := range modified {
+		switch conflictResolutions[entry.RelPath] {
+		case driveSyncOnConflictRemoteWins, driveSyncOnConflictKeepBoth:
+			return true
+		}
+	}
+	return false
+}
+
+func driveSyncPlannedUploadPaths(newLocal, modified []driveStatusEntry, conflictResolutions map[string]string) []string {
+	planned := make([]string, 0, len(newLocal)+len(modified))
+	for _, entry := range newLocal {
+		planned = append(planned, entry.RelPath)
+	}
+	for _, entry := range modified {
+		if conflictResolutions[entry.RelPath] == driveSyncOnConflictLocalWins {
+			planned = append(planned, entry.RelPath)
+		}
+	}
+	return planned
+}
+
+func driveSyncNeedsCreateScope(uploadPaths []string, localDirs []string, folderCache map[string]string) bool {
+	for _, relPath := range uploadPaths {
+		parentRel := drivePushParentRel(relPath)
+		if parentRel == "" {
+			continue
+		}
+		if _, ok := folderCache[parentRel]; !ok {
+			return true
+		}
+	}
+	// Empty local directories also need create_folder if not already on Drive.
+	for _, relDir := range localDirs {
+		if _, ok := folderCache[relDir]; !ok {
+			return true
+		}
+	}
+	return false
+}
+
 func driveSyncRollbackRenamedLocal(oldAbsPath, newAbsPath string) error {
 	if info, err := os.Stat(oldAbsPath); err == nil { //nolint:forbidigo // shortcuts cannot import internal/vfs (depguard rule shortcuts-no-vfs); safeRoot is validated.
 		if info.IsDir() {

shortcuts/drive/drive_sync_test.go

@@ -311,71 +311,6 @@ func TestDriveSyncRemoteWinsPullsNewRemoteAndPushesNewLocal(t *testing.T) {
 	}
 }
 
-func TestDriveSyncAbortsAfterNewRemoteDownloadForbidden(t *testing.T) {
-	syncTestConfig := &core.CliConfig{
-		AppID: "drive-sync-forbidden", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	}
-	f, stdout, _, reg := cmdutil.TestFactory(t, syncTestConfig)
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll("local", 0o755); err != nil {
-		t.Fatalf("MkdirAll: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{
-				"files": []interface{}{
-					map[string]interface{}{"token": "tok_a", "name": "a.txt", "type": "file", "modified_time": "100"},
-					map[string]interface{}{"token": "tok_b", "name": "b.txt", "type": "file", "modified_time": "100"},
-				},
-				"has_more": false,
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method:  "GET",
-		URL:     "/open-apis/drive/v1/files/tok_a/download",
-		Status:  http.StatusForbidden,
-		RawBody: []byte("forbidden"),
-	})
-
-	err := mountAndRunDrive(t, DriveSync, []string{
-		"+sync",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--quick",
-		"--as", "bot",
-	}, f, stdout)
-	assertDriveSyncPartialFailure(t, err)
-
-	summary := driveSyncStdoutSummary(t, stdout.Bytes())
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	items := driveSyncStdoutItems(t, stdout.Bytes())
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item.RelPath != "a.txt" || item.Direction != "pull" || item.Phase != "download" || item.ErrorClass != "permission_denied" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item.Code != http.StatusForbidden || item.Retryable == nil || *item.Retryable {
-		t.Fatalf("unexpected failure classification: %#v", item)
-	}
-	if _, statErr := os.Stat(filepath.Join("local", "b.txt")); !os.IsNotExist(statErr) {
-		t.Fatalf("b.txt should not be downloaded after terminal permission failure; stat err=%v", statErr)
-	}
-}
-
 // TestDriveSyncLocalWinsPushesOverRemote verifies that --on-conflict=local-wins
 // pushes the local version over the remote file.
 func TestDriveSyncLocalWinsPushesOverRemote(t *testing.T) {
@@ -1617,11 +1552,11 @@ func TestDriveSyncDryRunQuickAcceptsMetadataOnlyScope(t *testing.T) {
 	}
 }
 
-func TestDriveSyncPreflightsActionScopesBeforeListing(t *testing.T) {
+func TestDriveSyncExactRemoteWinsAcceptsDownloadOnlyScope(t *testing.T) {
 	syncTestConfig := &core.CliConfig{
 		AppID: "drive-sync-download-scope-only", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	}
-	f, stdout, _, _ := cmdutil.TestFactory(t, syncTestConfig)
+	f, stdout, _, reg := cmdutil.TestFactory(t, syncTestConfig)
 	f.Credential = credential.NewCredentialProvider(nil, nil, &driveStatusScopedTokenResolver{scopes: "drive:drive.metadata:readonly drive:file:download"}, nil)
 
 	tmpDir := t.TempDir()
@@ -1633,6 +1568,34 @@ func TestDriveSyncPreflightsActionScopesBeforeListing(t *testing.T) {
 		t.Fatalf("WriteFile a.txt: %v", err)
 	}
 
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "folder_token=folder_root",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"files": []interface{}{
+					map[string]interface{}{"token": "tok_a", "name": "a.txt", "type": "file"},
+				},
+				"has_more": false,
+			},
+		},
+	})
+	reg.Register(&httpmock.Stub{
+		Method:  "GET",
+		URL:     "/open-apis/drive/v1/files/tok_a/download",
+		Status:  200,
+		Body:    []byte("remote-a"),
+		Headers: http.Header{"Content-Type": []string{"application/octet-stream"}},
+	})
+	reg.Register(&httpmock.Stub{
+		Method:  "GET",
+		URL:     "/open-apis/drive/v1/files/tok_a/download",
+		Status:  200,
+		Body:    []byte("remote-a"),
+		Headers: http.Header{"Content-Type": []string{"application/octet-stream"}},
+	})
+
 	err := mountAndRunDrive(t, DriveSync, []string{
 		"+sync",
 		"--local-dir", "local",
@@ -1640,30 +1603,11 @@ func TestDriveSyncPreflightsActionScopesBeforeListing(t *testing.T) {
 		"--on-conflict", "remote-wins",
 		"--as", "bot",
 	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected action-scope preflight to reject download-only scope\nstdout: %s", stdout.String())
+	if err != nil {
+		t.Fatalf("expected exact remote-wins to succeed with download-only scope, got: %v\nstdout: %s", err, stdout.String())
 	}
-	var permErr *errs.PermissionError
-	if !errors.As(err, &permErr) {
-		t.Fatalf("expected *errs.PermissionError, got %T: %v", err, err)
-	}
-	if permErr.Subtype != errs.SubtypeMissingScope {
-		t.Fatalf("Subtype = %q, want %q", permErr.Subtype, errs.SubtypeMissingScope)
-	}
-	for _, scope := range []string{"drive:file:upload", "space:folder:create"} {
-		found := false
-		for _, missing := range permErr.MissingScopes {
-			if missing == scope {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Fatalf("MissingScopes = %v, want %s", permErr.MissingScopes, scope)
-		}
-	}
-	if strings.Contains(stdout.String(), "folder_root") {
-		t.Fatalf("preflight should fail before remote listing, got stdout: %s", stdout.String())
+	if strings.Contains(strings.ToLower(stdout.String()), "missing_scope") {
+		t.Fatalf("should not surface missing_scope, got: %s", stdout.String())
 	}
 }
 
@@ -2608,6 +2552,30 @@ func TestDriveSyncAskConflictRemoteShortForms(t *testing.T) {
 	}
 }
 
+// TestDriveSyncNeedsDownloadScopeReturnsFalseForLocalWinsOnly verifies
+// that driveSyncNeedsDownloadScope returns false when there are no
+// new_remote entries and all modified entries resolve to local-wins.
+func TestDriveSyncNeedsDownloadScopeReturnsFalseForLocalWinsOnly(t *testing.T) {
+	modified := []driveStatusEntry{{RelPath: "a.txt"}, {RelPath: "b.txt"}}
+	resolutions := map[string]string{"a.txt": driveSyncOnConflictLocalWins, "b.txt": driveSyncOnConflictLocalWins}
+
+	if driveSyncNeedsDownloadScope(nil, modified, resolutions) {
+		t.Fatal("expected false when no new_remote and all conflicts are local-wins")
+	}
+}
+
+// TestDriveSyncNeedsDownloadScopeReturnsTrueForKeepBoth verifies that
+// driveSyncNeedsDownloadScope returns true when a modified entry resolves
+// to keep-both (which requires pulling the remote version).
+func TestDriveSyncNeedsDownloadScopeReturnsTrueForKeepBoth(t *testing.T) {
+	modified := []driveStatusEntry{{RelPath: "a.txt"}}
+	resolutions := map[string]string{"a.txt": driveSyncOnConflictKeepBoth}
+
+	if !driveSyncNeedsDownloadScope(nil, modified, resolutions) {
+		t.Fatal("expected true when a conflict resolves to keep-both")
+	}
+}
+
 // TestDriveSyncRemoteWinsReportsMissingPullView verifies that when a
 // modified file's rel_path is not in pullRemoteFiles during the
 // remote-wins branch, a failed item is reported instead of a panic.
@@ -3115,19 +3083,3 @@ func driveSyncStdoutItems(t *testing.T, stdout []byte) []driveSyncItem {
 	}
 	return envelope.Data.Items
 }
-
-func driveSyncStdoutSummary(t *testing.T, stdout []byte) map[string]interface{} {
-	t.Helper()
-	var envelope struct {
-		Data struct {
-			Summary map[string]interface{} `json:"summary"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(stdout, &envelope); err != nil {
-		t.Fatalf("unmarshal stdout: %v\nraw=%s", err, string(stdout))
-	}
-	if envelope.Data.Summary == nil {
-		t.Fatalf("stdout missing data.summary; raw=%s", string(stdout))
-	}
-	return envelope.Data.Summary
-}

shortcuts/drive/shortcuts_test.go

@@ -3,10 +3,7 @@
 
 package drive
 
-import (
-	"reflect"
-	"testing"
-)
+import "testing"
 
 // TestShortcutsIncludesExpectedCommands verifies the drive shortcut registry contains the expected commands.
 func TestShortcutsIncludesExpectedCommands(t *testing.T) {
@@ -61,12 +58,3 @@ func TestShortcutsIncludesExpectedCommands(t *testing.T) {
 		}
 	}
 }
-
-func TestDriveSearchSupportsUserAndBotIdentity(t *testing.T) {
-	t.Parallel()
-
-	want := []string{"user", "bot"}
-	if !reflect.DeepEqual(DriveSearch.AuthTypes, want) {
-		t.Fatalf("DriveSearch.AuthTypes = %v, want %v", DriveSearch.AuthTypes, want)
-	}
-}

shortcuts/im/helpers_test.go

@@ -651,7 +651,6 @@ func TestShortcuts(t *testing.T) {
 	want := []string{
 		"+chat-create",
 		"+chat-list",
-		"+chat-members-list",
 		"+chat-messages-list",
 		"+chat-search",
 		"+chat-update",

shortcuts/im/im_chat_members_list.go

@@ -1,420 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package im
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const (
-	imChatMembersListPathFmt       = "/open-apis/im/v1/chats/%s/members/list"
-	chatMembersListDefaultPageSize = 20
-	chatMembersListMaxPageSize     = 100
-	// chatMembersListDefaultPageDelay throttles --page-all the same way the
-	// generic paginateLoop does (200ms). It matters for tenants WITHOUT the
-	// server-side member cap, where a large group drains many pages back to
-	// back and could otherwise trip rate limits.
-	chatMembersListDefaultPageDelay = 200
-)
-
-// ImChatMembersList is the +chat-members-list shortcut: it lists chat members,
-// returning users and bots in separate buckets (users[]/bots[]). It owns its
-// pagination loop (mirroring the generic paginateLoop conventions: a per-page
-// log line, a --page-limit cap, a non-advancing-token guard) precisely because
-// the response is multi-bucket — the generic --page-all merger is built for
-// single-array responses and would drop the bots[] bucket and the final-page
-// truncations[] signal. See mergeChatMemberPages for the merge semantics.
-var ImChatMembersList = common.Shortcut{
-	Service:     "im",
-	Command:     "+chat-members-list",
-	Description: "List members of a chat; returns separate users[] / bots[] buckets; callable as user or bot; --member-types filters which kinds to return; --page-all pagination; surfaces truncations[] when the server caps a bucket",
-	Risk:        "read",
-	// Declare the narrowest scope the API accepts so tokens carrying only
-	// im:chat.members:read are honored (same rationale as +chat-list).
-	Scopes:    []string{"im:chat.members:read"},
-	AuthTypes: []string{"user", "bot"},
-	Flags: []common.Flag{
-		{Name: "chat-id", Required: true, Desc: "chat ID (oc_xxx)"},
-		{Name: "member-types", Type: "string_slice", Desc: "member types to return (user, bot); omit = all"},
-		{Name: "member-id-type", Default: "open_id", Desc: "ID type for member_id in response", Enum: []string{"open_id", "union_id", "user_id"}},
-		{Name: "page-size", Type: "int", Default: fmt.Sprintf("%d", chatMembersListDefaultPageSize), Desc: fmt.Sprintf("page size, 1-%d", chatMembersListMaxPageSize)},
-		{Name: "page-token", Desc: "page token; implies single-page fetch (no auto-pagination)"},
-		{Name: "page-all", Type: "bool", Desc: "automatically paginate through all pages (capped by --page-limit)"},
-		{Name: "page-limit", Type: "int", Default: "10", Desc: "max pages to fetch with --page-all (default 10, 0 = unlimited)"},
-		{Name: "page-delay", Type: "int", Default: fmt.Sprintf("%d", chatMembersListDefaultPageDelay), Desc: "delay in ms between pages when --page-all (0 = no delay)"},
-	},
-	Tips: []string{
-		"Default fetches a single page; pass --page-all to walk every page.",
-		"With --page-all and no explicit --page-size, the max page size is used to minimize round-trips.",
-		"truncations[] in the result means the server capped a bucket due to security config — the member list is incomplete.",
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		chatID := strings.TrimSpace(runtime.Str("chat-id"))
-		if chatID == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--chat-id is required (oc_xxx)").WithParam("--chat-id")
-		}
-		if !strings.HasPrefix(chatID, "oc_") {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --chat-id %q: must be an open_chat_id starting with oc_", chatID).WithParam("--chat-id")
-		}
-		if n := runtime.Int("page-size"); n < 1 || n > chatMembersListMaxPageSize {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--page-size must be an integer between 1 and %d", chatMembersListMaxPageSize).WithParam("--page-size")
-		}
-		if n := runtime.Int("page-limit"); n < 0 {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--page-limit must be a non-negative integer").WithParam("--page-limit")
-		}
-		if n := runtime.Int("page-delay"); n < 0 {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--page-delay must be a non-negative integer").WithParam("--page-delay")
-		}
-		_, err := normalizeMemberTypes(runtime.StrSlice("member-types"))
-		return err
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		chatID := strings.TrimSpace(runtime.Str("chat-id"))
-		dry := common.NewDryRunAPI()
-		if chatMembersShouldAutoPaginate(runtime) {
-			dry.Desc("Auto-paginates through all pages (capped by --page-limit when > 0)")
-		}
-		params, _ := buildChatMembersParams(runtime, strings.TrimSpace(runtime.Str("page-token")))
-		return dry.
-			GET(fmt.Sprintf(imChatMembersListPathFmt, validate.EncodePathSegment(chatID))).
-			Params(params)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		warnIfConflictingPagingFlags(runtime)
-
-		chatID := strings.TrimSpace(runtime.Str("chat-id"))
-		res, err := fetchChatMembers(ctx, runtime, chatID)
-		if err != nil {
-			return err
-		}
-
-		// The truncation signal is the whole reason this is a dedicated shortcut:
-		// surface it loudly so an agent never mistakes a capped list for a
-		// complete one.
-		if len(res.truncations) > 0 {
-			writeChatMembersTruncationWarning(runtime.IO().ErrOut, res.truncations)
-		}
-		fmt.Fprintf(runtime.IO().ErrOut, "Found %d user(s) and %d bot(s)\n", len(res.users), len(res.bots))
-
-		outData := map[string]interface{}{
-			"chat_id":     chatID,
-			"users":       res.users,
-			"bots":        res.bots,
-			"truncations": res.truncations,
-			"has_more":    res.hasMore,
-			"page_token":  res.pageToken,
-		}
-		if res.userTotal != nil {
-			outData["user_total"] = res.userTotal
-		}
-		if res.botTotal != nil {
-			outData["bot_total"] = res.botTotal
-		}
-
-		runtime.OutFormat(outData, &output.Meta{Count: len(res.users) + len(res.bots)}, func(w io.Writer) {
-			renderChatMembersPretty(w, chatID, res)
-		})
-		return nil
-	},
-}
-
-// chatMembersResult is the aggregated view across one or more pages.
-type chatMembersResult struct {
-	users       []interface{}
-	bots        []interface{}
-	truncations []interface{}
-	userTotal   interface{}
-	botTotal    interface{}
-	hasMore     bool
-	pageToken   string
-}
-
-// effectiveChatMembersPageSize resolves the page_size to request. When draining
-// every page (--page-all) and the caller did NOT explicitly set --page-size, it
-// uses the maximum so a full walk takes the fewest round-trips. An explicit
-// --page-size is always honored; without --page-all the smaller default is kept
-// as a sensible single-page preview size.
-func effectiveChatMembersPageSize(runtime *common.RuntimeContext) int {
-	if chatMembersShouldAutoPaginate(runtime) && !runtime.Changed("page-size") {
-		return chatMembersListMaxPageSize
-	}
-	if n := runtime.Int("page-size"); n > 0 {
-		return n
-	}
-	return chatMembersListDefaultPageSize
-}
-
-// chatMembersShouldAutoPaginate reports whether the fetch loop should walk
-// every page. An explicit --page-token disables the auto loop because the
-// caller supplied a specific cursor (single-page fetch).
-func chatMembersShouldAutoPaginate(runtime *common.RuntimeContext) bool {
-	if strings.TrimSpace(runtime.Str("page-token")) != "" {
-		return false
-	}
-	return runtime.Bool("page-all")
-}
-
-// buildChatMembersParams builds the query params for one page request. The
-// startToken (when non-empty) seeds the page_token; the loop overrides it per
-// page. Returns the params and the normalized member-types CSV (already
-// validated by Validate, so the error is only a defensive guard).
-func buildChatMembersParams(runtime *common.RuntimeContext, startToken string) (map[string]interface{}, error) {
-	memberTypes, err := normalizeMemberTypes(runtime.StrSlice("member-types"))
-	if err != nil {
-		return nil, err
-	}
-	params := map[string]interface{}{
-		"member_id_type": runtime.Str("member-id-type"),
-		"page_size":      effectiveChatMembersPageSize(runtime),
-	}
-	if memberTypes != "" {
-		params["member_types"] = memberTypes
-	}
-	if startToken != "" {
-		params["page_token"] = startToken
-	}
-	return params, nil
-}
-
-// fetchChatMembers walks the list_members endpoint, honoring the four
-// pagination flags the same way the generic --page-all path does. It merges
-// each page into the aggregate as it arrives (rather than buffering every raw
-// page), so peak memory is just the aggregated members plus the single most
-// recent page — important for large groups under --page-limit 0.
-func fetchChatMembers(ctx context.Context, runtime *common.RuntimeContext, chatID string) (*chatMembersResult, error) {
-	auto := chatMembersShouldAutoPaginate(runtime)
-	pageLimit := runtime.Int("page-limit")
-	pageDelay := runtime.Int("page-delay")
-	apiPath := fmt.Sprintf(imChatMembersListPathFmt, validate.EncodePathSegment(chatID))
-
-	params, err := buildChatMembersParams(runtime, strings.TrimSpace(runtime.Str("page-token")))
-	if err != nil {
-		return nil, err
-	}
-
-	res := newChatMembersResult()
-	var lastData map[string]interface{}
-	pageToken := strings.TrimSpace(runtime.Str("page-token"))
-	for page := 0; ; page++ {
-		if pageToken != "" {
-			params["page_token"] = pageToken
-		}
-		fmt.Fprintf(runtime.IO().ErrOut, "[page %d] fetching...\n", page+1)
-		data, err := runtime.CallAPITyped("GET", apiPath, params, nil)
-		if err != nil {
-			return nil, err
-		}
-		addMemberBuckets(res, data)
-		lastData = data
-
-		hasMore, nextToken := common.PaginationMeta(data)
-		if !auto {
-			break
-		}
-		if !hasMore || nextToken == "" {
-			break
-		}
-		if nextToken == pageToken {
-			// Guard against a buggy server echoing the same cursor with
-			// has_more=true: without --page-limit we would loop forever.
-			fmt.Fprintln(runtime.IO().ErrOut, "Stopping pagination: server returned a non-advancing page_token.")
-			break
-		}
-		if pageLimit > 0 && page+1 >= pageLimit {
-			fmt.Fprintf(runtime.IO().ErrOut, "[pagination] reached page limit (%d), stopping. Use --page-all --page-limit 0 to fetch all pages.\n", pageLimit)
-			break
-		}
-		pageToken = nextToken
-		// Throttle between pages (only reached when another page follows), so
-		// draining a large untruncated list doesn't hammer the API.
-		if pageDelay > 0 {
-			time.Sleep(time.Duration(pageDelay) * time.Millisecond)
-		}
-	}
-	if lastData != nil {
-		applyLastPageSignals(res, lastData)
-	}
-	return res, nil
-}
-
-// newChatMembersResult returns an empty aggregate with non-nil buckets so the
-// JSON output always carries arrays (never null).
-func newChatMembersResult() *chatMembersResult {
-	return &chatMembersResult{
-		users:       []interface{}{},
-		bots:        []interface{}{},
-		truncations: []interface{}{},
-	}
-}
-
-// addMemberBuckets appends one page's users[] and bots[] into the aggregate.
-// Concatenating every bucket is what avoids dropping bots[] — the bug the
-// generic single-array --page-all merger would hit on this multi-bucket shape.
-func addMemberBuckets(res *chatMembersResult, data map[string]interface{}) {
-	if u, ok := data["users"].([]interface{}); ok {
-		res.users = append(res.users, u...)
-	}
-	if b, ok := data["bots"].([]interface{}); ok {
-		res.bots = append(res.bots, b...)
-	}
-}
-
-// applyLastPageSignals copies the per-request signals from the FINAL page:
-// has_more / page_token / truncations / totals. These must come from the last
-// page, not page 1: truncations[] is emitted only on the final page (empty
-// earlier), so reading it sooner would hide a server-side cap; user_total /
-// bot_total are server-wide counts, and taking the final page's value keeps a
-// single, consistent source rather than a possibly-stale earlier count.
-func applyLastPageSignals(res *chatMembersResult, data map[string]interface{}) {
-	res.hasMore, res.pageToken = common.PaginationMeta(data)
-	if t, ok := data["truncations"].([]interface{}); ok {
-		res.truncations = t
-	}
-	res.userTotal = data["user_total"]
-	res.botTotal = data["bot_total"]
-}
-
-// mergeChatMemberPages folds a slice of page payloads into one aggregate. It is
-// the same logic fetchChatMembers applies incrementally, kept as a pure
-// function so the multi-bucket merge + last-page-signal semantics are unit
-// tested in one place.
-func mergeChatMemberPages(pages []map[string]interface{}) *chatMembersResult {
-	res := newChatMembersResult()
-	if len(pages) == 0 {
-		return res
-	}
-	for _, data := range pages {
-		addMemberBuckets(res, data)
-	}
-	applyLastPageSignals(res, pages[len(pages)-1])
-	return res
-}
-
-// normalizeMemberTypes validates the --member-types slice (already CSV-split by
-// cobra) into a lowercased, deduped CSV string. Empty input is a no-op (return
-// the API's default of all types). Any element outside {user, bot} is rejected.
-func normalizeMemberTypes(raw []string) (string, error) {
-	if len(raw) == 0 {
-		return "", nil
-	}
-	seen := make(map[string]struct{}, len(raw))
-	out := make([]string, 0, len(raw))
-	for _, p := range raw {
-		p = strings.TrimSpace(strings.ToLower(p))
-		if p != "user" && p != "bot" {
-			return "", errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --member-types value %q: expected one of user, bot", p).WithParam("--member-types")
-		}
-		if _, dup := seen[p]; dup {
-			continue
-		}
-		seen[p] = struct{}{}
-		out = append(out, p)
-	}
-	return strings.Join(out, ","), nil
-}
-
-// warnIfConflictingPagingFlags mirrors the wiki list shortcuts: --page-token
-// wins (single-page fetch from the supplied cursor) and --page-all is ignored.
-func warnIfConflictingPagingFlags(runtime *common.RuntimeContext) {
-	if strings.TrimSpace(runtime.Str("page-token")) != "" && runtime.Bool("page-all") {
-		fmt.Fprintln(runtime.IO().ErrOut,
-			"warning: --page-token is set, so --page-all is ignored (single-page fetch from the supplied cursor)")
-	}
-}
-
-// writeChatMembersTruncationWarning emits a stderr warning for every
-// server-side bucket cap reported in truncations[]. It uses the repo's plain
-// "warning: <code>: <message>" convention (see shortcuts/common/runner.go and
-// +chat-list's bot_strip_p2p) — no emoji, so it stays legible in CI logs and
-// pipes regardless of terminal encoding.
-func writeChatMembersTruncationWarning(w io.Writer, truncations []interface{}) {
-	for _, t := range truncations {
-		tm, ok := t.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		memberType := valueOrAll(tm["member_type"])
-		limit := tm["limit"]
-		fmt.Fprintf(w, "warning: members_truncated: %s bucket capped at %v by server security config; the member list is INCOMPLETE\n", memberType, limit)
-	}
-}
-
-func valueOrAll(v interface{}) string {
-	if s, ok := v.(string); ok && s != "" {
-		return s
-	}
-	return "member"
-}
-
-func renderChatMembersPretty(w io.Writer, chatID string, res *chatMembersResult) {
-	fmt.Fprintf(w, "Chat: %s\n", chatID)
-	// Show the server-wide total next to the fetched count: when truncated or
-	// paged, total can far exceed len(users)/len(bots), and that gap is exactly
-	// what tells the reader how incomplete the list is.
-	fmt.Fprintf(w, "Users (%d%s):\n", len(res.users), totalSuffix(res.userTotal, len(res.users)))
-	for i, u := range res.users {
-		m, _ := u.(map[string]interface{})
-		fmt.Fprintf(w, "  [%d] %s  %s\n", i+1, valueOrDash(m["member_id"]), valueOrDash(m["name"]))
-	}
-	fmt.Fprintf(w, "Bots (%d%s):\n", len(res.bots), totalSuffix(res.botTotal, len(res.bots)))
-	for i, b := range res.bots {
-		m, _ := b.(map[string]interface{})
-		fmt.Fprintf(w, "  [%d] %s  %s\n", i+1, valueOrDash(m["member_id"]), valueOrDash(m["name"]))
-	}
-	if len(res.truncations) > 0 {
-		fmt.Fprintln(w, "warning: result truncated by server security config (see truncations[]); the list is INCOMPLETE")
-	}
-	if res.hasMore {
-		fmt.Fprint(w, "More pages available; pass --page-all (and --page-limit 0 for everything)")
-		if res.pageToken != "" {
-			fmt.Fprintf(w, ", or --page-token %s to resume", res.pageToken)
-		}
-		fmt.Fprintln(w)
-	}
-}
-
-func valueOrDash(v interface{}) string {
-	if s, ok := v.(string); ok && s != "" {
-		return s
-	}
-	return "-"
-}
-
-// totalSuffix renders " of <total>" when the server-reported total exceeds the
-// number actually fetched (so a truncated/partial bucket is obvious), and ""
-// when the total is absent or already matches the fetched count.
-func totalSuffix(total interface{}, fetched int) string {
-	n, ok := toInt(total)
-	if !ok || n <= fetched {
-		return ""
-	}
-	return fmt.Sprintf(" of %d", n)
-}
-
-// toInt coerces a JSON-decoded number (float64 / json.Number / int) to int.
-func toInt(v interface{}) (int, bool) {
-	switch n := v.(type) {
-	case float64:
-		return int(n), true
-	case int:
-		return n, true
-	case int64:
-		return int(n), true
-	case json.Number:
-		if i, err := n.Int64(); err == nil {
-			return int(i), true
-		}
-	}
-	return 0, false
-}

shortcuts/im/im_chat_members_list_test.go

@@ -1,325 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package im
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-	"github.com/spf13/cobra"
-)
-
-// page builds one list_members page payload shaped like the data object the
-// server returns (users[]/bots[]/truncations[] plus paging + totals).
-func cmlPage(users, bots, truncations []interface{}, hasMore bool, pageToken string) map[string]interface{} {
-	return map[string]interface{}{
-		"users":       users,
-		"bots":        bots,
-		"truncations": truncations,
-		"has_more":    hasMore,
-		"page_token":  pageToken,
-		"user_total":  324,
-		"bot_total":   2,
-	}
-}
-
-func us(ids ...string) []interface{} {
-	out := make([]interface{}, 0, len(ids))
-	for _, id := range ids {
-		out = append(out, map[string]interface{}{"member_id": id})
-	}
-	return out
-}
-
-// TestMergeChatMemberPages_MergesUsersAndBots covers Bug 1: every list bucket
-// (users AND bots) must be concatenated across pages, not just one of them.
-func TestMergeChatMemberPages_MergesUsersAndBots(t *testing.T) {
-	pages := []map[string]interface{}{
-		cmlPage(us("u1", "u2"), us("b1"), []interface{}{}, true, "p2"),
-		cmlPage(us("u3"), us("b2", "b3"), []interface{}{}, false, ""),
-	}
-
-	res := mergeChatMemberPages(pages)
-
-	if len(res.users) != 3 {
-		t.Errorf("users: want 3 merged, got %d", len(res.users))
-	}
-	if len(res.bots) != 3 {
-		t.Errorf("bots: want 3 merged, got %d", len(res.bots))
-	}
-}
-
-// TestMergeChatMemberPages_TruncationsFromLastPage covers Bug 2: truncations[]
-// is emitted only on the final page, so the merged view must take it from the
-// last page rather than inherit page 1's empty slice.
-func TestMergeChatMemberPages_TruncationsFromLastPage(t *testing.T) {
-	limit := []interface{}{map[string]interface{}{"limit": 100, "member_type": "user"}}
-	pages := []map[string]interface{}{
-		cmlPage(us("u1"), us("b1"), []interface{}{}, true, "p2"),
-		cmlPage(us("u2"), nil, limit, false, ""),
-	}
-
-	res := mergeChatMemberPages(pages)
-
-	if len(res.truncations) != 1 {
-		t.Fatalf("truncations: want last page's 1 entry, got %d (%v)", len(res.truncations), res.truncations)
-	}
-}
-
-// TestMergeChatMemberPages_HasMoreAndTokenFromLastPage guards that paging
-// signals come from the final page (so a --page-limit cutoff is visible).
-func TestMergeChatMemberPages_HasMoreAndTokenFromLastPage(t *testing.T) {
-	pages := []map[string]interface{}{
-		cmlPage(us("u1"), nil, nil, true, "p2"),
-		cmlPage(us("u2"), nil, nil, true, "p3"), // loop stopped early; server still has more
-	}
-
-	res := mergeChatMemberPages(pages)
-
-	if !res.hasMore {
-		t.Error("has_more: want true from last page")
-	}
-	if res.pageToken != "p3" {
-		t.Errorf("page_token: want last page's p3, got %q", res.pageToken)
-	}
-}
-
-// TestMergeChatMemberPages_TotalsFromLastPage verifies user_total / bot_total
-// are taken from the final page (not an earlier, possibly-different value).
-func TestMergeChatMemberPages_TotalsFromLastPage(t *testing.T) {
-	pages := []map[string]interface{}{
-		{"users": us("u1"), "user_total": 999, "bot_total": 7, "has_more": true, "page_token": "p2"},
-		{"users": us("u2"), "user_total": 324, "bot_total": 2, "has_more": false, "page_token": ""},
-	}
-	res := mergeChatMemberPages(pages)
-	if n, _ := toInt(res.userTotal); n != 324 {
-		t.Errorf("user_total: want last page's 324, got %v", res.userTotal)
-	}
-	if n, _ := toInt(res.botTotal); n != 2 {
-		t.Errorf("bot_total: want last page's 2, got %v", res.botTotal)
-	}
-}
-
-// TestChatMembersValidate covers --chat-id presence + oc_ prefix enforcement.
-func TestChatMembersValidate(t *testing.T) {
-	noop := shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		return shortcutJSONResponse(200, map[string]interface{}{"code": 0, "data": cmlPage(nil, nil, nil, false, "")}), nil
-	})
-	cases := []struct {
-		name    string
-		chatID  string
-		wantErr bool
-	}{
-		{"valid oc_", "oc_abc", false},
-		{"empty", "", true},
-		{"missing oc_ prefix", "abc123", true},
-	}
-	for _, c := range cases {
-		rt := newChatMembersTestRuntime(t, noop, map[string]string{"chat-id": c.chatID}, nil, nil)
-		err := ImChatMembersList.Validate(context.Background(), rt)
-		if c.wantErr {
-			assertValidationError(t, c.name, err, "--chat-id")
-			continue
-		}
-		if err != nil {
-			t.Errorf("%s: unexpected error %v", c.name, err)
-		}
-	}
-}
-
-// assertValidationError checks err satisfies the repo's typed-error contract for
-// a validation failure: a *errs.ValidationError carrying the expected Param, and
-// problem metadata of category validation / subtype invalid_argument.
-func assertValidationError(t *testing.T, ctx string, err error, wantParam string) {
-	t.Helper()
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Errorf("%s: want *errs.ValidationError, got %T (%v)", ctx, err, err)
-		return
-	}
-	if ve.Param != wantParam {
-		t.Errorf("%s: Param = %q, want %q", ctx, ve.Param, wantParam)
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("%s: problem = %+v (ok=%v), want category=%s subtype=%s", ctx, p, ok, errs.CategoryValidation, errs.SubtypeInvalidArgument)
-	}
-}
-
-func TestNormalizeMemberTypes(t *testing.T) {
-	cases := []struct {
-		in      []string
-		want    string
-		wantErr bool
-	}{
-		{nil, "", false},
-		{[]string{"user", "bot"}, "user,bot", false},
-		{[]string{"USER", "user"}, "user", false}, // lowercased + deduped
-		{[]string{"admin"}, "", true},
-		{[]string{""}, "", true},
-	}
-	for _, c := range cases {
-		got, err := normalizeMemberTypes(c.in)
-		if c.wantErr {
-			assertValidationError(t, fmt.Sprintf("normalizeMemberTypes(%v)", c.in), err, "--member-types")
-			continue
-		}
-		if err != nil {
-			t.Errorf("normalizeMemberTypes(%v): unexpected error %v", c.in, err)
-		}
-		if got != c.want {
-			t.Errorf("normalizeMemberTypes(%v) = %q, want %q", c.in, got, c.want)
-		}
-	}
-}
-
-// TestEffectiveChatMembersPageSize covers the --page-all max-page-size behavior:
-// drain with no explicit size → max; explicit size → honored; single page → default.
-func TestEffectiveChatMembersPageSize(t *testing.T) {
-	noop := shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		return shortcutJSONResponse(200, map[string]interface{}{"code": 0, "data": cmlPage(nil, nil, nil, false, "")}), nil
-	})
-	cases := []struct {
-		name string
-		b    map[string]bool
-		ints map[string]int
-		want int
-	}{
-		{"page-all, size unset -> max", map[string]bool{"page-all": true}, nil, chatMembersListMaxPageSize},
-		{"page-all, size explicit -> honored", map[string]bool{"page-all": true}, map[string]int{"page-size": 15}, 15},
-		{"single page, size unset -> default", nil, nil, chatMembersListDefaultPageSize},
-	}
-	for _, c := range cases {
-		rt := newChatMembersTestRuntime(t, noop, map[string]string{"chat-id": "oc_x"}, c.b, c.ints)
-		if got := effectiveChatMembersPageSize(rt); got != c.want {
-			t.Errorf("%s: want %d, got %d", c.name, c.want, got)
-		}
-	}
-}
-
-// newChatMembersTestRuntime registers the shortcut's flags and returns a
-// user-identity runtime wired to the given RoundTripper for multi-page mocking.
-func newChatMembersTestRuntime(t *testing.T, rt http.RoundTripper, str map[string]string, b map[string]bool, ints map[string]int) *common.RuntimeContext {
-	t.Helper()
-	runtime := newUserShortcutRuntime(t, rt)
-	cmd := &cobra.Command{Use: "test"}
-	cmd.Flags().String("chat-id", "", "")
-	cmd.Flags().String("member-id-type", "open_id", "")
-	cmd.Flags().StringSlice("member-types", nil, "")
-	cmd.Flags().String("page-token", "", "")
-	cmd.Flags().Bool("page-all", false, "")
-	cmd.Flags().Int("page-size", 20, "")
-	cmd.Flags().Int("page-limit", 10, "")
-	cmd.Flags().Int("page-delay", 200, "")
-	if err := cmd.ParseFlags(nil); err != nil {
-		t.Fatalf("ParseFlags: %v", err)
-	}
-	for k, v := range str {
-		if err := cmd.Flags().Set(k, v); err != nil {
-			t.Fatalf("set %s: %v", k, err)
-		}
-	}
-	for k, v := range b {
-		if err := cmd.Flags().Set(k, strconv.FormatBool(v)); err != nil {
-			t.Fatalf("set %s: %v", k, err)
-		}
-	}
-	for k, v := range ints {
-		if err := cmd.Flags().Set(k, strconv.Itoa(v)); err != nil {
-			t.Fatalf("set %s: %v", k, err)
-		}
-	}
-	runtime.Cmd = cmd
-	return runtime
-}
-
-// TestFetchChatMembers_PageAllMergesBucketsAndTruncations exercises the full
-// fetch loop over mocked pages: users/bots merge across pages and the final
-// page's truncations[] survives.
-func TestFetchChatMembers_PageAllMergesBucketsAndTruncations(t *testing.T) {
-	calls := 0
-	rt := shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		if !strings.Contains(req.URL.Path, "/open-apis/im/v1/chats/oc_test/members/list") {
-			return shortcutJSONResponse(404, map[string]interface{}{"code": 1}), nil
-		}
-		calls++
-		token := req.URL.Query().Get("page_token")
-		if token == "" {
-			return shortcutJSONResponse(200, map[string]interface{}{
-				"code": 0,
-				"data": cmlPage(us("u1", "u2"), us("b1"), []interface{}{}, true, "p2"),
-			}), nil
-		}
-		return shortcutJSONResponse(200, map[string]interface{}{
-			"code": 0,
-			"data": cmlPage(us("u3"), us("b2"), []interface{}{map[string]interface{}{"limit": 100, "member_type": "user"}}, false, ""),
-		}), nil
-	})
-	runtime := newChatMembersTestRuntime(t, rt,
-		map[string]string{"chat-id": "oc_test"},
-		map[string]bool{"page-all": true},
-		map[string]int{"page-size": 2, "page-limit": 0, "page-delay": 0})
-
-	res, err := fetchChatMembers(context.Background(), runtime, "oc_test")
-	if err != nil {
-		t.Fatalf("fetchChatMembers: %v", err)
-	}
-	if calls != 2 {
-		t.Errorf("want 2 page calls, got %d", calls)
-	}
-	if len(res.users) != 3 {
-		t.Errorf("users: want 3, got %d", len(res.users))
-	}
-	if len(res.bots) != 2 {
-		t.Errorf("bots: want 2, got %d", len(res.bots))
-	}
-	if len(res.truncations) != 1 {
-		t.Errorf("truncations: want 1 from last page, got %d", len(res.truncations))
-	}
-	if res.hasMore {
-		t.Error("has_more: want false after draining all pages")
-	}
-}
-
-// TestFetchChatMembers_PageLimitStops verifies --page-limit caps the loop and
-// leaves has_more=true so the caller knows the result is incomplete.
-func TestFetchChatMembers_PageLimitStops(t *testing.T) {
-	seq := 0
-	rt := shortcutRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		// Every page reports more pages available, with an advancing token so the
-		// loop is stopped by --page-limit, not the non-advancing-token guard.
-		seq++
-		return shortcutJSONResponse(200, map[string]interface{}{
-			"code": 0,
-			"data": cmlPage(us("u"), nil, nil, true, fmt.Sprintf("p%d", seq)),
-		}), nil
-	})
-	runtime := newChatMembersTestRuntime(t, rt,
-		map[string]string{"chat-id": "oc_test"},
-		map[string]bool{"page-all": true},
-		map[string]int{"page-size": 1, "page-limit": 3, "page-delay": 0})
-
-	res, err := fetchChatMembers(context.Background(), runtime, "oc_test")
-	if err != nil {
-		t.Fatalf("fetchChatMembers: %v", err)
-	}
-	if len(res.users) != 3 {
-		t.Errorf("users: want 3 (capped at page-limit), got %d", len(res.users))
-	}
-	if !res.hasMore {
-		t.Error("has_more: want true (loop cut short by page-limit)")
-	}
-	errOut := runtime.IO().ErrOut.(*bytes.Buffer)
-	if !strings.Contains(errOut.String(), "reached page limit (3)") {
-		t.Errorf("want page-limit notice on stderr, got: %s", errOut.String())
-	}
-}

shortcuts/im/shortcuts.go

@@ -10,7 +10,6 @@ func Shortcuts() []common.Shortcut {
 	return []common.Shortcut{
 		ImChatCreate,
 		ImChatList,
-		ImChatMembersList,
 		ImChatMessageList,
 		ImChatSearch,
 		ImChatUpdate,

shortcuts/markdown/helpers.go

@@ -715,15 +715,9 @@ func markdownUploadProblem(err error, action string) error {
 		case 90003087:
 			appendMarkdownProblemHint(err, "The current tenant or user may not have document capabilities enabled. Ask an administrator to verify document-module access.")
 		case 1061003, 1061044:
-			appendMarkdownProblemHint(err, "Check whether the target folder or wiki node still exists, and verify the parent token type. For Drive folders, pass --folder-token with a Drive folder token/URL; for wiki nodes, pass --wiki-token with a wiki node token/URL.")
+			appendMarkdownProblemHint(err, "Check whether the target folder or wiki node still exists, and verify the token you passed to the command.")
 		case 1061004, 1062501:
 			appendMarkdownProblemHint(err, "Check whether the current identity has write access to the target folder or wiki node.")
-		case 1061101:
-			appendMarkdownProblemHint(err, "The target Drive/wiki storage quota is exhausted. Free space, choose another parent folder/wiki node, or ask an administrator to raise quota before retrying.")
-		case 233523001:
-			appendMarkdownProblemHint(err, "The upstream document service returned a transient server error. Retry later; if it repeats, keep the log_id/request_id for service-side investigation.")
-		case 99991400:
-			appendMarkdownProblemHint(err, "The upload API is rate limited. Stop immediate retries and retry later with exponential backoff.")
 		}
 	}
 	return err

shortcuts/markdown/markdown_create.go

@@ -9,7 +9,6 @@ import (
 	"io"
 	"strings"
 
-	"github.com/larksuite/cli/internal/validate"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
@@ -31,19 +30,27 @@ var MarkdownCreate = common.Shortcut{
 	Tips: []string{
 		"Omit both --folder-token and --wiki-token to create the Markdown file in the caller's Drive root folder.",
 		"Use --wiki-token <wiki_node_token> to create the Markdown file under a wiki node; the shortcut maps this to parent_type=wiki automatically.",
-		"--folder-token and --wiki-token also accept full Lark URLs and normalize them to the required token.",
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec, err := readMarkdownCreateSpec(runtime)
-		if err != nil {
-			return err
-		}
-		return validateMarkdownSpec(runtime, spec, true)
+		return validateMarkdownSpec(runtime, markdownUploadSpec{
+			FileName:    strings.TrimSpace(runtime.Str("name")),
+			FolderToken: strings.TrimSpace(runtime.Str("folder-token")),
+			WikiToken:   strings.TrimSpace(runtime.Str("wiki-token")),
+			FilePath:    strings.TrimSpace(runtime.Str("file")),
+			FileSet:     runtime.Changed("file"),
+			Content:     runtime.Str("content"),
+			ContentSet:  runtime.Changed("content"),
+		}, true)
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec, err := readMarkdownCreateSpec(runtime)
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
+		spec := markdownUploadSpec{
+			FileName:    strings.TrimSpace(runtime.Str("name")),
+			FolderToken: strings.TrimSpace(runtime.Str("folder-token")),
+			WikiToken:   strings.TrimSpace(runtime.Str("wiki-token")),
+			FilePath:    strings.TrimSpace(runtime.Str("file")),
+			FileSet:     runtime.Changed("file"),
+			Content:     runtime.Str("content"),
+			ContentSet:  runtime.Changed("content"),
 		}
 		fileSize, err := markdownSourceSize(runtime, spec)
 		if err != nil {
@@ -64,9 +71,14 @@ var MarkdownCreate = common.Shortcut{
 		return dry
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec, err := readMarkdownCreateSpec(runtime)
-		if err != nil {
-			return err
+		spec := markdownUploadSpec{
+			FileName:    strings.TrimSpace(runtime.Str("name")),
+			FolderToken: strings.TrimSpace(runtime.Str("folder-token")),
+			WikiToken:   strings.TrimSpace(runtime.Str("wiki-token")),
+			FilePath:    strings.TrimSpace(runtime.Str("file")),
+			FileSet:     runtime.Changed("file"),
+			Content:     runtime.Str("content"),
+			ContentSet:  runtime.Changed("content"),
 		}
 		fileSize, err := markdownSourceSize(runtime, spec)
 		if err != nil {
@@ -103,139 +115,3 @@ var MarkdownCreate = common.Shortcut{
 		return nil
 	},
 }
-
-func readMarkdownCreateSpec(runtime *common.RuntimeContext) (markdownUploadSpec, error) {
-	spec := markdownUploadSpec{
-		FileName:    strings.TrimSpace(runtime.Str("name")),
-		FolderToken: strings.TrimSpace(runtime.Str("folder-token")),
-		WikiToken:   strings.TrimSpace(runtime.Str("wiki-token")),
-		FilePath:    strings.TrimSpace(runtime.Str("file")),
-		FileSet:     runtime.Changed("file"),
-		Content:     runtime.Str("content"),
-		ContentSet:  runtime.Changed("content"),
-	}
-	return normalizeMarkdownCreateTargetSpec(spec)
-}
-
-func normalizeMarkdownCreateTargetSpec(spec markdownUploadSpec) (markdownUploadSpec, error) {
-	if spec.FolderToken != "" {
-		token, err := normalizeMarkdownFolderToken(spec.FolderToken)
-		if err != nil {
-			return markdownUploadSpec{}, err
-		}
-		spec.FolderToken = token
-	}
-	if spec.WikiToken != "" {
-		token, err := normalizeMarkdownWikiToken(spec.WikiToken)
-		if err != nil {
-			return markdownUploadSpec{}, err
-		}
-		spec.WikiToken = token
-	}
-	return spec, nil
-}
-
-func normalizeMarkdownFolderToken(token string) (string, error) {
-	token = strings.TrimSpace(token)
-	if strings.Contains(token, "://") {
-		ref, ok := common.ParseResourceURL(token)
-		if !ok {
-			return "", markdownValidationParamError("--folder-token", "--folder-token URL is unsupported").
-				WithHint("Pass a Drive folder URL or raw folder token.")
-		}
-		if ref.Type != "folder" {
-			return "", markdownValidationParamError("--folder-token",
-				"--folder-token must identify a Drive folder; got a %s URL",
-				ref.Type,
-			).WithHint("Use --wiki-token for wiki nodes or pass a Drive folder URL/token.")
-		}
-		if err := validateMarkdownTargetTokenName(ref.Token, "--folder-token"); err != nil {
-			return "", err
-		}
-		return ref.Token, nil
-	}
-	if err := rejectMarkdownPartialToken(token, "--folder-token"); err != nil {
-		return "", err
-	}
-	switch markdownKnownResourceTokenKind(token) {
-	case "wiki":
-		return "", markdownValidationParamError("--folder-token", "--folder-token looks like a wiki node token").
-			WithHint("Pass it with --wiki-token instead.")
-	case "doc", "docx", "sheet", "bitable", "mindnote", "slides", "file":
-		return "", markdownValidationParamError("--folder-token", "--folder-token must be a Drive folder token, not a %s token", markdownKnownResourceTokenKind(token))
-	}
-	if err := validateMarkdownTargetTokenName(token, "--folder-token"); err != nil {
-		return "", err
-	}
-	return token, nil
-}
-
-func normalizeMarkdownWikiToken(token string) (string, error) {
-	token = strings.TrimSpace(token)
-	if strings.Contains(token, "://") {
-		ref, ok := common.ParseResourceURL(token)
-		if !ok {
-			return "", markdownValidationParamError("--wiki-token", "--wiki-token URL is unsupported").
-				WithHint("Pass a wiki node URL or raw wiki node token.")
-		}
-		if ref.Type != "wiki" {
-			return "", markdownValidationParamError("--wiki-token",
-				"--wiki-token must identify a wiki node; got a %s URL",
-				ref.Type,
-			).WithHint("Resolve document URLs with `lark-cli wiki +node-get --node-token <url>` and use the returned node_token.")
-		}
-		if err := validateMarkdownTargetTokenName(ref.Token, "--wiki-token"); err != nil {
-			return "", err
-		}
-		return ref.Token, nil
-	}
-	if err := rejectMarkdownPartialToken(token, "--wiki-token"); err != nil {
-		return "", err
-	}
-	if kind := markdownKnownResourceTokenKind(token); kind != "" && kind != "wiki" {
-		return "", markdownValidationParamError("--wiki-token", "--wiki-token must be a wiki node token, not a %s token", kind)
-	}
-	if err := validateMarkdownTargetTokenName(token, "--wiki-token"); err != nil {
-		return "", err
-	}
-	return token, nil
-}
-
-func rejectMarkdownPartialToken(token, flagName string) error {
-	if strings.ContainsAny(token, "/?#") {
-		return markdownValidationParamError(flagName, "%s must be a raw token, not a path, query, or fragment", flagName).
-			WithHint("Pass a full Lark URL, or copy only the token value without path/query/fragment characters.")
-	}
-	return nil
-}
-
-func validateMarkdownTargetTokenName(token, flagName string) error {
-	if err := validate.ResourceName(token, flagName); err != nil {
-		return markdownValidationParamError(flagName, "%s", err).WithCause(err)
-	}
-	return nil
-}
-
-func markdownKnownResourceTokenKind(token string) string {
-	lower := strings.ToLower(strings.TrimSpace(token))
-	switch {
-	case strings.HasPrefix(lower, "wik"):
-		return "wiki"
-	case strings.HasPrefix(lower, "docx"):
-		return "docx"
-	case strings.HasPrefix(lower, "doc"):
-		return "doc"
-	case strings.HasPrefix(lower, "sht"):
-		return "sheet"
-	case strings.HasPrefix(lower, "bas"):
-		return "bitable"
-	case strings.HasPrefix(lower, "mn"):
-		return "mindnote"
-	case strings.HasPrefix(lower, "sld"):
-		return "slides"
-	case strings.HasPrefix(lower, "box"), strings.HasPrefix(lower, "file"):
-		return "file"
-	default:
-		return ""
-	}
-}

shortcuts/markdown/markdown_test.go

@@ -446,173 +446,6 @@ func TestMarkdownCreateDryRunWithWikiToken(t *testing.T) {
 	}
 }
 
-func TestMarkdownCreateDryRunNormalizesFolderURL(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, markdownTestConfig())
-
-	err := mountAndRunMarkdown(t, MarkdownCreate, []string{
-		"+create",
-		"--name", "README.md",
-		"--content", "# hello",
-		"--folder-token", "https://feishu.cn/drive/folder/fldcnMarkdownTarget",
-		"--dry-run",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	out := stdout.String()
-	if !strings.Contains(out, `"parent_type": "explorer"`) {
-		t.Fatalf("dry-run missing explorer parent_type: %s", out)
-	}
-	if !strings.Contains(out, `"parent_node": "fldcnMarkdownTarget"`) {
-		t.Fatalf("dry-run did not normalize folder URL to token: %s", out)
-	}
-	if strings.Contains(out, "https://feishu.cn/drive/folder/") {
-		t.Fatalf("dry-run leaked raw folder URL instead of token: %s", out)
-	}
-}
-
-func TestMarkdownCreateRejectsWikiURLInFolderToken(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, markdownTestConfig())
-
-	err := mountAndRunMarkdown(t, MarkdownCreate, []string{
-		"+create",
-		"--name", "README.md",
-		"--content", "# hello",
-		"--folder-token", "https://feishu.cn/wiki/wikcnWrongFlag",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected folder-token URL type error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("ProblemOf() ok=false for %T: %v", err, err)
-	}
-	if !strings.Contains(p.Message, "must identify a Drive folder") || !strings.Contains(p.Hint, "Use --wiki-token") {
-		t.Fatalf("expected folder-token URL type error, got %v", err)
-	}
-}
-
-func TestMarkdownCreateRejectsDocURLInWikiToken(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, markdownTestConfig())
-
-	err := mountAndRunMarkdown(t, MarkdownCreate, []string{
-		"+create",
-		"--name", "README.md",
-		"--content", "# hello",
-		"--wiki-token", "https://feishu.cn/docx/docxWrongFlag",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected wiki-token URL type error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("ProblemOf() ok=false for %T: %v", err, err)
-	}
-	if !strings.Contains(p.Message, "must identify a wiki node") || !strings.Contains(p.Hint, "+node-get") {
-		t.Fatalf("expected wiki-token URL type error, got %v", err)
-	}
-}
-
-func TestNormalizeMarkdownTargetTokensRejectAmbiguousInputs(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name     string
-		run      func() (string, error)
-		wantMsg  string
-		wantHint string
-	}{
-		{
-			name:     "wiki token passed as folder token",
-			run:      func() (string, error) { return normalizeMarkdownFolderToken("wik_placeholder_wrong") },
-			wantMsg:  "--folder-token looks like a wiki node token",
-			wantHint: "--wiki-token",
-		},
-		{
-			name:     "folder token path fragment",
-			run:      func() (string, error) { return normalizeMarkdownFolderToken("folder_token/child") },
-			wantMsg:  "--folder-token must be a raw token",
-			wantHint: "full Lark URL",
-		},
-		{
-			name:     "doc token passed as wiki token",
-			run:      func() (string, error) { return normalizeMarkdownWikiToken("docx_placeholder_wrong") },
-			wantMsg:  "--wiki-token must be a wiki node token",
-			wantHint: "",
-		},
-		{
-			name:     "wiki token query fragment",
-			run:      func() (string, error) { return normalizeMarkdownWikiToken("wik_placeholder?from=copy") },
-			wantMsg:  "--wiki-token must be a raw token",
-			wantHint: "path/query/fragment",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := tt.run()
-			if err == nil {
-				t.Fatalf("expected validation error")
-			}
-			p, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("ProblemOf() ok=false for %T: %v", err, err)
-			}
-			if !strings.Contains(p.Message, tt.wantMsg) {
-				t.Fatalf("message = %q, want substring %q", p.Message, tt.wantMsg)
-			}
-			if tt.wantHint != "" && !strings.Contains(p.Hint, tt.wantHint) {
-				t.Fatalf("hint = %q, want substring %q", p.Hint, tt.wantHint)
-			}
-		})
-	}
-}
-
-func TestNormalizeMarkdownTargetTokensAcceptRawTokens(t *testing.T) {
-	t.Parallel()
-
-	folderToken, err := normalizeMarkdownFolderToken("folder_token_raw")
-	if err != nil {
-		t.Fatalf("normalizeMarkdownFolderToken() error = %v", err)
-	}
-	if folderToken != "folder_token_raw" {
-		t.Fatalf("folder token = %q", folderToken)
-	}
-
-	wikiToken, err := normalizeMarkdownWikiToken("wik_placeholder_raw")
-	if err != nil {
-		t.Fatalf("normalizeMarkdownWikiToken() error = %v", err)
-	}
-	if wikiToken != "wik_placeholder_raw" {
-		t.Fatalf("wiki token = %q", wikiToken)
-	}
-}
-
-func TestMarkdownUploadProblemAddsQuotaAndServerHints(t *testing.T) {
-	t.Parallel()
-
-	quotaErr := errs.NewAPIError(errs.SubtypeQuotaExceeded, "file quota exceeded").WithCode(1061101)
-	got := markdownUploadProblem(quotaErr, markdownUploadAllAction)
-	p, ok := errs.ProblemOf(got)
-	if !ok {
-		t.Fatalf("ProblemOf(quotaErr) ok=false")
-	}
-	if !strings.Contains(p.Hint, "storage quota is exhausted") {
-		t.Fatalf("quota hint = %q", p.Hint)
-	}
-
-	serverErr := errs.NewAPIError(errs.SubtypeServerError, "NA").WithCode(233523001).WithRetryable()
-	got = markdownUploadProblem(serverErr, markdownUploadAllAction)
-	p, ok = errs.ProblemOf(got)
-	if !ok {
-		t.Fatalf("ProblemOf(serverErr) ok=false")
-	}
-	if !p.Retryable || !strings.Contains(p.Hint, "transient server error") {
-		t.Fatalf("server retryable=%v hint=%q", p.Retryable, p.Hint)
-	}
-}
-
 func TestMarkdownCreateDryRunReportsSourceFileError(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, markdownTestConfig())
 

shortcuts/minutes/minutes_speaker_replace.go

@@ -66,24 +66,31 @@ var MinutesSpeakerReplace = common.Shortcut{
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		return common.NewDryRunAPI().
-			PUT(fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speaker", validate.EncodePathSegment(minuteToken))).
+		dr := common.NewDryRunAPI()
+		if strings.TrimSpace(runtime.Str("from-speaker-id")) != "" && strings.TrimSpace(runtime.Str("from-user-id")) == "" {
+			dr.GET(minuteTranscriptSpeakerlistPath(minuteToken)).Desc("Resolve --from-speaker-id when it is a display name")
+		}
+		return dr.PUT(fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speaker", validate.EncodePathSegment(minuteToken))).
 			Body(buildSpeakerReplaceRequestBody(runtime))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		fromSpeakerID := strings.TrimSpace(runtime.Str("from-speaker-id"))
-		fromUserID := strings.TrimSpace(runtime.Str("from-user-id"))
+		fromSpeakerInput := strings.TrimSpace(runtime.Str("from-speaker-id"))
 		toUserID := strings.TrimSpace(runtime.Str("to-user-id"))
 
-		_, err := runtime.CallAPITyped(http.MethodPut,
+		fromSpeakerID, fromUserID, err := resolveSpeakerReplaceFrom(runtime, minuteToken)
+		if err != nil {
+			return err
+		}
+
+		_, err = runtime.CallAPITyped(http.MethodPut,
 			fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speaker", validate.EncodePathSegment(minuteToken)),
 			map[string]interface{}{"user_id_type": "open_id"}, buildSpeakerReplaceRequestBodyResolved(fromSpeakerID, fromUserID, toUserID))
 		if err != nil {
-			return minutesSpeakerReplaceError(err, minuteToken, speakerReplaceSourceLabel(fromSpeakerID, fromUserID))
+			return minutesSpeakerReplaceError(err, minuteToken, speakerReplaceSourceLabel(fromSpeakerInput, fromSpeakerID, fromUserID))
 		}
 
-		runtime.OutFormat(buildSpeakerReplaceOutputData(minuteToken, fromSpeakerID, fromUserID, toUserID), nil, nil)
+		runtime.OutFormat(buildSpeakerReplaceOutputData(fromSpeakerInput, minuteToken, fromSpeakerID, fromUserID, toUserID), nil, nil)
 		return nil
 	},
 }
@@ -107,20 +114,26 @@ func buildSpeakerReplaceRequestBodyResolved(fromSpeakerID, fromUserID, toUserID
 	return body
 }
 
-func buildSpeakerReplaceOutputData(minuteToken, fromSpeakerID, fromUserID, toUserID string) map[string]interface{} {
+func buildSpeakerReplaceOutputData(fromSpeakerInput, minuteToken, fromSpeakerID, fromUserID, toUserID string) map[string]interface{} {
 	out := map[string]interface{}{
 		"minute_token": minuteToken,
 		"to_user_id":   toUserID,
 	}
 	if fromSpeakerID != "" {
 		out["from_speaker_id"] = fromSpeakerID
+		if fromSpeakerInput != "" && fromSpeakerInput != fromSpeakerID {
+			out["from_speaker_input"] = fromSpeakerInput
+		}
 	} else {
 		out["from_user_id"] = fromUserID
 	}
 	return out
 }
 
-func speakerReplaceSourceLabel(fromSpeakerID, fromUserID string) string {
+func speakerReplaceSourceLabel(fromSpeakerInput, fromSpeakerID, fromUserID string) string {
+	if fromSpeakerInput != "" {
+		return fromSpeakerInput
+	}
 	if fromSpeakerID != "" {
 		return fromSpeakerID
 	}

shortcuts/minutes/minutes_speaker_replace_test.go

@@ -153,14 +153,58 @@ func TestMinutesSpeakerReplace_DryRun(t *testing.T) {
 	}
 }
 
-func TestMinutesSpeakerReplace_Execute_OpaqueSpeakerIDNoPrefetch(t *testing.T) {
+func TestMinutesSpeakerReplace_DryRun_ResolveFromSpeakerID(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	f, stdout, _, _ := cmdutil.TestFactory(t, defaultConfig())
+	warmTokenCache(t)
+
+	err := mountAndRun(t, MinutesSpeakerReplace, []string{
+		"+speaker-replace",
+		"--minute-token", minutesSpeakerReplaceTestToken,
+		"--from-speaker-id", "说话人1",
+		"--to-user-id", "ou_new_speaker",
+		"--dry-run", "--as", "user",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	out := stdout.String()
+	if !strings.Contains(out, "GET") {
+		t.Errorf("expected GET for internal speaker list, got:\n%s", out)
+	}
+	if !strings.Contains(out, "/transcript/speakerlist") {
+		t.Errorf("expected speakerlist path, got:\n%s", out)
+	}
+	if !strings.Contains(out, "PUT") {
+		t.Errorf("expected PUT for speaker replace, got:\n%s", out)
+	}
+	if !strings.Contains(out, "ou_new_speaker") {
+		t.Errorf("expected to_user_id in body, got:\n%s", out)
+	}
+}
+
+func TestMinutesSpeakerReplace_Execute_ResolveFromSpeakerID(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
 	warmTokenCache(t)
 
-	// Only the PUT is registered on purpose: an opaque speaker_id must be passed
-	// straight through without a second speakerlist call. If the code still
-	// prefetched speakerlist, the unregistered GET would fail the request.
+	reg.Register(&httpmock.Stub{
+		Method: http.MethodGet,
+		URL:    "/open-apis/minutes/v1/minutes/" + minutesSpeakerReplaceTestToken + "/transcript/speakerlist",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{
+				"speakers": []interface{}{
+					map[string]interface{}{
+						"speaker_id": "ENCRYPTED_TOKEN_ABC",
+						"name":       "说话人1",
+					},
+				},
+			},
+		},
+	})
 	reg.Register(&httpmock.Stub{
 		Method: http.MethodPut,
 		URL:    "/open-apis/minutes/v1/minutes/" + minutesSpeakerReplaceTestToken + "/transcript/speaker",
@@ -174,7 +218,7 @@ func TestMinutesSpeakerReplace_Execute_OpaqueSpeakerIDNoPrefetch(t *testing.T) {
 	err := mountAndRun(t, MinutesSpeakerReplace, []string{
 		"+speaker-replace",
 		"--minute-token", minutesSpeakerReplaceTestToken,
-		"--from-speaker-id", "ENCRYPTED_TOKEN_ABC",
+		"--from-speaker-id", "说话人1",
 		"--to-user-id", "ou_new_speaker",
 		"--format", "json", "--as", "user",
 	}, f, stdout)
@@ -184,19 +228,21 @@ func TestMinutesSpeakerReplace_Execute_OpaqueSpeakerIDNoPrefetch(t *testing.T) {
 
 	var envelope struct {
 		Data struct {
-			FromSpeakerID string `json:"from_speaker_id"`
-			ToUserID      string `json:"to_user_id"`
+			MinuteToken      string `json:"minute_token"`
+			FromSpeakerInput string `json:"from_speaker_input"`
+			FromSpeakerID    string `json:"from_speaker_id"`
+			ToUserID         string `json:"to_user_id"`
 		} `json:"data"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
 		t.Fatalf("unmarshal stdout: %v", err)
 	}
+	if envelope.Data.FromSpeakerInput != "说话人1" {
+		t.Errorf("data.from_speaker_input = %q, want 说话人1", envelope.Data.FromSpeakerInput)
+	}
 	if envelope.Data.FromSpeakerID != "ENCRYPTED_TOKEN_ABC" {
 		t.Errorf("data.from_speaker_id = %q, want ENCRYPTED_TOKEN_ABC", envelope.Data.FromSpeakerID)
 	}
-	if envelope.Data.ToUserID != "ou_new_speaker" {
-		t.Errorf("data.to_user_id = %q, want ou_new_speaker", envelope.Data.ToUserID)
-	}
 }
 
 func TestMinutesSpeakerReplace_DryRun_FromSpeakerID(t *testing.T) {
@@ -216,11 +262,8 @@ func TestMinutesSpeakerReplace_DryRun_FromSpeakerID(t *testing.T) {
 	}
 
 	out := stdout.String()
-	if strings.Contains(out, "/transcript/speakerlist") {
-		t.Errorf("opaque speaker_id should not prefetch speakerlist, got:\n%s", out)
-	}
-	if !strings.Contains(out, "PUT") {
-		t.Errorf("expected PUT for speaker replace, got:\n%s", out)
+	if !strings.Contains(out, "GET") {
+		t.Errorf("expected GET for internal speaker list, got:\n%s", out)
 	}
 	if !strings.Contains(out, "from_speaker_id") || !strings.Contains(out, "ENCRYPTED_TOKEN_ABC") {
 		t.Errorf("expected from_speaker_id in body, got:\n%s", out)

shortcuts/minutes/minutes_speakers.go

@@ -0,0 +1,104 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package minutes
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/validate"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+type minuteSpeaker struct {
+	SpeakerID string
+	Name      string
+}
+
+func minuteTranscriptSpeakerlistPath(minuteToken string) string {
+	return fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/transcript/speakerlist", validate.EncodePathSegment(minuteToken))
+}
+
+func fetchMinuteSpeakers(runtime *common.RuntimeContext, minuteToken string) ([]minuteSpeaker, error) {
+	data, err := runtime.CallAPITyped(http.MethodGet, minuteTranscriptSpeakerlistPath(minuteToken), nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	if data == nil {
+		return nil, nil
+	}
+
+	items := common.GetSlice(data, "speakers")
+	speakers := make([]minuteSpeaker, 0, len(items))
+	for _, raw := range items {
+		item, _ := raw.(map[string]interface{})
+		if item == nil {
+			continue
+		}
+		id := strings.TrimSpace(common.GetString(item, "speaker_id"))
+		name := strings.TrimSpace(common.GetString(item, "name"))
+		if id == "" {
+			continue
+		}
+		speakers = append(speakers, minuteSpeaker{SpeakerID: id, Name: name})
+	}
+	return speakers, nil
+}
+
+func resolveSpeakerIDByName(speakers []minuteSpeaker, name string) (string, error) {
+	name = strings.TrimSpace(name)
+	var matches []minuteSpeaker
+	for _, s := range speakers {
+		if s.Name == name {
+			matches = append(matches, s)
+		}
+	}
+	switch len(matches) {
+	case 0:
+		return "", errs.NewValidationError(errs.SubtypeNotFound,
+			"no speaker named %q in minute transcript", name).
+			WithParam("--from-speaker-id").
+			WithHint("Check the speaker name spelling or open the minute to see transcript speaker labels")
+	case 1:
+		return matches[0].SpeakerID, nil
+	default:
+		ids := make([]string, len(matches))
+		for i, m := range matches {
+			ids[i] = m.SpeakerID
+		}
+		return "", errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"multiple speakers named %q (%d matches); pass the exact --from-speaker-id", name, len(matches)).
+			WithParam("--from-speaker-id").
+			WithHint(fmt.Sprintf("Matching speaker_ids: %s. Review each speaker's utterances in the minute, then retry with the exact speaker_id", strings.Join(ids, ", ")))
+	}
+}
+
+// resolveFromSpeakerID resolves --from-speaker-id to an API speaker_id.
+// The input may already be an opaque speaker_id, or a display name that requires
+// an internal speaker-list fetch.
+func resolveFromSpeakerID(runtime *common.RuntimeContext, minuteToken, input string) (string, error) {
+	input = strings.TrimSpace(input)
+	speakers, err := fetchMinuteSpeakers(runtime, minuteToken)
+	if err != nil {
+		return "", err
+	}
+	for _, s := range speakers {
+		if s.SpeakerID == input {
+			return input, nil
+		}
+	}
+	return resolveSpeakerIDByName(speakers, input)
+}
+
+func resolveSpeakerReplaceFrom(runtime *common.RuntimeContext, minuteToken string) (fromSpeakerID, fromUserID string, err error) {
+	fromUserID = strings.TrimSpace(runtime.Str("from-user-id"))
+	if fromUserID != "" {
+		return "", fromUserID, nil
+	}
+
+	fromSpeakerID, err = resolveFromSpeakerID(runtime, minuteToken, runtime.Str("from-speaker-id"))
+	return fromSpeakerID, "", err
+}

shortcuts/minutes/minutes_speakers_test.go

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package minutes
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+)
+
+func TestResolveSpeakerIDByName(t *testing.T) {
+	speakers := []minuteSpeaker{
+		{SpeakerID: "id_a", Name: "Alice"},
+		{SpeakerID: "id_b", Name: "Bob"},
+		{SpeakerID: "id_c", Name: "Alice"},
+	}
+
+	id, err := resolveSpeakerIDByName(speakers, "Bob")
+	if err != nil || id != "id_b" {
+		t.Fatalf("resolve Bob: id=%q err=%v", id, err)
+	}
+
+	_, err = resolveSpeakerIDByName(speakers, "Carol")
+	if err == nil {
+		t.Fatal("expected not found error")
+	}
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeNotFound {
+		t.Fatalf("want not-found validation error, got %T: %v", err, err)
+	}
+
+	_, err = resolveSpeakerIDByName(speakers, "Alice")
+	if err == nil {
+		t.Fatal("expected duplicate name error")
+	}
+	if !errors.As(err, &ve) || ve.Subtype != errs.SubtypeFailedPrecondition {
+		t.Fatalf("want failed-precondition validation error, got %T: %v", err, err)
+	}
+	if !strings.Contains(ve.Hint, "id_a") || !strings.Contains(ve.Hint, "id_c") {
+		t.Errorf("hint should list matching speaker_ids, got: %s", ve.Hint)
+	}
+}

shortcuts/okr/okr_batch_create.go

@@ -58,9 +58,45 @@ func parseBatchCreateInput(input string) ([]batchCreateObjective, error) {
 	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)
+	content := buildContentBlock(obj.Text, obj.Mention)
 	body := map[string]interface{}{
 		"content": content,
 	}
@@ -84,7 +120,7 @@ func createObjective(ctx context.Context, runtime *common.RuntimeContext, cycleI
 
 // 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)
+	content := buildContentBlock(kr.Text, kr.Mention)
 	body := map[string]interface{}{
 		"content": content,
 	}
@@ -188,7 +224,7 @@ var OKRBatchCreate = common.Shortcut{
 
 		for i, obj := range objectives {
 			// Objective creation
-			objContent := BuildContentBlock(obj.Text, obj.Mention)
+			objContent := buildContentBlock(obj.Text, obj.Mention)
 			objBody := map[string]interface{}{
 				"content": objContent,
 			}
@@ -205,7 +241,7 @@ var OKRBatchCreate = common.Shortcut{
 
 			// KR creations
 			for j, kr := range obj.KRs {
-				krContent := BuildContentBlock(kr.Text, kr.Mention)
+				krContent := buildContentBlock(kr.Text, kr.Mention)
 				krBody := map[string]interface{}{
 					"content": krContent,
 				}

shortcuts/okr/okr_batch_create_test.go

@@ -557,7 +557,7 @@ func TestParseBatchCreateInput_Valid(t *testing.T) {
 
 func TestBuildContentBlock(t *testing.T) {
 	t.Parallel()
-	cb := BuildContentBlock("Test text", []string{"ou_123", "ou_456"})
+	cb := buildContentBlock("Test text", []string{"ou_123", "ou_456"})
 	if cb == nil {
 		t.Fatal("expected non-nil ContentBlock")
 	}

shortcuts/okr/okr_cli_resp.go

@@ -29,10 +29,15 @@ type RespCategory struct {
 
 // RespCycle 周期
 type RespCycle struct {
-	ID          string  `json:"id"`
-	StartTime   string  `json:"start_time"`
-	EndTime     string  `json:"end_time"`
-	CycleStatus *string `json:"cycle_status,omitempty"`
+	ID            string    `json:"id"`
+	CreateTime    string    `json:"create_time"`
+	UpdateTime    string    `json:"update_time"`
+	TenantCycleID string    `json:"tenant_cycle_id"`
+	Owner         RespOwner `json:"owner"`
+	StartTime     string    `json:"start_time"`
+	EndTime       string    `json:"end_time"`
+	CycleStatus   *string   `json:"cycle_status,omitempty"`
+	Score         *float64  `json:"score,omitempty"`
 }
 
 // RespIndicator 指标
@@ -147,145 +152,3 @@ type RespProgress struct {
 	Content      *string           `json:"content,omitempty"`
 	ProgressRate *RespProgressRate `json:"progress_rate,omitempty"`
 }
-
-// ========== Simple-style response types (semi-plain text format) ==========
-
-// RespKeyResultSimple is KeyResult response with SemiPlainContent instead of ContentBlock JSON string.
-type RespKeyResultSimple struct {
-	ID          string            `json:"id"`
-	CreateTime  string            `json:"create_time"`
-	UpdateTime  string            `json:"update_time"`
-	Owner       RespOwner         `json:"owner"`
-	ObjectiveID string            `json:"objective_id"`
-	Position    *int32            `json:"position,omitempty"`
-	Content     *SemiPlainContent `json:"content,omitempty"`
-	Score       *float64          `json:"score,omitempty"`
-	Weight      *float64          `json:"weight,omitempty"`
-	Deadline    *string           `json:"deadline,omitempty"`
-}
-
-// RespObjectiveSimple is Objective response with SemiPlainContent instead of ContentBlock JSON string.
-type RespObjectiveSimple struct {
-	ID         string                `json:"id"`
-	CreateTime string                `json:"create_time"`
-	UpdateTime string                `json:"update_time"`
-	Owner      RespOwner             `json:"owner"`
-	CycleID    string                `json:"cycle_id"`
-	Position   *int32                `json:"position,omitempty"`
-	Content    *SemiPlainContent     `json:"content,omitempty"`
-	Score      *float64              `json:"score,omitempty"`
-	Notes      *SemiPlainContent     `json:"notes,omitempty"`
-	Weight     *float64              `json:"weight,omitempty"`
-	Deadline   *string               `json:"deadline,omitempty"`
-	CategoryID *string               `json:"category_id,omitempty"`
-	KeyResults []RespKeyResultSimple `json:"key_results,omitempty"`
-}
-
-// RespProgressSimple is Progress response with SemiPlainContent instead of ContentBlock JSON string.
-type RespProgressSimple struct {
-	ID           string            `json:"progress_id"`
-	ModifyTime   string            `json:"modify_time"`
-	CreateTime   *string           `json:"create_time,omitempty"`
-	Content      *SemiPlainContent `json:"content,omitempty"`
-	ProgressRate *RespProgressRate `json:"progress_rate,omitempty"`
-}
-
-// ToSimple converts KeyResult to RespKeyResultSimple.
-func (k *KeyResult) ToSimple() *RespKeyResultSimple {
-	if k == nil {
-		return nil
-	}
-	result := &RespKeyResultSimple{
-		ID:          k.ID,
-		CreateTime:  formatTimestamp(k.CreateTime),
-		UpdateTime:  formatTimestamp(k.UpdateTime),
-		Owner:       *k.Owner.ToResp(),
-		ObjectiveID: k.ObjectiveID,
-		Position:    k.Position,
-		Score:       k.Score,
-		Weight:      k.Weight,
-	}
-	if k.Deadline != nil {
-		d := formatTimestamp(*k.Deadline)
-		result.Deadline = &d
-	}
-	result.Content = k.Content.ToSemiPlain()
-	return result
-}
-
-// ToSimple converts Objective to RespObjectiveSimple.
-func (o *Objective) ToSimple() *RespObjectiveSimple {
-	if o == nil {
-		return nil
-	}
-	result := &RespObjectiveSimple{
-		ID:         o.ID,
-		CreateTime: formatTimestamp(o.CreateTime),
-		UpdateTime: formatTimestamp(o.UpdateTime),
-		Owner:      *o.Owner.ToResp(),
-		CycleID:    o.CycleID,
-		Position:   o.Position,
-		Score:      o.Score,
-		Weight:     o.Weight,
-		CategoryID: o.CategoryID,
-	}
-	if o.Deadline != nil {
-		d := formatTimestamp(*o.Deadline)
-		result.Deadline = &d
-	}
-	result.Content = o.Content.ToSemiPlain()
-	result.Notes = o.Notes.ToSemiPlain()
-	return result
-}
-
-// ToSimple converts ProgressV1 to RespProgressSimple.
-func (p *ProgressV1) ToSimple() *RespProgressSimple {
-	if p == nil {
-		return nil
-	}
-	resp := &RespProgressSimple{
-		ID:         p.ID,
-		ModifyTime: formatTimestamp(p.ModifyTime),
-	}
-	if p.ProgressRate != nil {
-		resp.ProgressRate = &RespProgressRate{
-			Percent: p.ProgressRate.Percent,
-		}
-		if p.ProgressRate.Status != nil {
-			s := ProgressStatus(*p.ProgressRate.Status).String()
-			if s != "" {
-				resp.ProgressRate.Status = &s
-			}
-		}
-	}
-	if p.Content != nil {
-		resp.Content = p.Content.ToV2().ToSemiPlain()
-	}
-	return resp
-}
-
-// ToSimple converts Progress to RespProgressSimple.
-func (p *Progress) ToSimple() *RespProgressSimple {
-	if p == nil {
-		return nil
-	}
-	createTime := formatTimestamp(p.CreateTime)
-	resp := &RespProgressSimple{
-		ID:         p.ID,
-		ModifyTime: formatTimestamp(p.UpdateTime),
-		CreateTime: &createTime,
-	}
-	if p.ProgressRate != nil {
-		resp.ProgressRate = &RespProgressRate{
-			Percent: p.ProgressRate.ProgressPercent,
-		}
-		if p.ProgressRate.ProgressStatus != nil {
-			s := ProgressStatus(*p.ProgressRate.ProgressStatus).String()
-			if s != "" {
-				resp.ProgressRate.Status = &s
-			}
-		}
-	}
-	resp.Content = p.Content.ToSemiPlain()
-	return resp
-}

shortcuts/okr/okr_cycle_detail.go

@@ -26,7 +26,6 @@ var OKRCycleDetail = common.Shortcut{
 	HasFormat:   true,
 	Flags: []common.Flag{
 		{Name: "cycle-id", Desc: "OKR cycle id (int64)", Required: true},
-		{Name: "style", Default: "simple", Desc: "output style: simple (semi-plain text JSON) | richtext (ContentBlock JSON)", Enum: []string{"simple", "richtext"}},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		cycleID := runtime.Str("cycle-id")
@@ -36,10 +35,6 @@ var OKRCycleDetail = common.Shortcut{
 		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")
 		}
-		style := runtime.Str("style")
-		if style != "simple" && style != "richtext" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--style must be one of: simple | richtext").WithParam("--style")
-		}
 		return nil
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
@@ -55,7 +50,6 @@ var OKRCycleDetail = common.Shortcut{
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		cycleID := runtime.Str("cycle-id")
-		style := runtime.Str("style")
 
 		// Paginate objectives under the cycle.
 		queryParams := map[string]interface{}{"page_size": "100"}
@@ -102,106 +96,85 @@ var OKRCycleDetail = common.Shortcut{
 		}
 
 		// For each objective, paginate key results and convert to response format.
-		if style == "simple" {
-			respObjectives := make([]*RespObjectiveSimple, 0, len(objectives))
-			for i := range objectives {
+		respObjectives := make([]*RespObjective, 0, len(objectives))
+		for i := range objectives {
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+			obj := &objectives[i]
+
+			krQuery := map[string]interface{}{"page_size": "100"}
+
+			var keyResults []KeyResult
+			krPage := 0
+			for {
 				if err := ctx.Err(); err != nil {
 					return err
 				}
-				obj := &objectives[i]
+				if krPage > 0 {
+					select {
+					case <-ctx.Done():
+						return ctx.Err()
+					case <-time.After(500 * time.Millisecond):
+					}
+				}
+				krPage++
 
-				keyResults, err := fetchKeyResults(ctx, runtime, obj.ID)
+				path := fmt.Sprintf("/open-apis/okr/v2/objectives/%s/key_results", obj.ID)
+				data, err := runtime.CallAPITyped("GET", path, krQuery, nil)
 				if err != nil {
 					return err
 				}
 
-				respObj := obj.ToSimple()
-				if respObj == nil {
-					continue
-				}
-				respKRs := make([]RespKeyResultSimple, 0, len(keyResults))
-				for j := range keyResults {
-					if r := keyResults[j].ToSimple(); r != nil {
-						respKRs = append(respKRs, *r)
+				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)
 				}
-				respObj.KeyResults = respKRs
-				respObjectives = append(respObjectives, respObj)
+
+				hasMore, pageToken := common.PaginationMeta(data)
+				if !hasMore || pageToken == "" {
+					break
+				}
+				krQuery["page_token"] = pageToken
 			}
 
-			result := map[string]interface{}{
-				"cycle_id":   cycleID,
-				"objectives": respObjectives,
-				"total":      len(respObjectives),
-				"style":      style,
+			respObj := obj.ToResp()
+			if respObj == nil {
+				continue
 			}
-
-			runtime.OutFormat(result, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "Cycle %s: %d objective(s) (style: %s)\n", cycleID, len(respObjectives), style)
-				for _, o := range respObjectives {
-					contentText := ""
-					if o.Content != nil {
-						contentText = o.Content.Text
-					}
-					notesText := ""
-					if o.Notes != nil {
-						notesText = o.Notes.Text
-					}
-					fmt.Fprintf(w, "Objective [%s]: %s \n Notes: %s \n score=%.2f weight=%.2f\n", o.ID, contentText, notesText, ptrFloat64(o.Score), ptrFloat64(o.Weight))
-					for _, kr := range o.KeyResults {
-						krText := ""
-						if kr.Content != nil {
-							krText = kr.Content.Text
-						}
-						fmt.Fprintf(w, "  - KR [%s]: %s \n score=%.2f weight=%.2f\n", kr.ID, krText, ptrFloat64(kr.Score), ptrFloat64(kr.Weight))
-					}
+			respKRs := make([]RespKeyResult, 0, len(keyResults))
+			for j := range keyResults {
+				if r := keyResults[j].ToResp(); r != nil {
+					respKRs = append(respKRs, *r)
 				}
-			})
-		} else {
-			// richtext mode
-			respObjectives := make([]*RespObjective, 0, len(objectives))
-			for i := range objectives {
-				if err := ctx.Err(); err != nil {
-					return err
-				}
-				obj := &objectives[i]
-
-				keyResults, err := fetchKeyResults(ctx, runtime, obj.ID)
-				if err != nil {
-					return err
-				}
-
-				respObj := obj.ToResp()
-				if respObj == nil {
-					continue
-				}
-				respKRs := make([]RespKeyResult, 0, len(keyResults))
-				for j := range keyResults {
-					if r := keyResults[j].ToResp(); r != nil {
-						respKRs = append(respKRs, *r)
-					}
-				}
-				respObj.KeyResults = respKRs
-				respObjectives = append(respObjectives, respObj)
 			}
-
-			result := map[string]interface{}{
-				"cycle_id":   cycleID,
-				"objectives": respObjectives,
-				"total":      len(respObjectives),
-				"style":      style,
-			}
-
-			runtime.OutFormat(result, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "Cycle %s: %d objective(s) (style: %s)\n", cycleID, len(respObjectives), style)
-				for _, o := range respObjectives {
-					fmt.Fprintf(w, "Objective [%s]: %s \n Notes: %s \n score=%.2f weight=%.2f\n", o.ID, ptrStr(o.Content), ptrStr(o.Notes), ptrFloat64(o.Score), ptrFloat64(o.Weight))
-					for _, kr := range o.KeyResults {
-						fmt.Fprintf(w, "  - KR [%s]: %s \n score=%.2f weight=%.2f\n", kr.ID, ptrStr(kr.Content), ptrFloat64(kr.Score), ptrFloat64(kr.Weight))
-					}
-				}
-			})
+			respObj.KeyResults = respKRs
+			respObjectives = append(respObjectives, respObj)
 		}
+
+		result := map[string]interface{}{
+			"cycle_id":   cycleID,
+			"objectives": respObjectives,
+			"total":      len(respObjectives),
+		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Cycle %s: %d objective(s)\n", cycleID, len(respObjectives))
+			for _, o := range respObjectives {
+				fmt.Fprintf(w, "Objective [%s]: %s \n Notes: %s \n score=%.2f weight=%.2f\n", o.ID, ptrStr(o.Content), ptrStr(o.Notes), ptrFloat64(o.Score), ptrFloat64(o.Weight))
+				for _, kr := range o.KeyResults {
+					fmt.Fprintf(w, "  - KR [%s]: %s \n score=%.2f weight=%.2f\n", kr.ID, ptrStr(kr.Content), ptrFloat64(kr.Score), ptrFloat64(kr.Weight))
+				}
+			}
+		})
 		return nil
 	},
 }

shortcuts/okr/okr_cycle_list.go

@@ -46,38 +46,12 @@ func cycleOverlaps(cycle *Cycle, rangeStart, rangeEnd time.Time) bool {
 	if err1 != nil || err2 != nil {
 		return false
 	}
-	cycleStart := time.UnixMilli(startMs).UTC()
-	cycleEnd := time.UnixMilli(endMs).UTC()
+	cycleStart := time.UnixMilli(startMs)
+	cycleEnd := time.UnixMilli(endMs)
 	// Two ranges overlap iff one starts before the other ends
 	return !cycleStart.After(rangeEnd) && !cycleEnd.Before(rangeStart)
 }
 
-// isCurrentActiveCycle checks whether a cycle is currently active:
-// - current time is within the cycle's start and end time
-// - cycle status is default (0) or normal (1)
-func isCurrentActiveCycle(cycle *Cycle, now time.Time) bool {
-	startMs, err1 := strconv.ParseInt(cycle.StartTime, 10, 64)
-	endMs, err2 := strconv.ParseInt(cycle.EndTime, 10, 64)
-	if err1 != nil || err2 != nil {
-		return false
-	}
-	cycleStart := time.UnixMilli(startMs).UTC()
-	cycleEnd := time.UnixMilli(endMs).UTC()
-	nowUTC := now.UTC()
-
-	// Check time range: now must be >= start and <= end
-	if nowUTC.Before(cycleStart) || nowUTC.After(cycleEnd) {
-		return false
-	}
-
-	// Check status: must be default or normal
-	if cycle.CycleStatus == nil {
-		return false
-	}
-	status := *cycle.CycleStatus
-	return status == CycleStatusDefault || status == CycleStatusNormal
-}
-
 var OKRListCycles = common.Shortcut{
 	Service:     "okr",
 	Command:     "+cycle-list",
@@ -201,30 +175,14 @@ var OKRListCycles = common.Shortcut{
 			respCycles = append(respCycles, filtered[i].ToResp())
 		}
 
-		// Filter current active cycles
-		now := time.Now()
-		currentActiveCycles := make([]*RespCycle, 0)
-		for i := range filtered {
-			if isCurrentActiveCycle(&filtered[i], now) {
-				currentActiveCycles = append(currentActiveCycles, filtered[i].ToResp())
-			}
-		}
-
 		runtime.OutFormat(map[string]interface{}{
-			"cycles":                respCycles,
-			"total":                 len(respCycles),
-			"current_active_cycles": currentActiveCycles,
+			"cycles": respCycles,
+			"total":  len(respCycles),
 		}, nil, func(w io.Writer) {
 			fmt.Fprintf(w, "Found %d cycle(s)\n", len(respCycles))
 			for _, c := range respCycles {
 				fmt.Fprintf(w, "  [%s] %s ~ %s (status: %s)\n", c.ID, c.StartTime, c.EndTime, ptrStr(c.CycleStatus))
 			}
-			if len(currentActiveCycles) > 0 {
-				fmt.Fprintf(w, "\nCurrent active cycle(s):\n")
-				for _, c := range currentActiveCycles {
-					fmt.Fprintf(w, "  [%s] %s ~ %s\n", c.ID, c.StartTime, c.EndTime)
-				}
-			}
 		})
 		return nil
 	},

shortcuts/okr/okr_cycle_list_test.go

@@ -5,10 +5,8 @@ package okr
 
 import (
 	"bytes"
-	"strconv"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/spf13/cobra"
 
@@ -262,156 +260,11 @@ func TestCycleListExecute_NoCycles(t *testing.T) {
 	if len(cycles) != 0 {
 		t.Fatalf("cycles = %v, want empty", cycles)
 	}
-	// Assert current_active_cycles field exists and is a slice
-	rawCurrentActive, ok := data["current_active_cycles"]
-	if !ok {
-		t.Fatal("current_active_cycles field is missing from response")
-	}
-	currentActive, ok := rawCurrentActive.([]interface{})
-	if !ok {
-		t.Fatalf("current_active_cycles is not a slice, got %T", rawCurrentActive)
-	}
-	if len(currentActive) != 0 {
-		t.Fatalf("current_active_cycles = %v, want empty", currentActive)
-	}
-}
-
-// --- isCurrentActiveCycle unit tests ---
-
-func TestIsCurrentActiveCycle(t *testing.T) {
-	t.Parallel()
-	now := time.Date(2026, 6, 29, 12, 0, 0, 0, time.UTC)
-
-	tests := []struct {
-		name     string
-		cycle    *Cycle
-		expected bool
-	}{
-		{
-			name: "active cycle with normal status",
-			cycle: &Cycle{
-				ID:          "c1",
-				StartTime:   "1767225600000", // 2026-01-01
-				EndTime:     "1798761599999", // 2026-12-31 23:59:59
-				CycleStatus: CycleStatusNormal.Ptr(),
-			},
-			expected: true,
-		},
-		{
-			name: "active cycle with default status",
-			cycle: &Cycle{
-				ID:          "c2",
-				StartTime:   "1767225600000", // 2026-01-01
-				EndTime:     "1798761599999", // 2026-12-31
-				CycleStatus: CycleStatusDefault.Ptr(),
-			},
-			expected: true,
-		},
-		{
-			name: "cycle with invalid status",
-			cycle: &Cycle{
-				ID:          "c3",
-				StartTime:   "1767225600000", // 2026-01-01
-				EndTime:     "1798761599999", // 2026-12-31
-				CycleStatus: CycleStatusInvalid.Ptr(),
-			},
-			expected: false,
-		},
-		{
-			name: "cycle with hidden status",
-			cycle: &Cycle{
-				ID:          "c4",
-				StartTime:   "1767225600000", // 2026-01-01
-				EndTime:     "1798761599999", // 2026-12-31
-				CycleStatus: CycleStatusHidden.Ptr(),
-			},
-			expected: false,
-		},
-		{
-			name: "past cycle",
-			cycle: &Cycle{
-				ID:          "c5",
-				StartTime:   "1704067200000", // 2024-01-01
-				EndTime:     "1719791999999", // 2024-06-30
-				CycleStatus: CycleStatusNormal.Ptr(),
-			},
-			expected: false,
-		},
-		{
-			name: "future cycle",
-			cycle: &Cycle{
-				ID:          "c6",
-				StartTime:   "1830297600000", // 2028-01-01
-				EndTime:     "1861833599999", // 2028-12-31
-				CycleStatus: CycleStatusNormal.Ptr(),
-			},
-			expected: false,
-		},
-		{
-			name: "nil cycle status",
-			cycle: &Cycle{
-				ID:          "c7",
-				StartTime:   "1767225600000", // 2026-01-01
-				EndTime:     "1798761599999", // 2026-12-31
-				CycleStatus: nil,
-			},
-			expected: false,
-		},
-		{
-			name: "invalid start time",
-			cycle: &Cycle{
-				ID:          "c8",
-				StartTime:   "invalid",
-				EndTime:     "1798761599999", // 2026-12-31
-				CycleStatus: CycleStatusNormal.Ptr(),
-			},
-			expected: false,
-		},
-		{
-			name: "exact start time boundary",
-			cycle: &Cycle{
-				ID:          "c9",
-				StartTime:   "1782734400000", // 2026-06-29 12:00:00 UTC
-				EndTime:     "1798761599000", // 2026-12-31 23:59:59 UTC
-				CycleStatus: CycleStatusNormal.Ptr(),
-			},
-			expected: true,
-		},
-		{
-			name: "exact end time boundary",
-			cycle: &Cycle{
-				ID:          "c10",
-				StartTime:   "1767225600000", // 2026-01-01 00:00:00 UTC
-				EndTime:     "1782734400000", // 2026-06-29 12:00:00 UTC
-				CycleStatus: CycleStatusNormal.Ptr(),
-			},
-			expected: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isCurrentActiveCycle(tt.cycle, now)
-			if result != tt.expected {
-				t.Fatalf("isCurrentActiveCycle() = %v, want %v", result, tt.expected)
-			}
-		})
-	}
 }
 
 func TestCycleListExecute_WithCycles(t *testing.T) {
 	t.Parallel()
 	f, stdout, _, reg := cmdutil.TestFactory(t, cycleListTestConfig(t))
-
-	// Calculate timestamps relative to now to avoid test expiration
-	now := time.Now().UTC()
-	// Active cycle: 6 months before to 6 months after now
-	activeStartMs := now.AddDate(0, -6, 0).UnixMilli()
-	activeEndMs := now.AddDate(0, 6, 0).UnixMilli()
-	// Past cycle: 2 years before to 1.5 years before now
-	pastStartMs := now.AddDate(-2, 0, 0).UnixMilli()
-	pastEndMs := now.AddDate(-1, -6, 0).UnixMilli()
-
 	reg.Register(&httpmock.Stub{
 		Method: "GET",
 		URL:    "/open-apis/okr/v2/cycles",
@@ -421,19 +274,19 @@ func TestCycleListExecute_WithCycles(t *testing.T) {
 			"data": map[string]interface{}{
 				"items": []interface{}{
 					map[string]interface{}{
-						"id":              "cycle-active",
-						"start_time":      strconv.FormatInt(activeStartMs, 10),
-						"end_time":        strconv.FormatInt(activeEndMs, 10),
-						"cycle_status":    1, // normal
+						"id":              "cycle-1",
+						"start_time":      "1735689600000",
+						"end_time":        "1751318400000",
+						"cycle_status":    1,
 						"owner":           map[string]interface{}{"owner_type": "user", "user_id": "ou-1"},
 						"tenant_cycle_id": "tc-1",
 						"score":           0.75,
 					},
 					map[string]interface{}{
-						"id":              "cycle-past",
-						"start_time":      strconv.FormatInt(pastStartMs, 10),
-						"end_time":        strconv.FormatInt(pastEndMs, 10),
-						"cycle_status":    2, // invalid
+						"id":              "cycle-2",
+						"start_time":      "1704067200000",
+						"end_time":        "1719792000000",
+						"cycle_status":    2,
 						"owner":           map[string]interface{}{"owner_type": "user", "user_id": "ou-1"},
 						"tenant_cycle_id": "tc-2",
 						"score":           0.5,
@@ -458,46 +311,6 @@ func TestCycleListExecute_WithCycles(t *testing.T) {
 	if int(total) != 2 {
 		t.Fatalf("total = %v, want 2", total)
 	}
-
-	// Check current_active_cycles - should only contain cycle-active
-	rawCurrentActive, ok := data["current_active_cycles"]
-	if !ok {
-		t.Fatal("current_active_cycles field is missing from response")
-	}
-	currentActive, ok := rawCurrentActive.([]interface{})
-	if !ok {
-		t.Fatalf("current_active_cycles is not a slice, got %T", rawCurrentActive)
-	}
-	if len(currentActive) != 1 {
-		t.Fatalf("current_active_cycles count = %d, want 1", len(currentActive))
-	}
-	activeCycle, ok := currentActive[0].(map[string]interface{})
-	if !ok {
-		t.Fatalf("current_active_cycles[0] is not a map, got %T", currentActive[0])
-	}
-	if activeCycle["id"] != "cycle-active" {
-		t.Fatalf("current_active_cycles[0].id = %v, want cycle-active", activeCycle["id"])
-	}
-
-	// Verify removed fields are not present in the response
-	for _, c := range cycles {
-		cycleMap, _ := c.(map[string]interface{})
-		if _, ok := cycleMap["create_time"]; ok {
-			t.Fatal("create_time should not be present in response")
-		}
-		if _, ok := cycleMap["update_time"]; ok {
-			t.Fatal("update_time should not be present in response")
-		}
-		if _, ok := cycleMap["tenant_cycle_id"]; ok {
-			t.Fatal("tenant_cycle_id should not be present in response")
-		}
-		if _, ok := cycleMap["owner"]; ok {
-			t.Fatal("owner should not be present in response")
-		}
-		if _, ok := cycleMap["score"]; ok {
-			t.Fatal("score should not be present in response")
-		}
-	}
 }
 
 func TestCycleListExecute_WithTimeRangeFilter(t *testing.T) {

shortcuts/okr/okr_openapi.go

@@ -5,9 +5,7 @@ package okr
 
 import (
 	"encoding/json"
-	"regexp"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -263,9 +261,14 @@ func (c *Cycle) ToResp() *RespCycle {
 		return nil
 	}
 	resp := &RespCycle{
-		ID:        c.ID,
-		StartTime: formatTimestamp(c.StartTime),
-		EndTime:   formatTimestamp(c.EndTime),
+		ID:            c.ID,
+		CreateTime:    formatTimestamp(c.CreateTime),
+		UpdateTime:    formatTimestamp(c.UpdateTime),
+		TenantCycleID: c.TenantCycleID,
+		Owner:         *c.Owner.ToResp(),
+		StartTime:     formatTimestamp(c.StartTime),
+		EndTime:       formatTimestamp(c.EndTime),
+		Score:         c.Score,
 	}
 	if c.CycleStatus != nil {
 		s := c.CycleStatus.ToString()
@@ -730,131 +733,6 @@ func (p *ContentPersonV1) ToV2() *ContentMention {
 	}
 }
 
-// ========== SemiPlainContent (半纯文本格式) ==========
-
-// Regex patterns for semi-plain text processing (pre-compiled for performance).
-var (
-	placeholderRE = regexp.MustCompile(`\s*@\{[^}]+\}\s*`)
-	multiSpaceRE  = regexp.MustCompile(`\s+`)
-)
-
-// SemiPlainDoc represents a document link in semi-plain content.
-type SemiPlainDoc struct {
-	Title string `json:"title"`
-	URL   string `json:"url"`
-}
-
-// SemiPlainContent is a simplified, lossy representation of ContentBlock.
-// It contains plain text, mentions, docs, and images without rich formatting or position info.
-type SemiPlainContent struct {
-	Text    string         `json:"text"`
-	Mention []string       `json:"mention,omitempty"`
-	Docs    []SemiPlainDoc `json:"docs,omitempty"`
-	Images  []string       `json:"images,omitempty"`
-}
-
-// ToSemiPlain converts ContentBlock to SemiPlainContent (lossy conversion).
-// Position information and formatting are discarded; only text, mentions, docs, and images are extracted.
-func (c *ContentBlock) ToSemiPlain() *SemiPlainContent {
-	if c == nil {
-		return nil
-	}
-	result := &SemiPlainContent{}
-	var textParts []string
-
-	for _, block := range c.Blocks {
-		if block.Paragraph != nil {
-			for _, elem := range block.Paragraph.Elements {
-				switch {
-				case elem.TextRun != nil && elem.TextRun.Text != nil:
-					textParts = append(textParts, *elem.TextRun.Text)
-				case elem.Mention != nil && elem.Mention.UserID != nil:
-					textParts = append(textParts, " @{"+*elem.Mention.UserID+"} ")
-					result.Mention = append(result.Mention, *elem.Mention.UserID)
-				case elem.DocsLink != nil:
-					doc := SemiPlainDoc{}
-					if elem.DocsLink.Title != nil {
-						doc.Title = *elem.DocsLink.Title
-					}
-					if elem.DocsLink.URL != nil {
-						doc.URL = *elem.DocsLink.URL
-					}
-					result.Docs = append(result.Docs, doc)
-				}
-			}
-		}
-		if block.Gallery != nil {
-			for _, img := range block.Gallery.Images {
-				if img.Src != nil {
-					result.Images = append(result.Images, *img.Src)
-				}
-			}
-		}
-	}
-
-	result.Text = strings.Join(textParts, "")
-	return result
-}
-
-// ToContentBlock converts SemiPlainContent to ContentBlock.
-// Text and mentions are placed in a single paragraph (text first, then mentions).
-// Docs and images are NOT converted (input semi-plain format only supports text+mention).
-func (s *SemiPlainContent) ToContentBlock() *ContentBlock {
-	if s == nil {
-		return nil
-	}
-	elements := make([]ContentParagraphElement, 0, len(s.Mention)+1)
-
-	// Strip @{userID} placeholders from text to avoid duplicate mentions
-	// (these placeholders are only for readability in the output format)
-	strippedText := placeholderRE.ReplaceAllString(s.Text, " ")
-	// Collapse multiple spaces and trim
-	strippedText = multiSpaceRE.ReplaceAllString(strippedText, " ")
-	strippedText = strings.TrimSpace(strippedText)
-
-	// Add text element if stripped text is not empty
-	if strippedText != "" {
-		text := strippedText
-		elements = append(elements, ContentParagraphElement{
-			ParagraphElementType: ParagraphElementTypeTextRun.Ptr(),
-			TextRun: &ContentTextRun{
-				Text: &text,
-			},
-		})
-	}
-
-	// Add mention elements
-	for _, mention := range s.Mention {
-		m := mention
-		elements = append(elements, ContentParagraphElement{
-			ParagraphElementType: ParagraphElementTypeMention.Ptr(),
-			Mention: &ContentMention{
-				UserID: &m,
-			},
-		})
-	}
-
-	return &ContentBlock{
-		Blocks: []ContentBlockElement{
-			{
-				BlockElementType: BlockElementTypeParagraph.Ptr(),
-				Paragraph: &ContentParagraph{
-					Elements: elements,
-				},
-			},
-		},
-	}
-}
-
-// BuildContentBlock converts text and mentions to a ContentBlock.
-// This is a convenience wrapper around SemiPlainContent.ToContentBlock().
-func BuildContentBlock(text string, mentions []string) *ContentBlock {
-	return (&SemiPlainContent{
-		Text:    text,
-		Mention: mentions,
-	}).ToContentBlock()
-}
-
 // ProgressRateV1 进度率
 type ProgressRateV1 struct {
 	Percent *float64 `json:"percent,omitempty"`

shortcuts/okr/okr_openapi_test.go

@@ -57,9 +57,7 @@ func TestToRespMethods(t *testing.T) {
 			convey.So(resp, convey.ShouldNotBeNil)
 			convey.So(resp.ID, convey.ShouldEqual, "cycle-id")
 			convey.So(*resp.CycleStatus, convey.ShouldEqual, "normal")
-			// Verify removed fields are not present in RespCycle
-			convey.So(resp.StartTime, convey.ShouldNotBeEmpty)
-			convey.So(resp.EndTime, convey.ShouldNotBeEmpty)
+			convey.So(*resp.Score, convey.ShouldEqual, 0.75)
 		})
 
 		convey.Convey("Objective", func() {
@@ -520,449 +518,5 @@ func float64Ptr(v float64) *float64 { return &v }
 // boolPtr returns a pointer to the given bool value.
 func boolPtr(v bool) *bool { return &v }
 
-// ========== SemiPlainContent Conversion Tests ==========
-
-func TestContentBlockToSemiPlain_TextOnly(t *testing.T) {
-	t.Parallel()
-	cb := &ContentBlock{
-		Blocks: []ContentBlockElement{
-			{
-				BlockElementType: BlockElementTypeParagraph.Ptr(),
-				Paragraph: &ContentParagraph{
-					Elements: []ContentParagraphElement{
-						{
-							ParagraphElementType: ParagraphElementTypeTextRun.Ptr(),
-							TextRun: &ContentTextRun{
-								Text: strPtr("Hello world"),
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-	sp := cb.ToSemiPlain()
-	if sp == nil {
-		t.Fatal("expected non-nil SemiPlainContent")
-	}
-	if sp.Text != "Hello world" {
-		t.Fatalf("expected text 'Hello world', got '%s'", sp.Text)
-	}
-	if len(sp.Mention) != 0 {
-		t.Fatalf("expected 0 mentions, got %d", len(sp.Mention))
-	}
-	if len(sp.Docs) != 0 {
-		t.Fatalf("expected 0 docs, got %d", len(sp.Docs))
-	}
-	if len(sp.Images) != 0 {
-		t.Fatalf("expected 0 images, got %d", len(sp.Images))
-	}
-}
-
-func TestContentBlockToSemiPlain_WithMention(t *testing.T) {
-	t.Parallel()
-	cb := &ContentBlock{
-		Blocks: []ContentBlockElement{
-			{
-				BlockElementType: BlockElementTypeParagraph.Ptr(),
-				Paragraph: &ContentParagraph{
-					Elements: []ContentParagraphElement{
-						{
-							ParagraphElementType: ParagraphElementTypeTextRun.Ptr(),
-							TextRun: &ContentTextRun{
-								Text: strPtr("Hello "),
-							},
-						},
-						{
-							ParagraphElementType: ParagraphElementTypeMention.Ptr(),
-							Mention: &ContentMention{
-								UserID: strPtr("ou_123"),
-							},
-						},
-						{
-							ParagraphElementType: ParagraphElementTypeTextRun.Ptr(),
-							TextRun: &ContentTextRun{
-								Text: strPtr(", how are you?"),
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-	sp := cb.ToSemiPlain()
-	if sp == nil {
-		t.Fatal("expected non-nil SemiPlainContent")
-	}
-	// Text includes @{userID} placeholder to preserve positional context
-	if sp.Text != "Hello  @{ou_123} , how are you?" {
-		t.Fatalf("expected text 'Hello  @{ou_123} , how are you?', got '%s'", sp.Text)
-	}
-	if len(sp.Mention) != 1 || sp.Mention[0] != "ou_123" {
-		t.Fatalf("expected mention [ou_123], got %v", sp.Mention)
-	}
-}
-
-func TestContentBlockToSemiPlain_WithDocsAndImages(t *testing.T) {
-	t.Parallel()
-	cb := &ContentBlock{
-		Blocks: []ContentBlockElement{
-			{
-				BlockElementType: BlockElementTypeParagraph.Ptr(),
-				Paragraph: &ContentParagraph{
-					Elements: []ContentParagraphElement{
-						{
-							ParagraphElementType: ParagraphElementTypeTextRun.Ptr(),
-							TextRun: &ContentTextRun{
-								Text: strPtr("Check out this doc: "),
-							},
-						},
-						{
-							ParagraphElementType: ParagraphElementTypeDocsLink.Ptr(),
-							DocsLink: &ContentDocsLink{
-								Title: strPtr("Design Doc"),
-								URL:   strPtr("https://example.feishu.cn/docx/xxx"),
-							},
-						},
-					},
-				},
-			},
-			{
-				BlockElementType: BlockElementTypeGallery.Ptr(),
-				Gallery: &ContentGallery{
-					Images: []ContentImageItem{
-						{
-							Src: strPtr("https://example.com/img1.png"),
-						},
-						{
-							Src: strPtr("https://example.com/img2.png"),
-						},
-					},
-				},
-			},
-		},
-	}
-	sp := cb.ToSemiPlain()
-	if sp == nil {
-		t.Fatal("expected non-nil SemiPlainContent")
-	}
-	if sp.Text != "Check out this doc: " {
-		t.Fatalf("unexpected text: '%s'", sp.Text)
-	}
-	if len(sp.Docs) != 1 {
-		t.Fatalf("expected 1 doc, got %d", len(sp.Docs))
-	}
-	if sp.Docs[0].Title != "Design Doc" || sp.Docs[0].URL != "https://example.feishu.cn/docx/xxx" {
-		t.Fatalf("unexpected doc: %+v", sp.Docs[0])
-	}
-	if len(sp.Images) != 2 {
-		t.Fatalf("expected 2 images, got %d", len(sp.Images))
-	}
-	if sp.Images[0] != "https://example.com/img1.png" || sp.Images[1] != "https://example.com/img2.png" {
-		t.Fatalf("unexpected images: %v", sp.Images)
-	}
-}
-
-func TestContentBlockToSemiPlain_Nil(t *testing.T) {
-	t.Parallel()
-	var cb *ContentBlock
-	sp := cb.ToSemiPlain()
-	if sp != nil {
-		t.Fatal("expected nil SemiPlainContent for nil ContentBlock")
-	}
-}
-
-func TestSemiPlainContentToContentBlock_TextOnly(t *testing.T) {
-	t.Parallel()
-	sp := &SemiPlainContent{
-		Text: "Hello world",
-	}
-	cb := sp.ToContentBlock()
-	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.Fatal("expected paragraph block")
-	}
-	if block.Paragraph == nil || len(block.Paragraph.Elements) != 1 {
-		t.Fatalf("expected 1 paragraph element, got %d", len(block.Paragraph.Elements))
-	}
-	elem := block.Paragraph.Elements[0]
-	if elem.ParagraphElementType == nil || *elem.ParagraphElementType != ParagraphElementTypeTextRun {
-		t.Fatal("expected textRun element")
-	}
-	if elem.TextRun == nil || elem.TextRun.Text == nil || *elem.TextRun.Text != "Hello world" {
-		t.Fatalf("unexpected text: %v", elem.TextRun)
-	}
-}
-
-func TestSemiPlainContentToContentBlock_WithMentions(t *testing.T) {
-	t.Parallel()
-	sp := &SemiPlainContent{
-		Text:    "Please review",
-		Mention: []string{"ou_123", "ou_456"},
-	}
-	cb := sp.ToContentBlock()
-	if cb == nil {
-		t.Fatal("expected non-nil ContentBlock")
-	}
-	if len(cb.Blocks) != 1 {
-		t.Fatalf("expected 1 block, got %d", len(cb.Blocks))
-	}
-	elems := cb.Blocks[0].Paragraph.Elements
-	if len(elems) != 3 {
-		t.Fatalf("expected 3 elements (1 text + 2 mentions), got %d", len(elems))
-	}
-	if *elems[0].ParagraphElementType != ParagraphElementTypeTextRun || *elems[0].TextRun.Text != "Please review" {
-		t.Fatal("unexpected first element")
-	}
-	if *elems[1].ParagraphElementType != ParagraphElementTypeMention || *elems[1].Mention.UserID != "ou_123" {
-		t.Fatal("unexpected second element")
-	}
-	if *elems[2].ParagraphElementType != ParagraphElementTypeMention || *elems[2].Mention.UserID != "ou_456" {
-		t.Fatal("unexpected third element")
-	}
-}
-
-func TestSemiPlainContentToContentBlock_EmptyText(t *testing.T) {
-	t.Parallel()
-	sp := &SemiPlainContent{
-		Text:    "   ",
-		Mention: []string{"ou_123"},
-	}
-	cb := sp.ToContentBlock()
-	if cb == nil {
-		t.Fatal("expected non-nil ContentBlock")
-	}
-	elems := cb.Blocks[0].Paragraph.Elements
-	// Empty text should be skipped, only mention remains
-	if len(elems) != 1 {
-		t.Fatalf("expected 1 element (mention only), got %d", len(elems))
-	}
-	if *elems[0].ParagraphElementType != ParagraphElementTypeMention {
-		t.Fatal("expected mention element")
-	}
-}
-
-func TestSemiPlainContentToContentBlock_DocsImagesIgnored(t *testing.T) {
-	t.Parallel()
-	sp := &SemiPlainContent{
-		Text:    "Test",
-		Mention: []string{"ou_123"},
-		Docs:    []SemiPlainDoc{{Title: "Doc", URL: "https://..."}},
-		Images:  []string{"https://img.png"},
-	}
-	cb := sp.ToContentBlock()
-	if cb == nil {
-		t.Fatal("expected non-nil ContentBlock")
-	}
-	elems := cb.Blocks[0].Paragraph.Elements
-	// Docs and images are ignored in input conversion
-	if len(elems) != 2 {
-		t.Fatalf("expected 2 elements (text + mention), got %d", len(elems))
-	}
-}
-
-func TestSemiPlainContentToContentBlock_PlaceholderStripping(t *testing.T) {
-	t.Parallel()
-	// Simulate round-trip: output format has @{userID} in text,
-	// input conversion should strip them to avoid duplicate mentions
-	sp := &SemiPlainContent{
-		Text:    "任务一 @{ou_zhangsan} ，任务二 @{ou_lisi} ",
-		Mention: []string{"ou_zhangsan", "ou_lisi"},
-	}
-	cb := sp.ToContentBlock()
-	if cb == nil {
-		t.Fatal("expected non-nil ContentBlock")
-	}
-	elems := cb.Blocks[0].Paragraph.Elements
-	// Should have 3 elements: 1 text (stripped) + 2 mentions
-	if len(elems) != 3 {
-		t.Fatalf("expected 3 elements (1 text + 2 mentions), got %d", len(elems))
-	}
-	// Text should have placeholders stripped
-	if *elems[0].ParagraphElementType != ParagraphElementTypeTextRun {
-		t.Fatal("expected first element to be textRun")
-	}
-	// Note: space before comma is preserved from the placeholder's trailing space
-	expectedText := "任务一 ，任务二"
-	if *elems[0].TextRun.Text != expectedText {
-		t.Fatalf("expected stripped text '%s', got '%s'", expectedText, *elems[0].TextRun.Text)
-	}
-	// Mentions should be preserved as separate elements
-	if *elems[1].ParagraphElementType != ParagraphElementTypeMention || *elems[1].Mention.UserID != "ou_zhangsan" {
-		t.Fatal("unexpected second element")
-	}
-	if *elems[2].ParagraphElementType != ParagraphElementTypeMention || *elems[2].Mention.UserID != "ou_lisi" {
-		t.Fatal("unexpected third element")
-	}
-}
-
-func TestSemiPlainContentToContentBlock_OnlyPlaceholders(t *testing.T) {
-	t.Parallel()
-	// Text that is only placeholders should result in no text element
-	sp := &SemiPlainContent{
-		Text:    " @{ou_123}  @{ou_456} ",
-		Mention: []string{"ou_123", "ou_456"},
-	}
-	cb := sp.ToContentBlock()
-	if cb == nil {
-		t.Fatal("expected non-nil ContentBlock")
-	}
-	elems := cb.Blocks[0].Paragraph.Elements
-	// Should have only 2 mention elements, no text element
-	if len(elems) != 2 {
-		t.Fatalf("expected 2 elements (mentions only), got %d", len(elems))
-	}
-	if *elems[0].ParagraphElementType != ParagraphElementTypeMention {
-		t.Fatal("expected first element to be mention")
-	}
-	if *elems[1].ParagraphElementType != ParagraphElementTypeMention {
-		t.Fatal("expected second element to be mention")
-	}
-}
-
-func TestSemiPlainContentToContentBlock_Nil(t *testing.T) {
-	t.Parallel()
-	var sp *SemiPlainContent
-	cb := sp.ToContentBlock()
-	if cb != nil {
-		t.Fatal("expected nil ContentBlock for nil SemiPlainContent")
-	}
-}
-
-func TestBuildContentBlock_Conversion(t *testing.T) {
-	t.Parallel()
-	cb := BuildContentBlock("Test text", []string{"ou_123", "ou_456"})
-	if cb == nil {
-		t.Fatal("expected non-nil ContentBlock")
-	}
-	elems := cb.Blocks[0].Paragraph.Elements
-	if len(elems) != 3 {
-		t.Fatalf("expected 3 elements, got %d", len(elems))
-	}
-	if *elems[0].TextRun.Text != "Test text" {
-		t.Fatalf("unexpected text: %s", *elems[0].TextRun.Text)
-	}
-	if *elems[1].Mention.UserID != "ou_123" {
-		t.Fatalf("unexpected mention: %s", *elems[1].Mention.UserID)
-	}
-	if *elems[2].Mention.UserID != "ou_456" {
-		t.Fatalf("unexpected mention: %s", *elems[2].Mention.UserID)
-	}
-}
-
-func TestToSimpleMethods(t *testing.T) {
-	t.Parallel()
-
-	// Test Objective.ToSimple()
-	text := "Objective text"
-	obj := &Objective{
-		ID:       "obj-1",
-		Content:  BuildContentBlock(text, []string{"ou_123"}),
-		Notes:    BuildContentBlock("Note text", nil),
-		Owner:    Owner{OwnerType: OwnerTypeUser, UserID: strPtr("ou_owner")},
-		CycleID:  "cycle-1",
-		Score:    float64Ptr(0.7),
-		Weight:   float64Ptr(0.5),
-		Deadline: strPtr("1735776000000"),
-	}
-	simpleObj := obj.ToSimple()
-	if simpleObj == nil {
-		t.Fatal("expected non-nil RespObjectiveSimple")
-	}
-	if simpleObj.ID != "obj-1" {
-		t.Fatalf("expected ID obj-1, got %s", simpleObj.ID)
-	}
-	// Text includes @{userID} placeholder for positional context
-	expectedContentText := "Objective text @{ou_123} "
-	if simpleObj.Content == nil || simpleObj.Content.Text != expectedContentText {
-		t.Fatalf("unexpected content text: expected '%s', got '%s'", expectedContentText, simpleObj.Content.Text)
-	}
-	if simpleObj.Notes == nil || simpleObj.Notes.Text != "Note text" {
-		t.Fatalf("unexpected notes: %+v", simpleObj.Notes)
-	}
-	if simpleObj.Score == nil || *simpleObj.Score != 0.7 {
-		t.Fatalf("unexpected score: %v", simpleObj.Score)
-	}
-	if len(simpleObj.Content.Mention) != 1 || simpleObj.Content.Mention[0] != "ou_123" {
-		t.Fatalf("unexpected mentions: %v", simpleObj.Content.Mention)
-	}
-
-	// Test KeyResult.ToSimple()
-	kr := &KeyResult{
-		ID:          "kr-1",
-		ObjectiveID: "obj-1",
-		Content:     BuildContentBlock("KR text", nil),
-		Owner:       Owner{OwnerType: OwnerTypeUser, UserID: strPtr("ou_kr_owner")},
-		Score:       float64Ptr(0.5),
-	}
-	simpleKR := kr.ToSimple()
-	if simpleKR == nil {
-		t.Fatal("expected non-nil RespKeyResultSimple")
-	}
-	if simpleKR.Content == nil || simpleKR.Content.Text != "KR text" {
-		t.Fatalf("unexpected KR content: %+v", simpleKR.Content)
-	}
-
-	// Test ProgressV1.ToSimple()
-	progress := &ProgressV1{
-		ID:         "prog-1",
-		ModifyTime: "1735776000000",
-		Content:    BuildContentBlock("Progress text", []string{"ou_mention"}).ToV1(),
-	}
-	simpleProgress := progress.ToSimple()
-	if simpleProgress == nil {
-		t.Fatal("expected non-nil RespProgressSimple")
-	}
-	// Text includes @{userID} placeholder for positional context
-	expectedProgressText := "Progress text @{ou_mention} "
-	if simpleProgress.Content == nil || simpleProgress.Content.Text != expectedProgressText {
-		t.Fatalf("unexpected progress text: expected '%s', got '%s'", expectedProgressText, simpleProgress.Content.Text)
-	}
-	if len(simpleProgress.Content.Mention) != 1 || simpleProgress.Content.Mention[0] != "ou_mention" {
-		t.Fatalf("unexpected progress mentions: %v", simpleProgress.Content.Mention)
-	}
-
-	// Test Progress.ToSimple() (V2 progress record)
-	progressV2 := &Progress{
-		ID:         "prog-v2-1",
-		CreateTime: "1735689600000",
-		UpdateTime: "1735776000000",
-		Content:    BuildContentBlock("V2 progress text", []string{"ou_v2_mention"}),
-		ProgressRate: &ProgressRate{
-			ProgressPercent: float64Ptr(80.0),
-			ProgressStatus:  int32Ptr(int32(ProgressStatusDone)),
-		},
-	}
-	simpleProgressV2 := progressV2.ToSimple()
-	if simpleProgressV2 == nil {
-		t.Fatal("expected non-nil RespProgressSimple for Progress V2")
-	}
-	if simpleProgressV2.ID != "prog-v2-1" {
-		t.Fatalf("expected ID prog-v2-1, got %s", simpleProgressV2.ID)
-	}
-	if simpleProgressV2.CreateTime == nil || *simpleProgressV2.CreateTime == "" {
-		t.Fatal("expected non-empty CreateTime for Progress V2")
-	}
-	expectedV2Text := "V2 progress text @{ou_v2_mention} "
-	if simpleProgressV2.Content == nil || simpleProgressV2.Content.Text != expectedV2Text {
-		t.Fatalf("unexpected V2 progress text: expected '%s', got '%s'", expectedV2Text, simpleProgressV2.Content.Text)
-	}
-	if simpleProgressV2.ProgressRate == nil || simpleProgressV2.ProgressRate.Status == nil || *simpleProgressV2.ProgressRate.Status != "done" {
-		t.Fatalf("expected progress status 'done', got %+v", simpleProgressV2.ProgressRate)
-	}
-	if simpleProgressV2.ProgressRate.Percent == nil || *simpleProgressV2.ProgressRate.Percent != 80.0 {
-		t.Fatalf("expected progress percent 80.0, got %v", simpleProgressV2.ProgressRate.Percent)
-	}
-	if len(simpleProgressV2.Content.Mention) != 1 || simpleProgressV2.Content.Mention[0] != "ou_v2_mention" {
-		t.Fatalf("unexpected V2 progress mentions: %v", simpleProgressV2.Content.Mention)
-	}
-}
-
 // listTypePtr returns a pointer to the given ListType value.
 func listTypePtr(v ListType) *ListType { return &v }

shortcuts/okr/okr_patch.go

@@ -1,311 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package okr
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// patchParams holds the parsed parameters for the patch operation.
-type patchParams struct {
-	Level      string
-	TargetID   string
-	Style      string
-	Content    *ContentBlock
-	Notes      *ContentBlock
-	Score      *float64
-	Deadline   *string
-	UserIDType string
-}
-
-// parsePatchParams parses and validates flags from runtime into request-ready parameters.
-func parsePatchParams(runtime *common.RuntimeContext) (*patchParams, error) {
-	p := &patchParams{
-		Level:      runtime.Str("level"),
-		TargetID:   runtime.Str("target-id"),
-		Style:      runtime.Str("style"),
-		UserIDType: runtime.Str("user-id-type"),
-	}
-
-	hasField := false
-
-	// Parse content if provided
-	if contentStr := runtime.Str("content"); contentStr != "" {
-		hasField = true
-		if err := common.RejectDangerousCharsTyped("--content", contentStr); err != nil {
-			return nil, err
-		}
-		if p.Style == "simple" {
-			var sp SemiPlainContent
-			if err := json.Unmarshal([]byte(contentStr), &sp); err != nil {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid semi-plain JSON: {\"text\":\"...\",\"mention\":[\"...\"]}: %s", err).WithParam("--content").WithCause(err)
-			}
-			if strings.TrimSpace(sp.Text) == "" {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content text is required and cannot be empty").WithParam("--content")
-			}
-			for i, m := range sp.Mention {
-				if strings.TrimSpace(m) == "" {
-					return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content mention[%d] cannot be empty", i).WithParam("--content")
-				}
-			}
-			if len(sp.Docs) > 0 || len(sp.Images) > 0 {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content docs and images are not supported in simple style input; use richtext style or remove these fields").WithParam("--content")
-			}
-			p.Content = sp.ToContentBlock()
-		} else {
-			var cb ContentBlock
-			if err := json.Unmarshal([]byte(contentStr), &cb); err != nil {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid ContentBlock JSON: %s", err).WithParam("--content").WithCause(err)
-			}
-			p.Content = &cb
-		}
-	}
-
-	// Parse notes if provided (only for objective)
-	if notesStr := runtime.Str("notes"); notesStr != "" {
-		hasField = true
-		if err := common.RejectDangerousCharsTyped("--notes", notesStr); err != nil {
-			return nil, err
-		}
-		if p.Level != "objective" {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--notes is only supported for level=objective").WithParam("--notes")
-		}
-		if p.Style == "simple" {
-			var sp SemiPlainContent
-			if err := json.Unmarshal([]byte(notesStr), &sp); err != nil {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--notes must be valid semi-plain JSON: {\"text\":\"...\",\"mention\":[\"...\"]}: %s", err).WithParam("--notes").WithCause(err)
-			}
-			if strings.TrimSpace(sp.Text) == "" {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--notes text is required and cannot be empty").WithParam("--notes")
-			}
-			for i, m := range sp.Mention {
-				if strings.TrimSpace(m) == "" {
-					return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--notes mention[%d] cannot be empty", i).WithParam("--notes")
-				}
-			}
-			if len(sp.Docs) > 0 || len(sp.Images) > 0 {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--notes docs and images are not supported in simple style input; use richtext style or remove these fields").WithParam("--notes")
-			}
-			p.Notes = sp.ToContentBlock()
-		} else {
-			var cb ContentBlock
-			if err := json.Unmarshal([]byte(notesStr), &cb); err != nil {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--notes must be valid ContentBlock JSON: %s", err).WithParam("--notes").WithCause(err)
-			}
-			p.Notes = &cb
-		}
-	}
-
-	// Parse score if provided
-	if scoreStr := runtime.Str("score"); scoreStr != "" {
-		hasField = true
-		score, err := strconv.ParseFloat(scoreStr, 64)
-		if err != nil || math.IsNaN(score) || math.IsInf(score, 0) {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--score must be a valid number").WithParam("--score")
-		}
-		if score < 0 || score > 1 {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--score must be between 0 and 1").WithParam("--score")
-		}
-		// Check for exactly one decimal place
-		scoreStrTrimmed := strings.TrimRight(strings.TrimRight(scoreStr, "0"), ".")
-		parts := strings.Split(scoreStrTrimmed, ".")
-		if len(parts) == 2 && len(parts[1]) > 1 {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--score must have at most one decimal place (e.g., 0.5, not 0.51)").WithParam("--score")
-		}
-		// Validation ensures at most one decimal place, so score is already correctly formatted
-		p.Score = &score
-	}
-
-	// Parse deadline if provided
-	if deadlineStr := runtime.Str("deadline"); deadlineStr != "" {
-		hasField = true
-		deadlineMs, err := strconv.ParseInt(deadlineStr, 10, 64)
-		if err != nil {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--deadline must be a valid millisecond timestamp (integer)").WithParam("--deadline")
-		}
-		if deadlineMs <= 0 {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--deadline must be a positive millisecond timestamp").WithParam("--deadline")
-		}
-		// Reject non-millisecond timestamps: year 2000 in ms is ~946e9, year 2100 in ms is ~4.1e12
-		// Anything less than 1e12 is likely seconds or a wrong unit
-		if deadlineMs < 1000000000000 { // 1e12 ms = year ~33658, so use 1e12 as lower bound for reasonable ms timestamps
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--deadline must be a millisecond timestamp (13 digits), not seconds").WithParam("--deadline")
-		}
-		p.Deadline = &deadlineStr
-	}
-
-	// At least one field must be provided
-	if !hasField {
-		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "at least one of --content, --notes, --score, or --deadline must be provided")
-	}
-
-	return p, nil
-}
-
-// OKRPatch patches an objective or key result.
-var OKRPatch = common.Shortcut{
-	Service:     "okr",
-	Command:     "+patch",
-	Description: "Patch an OKR objective or key result (content, notes, score, deadline)",
-	Risk:        "write",
-	Scopes:      []string{"okr:okr.content:writeonly"},
-	AuthTypes:   []string{"user", "bot"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "level", Desc: "patch level: objective | key-result", Required: true, Enum: []string{"objective", "key-result"}},
-		{Name: "target-id", Desc: "target ID (objective or key result ID)", Required: true},
-		{Name: "style", Default: "simple", Desc: "input style for content/notes: simple (semi-plain text JSON) | richtext (ContentBlock JSON)", Enum: []string{"simple", "richtext"}},
-		{Name: "content", Desc: "content: semi-plain JSON {\"text\":\"...\",\"mention\":[\"...\"]} (simple) or ContentBlock JSON (richtext)", Input: []string{common.File, common.Stdin}},
-		{Name: "notes", Desc: "notes (objective only): semi-plain JSON {\"text\":\"...\",\"mention\":[\"...\"]} (simple) or ContentBlock JSON (richtext)", Input: []string{common.File, common.Stdin}},
-		{Name: "score", Desc: "score value between 0 and 1, with at most one decimal place (e.g., 0.5)"},
-		{Name: "deadline", Desc: "deadline as millisecond timestamp"},
-		{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 {
-		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")
-		}
-
-		targetID := runtime.Str("target-id")
-		if targetID == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--target-id is required").WithParam("--target-id")
-		}
-		if err := common.RejectDangerousCharsTyped("--target-id", targetID); err != nil {
-			return err
-		}
-		if id, err := strconv.ParseInt(targetID, 10, 64); err != nil || id <= 0 {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--target-id must be a positive int64").WithParam("--target-id")
-		}
-
-		style := runtime.Str("style")
-		if style != "simple" && style != "richtext" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--style must be one of: simple | richtext").WithParam("--style")
-		}
-
-		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")
-		}
-
-		// Delegate content/notes/score/deadline validation to parsePatchParams
-		if _, err := parsePatchParams(runtime); err != nil {
-			return err
-		}
-
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		p, err := parsePatchParams(runtime)
-		if err != nil {
-			return common.NewDryRunAPI().
-				PATCH("").
-				Desc(fmt.Sprintf("Dry-run skipped: %s", err.Error()))
-		}
-
-		body := make(map[string]interface{})
-		if p.Content != nil {
-			body["content"] = p.Content
-		}
-		if p.Notes != nil {
-			body["notes"] = p.Notes
-		}
-		if p.Score != nil {
-			body["score"] = *p.Score
-		}
-		if p.Deadline != nil {
-			body["deadline"] = *p.Deadline
-		}
-
-		params := map[string]interface{}{
-			"user_id_type": p.UserIDType,
-		}
-
-		api := common.NewDryRunAPI()
-		if p.Level == "objective" {
-			api = api.PATCH("/open-apis/okr/v2/objectives/:objective_id").
-				Set("objective_id", p.TargetID)
-		} else {
-			api = api.PATCH("/open-apis/okr/v2/key_results/:key_result_id").
-				Set("key_result_id", p.TargetID)
-		}
-		return api.Params(params).Body(body).
-			Desc(fmt.Sprintf("Patch OKR %s: content=%v, notes=%v, score=%v, deadline=%v",
-				p.Level, p.Content != nil, p.Notes != nil, p.Score != nil, p.Deadline != nil))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		p, err := parsePatchParams(runtime)
-		if err != nil {
-			return err
-		}
-
-		body := make(map[string]interface{})
-		if p.Content != nil {
-			body["content"] = p.Content
-		}
-		if p.Notes != nil {
-			body["notes"] = p.Notes
-		}
-		if p.Score != nil {
-			body["score"] = *p.Score
-		}
-		if p.Deadline != nil {
-			body["deadline"] = *p.Deadline
-		}
-
-		queryParams := map[string]interface{}{
-			"user_id_type": p.UserIDType,
-		}
-
-		var path string
-		if p.Level == "objective" {
-			path = fmt.Sprintf("/open-apis/okr/v2/objectives/%s", p.TargetID)
-		} else {
-			path = fmt.Sprintf("/open-apis/okr/v2/key_results/%s", p.TargetID)
-		}
-
-		_, err = runtime.CallAPITyped("PATCH", path, queryParams, body)
-		if err != nil {
-			return wrapOkrNetworkErr(err, "failed to patch OKR %s", p.Level)
-		}
-
-		result := map[string]interface{}{
-			"level":     p.Level,
-			"target_id": p.TargetID,
-			"patched": map[string]bool{
-				"content":  p.Content != nil,
-				"notes":    p.Notes != nil,
-				"score":    p.Score != nil,
-				"deadline": p.Deadline != nil,
-			},
-		}
-
-		runtime.OutFormat(result, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "Patched OKR %s [%s]\n", p.Level, p.TargetID)
-			if p.Content != nil {
-				fmt.Fprintf(w, "  - content: updated\n")
-			}
-			if p.Notes != nil {
-				fmt.Fprintf(w, "  - notes: updated\n")
-			}
-			if p.Score != nil {
-				fmt.Fprintf(w, "  - score: %.1f\n", *p.Score)
-			}
-			if p.Deadline != nil {
-				fmt.Fprintf(w, "  - deadline: %s\n", formatTimestamp(*p.Deadline))
-			}
-		})
-
-		return nil
-	},
-}

shortcuts/okr/okr_progress_create.go

@@ -10,7 +10,6 @@ import (
 	"io"
 	"math"
 	"strconv"
-	"strings"
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
@@ -36,37 +35,12 @@ type createProgressRecordParams struct {
 
 // parseCreateProgressRecordParams parses and validates flags from runtime into request-ready parameters.
 func parseCreateProgressRecordParams(runtime *common.RuntimeContext) (*createProgressRecordParams, error) {
-	style := runtime.Str("style")
 	content := runtime.Str("content")
-	var contentV1 *ContentBlockV1
-
-	if style == "simple" {
-		var sp SemiPlainContent
-		if err := json.Unmarshal([]byte(content), &sp); err != nil {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid semi-plain JSON: {\"text\":\"...\",\"mention\":[\"...\"]}: %s", err).WithParam("--content").WithCause(err)
-		}
-		if strings.TrimSpace(sp.Text) == "" {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content text is required and cannot be empty").WithParam("--content")
-		}
-		// Validate mention IDs are non-empty
-		for i, m := range sp.Mention {
-			if strings.TrimSpace(m) == "" {
-				return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content mention[%d] cannot be empty", i).WithParam("--content")
-			}
-		}
-		if len(sp.Docs) > 0 || len(sp.Images) > 0 {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content docs and images are not supported in simple style input; use richtext style or remove these fields").WithParam("--content")
-		}
-		// Build ContentBlock from semi-plain content (text + mentions)
-		contentV1 = sp.ToContentBlock().ToV1()
-	} else {
-		// richtext mode
-		var cb ContentBlock
-		if err := json.Unmarshal([]byte(content), &cb); err != nil {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid ContentBlock JSON: %s", err).WithParam("--content").WithCause(err)
-		}
-		contentV1 = cb.ToV1()
+	var cb ContentBlock
+	if err := json.Unmarshal([]byte(content), &cb); err != nil {
+		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid ContentBlock JSON: %s", err).WithParam("--content").WithCause(err)
 	}
+	contentV1 := cb.ToV1()
 
 	targetType := runtime.Str("target-type")
 	targetTypeVal := targetTypeAllowed[targetType]
@@ -118,7 +92,7 @@ var OKRCreateProgressRecord = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	HasFormat:   true,
 	Flags: []common.Flag{
-		{Name: "content", Desc: "progress content: semi-plain JSON {\"text\":\"...\",\"mention\":[\"...\"]} (simple style) or ContentBlock JSON (richtext style)", Required: true, Input: []string{common.File, common.Stdin}},
+		{Name: "content", Desc: "progress content in ContentBlock JSON format", Required: true, Input: []string{common.File, common.Stdin}},
 		{Name: "target-id", Desc: "target ID (objective or key result ID)", Required: true},
 		{Name: "target-type", Desc: "target type: objective | key_result", Required: true, Enum: []string{"objective", "key_result"}},
 		{Name: "progress-percent", Desc: "progress percentage"},
@@ -126,7 +100,6 @@ var OKRCreateProgressRecord = common.Shortcut{
 		{Name: "source-title", Default: "created by lark-cli", Desc: "source title for display"},
 		{Name: "source-url", Desc: "source URL for display (defaults to open platform URL based on brand)"},
 		{Name: "user-id-type", Default: "open_id", Desc: "user ID type: open_id | union_id | user_id"},
-		{Name: "style", Default: "simple", Desc: "input style: simple (semi-plain text JSON) | richtext (ContentBlock JSON)", Enum: []string{"simple", "richtext"}},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		content := runtime.Str("content")
@@ -136,36 +109,10 @@ var OKRCreateProgressRecord = common.Shortcut{
 		if err := common.RejectDangerousCharsTyped("--content", content); err != nil {
 			return err
 		}
-
-		style := runtime.Str("style")
-		if style != "simple" && style != "richtext" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--style must be one of: simple | richtext").WithParam("--style")
-		}
-
-		// Validate content based on style
-		if style == "simple" {
-			var sp SemiPlainContent
-			if err := json.Unmarshal([]byte(content), &sp); err != nil {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid semi-plain JSON: {\"text\":\"...\",\"mention\":[\"...\"]}: %s", err).WithParam("--content").WithCause(err)
-			}
-			if strings.TrimSpace(sp.Text) == "" {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content text is required and cannot be empty").WithParam("--content")
-			}
-			for i, m := range sp.Mention {
-				if strings.TrimSpace(m) == "" {
-					return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content mention[%d] cannot be empty", i).WithParam("--content")
-				}
-			}
-			// If user provided docs or images in simple mode, warn that they are ignored
-			if len(sp.Docs) > 0 || len(sp.Images) > 0 {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content docs and images are not supported in simple style input; use richtext style or remove these fields").WithParam("--content")
-			}
-		} else {
-			// richtext mode
-			var cb ContentBlock
-			if err := json.Unmarshal([]byte(content), &cb); err != nil {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid ContentBlock JSON: %s", err).WithParam("--content").WithCause(err)
-			}
+		// Validate content is valid JSON and can be parsed as ContentBlock
+		var cb ContentBlock
+		if err := json.Unmarshal([]byte(content), &cb); err != nil {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--content must be valid ContentBlock JSON: %s", err).WithParam("--content").WithCause(err)
 		}
 
 		targetID := runtime.Str("target-id")
@@ -266,43 +213,21 @@ var OKRCreateProgressRecord = common.Shortcut{
 			return err
 		}
 
-		style := runtime.Str("style")
-		var result map[string]interface{}
-		if style == "simple" {
-			resp := record.ToSimple()
-			result = map[string]interface{}{
-				"progress": resp,
-				"style":    style,
-			}
-
-			runtime.OutFormat(result, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "Created Progress [%s] (style: %s)\n", resp.ID, style)
-				fmt.Fprintf(w, "  ModifyTime: %s\n", resp.ModifyTime)
-				if resp.ProgressRate != nil && resp.ProgressRate.Percent != nil {
-					fmt.Fprintf(w, "  ProgressRate: %.1f%%\n", *resp.ProgressRate.Percent)
-				}
-				if resp.Content != nil {
-					fmt.Fprintf(w, "  Content: %s\n", resp.Content.Text)
-				}
-			})
-		} else {
-			resp := record.ToResp()
-			result = map[string]interface{}{
-				"progress": resp,
-				"style":    style,
-			}
-
-			runtime.OutFormat(result, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "Created Progress [%s] (style: %s)\n", resp.ID, style)
-				fmt.Fprintf(w, "  ModifyTime: %s\n", resp.ModifyTime)
-				if resp.ProgressRate != nil && resp.ProgressRate.Percent != nil {
-					fmt.Fprintf(w, "  ProgressRate: %.1f%%\n", *resp.ProgressRate.Percent)
-				}
-				if resp.Content != nil {
-					fmt.Fprintf(w, "  Content: %s\n", *resp.Content)
-				}
-			})
+		resp := record.ToResp()
+		result := map[string]interface{}{
+			"progress": resp,
 		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Created Progress [%s]\n", resp.ID)
+			fmt.Fprintf(w, "  ModifyTime: %s\n", resp.ModifyTime)
+			if resp.ProgressRate != nil && resp.ProgressRate.Percent != nil {
+				fmt.Fprintf(w, "  ProgressRate: %.1f%%\n", *resp.ProgressRate.Percent)
+			}
+			if resp.Content != nil {
+				fmt.Fprintf(w, "  Content: %s\n", *resp.Content)
+			}
+		})
 		return nil
 	},
 }

shortcuts/okr/okr_progress_create_test.go

@@ -5,13 +5,11 @@ package okr
 
 import (
 	"bytes"
-	"errors"
 	"strings"
 	"testing"
 
 	"github.com/spf13/cobra"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/httpmock"
@@ -40,7 +38,6 @@ func runProgressCreateShortcut(t *testing.T, f *cmdutil.Factory, stdout *bytes.B
 }
 
 const validContentBlockJSON = `{"blocks":[{"block_element_type":"paragraph","paragraph":{"elements":[{"paragraph_element_type":"textRun","text_run":{"text":"test content"}}]}}]}`
-const validSemiPlainJSON = `{"text":"test content","mention":["ou_123"]}`
 
 // --- Validate tests ---
 
@@ -63,7 +60,6 @@ func TestProgressCreateValidate_InvalidContentJSON(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", "not-json",
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 	})
@@ -81,7 +77,6 @@ func TestProgressCreateValidate_MissingTargetID(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-type", "objective",
 	})
 	if err == nil {
@@ -95,7 +90,6 @@ func TestProgressCreateValidate_InvalidTargetID_NonNumeric(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "abc",
 		"--target-type", "objective",
 	})
@@ -113,7 +107,6 @@ func TestProgressCreateValidate_InvalidTargetType(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "invalid",
 	})
@@ -131,7 +124,6 @@ func TestProgressCreateValidate_ControlCharsInContent(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", "{\"blocks\":[{\"block_element_type\":\"para\tgraph\"}]}",
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 	})
@@ -146,7 +138,6 @@ func TestProgressCreateValidate_InvalidUserIDType(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 		"--user-id-type", "invalid",
@@ -162,7 +153,6 @@ func TestProgressCreateValidate_InvalidProgressPercent_OutOfRange(t *testing.T)
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 		"--progress-percent", "999999999999",
@@ -181,7 +171,6 @@ func TestProgressCreateValidate_InvalidProgressPercent_NonNumeric(t *testing.T)
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 		"--progress-percent", "abc",
@@ -200,7 +189,6 @@ func TestProgressCreateValidate_InvalidProgressStatus(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 		"--progress-status", "invalid_status",
@@ -231,7 +219,6 @@ func TestProgressCreateValidate_Valid(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 	})
@@ -248,7 +235,6 @@ func TestProgressCreateDryRun(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 		"--dry-run",
@@ -278,7 +264,6 @@ func TestProgressCreateDryRun_WithProgressRate(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "123",
 		"--target-type", "objective",
 		"--progress-percent", "75",
@@ -314,7 +299,6 @@ func TestProgressCreateExecute_Success(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "456",
 		"--target-type", "key_result",
 	})
@@ -346,7 +330,6 @@ func TestProgressCreateExecute_APIError(t *testing.T) {
 	err := runProgressCreateShortcut(t, f, stdout, []string{
 		"+progress-create",
 		"--content", validContentBlockJSON,
-		"--style", "richtext",
 		"--target-id", "789",
 		"--target-type", "objective",
 	})
@@ -354,200 +337,3 @@ func TestProgressCreateExecute_APIError(t *testing.T) {
 		t.Fatal("expected error for API failure")
 	}
 }
-
-// --- Simple mode tests ---
-
-func TestProgressCreateExecute_SimpleMode_DefaultStyle(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, reg := cmdutil.TestFactory(t, progressCreateTestConfig(t))
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/okr/v1/progress_records/",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"progress_id": "300",
-				"modify_time": "1735776000000",
-			},
-		},
-	})
-	// Use default style (simple) without specifying --style
-	err := runProgressCreateShortcut(t, f, stdout, []string{
-		"+progress-create",
-		"--content", validSemiPlainJSON,
-		"--target-id", "123",
-		"--target-type", "objective",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	data := decodeEnvelope(t, stdout)
-	pr, _ := data["progress"].(map[string]interface{})
-	if pr == nil {
-		t.Fatal("expected progress in output")
-	}
-	if pr["progress_id"] != "300" {
-		t.Fatalf("progress_id = %v, want 300", pr["progress_id"])
-	}
-}
-
-func TestProgressCreateExecute_SimpleMode_ExplicitStyle(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, reg := cmdutil.TestFactory(t, progressCreateTestConfig(t))
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/okr/v1/progress_records/",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"progress_id": "400",
-				"modify_time": "1735776000000",
-			},
-		},
-	})
-	// Explicitly specify --style simple with mentions
-	err := runProgressCreateShortcut(t, f, stdout, []string{
-		"+progress-create",
-		"--content", `{"text":"simple progress with mention","mention":["ou_abc","ou_def"]}`,
-		"--style", "simple",
-		"--target-id", "456",
-		"--target-type", "key_result",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	data := decodeEnvelope(t, stdout)
-	pr, _ := data["progress"].(map[string]interface{})
-	if pr == nil {
-		t.Fatal("expected progress in output")
-	}
-	if pr["progress_id"] != "400" {
-		t.Fatalf("progress_id = %v, want 400", pr["progress_id"])
-	}
-}
-
-func TestProgressCreateValidate_SimpleMode_InvalidSemiPlainJSON(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, _ := cmdutil.TestFactory(t, progressCreateTestConfig(t))
-	err := runProgressCreateShortcut(t, f, stdout, []string{
-		"+progress-create",
-		"--content", `{"text":"missing closing brace`,
-		"--target-id", "123",
-		"--target-type", "objective",
-	})
-	if err == nil {
-		t.Fatal("expected error for invalid semi-plain JSON")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed error, got: %v", err)
-	}
-	if problem.Category != errs.CategoryValidation {
-		t.Fatalf("expected category %q, got %q", errs.CategoryValidation, problem.Category)
-	}
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("expected subtype %q, got %q", errs.SubtypeInvalidArgument, problem.Subtype)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("expected *errs.ValidationError, got: %T", err)
-	}
-	if validationErr.Param != "--content" {
-		t.Fatalf("expected param %q, got %q", "--content", validationErr.Param)
-	}
-	if !strings.Contains(err.Error(), "--content must be valid semi-plain JSON") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestProgressCreateValidate_SimpleMode_EmptyText(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, _ := cmdutil.TestFactory(t, progressCreateTestConfig(t))
-	err := runProgressCreateShortcut(t, f, stdout, []string{
-		"+progress-create",
-		"--content", `{"text":"   ","mention":[]}`,
-		"--target-id", "123",
-		"--target-type", "objective",
-	})
-	if err == nil {
-		t.Fatal("expected error for empty text in simple mode")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed error, got: %v", err)
-	}
-	if problem.Category != errs.CategoryValidation {
-		t.Fatalf("expected category %q, got %q", errs.CategoryValidation, problem.Category)
-	}
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("expected subtype %q, got %q", errs.SubtypeInvalidArgument, problem.Subtype)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("expected *errs.ValidationError, got: %T", err)
-	}
-	if validationErr.Param != "--content" {
-		t.Fatalf("expected param %q, got %q", "--content", validationErr.Param)
-	}
-	if !strings.Contains(err.Error(), "--content text is required and cannot be empty") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestProgressCreateValidate_SimpleMode_DocsImagesNotSupported(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, _ := cmdutil.TestFactory(t, progressCreateTestConfig(t))
-	err := runProgressCreateShortcut(t, f, stdout, []string{
-		"+progress-create",
-		"--content", `{"text":"has docs","mention":[],"docs":[{"title":"doc","url":"https://example.com"}]}`,
-		"--target-id", "123",
-		"--target-type", "objective",
-	})
-	if err == nil {
-		t.Fatal("expected error for docs in simple mode")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed error, got: %v", err)
-	}
-	if problem.Category != errs.CategoryValidation {
-		t.Fatalf("expected category %q, got %q", errs.CategoryValidation, problem.Category)
-	}
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("expected subtype %q, got %q", errs.SubtypeInvalidArgument, problem.Subtype)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("expected *errs.ValidationError, got: %T", err)
-	}
-	if validationErr.Param != "--content" {
-		t.Fatalf("expected param %q, got %q", "--content", validationErr.Param)
-	}
-	if !strings.Contains(err.Error(), "docs and images are not supported in simple style input") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestProgressCreateDryRun_SimpleMode(t *testing.T) {
-	t.Parallel()
-	f, stdout, _, _ := cmdutil.TestFactory(t, progressCreateTestConfig(t))
-	err := runProgressCreateShortcut(t, f, stdout, []string{
-		"+progress-create",
-		"--content", validSemiPlainJSON,
-		"--target-id", "123",
-		"--target-type", "objective",
-		"--dry-run",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	output := stdout.String()
-	if !strings.Contains(output, "/open-apis/okr/v1/progress_records/") {
-		t.Fatalf("dry-run output should contain API path, got: %s", output)
-	}
-	if !strings.Contains(output, "POST") {
-		t.Fatalf("dry-run output should contain POST method, got: %s", output)
-	}
-}

shortcuts/okr/okr_progress_get.go

@@ -26,7 +26,6 @@ var OKRGetProgressRecord = common.Shortcut{
 	Flags: []common.Flag{
 		{Name: "progress-id", Desc: "progress ID (int64)", Required: true},
 		{Name: "user-id-type", Default: "open_id", Desc: "user ID type: open_id | union_id | user_id"},
-		{Name: "style", Default: "simple", Desc: "output style: simple (semi-plain text JSON) | richtext (ContentBlock JSON)", Enum: []string{"simple", "richtext"}},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		progressID := runtime.Str("progress-id")
@@ -40,10 +39,6 @@ var OKRGetProgressRecord = common.Shortcut{
 		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")
 		}
-		style := runtime.Str("style")
-		if style != "simple" && style != "richtext" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--style must be one of: simple | richtext").WithParam("--style")
-		}
 		return nil
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
@@ -60,7 +55,6 @@ var OKRGetProgressRecord = common.Shortcut{
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		progressID := runtime.Str("progress-id")
 		userIDType := runtime.Str("user-id-type")
-		style := runtime.Str("style")
 
 		queryParams := map[string]interface{}{"user_id_type": userIDType}
 
@@ -75,45 +69,21 @@ var OKRGetProgressRecord = common.Shortcut{
 			return err
 		}
 
-		var result map[string]interface{}
-		if style == "simple" {
-			resp := record.ToSimple()
-			result = map[string]interface{}{
-				"progress": resp,
-				"style":    style,
-			}
-
-			runtime.OutFormat(result, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "Progress [%s] (style: %s)\n", resp.ID, style)
-				fmt.Fprintf(w, "  ModifyTime: %s\n", resp.ModifyTime)
-				if resp.ProgressRate != nil && resp.ProgressRate.Percent != nil {
-					fmt.Fprintf(w, "  ProgressRate: %.1f%%\n", *resp.ProgressRate.Percent)
-				}
-				if resp.Content != nil {
-					fmt.Fprintf(w, "  Content: %s\n", resp.Content.Text)
-					if len(resp.Content.Mention) > 0 {
-						fmt.Fprintf(w, "  Mentions: %v\n", resp.Content.Mention)
-					}
-				}
-			})
-		} else {
-			resp := record.ToResp()
-			result = map[string]interface{}{
-				"progress": resp,
-				"style":    style,
-			}
-
-			runtime.OutFormat(result, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "Progress [%s] (style: %s)\n", resp.ID, style)
-				fmt.Fprintf(w, "  ModifyTime: %s\n", resp.ModifyTime)
-				if resp.ProgressRate != nil && resp.ProgressRate.Percent != nil {
-					fmt.Fprintf(w, "  ProgressRate: %.1f%%\n", *resp.ProgressRate.Percent)
-				}
-				if resp.Content != nil {
-					fmt.Fprintf(w, "  Content: %s\n", *resp.Content)
-				}
-			})
+		resp := record.ToResp()
+		result := map[string]interface{}{
+			"progress": resp,
 		}
+
+		runtime.OutFormat(result, nil, func(w io.Writer) {
+			fmt.Fprintf(w, "Progress [%s]\n", resp.ID)
+			fmt.Fprintf(w, "  ModifyTime: %s\n", resp.ModifyTime)
+			if resp.ProgressRate != nil && resp.ProgressRate.Percent != nil {
+				fmt.Fprintf(w, "  ProgressRate: %.1f%%\n", *resp.ProgressRate.Percent)
+			}
+			if resp.Content != nil {
+				fmt.Fprintf(w, "  Content: %s\n", *resp.Content)
+			}
+		})
 		return nil
 	},
 }