docs(spec): add sheet-history-revert spec (history list / revert / revert-status)

3 new lark-sheets shortcuts via existing ToolsCall framework: - +history-list, +history-revert, +history-revert-status - async revert: sheet/data RecoverHistory → RecoverMsg(MQ) → agg consumer assigns memberId by scene (lark-cli=11 / doubao=10) - scene threaded via ctx baggage; no thrift changes (codegen all-no) - spans larksuite/cli, ee/sheet-skill-spec, ee/sheet-facade-agg, sheet/data Force-added under docs/ (repo-wide gitignored) so ccm-harness drift detection has the git-tracked SSOT.
chore: inject ccm-harness skill routing v2 to CLAUDE.md/AGENTS.md
2026-07-04 06:29:52 +08:00 · 2026-06-26 10:53:04 +08:00 · 2026-06-23 20:58:20 +08:00 · 2026-06-23 11:06:36 +08:00 · 2026-06-22 19:13:38 +08:00 · 2026-06-22 19:13:07 +08:00
181 changed files with 10498 additions and 7222 deletions
--- a/.github/workflows/semantic-review.yml
+++ b/.github/workflows/semantic-review.yml
@@ -47,13 +47,10 @@ jobs:
              throw new Error(`ambiguous workflow_run pull request bindings: ${runPRs.length}`);
            }
            let prNumber = Number(runPRs[0]?.number || 0);
-            const eventBaseSha = runPRs[0]?.base?.sha || "";
+            let eventBaseSha = runPRs[0]?.base?.sha || "";
            const eventHeadSha = runPRs[0]?.head?.sha || "";
-            const targetHeadSha = run.head_sha;
+            const targetHeadSha = eventHeadSha || run.head_sha;
            if (!/^[a-f0-9]{40}$/i.test(targetHeadSha)) throw new Error("invalid PR head sha");
-            if (eventHeadSha && eventHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()) {
-              core.notice("PR quality summary using workflow_run head_sha because workflow_run pull request head differs from the CI run head");
-            }

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

            const factsArtifactPattern = /^quality-gate-facts-([a-f0-9]{40})-([a-f0-9]{40})$/i;
            const { data: artifactData } = await github.rest.actions.listWorkflowRunArtifacts({
@@ -285,11 +279,11 @@ jobs:
              if (artifactHeadSha.toLowerCase() !== targetHeadSha.toLowerCase()) {
                artifactError = "facts artifact head sha does not match verified PR head sha";
                factsArtifactName = "";
+              } else if (eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()) {
+                artifactError = "facts artifact base sha does not match workflow_run pull request base sha";
+                factsArtifactName = "";
              } else {
                artifactBaseSha = parsedBaseSha;
-                if (eventBaseSha && parsedBaseSha.toLowerCase() !== eventBaseSha.toLowerCase()) {
-                  core.notice("semantic review using facts artifact base because workflow_run pull request base differs from the CI facts artifact base");
-                }
              }
            }
            if (!prNumber) {
@@ -337,7 +331,7 @@ jobs:
              core.setOutput("stale", "true");
              return;
            }
-            const baseSha = artifactBaseSha || eventBaseSha || pr.base.sha;
+            const baseSha = eventBaseSha || artifactBaseSha || pr.base.sha;
            if (!/^[a-f0-9]{40}$/i.test(baseSha)) throw new Error("invalid PR base sha");
            if ((eventBaseSha || artifactBaseSha) && pr.base.sha !== baseSha) {
              core.notice("semantic review skipped: workflow_run is stale for this PR base");
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -141,3 +141,74 @@ CLI arguments are untrusted (they come from AI agents). Call `validate.SafeInput
 | Modify shortcut flags/params | Required | If behavior changes |
 | Shortcut bug fix | Required | If regression risk |
 | Internal refactor (no shortcut impact) | Not needed | Not needed |
+
+
+
+## CCM Harness Skill Routing (v2)
+
+When the user's request matches one of these patterns, invoke the corresponding `/ccm-harness:*` skill via the Skill tool. Skills include multi-step workflows, gates, and quality checks that produce more reliable results than ad-hoc answers. When in doubt, invoke the skill — a false positive is cheaper than a false negative.
+
+### 主链路（spec → idl → dev → release）
+
+| 用户表达 | Skill |
+|---------|-------|
+| "新需求 / 这是个新功能 / 开始一个 req / 写 spec / 起 spec / PRD 来了 / 把 PRD 转 spec / 改 spec / 微调 spec / spec 局部更新 / spec 加一个字段" | `/ccm-harness:draft-spec <req-id> [<arg2>] [--force]`（Phase 0 路由器自动决定 init / generate / update capability）|
+| "review spec / 看 spec / 评审 spec / spec 评审" | `/ccm-harness:spec-review <req-id>` |
+| "生成 thrift / 起 idl / 把 spec 转 thrift" | `/ccm-harness:draft-idl` |
+| "推 thrift / 落 contract / Frozen Spec / codegen / 生成框架代码" | `/ccm-harness:codegen-idl <req-id>` |
+| "实现 spec / 写后端 / 后端开发 / 实现这个功能" | `/ccm-harness:backend-dev <req-id>` |
+| "前端怎么改 / 写前端 / 前端开发 / 前端编码" | `/ccm-harness:frontend-coding <req-id>` |
+| "部署 BOE / 上 PPE / 部署到 feature 环境" | `/ccm-harness:deploy <req-id>` |
+| "提 release / 上线 / 发布 / 走 PRE-GRAY-ONLINE" | `/ccm-harness:release <req-id>` |
+| "触发打包 / build / 起 SCM 编译" | `/ccm-harness:build <repo or psm>` |
+
+### 守护与诊断
+
+| 用户表达 | Skill |
+|---------|-------|
+| "工作流到哪一步了 / 下一步咋走 / 我迷路了" | `/ccm-harness:doctor` |
+| "调试 / debug / 这个 bug 怎么排" | `/ccm-harness:debug` |
+| "查 CI 失败 / CI 跑挂了 / pipeline 红了" | `/ccm-harness:check-ci-failure <mr>` |
+| "检查实现是否符合 spec / 蓝图对比" | `/ccm-harness:check-impl-gap` |
+| "spec 跟代码飘了吗 / drift 检查" | `/ccm-harness:spec-review <req-id> --mode drift` |
+| "Hub 知识跟代码一致吗" | `/ccm-harness:check-knowledge-consistency` |
+| "代码 review / 看 MR / cr 一下" | `/ccm-harness:code-review <mr>` |
+| "设计 review / 看技术方案" | `/ccm-harness:design-review <doc>` |
+
+### 工程辅助
+
+| 用户表达 | Skill |
+|---------|-------|
+| "通知 reviewer / 发 review 卡片" | `/ccm-harness:notify-reviewer <mr>` |
+| "自动修 MR / 按 review 改" | `/ccm-harness:autofix-mr <mr>` |
+| "生成测试用例 / 起 case / 筛选可执行 case / E2E 用例 / Playwright 脚本 / 自动化验收" | `/ccm-harness:test`（路由到 `ccm-e2e-check -> exec-e2e`） |
+| "查 idl / 看 thrift 定义" | `/ccm-harness:lookup-idl <psm>` |
+| "看仓库最近改了啥 / 仓库脉搏" | `/ccm-harness:pulse` |
+
+### 元能力（Skill / Prompt 研发）
+
+| 用户表达 | Skill |
+|---------|-------|
+| "起一个新 skill / 设计 skill" | `/ccm-harness:meta-draft-skill` |
+| "做评测集 / 给 skill 出评测数据" | `/ccm-harness:meta-build-evalset` |
+| "跑评测 / Fornax 实验" | `/ccm-harness:meta-run-eval` |
+| "优化 skill / skill 反馈优化" | `/ccm-harness:meta-optimize-skill` |
+
+### 环境与配置
+
+| 用户表达 | Skill |
+|---------|-------|
+| "升级 ccm-harness / 更新插件" | `/ccm-harness:upgrade` |
+| "看遥测 / 最近的反馈" | `/ccm-harness:show-telemetry` |
+| "清遥测 / 重置 telemetry" | `/ccm-harness:clear-telemetry` |
+| "上报问题 / 提 issue" | `/ccm-harness:report-issue` |
+| "看本地教训 / project learnings / 我们踩过啥" | `/ccm-harness:learn` |
+| "反馈 / 评分这次 skill" | `/ccm-harness:feedback` |
+
+### 使用提示
+
+- **入口**：新需求**必从** `/ccm-harness:draft-spec <req-id>` 开始（Phase 0 路由器自动决定建目录 / 带 PRD 一气呵成）。
+- **不跳步**：spec → idl → dev → release 是流水线，不是菜单——按顺序推进，反向走需要 `/ccm-harness:draft-spec <req-id> "<change-desc>"` 局部修（路由进 update capability）。
+- **横切**：任何阶段发现 spec 要局部改 → `/ccm-harness:draft-spec <req-id> "<change-desc>"`；想检测漂移 → `/ccm-harness:spec-review <req-id> --mode drift`；CI 红 → `/ccm-harness:check-ci-failure`；迷路 → `/ccm-harness:doctor`。
+
+完整流程文档：`docs/user-guide/workflow.md`
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,30 +2,6 @@

 All notable changes to this project will be documented in this file.

-## [v1.0.57] - 2026-06-23
-
-### Features
-
- **slides**: Add `+screenshot` to capture slide page images (or render a single `<slide>` XML snippet), returning the local file path instead of Base64 (#1358)
- **base**: Support record comments (#1043)
- **search**: Surface search API notices (#1413)
-
-### Bug Fixes
-
- **mail**: Resolve folder/label filter once per `+triage list` call (#1512)
- **meta**: Backfill enum value descriptions from options (#1541)
- **cli**: Add missing CLI headers for git credential helper (#1539)
-
-### Documentation
-
- **doc**: Refine rich block, path, and block ID guidance (#1508)
- **mail**: Trim lark-mail skill context (#1527)
- **drive**: Add permission governance workflow guidance (#1292)
-
-### Build
-
- **ci**: Bind semantic review to workflow run head (#1551)
-
 ## [v1.0.56] - 2026-06-18

 ### Features
@@ -1236,7 +1212,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.

-[v1.0.57]: https://github.com/larksuite/cli/releases/tag/v1.0.57
 [v1.0.56]: https://github.com/larksuite/cli/releases/tag/v1.0.56
 [v1.0.55]: https://github.com/larksuite/cli/releases/tag/v1.0.55
 [v1.0.54]: https://github.com/larksuite/cli/releases/tag/v1.0.54
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -0,0 +1,69 @@
+
+## CCM Harness Skill Routing (v2)
+
+When the user's request matches one of these patterns, invoke the corresponding `/ccm-harness:*` skill via the Skill tool. Skills include multi-step workflows, gates, and quality checks that produce more reliable results than ad-hoc answers. When in doubt, invoke the skill — a false positive is cheaper than a false negative.
+
+### 主链路（spec → idl → dev → release）
+
+| 用户表达 | Skill |
+|---------|-------|
+| "新需求 / 这是个新功能 / 开始一个 req / 写 spec / 起 spec / PRD 来了 / 把 PRD 转 spec / 改 spec / 微调 spec / spec 局部更新 / spec 加一个字段" | `/ccm-harness:draft-spec <req-id> [<arg2>] [--force]`（Phase 0 路由器自动决定 init / generate / update capability）|
+| "review spec / 看 spec / 评审 spec / spec 评审" | `/ccm-harness:spec-review <req-id>` |
+| "生成 thrift / 起 idl / 把 spec 转 thrift" | `/ccm-harness:draft-idl` |
+| "推 thrift / 落 contract / Frozen Spec / codegen / 生成框架代码" | `/ccm-harness:codegen-idl <req-id>` |
+| "实现 spec / 写后端 / 后端开发 / 实现这个功能" | `/ccm-harness:backend-dev <req-id>` |
+| "前端怎么改 / 写前端 / 前端开发 / 前端编码" | `/ccm-harness:frontend-coding <req-id>` |
+| "部署 BOE / 上 PPE / 部署到 feature 环境" | `/ccm-harness:deploy <req-id>` |
+| "提 release / 上线 / 发布 / 走 PRE-GRAY-ONLINE" | `/ccm-harness:release <req-id>` |
+| "触发打包 / build / 起 SCM 编译" | `/ccm-harness:build <repo or psm>` |
+
+### 守护与诊断
+
+| 用户表达 | Skill |
+|---------|-------|
+| "工作流到哪一步了 / 下一步咋走 / 我迷路了" | `/ccm-harness:doctor` |
+| "调试 / debug / 这个 bug 怎么排" | `/ccm-harness:debug` |
+| "查 CI 失败 / CI 跑挂了 / pipeline 红了" | `/ccm-harness:check-ci-failure <mr>` |
+| "检查实现是否符合 spec / 蓝图对比" | `/ccm-harness:check-impl-gap` |
+| "spec 跟代码飘了吗 / drift 检查" | `/ccm-harness:spec-review <req-id> --mode drift` |
+| "Hub 知识跟代码一致吗" | `/ccm-harness:check-knowledge-consistency` |
+| "代码 review / 看 MR / cr 一下" | `/ccm-harness:code-review <mr>` |
+| "设计 review / 看技术方案" | `/ccm-harness:design-review <doc>` |
+
+### 工程辅助
+
+| 用户表达 | Skill |
+|---------|-------|
+| "通知 reviewer / 发 review 卡片" | `/ccm-harness:notify-reviewer <mr>` |
+| "自动修 MR / 按 review 改" | `/ccm-harness:autofix-mr <mr>` |
+| "生成测试用例 / 起 case / 筛选可执行 case / E2E 用例 / Playwright 脚本 / 自动化验收" | `/ccm-harness:test`（路由到 `ccm-e2e-check -> exec-e2e`） |
+| "查 idl / 看 thrift 定义" | `/ccm-harness:lookup-idl <psm>` |
+| "看仓库最近改了啥 / 仓库脉搏" | `/ccm-harness:pulse` |
+
+### 元能力（Skill / Prompt 研发）
+
+| 用户表达 | Skill |
+|---------|-------|
+| "起一个新 skill / 设计 skill" | `/ccm-harness:meta-draft-skill` |
+| "做评测集 / 给 skill 出评测数据" | `/ccm-harness:meta-build-evalset` |
+| "跑评测 / Fornax 实验" | `/ccm-harness:meta-run-eval` |
+| "优化 skill / skill 反馈优化" | `/ccm-harness:meta-optimize-skill` |
+
+### 环境与配置
+
+| 用户表达 | Skill |
+|---------|-------|
+| "升级 ccm-harness / 更新插件" | `/ccm-harness:upgrade` |
+| "看遥测 / 最近的反馈" | `/ccm-harness:show-telemetry` |
+| "清遥测 / 重置 telemetry" | `/ccm-harness:clear-telemetry` |
+| "上报问题 / 提 issue" | `/ccm-harness:report-issue` |
+| "看本地教训 / project learnings / 我们踩过啥" | `/ccm-harness:learn` |
+| "反馈 / 评分这次 skill" | `/ccm-harness:feedback` |
+
+### 使用提示
+
+- **入口**：新需求**必从** `/ccm-harness:draft-spec <req-id>` 开始（Phase 0 路由器自动决定建目录 / 带 PRD 一气呵成）。
+- **不跳步**：spec → idl → dev → release 是流水线，不是菜单——按顺序推进，反向走需要 `/ccm-harness:draft-spec <req-id> "<change-desc>"` 局部修（路由进 update capability）。
+- **横切**：任何阶段发现 spec 要局部改 → `/ccm-harness:draft-spec <req-id> "<change-desc>"`；想检测漂移 → `/ccm-harness:spec-review <req-id> --mode drift`；CI 红 → `/ccm-harness:check-ci-failure`；迷路 → `/ccm-harness:doctor`。
+
+完整流程文档：`docs/user-guide/workflow.md`
--- a/cmd/event/list_test.go
+++ b/cmd/event/list_test.go
@@ -26,7 +26,6 @@ func TestRunList_TextOutput(t *testing.T) {
 		"KEY", "AUTH", "PARAMS", "DESCRIPTION",
 		"im.message.receive_v1",
 		"im.message.message_read_v1",
-		"task.task.update_user_access_v2",
 	} {
 		if !strings.Contains(out, want) {
 			t.Errorf("list output missing %q; full output:\n%s", want, out)
@@ -56,17 +55,4 @@ func TestRunList_JSONOutput(t *testing.T) {
 			}
 		}
 	}
-
-	var foundTask bool
-	for _, row := range rows {
-		if row["key"] == "task.task.update_user_access_v2" {
-			foundTask = true
-			if row["single_consumer"] != true {
-				t.Errorf("task row single_consumer = %v, want true", row["single_consumer"])
-			}
-		}
-	}
-	if !foundTask {
-		t.Fatal("event list JSON missing task.task.update_user_access_v2")
-	}
 }
--- a/cmd/event/schema_test.go
+++ b/cmd/event/schema_test.go
@@ -96,34 +96,6 @@ func TestRunSchema_JSONOutput(t *testing.T) {
 	}
 }

-func TestRunSchema_TaskUpdateUserAccessJSON(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})
-
-	if err := runSchema(f, "task.task.update_user_access_v2", true); err != nil {
-		t.Fatalf("runSchema json: %v", err)
-	}
-
-	var payload map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
-		t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
-	}
-	if payload["jq_root_path"] != ".event" {
-		t.Errorf("jq_root_path = %v, want .event", payload["jq_root_path"])
-	}
-	if payload["single_consumer"] != true {
-		t.Errorf("single_consumer = %v, want true", payload["single_consumer"])
-	}
-	resolved := payload["resolved_output_schema"].(map[string]interface{})
-	props := resolved["properties"].(map[string]interface{})
-	eventProps := props["event"].(map[string]interface{})["properties"].(map[string]interface{})
-	if got := eventProps["task_guid"].(map[string]interface{})["format"]; got != "task_guid" {
-		t.Errorf("task_guid format = %v, want task_guid", got)
-	}
-	if _, ok := eventProps["event_types"].(map[string]interface{})["items"].(map[string]interface{})["enum"]; !ok {
-		t.Fatalf("event_types enum missing in schema: %#v", eventProps["event_types"])
-	}
-}
-
 func TestSchema_RendersSubscriptionKeyMarker(t *testing.T) {
 	const syntheticKey = "test.evt_sub"
 	t.Cleanup(func() { eventlib.UnregisterKeyForTest(syntheticKey) })
--- a/docs/specs/sheet-history-revert/spec.md
+++ b/docs/specs/sheet-history-revert/spec.md
@@ -0,0 +1,305 @@
+---
+req_id: sheet-history-revert
+mode: from-prd
+tracks: [be]
+created_at: 2026-06-23T13:09:08Z
+---
+
+> ⚠️ **请勿直接编辑此文档**
+> 修改请通过 `/ccm-harness:draft-spec sheet-history-revert "<变更描述>"`（路由器会进入 update capability）
+> 手改不会被 check-spec-drift 放过，且会破坏 Frozen 快照关联性
+> 本文档由 /ccm-harness:draft-spec 生成于 2026-06-23T13:09:08Z；req-id：sheet-history-revert
+
+---
+
+# Sheet 历史版本查询与回滚
+
+<!-- BEGIN generated overview — scripts/render_spec_overview.py 自动生成，勿手改；改 spec 请走 /ccm-harness:draft-spec <req-id> "<变更>"（update） -->
+## 方案概览 / TL;DR
+
+> 本段由机器从下方子任务字段**确定性生成**，供快速把握方案；**权威细节仍以各子任务 `yaml` 块为准**。
+
+- **需求** `sheet-history-revert` ｜ 模式 `from-prd` ｜ 端 BE
+- **规模** 5 BE ｜ **涉及 PSM** `tooling.lark_cli`, `tooling.sheet_skill_spec`, `sheet.facade.agg`, `bear.server.sheet_data` ｜ **Thrift 影响** 无 ×5
+
+| 子任务 | 一句话 | 关键信息 |
+|---|---|---|
+| BE-1 | lark-cli `+history-list` 历史记录列表 shortcut | `tooling.lark_cli` · thrift:无 · `history_list[read]（callTool tools/invoke_read；内部对接 /space/api/v3/sheet/histories）` |
+| BE-2 | lark-cli `+history-revert` 与 `+history-revert-status` 回滚流 shortcut | `tooling.lark_cli` · thrift:无 · `history_revert[write] / history_revert_status[read]（callTool tools/invoke_write\|read；内部对接 /space/api/v2/sheet/recover、/api/v2/sheet/recover/status）` |
+| BE-3 | sheet-skill-spec 上游事实源（skill 正文 + shortcut/flag 定义） | `tooling.sheet_skill_spec` · thrift:无 · `A` |
+| BE-4 | sheet-facade-agg 在现有 ToolsCall 上新增 3 个历史/回滚工具 | `sheet.facade.agg` · thrift:无 · `history_list[read] / history_revert[write] / history_revert_status[read]` |
+| BE-5 | sheet/data 透传 scene 并在 RecoverMsg 上新增 Scene 字段 | `bear.server.sheet_data` · thrift:无 · `RecoverHistory / QueryRecoverStatus（复用）；MQ RecoverMsg 加 Scene 字段` |
+
+> 完整字段见各子任务 `yaml` 块。
+<!-- END generated overview -->
+
+## 概述与范围
+
+为 `lark-cli` 的 lark-sheets 能力补齐**电子表格历史版本查询与回滚**，新增 3 个 shortcut，让 AI / 用户可以列出某张表的历史版本、回滚到指定版本、并查询回滚的异步状态。三个 shortcut 封装的是飞书电子表格已上线的 space 接口（见下表的「前端接口参考」），本需求不新建产品能力，只是把它们包装成稳定、AI 友好的命令面。
+
+| 功能 | shortcut | 前端接口参考（搜索 lark/idl） | 实现差异点 |
+|---|---|---|---|
+| 查历史记录列表 | `+history-list` | `/space/api/v3/sheet/histories` | ① 仅返回 `minor_histories` 列表；② `minor_histories` 的 `id` 字段重命名为 `history_version_id`；③ 每条仅保留 `history_version_id` / `create_time`（序列化成 AI 优化的可读格式）/ `action` / `all_block_revision` 四个字段 |
+| 历史记录回滚 | `+history-revert` | `/space/api/v2/sheet/recover` | 传入 `+history-list` 拿到的 `history_version_id`，回滚到指定版本 |
+| 查询回滚状态 | `+history-revert-status` | `/api/v2/sheet/recover/status` | 查询 `+history-revert` 发起的异步回滚的当前状态 |
+
+**范围内**：
+- `larksuite/cli` 仓新增 3 个 sheets shortcut（含 `+history-list` 的响应裁剪 / 字段重命名 / 时间格式转换逻辑）。
+- `ee/sheet-skill-spec` 上游事实源补 skill 正文与 shortcut/flag 定义，经其工作流 `sync:cli` 同步到 `larksuite/cli` 的 `skills/lark-sheets/` 与 `shortcuts/sheets/data/`。
+- `ee/sheet-facade-agg` **复用现有 `ToolsCall` 接口**，在其上新增 3 个工具（`history_list` / `history_revert` / `history_revert_status`）；并在**回滚消息消费侧**（消费 `sheet/data` 产出的 RecoverMsg）按 scene 给 `memberId` 赋值（doubao=10，lark-cli=11）后构造 recover cs。
+- `sheet/data`（`bear.server.sheet_data`）把 scene 从入口透传到 `RecoverHistory`，并在产出的 `RecoverMsg`（MQ 消息）上**新增 `Scene` 字段**，供 agg 消费时区分场景。
+
+**范围外**：
+- 历史版本的底层存储 / 快照 / 过期清理逻辑、`RecoverHistory` 的回滚业务语义（`bear.server.sheet_data` 已有，本需求仅透传 scene + 加 MQ 字段，不改回滚逻辑本身）。
+- 历史版本 diff、可视化、权限模型变更等产品侧扩展。
+- `doubao-office` 消费方的同步（`sheet-skill-spec` 另有 `sync:doubao`，本需求不涉及）。
+
+## 服务拓扑与 PSM 变更判定表
+
+**调用链路（目标形态）**：
+
+```
+用户 / AI ──> lark-cli (+history-list / +history-revert / +history-revert-status)
+                   │  callTool → POST /open-apis/sheet_ai/v2/.../tools/invoke_read|write（scene 随入口确定）
+                   ▼
+        sheet.facade.agg  ToolsCall（复用现有接口，新增 3 个工具:
+                          history_list[read] / history_revert[write] / history_revert_status[read]）
+        ├─ history_list      ──> 拉历史列表（裁剪 minor_histories / 4 字段 / AI 时间格式）
+        ├─ history_revert ───scene(ctx 透传)──> bear.server.sheet_data: RecoverHistory
+        │                                          │ service.RecoverHistory → SendRecoverMsg
+        │                                          ▼
+        │                                   MQ: RecoverMsg（新增 Scene 字段）
+        │                                          ▼
+        │   sheet.facade.agg  RecoverMsg 消费者 ── 读 Scene → memberId(doubao=10/lark-cli=11)
+        │                                          → 构造 recover cs → 调既有 recover 下游
+        └─ history_revert_status ──> bear.server.sheet_data: QueryRecoverStatus(transactionID)
+```
+
+`lark-cli` 现有 sheets shortcut 统一通过 `callTool`（`shortcuts/sheets/sheet_ai_api.go`）走 One-OpenAPI 的 `tools/invoke_read|write` 入口（`ToolKindRead` / `ToolKindWrite`），由 `sheet.facade.agg` 的 `OpenAPIToolCallRead/Write`（`biz/handler/lark_cli.go`，底层复用 `aiService.ToolsCall`）按 `tool_name` 分发。本需求的 3 个 shortcut 即按此路径新增 3 个工具，而非直连 space 接口或新增独立 OpenAPI 路由。
+
+**回滚为异步两段式**：`history_revert` 工具调 `sheet/data` 的 `RecoverHistory`（`biz/history/service/recover.go`），后者通过 `SendRecoverMsg`（`infra/mq/producer/recover.go` 的 `RecoverMsg`）投递回滚消息并返回 `transactionID`；agg 侧的 RecoverMsg 消费者真正构造 recover cs，并在此时按 scene 给 `memberId` 赋值。`history_revert_status` 工具走 `sheet/data` 的 `QueryRecoverStatus(transactionID)` 查询异步结果。scene 从 ToolsCall 入口经 **ctx 透传**（沿用既有 `utils.WithSceneDoubao(ctx)` 范式）到 `RecoverHistory`，再写入 `RecoverMsg.Scene` 字段，使 agg 消费时可区分 doubao / lark-cli。
+
+**PSM 变更判定表**：
+
+| PSM | 需要代码变更？ | 变更内容 | 不变更原因 |
+|---|---|---|---|
+| `tooling.lark_cli`（`larksuite/cli`，无服务 PSM） | 是 | 新增 3 个 shortcut + `+history-list` 响应 transform | — |
+| `tooling.sheet_skill_spec`（`ee/sheet-skill-spec`，无服务 PSM） | 是 | 新增 lark-sheets skill 正文 + 3 个 shortcut/flag 定义，生成后同步到 cli | — |
+| `sheet.facade.agg`（`ee/sheet-facade-agg`） | 是 | ① 现有 `ToolsCall` 新增 3 个工具（`history_list[read]` / `history_revert[write]` / `history_revert_status[read]`）；② `history_revert` 工具调 `sheet/data` 时透传 scene（ctx）；③ **RecoverMsg 消费者**读 `Scene` 字段，按 scene 给 `memberId` 赋值后构造 recover cs。**无新 thrift**（工具按 `tool_name`+JSON 注册，scene 走 ctx baggage） | — |
+| `bear.server.sheet_data`（`sheet/data`） | 是 | scene 从入口透传到 `RecoverHistory`（`biz/history/service/recover.go`），并在 `RecoverMsg`（`infra/mq/producer/recover.go`）上**新增 `Scene` 字段**随消息投递。`RecoverMsg` 是 JSON Go struct，加字段**非 thrift**；scene 透传走 ctx baggage | 回滚 / 快照业务语义不变（`RestoreHistorySnapshot` / `QueryRecoverStatus` 等复用） |
+
+> **`memberId` 按 scene 赋值（实现硬约束，跨 sheet/data + agg）**：scene 区分 doubao 与 lark-cli（沿用既有 `utils.WithSceneDoubao(ctx)` 范式）。本需求要求 scene 从 ToolsCall 入口一路透传：
+> 1. agg `history_revert` 工具调用 `sheet/data.RecoverHistory` 时，把 scene 经 ctx 透传；
+> 2. `sheet/data` 在产出的 `RecoverMsg` 上写入 `Scene` 字段，随 MQ 投递；
+> 3. **agg 的 RecoverMsg 消费者**在真正构造 recover cs 时，读 `Scene` 给 `memberId` 赋值——doubao 场景 = `10`，其他（lark-cli）场景 = `11`。
+>
+> memberId 赋值发生在 **agg 消费侧**（不是同步 ToolsCall 调用栈，因为回滚是异步消息驱动）。错误的 memberId 会导致回滚归属错误的调用方身份（审计 / 权限相关）。`RecoverMsg.MemberId` 字段已存在，但本需求要求按 scene 正确赋值并据此区分两个消费方。
+
+## 后端 / Tooling 子任务
+
+> 说明：`lark-cli` 与 `sheet-skill-spec` 均属 Tooling，按 ccm-harness 约定建 BE-*，`thrift_impact: 无`。本需求无前端（FE）子任务。
+
+### BE-1: lark-cli `+history-list` 历史记录列表 shortcut
+
+```yaml
+psm: tooling.lark_cli
+repo: larksuite/cli
+module: shortcuts/sheets
+be_deploy_required: false
+thrift_impact: 无
+api: facade-agg ToolsCall::history_list[read]（callTool tools/invoke_read；内部对接 /space/api/v3/sheet/histories）
+depends_on: [BE-4]
+estimate: 1.5d
+```
+
+**调用的下游服务**：经 `callTool(ToolKindRead, "history_list", ...)`（`shortcuts/sheets/sheet_ai_api.go`）走 `tools/invoke_read` 入口，由 facade-agg 的 `history_list` 工具内部对接 `/space/api/v3/sheet/histories`。入参：表格 token（沿用现有 sheets shortcut 的 `--spreadsheet-token` / `--token` 解析）。响应裁剪 / 字段重命名 / 时间格式可在 facade-agg 工具侧或 lark-cli 侧完成（见实现要点；以 AI 友好输出为准）。
+**实现要点（实现差异点落地）**：
+- 仅取响应中的 `minor_histories` 列表，丢弃其余顶层字段（如 major histories）。
+- 将每条 `minor_histories` 的 `id` 字段重命名输出为 `history_version_id`。
+- 每条仅保留 4 个字段：`history_version_id`、`create_time`、`action`、`all_block_revision`。
+- `create_time` 序列化成 AI 优化的可读格式（如本地时区可读时间串），而非裸 unix 时间戳。
+**验收场景**：
+- Given 一张有多个历史版本的电子表格，When 执行 `lark-cli sheets +history-list --token <t>`，Then 返回 JSON 数组，每条恰好含 `history_version_id` / `create_time` / `action` / `all_block_revision` 四个键，且 `create_time` 为可读格式。
+- Given 一张无历史记录的表格，When 执行 `+history-list`，Then 返回空列表且退码 0（不报错）。
+
+### BE-2: lark-cli `+history-revert` 与 `+history-revert-status` 回滚流 shortcut
+
+```yaml
+psm: tooling.lark_cli
+repo: larksuite/cli
+module: shortcuts/sheets
+be_deploy_required: false
+thrift_impact: 无
+api: facade-agg ToolsCall::history_revert[write] / history_revert_status[read]（callTool tools/invoke_write|read；内部对接 /space/api/v2/sheet/recover、/api/v2/sheet/recover/status）
+depends_on: [BE-1, BE-4, BE-5]
+estimate: 1.5d
+```
+
+**调用的下游服务**：
+- `+history-revert` → `callTool(ToolKindWrite, "history_revert", ...)`，agg 工具调 `sheet/data.RecoverHistory`（异步），返回 `transactionID`。
+- `+history-revert-status` → `callTool(ToolKindRead, "history_revert_status", ...)`，agg 工具调 `sheet/data.QueryRecoverStatus(transactionID)` 查异步结果。
+- 注：`memberId` 按 scene 赋值（doubao=10 / lark-cli=11）发生在 agg 的 **RecoverMsg 消费者**侧（见 BE-4 / BE-5），lark-cli 侧不感知；scene 由 callTool 入口（read/write）确定。
+**实现要点**：
+- `+history-revert` 的 `--history-version-id`（命名对齐 BE-1 的输出字段）为必填；缺失时在 Validate 阶段给出可执行错误提示。
+- 回滚为异步操作，`+history-revert` 返回受理结果，`+history-revert-status` 供轮询最终状态（成功 / 进行中 / 失败）。
+**验收场景**：
+- Given 由 `+history-list` 取得的合法 `history_version_id`，When 执行 `+history-revert --token <t> --history-version-id <id>`，Then 后端受理回滚并返回可被 `+history-revert-status` 查询的标识。
+- Given 一次已发起的回滚，When 轮询 `+history-revert-status`，Then 能区分「进行中 / 成功 / 失败」三种状态。
+- Given 缺省 `--history-version-id`，When 执行 `+history-revert`，Then 返回明确的参数缺失错误，不发起请求。
+
+### BE-3: sheet-skill-spec 上游事实源（skill 正文 + shortcut/flag 定义）
+
+```yaml
+psm: tooling.sheet_skill_spec
+repo: ee/sheet-skill-spec
+module: canonical-spec
+be_deploy_required: false
+thrift_impact: 无
+api: N/A
+depends_on: [BE-1, BE-2]
+estimate: 1d
+```
+
+**调用的下游服务**：无（构建期工作流）。
+**实现要点（按 `sheet-skill-spec` README 工作流）**：
+- 在飞书 base 表登记 3 个新 shortcut 的 tool ↔ shortcut 映射与 flag 定义，`npm run sync:tool-shortcut-map` 镜像入仓。
+- 在 `canonical-spec/references/<相关 skill>/cli-reference.md` 补三个 shortcut 的描述 / 示例 / Validate-DryRun-Execute 约束。
+- 跑 `npm run generate:all && npm run check:all` 验证，产出 `generated/lark-cli/skills/lark-sheets/` 与 `generated/lark-cli/data/{flag-defs.json,flag-schemas.json}`。
+- 跑 `npm run sync:cli` 把 generated 同步到 `larksuite/cli` 的 `skills/lark-sheets/`（mirror）与 `shortcuts/sheets/data/`（mirror），在 cli 仓作为 PR 提交。
+**边界**：skill 命名 / 切分 / 正文 / flag 定义一律先落 `sheet-skill-spec`，禁止直接改 cli 仓的 `generated`/`skills/lark-sheets/` 产物（README「对齐原则」）。
+**验收场景**：
+- Given 在 `sheet-skill-spec` 完成上述编辑，When 跑 `npm run check:all`，Then 全部门禁通过（generated 与 canonical 一致、map 与 base 表一致）。
+- Given 跑 `npm run sync:cli`，Then cli 仓 `skills/lark-sheets/` 与 `shortcuts/sheets/data/` 出现对应 3 个 shortcut 的 skill 正文与 flag 定义。
+
+### BE-4: sheet-facade-agg 在现有 ToolsCall 上新增 3 个历史/回滚工具
+
+```yaml
+psm: sheet.facade.agg
+repo: ee/sheet-facade-agg
+module: biz/handler
+be_deploy_required: true
+thrift_impact: 无
+api: ToolsCall::history_list[read] / history_revert[write] / history_revert_status[read]
+depends_on: []
+estimate: 1.5d
+```
+
+**调用的下游服务**：`sheet/data` 的 `RecoverHistory` / `QueryRecoverStatus`（见 BE-5）+ 既有历史查询；agg 的 RecoverMsg 消费者复用既有 recover 下游（`biz/service/spreadsheet.go::ProcessRecoverCs`、`model.RecoverParam`），不新增 thrift。
+**实现要点**：
+- **ToolsCall 扩展**：在现有 `ToolsCall` 框架（`biz/handler/handler.go::ToolsCall` / `biz/handler/lark_cli.go::OpenAPIToolCallRead|Write`）注册 3 个新工具：`history_list`（read）、`history_revert`（write）、`history_revert_status`（read），按 `constants.IsReadTool` / `IsWriteTool` 归类，从 `tools/invoke_read` / `invoke_write` 入口可达。
+- **scene 透传**：`history_revert` / `history_revert_status` 工具调 `sheet/data` 时，把 scene 经 ctx（沿用 `utils.WithSceneDoubao` 范式）透传下去，使 `sheet/data` 能写入 `RecoverMsg.Scene`。
+- **RecoverMsg 消费者按 scene 赋 memberId（硬约束）**：agg 消费 `sheet/data` 投递的 `RecoverMsg`、构造真正 recover cs 时，读 `RecoverMsg.Scene` 给 `memberId` 赋值——doubao = `10`，lark-cli = `11`。这是异步消费侧逻辑，不在同步 ToolsCall 调用栈。
+- `history_list` 工具对接历史列表查询；响应裁剪（仅 `minor_histories`、`id`→`history_version_id`、4 字段、`create_time` AI 友好格式）建议落在此工具侧（两个消费方共享，避免 lark-cli / doubao 双实现漂移）。
+**边界**：只在 ToolsCall 上加工具 + 改 RecoverMsg 消费者；不新增独立 OpenAPI 路由、不改 `ai.ToolsCallRequest` thrift 契约、不改 `RecoverHistory` 回滚业务语义。
+**验收场景**：
+- Given lark-cli 经 `tools/invoke_read` 调用 `history_list`，Then 返回裁剪后的 `minor_histories`（4 字段，`history_version_id` 命名）。
+- Given lark-cli（scene=lark-cli）经 `history_revert` 发起回滚，When agg 消费对应 RecoverMsg，Then 构造的 recover cs 中 `memberId == 11`；doubao 场景下同一路径 `memberId == 10`。
+- Given 已发起回滚，When 调用 `history_revert_status`，Then 经 `QueryRecoverStatus` 返回可区分的回滚状态。
+
+### BE-5: sheet/data 透传 scene 并在 RecoverMsg 上新增 Scene 字段
+
+```yaml
+psm: bear.server.sheet_data
+repo: sheet/data
+module: biz/history
+be_deploy_required: true
+thrift_impact: 无
+api: bear.server.sheet_data::RecoverHistory / QueryRecoverStatus（复用）；MQ RecoverMsg 加 Scene 字段
+depends_on: []
+estimate: 1d
+```
+
+**调用的下游服务**：复用既有回滚链路（`biz/history/service/recover.go::RecoverHistory` → `infra/mq/producer/recover.go::SendRecoverMsg`）。
+**实现要点**：
+- **scene 透传**：把 agg 经 ctx 传入的 scene 接住，贯穿 `RecoverHistory`（`biz/history/service/recover.go`）到 `RecoverMsg` 构造处。
+- **RecoverMsg 加 `Scene` 字段**：在 `infra/mq/producer/recover.go` 的 `RecoverMsg` struct 上新增 `Scene` 字段并在投递时赋值。`RecoverMsg` 是 JSON Go struct（`recoverProducer.NewMessage`），**加字段非 thrift**——`thrift_impact: 无`。
+- `QueryRecoverStatus` 与回滚业务语义保持不变，仅承载 scene 透传。
+**边界**：不改回滚 / 历史快照业务逻辑；只加 scene 透传与 `RecoverMsg.Scene` 字段。
+**scene 透传方式（已定）**：经 **ctx baggage**（`metainfo` / 沿用既有 `utils.WithSceneDoubao(ctx)` 范式）从 agg 透传到 `RecoverHistory`，**不**在 `RecoverHistoryReq` thrift 上加字段 → 零 IDL 变更，`thrift_impact: 无`。
+**验收场景**：
+- Given agg 以 scene=lark-cli 调 `RecoverHistory`，Then 投递的 `RecoverMsg.Scene` 标识 lark-cli；doubao 同理。
+- Given 回滚已发起，When `QueryRecoverStatus(transactionID)`，Then 返回回滚状态（语义与现状一致）。
+- Given lark-cli（scene=lark-cli）经 `tools/invoke_write` 调用 `history_revert`，Then 构造的 recover cs 中 `memberId == 11`；doubao 场景下同一工具 `memberId == 10`。
+- Given 已发起回滚，When 调用 `history_revert_status`，Then 返回可区分的回滚状态。
+
+## API 契约引用
+
+本需求三个接口均为飞书电子表格已上线 space 接口，契约以各仓库最新 master 为准；对应 thrift 定义按 PRD 提示在 `lark/idl` 中搜索确认（实现阶段补全精确路径）：
+
+- 查列表：`/space/api/v3/sheet/histories`（取 `minor_histories`）
+- 回滚：`/space/api/v2/sheet/recover`
+- 回滚状态：`/api/v2/sheet/recover/status`
+
+> 契约本体不进本 spec 正文；精确 `lark/idl/...thrift::Service::Method` 路径在实现阶段确认并回填到对应 BE-* 的 `api` 字段说明。
+
+## 验收场景（汇总）
+
+- 列表：`+history-list` 仅返回 `minor_histories`，每条恰好 4 个字段，`id` 重命名为 `history_version_id`，`create_time` 为 AI 优化可读格式。
+- 回滚：`+history-revert` → agg `history_revert` → `sheet/data.RecoverHistory`（异步），受理后返回可查询标识。
+- memberId/scene：agg 消费 `RecoverMsg` 构造 recover cs 时，按 `RecoverMsg.Scene` 赋 `memberId`——lark-cli=11、doubao=10（facade-agg 侧单测断言）。
+- 状态：`+history-revert-status` → `QueryRecoverStatus` 能查询并区分回滚的进行中 / 成功 / 失败。
+- skill 同步：`sheet-skill-spec` 生成产物经 `sync:cli` 落地到 cli 仓，`check:all` 全绿。
+- 三个 shortcut 在 cli 中遵循统一的 Validate / DryRun / Execute 三段约定与现有 sheets shortcut 一致。
+
+## 非功能要求与约束
+
+- **复用既有模式**：3 个 shortcut 必须沿用 `shortcuts/sheets` 现有的 token 解析（`--spreadsheet-token` / `--token` 别名）、错误封装（`errs`）、`callTool`（`tools/invoke_read|write`）调用与 DryRun 渲染范式，不另起调用框架。facade-agg 侧必须复用现有 `ToolsCall` 接口扩展工具，不新增独立 OpenAPI 路由。
+- **AI 友好输出**：`+history-list` 的字段裁剪与 `create_time` 可读格式是硬约束（PRD「实现差异点」），目的是降低 AI 消费成本。
+- **工作流约束**：skill 内容与 flag 定义的唯一事实源是 `ee/sheet-skill-spec`；cli 仓的 `skills/lark-sheets/` 与 `shortcuts/sheets/data/` 为同步产物，不手改。
+- **回滚为异步**：`+history-revert` 与 `+history-revert-status` 分离，调用方需理解「发起 → 轮询」两步语义。
+- **事实基准**：所有外部仓库事实（space 接口、facade-agg 路由、sheet_data 能力）以各仓库最新 master 为准。
+
+## 安全设计
+
+- security_knowledge_ref: UNCONFIGURED
+- 风险判断依据: 未配置安全知识库，待安全侧补齐。需关注点（供安全侧复核）：`+history-revert` 是**写 / 不可逆**操作（覆盖当前表格内容到历史版本），必须校验操作者对目标表格具备编辑 / 回滚权限；历史版本列表可能暴露协作者操作痕迹（`action` 字段），需确认读权限边界。
+- 身份归属风险（memberId/scene）: `memberId` 须按 scene 正确赋值（lark-cli=11 / doubao=10）。错配会使回滚操作归属错误的调用方身份，影响审计与权限判定——属安全/审计相关，须在 agg RecoverMsg 消费侧保证赋值正确。
+- 需要安全侧补充: 回滚操作的权限校验口径、历史 `action` 字段的可见性范围是否需脱敏、memberId 与真实操作者身份的映射是否需对齐审计要求。
+
+## Codegen Delivery Plan
+
+applicable: true
+
+### A. Branch Plan
+
+| `key` | value |
+|---|---|
+| `psm` | `sheet.facade.agg` |
+| `business_branch` | `feat/sheet-history-revert` |
+| `generated_branch` | `N/A` |
+| `idl_branch` | `N/A` |
+| `kitex_branch` | `N/A` |
+
+### B. Delivery Targets
+
+| repo | required | branch | artifact_paths | reason |
+|---|---|---|---|---|
+| larksuite/cli | yes | feat/sheet-history-revert | shortcuts/sheets/ , skills/lark-sheets/ | 3 个 shortcut 实现 + 同步落地的 skill 正文与 flag 数据 |
+| ee/sheet-skill-spec | yes | feat/sheet-history-revert | canonical-spec/references/ , generated/lark-cli/ | skill / flag 上游事实源，生成后 sync 到 cli |
+| ee/sheet-facade-agg | yes | feat/sheet-history-revert | biz/handler/ | 现有 ToolsCall 新增 3 个工具 + scene 透传 + RecoverMsg 消费者按 scene 赋 memberId |
+| sheet/data | yes | feat/sheet-history-revert | biz/history/ , infra/mq/producer/ | RecoverHistory 透传 scene + RecoverMsg 新增 Scene 字段（JSON，非 thrift） |
+
+### C. Generation Decision
+
+| `key` | value |
+|---|---|
+| `needs_kitex_gen` | no |
+| `needs_apacana` | no |
+| `needs_kite_via_sdp` | no |
+| `decision_basis` | facade-agg 复用现有 ToolsCall 框架按 tool_name 注册 3 个工具（JSON input，不动 ai.ToolsCallRequest thrift）；sheet/data 仅在 RecoverMsg（JSON Go struct）加 Scene 字段 + 经 ctx baggage 透传 scene，复用既有 RecoverHistory/QueryRecoverStatus，均非 thrift；lark-cli 经现有 callTool 包装。scene 已定走 ctx baggage（不加 RecoverHistoryReq thrift 字段），无新增/修改 kitex/apacana/SDP 契约 |
+
+### D. Branch Naming Rule
+
+业务分支统一用 `feat/sheet-history-revert`；本需求无 codegen，故 `generated_branch` / `idl_branch` / `kitex_branch` 均为 `N/A`。
+
+## thrift 变更需求清单
+
+无（按推荐实现路径）。三个接口的能力已存在；本需求的新增内容是：facade-agg 在 ToolsCall 上注册 3 个工具（`tool_name`+JSON，不动 `ai.ToolsCallRequest`）、sheet/data 在 `RecoverMsg`（JSON Go struct）上加 `Scene` 字段、scene 经 **ctx baggage** 透传——均不涉及 thrift。
+
+**scene 透传方式：已定为 ctx baggage**（`metainfo` / 沿用既有 `utils.WithSceneDoubao(ctx)` 范式），明确**不**在 `bear.server.sheet_data` 的 `RecoverHistoryReq` thrift 上加字段。故本需求确无任何 thrift struct / RPC method / enum 的新增或修改，Generation Decision 三路保持 `no`、无 codegen。
+
+## N. AI Capability Manifest
+
+applicable: false
+
+本需求为确定性 CLI 命令封装，不含 LLM / prompt 驱动的 AI 能力。`+history-list` 中「`create_time` 序列化成 AI 优化格式」仅指对机器/AI 更易读的时间字符串格式化，属确定性数据转换，非 AI capability。
--- a/events/register.go
+++ b/events/register.go
@@ -7,7 +7,6 @@ package events
 import (
 	"github.com/larksuite/cli/events/im"
 	"github.com/larksuite/cli/events/minutes"
-	"github.com/larksuite/cli/events/task"
 	"github.com/larksuite/cli/events/vc"
 	"github.com/larksuite/cli/events/whiteboard"
 	"github.com/larksuite/cli/internal/event"
@@ -18,7 +17,6 @@ func init() {
 	all := [][]event.KeyDefinition{
 		im.Keys(),
 		minutes.Keys(),
-		task.Keys(),
 		vc.Keys(),
 		whiteboard.Keys(),
 	}
--- a/events/task/native.go
+++ b/events/task/native.go
@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package task
-
-// TaskUpdateUserAccessV2Data is the Task v2 update event payload under the
-// standard Lark V2 event envelope.
-type TaskUpdateUserAccessV2Data struct {
-	EventTypes []string `json:"event_types,omitempty" desc:"Task commit types included in this event" enum:"task_create,task_deleted,task_summary_update,task_desc_update,task_assignees_update,task_followers_update,task_reminders_update,task_start_due_update,task_completed_update"`
-	TaskGUID   string   `json:"task_guid,omitempty" desc:"Task GUID that changed" kind:"task_guid"`
-}
-
-var taskUpdateUserAccessCommitTypes = []string{
-	"task_create",
-	"task_deleted",
-	"task_summary_update",
-	"task_desc_update",
-	"task_assignees_update",
-	"task_followers_update",
-	"task_reminders_update",
-	"task_start_due_update",
-	"task_completed_update",
-}
--- a/events/task/preconsume.go
+++ b/events/task/preconsume.go
@@ -1,32 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package task
-
-import (
-	"context"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/event"
-)
-
-const taskSubscriptionPath = "/open-apis/task/v2/task_v2/task_subscription?user_id_type=open_id"
-
-func taskSubscriptionPreConsume(ctx context.Context, rt event.APIClient, _ map[string]string) (func() error, error) {
-	if rt == nil {
-		return nil, errs.NewInternalError(errs.SubtypeUnknown,
-			"runtime API client is required for pre-consume subscription")
-	}
-
-	if _, err := rt.CallAPI(ctx, "POST", taskSubscriptionPath, nil); err != nil {
-		if _, ok := errs.ProblemOf(err); ok {
-			return nil, err
-		}
-		return nil, errs.NewNetworkError(
-			errs.SubtypeNetworkTransport,
-			"failed to subscribe task event",
-		).WithCause(err)
-	}
-
-	return nil, nil
-}
--- a/events/task/preconsume_test.go
+++ b/events/task/preconsume_test.go
@@ -1,119 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package task
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-type stubAPIClient struct {
-	err error
-
-	method string
-	path   string
-	body   interface{}
-	calls  int
-}
-
-func (s *stubAPIClient) CallAPI(_ context.Context, method, path string, body interface{}) (json.RawMessage, error) {
-	s.method = method
-	s.path = path
-	s.body = body
-	s.calls++
-	if s.err != nil {
-		return nil, s.err
-	}
-	return json.RawMessage(`{"code":0,"msg":"success","data":{}}`), nil
-}
-
-func TestTaskSubscriptionPreConsumeCallsSubscribeAPI(t *testing.T) {
-	rt := &stubAPIClient{}
-	cleanup, err := taskSubscriptionPreConsume(context.Background(), rt, nil)
-	if err != nil {
-		t.Fatalf("taskSubscriptionPreConsume error = %v", err)
-	}
-	if cleanup != nil {
-		t.Fatal("cleanup = non-nil, want nil because task subscription has no unsubscribe API")
-	}
-	if rt.calls != 1 {
-		t.Fatalf("calls = %d, want 1", rt.calls)
-	}
-	if rt.method != "POST" {
-		t.Errorf("method = %q, want POST", rt.method)
-	}
-	if rt.path != taskSubscriptionPath {
-		t.Errorf("path = %q, want %q", rt.path, taskSubscriptionPath)
-	}
-	if rt.body != nil {
-		t.Errorf("body = %#v, want nil", rt.body)
-	}
-}
-
-func TestTaskSubscriptionPreConsumeRequiresRuntime(t *testing.T) {
-	_, err := taskSubscriptionPreConsume(context.Background(), nil, nil)
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed error, got %T: %v", err, err)
-	}
-	if p.Category != errs.CategoryInternal {
-		t.Errorf("category = %s, want %s", p.Category, errs.CategoryInternal)
-	}
-	if p.Subtype != errs.SubtypeUnknown {
-		t.Errorf("subtype = %s, want %s", p.Subtype, errs.SubtypeUnknown)
-	}
-}
-
-func TestTaskSubscriptionPreConsumePassesThroughAPIError(t *testing.T) {
-	wantErr := errs.NewValidationError(errs.SubtypeFailedPrecondition, "subscription already exists")
-	rt := &stubAPIClient{err: wantErr}
-
-	_, err := taskSubscriptionPreConsume(context.Background(), rt, nil)
-	if err != wantErr {
-		t.Fatalf("err identity changed: got %T %v, want original %T %v", err, err, wantErr, wantErr)
-	}
-	if !errors.Is(err, wantErr) {
-		t.Fatalf("err = %v, want %v", err, wantErr)
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed error, got %T: %v", err, err)
-	}
-	if p.Category != errs.CategoryValidation {
-		t.Errorf("category = %s, want %s", p.Category, errs.CategoryValidation)
-	}
-	if p.Subtype != errs.SubtypeFailedPrecondition {
-		t.Errorf("subtype = %s, want %s", p.Subtype, errs.SubtypeFailedPrecondition)
-	}
-}
-
-func TestTaskSubscriptionPreConsumeWrapsUntypedAPIError(t *testing.T) {
-	cause := errors.New("connection reset")
-	rt := &stubAPIClient{err: cause}
-
-	_, err := taskSubscriptionPreConsume(context.Background(), rt, nil)
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !errors.Is(err, cause) {
-		t.Fatalf("err = %v, want cause %v", err, cause)
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed error, got %T: %v", err, err)
-	}
-	if p.Category != errs.CategoryNetwork {
-		t.Errorf("category = %s, want %s", p.Category, errs.CategoryNetwork)
-	}
-	if p.Subtype != errs.SubtypeNetworkTransport {
-		t.Errorf("subtype = %s, want %s", p.Subtype, errs.SubtypeNetworkTransport)
-	}
-}
--- a/events/task/register.go
+++ b/events/task/register.go
@@ -1,33 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package task registers Task-domain EventKeys.
-package task
-
-import (
-	"reflect"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-const eventTypeTaskUpdateUserAccessV2 = "task.task.update_user_access_v2"
-
-// Keys returns all Task-domain EventKey definitions.
-func Keys() []event.KeyDefinition {
-	return []event.KeyDefinition{
-		{
-			Key:         eventTypeTaskUpdateUserAccessV2,
-			DisplayName: "Task updated",
-			Description: "Triggered when tasks visible to the current user or app are created, deleted, or updated",
-			EventType:   eventTypeTaskUpdateUserAccessV2,
-			Schema: event.SchemaDef{
-				Native: &event.SchemaSpec{Type: reflect.TypeOf(TaskUpdateUserAccessV2Data{})},
-			},
-			PreConsume:            taskSubscriptionPreConsume,
-			Scopes:                []string{"task:task:read"},
-			AuthTypes:             []string{"user", "bot"},
-			RequiredConsoleEvents: []string{eventTypeTaskUpdateUserAccessV2},
-			SingleConsumer:        true,
-		},
-	}
-}
--- a/events/task/register_test.go
+++ b/events/task/register_test.go
@@ -1,95 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package task
-
-import (
-	"encoding/json"
-	"reflect"
-	"testing"
-
-	"github.com/larksuite/cli/internal/event"
-	"github.com/larksuite/cli/internal/event/schemas"
-)
-
-func TestKeysTaskUpdateUserAccessMetadata(t *testing.T) {
-	keys := Keys()
-	if len(keys) != 1 {
-		t.Fatalf("len(Keys()) = %d, want 1", len(keys))
-	}
-
-	def := keys[0]
-	if def.Key != eventTypeTaskUpdateUserAccessV2 {
-		t.Errorf("Key = %q, want %q", def.Key, eventTypeTaskUpdateUserAccessV2)
-	}
-	if def.EventType != eventTypeTaskUpdateUserAccessV2 {
-		t.Errorf("EventType = %q, want %q", def.EventType, eventTypeTaskUpdateUserAccessV2)
-	}
-	if def.Schema.Native == nil {
-		t.Fatal("Schema.Native is nil")
-	}
-	if def.Schema.Native.Type != reflect.TypeOf(TaskUpdateUserAccessV2Data{}) {
-		t.Errorf("native type = %v, want TaskUpdateUserAccessV2Data", def.Schema.Native.Type)
-	}
-	if def.Process != nil {
-		t.Fatal("Native Task EventKey must not set Process")
-	}
-	if def.PreConsume == nil {
-		t.Fatal("PreConsume is nil")
-	}
-	if !def.SingleConsumer {
-		t.Fatal("SingleConsumer = false, want true")
-	}
-	if !reflect.DeepEqual(def.Scopes, []string{"task:task:read"}) {
-		t.Errorf("Scopes = %#v", def.Scopes)
-	}
-	if !reflect.DeepEqual(def.AuthTypes, []string{"user", "bot"}) {
-		t.Errorf("AuthTypes = %#v", def.AuthTypes)
-	}
-	if !reflect.DeepEqual(def.RequiredConsoleEvents, []string{eventTypeTaskUpdateUserAccessV2}) {
-		t.Errorf("RequiredConsoleEvents = %#v", def.RequiredConsoleEvents)
-	}
-}
-
-func TestTaskUpdateUserAccessSchemaAnnotations(t *testing.T) {
-	raw := schemas.WrapV2Envelope(schemas.FromType(reflect.TypeOf(TaskUpdateUserAccessV2Data{})))
-	var schema map[string]interface{}
-	if err := json.Unmarshal(raw, &schema); err != nil {
-		t.Fatalf("unmarshal schema: %v", err)
-	}
-
-	eventProps := schema["properties"].(map[string]interface{})["event"].(map[string]interface{})["properties"].(map[string]interface{})
-	taskGUID := eventProps["task_guid"].(map[string]interface{})
-	if got := taskGUID["format"]; got != "task_guid" {
-		t.Errorf("task_guid format = %v, want task_guid", got)
-	}
-
-	eventTypes := eventProps["event_types"].(map[string]interface{})
-	items := eventTypes["items"].(map[string]interface{})
-	rawEnum, ok := items["enum"].([]interface{})
-	if !ok {
-		t.Fatalf("event_types item enum missing: %#v", items["enum"])
-	}
-	got := make(map[string]bool, len(rawEnum))
-	for _, v := range rawEnum {
-		got[v.(string)] = true
-	}
-	for _, want := range taskUpdateUserAccessCommitTypes {
-		if !got[want] {
-			t.Errorf("event_types enum missing %q; enum=%v", want, rawEnum)
-		}
-	}
-}
-
-func TestTaskUpdateUserAccessRegistersCleanly(t *testing.T) {
-	const key = eventTypeTaskUpdateUserAccessV2
-	event.UnregisterKeyForTest(key)
-	t.Cleanup(func() { event.UnregisterKeyForTest(key) })
-
-	for _, def := range Keys() {
-		event.RegisterKey(def)
-	}
-	if _, ok := event.Lookup(key); !ok {
-		t.Fatalf("event.Lookup(%q) not registered", key)
-	}
-}
--- a/go.mod
+++ b/go.mod
@@ -27,6 +27,8 @@ require (
 	gopkg.in/yaml.v3 v3.0.1
 )

+require github.com/apache/arrow/go/v17 v17.0.0
+
 require (
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
@@ -42,13 +44,17 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/goccy/go-json v0.10.3 // indirect
 	github.com/godbus/dbus/v5 v5.2.2 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/google/flatbuffers v24.3.25+incompatible // indirect
 	github.com/gopherjs/gopherjs v1.17.2 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/itchyny/timefmt-go v0.1.6 // indirect
 	github.com/jtolds/gls v4.20.0+incompatible // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
@@ -57,10 +63,16 @@ require (
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
+	github.com/pierrec/lz4/v4 v4.1.21 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/smarty/assertions v1.15.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	github.com/zeebo/xxh3 v1.0.2 // indirect
+	golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 // indirect
+	golang.org/x/mod v0.18.0 // indirect
+	golang.org/x/tools v0.22.0 // indirect
+	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -2,6 +2,8 @@ github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ
 github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/apache/arrow/go/v17 v17.0.0 h1:RRR2bdqKcdbss9Gxy2NS/hK8i4LDMh23L6BbkN5+F54=
+github.com/apache/arrow/go/v17 v17.0.0/go.mod h1:jR7QHkODl15PfYyjM2nU+yTLScZ/qfj7OSUZmJ8putc=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
@@ -52,12 +54,16 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
+github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
 github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/google/flatbuffers v24.3.25+incompatible h1:CX395cjN9Kke9mmalRoL3d81AtFUxJM+yDthflgJGkI=
+github.com/google/flatbuffers v24.3.25+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
@@ -74,11 +80,16 @@ github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
+github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/larksuite/oapi-sdk-go/v3 v3.5.4 h1:U2S9x9LrfH++ZqJ+YAiUlqzCWJmVXhFdS8Z7rIBH8H0=
 github.com/larksuite/oapi-sdk-go/v3 v3.5.4/go.mod h1:ZEplY+kwuIrj/nqw5uSCINNATcH3KdxSN7y+UxYY5fI=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
@@ -97,6 +108,8 @@ github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELU
 github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
 github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
+github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
@@ -133,14 +146,20 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/zalando/go-keyring v0.2.8 h1:6sD/Ucpl7jNq10rM2pgqTs0sZ9V3qMrqfIIy5YPccHs=
 github.com/zalando/go-keyring v0.2.8/go.mod h1:tsMo+VpRq5NGyKfxoBVjCuMrG47yj8cmakZDO5QGii0=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
+github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 h1:LfspQV/FYTatPTr/3HzIcmiUFH7PGP+OQ6mgDYo3yuQ=
+golang.org/x/exp v0.0.0-20240222234643-814bf88cf225/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
+golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -156,6 +175,7 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
@@ -169,10 +189,16 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
+golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+gonum.org/v1/gonum v0.15.0 h1:2lYxjRbTYyxkJxlhC+LvJIx3SsANPdRybu1tGj9/OrQ=
+gonum.org/v1/gonum v0.15.0/go.mod h1:xzZVBJBtS+Mz4q0Yl2LJTk+OxOg4jiXZ7qBoM0uISGo=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
--- a/internal/meta/normalize.go
+++ b/internal/meta/normalize.go
@@ -113,8 +113,7 @@ type EnumOption struct {
 }

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

-func TestField_EnumOptions_BothEnumAndOptions(t *testing.T) {
-	// enum is the value set; descriptions backfilled from options, empty where absent
-	f := Field{Type: "string", Enum: []any{"1", "2", "3", "4", "6"}, Options: []Option{
-		{Value: "1", Description: "from"},
-		{Value: "2", Description: "to"},
-		{Value: "6", Description: "subject"},
-	}}
-	want := []EnumOption{
-		{Value: "1", Description: "from"},
-		{Value: "2", Description: "to"},
-		{Value: "3", Description: ""},
-		{Value: "4", Description: ""},
-		{Value: "6", Description: "subject"},
-	}
-	if got := f.EnumOptions(); !reflect.DeepEqual(got, want) {
-		t.Errorf("EnumOptions(enum+options) = %+v, want %+v", got, want)
-	}
-
-	// enum values stored as strings match option values stored as numbers
-	fi := Field{Type: "integer", Enum: []any{"10", "2", "1"}, Options: []Option{
-		{Value: 1, Description: "one"},
-		{Value: 2, Description: "two"},
-	}}
-	wantI := []EnumOption{
-		{Value: int64(1), Description: "one"},
-		{Value: int64(2), Description: "two"},
-		{Value: int64(10), Description: ""},
-	}
-	if got := fi.EnumOptions(); !reflect.DeepEqual(got, wantI) {
-		t.Errorf("EnumOptions(integer enum+options) = %+v, want %+v", got, wantI)
-	}
-}
-
 func TestField_Enum_NumberAndBoolean(t *testing.T) {
 	// number: string-stored floats coerced to float64 and numerically sorted
 	if got := (Field{Type: "number", Enum: []any{"2.5", "1.5", "10"}}).EnumValues(); !reflect.DeepEqual(got, []any{1.5, 2.5, float64(10)}) {
--- a/internal/schema/assembler_test.go
+++ b/internal/schema/assembler_test.go
@@ -472,18 +472,6 @@ func TestConvert_EnumDescriptions(t *testing.T) {
 	if bare.EnumDescriptions != nil {
 		t.Errorf("bare enum must have nil EnumDescriptions, got %v", bare.EnumDescriptions)
 	}
-
-	// enum + options both present -> enumDescriptions backfilled, aligned, "" where absent
-	both := Convert(meta.Field{Type: "string", Enum: []any{"1", "2", "3"}, Options: []meta.Option{
-		{Value: "1", Description: "from"},
-		{Value: "2", Description: "to"},
-	}})
-	if !reflect.DeepEqual(both.Enum, []interface{}{"1", "2", "3"}) {
-		t.Errorf("both Enum = %v", both.Enum)
-	}
-	if !reflect.DeepEqual(both.EnumDescriptions, []string{"from", "to", ""}) {
-		t.Errorf("both EnumDescriptions = %v, want [from to \"\"] aligned with enum", both.EnumDescriptions)
-	}
 }

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

 	"github.com/larksuite/cli/extension/fileio"
@@ -85,9 +84,6 @@ var AppsHTMLPublish = common.Shortcut{
 			// for dry-run "advisory preview" semantics).
 			dry.Set("validation_error", err.Error())
 		}
-		if hits := oversizeHTMLFiles(candidates); len(hits) > 0 {
-			dry.Set("oversize_html", hits)
-		}
 		dry.Set("file_count", len(candidates))
 		var totalSize int64
 		names := make([]string, 0, len(candidates))
@@ -144,22 +140,18 @@ type appsHTMLPublishSpec struct {
 // per-environment .env.* files for every stage).
 const maxSensitiveListInError = 5

-// truncatedJoin joins items with ", ", capping at max entries and appending
-// "(and N more)" for the remainder, so an inline error list stays readable when
-// a payload has many hits.
-func truncatedJoin(items []string, max int) string {
-	if len(items) <= max {
-		return strings.Join(items, ", ")
-	}
-	return strings.Join(items[:max], ", ") + fmt.Sprintf(" (and %d more)", len(items)-max)
-}
-
 // sensitiveCandidatesError builds the Validate-time rejection when --path
 // contains credential files and --allow-sensitive was not set.
 func sensitiveCandidatesError(hits []string) error {
+	var sample string
+	if len(hits) <= maxSensitiveListInError {
+		sample = strings.Join(hits, ", ")
+	} else {
+		sample = strings.Join(hits[:maxSensitiveListInError], ", ") +
+			fmt.Sprintf(" (and %d more)", len(hits)-maxSensitiveListInError)
+	}
 	return appsValidationParamError("--path",
-		"--path contains %d credential file(s) that should not be published: %s",
-		len(hits), truncatedJoin(hits, maxSensitiveListInError)).
+		"--path contains %d credential file(s) that should not be published: %s", len(hits), sample).
 		WithHint("remove these files from the publish payload, OR pass --allow-sensitive if shipping them is intentional (e.g. a docs site demoing credential-file formats)")
 }

@@ -176,30 +168,6 @@ var maxHTMLPublishTarballBytes int64 = 20 * 1024 * 1024
 // Mutable for tests.
 var maxHTMLPublishRawBytes int64 = 200 * 1024 * 1024

-// maxHTMLPublishSingleHTMLFileBytes 单个 .html 文件上限，对齐妙搭服务端 10MB 约束。
-// 用 var 而非 const，便于单测调小覆盖拦截路径。
-var maxHTMLPublishSingleHTMLFileBytes int64 = 10 * 1024 * 1024
-
-// oversizeHTMLFiles 返回 candidates 中扩展名为 .html（大小写不敏感）且单个 Size 超过
-// maxHTMLPublishSingleHTMLFileBytes 的 RelPath 列表。只针对 .html 文件，不波及图片/字体/JS。
-func oversizeHTMLFiles(candidates []htmlPublishCandidate) []string {
-	var hits []string
-	for _, c := range candidates {
-		if strings.EqualFold(filepath.Ext(c.RelPath), ".html") && c.Size > maxHTMLPublishSingleHTMLFileBytes {
-			hits = append(hits, c.RelPath)
-		}
-	}
-	return hits
-}
-
-// oversizeHTMLFilesError 构造单文件超限的 Validate 风格拒绝。
-func oversizeHTMLFilesError(hits []string) error {
-	return appsValidationParamError("--path",
-		"--path contains %d HTML file(s) exceeding the %d bytes (10MB) per-file limit: %s",
-		len(hits), maxHTMLPublishSingleHTMLFileBytes, truncatedJoin(hits, maxSensitiveListInError)).
-		WithHint("split or trim oversized HTML file(s); the 10MB cap applies to each single .html file")
-}
-
 // ensureIndexHTML 要求 walker 抓到的 candidates 里必须含 index.html。
 // 目录形态：根目录下必须有 index.html。
 // 单文件形态：文件名必须就是 index.html。
@@ -222,9 +190,6 @@ func runHTMLPublish(ctx context.Context, fio fileio.FileIO, publisher appsHTMLPu
 	if err := ensureIndexHTML(candidates); err != nil {
 		return nil, err
 	}
-	if hits := oversizeHTMLFiles(candidates); len(hits) > 0 {
-		return nil, oversizeHTMLFilesError(hits)
-	}
 	var rawTotal int64
 	for _, c := range candidates {
 		rawTotal += c.Size
--- a/shortcuts/apps/apps_html_publish_test.go
+++ b/shortcuts/apps/apps_html_publish_test.go
@@ -503,82 +503,3 @@ func TestRunHTMLPublish_RejectsOversizeRawCandidates(t *testing.T) {
 		t.Fatalf("client must not be called when raw cap hit")
 	}
 }
-
-func TestOversizeHTMLFiles(t *testing.T) {
-	orig := maxHTMLPublishSingleHTMLFileBytes
-	maxHTMLPublishSingleHTMLFileBytes = 100
-	defer func() { maxHTMLPublishSingleHTMLFileBytes = orig }()
-
-	cands := []htmlPublishCandidate{
-		{RelPath: "index.html", Size: 50},
-		{RelPath: "big.html", Size: 4096},
-		{RelPath: "BIG.HTML", Size: 4096}, // 大小写不敏感
-		{RelPath: "huge.png", Size: 9000}, // 非 .html，忽略
-	}
-	hits := oversizeHTMLFiles(cands)
-	if len(hits) != 2 {
-		t.Fatalf("hits=%v, want [big.html BIG.HTML]", hits)
-	}
-	for _, h := range hits {
-		if h == "huge.png" || h == "index.html" {
-			t.Fatalf("unexpected hit %q", h)
-		}
-	}
-}
-
-func TestMaxHTMLPublishSingleHTMLFileBytes_Default(t *testing.T) {
-	if maxHTMLPublishSingleHTMLFileBytes != 10*1024*1024 {
-		t.Fatalf("default=%d, want %d (10MiB)", maxHTMLPublishSingleHTMLFileBytes, 10*1024*1024)
-	}
-}
-
-func TestRunHTMLPublish_RejectsOversizeHTMLFile(t *testing.T) {
-	orig := maxHTMLPublishSingleHTMLFileBytes
-	maxHTMLPublishSingleHTMLFileBytes = 100
-	defer func() { maxHTMLPublishSingleHTMLFileBytes = orig }()
-
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("<html></html>"), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "big.html"), []byte(strings.Repeat("x", 4096)), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	fake := &fakeAppsHTMLPublishClient{}
-	_, err := runHTMLPublish(context.Background(), newTestFIO(), fake, appsHTMLPublishSpec{AppID: "app_x", Path: dir})
-	if err == nil {
-		t.Fatalf("expected per-file oversize error")
-	}
-	problem := requireAppsValidationProblem(t, err)
-	if !strings.Contains(problem.Message, "big.html") || !strings.Contains(problem.Message, "10MB") {
-		t.Fatalf("message=%q, want contains 'big.html' and '10MB'", problem.Message)
-	}
-	if problem.Hint == "" {
-		t.Fatalf("expected non-empty hint")
-	}
-	if len(fake.calls) != 0 {
-		t.Fatalf("client must not be called when an HTML file is oversize")
-	}
-}
-
-func TestRunHTMLPublish_IgnoresOversizeNonHTML(t *testing.T) {
-	// 单 .html 上限调小，但超限文件是 .png → 不被本护栏拦截，正常发布。
-	orig := maxHTMLPublishSingleHTMLFileBytes
-	maxHTMLPublishSingleHTMLFileBytes = 100
-	defer func() { maxHTMLPublishSingleHTMLFileBytes = orig }()
-
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("<html></html>"), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "big.png"), []byte(strings.Repeat("x", 4096)), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-	fake := &fakeAppsHTMLPublishClient{resp: &htmlPublishResponse{URL: "https://miaoda/app_x"}}
-	if _, err := runHTMLPublish(context.Background(), newTestFIO(), fake, appsHTMLPublishSpec{AppID: "app_x", Path: dir}); err != nil {
-		t.Fatalf("non-html oversize must not be blocked by the .html cap: %v", err)
-	}
-	if len(fake.calls) != 1 {
-		t.Fatalf("client should be called; calls=%v", fake.calls)
-	}
-}
--- a/shortcuts/apps/apps_init.go
+++ b/shortcuts/apps/apps_init.go
@@ -99,14 +99,7 @@ var AppsInit = common.Shortcut{
 			dry.Set("dir_error", err.Error())
 			dir = defaultCloneDir(appID)
 		} else if isAlreadyInitialized(dir) {
-			if existing, e := ensureInitDirMatchesApp(dir, appID); e != nil {
-				if existing != "" {
-					dry.Set("app_id_mismatch", existing)
-				}
-				dry.Set("dir_error", e.Error())
-			} else {
-				dry.Set("already_initialized", true)
-			}
+			dry.Set("already_initialized", true)
 		} else if e := ensureEmptyDir(dir); e != nil {
 			dry.Set("dir_error", e.Error())
 		}
@@ -206,61 +199,6 @@ func isAlreadyInitialized(dir string) bool {
 	return err == nil && !info.IsDir()
 }

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

-	// 异 app 目录护栏：拒绝把当前 app 初始化进另一个 app 的已初始化工程。
-	if _, err := ensureInitDirMatchesApp(dir, appID); err != nil {
-		return err
-	}
-
 	// Already-initialized short-circuit: a dir containing .spark/meta.json is an
 	// initialized app repo -> skip clone/scaffold/commit, but still refresh
 	// the local env so a re-run picks up the latest startup env vars.
--- a/shortcuts/apps/apps_init_test.go
+++ b/shortcuts/apps/apps_init_test.go
@@ -363,7 +363,7 @@ func TestAppsInit_AlreadyInitialized_ShortCircuit(t *testing.T) {
 	if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(`{"app_id":"app_x"}`), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(`{"app_id":"whatever"}`), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{"env-pull": envPullOK(filepath.Join(abs, ".env.local"))}}
@@ -394,40 +394,6 @@ func TestAppsInit_AlreadyInitialized_ShortCircuit(t *testing.T) {
 	}
 }

-func TestAppsInit_AlreadyInitialized_AppIDMismatch(t *testing.T) {
-	dir := relCloneDir(t)
-	if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	// 目录是 app_other 的工程，却用 --app-id app_x 初始化 → 必须报错且不拉 env。
-	if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(`{"app_id":"app_other"}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeCommandRunner{}
-	withFakeRunner(t, f)
-	factory, stdout, _ := newAppsExecuteFactory(t)
-	err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_x", "--dir", dir, "--as", "user"}, factory, stdout)
-	if err == nil {
-		t.Fatal("mismatched app_id must error")
-	}
-	problem := requireAppsValidationProblem(t, err)
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype=%q, want %q", problem.Subtype, errs.SubtypeInvalidArgument)
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) || ve.Param != "--dir" {
-		t.Fatalf("expected *errs.ValidationError with Param=--dir, got %T param=%v", err, ve)
-	}
-	if !strings.Contains(problem.Message, "different app") {
-		t.Fatalf("message=%q, want 'different app'", problem.Message)
-	}
-	for _, c := range f.calls {
-		if containsAll(c, "+env-pull") || containsAll(c, "git", "clone") {
-			t.Errorf("mismatch must not run env-pull/clone; got %v", f.calls)
-		}
-	}
-}
-
 func TestAppsInit_HappyPathCleanTree(t *testing.T) {
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{
 		"credential-init": credInitOK("http://u:t@h/app_x.git"),
@@ -1502,125 +1468,6 @@ func TestAppsInit_Description_IsAboutCode(t *testing.T) {
 	}
 }

-func TestReadMetaAppID(t *testing.T) {
-	writeMeta := func(t *testing.T, content string) string {
-		t.Helper()
-		dir := t.TempDir()
-		if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(content), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		return dir
-	}
-
-	// 不存在 meta.json → ("", false, nil)
-	if got, ok, err := readMetaAppID(t.TempDir()); ok || got != "" || err != nil {
-		t.Fatalf("no meta: got (%q,%v,%v), want (\"\",false,nil)", got, ok, err)
-	}
-	// 存在且有 app_id → (app_id, true, nil)
-	if got, ok, err := readMetaAppID(writeMeta(t, `{"app_id":"app_a"}`)); !ok || got != "app_a" || err != nil {
-		t.Fatalf("with app_id: got (%q,%v,%v), want (\"app_a\",true,nil)", got, ok, err)
-	}
-	// 存在但 app_id 空 → ("", true, nil)
-	if got, ok, err := readMetaAppID(writeMeta(t, `{"name":"x"}`)); !ok || got != "" || err != nil {
-		t.Fatalf("empty app_id: got (%q,%v,%v), want (\"\",true,nil)", got, ok, err)
-	}
-	// 存在但坏 JSON → ("", false, err)（无法确认）
-	if got, ok, err := readMetaAppID(writeMeta(t, `{not json`)); ok || got != "" || err == nil {
-		t.Fatalf("bad json: got (%q,%v,err=%v), want (\"\",false,non-nil)", got, ok, err)
-	}
-}
-
-func TestEnsureInitDirMatchesApp(t *testing.T) {
-	writeMeta := func(t *testing.T, content string) string {
-		t.Helper()
-		dir := t.TempDir()
-		if err := os.MkdirAll(filepath.Join(dir, ".spark"), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(dir, metaRelPath), []byte(content), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		return dir
-	}
-
-	// 无 meta（非妙搭工程）→ nil（交给 ensureEmptyDir）
-	if _, err := ensureInitDirMatchesApp(t.TempDir(), "app_x"); err != nil {
-		t.Fatalf("no meta should pass: %v", err)
-	}
-	// 同 app_id → (app_id, nil)（走已初始化短路）
-	if existing, err := ensureInitDirMatchesApp(writeMeta(t, `{"app_id":"app_x"}`), "app_x"); err != nil || existing != "app_x" {
-		t.Fatalf("same app should pass: existing=%q err=%v", existing, err)
-	}
-
-	// 不同 app_id → error（换目录），返回 existing=app_other；断言 typed metadata（subtype/param）
-	existing, errMismatch := ensureInitDirMatchesApp(writeMeta(t, `{"app_id":"app_other"}`), "app_x")
-	if errMismatch == nil {
-		t.Fatal("different app should error")
-	}
-	if existing != "app_other" {
-		t.Fatalf("mismatch should return existing app_id, got %q", existing)
-	}
-	problem := requireAppsValidationProblem(t, errMismatch) // 已校验 Category==Validation
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype=%q, want %q", problem.Subtype, errs.SubtypeInvalidArgument)
-	}
-	var ve *errs.ValidationError
-	if !errors.As(errMismatch, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T", errMismatch)
-	}
-	if ve.Param != "--dir" {
-		t.Fatalf("param=%q, want --dir", ve.Param)
-	}
-	if !strings.Contains(problem.Message, "different app") || !strings.Contains(problem.Message, "app_other") {
-		t.Fatalf("message=%q, want 'different app' and 'app_other'", problem.Message)
-	}
-	if !strings.Contains(problem.Hint, "different --dir") {
-		t.Fatalf("hint=%q, want 'different --dir'", problem.Hint)
-	}
-
-	// 空 app_id（缺 app_id 标记的半成品）→ error，独立文案（非 "different app"），返回 existing=""
-	emptyExisting, errEmpty := ensureInitDirMatchesApp(writeMeta(t, `{"name":"x"}`), "app_x")
-	if errEmpty == nil {
-		t.Fatal("empty meta app_id should error (cannot confirm same app)")
-	}
-	if emptyExisting != "" {
-		t.Fatalf("empty app_id should return existing=\"\", got %q", emptyExisting)
-	}
-	pEmpty := requireAppsValidationProblem(t, errEmpty)
-	if pEmpty.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("empty subtype=%q, want %q", pEmpty.Subtype, errs.SubtypeInvalidArgument)
-	}
-	if !strings.Contains(pEmpty.Message, "without an app_id") {
-		t.Fatalf("empty app_id should have its own message, msg=%q", pEmpty.Message)
-	}
-	if strings.Contains(pEmpty.Message, "different app") {
-		t.Fatalf("empty app_id must not reuse the different-app wording, msg=%q", pEmpty.Message)
-	}
-
-	// meta 损坏/不可读 → error（fail closed），返回 existing=""
-	badExisting, errBad := ensureInitDirMatchesApp(writeMeta(t, `{not json`), "app_x")
-	if errBad == nil {
-		t.Fatal("corrupted meta should fail closed")
-	}
-	if badExisting != "" {
-		t.Fatalf("corrupted should return existing=\"\", got %q", badExisting)
-	}
-	pBad := requireAppsValidationProblem(t, errBad)
-	if pBad.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("corrupted subtype=%q, want %q", pBad.Subtype, errs.SubtypeInvalidArgument)
-	}
-	if !strings.Contains(pBad.Message, "unreadable or corrupted") {
-		t.Fatalf("corrupted meta msg=%q, want 'unreadable or corrupted'", pBad.Message)
-	}
-	var veBad *errs.ValidationError
-	if !errors.As(errBad, &veBad) || veBad.Param != "--dir" {
-		t.Fatalf("corrupted: expected ValidationError Param=--dir, got %T param=%v", errBad, veBad)
-	}
-}
-
 // TestRunScaffold_SubprocessFailureIsExternalTool pins the typed
 // classification of an external-tool failure: a failing git subprocess
 // surfaces as internal/external_tool with the cause preserved.
--- a/shortcuts/apps/git_credential.go
+++ b/shortcuts/apps/git_credential.go
@@ -17,7 +17,6 @@ import (
 	"text/tabwriter"
 	"time"

-	"github.com/google/uuid"
 	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
 	"github.com/spf13/cobra"

@@ -33,7 +32,6 @@ import (
 )

 const gitCredentialIssuePath = apiBasePath + "/apps/:app_id/git_info"
-const gitCredentialHelperReportedShortcut = appsService + ":+git-credential-helper"

 // gitCredentialIssueHint is the actionable next-step attached to a failed
 // Git-credential issuance. A 5xx is flagged retryable separately at the call site.
@@ -304,12 +302,7 @@ func (i factoryIssuer) Issue(ctx context.Context, appID string, profile gitcred.
 		HttpMethod: http.MethodGet,
 		ApiPath:    issuePath(appID),
 	}
-	ctx = contextWithGitCredentialHelperShortcut(ctx)
-	var opts []larkcore.RequestOptionFunc
-	if optFn := cmdutil.ShortcutHeaderOpts(ctx); optFn != nil {
-		opts = append(opts, optFn)
-	}
-	resp, err := ac.DoSDKRequest(ctx, req, core.AsUser, opts...)
+	resp, err := ac.DoSDKRequest(ctx, req, core.AsUser)
 	data, err := parseIssueCredentialData(resp, err, errclass.ClassifyContext{
 		Brand:    string(cfg.Brand),
 		AppID:    cfg.AppID,
@@ -321,13 +314,6 @@ func (i factoryIssuer) Issue(ctx context.Context, appID string, profile gitcred.
 	return issuedFromData(appID, data)
 }

-func contextWithGitCredentialHelperShortcut(ctx context.Context) context.Context {
-	if _, ok := cmdutil.ShortcutNameFromContext(ctx); ok {
-		return ctx
-	}
-	return cmdutil.ContextWithShortcut(ctx, gitCredentialHelperReportedShortcut, uuid.New().String())
-}
-
 func runGitCredentialHelper(ctx context.Context, f *cmdutil.Factory, appID, action string) error {
 	if f == nil || f.IOStreams == nil {
 		return nil
--- a/shortcuts/apps/git_credential_test.go
+++ b/shortcuts/apps/git_credential_test.go
@@ -825,7 +825,7 @@ func TestRunGitCredentialHelperActions(t *testing.T) {
 func TestFactoryIssuerBranches(t *testing.T) {
 	factory, _, reg := newAppsExecuteFactory(t)
 	expiresAt := time.Now().Add(24 * time.Hour).Unix()
-	issueStub := &httpmock.Stub{
+	reg.Register(&httpmock.Stub{
 		Method: "GET",
 		URL:    "/open-apis/spark/v1/apps/app_xxx/git_info",
 		Body: map[string]interface{}{
@@ -836,8 +836,7 @@ func TestFactoryIssuerBranches(t *testing.T) {
 				"StatusCode": 0,
 			},
 		},
-	}
-	reg.Register(issueStub)
+	})
 	issued, err := (factoryIssuer{f: factory}).Issue(context.Background(), "app_xxx", gitcred.ProfileContext{})
 	if err != nil {
 		t.Fatalf("factory issuer returned error: %v", err)
@@ -845,12 +844,6 @@ func TestFactoryIssuerBranches(t *testing.T) {
 	if issued.PAT != "pat-token" {
 		t.Fatalf("PAT = %q", issued.PAT)
 	}
-	if got := issueStub.CapturedHeaders.Get(cmdutil.HeaderShortcut); got != gitCredentialHelperReportedShortcut {
-		t.Fatalf("%s = %q, want %q", cmdutil.HeaderShortcut, got, gitCredentialHelperReportedShortcut)
-	}
-	if got := issueStub.CapturedHeaders.Get(cmdutil.HeaderExecutionId); got == "" {
-		t.Fatalf("%s header missing", cmdutil.HeaderExecutionId)
-	}

 	factory.Config = func() (*core.CliConfig, error) { return nil, errors.New("config failed") }
 	if _, err := (factoryIssuer{f: factory}).Issue(context.Background(), "app_xxx", gitcred.ProfileContext{}); err == nil {
@@ -887,20 +880,6 @@ func TestFactoryIssuerBranches(t *testing.T) {
 	}
 }

-func TestContextWithGitCredentialHelperShortcutPreservesExistingShortcut(t *testing.T) {
-	ctx := cmdutil.ContextWithShortcut(context.Background(), "apps:+git-credential-init", "exec-existing")
-	got := contextWithGitCredentialHelperShortcut(ctx)
-
-	name, ok := cmdutil.ShortcutNameFromContext(got)
-	if !ok || name != "apps:+git-credential-init" {
-		t.Fatalf("shortcut = %q ok=%v, want existing shortcut", name, ok)
-	}
-	executionID, ok := cmdutil.ExecutionIdFromContext(got)
-	if !ok || executionID != "exec-existing" {
-		t.Fatalf("execution id = %q ok=%v, want existing execution id", executionID, ok)
-	}
-}
-
 func TestGitCredentialHelpersAndParsers(t *testing.T) {
 	if issuePath(" app/with space ") != "/open-apis/spark/v1/apps/app%2Fwith%20space/git_info" {
 		t.Fatalf("issuePath escaped incorrectly: %s", issuePath(" app/with space "))
--- a/shortcuts/common/runner.go
+++ b/shortcuts/common/runner.go
@@ -223,12 +223,6 @@ func (ctx *RuntimeContext) Float64(name string) float64 {
 	return v
 }

-// IntArray returns an int-array flag value (repeated flag, also supports CSV splitting).
-func (ctx *RuntimeContext) IntArray(name string) []int {
-	v, _ := ctx.Cmd.Flags().GetIntSlice(name)
-	return v
-}
-
 // StrArray returns a string-array flag value (repeated flag, no CSV splitting).
 func (ctx *RuntimeContext) StrArray(name string) []string {
 	v, _ := ctx.Cmd.Flags().GetStringArray(name)
@@ -1051,7 +1045,8 @@ func resolveInputFlags(rctx *RuntimeContext, flags []Flag) error {
 			}
 			if stdinUsed {
 				return ValidationErrorf("--%s: stdin (-) can only be used by one flag", fl.Name).
-					WithParam("--" + fl.Name)
+					WithParam("--"+fl.Name).
+					WithHint("a process has a single stdin, so only one flag per call may use '-'; pass the others as @file (e.g. --%s @/path/to/file)", fl.Name)
 			}
 			stdinUsed = true
 			data, err := io.ReadAll(rctx.IO().In)
@@ -1166,7 +1161,13 @@ func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f
 				hints = append(hints, "@file")
 			}
 			if slices.Contains(fl.Input, Stdin) {
-				hints = append(hints, "- for stdin")
+				// "- reads stdin" intentionally avoids implying each flag has
+				// its own stdin: a process has a single stdin, so at most one
+				// flag per call may use "-" (the rest must use @file). The old
+				// per-flag "- for stdin" wording led AI agents to write
+				// `--a - <x --b - <y`, where the second `<` silently clobbers
+				// the first and `--a` reads the wrong payload.
+				hints = append(hints, "- reads stdin (one flag per call; use @file for others)")
 			}
 			desc += " (supports " + strings.Join(hints, ", ") + ")"
 		}
@@ -1182,8 +1183,6 @@ func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f
 			var d float64
 			fmt.Sscanf(fl.Default, "%g", &d)
 			cmd.Flags().Float64(fl.Name, d, desc)
-		case "int_array":
-			cmd.Flags().IntSlice(fl.Name, nil, desc)
 		case "string_array":
 			cmd.Flags().StringArray(fl.Name, nil, desc)
 		case "string_slice":
--- a/shortcuts/common/runner_args_test.go
+++ b/shortcuts/common/runner_args_test.go
@@ -4,12 +4,9 @@
 package common

 import (
-	"context"
-	"reflect"
 	"strings"
 	"testing"

-	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/spf13/cobra"
 )

@@ -59,29 +56,3 @@ func TestRejectPositionalArgs_NoArgs(t *testing.T) {
 		t.Fatalf("expected no error for empty args, got: %v", err)
 	}
 }
-
-func TestShortcutFlagIntArray(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	parent := &cobra.Command{Use: "root"}
-	var got []int
-	shortcut := Shortcut{
-		Service:     "slides",
-		Command:     "+screenshot",
-		Description: "capture screenshots",
-		Flags: []Flag{
-			{Name: "slide-number", Type: "int_array"},
-		},
-		Execute: func(ctx context.Context, runtime *RuntimeContext) error {
-			got = runtime.IntArray("slide-number")
-			return nil
-		},
-	}
-	shortcut.Mount(parent, f)
-	parent.SetArgs([]string{"+screenshot", "--as", "user", "--slide-number", "1", "--slide-number", "2,3"})
-	if err := parent.Execute(); err != nil {
-		t.Fatalf("Execute() error = %v", err)
-	}
-	if want := []int{1, 2, 3}; !reflect.DeepEqual(got, want) {
-		t.Fatalf("slide-number = %#v, want %#v", got, want)
-	}
-}
--- a/shortcuts/common/runner_input_test.go
+++ b/shortcuts/common/runner_input_test.go
@@ -216,10 +216,15 @@ func TestResolveInputFlags_DuplicateStdin(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for duplicate stdin usage")
 	}
-	assertValidationParam(t, err, "--b")
+	vErr := assertValidationParam(t, err, "--b")
 	if !strings.Contains(err.Error(), "stdin (-) can only be used by one flag") {
 		t.Errorf("unexpected error: %v", err)
 	}
+	// The hint must steer an AI agent to the fix (@file for the extra flags),
+	// since `--a - <x --b - <y` is the exact misuse this guards against.
+	if !strings.Contains(vErr.Hint, "@file") {
+		t.Errorf("hint %q should mention @file as the fix", vErr.Hint)
+	}
 }

 func TestStripUTF8BOM(t *testing.T) {
--- a/shortcuts/common/types.go
+++ b/shortcuts/common/types.go
@@ -18,7 +18,7 @@ const (
 // Flag describes a CLI flag for a shortcut.
 type Flag struct {
 	Name     string // flag name (e.g. "calendar-id")
-	Type     string // "string" (default) | "bool" | "int" | "float64" | "int_array" | "string_array" | "string_slice"
+	Type     string // "string" (default) | "bool" | "int" | "float64" | "string_array" | "string_slice"
 	Default  string // default value as string
 	Desc     string // help text
 	Hidden   bool   // hidden from --help, still readable at runtime
--- a/shortcuts/contact/contact_search_user.go
+++ b/shortcuts/contact/contact_search_user.go
@@ -85,7 +85,6 @@ type searchUserAPIData struct {
 	Items     []searchUserAPIItem `json:"items"`
 	HasMore   bool                `json:"has_more"`
 	PageToken string              `json:"page_token"`
-	Notice    string              `json:"notice"`
 }

 type searchUserAPIItem struct {
@@ -127,7 +126,6 @@ type searchUser struct {
 type searchUserResponse struct {
 	Users   []searchUser `json:"users"`
 	HasMore bool         `json:"has_more"`
-	Notice  string       `json:"notice,omitempty"`
 }

 var ContactSearchUser = common.Shortcut{
@@ -191,7 +189,6 @@ var ContactSearchUser = common.Shortcut{
 	Execute: executeSearchUser,
 }

-// executeSearchUser dispatches contact search to single-query or fanout mode.
 func executeSearchUser(ctx context.Context, runtime *common.RuntimeContext) error {
 	if strings.TrimSpace(runtime.Str("queries")) != "" {
 		return executeSearchUserFanout(ctx, runtime)
@@ -199,7 +196,6 @@ func executeSearchUser(ctx context.Context, runtime *common.RuntimeContext) erro
 	return executeSearchUserSingle(ctx, runtime)
 }

-// executeSearchUserSingle performs one contact search and preserves server notices.
 func executeSearchUserSingle(ctx context.Context, runtime *common.RuntimeContext) error {
 	body, err := buildSearchUserBody(runtime)
 	if err != nil {
@@ -226,7 +222,7 @@ func executeSearchUserSingle(ctx context.Context, runtime *common.RuntimeContext
 	}

 	users, hasMore := projectUsers(respData, runtime.Str("lang"), runtime.Config.Brand)
-	out := searchUserResponse{Users: users, HasMore: hasMore, Notice: respData.Notice}
+	out := searchUserResponse{Users: users, HasMore: hasMore}

 	runtime.OutFormat(out, &output.Meta{Count: len(users)}, func(w io.Writer) {
 		if len(users) == 0 {
--- a/shortcuts/contact/contact_search_user_fanout.go
+++ b/shortcuts/contact/contact_search_user_fanout.go
@@ -45,17 +45,22 @@ type fanoutResult struct {
 	Query   string
 	Users   []searchUser
 	HasMore bool
-	Notice  string
 	ErrMsg  string // empty = success
 	Err     error  // original failure, kept for typed all-failed propagation
 }

-// isFanoutSummaryFormat gates the per-fanout stderr summary line.
+// isFanoutSummaryFormat gates the per-fanout stderr summary line. Includes csv
+// because that summary lives on stderr and never corrupts the csv stream on
+// stdout — single-query mode keeps the narrower isHumanReadableFormat predicate
+// for its refine hint, so adding csv here doesn't regress that path.
 func isFanoutSummaryFormat(format string) bool {
 	return format == "pretty" || format == "table" || format == "csv"
 }

-// runOneQuery converts one fanout request into either users or an error summary.
+// runOneQuery converts every failure mode (transport, HTTP status, parse,
+// API code) into an ErrMsg string instead of returning a Go error. The
+// fanout dispatcher (Task 6) relies on this so a single failed query never
+// short-circuits the remaining workers.
 func runOneQuery(ctx context.Context, runtime *common.RuntimeContext, index int, query string,
 	filter *searchUserAPIFilter) fanoutResult {
 	// Pre-check ctx so queued workers see cancellation before issuing a
@@ -89,10 +94,9 @@ func runOneQuery(ctx context.Context, runtime *common.RuntimeContext, index int,
 	}

 	users, hasMore := projectUsers(respData, runtime.Str("lang"), runtime.Config.Brand)
-	return fanoutResult{Index: index, Query: query, Users: users, HasMore: hasMore, Notice: respData.Notice}
+	return fanoutResult{Index: index, Query: query, Users: users, HasMore: hasMore}
 }

-// fanoutErrorResult records a failed fanout query without stopping other workers.
 func fanoutErrorResult(index int, query string, err error) fanoutResult {
 	if err == nil {
 		return fanoutResult{Index: index, Query: query}
@@ -109,16 +113,17 @@ type querySummary struct {
 	Query   string `json:"query"`
 	Error   string `json:"error,omitempty"`
 	HasMore bool   `json:"has_more"`
-	Notice  string `json:"notice,omitempty"`
 }

 type fanoutResponse struct {
 	Users   []fanoutUser   `json:"users"`
 	Queries []querySummary `json:"queries"`
-	Notice  string         `json:"notice,omitempty"`
 }

-// buildFanoutResponse flattens ordered fanout results and fails only when all queries fail.
+// buildFanoutResponse walks results by Index (input order), flattens users[]
+// with matched_query, lists every input in queries[] (including successes),
+// and returns an error only when every query failed. The error wraps the
+// first failing query's ErrMsg so the CLI exits non-zero on full failure.
 func buildFanoutResponse(queries []string, results []fanoutResult) (*fanoutResponse, error) {
 	indexed := make([]fanoutResult, len(queries))
 	for _, r := range results {
@@ -137,7 +142,6 @@ func buildFanoutResponse(queries []string, results []fanoutResult) (*fanoutRespo
 			Query:   queries[i],
 			Error:   r.ErrMsg,
 			HasMore: r.HasMore,
-			Notice:  r.Notice,
 		})
 		if r.ErrMsg != "" {
 			failed++
@@ -148,9 +152,6 @@ func buildFanoutResponse(queries []string, results []fanoutResult) (*fanoutRespo
 			}
 			continue
 		}
-		if out.Notice == "" {
-			out.Notice = r.Notice
-		}
 		for _, u := range r.Users {
 			out.Users = append(out.Users, fanoutUser{searchUser: u, MatchedQuery: queries[i]})
 		}
--- a/shortcuts/contact/contact_search_user_test.go
+++ b/shortcuts/contact/contact_search_user_test.go
@@ -562,7 +562,6 @@ func mountAndRun(t *testing.T, s common.Shortcut, args []string, f *cmdutil.Fact
 	return parent.Execute()
 }

-// searchUserStub returns a representative user search response with a notice.
 func searchUserStub() *httpmock.Stub {
 	return &httpmock.Stub{
 		Method: "POST",
@@ -570,7 +569,6 @@ func searchUserStub() *httpmock.Stub {
 		Body: map[string]interface{}{
 			"code": 0, "msg": "ok",
 			"data": map[string]interface{}{
-				"notice": "The query is too long and has been truncated to the first 50 characters for search.",
 				"items": []interface{}{
 					map[string]interface{}{
 						"id": "ou_a",
@@ -592,7 +590,6 @@ func searchUserStub() *httpmock.Stub {
 	}
 }

-// TestSearchUser_Integration_PrettyRendersExpectedColumns verifies human output columns.
 func TestSearchUser_Integration_PrettyRendersExpectedColumns(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	reg.Register(searchUserStub())
@@ -617,7 +614,6 @@ func TestSearchUser_Integration_PrettyRendersExpectedColumns(t *testing.T) {
 	}
 }

-// TestSearchUser_Integration_JSONStructuredFields verifies normalized JSON and notices.
 func TestSearchUser_Integration_JSONStructuredFields(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	reg.Register(searchUserStub())
@@ -635,9 +631,6 @@ func TestSearchUser_Integration_JSONStructuredFields(t *testing.T) {
 	if !ok {
 		t.Fatalf("envelope.data: expected object, got %v\nraw=%s", got["data"], stdout.String())
 	}
-	if data["notice"] != "The query is too long and has been truncated to the first 50 characters for search." {
-		t.Fatalf("data.notice = %v", data["notice"])
-	}
 	users, _ := data["users"].([]interface{})
 	if len(users) != 1 {
 		t.Fatalf("users: expected 1, got %d (output=%s)", len(users), stdout.String())
@@ -1365,7 +1358,6 @@ func TestSearchUser_Integration_NoAutoPaginationFlags(t *testing.T) {
 	}
 }

-// TestFanout_FilterAppliedToEachQuery verifies shared fanout filters reach every request.
 func TestFanout_FilterAppliedToEachQuery(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	stub := &httpmock.Stub{
@@ -1407,7 +1399,6 @@ func TestFanout_FilterAppliedToEachQuery(t *testing.T) {
 	}
 }

-// TestFanout_PartialFailure_ExitZero verifies partial fanout failures keep notices.
 func TestFanout_PartialFailure_ExitZero(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, searchUserDefaultConfig())
 	reg.Register(&httpmock.Stub{
@@ -1415,7 +1406,6 @@ func TestFanout_PartialFailure_ExitZero(t *testing.T) {
 		BodyFilter: func(b []byte) bool { return strings.Contains(string(b), `"alice"`) },
 		Body: map[string]interface{}{"code": 0, "msg": "ok",
 			"data": map[string]interface{}{
-				"notice":   "The query is too long and has been truncated to the first 50 characters for search.",
 				"items":    []interface{}{map[string]interface{}{"id": "ou_a"}},
 				"has_more": false,
 			}},
@@ -1442,17 +1432,10 @@ func TestFanout_PartialFailure_ExitZero(t *testing.T) {
 	if len(users) != 1 {
 		t.Errorf("users: expected 1 (alice), got %d; stdout=%s", len(users), stdout.String())
 	}
-	if data["notice"] != "The query is too long and has been truncated to the first 50 characters for search." {
-		t.Fatalf("data.notice = %v", data["notice"])
-	}
 	queries := data["queries"].([]interface{})
 	if len(queries) != 2 {
 		t.Fatalf("queries: expected 2, got %d", len(queries))
 	}
-	q0 := queries[0].(map[string]interface{})
-	if q0["notice"] != "The query is too long and has been truncated to the first 50 characters for search." {
-		t.Fatalf("queries[0].notice = %v", q0["notice"])
-	}
 	q1 := queries[1].(map[string]interface{})
 	if !strings.HasPrefix(q1["error"].(string), "HTTP 500") {
 		t.Errorf("queries[1].error: got %q", q1["error"])
--- a/shortcuts/doc/docs_search.go
+++ b/shortcuts/doc/docs_search.go
@@ -74,9 +74,6 @@ var DocsSearch = common.Shortcut{
 			"page_token": data["page_token"],
 			"results":    normalizedItems,
 		}
-		if notice, _ := data["notice"].(string); notice != "" {
-			resultData["notice"] = notice
-		}

 		runtime.OutFormat(resultData, &output.Meta{Count: len(normalizedItems)}, func(w io.Writer) {
 			if len(normalizedItems) == 0 {
--- a/shortcuts/doc/docs_search_test.go
+++ b/shortcuts/doc/docs_search_test.go
@@ -7,48 +7,8 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
 )

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

--- a/shortcuts/drive/drive_add_comment.go
+++ b/shortcuts/drive/drive_add_comment.go
@@ -121,7 +121,7 @@ const (
 var DriveAddComment = common.Shortcut{
 	Service:     "drive",
 	Command:     "+add-comment",
-	Description: "Add a comment to doc/docx/file/sheet/slides/base(bitable); file targets support selected extensions and full comments only",
+	Description: "Add a comment to doc/docx/file/sheet/slides; file targets support selected extensions and full comments only",
 	Risk:        "write",
 	Scopes: []string{
 		"drive:drive.metadata:readonly",
@@ -131,12 +131,12 @@ var DriveAddComment = common.Shortcut{
 	},
 	AuthTypes: []string{"user", "bot"},
 	Flags: []common.Flag{
-		{Name: "doc", Desc: "document URL/token, file URL/token, sheet/slides/base/bitable URL, or wiki URL that resolves to doc/docx/file/sheet/slides/base(bitable)", Required: true},
-		{Name: "type", Desc: "document type: doc, docx, file, sheet, slides, bitable, base (required when --doc is a bare token; auto-detected for URLs; use bitable as the wire value, base is accepted as a compatibility alias)", Enum: []string{"doc", "docx", "file", "sheet", "slides", "bitable", "base"}},
+		{Name: "doc", Desc: "document URL/token, file URL/token, sheet/slides URL, or wiki URL that resolves to doc/docx/file/sheet/slides", Required: true},
+		{Name: "type", Desc: "document type: doc, docx, file, sheet, slides (required when --doc is a bare token; auto-detected for URLs)", Enum: []string{"doc", "docx", "file", "sheet", "slides"}},
 		{Name: "content", Desc: "reply_elements JSON string", Required: true, Input: []string{common.File, common.Stdin}},
 		{Name: "full-comment", Type: "bool", Desc: "create a full-document comment; also the default when no location is provided"},
 		{Name: "selection-with-ellipsis", Desc: "target content locator (plain text or 'start...end')"},
-		{Name: "block-id", Desc: "for docx: anchor block ID; for sheet: <sheetId>!<cell>; for slides: <slide-block-type>!<xml-id>; for base(bitable): <table-id>!<record-id>!<view-id>"},
+		{Name: "block-id", Desc: "for docx: anchor block ID; for sheet: <sheetId>!<cell> (e.g. a281f9!D6); for slides: <slide-block-type>!<xml-id> (e.g. shape!bPq)"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		docRef, err := parseCommentDocRef(runtime.Str("doc"), runtime.Str("type"))
@@ -148,17 +148,6 @@ var DriveAddComment = common.Shortcut{
 			return err
 		}

-		if docRef.Kind == "base" {
-			if runtime.Bool("full-comment") {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--full-comment is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>").WithParam("--full-comment")
-			}
-			if strings.TrimSpace(runtime.Str("selection-with-ellipsis")) != "" {
-				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--selection-with-ellipsis is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>").WithParam("--selection-with-ellipsis")
-			}
-			_, err := parseBaseCommentAnchor(runtime)
-			return err
-		}
-
 		// Sheet comment validation.
 		if docRef.Kind == "sheet" {
 			blockID := strings.TrimSpace(runtime.Str("block-id"))
@@ -199,7 +188,7 @@ var DriveAddComment = common.Shortcut{
 			return validateFileCommentMode(mode, "")
 		}
 		if mode == commentModeLocal && docRef.Kind == "doc" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, slides, and base(bitable); old doc format only supports full comments")
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, and slides; old doc format only supports full comments")
 		}

 		return nil
@@ -226,23 +215,6 @@ var DriveAddComment = common.Shortcut{
 			resolvedToken = target.FileToken
 		}

-		if resolvedKind == "base" {
-			anchor, err := parseBaseCommentAnchor(runtime)
-			if err != nil {
-				return common.NewDryRunAPI().Set("error", err.Error())
-			}
-			commentBody := buildBaseCommentCreateV2Request(replyElements, anchor)
-			desc := "1-step request: create base(bitable) record-local comment"
-			if isWiki {
-				desc = "2-step orchestration: resolve wiki -> create base(bitable) record-local comment"
-			}
-			return common.NewDryRunAPI().
-				Desc(desc).
-				POST("/open-apis/drive/v1/files/:file_token/new_comments").
-				Body(commentBody).
-				Set("file_token", resolvedToken)
-		}
-
 		// Sheet comment dry-run.
 		if resolvedKind == "sheet" {
 			anchor, _ := parseSheetCellRef(blockID)
@@ -380,14 +352,6 @@ var DriveAddComment = common.Shortcut{
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		// Sheet comment: direct URL or token fast path.
 		docRef, _ := parseCommentDocRef(runtime.Str("doc"), runtime.Str("type"))
-		if docRef.Kind == "base" {
-			return executeBaseComment(runtime, resolvedCommentTarget{
-				DocID:      docRef.Token,
-				FileToken:  docRef.Token,
-				FileType:   "base",
-				ResolvedBy: "base",
-			})
-		}
 		if docRef.Kind == "sheet" {
 			return executeSheetComment(runtime, docRef)
 		}
@@ -411,9 +375,6 @@ var DriveAddComment = common.Shortcut{
 		if target.FileType == "slides" {
 			return executeSlidesComment(runtime, commentDocRef{Kind: "slides", Token: target.FileToken})
 		}
-		if target.FileType == "base" {
-			return executeBaseComment(runtime, target)
-		}
 		if target.FileType == "file" {
 			return executeFileComment(runtime, target)
 		}
@@ -521,12 +482,6 @@ func parseCommentDocRef(input, docType string) (commentDocRef, error) {
 	if token, ok := extractURLToken(raw, "/sheets/"); ok {
 		return commentDocRef{Kind: "sheet", Token: token}, nil
 	}
-	if token, ok := extractURLToken(raw, "/base/"); ok {
-		return commentDocRef{Kind: "base", Token: token}, nil
-	}
-	if token, ok := extractURLToken(raw, "/bitable/"); ok {
-		return commentDocRef{Kind: "base", Token: token}, nil
-	}
 	if token, ok := extractURLToken(raw, "/file/"); ok {
 		return commentDocRef{Kind: "file", Token: token}, nil
 	}
@@ -540,7 +495,7 @@ func parseCommentDocRef(input, docType string) (commentDocRef, error) {
 		return commentDocRef{Kind: "doc", Token: token}, nil
 	}
 	if strings.Contains(raw, "://") {
-		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a doc/docx/file/sheet/slides/base/bitable URL, a token with --type, or a wiki URL that resolves to doc/docx/file/sheet/slides/base(bitable)", raw).WithParam("--doc")
+		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a doc/docx/file/sheet/slides URL, a token with --type, or a wiki URL that resolves to doc/docx/file/sheet/slides", raw).WithParam("--doc")
 	}
 	if strings.ContainsAny(raw, "/?#") {
 		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a token with --type, or a wiki URL", raw).WithParam("--doc")
@@ -549,10 +504,7 @@ func parseCommentDocRef(input, docType string) (commentDocRef, error) {
 	// Bare token: --type is required.
 	docType = strings.TrimSpace(docType)
 	if docType == "" {
-		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--type is required when --doc is a bare token (allowed values: doc, docx, file, sheet, slides, bitable, base; use bitable as the wire value, base is accepted as a compatibility alias)").WithParam("--type")
-	}
-	if docType == "bitable" || docType == "base" {
-		return commentDocRef{Kind: "base", Token: raw}, nil
+		return commentDocRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--type is required when --doc is a bare token (allowed values: doc, docx, file, sheet, slides)").WithParam("--type")
 	}
 	return commentDocRef{Kind: docType, Token: raw}, nil
 }
@@ -563,11 +515,11 @@ func resolveCommentTarget(ctx context.Context, runtime *common.RuntimeContext, i
 		return resolvedCommentTarget{}, err
 	}

-	if docRef.Kind == "docx" || docRef.Kind == "doc" || docRef.Kind == "file" || docRef.Kind == "sheet" || docRef.Kind == "slides" || docRef.Kind == "base" {
+	if docRef.Kind == "docx" || docRef.Kind == "doc" || docRef.Kind == "file" || docRef.Kind == "sheet" || docRef.Kind == "slides" {
 		if mode == commentModeLocal {
 			switch docRef.Kind {
 			case "doc":
-				return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, slides, and base(bitable); old doc format only supports full comments")
+				return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "local comments only support docx, sheet, and slides; old doc format only supports full comments")
 			case "file":
 				if err := validateFileCommentMode(mode, ""); err != nil {
 					return resolvedCommentTarget{}, err
@@ -605,22 +557,6 @@ func resolveCommentTarget(ctx context.Context, runtime *common.RuntimeContext, i
 	if objType == "slides" && strings.TrimSpace(runtime.Str("selection-with-ellipsis")) != "" {
 		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but --selection-with-ellipsis is not applicable for slide comments; use --block-id <slide-block-type>!<xml-id>", objType)
 	}
-	if objType == "bitable" || objType == "base" {
-		if runtime.Bool("full-comment") {
-			return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but --full-comment is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>", objType).WithParam("--full-comment")
-		}
-		if strings.TrimSpace(runtime.Str("selection-with-ellipsis")) != "" {
-			return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but --selection-with-ellipsis is not applicable for base(bitable) comments; use --block-id <table-id>!<record-id>!<view-id>", objType).WithParam("--selection-with-ellipsis")
-		}
-		fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to base: %s\n", common.MaskToken(objToken))
-		return resolvedCommentTarget{
-			DocID:      objToken,
-			FileToken:  objToken,
-			FileType:   "base",
-			ResolvedBy: "wiki",
-			WikiToken:  docRef.Token,
-		}, nil
-	}
 	if objType == "sheet" {
 		// Sheet comments are handled via the sheet fast path in Execute.
 		fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to %s: %s\n", objType, common.MaskToken(objToken))
@@ -656,10 +592,10 @@ func resolveCommentTarget(ctx context.Context, runtime *common.RuntimeContext, i
 		}, nil
 	}
 	if mode == commentModeLocal && objType != "docx" {
-		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but local comments only support docx, sheet, slides, and base(bitable); for sheet use --block-id <sheetId>!<cell>, for slides use --block-id <slide-block-type>!<xml-id>, for base use --block-id <table-id>!<record-id>!<view-id>", objType)
+		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but local comments only support docx, sheet, and slides; for sheet use --block-id <sheetId>!<cell>, for slides use --block-id <slide-block-type>!<xml-id>", objType)
 	}
 	if mode == commentModeFull && objType != "docx" && objType != "doc" {
-		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but comments only support doc/docx/file/sheet/slides/base(bitable)", objType)
+		return resolvedCommentTarget{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "wiki resolved to %q, but comments only support doc/docx/file/sheet/slides", objType)
 	}

 	fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to %s: %s\n", objType, common.MaskToken(objToken))
@@ -851,12 +787,6 @@ type sheetAnchor struct {
 	Row     int
 }

-type baseAnchor struct {
-	BlockID      string
-	BaseRecordID string
-	BaseViewID   string
-}
-
 func buildCommentCreateV2Request(fileType, blockID, slideBlockType string, replyElements []map[string]interface{}, sheet *sheetAnchor) map[string]interface{} {
 	body := map[string]interface{}{
 		"file_type":      fileType,
@@ -883,18 +813,6 @@ func buildCommentCreateV2Request(fileType, blockID, slideBlockType string, reply
 	return body
 }

-func buildBaseCommentCreateV2Request(replyElements []map[string]interface{}, anchor baseAnchor) map[string]interface{} {
-	return map[string]interface{}{
-		"file_type":      "bitable",
-		"reply_elements": replyElements,
-		"anchor": map[string]interface{}{
-			"block_id":       anchor.BlockID,
-			"base_record_id": anchor.BaseRecordID,
-			"base_view_id":   anchor.BaseViewID,
-		},
-	}
-}
-
 func anchorBlockIDForDryRun(blockID string) string {
 	if strings.TrimSpace(blockID) != "" {
 		return strings.TrimSpace(blockID)
@@ -902,26 +820,6 @@ func anchorBlockIDForDryRun(blockID string) string {
 	return "<anchor_block_id>"
 }

-func parseBaseCommentAnchor(runtime *common.RuntimeContext) (baseAnchor, error) {
-	blockID := strings.TrimSpace(runtime.Str("block-id"))
-	if blockID == "" {
-		return baseAnchor{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--block-id is required for base(bitable) record-local comments (format: <table-id>!<record-id>!<view-id>, e.g. tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R)").WithParam("--block-id")
-	}
-	return parseBaseBlockRef(blockID)
-}
-
-func parseBaseBlockRef(blockID string) (baseAnchor, error) {
-	parts := strings.Split(strings.TrimSpace(blockID), "!")
-	if len(parts) != 3 || strings.TrimSpace(parts[0]) == "" || strings.TrimSpace(parts[1]) == "" || strings.TrimSpace(parts[2]) == "" {
-		return baseAnchor{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "base(bitable) record-local comments require --block-id in <table-id>!<record-id>!<view-id> format, e.g. tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R").WithParam("--block-id")
-	}
-	return baseAnchor{
-		BlockID:      strings.TrimSpace(parts[0]),
-		BaseRecordID: strings.TrimSpace(parts[1]),
-		BaseViewID:   strings.TrimSpace(parts[2]),
-	}, nil
-}
-
 func parseSlidesBlockRef(blockID string) (string, string, error) {
 	blockID = strings.TrimSpace(blockID)
 	if blockID == "" {
@@ -1132,53 +1030,6 @@ func executeSheetComment(runtime *common.RuntimeContext, docRef commentDocRef) e
 	return nil
 }

-func executeBaseComment(runtime *common.RuntimeContext, target resolvedCommentTarget) error {
-	replyElements, err := parseCommentReplyElements(runtime.Str("content"))
-	if err != nil {
-		return err
-	}
-	anchor, err := parseBaseCommentAnchor(runtime)
-	if err != nil {
-		return err
-	}
-
-	requestPath := fmt.Sprintf("/open-apis/drive/v1/files/%s/new_comments", validate.EncodePathSegment(target.FileToken))
-	requestBody := buildBaseCommentCreateV2Request(replyElements, anchor)
-
-	fmt.Fprintf(runtime.IO().ErrOut, "Creating base(bitable) record-local comment in %s (table=%s, record=%s, view=%s)\n",
-		common.MaskToken(target.FileToken), anchor.BlockID, anchor.BaseRecordID, anchor.BaseViewID)
-
-	data, err := runtime.CallAPITyped("POST", requestPath, nil, requestBody)
-	if err != nil {
-		return err
-	}
-
-	out := map[string]interface{}{
-		"file_token":     target.FileToken,
-		"file_type":      "bitable",
-		"resolved_by":    target.ResolvedBy,
-		"comment_mode":   "base_record",
-		"base_block_id":  anchor.BlockID,
-		"base_record_id": anchor.BaseRecordID,
-		"base_view_id":   anchor.BaseViewID,
-	}
-	if commentID := data["comment_id"]; commentID != nil {
-		out["comment_id"] = commentID
-	}
-	if replyID := data["reply_id"]; replyID != nil {
-		out["reply_id"] = replyID
-	}
-	if createdAt := firstPresentValue(data, "created_at", "create_time"); createdAt != nil {
-		out["created_at"] = createdAt
-	}
-	if target.WikiToken != "" {
-		out["wiki_token"] = target.WikiToken
-	}
-
-	runtime.Out(out, nil)
-	return nil
-}
-
 func executeFileComment(runtime *common.RuntimeContext, target resolvedCommentTarget) error {
 	replyElements, err := parseCommentReplyElements(runtime.Str("content"))
 	if err != nil {
--- a/shortcuts/drive/drive_add_comment_test.go
+++ b/shortcuts/drive/drive_add_comment_test.go
@@ -133,20 +133,6 @@ func TestParseCommentDocRef(t *testing.T) {
 			wantKind:  "file",
 			wantToken: "fileToken",
 		},
-		{
-			name:      "raw token with type bitable",
-			input:     "baseToken",
-			docType:   "bitable",
-			wantKind:  "base",
-			wantToken: "baseToken",
-		},
-		{
-			name:      "raw token with type base alias",
-			input:     "baseToken",
-			docType:   "base",
-			wantKind:  "base",
-			wantToken: "baseToken",
-		},
 		{
 			name:    "raw token without type",
 			input:   "xxxxxx",
@@ -170,18 +156,6 @@ func TestParseCommentDocRef(t *testing.T) {
 			wantKind:  "file",
 			wantToken: "boxcn123",
 		},
-		{
-			name:      "base url",
-			input:     "https://example.larksuite.com/base/baseToken123?table=tbl1",
-			wantKind:  "base",
-			wantToken: "baseToken123",
-		},
-		{
-			name:      "bitable url",
-			input:     "https://example.larksuite.com/bitable/baseToken456?table=tbl1",
-			wantKind:  "base",
-			wantToken: "baseToken456",
-		},
 		{
 			name:    "unsupported url",
 			input:   "https://example.com/not-a-doc",
@@ -752,35 +726,6 @@ func TestBuildCommentCreateV2RequestSheetOverridesBlockID(t *testing.T) {
 	}
 }

-func TestBuildBaseCommentCreateV2Request(t *testing.T) {
-	t.Parallel()
-	replyElements := []map[string]interface{}{
-		{"type": "text", "text": "base comment"},
-	}
-	got := buildBaseCommentCreateV2Request(replyElements, baseAnchor{
-		BlockID:      "tbl9mp6fj9kDKHQV",
-		BaseRecordID: "recBIBgGmb",
-		BaseViewID:   "vewc46MG1R",
-	})
-
-	if got["file_type"] != "bitable" {
-		t.Fatalf("expected file_type bitable, got %#v", got["file_type"])
-	}
-	anchor, ok := got["anchor"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("expected anchor map, got %#v", got["anchor"])
-	}
-	if anchor["block_id"] != "tbl9mp6fj9kDKHQV" {
-		t.Fatalf("expected block_id tbl9mp6fj9kDKHQV, got %#v", anchor["block_id"])
-	}
-	if anchor["base_record_id"] != "recBIBgGmb" {
-		t.Fatalf("expected base_record_id recBIBgGmb, got %#v", anchor["base_record_id"])
-	}
-	if anchor["base_view_id"] != "vewc46MG1R" {
-		t.Fatalf("expected base_view_id vewc46MG1R, got %#v", anchor["base_view_id"])
-	}
-}
-
 // ── Sheet cell ref parsing tests ────────────────────────────────────────────

 func TestParseSheetCellRef(t *testing.T) {
@@ -1040,78 +985,6 @@ func TestFileCommentValidateRejectsSelectionWithEllipsis(t *testing.T) {
 	}
 }

-func TestBaseCommentValidateMissingBlockID(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
-	err := mountAndRunDrive(t, DriveAddComment, []string{
-		"+add-comment",
-		"--doc", "https://example.larksuite.com/base/baseToken",
-		"--content", `[{"type":"text","text":"test"}]`,
-		"--as", "user",
-	}, f, stdout)
-	if err == nil || !strings.Contains(err.Error(), "--block-id is required") {
-		t.Fatalf("expected block-id required error, got: %v", err)
-	}
-}
-
-func TestBaseCommentValidateMalformedBlockID(t *testing.T) {
-	cases := []string{
-		"tbl9mp6fj9kDKHQV",
-		"tbl9mp6fj9kDKHQV!recBIBgGmb",
-		"tbl9mp6fj9kDKHQV!!vewc46MG1R",
-	}
-	for _, blockID := range cases {
-		t.Run(blockID, func(t *testing.T) {
-			f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
-			err := mountAndRunDrive(t, DriveAddComment, []string{
-				"+add-comment",
-				"--doc", "https://example.larksuite.com/base/baseToken",
-				"--content", `[{"type":"text","text":"test"}]`,
-				"--block-id", blockID,
-				"--as", "user",
-			}, f, stdout)
-			if err == nil || !strings.Contains(err.Error(), "<table-id>!<record-id>!<view-id>") {
-				t.Fatalf("expected block-id format error, got: %v", err)
-			}
-		})
-	}
-}
-
-func TestBaseCommentValidateRejectsIncompatibleFlags(t *testing.T) {
-	cases := []struct {
-		name    string
-		args    []string
-		wantErr string
-	}{
-		{
-			name:    "full comment",
-			args:    []string{"--full-comment"},
-			wantErr: "--full-comment is not applicable for base(bitable) comments",
-		},
-		{
-			name:    "selection",
-			args:    []string{"--selection-with-ellipsis", "some text"},
-			wantErr: "--selection-with-ellipsis is not applicable for base(bitable) comments",
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
-			args := []string{
-				"+add-comment",
-				"--doc", "https://example.larksuite.com/base/baseToken",
-				"--content", `[{"type":"text","text":"test"}]`,
-				"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
-				"--as", "user",
-			}
-			args = append(args, tc.args...)
-			err := mountAndRunDrive(t, DriveAddComment, args, f, stdout)
-			if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
-				t.Fatalf("expected %q error, got: %v", tc.wantErr, err)
-			}
-		})
-	}
-}
-
 // ── Slides comment execute tests ────────────────────────────────────────────

 func TestSlidesCommentExecuteSuccess(t *testing.T) {
@@ -1322,87 +1195,6 @@ func TestSheetCommentViaWikiMissingBlockID(t *testing.T) {
 	}
 }

-func TestBaseCommentExecuteSuccess(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	createStub := &httpmock.Stub{
-		Method: "POST", URL: "/open-apis/drive/v1/files/baseToken/new_comments",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "success",
-			"data": map[string]interface{}{
-				"comment_id": "baseComment123",
-				"reply_id":   "baseReply123",
-				"created_at": 1700000000,
-			},
-		},
-	}
-	reg.Register(createStub)
-	err := mountAndRunDrive(t, DriveAddComment, []string{
-		"+add-comment",
-		"--doc", "https://example.larksuite.com/base/baseToken",
-		"--content", `[{"type":"text","text":"请看这条记录"}]`,
-		"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var requestBody map[string]interface{}
-	if err := json.Unmarshal(createStub.CapturedBody, &requestBody); err != nil {
-		t.Fatalf("failed to decode captured body: %v\nbody:\n%s", err, string(createStub.CapturedBody))
-	}
-	if got := mustStringField(t, requestBody, "file_type", "request.file_type"); got != "bitable" {
-		t.Fatalf("request file_type = %q, want bitable", got)
-	}
-	anchor := mustMapValue(t, requestBody["anchor"], "request.anchor")
-	if got := mustStringField(t, anchor, "block_id", "request.anchor.block_id"); got != "tbl9mp6fj9kDKHQV" {
-		t.Fatalf("request block_id = %q, want tbl9mp6fj9kDKHQV", got)
-	}
-	if got := mustStringField(t, anchor, "base_record_id", "request.anchor.base_record_id"); got != "recBIBgGmb" {
-		t.Fatalf("request base_record_id = %q, want recBIBgGmb", got)
-	}
-	if got := mustStringField(t, anchor, "base_view_id", "request.anchor.base_view_id"); got != "vewc46MG1R" {
-		t.Fatalf("request base_view_id = %q, want vewc46MG1R", got)
-	}
-
-	out := decodeJSONMap(t, stdout.String())
-	data := mustMapValue(t, out["data"], "data")
-	if got := mustStringField(t, data, "file_type", "data.file_type"); got != "bitable" {
-		t.Fatalf("stdout file_type = %q, want bitable\nstdout:\n%s", got, stdout.String())
-	}
-	if got := mustStringField(t, data, "comment_mode", "data.comment_mode"); got != "base_record" {
-		t.Fatalf("stdout comment_mode = %q, want base_record\nstdout:\n%s", got, stdout.String())
-	}
-	if got := mustStringField(t, data, "reply_id", "data.reply_id"); got != "baseReply123" {
-		t.Fatalf("stdout reply_id = %q, want baseReply123\nstdout:\n%s", got, stdout.String())
-	}
-}
-
-func TestBaseCommentExecuteBareToken(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "POST", URL: "/open-apis/drive/v1/files/baseBareToken/new_comments",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "success",
-			"data": map[string]interface{}{"comment_id": "baseBareComment"},
-		},
-	})
-	err := mountAndRunDrive(t, DriveAddComment, []string{
-		"+add-comment",
-		"--doc", "baseBareToken",
-		"--type", "bitable",
-		"--content", `[{"type":"text","text":"ok"}]`,
-		"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(stdout.String(), "baseBareComment") {
-		t.Fatalf("stdout missing comment_id: %s", stdout.String())
-	}
-}
-
 func TestFileCommentExecuteSuccess(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
@@ -1641,40 +1433,6 @@ func TestDryRunSlidesDirectURL(t *testing.T) {
 	}
 }

-func TestDryRunBaseDirectURL(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, driveTestConfig())
-	err := mountAndRunDrive(t, DriveAddComment, []string{
-		"+add-comment",
-		"--doc", "https://example.larksuite.com/base/baseToken",
-		"--content", `[{"type":"text","text":"test"}]`,
-		"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
-		"--dry-run", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !strings.Contains(stdout.String(), "record-local comment") {
-		t.Fatalf("dry-run output missing record-local comment: %s", stdout.String())
-	}
-	out := decodeJSONMap(t, stdout.String())
-	api := mustSliceValue(t, out["api"], "api")
-	call := mustMapValue(t, api[0], "api[0]")
-	body := mustMapValue(t, call["body"], "api[0].body")
-	anchor := mustMapValue(t, body["anchor"], "api[0].body.anchor")
-	if got := mustStringField(t, body, "file_type", "api[0].body.file_type"); got != "bitable" {
-		t.Fatalf("dry-run body.file_type = %q, want bitable\nstdout:\n%s", got, stdout.String())
-	}
-	if got := mustStringField(t, anchor, "block_id", "api[0].body.anchor.block_id"); got != "tbl9mp6fj9kDKHQV" {
-		t.Fatalf("dry-run body.anchor.block_id = %q, want tbl9mp6fj9kDKHQV\nstdout:\n%s", got, stdout.String())
-	}
-	if got := mustStringField(t, anchor, "base_record_id", "api[0].body.anchor.base_record_id"); got != "recBIBgGmb" {
-		t.Fatalf("dry-run body.anchor.base_record_id = %q, want recBIBgGmb\nstdout:\n%s", got, stdout.String())
-	}
-	if got := mustStringField(t, anchor, "base_view_id", "api[0].body.anchor.base_view_id"); got != "vewc46MG1R" {
-		t.Fatalf("dry-run body.anchor.base_view_id = %q, want vewc46MG1R\nstdout:\n%s", got, stdout.String())
-	}
-}
-
 func TestDryRunWikiResolvesToSlides(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
@@ -1878,92 +1636,25 @@ func TestResolveWikiToDocxFullComment(t *testing.T) {
 	}
 }

-func TestResolveWikiToBaseComment(t *testing.T) {
-	for _, objType := range []string{"bitable", "base"} {
-		t.Run(objType, func(t *testing.T) {
-			f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-			reg.Register(&httpmock.Stub{
-				Method: "GET", URL: "/open-apis/wiki/v2/spaces/get_node",
-				Body: map[string]interface{}{
-					"code": 0, "msg": "success",
-					"data": map[string]interface{}{
-						"node": map[string]interface{}{"obj_type": objType, "obj_token": "bitToken"},
-					},
-				},
-			})
-			reg.Register(&httpmock.Stub{
-				Method: "POST", URL: "/open-apis/drive/v1/files/bitToken/new_comments",
-				Body: map[string]interface{}{
-					"code": 0, "msg": "success",
-					"data": map[string]interface{}{"comment_id": "wikiBaseComment", "reply_id": "wikiBaseReply"},
-				},
-			})
-			err := mountAndRunDrive(t, DriveAddComment, []string{
-				"+add-comment",
-				"--doc", "https://example.larksuite.com/wiki/wikiToken",
-				"--content", `[{"type":"text","text":"test"}]`,
-				"--block-id", "tbl9mp6fj9kDKHQV!recBIBgGmb!vewc46MG1R",
-				"--as", "user",
-			}, f, stdout)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if !strings.Contains(stdout.String(), "wikiBaseComment") {
-				t.Fatalf("stdout missing comment_id: %s", stdout.String())
-			}
-			out := decodeJSONMap(t, stdout.String())
-			data := mustMapValue(t, out["data"], "data")
-			if got := mustStringField(t, data, "file_type", "data.file_type"); got != "bitable" {
-				t.Fatalf("stdout file_type = %q, want bitable\nstdout:\n%s", got, stdout.String())
-			}
-			if got := mustStringField(t, data, "wiki_token", "data.wiki_token"); got != "wikiToken" {
-				t.Fatalf("stdout wiki_token = %q, want wikiToken\nstdout:\n%s", got, stdout.String())
-			}
-		})
-	}
-}
-
-func TestResolveWikiToBaseRejectsIncompatibleFlags(t *testing.T) {
-	cases := []struct {
-		name    string
-		args    []string
-		wantErr string
-	}{
-		{
-			name:    "full comment",
-			args:    []string{"--full-comment"},
-			wantErr: "--full-comment is not applicable for base(bitable) comments",
+func TestResolveWikiToUnsupportedType(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "GET", URL: "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{"obj_type": "bitable", "obj_token": "bitToken"},
+			},
 		},
-		{
-			name:    "selection",
-			args:    []string{"--selection-with-ellipsis", "some text"},
-			wantErr: "--selection-with-ellipsis is not applicable for base(bitable) comments",
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-			reg.Register(&httpmock.Stub{
-				Method: "GET", URL: "/open-apis/wiki/v2/spaces/get_node",
-				Body: map[string]interface{}{
-					"code": 0, "msg": "success",
-					"data": map[string]interface{}{
-						"node": map[string]interface{}{"obj_type": "bitable", "obj_token": "bitToken"},
-					},
-				},
-			})
-			args := []string{
-				"+add-comment",
-				"--doc", "https://example.larksuite.com/wiki/wikiToken",
-				"--content", `[{"type":"text","text":"test"}]`,
-				"--as", "user",
-			}
-			args = append(args, tc.args...)
-			err := mountAndRunDrive(t, DriveAddComment, args, f, stdout)
-			if err == nil || !strings.Contains(err.Error(), tc.wantErr) {
-				t.Fatalf("expected %q error, got: %v", tc.wantErr, err)
-			}
-		})
+	})
+	err := mountAndRunDrive(t, DriveAddComment, []string{
+		"+add-comment",
+		"--doc", "https://example.larksuite.com/wiki/wikiToken",
+		"--content", `[{"type":"text","text":"test"}]`,
+		"--as", "user",
+	}, f, stdout)
+	if err == nil || !strings.Contains(err.Error(), "only support doc/docx/file/sheet/slides") {
+		t.Fatalf("expected unsupported type error, got: %v", err)
 	}
 }

@@ -2044,7 +1735,7 @@ func TestDocOldFormatLocalCommentRejected(t *testing.T) {
 		"--block-id", "blk_123",
 		"--as", "user",
 	}, f, stdout)
-	if err == nil || !strings.Contains(err.Error(), "only support docx, sheet, slides, and base(bitable)") {
+	if err == nil || !strings.Contains(err.Error(), "only support docx, sheet, and slides") {
 		t.Fatalf("expected local comment rejection for old doc, got: %v", err)
 	}
 }
--- a/shortcuts/drive/drive_export.go
+++ b/shortcuts/drive/drive_export.go
@@ -40,236 +40,302 @@ var DriveExport = common.Shortcut{
 		{Name: "overwrite", Type: "bool", Desc: "overwrite existing output file"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		return validateDriveExportSpec(driveExportSpec{
-			Token:         runtime.Str("token"),
-			DocType:       runtime.Str("doc-type"),
-			FileExtension: runtime.Str("file-extension"),
-			SubID:         runtime.Str("sub-id"),
-			OnlySchema:    runtime.Bool("only-schema"),
-		})
+		return ValidateExport(exportParamsFromFlags(runtime))
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec := driveExportSpec{
-			Token:         runtime.Str("token"),
-			DocType:       runtime.Str("doc-type"),
-			FileExtension: runtime.Str("file-extension"),
-			SubID:         runtime.Str("sub-id"),
-			OnlySchema:    runtime.Bool("only-schema"),
-		}
-		// Markdown export is a special case: docx markdown comes from the V2
-		// docs_ai fetch API directly instead of the Drive export task API.
-		if spec.FileExtension == "markdown" {
-			apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
-			dr := common.NewDryRunAPI().
-				Desc("2-step orchestration: fetch docx markdown -> write local file").
-				POST(apiPath).
-				Body(map[string]interface{}{
-					"format": "markdown",
-				}).
-				Set("output_dir", runtime.Str("output-dir"))
-			if name := strings.TrimSpace(runtime.Str("file-name")); name != "" {
-				dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
-			}
-			return dr
-		}
+		return PlanExportDryRun(runtime, exportParamsFromFlags(runtime))
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		return RunExport(ctx, runtime, exportParamsFromFlags(runtime))
+	},
+}

-		body := map[string]interface{}{
-			"token":          spec.Token,
-			"type":           spec.DocType,
-			"file_extension": spec.FileExtension,
-		}
-		if strings.TrimSpace(spec.SubID) != "" {
-			body["sub_id"] = spec.SubID
-		}
-		if spec.OnlySchema {
-			body["only_schema"] = true
-		}
+// ExportParams holds the user-facing inputs for an export flow, decoupled from
+// cobra flags so other command groups (e.g. sheets +workbook-export) can reuse
+// the drive export implementation. An empty OutputDir means "create the export
+// task and poll, but do not download" — callers that only need the ready file
+// token / status get it back without writing a local file.
+type ExportParams struct {
+	Token         string
+	DocType       string
+	FileExtension string
+	SubID         string
+	OnlySchema    bool
+	OutputDir     string
+	FileName      string
+	Overwrite     bool
+}

+func (p ExportParams) spec() driveExportSpec {
+	return driveExportSpec{
+		Token:         p.Token,
+		DocType:       p.DocType,
+		FileExtension: p.FileExtension,
+		SubID:         p.SubID,
+		OnlySchema:    p.OnlySchema,
+	}
+}
+
+// exportParamsFromFlags reads the standard drive +export flag set.
+func exportParamsFromFlags(runtime *common.RuntimeContext) ExportParams {
+	// drive +export always downloads; an empty --output-dir historically means
+	// the current directory (saveContentToOutputDir maps "" -> "."), so normalize
+	// it here to keep behavior identical and stay off the export-only ("" => skip
+	// download) path that only sheets +workbook-export uses.
+	outputDir := runtime.Str("output-dir")
+	if outputDir == "" {
+		outputDir = "."
+	}
+	return ExportParams{
+		Token:         runtime.Str("token"),
+		DocType:       runtime.Str("doc-type"),
+		FileExtension: runtime.Str("file-extension"),
+		SubID:         runtime.Str("sub-id"),
+		OnlySchema:    runtime.Bool("only-schema"),
+		OutputDir:     outputDir,
+		FileName:      strings.TrimSpace(runtime.Str("file-name")),
+		Overwrite:     runtime.Bool("overwrite"),
+	}
+}
+
+// ValidateExport runs the CLI-level export constraint checks.
+func ValidateExport(p ExportParams) error {
+	return validateDriveExportSpec(p.spec())
+}
+
+// PlanExportDryRun builds the dry-run plan for an export without performing I/O.
+func PlanExportDryRun(runtime *common.RuntimeContext, p ExportParams) *common.DryRunAPI {
+	spec := p.spec()
+	// Markdown export is a special case: docx markdown comes from the V2
+	// docs_ai fetch API directly instead of the Drive export task API.
+	if spec.FileExtension == "markdown" {
+		apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
 		dr := common.NewDryRunAPI().
-			Desc("3-step orchestration: create export task -> limited polling -> download file").
-			POST("/open-apis/drive/v1/export_tasks").
-			Body(body).
-			Set("output_dir", runtime.Str("output-dir"))
-		if name := strings.TrimSpace(runtime.Str("file-name")); name != "" {
+			Desc("2-step orchestration: fetch docx markdown -> write local file").
+			POST(apiPath).
+			Body(map[string]interface{}{
+				"format": "markdown",
+			}).
+			Set("output_dir", p.OutputDir)
+		if name := strings.TrimSpace(p.FileName); name != "" {
 			dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
 		}
 		return dr
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec := driveExportSpec{
-			Token:         runtime.Str("token"),
-			DocType:       runtime.Str("doc-type"),
-			FileExtension: runtime.Str("file-extension"),
-			SubID:         runtime.Str("sub-id"),
-			OnlySchema:    runtime.Bool("only-schema"),
+	}
+
+	body := map[string]interface{}{
+		"token":          spec.Token,
+		"type":           spec.DocType,
+		"file_extension": spec.FileExtension,
+	}
+	if strings.TrimSpace(spec.SubID) != "" {
+		body["sub_id"] = spec.SubID
+	}
+	if spec.OnlySchema {
+		body["only_schema"] = true
+	}
+
+	dr := common.NewDryRunAPI().
+		Desc("3-step orchestration: create export task -> limited polling -> download file").
+		POST("/open-apis/drive/v1/export_tasks").
+		Body(body).
+		Set("output_dir", p.OutputDir)
+	if name := strings.TrimSpace(p.FileName); name != "" {
+		dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
+	}
+	return dr
+}
+
+// RunExport drives create export task -> bounded poll -> optional download. It
+// is the shared core behind both drive +export and sheets +workbook-export. An
+// empty p.OutputDir skips the download step and returns the ready file token.
+func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportParams) error {
+	spec := p.spec()
+	outputDir := p.OutputDir
+	preferredFileName := strings.TrimSpace(p.FileName)
+	overwrite := p.Overwrite
+
+	// Markdown export bypasses the async export task and writes the fetched
+	// markdown content directly to disk. Uses the V2 docs_ai fetch API for
+	// higher-quality Lark-flavored Markdown output.
+	if spec.FileExtension == "markdown" {
+		fmt.Fprintf(runtime.IO().ErrOut, "Exporting docx as markdown: %s\n", common.MaskToken(spec.Token))
+		apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
+		data, err := runtime.CallAPITyped(
+			"POST",
+			apiPath,
+			nil,
+			map[string]interface{}{
+				"format": "markdown",
+			},
+		)
+		if err != nil {
+			return err
 		}
-		outputDir := runtime.Str("output-dir")
-		preferredFileName := strings.TrimSpace(runtime.Str("file-name"))
-		overwrite := runtime.Bool("overwrite")

-		// Markdown export bypasses the async export task and writes the fetched
-		// markdown content directly to disk. Uses the V2 docs_ai fetch API for
-		// higher-quality Lark-flavored Markdown output.
-		if spec.FileExtension == "markdown" {
-			fmt.Fprintf(runtime.IO().ErrOut, "Exporting docx as markdown: %s\n", common.MaskToken(spec.Token))
-			apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
-			data, err := runtime.CallAPITyped(
-				"POST",
-				apiPath,
-				nil,
-				map[string]interface{}{
-					"format": "markdown",
-				},
-			)
+		// Extract content from the V2 response: data.document.content
+		doc, ok := data["document"].(map[string]interface{})
+		if !ok {
+			return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document object")
+		}
+		content, ok := doc["content"].(string)
+		if !ok {
+			return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document.content")
+		}
+
+		fileName := preferredFileName
+		if fileName == "" {
+			// Prefer the remote title for the exported file name, but still fall
+			// back to the token if metadata is empty.
+			title, err := common.FetchDriveMetaTitle(runtime, spec.Token, spec.DocType)
 			if err != nil {
-				return err
+				fmt.Fprintf(runtime.IO().ErrOut, "Title lookup failed, using token as filename: %v\n", err)
+				title = spec.Token
 			}
+			fileName = title
+		}
+		fileName = ensureExportFileExtension(sanitizeExportFileName(fileName, spec.Token), spec.FileExtension)
+		savedPath, err := saveContentToOutputDir(runtime.FileIO(), outputDir, fileName, []byte(content), overwrite)
+		if err != nil {
+			return err
+		}

-			// Extract content from the V2 response: data.document.content
-			doc, ok := data["document"].(map[string]interface{})
-			if !ok {
-				return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document object")
+		runtime.Out(map[string]interface{}{
+			"token":          spec.Token,
+			"doc_type":       spec.DocType,
+			"file_extension": spec.FileExtension,
+			"file_name":      filepath.Base(savedPath),
+			"saved_path":     savedPath,
+			"size_bytes":     len(content),
+		}, nil)
+		return nil
+	}
+
+	ticket, err := createDriveExportTask(runtime, spec)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(runtime.IO().ErrOut, "Created export task: %s\n", ticket)
+
+	var lastStatus driveExportStatus
+	var lastPollErr error
+	hasObservedStatus := false
+	// Keep the command responsive by polling for a bounded window. If the task
+	// is still running after that, return a resume command instead of blocking.
+	for attempt := 1; attempt <= driveExportPollAttempts; attempt++ {
+		if attempt > 1 {
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			case <-time.After(driveExportPollInterval):
 			}
-			content, ok := doc["content"].(string)
-			if !ok {
-				return errs.NewInternalError(errs.SubtypeInvalidResponse, "invalid markdown fetch response: missing document.content")
+		}
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		status, err := getDriveExportStatus(runtime, spec.Token, ticket)
+		if err != nil {
+			// Treat polling failures as transient so short-lived backend hiccups
+			// do not immediately fail an otherwise healthy export task.
+			lastPollErr = err
+			fmt.Fprintf(runtime.IO().ErrOut, "Export status attempt %d/%d failed: %v\n", attempt, driveExportPollAttempts, err)
+			continue
+		}
+		lastStatus = status
+		hasObservedStatus = true
+
+		if status.Ready() {
+			fmt.Fprintf(runtime.IO().ErrOut, "Export task completed: %s\n", common.MaskToken(status.FileToken))
+
+			// Export-only mode: caller wants the ready file token / metadata but
+			// no local download (e.g. sheets +workbook-export without an output
+			// path). Skip the download and return the status envelope.
+			if strings.TrimSpace(outputDir) == "" {
+				runtime.Out(map[string]interface{}{
+					"ticket":         ticket,
+					"token":          spec.Token,
+					"doc_type":       spec.DocType,
+					"file_extension": spec.FileExtension,
+					"file_token":     status.FileToken,
+					"file_name":      status.FileName,
+					"file_size":      status.FileSize,
+					"ready":          true,
+					"downloaded":     false,
+				}, nil)
+				return nil
 			}

 			fileName := preferredFileName
 			if fileName == "" {
-				// Prefer the remote title for the exported file name, but still fall
-				// back to the token if metadata is empty.
-				title, err := common.FetchDriveMetaTitle(runtime, spec.Token, spec.DocType)
-				if err != nil {
-					fmt.Fprintf(runtime.IO().ErrOut, "Title lookup failed, using token as filename: %v\n", err)
-					title = spec.Token
-				}
-				fileName = title
+				fileName = status.FileName
 			}
 			fileName = ensureExportFileExtension(sanitizeExportFileName(fileName, spec.Token), spec.FileExtension)
-			savedPath, err := saveContentToOutputDir(runtime.FileIO(), outputDir, fileName, []byte(content), overwrite)
+			out, err := downloadDriveExportFile(ctx, runtime, status.FileToken, outputDir, fileName, overwrite)
 			if err != nil {
-				return err
+				recoveryCommand := driveExportDownloadCommand(status.FileToken, fileName, outputDir, overwrite)
+				hint := fmt.Sprintf(
+					"the export artifact is already ready (ticket=%s, file_token=%s)\nretry download with: %s",
+					ticket,
+					status.FileToken,
+					recoveryCommand,
+				)
+				return appendDriveExportRecoveryHint(err, hint)
 			}
-
-			runtime.Out(map[string]interface{}{
-				"token":          spec.Token,
-				"doc_type":       spec.DocType,
-				"file_extension": spec.FileExtension,
-				"file_name":      filepath.Base(savedPath),
-				"saved_path":     savedPath,
-				"size_bytes":     len(content),
-			}, nil)
+			out["ticket"] = ticket
+			out["doc_type"] = spec.DocType
+			out["file_extension"] = spec.FileExtension
+			runtime.Out(out, nil)
 			return nil
 		}

-		ticket, err := createDriveExportTask(runtime, spec)
-		if err != nil {
-			return err
-		}
-		fmt.Fprintf(runtime.IO().ErrOut, "Created export task: %s\n", ticket)
-
-		var lastStatus driveExportStatus
-		var lastPollErr error
-		hasObservedStatus := false
-		// Keep the command responsive by polling for a bounded window. If the task
-		// is still running after that, return a resume command instead of blocking.
-		for attempt := 1; attempt <= driveExportPollAttempts; attempt++ {
-			if attempt > 1 {
-				select {
-				case <-ctx.Done():
-					return ctx.Err()
-				case <-time.After(driveExportPollInterval):
-				}
+		if status.Failed() {
+			msg := strings.TrimSpace(status.JobErrorMsg)
+			if msg == "" {
+				msg = status.StatusLabel()
 			}
-			if err := ctx.Err(); err != nil {
-				return err
-			}
-
-			status, err := getDriveExportStatus(runtime, spec.Token, ticket)
-			if err != nil {
-				// Treat polling failures as transient so short-lived backend hiccups
-				// do not immediately fail an otherwise healthy export task.
-				lastPollErr = err
-				fmt.Fprintf(runtime.IO().ErrOut, "Export status attempt %d/%d failed: %v\n", attempt, driveExportPollAttempts, err)
-				continue
-			}
-			lastStatus = status
-			hasObservedStatus = true
-
-			if status.Ready() {
-				fmt.Fprintf(runtime.IO().ErrOut, "Export task completed: %s\n", common.MaskToken(status.FileToken))
-				fileName := preferredFileName
-				if fileName == "" {
-					fileName = status.FileName
-				}
-				fileName = ensureExportFileExtension(sanitizeExportFileName(fileName, spec.Token), spec.FileExtension)
-				out, err := downloadDriveExportFile(ctx, runtime, status.FileToken, outputDir, fileName, overwrite)
-				if err != nil {
-					recoveryCommand := driveExportDownloadCommand(status.FileToken, fileName, outputDir, overwrite)
-					hint := fmt.Sprintf(
-						"the export artifact is already ready (ticket=%s, file_token=%s)\nretry download with: %s",
-						ticket,
-						status.FileToken,
-						recoveryCommand,
-					)
-					return appendDriveExportRecoveryHint(err, hint)
-				}
-				out["ticket"] = ticket
-				out["doc_type"] = spec.DocType
-				out["file_extension"] = spec.FileExtension
-				runtime.Out(out, nil)
-				return nil
-			}
-
-			if status.Failed() {
-				msg := strings.TrimSpace(status.JobErrorMsg)
-				if msg == "" {
-					msg = status.StatusLabel()
-				}
-				return errs.NewAPIError(errs.SubtypeServerError, "export task failed: %s (ticket=%s)", msg, ticket)
-			}
-
-			fmt.Fprintf(runtime.IO().ErrOut, "Export status %d/%d: %s\n", attempt, driveExportPollAttempts, status.StatusLabel())
+			return errs.NewAPIError(errs.SubtypeServerError, "export task failed: %s (ticket=%s)", msg, ticket)
 		}

-		nextCommand := driveExportTaskResultCommand(ticket, spec.Token)
-		if !hasObservedStatus && lastPollErr != nil {
-			hint := fmt.Sprintf(
-				"the export task was created but every status poll failed (ticket=%s)\nretry status lookup with: %s",
-				ticket,
-				nextCommand,
-			)
-			return appendDriveExportRecoveryHint(lastPollErr, hint)
-		}
+		fmt.Fprintf(runtime.IO().ErrOut, "Export status %d/%d: %s\n", attempt, driveExportPollAttempts, status.StatusLabel())
+	}

-		failed := false
-		var jobStatus interface{}
-		jobStatusLabel := "unknown"
-		if hasObservedStatus {
-			failed = lastStatus.Failed()
-			jobStatus = lastStatus.JobStatus
-			jobStatusLabel = lastStatus.StatusLabel()
-		}
-		// Return the last observed status so callers can resume from a known task
-		// state instead of losing all progress information on timeout.
-		result := map[string]interface{}{
-			"ticket":           ticket,
-			"token":            spec.Token,
-			"doc_type":         spec.DocType,
-			"file_extension":   spec.FileExtension,
-			"ready":            false,
-			"failed":           failed,
-			"job_status":       jobStatus,
-			"job_status_label": jobStatusLabel,
-			"timed_out":        true,
-			"next_command":     nextCommand,
-		}
-		if preferredFileName != "" {
-			result["file_name"] = ensureExportFileExtension(sanitizeExportFileName(preferredFileName, spec.Token), spec.FileExtension)
-		}
-		runtime.Out(result, nil)
-		fmt.Fprintf(runtime.IO().ErrOut, "Export task is still in progress. Continue with: %s\n", nextCommand)
-		return nil
-	},
+	nextCommand := driveExportTaskResultCommand(ticket, spec.Token)
+	if !hasObservedStatus && lastPollErr != nil {
+		hint := fmt.Sprintf(
+			"the export task was created but every status poll failed (ticket=%s)\nretry status lookup with: %s",
+			ticket,
+			nextCommand,
+		)
+		return appendDriveExportRecoveryHint(lastPollErr, hint)
+	}
+
+	failed := false
+	var jobStatus interface{}
+	jobStatusLabel := "unknown"
+	if hasObservedStatus {
+		failed = lastStatus.Failed()
+		jobStatus = lastStatus.JobStatus
+		jobStatusLabel = lastStatus.StatusLabel()
+	}
+	// Return the last observed status so callers can resume from a known task
+	// state instead of losing all progress information on timeout.
+	result := map[string]interface{}{
+		"ticket":           ticket,
+		"token":            spec.Token,
+		"doc_type":         spec.DocType,
+		"file_extension":   spec.FileExtension,
+		"ready":            false,
+		"failed":           failed,
+		"job_status":       jobStatus,
+		"job_status_label": jobStatusLabel,
+		"timed_out":        true,
+		"next_command":     nextCommand,
+	}
+	if preferredFileName != "" {
+		result["file_name"] = ensureExportFileExtension(sanitizeExportFileName(preferredFileName, spec.Token), spec.FileExtension)
+	}
+	runtime.Out(result, nil)
+	fmt.Fprintf(runtime.IO().ErrOut, "Export task is still in progress. Continue with: %s\n", nextCommand)
+	return nil
 }
--- a/shortcuts/drive/drive_export_test.go
+++ b/shortcuts/drive/drive_export_test.go
@@ -497,6 +497,72 @@ func TestDriveExportAsyncSuccess(t *testing.T) {
 	}
 }

+// TestDriveExportEmptyOutputDirDownloadsToCwd guards the export refactor: an
+// explicit empty --output-dir must still download to the current directory
+// (normalized to "."), not trigger the export-only no-download path that the
+// shared RunExport core uses for sheets +workbook-export.
+func TestDriveExportEmptyOutputDirDownloadsToCwd(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
+	reg.Register(&httpmock.Stub{
+		Method: "POST",
+		URL:    "/open-apis/drive/v1/export_tasks",
+		Body:   map[string]interface{}{"code": 0, "data": map[string]interface{}{"ticket": "tk_e"}},
+	})
+	reg.Register(&httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/drive/v1/export_tasks/tk_e",
+		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
+			"result": map[string]interface{}{
+				"job_status": 0, "file_token": "box_e", "file_name": "report",
+				"file_extension": "pdf", "type": "docx", "file_size": 3,
+			},
+		}},
+	})
+	reg.Register(&httpmock.Stub{
+		Method:  "GET",
+		URL:     "/open-apis/drive/v1/export_tasks/file/box_e/download",
+		Status:  200,
+		RawBody: []byte("pdf"),
+		Headers: http.Header{
+			"Content-Type":        []string{"application/pdf"},
+			"Content-Disposition": []string{`attachment; filename="report.pdf"`},
+		},
+	})
+
+	tmpDir := t.TempDir()
+	withDriveWorkingDir(t, tmpDir)
+
+	prevAttempts, prevInterval := driveExportPollAttempts, driveExportPollInterval
+	driveExportPollAttempts, driveExportPollInterval = 1, 0
+	t.Cleanup(func() {
+		driveExportPollAttempts, driveExportPollInterval = prevAttempts, prevInterval
+	})
+
+	err := mountAndRunDrive(t, DriveExport, []string{
+		"+export",
+		"--token", "docx123",
+		"--doc-type", "docx",
+		"--file-extension", "pdf",
+		"--output-dir", "",
+		"--as", "bot",
+	}, f, stdout)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Empty --output-dir must still write to cwd, not skip the download.
+	data, err := os.ReadFile(filepath.Join(tmpDir, "report.pdf"))
+	if err != nil {
+		t.Fatalf("empty --output-dir should still download to cwd: %v", err)
+	}
+	if string(data) != "pdf" {
+		t.Fatalf("downloaded content = %q", string(data))
+	}
+	if strings.Contains(stdout.String(), `"downloaded": false`) {
+		t.Fatalf("export-only path must not trigger for drive +export: %s", stdout.String())
+	}
+}
+
 func TestDriveExportAsyncUsesProvidedFileName(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
--- a/shortcuts/drive/drive_import.go
+++ b/shortcuts/drive/drive_import.go
@@ -35,132 +35,164 @@ var DriveImport = common.Shortcut{
 		{Name: "target-token", Desc: "existing token to import data into (only for type=bitable); when set, data is mounted into this bitable instead of creating a new one"},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		return validateDriveImportSpec(driveImportSpec{
-			FilePath:    runtime.Str("file"),
-			DocType:     strings.ToLower(runtime.Str("type")),
-			FolderToken: runtime.Str("folder-token"),
-			Name:        runtime.Str("name"),
-			TargetToken: runtime.Str("target-token"),
-		})
+		return ValidateImport(importParamsFromFlags(runtime))
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec := driveImportSpec{
-			FilePath:    runtime.Str("file"),
-			DocType:     strings.ToLower(runtime.Str("type")),
-			FolderToken: runtime.Str("folder-token"),
-			Name:        runtime.Str("name"),
-			TargetToken: runtime.Str("target-token"),
-		}
-		fileSize, err := preflightDriveImportFile(runtime.FileIO(), &spec)
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		if valErr := validateDriveImportSpec(spec); valErr != nil {
-			return common.NewDryRunAPI().Set("error", valErr.Error())
-		}
-
-		dry := common.NewDryRunAPI()
-		dry.Desc("Upload file (single-part or multipart) -> create import task -> poll status")
-
-		appendDriveImportFolderTokenWikiCheckDryRun(dry, spec)
-		appendDriveImportUploadDryRun(dry, spec, fileSize)
-
-		dry.POST("/open-apis/drive/v1/import_tasks").
-			Desc("[2] Create import task").
-			Body(spec.CreateTaskBody("<file_token>"))
-
-		dry.GET("/open-apis/drive/v1/import_tasks/:ticket").
-			Desc("[3] Poll import task result").
-			Set("ticket", "<ticket>")
-		if runtime.IsBot() {
-			dry.Desc("After the import result returns the final cloud document target in bot mode, the CLI will also try to grant the current CLI user full_access (可管理权限) on it.")
-		}
-
-		return dry
+		return PlanImportDryRun(runtime, importParamsFromFlags(runtime))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec := driveImportSpec{
-			FilePath:    runtime.Str("file"),
-			DocType:     strings.ToLower(runtime.Str("type")),
-			FolderToken: runtime.Str("folder-token"),
-			Name:        runtime.Str("name"),
-			TargetToken: runtime.Str("target-token"),
-		}
-		if _, err := preflightDriveImportFile(runtime.FileIO(), &spec); err != nil {
-			return err
-		}
-		if err := rejectDriveImportWikiFolderToken(runtime, spec.FolderToken); err != nil {
-			return err
-		}
-
-		// Step 1: Upload file as media
-		fileToken, uploadErr := uploadMediaForImport(ctx, runtime, spec.FilePath, spec.SourceFileName(), spec.DocType)
-		if uploadErr != nil {
-			return uploadErr
-		}
-
-		fmt.Fprintf(runtime.IO().ErrOut, "Creating import task for %s as %s...\n", spec.TargetFileName(), spec.DocType)
-
-		// Step 2: Create import task
-		ticket, err := createDriveImportTask(runtime, spec, fileToken)
-		if err != nil {
-			return err
-		}
-
-		// Step 3: Poll task
-		fmt.Fprintf(runtime.IO().ErrOut, "Polling import task %s...\n", ticket)
-
-		status, ready, err := pollDriveImportTask(runtime, ticket)
-		if err != nil {
-			return err
-		}
-
-		// Some intermediate responses omit the final type, so fall back to the
-		// requested type to keep the output shape stable.
-		resultType := status.DocType
-		if resultType == "" {
-			resultType = spec.DocType
-		}
-		out := map[string]interface{}{
-			"ticket":           ticket,
-			"type":             resultType,
-			"ready":            ready,
-			"job_status":       status.JobStatus,
-			"job_status_label": status.StatusLabel(),
-		}
-		if status.Token != "" {
-			out["token"] = status.Token
-		}
-		if statusURL := strings.TrimSpace(status.URL); statusURL != "" {
-			out["url"] = statusURL
-		} else if status.Token != "" {
-			if u := common.BuildResourceURL(runtime.Config.Brand, normalizeDriveImportKindForURL(resultType, spec.DocType), status.Token); u != "" {
-				out["url"] = u
-			}
-		}
-		if status.JobErrorMsg != "" {
-			out["job_error_msg"] = status.JobErrorMsg
-		}
-		if status.Extra != nil {
-			out["extra"] = status.Extra
-		}
-		if !ready {
-			nextCommand := driveImportTaskResultCommand(ticket)
-			fmt.Fprintf(runtime.IO().ErrOut, "Import task is still in progress. Continue with: %s\n", nextCommand)
-			out["timed_out"] = true
-			out["next_command"] = nextCommand
-		}
-		if ready {
-			if grant := common.AutoGrantCurrentUserDrivePermission(runtime, common.GetString(out, "token"), resultType); grant != nil {
-				out["permission_grant"] = grant
-			}
-		}
-
-		runtime.Out(out, nil)
-		return nil
+		return RunImport(ctx, runtime, importParamsFromFlags(runtime))
 	},
 }

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

 		runtime.OutFormat(resultData, &output.Meta{Count: len(normalizedItems)}, func(w io.Writer) {
 			renderDriveSearchTable(w, data, normalizedItems)
--- a/shortcuts/drive/drive_search_test.go
+++ b/shortcuts/drive/drive_search_test.go
@@ -14,49 +14,12 @@ import (
 	"time"

 	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/errclass"
-	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/internal/output"
 )

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

--- a/shortcuts/im/builders_test.go
+++ b/shortcuts/im/builders_test.go
@@ -26,7 +26,9 @@ func mustMarshalDryRun(t *testing.T, v interface{}) string {
 	return string(b)
 }

-// newTestRuntimeContext builds a RuntimeContext with string and bool test flags.
+// newTestRuntimeContext builds a *common.RuntimeContext backed by a cobra
+// command whose flags are populated from the provided string and bool maps,
+// for unit-testing shortcut bodies, validators, and dry-run shapes.
 func newTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlags map[string]bool) *common.RuntimeContext {
 	t.Helper()

@@ -57,38 +59,9 @@ func newTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlag
 	return &common.RuntimeContext{Cmd: cmd}
 }

-// newChatSearchTestRuntimeContext builds a chat-search RuntimeContext with typed flags.
-func newChatSearchTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlags map[string]bool) *common.RuntimeContext {
-	t.Helper()
-
-	cmd := &cobra.Command{Use: "test"}
-	cmd.Flags().Int("page-size", 20, "")
-	for name := range stringFlags {
-		if name == "page-size" {
-			continue
-		}
-		cmd.Flags().String(name, "", "")
-	}
-	for name := range boolFlags {
-		cmd.Flags().Bool(name, false, "")
-	}
-	if err := cmd.ParseFlags(nil); err != nil {
-		t.Fatalf("ParseFlags() error = %v", err)
-	}
-	for name, val := range stringFlags {
-		if err := cmd.Flags().Set(name, val); err != nil {
-			t.Fatalf("Flags().Set(%q) error = %v", name, err)
-		}
-	}
-	for name, val := range boolFlags {
-		if err := cmd.Flags().Set(name, map[bool]string{true: "true", false: "false"}[val]); err != nil {
-			t.Fatalf("Flags().Set(%q) error = %v", name, err)
-		}
-	}
-	return &common.RuntimeContext{Cmd: cmd}
-}
-
-// newMessagesSearchTestRuntimeContext builds a messages-search RuntimeContext.
+// newMessagesSearchTestRuntimeContext is the messages-search variant of
+// newTestRuntimeContext: registers the search-specific --page-size flag
+// before applying caller-provided values.
 func newMessagesSearchTestRuntimeContext(t *testing.T, stringFlags map[string]string, boolFlags map[string]bool) *common.RuntimeContext {
 	t.Helper()

@@ -258,7 +231,6 @@ func TestIsMediaKey(t *testing.T) {
 	}
 }

-// TestShortcutValidateBranches covers direct shortcut validation branches.
 func TestShortcutValidateBranches(t *testing.T) {

 	t.Run("ImChatCreate valid", func(t *testing.T) {
@@ -325,7 +297,7 @@ func TestShortcutValidateBranches(t *testing.T) {
 	})

 	t.Run("ImChatSearch invalid page size", func(t *testing.T) {
-		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
+		runtime := newTestRuntimeContext(t, map[string]string{
 			"query":     "ok",
 			"page-size": "0",
 		}, nil)
@@ -335,13 +307,12 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})

-	t.Run("ImChatSearch allows long query for server-side notice", func(t *testing.T) {
-		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
-			"query":     strings.Repeat("q", 81),
-			"page-size": "20",
+	t.Run("ImChatSearch query too long", func(t *testing.T) {
+		runtime := newTestRuntimeContext(t, map[string]string{
+			"query": strings.Repeat("q", 65),
 		}, nil)
 		err := ImChatSearch.Validate(context.Background(), runtime)
-		if err != nil {
+		if err == nil || !strings.Contains(err.Error(), "--query exceeds the maximum of 64 characters") {
 			t.Fatalf("ImChatSearch.Validate() error = %v", err)
 		}
 	})
@@ -469,29 +440,6 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})

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

-	t.Run("ImMessagesReply audio rejects non-opus local file", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
-			"message-id": "om_123",
-			"audio":      "./voice.mp3",
-		}, nil)
-		err := ImMessagesReply.Validate(context.Background(), runtime)
-		if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
-			t.Fatalf("ImMessagesReply.Validate() error = %v", err)
-		}
-	})
-
 	t.Run("ImThreadsMessagesList invalid thread", func(t *testing.T) {
 		runtime := newTestRuntimeContext(t, map[string]string{
 			"thread": "bad_thread",
@@ -670,7 +607,6 @@ func TestShortcutValidateBranches(t *testing.T) {
 	})
 }

-// TestMessagesSearchPaginationConfig verifies page-all and page-limit behavior.
 func TestMessagesSearchPaginationConfig(t *testing.T) {
 	t.Run("default single page", func(t *testing.T) {
 		runtime := newMessagesSearchTestRuntimeContext(t, nil, nil)
@@ -714,7 +650,8 @@ func TestMessagesSearchPaginationConfig(t *testing.T) {
 	})
 }

-// TestShortcutDryRunShapes verifies shortcut dry-run API paths and payloads.
+// TestShortcutDryRunShapes verifies that each shortcut's DryRun function
+// produces the expected API path, query parameters, and request body.
 func TestShortcutDryRunShapes(t *testing.T) {
 	t.Run("ImChatCreate dry run includes params and body", func(t *testing.T) {
 		cmd := &cobra.Command{Use: "test"}
@@ -737,19 +674,19 @@ func TestShortcutDryRunShapes(t *testing.T) {
 	})

 	t.Run("ImChatSearch dry run includes built params", func(t *testing.T) {
-		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
+		runtime := newTestRuntimeContext(t, map[string]string{
 			"query":      "team-alpha",
 			"page-size":  "50",
 			"page-token": "next_page",
 		}, nil)
 		got := mustMarshalDryRun(t, ImChatSearch.DryRun(context.Background(), runtime))
-		if !strings.Contains(got, `"/open-apis/im/v2/chats/search"`) || !strings.Contains(got, `"page_size":50`) || !strings.Contains(got, `"query":"\"team-alpha\""`) {
+		if !strings.Contains(got, `"/open-apis/im/v2/chats/search"`) || !strings.Contains(got, `"page_size":20`) || !strings.Contains(got, `"query":"\"team-alpha\""`) {
 			t.Fatalf("ImChatSearch.DryRun() = %s", got)
 		}
 	})

 	t.Run("ImChatSearch dry run still works with --exclude-muted set", func(t *testing.T) {
-		runtime := newChatSearchTestRuntimeContext(t, map[string]string{
+		runtime := newTestRuntimeContext(t, map[string]string{
 			"query": "team-alpha",
 		}, map[string]bool{
 			"exclude-muted": true,
--- a/shortcuts/im/helpers.go
+++ b/shortcuts/im/helpers.go
@@ -1048,42 +1048,6 @@ func detectIMFileType(filePath string) string {
 	}
 }

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

--- a/shortcuts/im/helpers_test.go
+++ b/shortcuts/im/helpers_test.go
@@ -13,7 +13,6 @@ import (
 	"strings"
 	"testing"

-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/shortcuts/common"
 )

@@ -51,56 +50,6 @@ func TestDetectIMFileType(t *testing.T) {
 	}
 }

-func TestValidateAudioMessageInput(t *testing.T) {
-	tests := []struct {
-		name    string
-		value   string
-		wantErr bool
-	}{
-		{name: "empty", value: ""},
-		{name: "existing file key", value: "file_abc"},
-		{name: "opus file", value: "./voice.opus"},
-		{name: "ogg opus file", value: "./voice.ogg"},
-		{name: "uppercase opus", value: "./VOICE.OPUS"},
-		{name: "mp3 local file", value: "./voice.mp3", wantErr: true},
-		{name: "wav local file", value: "./voice.wav", wantErr: true},
-		{name: "extensionless local path", value: "./voice"},
-		{name: "opus url", value: "https://example.com/voice.opus?download=1"},
-		{name: "ogg url", value: "https://example.com/voice.ogg?download=1"},
-		{name: "mp3 url", value: "https://example.com/voice.mp3?download=1", wantErr: true},
-		{name: "extensionless url", value: "https://example.com/download?id=1"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := validateAudioMessageInput("--audio", tt.value)
-			if tt.wantErr {
-				if err == nil || !strings.Contains(err.Error(), "--audio supports only Opus audio files") {
-					t.Fatalf("validateAudioMessageInput(%q) error = %v", tt.value, err)
-				}
-				p, ok := errs.ProblemOf(err)
-				if !ok {
-					t.Fatalf("validateAudioMessageInput(%q) error is not typed: %v", tt.value, err)
-				}
-				if p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-					t.Fatalf("ProblemOf(%q) = category %q subtype %q", tt.value, p.Category, p.Subtype)
-				}
-				validationErr, ok := err.(*errs.ValidationError)
-				if !ok || validationErr.Param != "--audio" {
-					t.Fatalf("validateAudioMessageInput(%q) param = %q, want --audio", tt.value, validationErr.Param)
-				}
-				if !strings.Contains(p.Hint, "use --file") || !strings.Contains(p.Hint, "ffmpeg") {
-					t.Fatalf("validateAudioMessageInput(%q) hint = %q, want --file and ffmpeg guidance", tt.value, p.Hint)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("validateAudioMessageInput(%q) unexpected error = %v", tt.value, err)
-			}
-		})
-	}
-}
-
 // TestSplitCSV covers the shared helper that replaced the three identical functions
 func TestSplitCSV(t *testing.T) {
 	tests := []struct {
--- a/shortcuts/im/im_chat_search.go
+++ b/shortcuts/im/im_chat_search.go
@@ -29,7 +29,7 @@ var ImChatSearch = common.Shortcut{
 	AuthTypes:   []string{"user", "bot"},
 	HasFormat:   true,
 	Flags: []common.Flag{
-		{Name: "query", Desc: "search keyword (server may return data.notice for overly long input)"},
+		{Name: "query", Desc: "search keyword (max 64 chars)"},
 		{Name: "search-types", Desc: "chat types, comma-separated (private, external, public_joined, public_not_joined)"},
 		{Name: "chat-modes", Desc: "filter by chat mode, comma-separated (group, topic)"},
 		{Name: "member-ids", Desc: "filter by member open_ids, comma-separated"},
@@ -50,7 +50,7 @@ var ImChatSearch = common.Shortcut{
 			Params(params).
 			Body(body)
 	},
-	// Validate enforces query/member-ids presence, search-types
+	// Validate enforces query/member-ids presence, --query rune cap, search-types
 	// enum, --member-ids count and format, and --page-size bounds.
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		query := runtime.Str("query")
@@ -58,6 +58,9 @@ var ImChatSearch = common.Shortcut{
 		if query == "" && memberIDs == "" {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--query and --member-ids cannot both be empty; provide at least one (e.g. --query \"team-name\" or --member-ids \"ou_xxx\")")
 		}
+		if query != "" && len([]rune(query)) > 64 {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--query exceeds the maximum of 64 characters (got %d)", len([]rune(query))).WithParam("--query")
+		}
 		if st := runtime.Str("search-types"); st != "" {
 			allowed := map[string]struct{}{
 				"private":           {},
@@ -148,9 +151,6 @@ var ImChatSearch = common.Shortcut{
 			"has_more":   hasMore,
 			"page_token": pageToken,
 		}
-		if notice, _ := resData["notice"].(string); notice != "" {
-			outData["notice"] = notice
-		}
 		if mfOut.Meta.Applied != "" {
 			outData["filter"] = MuteFilterMetaToMap(mfOut.Meta)
 		}
--- a/shortcuts/im/im_messages_reply.go
+++ b/shortcuts/im/im_messages_reply.go
@@ -33,7 +33,7 @@ var ImMessagesReply = common.Shortcut{
 		{Name: "file", Desc: "file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
 		{Name: "video", Desc: "video file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); must be used together with --video-cover"},
 		{Name: "video-cover", Desc: "video cover image key (img_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); required when using --video"},
-		{Name: "audio", Desc: audioMessageInputDesc},
+		{Name: "audio", Desc: "audio file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
 		{Name: "reply-in-thread", Type: "bool", Desc: "reply in thread (message appears in thread stream instead of main chat)"},
 		{Name: "idempotency-key", Desc: "idempotency key (prevents duplicate sends)"},
 	},
@@ -100,9 +100,6 @@ var ImMessagesReply = common.Shortcut{
 				return err
 			}
 		}
-		if err := validateAudioMessageInput("--audio", audioKey); err != nil {
-			return err
-		}

 		if messageId == "" {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--message-id is required (om_xxx)").WithParam("--message-id")
--- a/shortcuts/im/im_messages_search.go
+++ b/shortcuts/im/im_messages_search.go
@@ -91,7 +91,7 @@ var ImMessagesSearch = common.Shortcut{
 			return err
 		}

-		rawItems, hasMore, nextPageToken, truncatedByLimit, pageLimit, notice, err := searchMessages(runtime, req)
+		rawItems, hasMore, nextPageToken, truncatedByLimit, pageLimit, err := searchMessages(runtime, req)
 		if err != nil {
 			return err
 		}
@@ -103,9 +103,6 @@ var ImMessagesSearch = common.Shortcut{
 				"has_more":   hasMore,
 				"page_token": nextPageToken,
 			}
-			if notice != "" {
-				outData["notice"] = notice
-			}
 			runtime.OutFormat(outData, nil, func(w io.Writer) {
 				fmt.Fprintln(w, "No matching messages found.")
 			})
@@ -134,9 +131,6 @@ var ImMessagesSearch = common.Shortcut{
 				"page_token":  nextPageToken,
 				"note":        "failed to fetch message details, returning ID list only",
 			}
-			if notice != "" {
-				outData["notice"] = notice
-			}
 			runtime.OutFormat(outData, nil, func(w io.Writer) {
 				fmt.Fprintf(w, "Found %d messages (failed to fetch details):\n", len(messageIds))
 				for _, id := range messageIds {
@@ -212,9 +206,6 @@ var ImMessagesSearch = common.Shortcut{
 			"has_more":   hasMore,
 			"page_token": nextPageToken,
 		}
-		if notice != "" {
-			outData["notice"] = notice
-		}
 		runtime.OutFormat(outData, nil, func(w io.Writer) {
 			if len(enriched) == 0 {
 				fmt.Fprintln(w, "No matching messages found.")
@@ -386,7 +377,6 @@ func buildMessagesSearchRequest(runtime *common.RuntimeContext) (*messagesSearch
 	}, nil
 }

-// messagesSearchPaginationConfig derives auto-pagination mode and page limit.
 func messagesSearchPaginationConfig(runtime *common.RuntimeContext) (autoPaginate bool, pageLimit int) {
 	autoPaginate = runtime.Bool("page-all")
 	if runtime.Cmd != nil && runtime.Cmd.Flags().Changed("page-limit") {
@@ -402,8 +392,7 @@ func messagesSearchPaginationConfig(runtime *common.RuntimeContext) (autoPaginat
 	return autoPaginate, pageLimit
 }

-// searchMessages fetches message search pages and returns the first server notice.
-func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest) ([]interface{}, bool, string, bool, int, string, error) {
+func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest) ([]interface{}, bool, string, bool, int, error) {
 	autoPaginate, pageLimit := messagesSearchPaginationConfig(runtime)
 	pageToken := ""
 	if tokens := req.params["page_token"]; len(tokens) > 0 {
@@ -421,7 +410,6 @@ func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest)
 		lastPageToken    string
 		truncatedByLimit bool
 		pageCount        int
-		notice           string
 	)

 	for {
@@ -435,12 +423,9 @@ func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest)

 		searchData, err := runtime.DoAPIJSONTyped(http.MethodPost, "/open-apis/im/v1/messages/search", params, req.body)
 		if err != nil {
-			return nil, false, "", false, pageLimit, "", err
+			return nil, false, "", false, pageLimit, err
 		}

-		if notice == "" {
-			notice, _ = searchData["notice"].(string)
-		}
 		items, _ := searchData["items"].([]interface{})
 		allItems = append(allItems, items...)
 		lastHasMore, lastPageToken = common.PaginationMeta(searchData)
@@ -456,10 +441,9 @@ func searchMessages(runtime *common.RuntimeContext, req *messagesSearchRequest)
 		pageToken = lastPageToken
 	}

-	return allItems, lastHasMore, lastPageToken, truncatedByLimit, pageLimit, notice, nil
+	return allItems, lastHasMore, lastPageToken, truncatedByLimit, pageLimit, nil
 }

-// batchMGetMessages fetches message details in API-sized batches.
 func batchMGetMessages(runtime *common.RuntimeContext, messageIds []string) ([]interface{}, error) {
 	var items []interface{}
 	for _, batch := range chunkStrings(messageIds, messagesSearchMGetBatchSize) {
@@ -473,7 +457,6 @@ func batchMGetMessages(runtime *common.RuntimeContext, messageIds []string) ([]i
 	return items, nil
 }

-// batchQueryChatContexts fetches chat metadata best-effort for message rows.
 func batchQueryChatContexts(runtime *common.RuntimeContext, chatIds []string) map[string]map[string]interface{} {
 	chatContexts := map[string]map[string]interface{}{}
 	// Best-effort: a failed chunk only loses its own entries.
@@ -483,7 +466,6 @@ func batchQueryChatContexts(runtime *common.RuntimeContext, chatIds []string) ma
 	return chatContexts
 }

-// chunkStrings splits a string slice into fixed-size batches.
 func chunkStrings(items []string, chunkSize int) [][]string {
 	if len(items) == 0 || chunkSize <= 0 {
 		return nil
--- a/shortcuts/im/im_messages_send.go
+++ b/shortcuts/im/im_messages_send.go
@@ -37,7 +37,7 @@ var ImMessagesSend = common.Shortcut{
 		{Name: "file", Desc: "file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
 		{Name: "video", Desc: "video file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); must be used together with --video-cover"},
 		{Name: "video-cover", Desc: "video cover image key (img_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected); required when using --video"},
-		{Name: "audio", Desc: audioMessageInputDesc},
+		{Name: "audio", Desc: "audio file key (file_xxx), URL, or cwd-relative local path (absolute paths and .. are rejected)"},
 	},
 	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
 		chatFlag := runtime.Str("chat-id")
@@ -112,9 +112,6 @@ var ImMessagesSend = common.Shortcut{
 				return err
 			}
 		}
-		if err := validateAudioMessageInput("--audio", audioKey); err != nil {
-			return err
-		}

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

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

@@ -799,7 +801,13 @@ func buildListParams(runtime *common.RuntimeContext, mailboxID string, f triageF
 				params["label_id"] = labelIDFromFilter
 			}
 		} else {
-			params["label_id"] = labelIDFromFilter
+			resolved, err := resolveLabelID(runtime, mailboxID, labelIDFromFilter)
+			if err != nil {
+				return nil, err
+			}
+			if resolved != "" {
+				params["label_id"] = resolved
+			}
 		}
 	} else if labelFromFilter != "" {
 		if dryRun {
@@ -809,7 +817,13 @@ func buildListParams(runtime *common.RuntimeContext, mailboxID string, f triageF
 				params["label_id"] = labelFromFilter
 			}
 		} else {
-			params["label_id"] = labelFromFilter
+			resolved, err := resolveLabelName(runtime, mailboxID, labelFromFilter)
+			if err != nil {
+				return nil, err
+			}
+			if resolved != "" {
+				params["label_id"] = resolved
+			}
 		}
 	}

--- a/shortcuts/mail/mail_triage_test.go
+++ b/shortcuts/mail/mail_triage_test.go
@@ -12,7 +12,6 @@ import (
 	"testing"

 	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/shortcuts/common"
@@ -975,11 +974,7 @@ func TestBuildListParamsDryRunOnlyUnread(t *testing.T) {
 func TestBuildListParamsDryRunFolderAlias(t *testing.T) {
 	rt := runtimeForMailTriageTest(t, nil)
 	f := triageFilter{Folder: "sent"}
-	resolved, err := resolveListFilter(rt, "me", f, true)
-	if err != nil {
-		t.Fatalf("resolveListFilter: %v", err)
-	}
-	got, err := buildListParams(rt, "me", resolved, 20, "", true)
+	got, err := buildListParams(rt, "me", f, 20, "", true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -988,30 +983,10 @@ func TestBuildListParamsDryRunFolderAlias(t *testing.T) {
 	}
 }

-func TestBuildListParamsDryRunCustomFolderPreservesInput(t *testing.T) {
-	rt := runtimeForMailTriageTest(t, nil)
-	f := triageFilter{Folder: "team-folder"}
-	resolved, err := resolveListFilter(rt, "me", f, true)
-	if err != nil {
-		t.Fatalf("resolveListFilter: %v", err)
-	}
-	got, err := buildListParams(rt, "me", resolved, 20, "", true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got["folder_id"] != "team-folder" {
-		t.Fatalf("expected dry-run folder_id=team-folder, got %v", got["folder_id"])
-	}
-}
-
 func TestBuildListParamsDryRunLabelAlias(t *testing.T) {
 	rt := runtimeForMailTriageTest(t, nil)
 	f := triageFilter{Label: "flagged"}
-	resolved, err := resolveListFilter(rt, "me", f, true)
-	if err != nil {
-		t.Fatalf("resolveListFilter: %v", err)
-	}
-	got, err := buildListParams(rt, "me", resolved, 10, "", true)
+	got, err := buildListParams(rt, "me", f, 10, "", true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1020,25 +995,6 @@ func TestBuildListParamsDryRunLabelAlias(t *testing.T) {
 	}
 }

-func TestBuildListParamsDryRunCustomLabelPreservesInput(t *testing.T) {
-	rt := runtimeForMailTriageTest(t, nil)
-	f := triageFilter{Label: "custom-label"}
-	resolved, err := resolveListFilter(rt, "me", f, true)
-	if err != nil {
-		t.Fatalf("resolveListFilter: %v", err)
-	}
-	got, err := buildListParams(rt, "me", resolved, 10, "", true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := got["folder_id"]; ok {
-		t.Fatalf("folder_id should not be set when label is specified, got %v", got["folder_id"])
-	}
-	if got["label_id"] != "custom-label" {
-		t.Fatalf("expected dry-run label_id=custom-label, got %v", got["label_id"])
-	}
-}
-
 // --- buildSearchParams additional coverage ---

 func TestBuildSearchParamsAllFilterFields(t *testing.T) {
@@ -1522,16 +1478,14 @@ func boolPtr(v bool) *bool { return &v }

 // --- mailbox_id preservation tests ---

-// TestMailTriageStructuredOutputPreservesMailboxID verifies mailbox and notice metadata.
 func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 	tests := []struct {
-		name       string
-		mailbox    string
-		format     string
-		args       []string
-		register   func(*httpmock.Registry, string)
-		wantCount  int
-		wantNotice string
+		name      string
+		mailbox   string
+		format    string
+		args      []string
+		register  func(*httpmock.Registry, string)
+		wantCount int
 	}{
 		{
 			name:    "list json default mailbox",
@@ -1568,10 +1522,9 @@ func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 			register: func(reg *httpmock.Registry, mailbox string) {
 				registerMailTriageSearchStub(reg, mailbox, []interface{}{
 					mailTriageSearchItem("search_pub_001", "Shared search"),
-				}, false, "", "The query is too long and has been truncated to the first 50 characters for search.")
+				}, false, "")
 			},
-			wantCount:  1,
-			wantNotice: "The query is too long and has been truncated to the first 50 characters for search.",
+			wantCount: 1,
 		},
 		{
 			name:    "empty list json keeps top-level mailbox",
@@ -1606,9 +1559,6 @@ func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 			if data["mailbox_id"] != tt.mailbox {
 				t.Fatalf("top-level mailbox_id mismatch: got %v, want %q", data["mailbox_id"], tt.mailbox)
 			}
-			if tt.wantNotice != "" && data["notice"] != tt.wantNotice {
-				t.Fatalf("notice mismatch: got %v, want %q", data["notice"], tt.wantNotice)
-			}
 			messages := mailTriageMessagesFromOutput(t, data)
 			if len(messages) != tt.wantCount {
 				t.Fatalf("message count mismatch: got %d, want %d", len(messages), tt.wantCount)
@@ -1622,7 +1572,6 @@ func TestMailTriageStructuredOutputPreservesMailboxID(t *testing.T) {
 	}
 }

-// TestMailTriageMissingMessageMetadataStillGetsMailboxID verifies fallback rows keep mailbox IDs.
 func TestMailTriageMissingMessageMetadataStillGetsMailboxID(t *testing.T) {
 	f, stdout, _, reg := mailShortcutTestFactory(t)
 	defer reg.Verify(t)
@@ -1655,7 +1604,6 @@ func TestMailTriageMissingMessageMetadataStillGetsMailboxID(t *testing.T) {
 	}
 }

-// TestMailTriageTableOutputPreservesMailboxContext verifies public mailbox table hints.
 func TestMailTriageTableOutputPreservesMailboxContext(t *testing.T) {
 	tests := []struct {
 		name              string
@@ -1706,33 +1654,6 @@ func TestMailTriageTableOutputPreservesMailboxContext(t *testing.T) {
 	}
 }

-// TestMailTriageDefaultTableOutputPrintsSearchNoticeToStderr verifies stderr notices.
-func TestMailTriageDefaultTableOutputPrintsSearchNoticeToStderr(t *testing.T) {
-	const notice = "The query is too long and has been truncated to the first 50 characters for search."
-
-	f, stdout, stderr, reg := mailShortcutTestFactory(t)
-	defer reg.Verify(t)
-
-	registerMailTriageSearchStub(reg, "me", []interface{}{
-		mailTriageSearchItem("msg_search_notice", "Search notice result"),
-	}, false, "", notice)
-
-	if err := runMountedMailShortcut(t, MailTriage, []string{
-		"+triage",
-		"--query", strings.Repeat("q", 81),
-	}, f, stdout); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if out := stdout.String(); !strings.Contains(out, "msg_search_notice") {
-		t.Fatalf("stdout should contain table row, got:\n%s", out)
-	}
-	if errOut := stderr.String(); !strings.Contains(errOut, "notice: "+notice) {
-		t.Fatalf("stderr should contain search notice, got:\n%s", errOut)
-	}
-}
-
-// decodeMailTriageJSONOutput decodes structured triage output for assertions.
 func decodeMailTriageJSONOutput(t *testing.T, stdout interface{ Bytes() []byte }) map[string]interface{} {
 	t.Helper()
 	var data map[string]interface{}
@@ -1742,7 +1663,6 @@ func decodeMailTriageJSONOutput(t *testing.T, stdout interface{ Bytes() []byte }
 	return data
 }

-// mailTriageMessagesFromOutput extracts triage messages as object maps.
 func mailTriageMessagesFromOutput(t *testing.T, data map[string]interface{}) []map[string]interface{} {
 	t.Helper()
 	rawMessages, ok := data["messages"].([]interface{})
@@ -1795,8 +1715,7 @@ func registerMailTriageBatchStub(reg *httpmock.Registry, mailbox string, message
 	})
 }

-// registerMailTriageSearchStub registers a mailbox search response for triage tests.
-func registerMailTriageSearchStub(reg *httpmock.Registry, mailbox string, items []interface{}, hasMore bool, pageToken string, notices ...string) {
+func registerMailTriageSearchStub(reg *httpmock.Registry, mailbox string, items []interface{}, hasMore bool, pageToken string) {
 	data := map[string]interface{}{
 		"items":    items,
 		"has_more": hasMore,
@@ -1804,9 +1723,6 @@ func registerMailTriageSearchStub(reg *httpmock.Registry, mailbox string, items
 	if pageToken != "" {
 		data["page_token"] = pageToken
 	}
-	if len(notices) > 0 && notices[0] != "" {
-		data["notice"] = notices[0]
-	}
 	reg.Register(&httpmock.Stub{
 		Method: "POST",
 		URL:    mailboxPath(mailbox, "search"),
@@ -1835,137 +1751,3 @@ func mailTriageSearchItem(messageID, subject string) map[string]interface{} {
 		},
 	}
 }
-
-// registerMailTriageFoldersListStub registers a NON-reusable stub for the
-// mailbox folders list API. Because it is non-reusable, any second hit returns
-// "httpmock: no stub for GET .../folders" — which is exactly the assertion we
-// use to prove resolveListFilter runs once and buildListParams does NOT
-// re-resolve. folderID/folderName is the single custom folder the API reports.
-func registerMailTriageFoldersListStub(reg *httpmock.Registry, mailbox, folderID, folderName string) {
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    mailboxPath(mailbox, "folders"),
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"items": []interface{}{
-					map[string]interface{}{
-						"id":   folderID,
-						"name": folderName,
-					},
-				},
-			},
-		},
-	})
-}
-
-// registerMailTriageListPageStub registers one page of the messages list API,
-// disambiguated from sibling pages by a URL substring unique to that page
-// (e.g. "page_size=5" for page 1 vs "page_size=2" for page 2). The substring
-// must NOT depend on query-param ordering: map iteration makes param order
-// nondeterministic, so prefer a value-only token like "page_size=N" (the N
-// differs per page because pageSize = maxCount - fetched_so_far). Non-reusable
-// so reg.Verify catches under- or over-consumption.
-func registerMailTriageListPageStub(reg *httpmock.Registry, urlSubstring string, items []string, hasMore bool, pageToken string) {
-	data := map[string]interface{}{
-		"items":    items,
-		"has_more": hasMore,
-	}
-	if pageToken != "" {
-		data["page_token"] = pageToken
-	}
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    urlSubstring,
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": data,
-		},
-	})
-}
-
-// TestMailTriageCustomFolderResolvesOnceAcrossListPages is the regression test
-// for the bug where buildListParams re-called resolveFolderID on every list
-// page, turning "resolve once" into "1 + page_count" folder-list API calls and
-// easily tripping rate limits.
-//
-// Setup: a custom folder filter that forces resolveListFilter to hit the
-// folders list API once (to map folder name "team-folder" to folder_id), then two
-// messages-list pages. The folders list stub is non-reusable, so if
-// buildListParams re-resolves, the second hit fails with "no stub". The
-// messages-list stubs are page-specific (disambiguated by page_size in the
-// URL), so both pages are served and Verify asserts each fired exactly once.
-func TestMailTriageCustomFolderResolvesOnceAcrossListPages(t *testing.T) {
-	f, stdout, _, reg := mailShortcutTestFactory(t)
-	defer reg.Verify(t)
-
-	// listMailboxFolders (called once by resolveListFilter) gates on the
-	// mail:user_mailbox.folder:read scope, which the default test token does
-	// not carry. Re-store the token with that scope appended so the folders
-	// API call is actually exercised (and thus the non-reusable folders stub
-	// is the load-bearing "exactly once" assertion).
-	const folderScope = "mail:user_mailbox.folder:read"
-	cfg := mailTestConfig()
-	if stored := auth.GetStoredToken(cfg.AppID, cfg.UserOpenId); stored != nil {
-		if !strings.Contains(stored.Scope, folderScope) {
-			stored.Scope = stored.Scope + " " + folderScope
-			if err := auth.SetStoredToken(stored); err != nil {
-				t.Fatalf("re-store token with folder scope: %v", err)
-			}
-		}
-	}
-
-	const (
-		mailbox    = "me"
-		folderName = "team-folder"
-		folderID   = "fld_custom_team"
-		page2Token = "tok_page2"
-	)
-	// --max 5 with listPageMax=20 → pageSize = 5-0 = 5 on page 1, then 5-3 = 2
-	// on page 2. The page_size query value disambiguates the two list stubs.
-	page1IDs := []string{"msg_a", "msg_b", "msg_c"}
-	page2IDs := []string{"msg_d", "msg_e"}
-
-	// Folders list: registered exactly once, non-reusable. Any second folder
-	// lookup (the bug) fails the test with "no stub for GET .../folders".
-	registerMailTriageFoldersListStub(reg, mailbox, folderID, folderName)
-	// Messages list, page 1: 3 ids, has_more, hands off a page-2 token. The
-	// page_size value (5 = maxCount - 0) is unique to page 1; page 2 uses 2.
-	registerMailTriageListPageStub(reg, "page_size=5", page1IDs, true, page2Token)
-	// Messages list, page 2: 2 ids, terminal.
-	registerMailTriageListPageStub(reg, "page_size=2", page2IDs, false, "")
-	// Batch metadata fetch for all 5 ids.
-	registerMailTriageBatchStub(reg, mailbox, []map[string]interface{}{
-		mailTriageBatchMessage("msg_a", "Subject A"),
-		mailTriageBatchMessage("msg_b", "Subject B"),
-		mailTriageBatchMessage("msg_c", "Subject C"),
-		mailTriageBatchMessage("msg_d", "Subject D"),
-		mailTriageBatchMessage("msg_e", "Subject E"),
-	})
-
-	args := []string{
-		"+triage",
-		"--as", "user",
-		"--mailbox", mailbox,
-		"--filter", `{"folder":"` + folderName + `"}`,
-		"--max", "5",
-		"--format", "json",
-	}
-	if err := runMountedMailShortcut(t, MailTriage, args, f, stdout); err != nil {
-		t.Fatalf("unexpected error running +triage (likely a second folders API call — the bug): %v", err)
-	}
-
-	data := decodeMailTriageJSONOutput(t, stdout)
-	messages := mailTriageMessagesFromOutput(t, data)
-	if len(messages) != 5 {
-		t.Fatalf("expected 5 messages across 2 pages, got %d (stdout=%s)", len(messages), stdout.String())
-	}
-	if got := data["has_more"]; got != false {
-		t.Fatalf("expected has_more=false after exhausting pages, got %v", got)
-	}
-	// All registered stubs (1 folders + 2 list pages + 1 batch_get) are
-	// non-reusable; reg.Verify (deferred above) asserts each was matched
-	// exactly once. Combined with the non-reusable folders stub, this is the
-	// proof that the folders list API was called exactly once across both
-	// pages — the core invariant the fix restores.
-}
--- a/shortcuts/minutes/minutes_search.go
+++ b/shortcuts/minutes/minutes_search.go
@@ -308,9 +308,6 @@ var MinutesSearch = common.Shortcut{
 			"has_more":   data["has_more"],
 			"page_token": data["page_token"],
 		}
-		if notice, _ := data["notice"].(string); notice != "" {
-			outData["notice"] = notice
-		}

 		runtime.OutFormat(outData, &output.Meta{Count: len(rows)}, func(w io.Writer) {
 			if len(rows) == 0 {
--- a/shortcuts/minutes/minutes_search_test.go
+++ b/shortcuts/minutes/minutes_search_test.go
@@ -609,8 +609,6 @@ func TestMinutesSearchExecuteShowsPaginationHintForTableFormat(t *testing.T) {
 func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 	t.Parallel()

-	const notice = "The query is too long and has been truncated to the first 50 characters for search."
-
 	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
 	reg.Register(&httpmock.Stub{
 		Method: "POST",
@@ -619,7 +617,6 @@ func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 			"code": 0,
 			"msg":  "ok",
 			"data": map[string]interface{}{
-				"notice": notice,
 				"items": []interface{}{
 					nil,
 					map[string]interface{}{
@@ -644,9 +641,6 @@ func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 	reg.Verify(t)

 	var envelope struct {
-		Data struct {
-			Notice string `json:"notice"`
-		} `json:"data"`
 		Meta struct {
 			Count int `json:"count"`
 		} `json:"meta"`
@@ -657,9 +651,6 @@ func TestMinutesSearchExecuteJSONCountUsesRenderedRows(t *testing.T) {
 	if envelope.Meta.Count != 1 {
 		t.Fatalf("meta.count = %d, want 1", envelope.Meta.Count)
 	}
-	if envelope.Data.Notice != notice {
-		t.Fatalf("data.notice = %q, want %q", envelope.Data.Notice, notice)
-	}
 }

 // TestMinuteSearchFieldExtractors verifies field extractors read populated metadata correctly.
--- a/shortcuts/sheets/batch_op_contract_test.go
+++ b/shortcuts/sheets/batch_op_contract_test.go
@@ -177,6 +177,18 @@ func TestBatchOp_BodyMatchesStandalone(t *testing.T) {
 			args:     []string{"--sheet-id", "sh1", "--color", "#FF0000"},
 			subInput: `{"sheet-id":"sh1","color":"#FF0000"}`,
 		},
+		{
+			shortcut: "+sheet-show-gridline",
+			sc:       SheetShowGridline,
+			args:     []string{"--sheet-id", "sh1"},
+			subInput: `{"sheet-id":"sh1"}`,
+		},
+		{
+			shortcut: "+sheet-hide-gridline",
+			sc:       SheetHideGridline,
+			args:     []string{"--sheet-id", "sh1"},
+			subInput: `{"sheet-id":"sh1"}`,
+		},
 		{
 			shortcut: "+dropdown-set",
 			sc:       DropdownSet,
--- a/shortcuts/sheets/batch_op_dispatch.go
+++ b/shortcuts/sheets/batch_op_dispatch.go
@@ -150,6 +150,12 @@ var batchOpDispatch = map[string]batchOpMapping{
 		return sheetVisibilityInput(fv, t, sid, sn, "unhide")
 	}},
 	"+sheet-set-tab-color": {"modify_workbook_structure", sheetSetTabColorInput},
+	"+sheet-show-gridline": {"modify_workbook_structure", func(fv flagView, t, sid, sn string) (map[string]interface{}, error) {
+		return sheetVisibilityInput(fv, t, sid, sn, "show_gridline")
+	}},
+	"+sheet-hide-gridline": {"modify_workbook_structure", func(fv flagView, t, sid, sn string) (map[string]interface{}, error) {
+		return sheetVisibilityInput(fv, t, sid, sn, "hide_gridline")
+	}},

 	// ─── 对象族 CRUD (manage_*_object, operation 区分) ─────────────
 	"+chart-create": {"manage_chart_object", objCreateTranslate(chartSpec)},
--- a/shortcuts/sheets/data/flag-defs.json
+++ b/shortcuts/sheets/data/flag-defs.json
@@ -54,7 +54,7 @@
        "kind": "own",
        "type": "int",
        "required": "optional",
-        "desc": "Insert position; appended to the end when omitted",
+        "desc": "Insert position (0-based); appended to the end when omitted",
        "default": "-1"
      },
      {
@@ -413,6 +413,86 @@
      }
    ]
  },
+  "+sheet-hide-gridline": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token (XOR with `--url`)"
+      },
+      {
+        "name": "sheet-id",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet reference_id (XOR with `--sheet-name`)"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet name (XOR with `--sheet-id`)"
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": ""
+      }
+    ]
+  },
+  "+sheet-show-gridline": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token (XOR with `--url`)"
+      },
+      {
+        "name": "sheet-id",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet reference_id (XOR with `--sheet-name`)"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Sheet name (XOR with `--sheet-id`)"
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": ""
+      }
+    ]
+  },
  "+workbook-create": {
    "risk": "write",
    "flags": [
@@ -431,27 +511,45 @@
        "desc": "Target folder token; placed at the drive root when omitted"
      },
      {
-        "name": "headers",
+        "name": "values",
        "kind": "own",
        "type": "string",
        "required": "optional",
-        "desc": "Header row as a JSON array: `[\"Col A\",\"Col B\"]`",
+        "desc": "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected, through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes",
        "input": [
          "file",
          "stdin"
        ]
      },
      {
-        "name": "values",
+        "name": "sheets",
        "kind": "own",
        "type": "string",
        "required": "optional",
-        "desc": "Initial data as a 2D JSON array: `[[\"alice\",95]]`",
+        "desc": "Typed table payload as JSON (same shape as `+table-put`): a top-level `sheets` array, each item `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}`. Agents typically build it from a DataFrame via `{**json.loads(df.to_json(orient=\"split\")), \"dtypes\": df.dtypes.astype(str).to_dict()}`. Mutually exclusive with --values and --dataframe. Creates the workbook, then writes typed type-faithful data (dates land as real dates, numbers keep precision).",
        "input": [
          "file",
          "stdin"
        ]
      },
+      {
+        "name": "styles",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Initial visual operations as JSON: top-level `{styles:[...]}`. Each item corresponds to one target sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. With --sheets, styles array length/order/name must match --sheets.sheets. With --values, pass exactly one styles item for the initial sheet (its name is ignored).",
+        "input": [
+          "file",
+          "stdin"
+        ]
+      },
+      {
+        "name": "dataframe",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Single-sheet typed table from one Arrow IPC file (Feather v2 — what `pandas.DataFrame.to_feather()` writes), mutually exclusive with --values and --sheets. Pass `@<path>` for a file or `-` for binary stdin (same convention as other input flags). Arrow bytes are read raw — no TrimSpace / BOM strip — so the IPC magic survives intact (unlike text input flags). Column types come from the Arrow schema; per-column `number_format` may be set via Arrow field metadata. Creates the workbook and fills its default sheet (`Sheet1` — adopted in place, no empty Sheet1 left behind). For multi-sheet or non-default placement, use `--sheets` instead."
+      },
      {
        "name": "dry-run",
        "kind": "system",
@@ -513,6 +611,32 @@
      }
    ]
  },
+  "+workbook-import": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "file",
+        "kind": "own",
+        "type": "string",
+        "required": "required",
+        "desc": "Local file path (.xlsx / .xls / .csv)"
+      },
+      {
+        "name": "folder-token",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Target folder token; imported to the cloud drive root when omitted"
+      },
+      {
+        "name": "name",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Imported spreadsheet name; defaults to the local file name without its extension"
+      }
+    ]
+  },
  "+sheet-info": {
    "risk": "read",
    "flags": [
@@ -1082,9 +1206,8 @@
        "kind": "own",
        "type": "int",
        "required": "optional",
-        "desc": "Safety cap; default 200000",
-        "default": "200000",
-        "hidden": true
+        "desc": "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more",
+        "default": "500000"
      },
      {
        "name": "skip-hidden",
@@ -1192,9 +1315,8 @@
        "kind": "own",
        "type": "int",
        "required": "optional",
-        "desc": "Safety cap; default 200000",
-        "default": "200000",
-        "hidden": true
+        "desc": "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more",
+        "default": "500000"
      },
      {
        "name": "include-row-prefix",
@@ -1212,19 +1334,72 @@
        "desc": "Skip hidden rows and columns; default `false`"
      },
      {
-        "name": "rows-json",
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": "Print the request path and parameters without executing"
+      }
+    ]
+  },
+  "+table-get": {
+    "risk": "read",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token (XOR with `--url`)"
+      },
+      {
+        "name": "sheet-id",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Read only this sheet (by id); omit to read all sheets"
+      },
+      {
+        "name": "sheet-name",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Read only this sheet (by name); omit to read all sheets"
+      },
+      {
+        "name": "range",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "A1 range to read; omit to read each sheet's full used range (spans internal blank rows/columns, not just the A1 current region)"
+      },
+      {
+        "name": "no-header",
        "kind": "own",
        "type": "bool",
        "required": "optional",
-        "desc": "Return structured rows ({row_number, values:{col→cell}}) instead of CSV text; default false",
-        "default": "false"
+        "desc": "Treat the first row as data instead of a header (columns get positional names col1, col2, ...)"
+      },
+      {
+        "name": "dataframe-out",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Write the typed table as one Arrow IPC file (Feather v2) instead of the default JSON. Pass `@<path>` for a file or `-` for binary stdout (same convention as other binary I/O flags). Mirror of the input-side `--dataframe` on `+table-put` / `+workbook-create` — pandas users round-trip via `df = pd.read_feather(\"x.arrow\")` or `pd.read_feather(io.BytesIO(stdout))`. Single-sheet only: requires `--sheet-id` or `--sheet-name`; whole-workbook reads keep the default JSON path. Column types come from the typed read-back (string/number/date/bool); per-column `number_format` is preserved as Arrow field metadata so the Arrow file can round-trip straight back through `+table-put --dataframe`."
      },
      {
        "name": "dry-run",
        "kind": "system",
        "type": "bool",
        "required": "optional",
-        "desc": "Print the request path and parameters without executing"
+        "desc": ""
      }
    ]
  },
@@ -1849,7 +2024,7 @@
        "kind": "own",
        "type": "string",
        "required": "required",
-        "desc": "RFC 4180 CSV text; plain values only (no formulas / styles / comments)",
+        "desc": "RFC 4180 CSV text; values or formulas (a leading = is evaluated as a formula); no styles / comments / images (use +cells-set for those).",
        "input": [
          "file",
          "stdin"
@@ -1880,6 +2055,61 @@
      }
    ]
  },
+  "+table-put": {
+    "risk": "write",
+    "flags": [
+      {
+        "name": "url",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet URL to write into (XOR with `--spreadsheet-token`)"
+      },
+      {
+        "name": "spreadsheet-token",
+        "kind": "public",
+        "type": "string",
+        "required": "xor",
+        "desc": "Spreadsheet token to write into (XOR with `--url`)"
+      },
+      {
+        "name": "sheets",
+        "kind": "own",
+        "type": "string",
+        "required": "xor",
+        "desc": "Typed table payload (pandas-DataFrame-shaped) as JSON, XOR with `--dataframe`: a top-level `sheets` array, each item `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}`. Agents typically build it with `{**json.loads(df.to_json(orient=\"split\")), \"dtypes\": df.dtypes.astype(str).to_dict()}`. `dtypes` values are pandas dtype strings (`int64`, `float64`, `Int64`, `bool`, `boolean`, `datetime64[ns]`, `object`, ...); the writer maps them to internal string/number/date/bool — omit `dtypes` and a column writes as text (good for raw CSV-shaped data). `formats[col]` is an Excel number_format string (e.g. `#,##0.00`, `0.0%`, `yyyy-mm`); when absent, date columns default to `yyyy-mm-dd` and string columns to text format (`@`).",
+        "input": [
+          "file",
+          "stdin"
+        ]
+      },
+      {
+        "name": "dataframe",
+        "kind": "own",
+        "type": "string",
+        "required": "xor",
+        "desc": "Single-sheet typed table from one Arrow IPC file (a.k.a. Feather v2 — what `pandas.DataFrame.to_feather()` writes), XOR with `--sheets`. Pass `@<path>` for a file or `-` for binary stdin (same convention as other input flags). Arrow bytes are read raw — no TrimSpace / BOM strip — so the IPC magic survives intact (unlike text input flags). Column types come from the Arrow schema (int*/uint*/float* → number, date32/date64/timestamp → date, utf8/large_utf8 → string, bool → bool); per-column `number_format` may be set via Arrow field metadata (`pa.field(\"price\", pa.float64(), metadata={b\"number_format\": b\"$#,##0.00\"})`). Writes the sheet at default placement: name `Sheet1` (created when absent), overwrite from A1 with header. For a different sheet name, anchor, mode, or to write multiple sheets, use `--sheets` instead."
+      },
+      {
+        "name": "styles",
+        "kind": "own",
+        "type": "string",
+        "required": "optional",
+        "desc": "Visual operations applied after the typed write, as JSON: top-level `{styles:[...]}`. Each item corresponds to one written sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. The styles array length/order/name must match the written sheets: with --sheets, match --sheets.sheets; with --dataframe (single sheet named Sheet1), pass exactly one styles item with name `Sheet1`. Run `+table-put --print-schema --flag-name styles` for the full cell_styles field schema.",
+        "input": [
+          "file",
+          "stdin"
+        ]
+      },
+      {
+        "name": "dry-run",
+        "kind": "system",
+        "type": "bool",
+        "required": "optional",
+        "desc": ""
+      }
+    ]
+  },
  "+cells-clear": {
    "risk": "high-risk-write",
    "flags": [
--- a/shortcuts/sheets/data/flag-schemas.json
+++ b/shortcuts/sheets/data/flag-schemas.json
@@ -1,5 +1,5 @@
 {
-  "schema_version": "2",
+  "schema_version": "3",
  "flags": {
    "+batch-update": {
      "operations": {
@@ -454,7 +454,7 @@
                      "type": "object"
                    },
                    "link": {
-                      "description": "超链接地址（仅 type='link' 时必填）",
+                      "description": "超链接地址（type='link' 时必填）；@文档 mention（mention_type 非 0）时也必填，传文档 URL（如搜索结果里的文档链接），否则卡片不可点。@人（mention_type=0）不需要传",
                      "type": "string"
                    },
                    "mention_token": {
@@ -462,8 +462,21 @@
                      "type": "string"
                    },
                    "mention_type": {
-                      "description": "@提及类型编号（仅 type='mention' 时可选）",
-                      "type": "number"
+                      "description": "@提及类型编号（仅 type='mention' 时可选）。0 或不填=@用户；@文件时按类型取：1=文档 3=电子表格 8=多维表格 11=思维笔记 12=文件 15=旧版幻灯片 16=知识库 22=新版文档 30=幻灯片 38=画板",
+                      "type": "number",
+                      "enum": [
+                        0,
+                        1,
+                        3,
+                        8,
+                        11,
+                        12,
+                        15,
+                        16,
+                        22,
+                        30,
+                        38
+                      ]
                    },
                    "notify": {
                      "description": "是否发送通知（仅 type='mention' 时可选，默认 true）",
@@ -1730,11 +1743,12 @@
                            },
                            "aggregateType": {
                              "type": "string",
-                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效",
+                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效。count 只统计数值单元格；counta 统计所有非空单元格（含文本），按文本/分类列统计出现次数（如各类别的数量、频次分布）时用 counta。",
                              "enum": [
                                "sum",
                                "average",
                                "count",
+                                "counta",
                                "min",
                                "max",
                                "median"
@@ -1787,11 +1801,7 @@
              "data"
            ]
          }
-        },
-        "required": [
-          "position",
-          "size"
-        ]
+        }
      }
    },
    "+chart-update": {
@@ -2769,11 +2779,12 @@
                            },
                            "aggregateType": {
                              "type": "string",
-                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效",
+                              "description": "汇总方式，默认为'sum'，仅在 aggregate 为 true 时生效。count 只统计数值单元格；counta 统计所有非空单元格（含文本），按文本/分类列统计出现次数（如各类别的数量、频次分布）时用 counta。",
                              "enum": [
                                "sum",
                                "average",
                                "count",
+                                "counta",
                                "min",
                                "max",
                                "median"
@@ -2826,11 +2837,7 @@
              "data"
            ]
          }
-        },
-        "required": [
-          "position",
-          "size"
-        ]
+        }
      }
    },
    "+cond-format-create": {
@@ -6249,6 +6256,744 @@
          }
        }
      }
+    },
+    "+table-put": {
+      "sheets": {
+        "type": "array",
+        "minItems": 1,
+        "description": "一个或多个子表的 typed 数据，每个数组元素写入一张子表；支持多 DataFrame → 多子表一次写入。整体形状对齐 pandas `df.to_json(orient=\"split\")`：列名走 `columns`、二维取值走 `data`、每列的 pandas dtype 走 `dtypes`、可选的展示格式走 `formats`。一行式用法：`{**json.loads(df.to_json(orient=\"split\")), \"dtypes\": df.dtypes.astype(str).to_dict()}`。",
+        "items": {
+          "type": "object",
+          "required": [
+            "name",
+            "columns",
+            "data"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "目标子表名。按名匹配已有子表；不存在则新建该子表。同一次调用内子表名不可重复。"
+            },
+            "start_cell": {
+              "type": "string",
+              "default": "A1",
+              "description": "写入起点单元格（A1 记法，如 \"B2\"），默认 \"A1\"。mode=append 时忽略其行号、仅沿用其列。"
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "overwrite",
+                "append"
+              ],
+              "default": "overwrite",
+              "description": "overwrite（默认）：从 start_cell 起写「表头 + 数据」块；append：把数据追加到子表已有数据下方（默认不重复表头）。"
+            },
+            "header": {
+              "type": "boolean",
+              "description": "是否写一行列名表头。省略时按 mode 取默认:overwrite→true、append→false（避免在已有表头下重复）；显式给值可覆盖。"
+            },
+            "allow_overwrite": {
+              "type": "boolean",
+              "default": true,
+              "description": "为 false 时，若写入会落在非空单元格则拒写以保护原数据（返回 partial_success）。默认 true。"
+            },
+            "columns": {
+              "type": "array",
+              "minItems": 1,
+              "description": "列名字符串数组，顺序与 `data` 中每行取值一一对应。同一子表内列名不可重复。",
+              "items": {
+                "type": "string"
+              }
+            },
+            "data": {
+              "type": "array",
+              "description": "数据行；每行是一个数组，长度必须等于 `columns` 数。元素按 `dtypes` 推得的列类型取值（date 列写 ISO yyyy-mm-dd 字符串、number 列写数值、bool 列写布尔、其余写文本），null 表示空单元格。",
+              "items": {
+                "type": "array",
+                "items": {
+                  "type": [
+                    "string",
+                    "number",
+                    "boolean",
+                    "null"
+                  ],
+                  "description": "单元格值：date→ISO yyyy-mm-dd 字符串；number→数值（json.Number 精度保留）；bool→布尔；string→文本；null→空单元格。"
+                }
+              }
+            },
+            "dtypes": {
+              "type": "object",
+              "description": "可选。列名 → pandas dtype 字符串的映射；缺失项默认按 object（string + 文本格式 `@`）处理，所以省略整段时整张表按文本写入（导入 CSV-shaped 数据的最简形态）。dtype 解析规则：`int*` / `uint*` / `Int*` / `UInt*` / `float*` / `Float*` / `complex*` → number（精度保留），`bool` / `boolean` → bool，`datetime64[ns]` / 含时区的 `datetime64[ns, UTC]` 等 → date（默认 `yyyy-mm-dd` 格式），`object` / `string` / `category` / 未识别 → string + 文本格式 `@`（数字样字符串如「00123」不会塌缩成数字）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            "formats": {
+              "type": "object",
+              "description": "可选。列名 → Excel number_format 字符串的映射，覆盖 dtype 自带的默认格式（金额 `#,##0.00`、百分比 `0.0%`、自定义日期 `yyyy-mm` 等）。percent 列的数值尺度由调用方负责（0.0469 配 `0.00%` 显示 4.69%）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      },
+      "styles": {
+        "items": {
+          "properties": {
+            "cell_merges": {
+              "description": "单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all。",
+              "items": {
+                "properties": {
+                  "merge_type": {
+                    "enum": [
+                      "all",
+                      "rows",
+                      "columns"
+                    ],
+                    "type": "string"
+                  },
+                  "range": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "cell_styles": {
+              "description": "单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐。",
+              "items": {
+                "properties": {
+                  "background_color": {
+                    "type": "string"
+                  },
+                  "border_styles": {
+                    "type": "object",
+                    "description": "边框配置，结构同 +cells-set-style --border-styles。",
+                    "properties": {
+                      "bottom": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "left": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "right": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "top": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      }
+                    }
+                  },
+                  "font_color": {
+                    "type": "string"
+                  },
+                  "font_line": {
+                    "enum": [
+                      "none",
+                      "underline",
+                      "line-through"
+                    ],
+                    "type": "string"
+                  },
+                  "font_size": {
+                    "type": "number"
+                  },
+                  "font_style": {
+                    "enum": [
+                      "normal",
+                      "italic"
+                    ],
+                    "type": "string"
+                  },
+                  "font_weight": {
+                    "enum": [
+                      "normal",
+                      "bold"
+                    ],
+                    "type": "string"
+                  },
+                  "horizontal_alignment": {
+                    "enum": [
+                      "left",
+                      "center",
+                      "right"
+                    ],
+                    "type": "string"
+                  },
+                  "number_format": {
+                    "type": "string"
+                  },
+                  "range": {
+                    "description": "A1 单元格范围，必须落在该子表本次写入区域内；例如 A1:B1、B2。",
+                    "type": "string"
+                  },
+                  "vertical_alignment": {
+                    "enum": [
+                      "top",
+                      "middle",
+                      "bottom"
+                    ],
+                    "type": "string"
+                  },
+                  "word_wrap": {
+                    "enum": [
+                      "overflow",
+                      "auto-wrap",
+                      "word-clip"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "col_sizes": {
+              "description": "列宽操作数组；range 使用列范围如 A:C，type 为 pixel/standard，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "name": {
+              "description": "子表名。--sheets 模式下必须与同位置 --sheets.sheets[].name 一致；--values 模式下建议写 Sheet1（其 name 会被忽略）。",
+              "type": "string"
+            },
+            "row_sizes": {
+              "description": "行高操作数组；range 使用行范围如 1:3，type 为 pixel/standard/auto，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard",
+                      "auto"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "name"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
+    },
+    "+workbook-create": {
+      "sheets": {
+        "type": "array",
+        "minItems": 1,
+        "description": "一个或多个子表的 typed 数据，每个数组元素写入一张子表；支持多 DataFrame → 多子表一次写入。整体形状对齐 pandas `df.to_json(orient=\"split\")`：列名走 `columns`、二维取值走 `data`、每列的 pandas dtype 走 `dtypes`、可选的展示格式走 `formats`。一行式用法：`{**json.loads(df.to_json(orient=\"split\")), \"dtypes\": df.dtypes.astype(str).to_dict()}`。",
+        "items": {
+          "type": "object",
+          "required": [
+            "name",
+            "columns",
+            "data"
+          ],
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "目标子表名。按名匹配已有子表；不存在则新建该子表。同一次调用内子表名不可重复。"
+            },
+            "start_cell": {
+              "type": "string",
+              "default": "A1",
+              "description": "写入起点单元格（A1 记法，如 \"B2\"），默认 \"A1\"。mode=append 时忽略其行号、仅沿用其列。"
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "overwrite",
+                "append"
+              ],
+              "default": "overwrite",
+              "description": "overwrite（默认）：从 start_cell 起写「表头 + 数据」块；append：把数据追加到子表已有数据下方（默认不重复表头）。"
+            },
+            "header": {
+              "type": "boolean",
+              "description": "是否写一行列名表头。省略时按 mode 取默认:overwrite→true、append→false（避免在已有表头下重复）；显式给值可覆盖。"
+            },
+            "allow_overwrite": {
+              "type": "boolean",
+              "default": true,
+              "description": "为 false 时，若写入会落在非空单元格则拒写以保护原数据（返回 partial_success）。默认 true。"
+            },
+            "columns": {
+              "type": "array",
+              "minItems": 1,
+              "description": "列名字符串数组，顺序与 `data` 中每行取值一一对应。同一子表内列名不可重复。",
+              "items": {
+                "type": "string"
+              }
+            },
+            "data": {
+              "type": "array",
+              "description": "数据行；每行是一个数组，长度必须等于 `columns` 数。元素按 `dtypes` 推得的列类型取值（date 列写 ISO yyyy-mm-dd 字符串、number 列写数值、bool 列写布尔、其余写文本），null 表示空单元格。",
+              "items": {
+                "type": "array",
+                "items": {
+                  "type": [
+                    "string",
+                    "number",
+                    "boolean",
+                    "null"
+                  ],
+                  "description": "单元格值：date→ISO yyyy-mm-dd 字符串；number→数值（json.Number 精度保留）；bool→布尔；string→文本；null→空单元格。"
+                }
+              }
+            },
+            "dtypes": {
+              "type": "object",
+              "description": "可选。列名 → pandas dtype 字符串的映射；缺失项默认按 object（string + 文本格式 `@`）处理，所以省略整段时整张表按文本写入（导入 CSV-shaped 数据的最简形态）。dtype 解析规则：`int*` / `uint*` / `Int*` / `UInt*` / `float*` / `Float*` / `complex*` → number（精度保留），`bool` / `boolean` → bool，`datetime64[ns]` / 含时区的 `datetime64[ns, UTC]` 等 → date（默认 `yyyy-mm-dd` 格式），`object` / `string` / `category` / 未识别 → string + 文本格式 `@`（数字样字符串如「00123」不会塌缩成数字）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            "formats": {
+              "type": "object",
+              "description": "可选。列名 → Excel number_format 字符串的映射，覆盖 dtype 自带的默认格式（金额 `#,##0.00`、百分比 `0.0%`、自定义日期 `yyyy-mm` 等）。percent 列的数值尺度由调用方负责（0.0469 配 `0.00%` 显示 4.69%）。",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      },
+      "styles": {
+        "items": {
+          "properties": {
+            "cell_merges": {
+              "description": "单元格合并操作数组；range 使用 A1 单元格范围，merge_type 默认 all。",
+              "items": {
+                "properties": {
+                  "merge_type": {
+                    "enum": [
+                      "all",
+                      "rows",
+                      "columns"
+                    ],
+                    "type": "string"
+                  },
+                  "range": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "cell_styles": {
+              "description": "单元格样式操作数组；每项用 A1 单元格 range 指定范围，字段名与 +cells-set-style 对齐。",
+              "items": {
+                "properties": {
+                  "background_color": {
+                    "type": "string"
+                  },
+                  "border_styles": {
+                    "type": "object",
+                    "description": "边框配置，结构同 +cells-set-style --border-styles。",
+                    "properties": {
+                      "bottom": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "left": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "right": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "top": {
+                        "properties": {
+                          "color": {
+                            "description": "边框颜色（十六进制，例如 \"#000000\"）",
+                            "type": "string"
+                          },
+                          "style": {
+                            "description": "边框线型；传 \"none\" 表示清除该方向边框（无边框线）",
+                            "enum": [
+                              "solid",
+                              "dashed",
+                              "dotted",
+                              "double",
+                              "none"
+                            ],
+                            "type": "string"
+                          },
+                          "weight": {
+                            "description": "边框粗细/线宽",
+                            "enum": [
+                              "thin",
+                              "medium",
+                              "thick"
+                            ],
+                            "type": "string"
+                          }
+                        },
+                        "type": "object"
+                      }
+                    }
+                  },
+                  "font_color": {
+                    "type": "string"
+                  },
+                  "font_line": {
+                    "enum": [
+                      "none",
+                      "underline",
+                      "line-through"
+                    ],
+                    "type": "string"
+                  },
+                  "font_size": {
+                    "type": "number"
+                  },
+                  "font_style": {
+                    "enum": [
+                      "normal",
+                      "italic"
+                    ],
+                    "type": "string"
+                  },
+                  "font_weight": {
+                    "enum": [
+                      "normal",
+                      "bold"
+                    ],
+                    "type": "string"
+                  },
+                  "horizontal_alignment": {
+                    "enum": [
+                      "left",
+                      "center",
+                      "right"
+                    ],
+                    "type": "string"
+                  },
+                  "number_format": {
+                    "type": "string"
+                  },
+                  "range": {
+                    "description": "A1 单元格范围，必须落在该子表本次写入区域内；例如 A1:B1、B2。",
+                    "type": "string"
+                  },
+                  "vertical_alignment": {
+                    "enum": [
+                      "top",
+                      "middle",
+                      "bottom"
+                    ],
+                    "type": "string"
+                  },
+                  "word_wrap": {
+                    "enum": [
+                      "overflow",
+                      "auto-wrap",
+                      "word-clip"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "col_sizes": {
+              "description": "列宽操作数组；range 使用列范围如 A:C，type 为 pixel/standard，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            },
+            "name": {
+              "description": "子表名。--sheets 模式下必须与同位置 --sheets.sheets[].name 一致；--values 模式下建议写 Sheet1（其 name 会被忽略）。",
+              "type": "string"
+            },
+            "row_sizes": {
+              "description": "行高操作数组；range 使用行范围如 1:3，type 为 pixel/standard/auto，pixel 需要 size。",
+              "items": {
+                "properties": {
+                  "range": {
+                    "type": "string"
+                  },
+                  "size": {
+                    "type": "number"
+                  },
+                  "type": {
+                    "enum": [
+                      "pixel",
+                      "standard",
+                      "auto"
+                    ],
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "range",
+                  "type"
+                ],
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "name"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
    }
  }
 }
--- a/shortcuts/sheets/execute_paths_test.go
+++ b/shortcuts/sheets/execute_paths_test.go
@@ -63,6 +63,97 @@ func TestExecute_WorkbookInfo_ToolError(t *testing.T) {
 	}
 }

+// TestExecute_WikiURLResolvesToSheet covers the two-step wiki path: a /wiki/
+// URL is resolved via get_node to its spreadsheet obj_token, which then feeds
+// the tool invoke. The tool stub is keyed on the resolved obj_token, so the
+// test would fail if the node_token were used unresolved.
+func TestExecute_WikiURLResolvesToSheet(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{
+					"obj_type":  "sheet",
+					"obj_token": testToken,
+				},
+			},
+		},
+	}
+	tool := toolOutputStub(testToken, "read", `{"sheets":[{"sheet_id":"sh1","title":"Sheet1","index":0}]}`)
+	out, err := runShortcutWithStubs(t, WorkbookInfo,
+		[]string{"--url", "https://example.feishu.cn/wiki/wikTestNODE"}, getNode, tool)
+	if err != nil {
+		t.Fatalf("execute failed: %v\nout=%s", err, out)
+	}
+	data := decodeEnvelopeData(t, out)
+	if sheets, _ := data["sheets"].([]interface{}); len(sheets) != 1 {
+		t.Fatalf("sheets len = %d, want 1; out=%s", len(sheets), out)
+	}
+}
+
+// TestExecute_WikiURLWrongObjType rejects a wiki node that resolves to a
+// non-spreadsheet obj_type before any tool invoke.
+func TestExecute_WikiURLWrongObjType(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{
+					"obj_type":  "docx",
+					"obj_token": "docABC",
+				},
+			},
+		},
+	}
+	out, err := runShortcutWithStubs(t, WorkbookInfo,
+		[]string{"--url", "https://example.feishu.cn/wiki/wikTestNODE"}, getNode)
+	if err == nil {
+		t.Fatalf("want error for non-sheet wiki node; out=%s", out)
+	}
+	if !strings.Contains(err.Error(), "obj_type") {
+		t.Fatalf("error = %v, want mention of obj_type", err)
+	}
+	var ve *errs.ValidationError
+	if !errors.As(err, &ve) {
+		t.Fatalf("wrong-obj_type error = %T, want *errs.ValidationError", err)
+	}
+}
+
+// TestExecute_WikiURLIncompleteNode treats an incomplete get_node response
+// (missing obj_type/obj_token) as an internal/server error, not a user --url
+// validation error.
+func TestExecute_WikiURLIncompleteNode(t *testing.T) {
+	t.Parallel()
+	getNode := &httpmock.Stub{
+		Method: "GET",
+		URL:    "/open-apis/wiki/v2/spaces/get_node",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "success",
+			"data": map[string]interface{}{
+				"node": map[string]interface{}{},
+			},
+		},
+	}
+	_, err := runShortcutWithStubs(t, WorkbookInfo,
+		[]string{"--url", "https://example.feishu.cn/wiki/wikTestNODE"}, getNode)
+	if err == nil {
+		t.Fatal("want error for incomplete get_node node data")
+	}
+	var ve *errs.ValidationError
+	if errors.As(err, &ve) {
+		t.Fatalf("incomplete-data error classified as validation (%v); want internal", err)
+	}
+}
+
 // TestExecute_SheetMove_LookupsIndex covers the two-step path: SheetMove
 // when only --sheet-name is given (and --source-index omitted) first
 // reads the workbook structure to derive sheet_id + source_index, then
@@ -365,14 +456,17 @@ func TestExecute_WorkbookCreate(t *testing.T) {
 			},
 		},
 	}
-	// Initial fill first reads the workbook structure to resolve the default
-	// sheet's id (the create response doesn't echo it), then writes.
+	// The write reads the workbook structure to resolve the default sheet's id
+	// (the create response doesn't echo it). lookupFirstSheetID and
+	// writeTypedSheets' listSheetIDsByName both read it — one reusable stub serves
+	// both. The synthesized sheet is named "Sheet1", matching the default sheet,
+	// so it's adopted in place (no rename).
 	structure := toolOutputStub("shtcnBRAND", "read", `{"sheets":[{"sheet_id":"shtFirst","sheet_name":"Sheet1","index":0}]}`)
+	structure.Reusable = true
 	fill := toolOutputStub("shtcnBRAND", "write", `{"updated_cells":4}`)
 	out, err := runShortcutWithStubs(t, WorkbookCreate, []string{
 		"--title", "Sales",
-		"--headers", `["Name","Score"]`,
-		"--values", `[["alice",95]]`,
+		"--values", `[["Name","Score"],["alice",95]]`,
 	}, create, structure, fill)
 	if err != nil {
 		t.Fatalf("execute failed: %v\nout=%s", err, out)
@@ -382,8 +476,8 @@ func TestExecute_WorkbookCreate(t *testing.T) {
 	if ss["spreadsheet_token"] != "shtcnBRAND" {
 		t.Errorf("spreadsheet_token = %v", ss["spreadsheet_token"])
 	}
-	if data["initial_fill"] == nil {
-		t.Errorf("initial_fill missing in envelope")
+	if sheets, _ := data["sheets"].([]interface{}); len(sheets) != 1 {
+		t.Errorf("sheets summary missing in envelope; got %#v", data["sheets"])
 	}
 	// The fill must target the resolved first sheet, not an empty selector.
 	fillInput := decodeToolInput(t, decodeRawEnvelopeBody(t, fill.CapturedBody), "set_cell_range")
@@ -393,14 +487,13 @@ func TestExecute_WorkbookCreate(t *testing.T) {
 }

 // TestExecute_WorkbookCreate_EmptyArraysSkipFill locks the fix for the nil-map
-// panic / illegal-range bug: --values '[]' or --headers '[]' must short-circuit
-// the initial fill (no structure/fill calls fire) and finish with the
-// spreadsheet created but no initial_fill — never panic on a nil fill map.
+// panic / illegal-range bug: --values '[]' must short-circuit the initial fill
+// (no structure/fill calls fire) and finish with the spreadsheet created but no
+// sheets summary — never panic on a nil payload.
 func TestExecute_WorkbookCreate_EmptyArraysSkipFill(t *testing.T) {
 	t.Parallel()
 	for _, tc := range []struct{ name, flag, val string }{
 		{"empty values", "--values", "[]"},
-		{"empty headers", "--headers", "[]"},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
@@ -421,8 +514,8 @@ func TestExecute_WorkbookCreate_EmptyArraysSkipFill(t *testing.T) {
 				t.Fatalf("execute failed: %v\nout=%s", err, out)
 			}
 			data := decodeEnvelopeData(t, out)
-			if data["initial_fill"] != nil {
-				t.Errorf("initial_fill should be absent for %s %s; got %#v", tc.flag, tc.val, data["initial_fill"])
+			if data["sheets"] != nil {
+				t.Errorf("sheets should be absent for %s %s; got %#v", tc.flag, tc.val, data["sheets"])
 			}
 			if ss, _ := data["spreadsheet"].(map[string]interface{}); ss["spreadsheet_token"] != "shtNEW" {
 				t.Errorf("spreadsheet_token = %v, want shtNEW", ss["spreadsheet_token"])
--- a/shortcuts/sheets/flag_defs.go
+++ b/shortcuts/sheets/flag_defs.go
@@ -80,3 +80,28 @@ func flagsFor(command string) []common.Flag {
 	}
 	return out
 }
+
+// flagAcceptsStdin reports whether the (command, flag) pair declares stdin as
+// an input source in flag-defs.json. Used to decide whether an "invalid JSON"
+// error should also steer the caller toward stdin. It runs on an error path,
+// so it returns false for an unknown command/flag rather than panicking the
+// way flagsFor does.
+func flagAcceptsStdin(command, name string) bool {
+	defs, _ := loadFlagDefs()
+	spec, ok := defs[command]
+	if !ok {
+		return false
+	}
+	for _, df := range spec.Flags {
+		if df.Name != name {
+			continue
+		}
+		for _, in := range df.Input {
+			if in == common.Stdin {
+				return true
+			}
+		}
+		return false
+	}
+	return false
+}
--- a/shortcuts/sheets/flag_defs_gen.go
+++ b/shortcuts/sheets/flag_defs_gen.go
@@ -75,7 +75,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
 			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "A1 range, e.g. `A1:F10` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet)"},
 			{Name: "include", Kind: "own", Type: "string_slice", Required: "optional", Desc: "Comma-separated info categories to include", Enum: []string{"value", "formula", "style", "comment", "data_validation"}},
-			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Safety cap; default 200000", Default: "200000", Hidden: true},
+			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more", Default: "500000"},
 			{Name: "skip-hidden", Kind: "own", Type: "bool", Required: "optional", Desc: "Skip hidden rows and columns; default `false`"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
@@ -305,10 +305,9 @@ var flagDefs = map[string]commandDef{
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
 			{Name: "range", Kind: "own", Type: "string", Required: "required", Desc: "A1 range, e.g. `A1:F30` (no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet)"},
-			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Safety cap; default 200000", Default: "200000", Hidden: true},
+			{Name: "max-chars", Kind: "own", Type: "int", Required: "optional", Desc: "Max output chars per call; default 500000 (safety cap). Large reads are usually better redirected to a file; only lower it (e.g. 25000) when you want results inline without triggering file offload, paging via has_more", Default: "500000"},
 			{Name: "include-row-prefix", Kind: "own", Type: "bool", Required: "optional", Desc: "Whether to prefix each row with `[row=N]`; default `true`", Default: "true"},
 			{Name: "skip-hidden", Kind: "own", Type: "bool", Required: "optional", Desc: "Skip hidden rows and columns; default `false`"},
-			{Name: "rows-json", Kind: "own", Type: "bool", Required: "optional", Desc: "Return structured rows ({row_number, values:{col→cell}}) instead of CSV text; default false", Default: "false"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional", Desc: "Print the request path and parameters without executing"},
 		},
 	},
@@ -320,7 +319,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
 			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
 			{Name: "start-cell", Kind: "own", Type: "string", Required: "required", Desc: "Top-left A1 anchor (e.g. `A1`, `B5`; no sheet prefix — use `--sheet-id` / `--sheet-name` to select the sheet); must be a single cell, range notation not accepted; the bottom-right is inferred from CSV row/column counts", Default: "A1"},
-			{Name: "csv", Kind: "own", Type: "string", Required: "required", Desc: "RFC 4180 CSV text; plain values only (no formulas / styles / comments)", Input: []string{"file", "stdin"}},
+			{Name: "csv", Kind: "own", Type: "string", Required: "required", Desc: "RFC 4180 CSV text; values or formulas (a leading = is evaluated as a formula); no styles / comments / images (use +cells-set for those).", Input: []string{"file", "stdin"}},
 			{Name: "allow-overwrite", Kind: "own", Type: "bool", Required: "optional", Desc: "Allow overwriting (default true); set false to error if any target cell is non-empty", Default: "true"},
 			{Name: "range", Kind: "own", Type: "string", Required: "optional", Desc: "alias for --start-cell (parity with +csv-get / +cells-set, which locate with --range); a range like A1:H17 collapses to its top-left cell", Hidden: true},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
@@ -766,7 +765,7 @@ var flagDefs = map[string]commandDef{
 			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
 			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
 			{Name: "title", Kind: "own", Type: "string", Required: "required", Desc: "New sheet title"},
-			{Name: "index", Kind: "own", Type: "int", Required: "optional", Desc: "Insert position; appended to the end when omitted", Default: "-1"},
+			{Name: "index", Kind: "own", Type: "int", Required: "optional", Desc: "Insert position (0-based); appended to the end when omitted", Default: "-1"},
 			{Name: "row-count", Kind: "own", Type: "int", Required: "optional", Desc: "Initial row count (default 200, max 50000)", Default: "200"},
 			{Name: "col-count", Kind: "own", Type: "int", Required: "optional", Desc: "Initial column count (default 20, max 200)", Default: "20"},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
@@ -793,6 +792,16 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+sheet-hide-gridline": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
+			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
+			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
 	"+sheet-info": {
 		Risk: "read",
 		Flags: []flagDef{
@@ -839,6 +848,16 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+sheet-show-gridline": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
+			{Name: "sheet-id", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet reference_id (XOR with `--sheet-name`)"},
+			{Name: "sheet-name", Kind: "public", Type: "string", Required: "xor", Desc: "Sheet name (XOR with `--sheet-id`)"},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
 	"+sheet-unhide": {
 		Risk: "write",
 		Flags: []flagDef{
@@ -895,13 +914,39 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+table-get": {
+		Risk: "read",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token (XOR with `--url`)"},
+			{Name: "sheet-id", Kind: "own", Type: "string", Required: "optional", Desc: "Read only this sheet (by id); omit to read all sheets"},
+			{Name: "sheet-name", Kind: "own", Type: "string", Required: "optional", Desc: "Read only this sheet (by name); omit to read all sheets"},
+			{Name: "range", Kind: "own", Type: "string", Required: "optional", Desc: "A1 range to read; omit to read each sheet's full used range (spans internal blank rows/columns, not just the A1 current region)"},
+			{Name: "no-header", Kind: "own", Type: "bool", Required: "optional", Desc: "Treat the first row as data instead of a header (columns get positional names col1, col2, ...)"},
+			{Name: "dataframe-out", Kind: "own", Type: "string", Required: "optional", Desc: "Write the typed table as one Arrow IPC file (Feather v2) instead of the default JSON. Pass `@<path>` for a file or `-` for binary stdout (same convention as other binary I/O flags). Mirror of the input-side `--dataframe` on `+table-put` / `+workbook-create` — pandas users round-trip via `df = pd.read_feather(\"x.arrow\")` or `pd.read_feather(io.BytesIO(stdout))`. Single-sheet only: requires `--sheet-id` or `--sheet-name`; whole-workbook reads keep the default JSON path. Column types come from the typed read-back (string/number/date/bool); per-column `number_format` is preserved as Arrow field metadata so the Arrow file can round-trip straight back through `+table-put --dataframe`."},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
+	"+table-put": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "url", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet URL to write into (XOR with `--spreadsheet-token`)"},
+			{Name: "spreadsheet-token", Kind: "public", Type: "string", Required: "xor", Desc: "Spreadsheet token to write into (XOR with `--url`)"},
+			{Name: "sheets", Kind: "own", Type: "string", Required: "xor", Desc: "Typed table payload (pandas-DataFrame-shaped) as JSON, XOR with `--dataframe`: a top-level `sheets` array, each item `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}`. Agents typically build it with `{**json.loads(df.to_json(orient=\"split\")), \"dtypes\": df.dtypes.astype(str).to_dict()}`. `dtypes` values are pandas dtype strings (`int64`, `float64`, `Int64`, `bool`, `boolean`, `datetime64[ns]`, `object`, ...); the writer maps them to internal string/number/date/bool — omit `dtypes` and a column writes as text (good for raw CSV-shaped data). `formats[col]` is an Excel number_format string (e.g. `#,##0.00`, `0.0%`, `yyyy-mm`); when absent, date columns default to `yyyy-mm-dd` and string columns to text format (`@`).", Input: []string{"file", "stdin"}},
+			{Name: "dataframe", Kind: "own", Type: "string", Required: "xor", Desc: "Single-sheet typed table from one Arrow IPC file (a.k.a. Feather v2 — what `pandas.DataFrame.to_feather()` writes), XOR with `--sheets`. Pass `@<path>` for a file or `-` for binary stdin (same convention as other input flags). Arrow bytes are read raw — no TrimSpace / BOM strip — so the IPC magic survives intact (unlike text input flags). Column types come from the Arrow schema (int*/uint*/float* → number, date32/date64/timestamp → date, utf8/large_utf8 → string, bool → bool); per-column `number_format` may be set via Arrow field metadata (`pa.field(\"price\", pa.float64(), metadata={b\"number_format\": b\"$#,##0.00\"})`). Writes the sheet at default placement: name `Sheet1` (created when absent), overwrite from A1 with header. For a different sheet name, anchor, mode, or to write multiple sheets, use `--sheets` instead."},
+			{Name: "styles", Kind: "own", Type: "string", Required: "optional", Desc: "Visual operations applied after the typed write, as JSON: top-level `{styles:[...]}`. Each item corresponds to one written sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. The styles array length/order/name must match the written sheets: with --sheets, match --sheets.sheets; with --dataframe (single sheet named Sheet1), pass exactly one styles item with name `Sheet1`.", Input: []string{"file", "stdin"}},
+			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
+		},
+	},
 	"+workbook-create": {
 		Risk: "write",
 		Flags: []flagDef{
 			{Name: "title", Kind: "own", Type: "string", Required: "required", Desc: "Spreadsheet title"},
 			{Name: "folder-token", Kind: "own", Type: "string", Required: "optional", Desc: "Target folder token; placed at the drive root when omitted"},
-			{Name: "headers", Kind: "own", Type: "string", Required: "optional", Desc: "Header row as a JSON array: `[\"Col A\",\"Col B\"]`", Input: []string{"file", "stdin"}},
-			{Name: "values", Kind: "own", Type: "string", Required: "optional", Desc: "Initial data as a 2D JSON array: `[[\"alice\",95]]`", Input: []string{"file", "stdin"}},
+			{Name: "values", Kind: "own", Type: "string", Required: "optional", Desc: "Untyped initial data as one 2D JSON array (`[[\"alice\",95]]`); values are written as-is with their type auto-detected, through the same batched set_cell_range path as --sheets — pair with --styles for number formats, colors, merges, and row/col sizes", Input: []string{"file", "stdin"}},
+			{Name: "sheets", Kind: "own", Type: "string", Required: "optional", Desc: "Typed table payload as JSON (same shape as `+table-put`): a top-level `sheets` array, each item `{name, start_cell?, mode?, header?, allow_overwrite?, columns:[\"colA\",\"colB\",...], data:[[...]], dtypes?:{colA:pandasDtype, ...}, formats?:{colA:numberFormat, ...}}`. Agents typically build it from a DataFrame via `{**json.loads(df.to_json(orient=\"split\")), \"dtypes\": df.dtypes.astype(str).to_dict()}`. Mutually exclusive with --values and --dataframe. Creates the workbook, then writes typed type-faithful data (dates land as real dates, numbers keep precision).", Input: []string{"file", "stdin"}},
+			{Name: "styles", Kind: "own", Type: "string", Required: "optional", Desc: "Initial visual operations as JSON: top-level `{styles:[...]}`. Each item corresponds to one target sheet and must include `name`, plus at least one of `cell_styles` / `row_sizes` / `col_sizes` / `cell_merges`. `cell_styles` entries use +cells-set-style fields with a cell range; row/col sizes use dimension ranges plus type/size; merges use cell ranges plus optional merge_type. With --sheets, styles array length/order/name must match --sheets.sheets. With --values, pass exactly one styles item for the initial sheet (its name is ignored).", Input: []string{"file", "stdin"}},
+			{Name: "dataframe", Kind: "own", Type: "string", Required: "optional", Desc: "Single-sheet typed table from one Arrow IPC file (Feather v2 — what `pandas.DataFrame.to_feather()` writes), mutually exclusive with --values and --sheets. Pass `@<path>` for a file or `-` for binary stdin (same convention as other input flags). Arrow bytes are read raw — no TrimSpace / BOM strip — so the IPC magic survives intact (unlike text input flags). Column types come from the Arrow schema; per-column `number_format` may be set via Arrow field metadata. Creates the workbook and fills its default sheet (`Sheet1` — adopted in place, no empty Sheet1 left behind). For multi-sheet or non-default placement, use `--sheets` instead."},
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
@@ -916,6 +961,14 @@ var flagDefs = map[string]commandDef{
 			{Name: "dry-run", Kind: "system", Type: "bool", Required: "optional"},
 		},
 	},
+	"+workbook-import": {
+		Risk: "write",
+		Flags: []flagDef{
+			{Name: "file", Kind: "own", Type: "string", Required: "required", Desc: "Local file path (.xlsx / .xls / .csv)"},
+			{Name: "folder-token", Kind: "own", Type: "string", Required: "optional", Desc: "Target folder token; imported to the cloud drive root when omitted"},
+			{Name: "name", Kind: "own", Type: "string", Required: "optional", Desc: "Imported spreadsheet name; defaults to the local file name without its extension"},
+		},
+	},
 	"+workbook-info": {
 		Risk: "read",
 		Flags: []flagDef{
--- a/shortcuts/sheets/flag_defs_test.go
+++ b/shortcuts/sheets/flag_defs_test.go
@@ -65,9 +65,9 @@ func TestFlagsFor_MapsAllFields(t *testing.T) {
 	if url == nil || url.Required {
 		t.Errorf("+sheet-create --url should not be cobra-required: %+v", url)
 	}
-	// hidden + int default
+	// visible + int default
 	cap := byName("+cells-get", "max-chars")
-	if cap == nil || !cap.Hidden || cap.Default != "200000" {
+	if cap == nil || cap.Hidden || cap.Default != "500000" {
 		t.Errorf("+cells-get --max-chars not mapped: %+v", cap)
 	}
 	// input sources
@@ -140,3 +140,24 @@ func TestFlagsFor_EveryRegisteredCommandHasDefs(t *testing.T) {
 		}
 	}
 }
+
+// TestFlagAcceptsStdin verifies the stdin-capability probe that decides whether
+// an "invalid JSON" error should also steer the caller toward stdin: a composite
+// flag (cells) accepts stdin, a plain locator (spreadsheet-token) does not, and
+// an unknown command/flag returns false without panicking (it runs on an error
+// path, unlike flagsFor).
+func TestFlagAcceptsStdin(t *testing.T) {
+	t.Parallel()
+	if !flagAcceptsStdin("+cells-set", "cells") {
+		t.Error("+cells-set --cells should accept stdin")
+	}
+	if flagAcceptsStdin("+cells-set", "spreadsheet-token") {
+		t.Error("--spreadsheet-token should not accept stdin")
+	}
+	if flagAcceptsStdin("+nope", "cells") {
+		t.Error("unknown command should be false (and must not panic)")
+	}
+	if flagAcceptsStdin("+cells-set", "nope") {
+		t.Error("unknown flag should be false")
+	}
+}
--- a/shortcuts/sheets/flag_schema_validate.go
+++ b/shortcuts/sheets/flag_schema_validate.go
@@ -63,6 +63,7 @@ func validateParsedJSONFlag(fv flagView, name string, value interface{}) error {
 var parseJSONFlagSkip = map[string]struct{}{
 	"properties": {},
 	"operations": {},
+	"styles":     {},
 }

 // validateValueAgainstSchema is the (command, flag) → schema → check
@@ -93,7 +94,17 @@ func validateValueAgainstSchema(fv flagView, name string, value interface{}) err
 	var schema schemaProperty
 	json.Unmarshal(raw, &schema)
 	if vErr := validateAgainstSchema(value, &schema, ""); vErr != nil {
-		return sheetsValidationForFlag(name, "--%s: %s", name, vErr.Error())
+		// Composite-JSON shape errors (e.g. +cells-set --cells, chart
+		// --properties) are the highest-frequency usage-layer failure for
+		// sheets, and agents often burn several retries guessing the shape.
+		// Point them straight at --print-schema, which dumps the exact JSON
+		// Schema for this (command, flag) pair. The hint is always actionable:
+		// reaching this branch means entry[name] resolved a schema from the
+		// embedded index, and --print-schema reads that same index, so the
+		// suggested command is guaranteed to print it.
+		return sheetsValidationForFlag(name,
+			"--%s: %s; run `lark-cli sheets %s --print-schema --flag-name %s` to see the expected JSON Schema",
+			name, vErr.Error(), command, name)
 	}
 	return nil
 }
--- a/shortcuts/sheets/flag_schema_validate_test.go
+++ b/shortcuts/sheets/flag_schema_validate_test.go
@@ -587,3 +587,27 @@ func TestValidateInputAgainstSchema_SkipOperations(t *testing.T) {
 		t.Errorf("operations should be skipped; got %v", err)
 	}
 }
+
+// TestValidateValueAgainstSchema_PrintSchemaHint pins the highest-value
+// recovery affordance for composite-JSON flags: when the shape is wrong, the
+// error must point the agent straight at --print-schema (with the right
+// command + flag) instead of leaving it to guess across retries. +cells-set
+// --cells expects a 2-D array; a bare string trips the top-level type check.
+func TestValidateValueAgainstSchema_PrintSchemaHint(t *testing.T) {
+	t.Parallel()
+	fv := mapFlagView{command: "+cells-set"}
+	err := validateValueAgainstSchema(fv, "cells", "not-an-array")
+	if err == nil {
+		t.Fatal("expected schema validation error for wrong --cells shape")
+	}
+	msg := err.Error()
+	// Underlying shape error is preserved (substring callers still match).
+	if !strings.Contains(msg, `expected type "array"`) {
+		t.Errorf("want underlying shape error preserved; got %q", msg)
+	}
+	// And the actionable --print-schema hint is appended with the exact
+	// command + flag, so a copy-paste fetches the schema for this pair.
+	if !strings.Contains(msg, "lark-cli sheets +cells-set --print-schema --flag-name cells") {
+		t.Errorf("want --print-schema hint with command+flag; got %q", msg)
+	}
+}
--- a/shortcuts/sheets/flag_schemas_gen.go
+++ b/shortcuts/sheets/flag_schemas_gen.go
@@ -32,4 +32,6 @@ var commandsWithSchema = map[string]struct{}{
 	"+range-sort":            {},
 	"+sparkline-create":      {},
 	"+sparkline-update":      {},
+	"+table-put":             {},
+	"+workbook-create":       {},
 }
--- a/shortcuts/sheets/helpers.go
+++ b/shortcuts/sheets/helpers.go
@@ -10,6 +10,8 @@ package sheets
 import (
 	"context"
 	"encoding/json"
+	"fmt"
+	neturl "net/url"
 	"strings"

 	"github.com/larksuite/cli/errs"
@@ -48,46 +50,151 @@ func sheetsInputStatError(flag string, err error) error {
 	return wrapped
 }

-// resolveSpreadsheetToken applies the public --url / --spreadsheet-token XOR
-// pair shared by every sheets canonical shortcut and returns the resolved
-// token. Network-free, safe to call from Validate and DryRun.
-func resolveSpreadsheetToken(runtime *common.RuntimeContext) (string, error) {
+// spreadsheetRef classification: a --url / --spreadsheet-token input names a
+// spreadsheet either directly (a /sheets/ URL or raw token) or indirectly via a
+// wiki node that must be resolved to its backing spreadsheet at Execute time.
+const (
+	spreadsheetRefSheet = "sheet"
+	spreadsheetRefWiki  = "wiki"
+)
+
+// spreadsheetRef is a parsed --url / --spreadsheet-token input. A wiki ref holds
+// the still-unresolved wiki node_token; resolveSpreadsheetTokenExec turns it
+// into the real spreadsheet token at Execute time.
+type spreadsheetRef struct {
+	Kind  string // spreadsheetRefSheet | spreadsheetRefWiki
+	Token string
+}
+
+// parseSpreadsheetRef applies the public --url / --spreadsheet-token XOR pair and
+// classifies the input. Network-free, safe to call from Validate and DryRun.
+//
+// Recognized --url shapes:
+//   - https://.../sheets/<token>        → {sheet, token}
+//   - https://.../spreadsheets/<token>  → {sheet, token}
+//   - https://.../wiki/<node_token>     → {wiki, node_token}  (resolved at Execute)
+//
+// A raw --spreadsheet-token is always treated as a spreadsheet token; wiki nodes
+// only ever arrive as a /wiki/ URL.
+func parseSpreadsheetRef(runtime *common.RuntimeContext) (spreadsheetRef, error) {
 	if err := common.ExactlyOneTyped(runtime, "url", "spreadsheet-token"); err != nil {
-		return "", err
+		return spreadsheetRef{}, err
 	}
 	if token := strings.TrimSpace(runtime.Str("spreadsheet-token")); token != "" {
 		if err := validate.RejectControlChars(token, "spreadsheet-token"); err != nil {
-			return "", sheetsValidationCauseForFlag("spreadsheet-token", err)
+			return spreadsheetRef{}, sheetsValidationCauseForFlag("spreadsheet-token", err)
 		}
-		return token, nil
+		return spreadsheetRef{Kind: spreadsheetRefSheet, Token: token}, nil
 	}

-	url := strings.TrimSpace(runtime.Str("url"))
-	token := extractSpreadsheetToken(url)
-	if token == "" || token == url {
-		return "", sheetsValidationForFlag("url", "--url must be a spreadsheet URL like https://.../sheets/<token>")
+	rawURL := strings.TrimSpace(runtime.Str("url"))
+	token, kind, ok := spreadsheetURLToken(rawURL)
+	if !ok {
+		return spreadsheetRef{}, sheetsValidationForFlag("url", "--url must be a spreadsheet URL like https://.../sheets/<token> or a wiki URL like https://.../wiki/<token>")
 	}
 	if err := validate.RejectControlChars(token, "url"); err != nil {
-		return "", sheetsValidationCauseForFlag("url", err)
+		return spreadsheetRef{}, sheetsValidationCauseForFlag("url", err)
 	}
-	return token, nil
+	return spreadsheetRef{Kind: kind, Token: token}, nil
 }

-// extractSpreadsheetToken pulls the token segment out of a /sheets/<token>
-// or /spreadsheets/<token> URL. Returns the input unchanged when no known
-// prefix is present (callers must check token != originalInput).
-func extractSpreadsheetToken(input string) string {
-	input = strings.TrimSpace(input)
-	for _, prefix := range []string{"/sheets/", "/spreadsheets/"} {
-		if idx := strings.Index(input, prefix); idx >= 0 {
-			token := input[idx+len(prefix):]
-			if idx2 := strings.IndexAny(token, "/?#"); idx2 >= 0 {
-				token = token[:idx2]
-			}
-			return token
+// spreadsheetURLToken extracts the token and its kind from a Lark URL, matching
+// only on the URL *path* segment (parsed via net/url). A /wiki/ or /sheets/ that
+// appears only in the query or fragment (e.g. a redirect or anchor param) never
+// hijacks classification. Returns ok=false when no known prefix heads the path.
+func spreadsheetURLToken(rawURL string) (token, kind string, ok bool) {
+	u, err := neturl.Parse(rawURL)
+	if err != nil || u.Path == "" {
+		return "", "", false
+	}
+	for _, m := range []struct {
+		prefix string
+		kind   string
+	}{
+		{"/sheets/", spreadsheetRefSheet},
+		{"/spreadsheets/", spreadsheetRefSheet},
+		{"/wiki/", spreadsheetRefWiki},
+	} {
+		if seg, found := pathSegmentAfter(u.Path, m.prefix); found {
+			return seg, m.kind, true
 		}
 	}
-	return input
+	return "", "", false
+}
+
+// pathSegmentAfter returns the first path segment after prefix when path begins
+// with prefix, else ("", false).
+func pathSegmentAfter(path, prefix string) (string, bool) {
+	if !strings.HasPrefix(path, prefix) {
+		return "", false
+	}
+	rest := path[len(prefix):]
+	if i := strings.IndexByte(rest, '/'); i >= 0 {
+		rest = rest[:i]
+	}
+	rest = strings.TrimSpace(rest)
+	if rest == "" {
+		return "", false
+	}
+	return rest, true
+}
+
+// resolveSpreadsheetToken applies the public --url / --spreadsheet-token XOR pair
+// and returns the resolved token. Network-free, safe to call from Validate and
+// DryRun.
+//
+// A /wiki/ URL yields the still-unresolved wiki node_token: turning it into the
+// backing spreadsheet token needs a get_node call, which only Execute may make.
+// Validate/DryRun only need a non-empty, control-char-clean token, so the
+// node_token passes through unchanged here; Execute paths call
+// resolveSpreadsheetTokenExec instead.
+func resolveSpreadsheetToken(runtime *common.RuntimeContext) (string, error) {
+	ref, err := parseSpreadsheetRef(runtime)
+	if err != nil {
+		return "", err
+	}
+	return ref.Token, nil
+}
+
+// resolveSpreadsheetTokenExec is the Execute-time counterpart of
+// resolveSpreadsheetToken: it additionally resolves a /wiki/ URL's node_token to
+// the backing spreadsheet token via wiki get_node, verifying obj_type=sheet.
+// Non-wiki inputs make no API call. Use this from every sheets Execute hook and
+// keep resolveSpreadsheetToken in Validate/DryRun so those stay network-free.
+func resolveSpreadsheetTokenExec(runtime *common.RuntimeContext) (string, error) {
+	ref, err := parseSpreadsheetRef(runtime)
+	if err != nil {
+		return "", err
+	}
+	if ref.Kind != spreadsheetRefWiki {
+		return ref.Token, nil
+	}
+	return resolveWikiNodeToSpreadsheetToken(runtime, ref.Token)
+}
+
+// resolveWikiNodeToSpreadsheetToken resolves a wiki node_token to the spreadsheet
+// obj_token it points at, erroring when the node is not a spreadsheet. The
+// wiki:node:read scope is only needed on this path, so it is enforced here rather
+// than declared unconditionally on every sheets shortcut.
+func resolveWikiNodeToSpreadsheetToken(runtime *common.RuntimeContext, nodeToken string) (string, error) {
+	if err := runtime.EnsureScopes([]string{"wiki:node:read"}); err != nil {
+		return "", err
+	}
+	data, err := runtime.CallAPITyped("GET", "/open-apis/wiki/v2/spaces/get_node",
+		map[string]interface{}{"token": nodeToken}, nil)
+	if err != nil {
+		return "", err
+	}
+	node := common.GetMap(data, "node")
+	objType := common.GetString(node, "obj_type")
+	objToken := common.GetString(node, "obj_token")
+	if objType == "" || objToken == "" {
+		return "", errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki get_node returned incomplete node data for %q", nodeToken)
+	}
+	if objType != "sheet" {
+		return "", sheetsValidationForFlag("url", "wiki URL resolves to obj_type=%q, but a spreadsheet (obj_type=sheet) is required", objType)
+	}
+	return objToken, nil
 }

 // resolveSheetSelector validates the --sheet-id / --sheet-name XOR and
@@ -241,6 +348,16 @@ func parseJSONFlag(runtime flagView, name string) (interface{}, error) {
 	}
 	var out interface{}
 	if err := json.Unmarshal([]byte(raw), &out); err != nil {
+		// Composite payloads that embed formulas / quotes / commas are the
+		// classic source of this error: inlined into the shell, the JSON gets
+		// mangled (e.g. `\$` → "invalid character in string escape"). For any
+		// flag that accepts stdin, steer the caller there — passing the payload
+		// via `--<flag> - < file` sidesteps shell escaping entirely.
+		if flagAcceptsStdin(runtime.Command(), name) {
+			return nil, sheetsValidationForFlag(name,
+				"--%s: invalid JSON: %v; if the payload contains formulas / quotes / commas, pass it via stdin (`--%s - < file`) so the shell doesn't mangle the JSON",
+				name, err, name).WithCause(err)
+		}
 		return nil, sheetsValidationForFlag(name, "--%s: invalid JSON: %v", name, err).WithCause(err)
 	}
 	// Schema-driven flag validation at the user-input boundary. Skips
@@ -325,6 +442,72 @@ func buildCellStyleFromFlags(runtime flagView) map[string]interface{} {
 	return style
 }

+// cellStyleAliases maps shorthand cell_styles field names that models commonly
+// hallucinate (Excel / openpyxl / CSS conventions) onto the canonical field
+// names the backend expects. Only the unambiguous alignment shorthands are
+// aliased — they are the high-frequency miss; ambiguous guesses (e.g. "color",
+// "bg_color", "text_align") are intentionally left out so a wrong guess still
+// surfaces as an error rather than being silently reinterpreted.
+var cellStyleAliases = []struct{ alias, canonical string }{
+	{"horizontal_align", "horizontal_alignment"},
+	{"halign", "horizontal_alignment"},
+	{"vertical_align", "vertical_alignment"},
+	{"valign", "vertical_alignment"},
+}
+
+// normalizeCellStyleAliases renames known shorthand keys in a single
+// cell_styles map to their canonical equivalents, in place, so a model that
+// writes e.g. "horizontal_align" instead of "horizontal_alignment" still
+// applies the style instead of hitting an "unsupported field" error (--styles)
+// or having the field silently dropped by the backend (typed --cells). If both
+// the shorthand and its canonical key are present it returns a validation error
+// rather than picking one. path labels the map for the error message.
+func normalizeCellStyleAliases(style map[string]interface{}, path string) error {
+	if len(style) == 0 {
+		return nil
+	}
+	for _, a := range cellStyleAliases {
+		v, ok := style[a.alias]
+		if !ok {
+			continue
+		}
+		if _, exists := style[a.canonical]; exists {
+			return common.ValidationErrorf("%s.%s conflicts with %s; pass only %s", path, a.alias, a.canonical, a.canonical)
+		}
+		style[a.canonical] = v
+		delete(style, a.alias)
+	}
+	return nil
+}
+
+// normalizeTypedCellsStyleAliases walks a typed --cells 2D array and applies
+// normalizeCellStyleAliases to every cell's inline cell_styles object, so the
+// alignment shorthands are accepted on +cells-set the same as on --styles.
+// Structure is checked leniently to match the pass-through contract: any
+// element that isn't the expected shape is skipped, not rejected.
+func normalizeTypedCellsStyleAliases(cells []interface{}, path string) error {
+	for r, rowRaw := range cells {
+		row, ok := rowRaw.([]interface{})
+		if !ok {
+			continue
+		}
+		for c, cellRaw := range row {
+			cell, ok := cellRaw.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			st, ok := cell["cell_styles"].(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if err := normalizeCellStyleAliases(st, fmt.Sprintf("%s[%d][%d].cell_styles", path, r, c)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // borderStylesFromFlag parses --border-styles as a JSON object (top/bottom/
 // left/right with style sub-objects). Returns nil when the flag is empty.
 func borderStylesFromFlag(runtime flagView) (map[string]interface{}, error) {
--- a/shortcuts/sheets/helpers_test.go
+++ b/shortcuts/sheets/helpers_test.go
@@ -268,3 +268,53 @@ const (
 	testSheetID  = "shtSubA"
 	testSheetID2 = "shtSubB"
 )
+
+// TestParseSpreadsheetRef locks the network-free classification of
+// --url / --spreadsheet-token into a sheet token vs an (unresolved) wiki
+// node_token. The wiki node is resolved later, at Execute time only.
+func TestParseSpreadsheetRef(t *testing.T) {
+	t.Parallel()
+	mk := func(url, tok string) *common.RuntimeContext {
+		cmd := &cobra.Command{Use: "sheets"}
+		cmd.Flags().String("url", url, "")
+		cmd.Flags().String("spreadsheet-token", tok, "")
+		return common.TestNewRuntimeContext(cmd, testConfig(t))
+	}
+	cases := []struct {
+		name      string
+		url       string
+		tok       string
+		wantKind  string
+		wantToken string
+		wantErr   bool
+	}{
+		{name: "sheets url", url: "https://x.feishu.cn/sheets/shtABC", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "spreadsheets url", url: "https://x.feishu.cn/spreadsheets/shtABC", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "wiki url", url: "https://x.feishu.cn/wiki/wikDEF", wantKind: spreadsheetRefWiki, wantToken: "wikDEF"},
+		{name: "wiki url with query", url: "https://x.feishu.cn/wiki/wikDEF?sheet=xxxxxx", wantKind: spreadsheetRefWiki, wantToken: "wikDEF"},
+		{name: "raw token", tok: "shtRAW", wantKind: spreadsheetRefSheet, wantToken: "shtRAW"},
+		{name: "sheets url with /wiki/ in query stays sheet", url: "https://x.feishu.cn/sheets/shtABC?from=/wiki/wikX", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "sheets url with /wiki/ in fragment stays sheet", url: "https://x.feishu.cn/sheets/shtABC#/wiki/wikX", wantKind: spreadsheetRefSheet, wantToken: "shtABC"},
+		{name: "docx url unsupported", url: "https://x.feishu.cn/docx/docABC", wantErr: true},
+		{name: "neither provided", wantErr: true},
+	}
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			ref, err := parseSpreadsheetRef(mk(tc.url, tc.tok))
+			if tc.wantErr {
+				if err == nil {
+					t.Fatalf("want error, got ref=%+v", ref)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if ref.Kind != tc.wantKind || ref.Token != tc.wantToken {
+				t.Fatalf("ref = %+v, want {Kind:%s Token:%s}", ref, tc.wantKind, tc.wantToken)
+			}
+		})
+	}
+}
--- a/shortcuts/sheets/lark_sheet_batch_update.go
+++ b/shortcuts/sheets/lark_sheet_batch_update.go
@@ -67,7 +67,7 @@ var BatchUpdate = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -180,7 +180,7 @@ var CellsBatchSetStyle = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -270,7 +270,7 @@ var CellsBatchClear = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -350,7 +350,7 @@ var DropdownUpdate = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -396,7 +396,7 @@ var DropdownDelete = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "batch_update", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
--- a/shortcuts/sheets/lark_sheet_dataframe.go
+++ b/shortcuts/sheets/lark_sheet_dataframe.go
@@ -0,0 +1,554 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/apache/arrow/go/v17/arrow"
+	"github.com/apache/arrow/go/v17/arrow/array"
+	"github.com/apache/arrow/go/v17/arrow/ipc"
+	"github.com/apache/arrow/go/v17/arrow/memory"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/extension/fileio"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+// ─── --dataframe (Arrow IPC / Feather v2 binary input) ────────────────
+//
+// --dataframe is the binary-typed twin of --sheets. The wire payload is one
+// Arrow IPC file (a.k.a. Feather v2 — what `pandas.DataFrame.to_feather()`
+// writes), single schema, optionally multi-batch. Type / format are read off
+// the Arrow schema (no separate dtypes/formats maps), and per-column number
+// format can be set via the field's `number_format` metadata key:
+//
+//	pa.field("price", pa.float64(), metadata={b"number_format": b"$#,##0.00"})
+//
+// One DataFrame writes into one sub-sheet at fixed defaults: name `Sheet1`
+// (adopted in place by +workbook-create; created when absent by +table-put),
+// overwrite from A1 with header on, allow_overwrite=true. The shortcut
+// surface is deliberately the one flag — anything that needs a different
+// sheet name / anchor / mode / multi-sheet falls back to --sheets, whose
+// JSON payload already carries every knob.
+//
+// Binary IO note: --dataframe bypasses the text-oriented Input resolver
+// (`runtime.Str("dataframe")` carries a *path*, not file contents). Reading
+// the Arrow bytes through that resolver would TrimSpace the trailing IPC
+// magic / corrupt non-UTF8 bytes. Path → FileIO.Open → io.ReadAll keeps the
+// stream byte-exact. "-" reads from stdin directly.
+
+// dataframeDefaultSheetName is the sub-sheet name --dataframe writes into.
+// Matches valuesSheetName so +workbook-create adopts the brand-new
+// workbook's default sheet in place (no stray empty Sheet1 left behind);
+// +table-put creates Sheet1 if it doesn't already exist.
+const dataframeDefaultSheetName = valuesSheetName
+
+// parseDataframePayload reads the --dataframe path (Arrow IPC file) and
+// composes a single-sheet tablePayload at the fixed default placement.
+// Network-free: safe from Validate and DryRun. The resulting tableSheetSpec
+// rides the same buildSheetMatrix / buildTypedCell path as a --sheets entry,
+// so downstream is unaware of where the rows came from.
+func parseDataframePayload(rctx *common.RuntimeContext) (*tablePayload, error) {
+	raw := strings.TrimSpace(rctx.Str("dataframe"))
+	if raw == "" {
+		return nil, common.ValidationErrorf("--dataframe is required")
+	}
+	data, err := readDataframeBytes(rctx, raw)
+	if err != nil {
+		return nil, err
+	}
+	spec, err := decodeArrowToSheet(data, dataframeDefaultSheetName)
+	if err != nil {
+		return nil, common.ValidationErrorf("--dataframe: %v", err)
+	}
+	payload := &tablePayload{Sheets: []tableSheetSpec{spec}}
+	if err := payload.validate(); err != nil {
+		return nil, err
+	}
+	return payload, nil
+}
+
+// dataframeStdinCache holds the bytes read from stdin on the first call so a
+// later call (Validate → Execute / DryRun) gets the same bytes instead of an
+// empty stream — stdin is single-shot, but parseDataframePayload runs
+// multiple times per command invocation. Process-wide is fine: lark-cli is
+// one-shot (one command per process). Tests reset by setting it back to nil.
+var dataframeStdinCache []byte
+
+// readDataframeBytes resolves --dataframe to raw binary. A literal `@` prefix
+// is tolerated for symmetry with --sheets (`@/tmp/x.arrow` and `/tmp/x.arrow`
+// both work). `-` reads stdin verbatim — cached on first call so Validate /
+// Execute / DryRun all see the same bytes. Bytes are returned untouched: no
+// TrimSpace, no BOM strip — both would corrupt an Arrow IPC stream.
+func readDataframeBytes(rctx *common.RuntimeContext, raw string) ([]byte, error) {
+	if raw == "-" {
+		if dataframeStdinCache != nil {
+			return dataframeStdinCache, nil
+		}
+		io := rctx.IO()
+		if io == nil || io.In == nil {
+			return nil, common.ValidationErrorf("--dataframe: stdin is not available")
+		}
+		data, err := readAllBytes(io.In)
+		if err != nil {
+			return nil, common.ValidationErrorf("--dataframe: read stdin: %v", err)
+		}
+		if len(data) == 0 {
+			return nil, common.ValidationErrorf("--dataframe: stdin is empty")
+		}
+		dataframeStdinCache = data
+		return data, nil
+	}
+	path := strings.TrimPrefix(raw, "@")
+	data, err := cmdutil.ReadInputFile(rctx.FileIO(), path)
+	if err != nil {
+		return nil, common.ValidationErrorf("--dataframe: %v", err)
+	}
+	if len(data) == 0 {
+		return nil, common.ValidationErrorf("--dataframe: file %q is empty", path)
+	}
+	return data, nil
+}
+
+// readAllBytes is a thin wrapper so tests can fake the io.Reader without
+// importing io. Mirrors io.ReadAll exactly.
+func readAllBytes(r io.Reader) ([]byte, error) { return io.ReadAll(r) }
+
+// decodeArrowToSheet reads `data` as an Arrow IPC file (single schema,
+// possibly multi-batch) and produces a tableSheetSpec with name + columns +
+// rows filled in. Sheet placement (start_cell / mode / header / overwrite) is
+// not touched here — parseDataframePayload layers those on from CLI flags.
+func decodeArrowToSheet(data []byte, sheetName string) (tableSheetSpec, error) {
+	reader, err := ipc.NewFileReader(bytes.NewReader(data))
+	if err != nil {
+		return tableSheetSpec{}, fmt.Errorf("invalid Arrow IPC file (expected pandas df.to_feather output): %v", err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	defer reader.Close()
+
+	schema := reader.Schema()
+	if schema == nil || schema.NumFields() == 0 {
+		return tableSheetSpec{}, fmt.Errorf("Arrow schema has no fields") //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+
+	ncols := schema.NumFields()
+	cols := make([]tableColumnSpec, ncols)
+	seen := make(map[string]bool, ncols)
+	for i := 0; i < ncols; i++ {
+		f := schema.Field(i)
+		name := f.Name
+		if strings.TrimSpace(name) == "" {
+			return tableSheetSpec{}, fmt.Errorf("column %d has empty name", i) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		if seen[name] {
+			return tableSheetSpec{}, fmt.Errorf("duplicate column name %q", name) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		seen[name] = true
+		typ, format, err := arrowFieldToTypeFormat(f)
+		if err != nil {
+			return tableSheetSpec{}, fmt.Errorf("column %q: %v", name, err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		cols[i] = tableColumnSpec{Name: name, Type: typ, Format: format}
+	}
+
+	var rows [][]interface{}
+	for b := 0; b < reader.NumRecords(); b++ {
+		rec, err := reader.RecordAt(b)
+		if err != nil {
+			return tableSheetSpec{}, fmt.Errorf("read record batch %d: %v", b, err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		batchRows, err := arrowRecordToRows(rec, cols)
+		rec.Release()
+		if err != nil {
+			return tableSheetSpec{}, err
+		}
+		rows = append(rows, batchRows...)
+	}
+
+	return tableSheetSpec{Name: sheetName, Columns: cols, Rows: rows}, nil
+}
+
+// arrowFieldToTypeFormat maps an Arrow field to the internal (type, format)
+// pair. The field's `number_format` metadata key — when present — sets the
+// Excel number_format string verbatim; otherwise sensible defaults are
+// applied per type (`@` text for strings, `yyyy-mm-dd` for dates).
+func arrowFieldToTypeFormat(f arrow.Field) (typ, format string, err error) {
+	if v, ok := f.Metadata.GetValue("number_format"); ok {
+		format = strings.TrimSpace(v)
+	}
+	switch f.Type.(type) {
+	case *arrow.StringType, *arrow.LargeStringType:
+		if format == "" {
+			format = "@"
+		}
+		return "string", format, nil
+	case *arrow.BooleanType:
+		return "bool", format, nil
+	case *arrow.Date32Type, *arrow.Date64Type, *arrow.TimestampType:
+		if format == "" {
+			format = "yyyy-mm-dd"
+		}
+		return "date", format, nil
+	}
+	if isArrowNumericType(f.Type) {
+		return "number", format, nil
+	}
+	return "", "", fmt.Errorf("unsupported Arrow type %s (want string/number/date/bool)", f.Type.Name()) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+}
+
+func isArrowNumericType(t arrow.DataType) bool {
+	switch t.ID() {
+	case arrow.INT8, arrow.INT16, arrow.INT32, arrow.INT64,
+		arrow.UINT8, arrow.UINT16, arrow.UINT32, arrow.UINT64,
+		arrow.FLOAT16, arrow.FLOAT32, arrow.FLOAT64:
+		return true
+	}
+	return false
+}
+
+// arrowRecordToRows transposes one column-batch into row-major
+// [][]interface{} matched to `cols`. Cells are stamped with the same value
+// shapes buildTypedCell expects from the JSON path: nil for nulls,
+// json.Number for numerics (precision-preserving), `yyyy-mm-dd` strings for
+// dates/timestamps, bool for booleans, string for strings.
+func arrowRecordToRows(rec arrow.Record, cols []tableColumnSpec) ([][]interface{}, error) {
+	if int(rec.NumCols()) != len(cols) {
+		return nil, fmt.Errorf("record has %d cols, schema declared %d", rec.NumCols(), len(cols)) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	nrows := int(rec.NumRows())
+	rows := make([][]interface{}, nrows)
+	for r := range rows {
+		rows[r] = make([]interface{}, len(cols))
+	}
+	for c := range cols {
+		arr := rec.Column(c)
+		for r := 0; r < nrows; r++ {
+			if arr.IsNull(r) {
+				continue
+			}
+			v, err := arrowCellValue(arr, r)
+			if err != nil {
+				return nil, fmt.Errorf("row %d column %q: %v", r, cols[c].Name, err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+			}
+			rows[r][c] = v
+		}
+	}
+	return rows, nil
+}
+
+func arrowCellValue(arr arrow.Array, i int) (interface{}, error) {
+	switch a := arr.(type) {
+	case *array.String:
+		return a.Value(i), nil
+	case *array.LargeString:
+		return a.Value(i), nil
+	case *array.Boolean:
+		return a.Value(i), nil
+	case *array.Int8:
+		return json.Number(strconv.FormatInt(int64(a.Value(i)), 10)), nil
+	case *array.Int16:
+		return json.Number(strconv.FormatInt(int64(a.Value(i)), 10)), nil
+	case *array.Int32:
+		return json.Number(strconv.FormatInt(int64(a.Value(i)), 10)), nil
+	case *array.Int64:
+		return json.Number(strconv.FormatInt(a.Value(i), 10)), nil
+	case *array.Uint8:
+		return json.Number(strconv.FormatUint(uint64(a.Value(i)), 10)), nil
+	case *array.Uint16:
+		return json.Number(strconv.FormatUint(uint64(a.Value(i)), 10)), nil
+	case *array.Uint32:
+		return json.Number(strconv.FormatUint(uint64(a.Value(i)), 10)), nil
+	case *array.Uint64:
+		return json.Number(strconv.FormatUint(a.Value(i), 10)), nil
+	case *array.Float16:
+		return json.Number(strconv.FormatFloat(float64(a.Value(i).Float32()), 'f', -1, 32)), nil
+	case *array.Float32:
+		return json.Number(strconv.FormatFloat(float64(a.Value(i)), 'f', -1, 32)), nil
+	case *array.Float64:
+		return json.Number(strconv.FormatFloat(a.Value(i), 'f', -1, 64)), nil
+	case *array.Date32:
+		// Date32: days since 1970-01-01 (epoch). Multiply to seconds, format
+		// in UTC so timezone offset can't flip the calendar date.
+		t := time.Unix(int64(a.Value(i))*86400, 0).UTC()
+		return t.Format("2006-01-02"), nil
+	case *array.Date64:
+		t := time.UnixMilli(int64(a.Value(i))).UTC()
+		return t.Format("2006-01-02"), nil
+	case *array.Timestamp:
+		ts := int64(a.Value(i))
+		unit := a.DataType().(*arrow.TimestampType).Unit
+		var t time.Time
+		switch unit {
+		case arrow.Second:
+			t = time.Unix(ts, 0).UTC()
+		case arrow.Millisecond:
+			t = time.UnixMilli(ts).UTC()
+		case arrow.Microsecond:
+			t = time.UnixMicro(ts).UTC()
+		case arrow.Nanosecond:
+			t = time.Unix(0, ts).UTC()
+		default:
+			return nil, fmt.Errorf("unsupported timestamp unit %v", unit) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		return t.Format("2006-01-02"), nil
+	}
+	return nil, fmt.Errorf("unsupported Arrow array %T", arr) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+}
+
+// ─── --dataframe-out (Arrow IPC binary output, mirror of --dataframe) ──
+//
+// +table-get's binary read-back: encode one sheet's typed read-back as an
+// Arrow IPC file (Feather v2), so pandas can `pd.read_feather(path)` /
+// `pd.read_feather(BytesIO(stdout))` symmetrically with the put side.
+// Single-sheet only — Arrow IPC carries one schema per file. The JSON path
+// is unchanged; --dataframe-out swaps the encoder for callers that already
+// have pandas / pyarrow in their pipeline.
+
+// encodeSheetMapToArrowIPC turns one readSheetAsSpec output into an Arrow IPC
+// file blob. Internal column types are recovered from `dtypes` (the wire
+// proxy for the typed protocol), and per-column `number_format` rides through
+// as Arrow field metadata so the file feeds straight back into
+// `+table-put --dataframe`.
+func encodeSheetMapToArrowIPC(sheet map[string]interface{}) ([]byte, error) {
+	columns, _ := sheet["columns"].([]interface{})
+	if len(columns) == 0 {
+		return nil, fmt.Errorf("sheet has no columns") //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	dtypes, _ := sheet["dtypes"].(map[string]interface{})
+	formats, _ := sheet["formats"].(map[string]interface{})
+	// `data` arrives as either []interface{} (when the sheet came through a
+	// JSON round-trip / unit-test fixture) or [][]interface{} (the shape
+	// readSheetAsSpec directly emits in production). Accept both — anything
+	// else falls through to a zero-row table.
+	var rawData [][]interface{}
+	switch d := sheet["data"].(type) {
+	case [][]interface{}:
+		rawData = d
+	case []interface{}:
+		rawData = make([][]interface{}, len(d))
+		for i, r := range d {
+			rawData[i], _ = r.([]interface{})
+		}
+	}
+
+	ncols := len(columns)
+	colNames := make([]string, ncols)
+	colTypes := make([]string, ncols)
+	fields := make([]arrow.Field, ncols)
+	for i, c := range columns {
+		name, _ := c.(string)
+		if name == "" {
+			return nil, fmt.Errorf("column %d has empty name", i) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		colNames[i] = name
+		dt, _ := dtypes[name].(string)
+		colTypes[i] = dtypeToInternalType(dt)
+		var meta arrow.Metadata
+		if formats != nil {
+			if nf, ok := formats[name].(string); ok && strings.TrimSpace(nf) != "" {
+				meta = arrow.NewMetadata([]string{"number_format"}, []string{nf})
+			}
+		}
+		fields[i] = arrow.Field{
+			Name:     name,
+			Type:     internalTypeToArrowType(colTypes[i]),
+			Nullable: true,
+			Metadata: meta,
+		}
+	}
+	schema := arrow.NewSchema(fields, nil)
+
+	mem := memory.NewGoAllocator()
+	rb := array.NewRecordBuilder(mem, schema)
+	defer rb.Release()
+	for r, row := range rawData {
+		if len(row) != ncols {
+			return nil, fmt.Errorf("row %d has %d cells, want %d", r, len(row), ncols) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		for c := 0; c < ncols; c++ {
+			if err := appendArrowCell(rb.Field(c), colTypes[c], row[c]); err != nil {
+				return nil, fmt.Errorf("row %d column %q: %v", r, colNames[c], err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+			}
+		}
+	}
+	rec := rb.NewRecord()
+	defer rec.Release()
+
+	var buf bytesWriterSeeker
+	w, err := ipc.NewFileWriter(&buf, ipc.WithSchema(schema), ipc.WithAllocator(mem))
+	if err != nil {
+		return nil, fmt.Errorf("ipc.NewFileWriter: %v", err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	if err := w.Write(rec); err != nil {
+		return nil, fmt.Errorf("write record: %v", err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	if err := w.Close(); err != nil {
+		return nil, fmt.Errorf("close writer: %v", err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	return buf.buf, nil
+}
+
+// dtypeToInternalType inverts typeToDtype so the Arrow encoder can pick an
+// internal column type from the wire-level dtype string. Unknown / object
+// falls back to string (lossless: every cell is already typed as such).
+func dtypeToInternalType(dtype string) string {
+	switch strings.ToLower(strings.TrimSpace(dtype)) {
+	case "float64", "float32", "int64", "int32", "int16", "int8",
+		"uint64", "uint32", "uint16", "uint8":
+		return "number"
+	case "bool", "boolean":
+		return "bool"
+	}
+	if strings.HasPrefix(strings.ToLower(dtype), "datetime") {
+		return "date"
+	}
+	return "string"
+}
+
+// internalTypeToArrowType is the put-side dtypeToTypeFormat dual: maps the
+// internal column type to the Arrow data type the encoder builds a column
+// with. Numbers go to float64 because +table-get can't tell int from float
+// from a number_format alone — float64 covers both losslessly for the cell
+// ranges Lark Sheets accepts.
+func internalTypeToArrowType(typ string) arrow.DataType {
+	switch typ {
+	case "number":
+		return arrow.PrimitiveTypes.Float64
+	case "date":
+		return arrow.FixedWidthTypes.Date32
+	case "bool":
+		return arrow.FixedWidthTypes.Boolean
+	}
+	return arrow.BinaryTypes.String
+}
+
+// appendArrowCell stamps one cell into its column builder. Cell shape matches
+// what cellToTyped emits on the JSON path: json.Number for numbers, ISO
+// `yyyy-mm-dd` string for dates, plain string for strings, bool for bools,
+// nil for empty. Anything off-shape errors so the caller doesn't silently
+// emit nulls for malformed data.
+func appendArrowCell(b array.Builder, typ string, v interface{}) error {
+	if v == nil {
+		b.AppendNull()
+		return nil
+	}
+	switch typ {
+	case "string":
+		s, ok := v.(string)
+		if !ok {
+			return fmt.Errorf("string expects string value, got %T", v) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		b.(*array.StringBuilder).Append(s)
+	case "number":
+		f, err := arrowNumber(v)
+		if err != nil {
+			return err
+		}
+		b.(*array.Float64Builder).Append(f)
+	case "date":
+		s, ok := v.(string)
+		if !ok {
+			return fmt.Errorf("date expects ISO yyyy-mm-dd string, got %T", v) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		t, err := time.Parse("2006-01-02", strings.TrimSpace(s))
+		if err != nil {
+			return fmt.Errorf("date parse %q: %v", s, err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		b.(*array.Date32Builder).Append(arrow.Date32FromTime(t))
+	case "bool":
+		bb, ok := v.(bool)
+		if !ok {
+			return fmt.Errorf("bool expects bool, got %T", v) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		b.(*array.BooleanBuilder).Append(bb)
+	default:
+		return fmt.Errorf("unsupported internal type %q", typ) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	return nil
+}
+
+// arrowNumber converts the number cell shape readSheetAsSpec emits
+// (json.Number) plus the float fallback to float64 for the Arrow builder.
+func arrowNumber(v interface{}) (float64, error) {
+	switch n := v.(type) {
+	case json.Number:
+		f, err := n.Float64()
+		if err != nil {
+			return 0, fmt.Errorf("number parse %q: %v", n.String(), err) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+		}
+		return f, nil
+	case float64:
+		return n, nil
+	}
+	return 0, fmt.Errorf("number expects numeric value, got %T", v) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+}
+
+// bytesWriterSeeker is a 10-line in-memory io.WriteSeeker for
+// ipc.NewFileWriter, which seeks back to patch a footer offset. Using a
+// buffer (instead of a temp file or os.Stdout, which isn't seekable) keeps
+// --dataframe-out's stdout path zero-IO and stays straightforward.
+type bytesWriterSeeker struct {
+	buf []byte
+	pos int64
+}
+
+func (w *bytesWriterSeeker) Write(p []byte) (int, error) {
+	end := w.pos + int64(len(p))
+	if end > int64(len(w.buf)) {
+		w.buf = append(w.buf, make([]byte, end-int64(len(w.buf)))...)
+	}
+	n := copy(w.buf[w.pos:], p)
+	w.pos = end
+	return n, nil
+}
+
+func (w *bytesWriterSeeker) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	case io.SeekStart:
+		w.pos = offset
+	case io.SeekCurrent:
+		w.pos += offset
+	case io.SeekEnd:
+		w.pos = int64(len(w.buf)) + offset
+	default:
+		return 0, fmt.Errorf("unknown whence %d", whence) //nolint:forbidigo // intermediate error; the command layer wraps it into a typed --dataframe/--dataframe-out validation error
+	}
+	return w.pos, nil
+}
+
+// writeDataframeOut dispatches the encoded Arrow bytes to wherever --dataframe-out
+// points: `-` → process stdout, `@<path>` or plain path → local file. Symmetric
+// with readDataframeBytes on the input side: same `@` tolerance, same TrimPrefix
+// semantics, and an absolute path will still get rejected by FileIO's SafePath.
+func writeDataframeOut(rctx *common.RuntimeContext, raw string, data []byte) error {
+	if raw == "-" {
+		out := rctx.IO()
+		if out == nil || out.Out == nil {
+			return common.ValidationErrorf("--dataframe-out: stdout is not available")
+		}
+		if _, err := out.Out.Write(data); err != nil {
+			return errs.NewInternalError(errs.SubtypeFileIO, "--dataframe-out: write stdout").WithCause(err)
+		}
+		return nil
+	}
+	path := strings.TrimPrefix(raw, "@")
+	fio := rctx.FileIO()
+	if fio == nil {
+		return common.ValidationErrorf("--dataframe-out: file output is not available in this context")
+	}
+	// FileIO.Save validates the path via SafeOutputPath (the same sandbox
+	// readDataframeBytes hits on the input side) and writes atomically, so we
+	// don't need an extra ValidatePath call here.
+	if _, err := fio.Save(path, fileio.SaveOptions{ContentLength: int64(len(data))}, bytes.NewReader(data)); err != nil {
+		return errs.NewInternalError(errs.SubtypeFileIO, "--dataframe-out: write %q", path).WithCause(err)
+	}
+	return nil
+}
--- a/shortcuts/sheets/lark_sheet_dataframe_test.go
+++ b/shortcuts/sheets/lark_sheet_dataframe_test.go
@@ -0,0 +1,378 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/apache/arrow/go/v17/arrow"
+	"github.com/apache/arrow/go/v17/arrow/array"
+	"github.com/apache/arrow/go/v17/arrow/ipc"
+	"github.com/apache/arrow/go/v17/arrow/memory"
+)
+
+// buildArrowIPC writes one record into a Feather v2 (Arrow IPC file) blob.
+// Used by the round-trip tests below to stand in for what
+// `pandas.DataFrame.to_feather(path)` would produce; saves the tests from
+// depending on a pandas-shaped fixture file.
+//
+// ipc.NewFileWriter wants an io.WriteSeeker (it back-patches a footer
+// offset), so we write to a temp file and read the bytes back — simpler than
+// re-implementing a seekable in-memory buffer.
+func buildArrowIPC(t *testing.T, schema *arrow.Schema, build func(b *array.RecordBuilder)) []byte {
+	t.Helper()
+	mem := memory.NewGoAllocator()
+	rb := array.NewRecordBuilder(mem, schema)
+	defer rb.Release()
+	build(rb)
+	rec := rb.NewRecord()
+	defer rec.Release()
+
+	path := filepath.Join(t.TempDir(), "df.arrow")
+	f, err := os.Create(path)
+	if err != nil {
+		t.Fatalf("create temp arrow file: %v", err)
+	}
+	w, err := ipc.NewFileWriter(f, ipc.WithSchema(schema), ipc.WithAllocator(mem))
+	if err != nil {
+		f.Close()
+		t.Fatalf("ipc.NewFileWriter: %v", err)
+	}
+	if err := w.Write(rec); err != nil {
+		t.Fatalf("write record: %v", err)
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("close writer: %v", err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatalf("close file: %v", err)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read temp arrow file: %v", err)
+	}
+	return data
+}
+
+// TestDataframe_RoundTripCoreTypes pins down the Arrow-schema → internal
+// (type, format) mapping and the per-cell value shape that buildTypedCell
+// expects: number cells are json.Number (precision-preserving), date cells
+// are `yyyy-mm-dd` strings, bool/string come through verbatim. Numbers, dates,
+// strings, bools, and nulls all in one record so a future Arrow-Go bump can't
+// quietly regress any one family.
+func TestDataframe_RoundTripCoreTypes(t *testing.T) {
+	t.Parallel()
+
+	schema := arrow.NewSchema([]arrow.Field{
+		{Name: "name", Type: arrow.BinaryTypes.String},
+		{Name: "qty", Type: arrow.PrimitiveTypes.Int64},
+		{Name: "price", Type: arrow.PrimitiveTypes.Float64, Metadata: arrow.NewMetadata(
+			[]string{"number_format"}, []string{"$#,##0.00"},
+		)},
+		{Name: "active", Type: arrow.FixedWidthTypes.Boolean},
+		{Name: "shipped_on", Type: arrow.FixedWidthTypes.Date32},
+	}, nil)
+
+	jan15 := arrow.Date32FromTime(time.Date(2024, 1, 15, 0, 0, 0, 0, time.UTC))
+	feb02 := arrow.Date32FromTime(time.Date(2024, 2, 2, 0, 0, 0, 0, time.UTC))
+
+	buf := buildArrowIPC(t, schema, func(b *array.RecordBuilder) {
+		b.Field(0).(*array.StringBuilder).AppendValues([]string{"alice", ""}, []bool{true, false})
+		b.Field(1).(*array.Int64Builder).AppendValues([]int64{42, 0}, []bool{true, false})
+		b.Field(2).(*array.Float64Builder).AppendValues([]float64{19.95, 0}, []bool{true, false})
+		b.Field(3).(*array.BooleanBuilder).AppendValues([]bool{true, false}, []bool{true, true})
+		b.Field(4).(*array.Date32Builder).AppendValues([]arrow.Date32{jan15, feb02}, []bool{true, true})
+	})
+
+	spec, err := decodeArrowToSheet(buf, "S1")
+	if err != nil {
+		t.Fatalf("decodeArrowToSheet: %v", err)
+	}
+	if spec.Name != "S1" {
+		t.Errorf("sheet name = %q, want S1", spec.Name)
+	}
+	if len(spec.Columns) != 5 {
+		t.Fatalf("got %d columns, want 5", len(spec.Columns))
+	}
+	want := []struct{ typ, format string }{
+		{"string", "@"},
+		{"number", ""},
+		{"number", "$#,##0.00"},
+		{"bool", ""},
+		{"date", "yyyy-mm-dd"},
+	}
+	for i, w := range want {
+		if spec.Columns[i].Type != w.typ {
+			t.Errorf("columns[%d].Type = %q, want %q", i, spec.Columns[i].Type, w.typ)
+		}
+		if spec.Columns[i].Format != w.format {
+			t.Errorf("columns[%d].Format = %q, want %q", i, spec.Columns[i].Format, w.format)
+		}
+	}
+
+	if len(spec.Rows) != 2 {
+		t.Fatalf("got %d rows, want 2", len(spec.Rows))
+	}
+	// Row 0: every field present, types match what buildTypedCell will accept.
+	row0 := spec.Rows[0]
+	if row0[0] != "alice" {
+		t.Errorf("row0[name] = %#v, want \"alice\"", row0[0])
+	}
+	if n, ok := row0[1].(json.Number); !ok || n.String() != "42" {
+		t.Errorf("row0[qty] = %#v, want json.Number(\"42\")", row0[1])
+	}
+	if n, ok := row0[2].(json.Number); !ok || n.String() != "19.95" {
+		t.Errorf("row0[price] = %#v, want json.Number(\"19.95\")", row0[2])
+	}
+	if row0[3] != true {
+		t.Errorf("row0[active] = %#v, want true", row0[3])
+	}
+	if row0[4] != "2024-01-15" {
+		t.Errorf("row0[shipped_on] = %#v, want \"2024-01-15\"", row0[4])
+	}
+
+	// Row 1: nulls on name/qty/price (despite the buffer values) must become nil
+	// so buildTypedCell paints an empty cell that still carries number_format.
+	row1 := spec.Rows[1]
+	for _, c := range []int{0, 1, 2} {
+		if row1[c] != nil {
+			t.Errorf("row1[%d] = %#v, want nil (null in arrow)", c, row1[c])
+		}
+	}
+	if row1[3] != false {
+		t.Errorf("row1[active] = %#v, want false", row1[3])
+	}
+	if row1[4] != "2024-02-02" {
+		t.Errorf("row1[shipped_on] = %#v, want \"2024-02-02\"", row1[4])
+	}
+}
+
+// TestDataframe_Timestamp pins the timestamp → date conversion for the
+// timestamp[us] case (pandas default for `pd.Timestamp` columns once written
+// via `to_feather`). Only the calendar date matters for our `yyyy-mm-dd`
+// landing — guard against TZ drift from the wrong unit pick.
+func TestDataframe_Timestamp(t *testing.T) {
+	t.Parallel()
+	schema := arrow.NewSchema([]arrow.Field{
+		{Name: "ts", Type: &arrow.TimestampType{Unit: arrow.Microsecond}},
+	}, nil)
+	ts := arrow.Timestamp(time.Date(2024, 6, 12, 14, 30, 0, 0, time.UTC).UnixMicro())
+	buf := buildArrowIPC(t, schema, func(b *array.RecordBuilder) {
+		b.Field(0).(*array.TimestampBuilder).AppendValues([]arrow.Timestamp{ts}, []bool{true})
+	})
+	spec, err := decodeArrowToSheet(buf, "S")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if spec.Columns[0].Type != "date" {
+		t.Errorf("type = %q, want date", spec.Columns[0].Type)
+	}
+	if got := spec.Rows[0][0]; got != "2024-06-12" {
+		t.Errorf("ts = %#v, want \"2024-06-12\"", got)
+	}
+}
+
+// TestDataframe_EmptySchema rejects an Arrow file whose schema has no fields:
+// a 0-column "DataFrame" would write a header-less, data-less block that
+// validates as "writer ran successfully" but produces nothing — the test ties
+// that off as an explicit error rather than letting it slip through.
+func TestDataframe_EmptySchema(t *testing.T) {
+	t.Parallel()
+	schema := arrow.NewSchema(nil, nil)
+	buf := buildArrowIPC(t, schema, func(b *array.RecordBuilder) {})
+	_, err := decodeArrowToSheet(buf, "S")
+	if err == nil || !strings.Contains(err.Error(), "no fields") {
+		t.Errorf("err = %v, want 'no fields' error", err)
+	}
+}
+
+// TestDataframe_DuplicateColumn catches duplicate-name columns at decode
+// time. Validate already rejects duplicate column names for the JSON path;
+// the Arrow path mirrors that so the error surfaces with the same shape.
+func TestDataframe_DuplicateColumn(t *testing.T) {
+	t.Parallel()
+	schema := arrow.NewSchema([]arrow.Field{
+		{Name: "x", Type: arrow.BinaryTypes.String},
+		{Name: "x", Type: arrow.PrimitiveTypes.Int64},
+	}, nil)
+	buf := buildArrowIPC(t, schema, func(b *array.RecordBuilder) {
+		b.Field(0).(*array.StringBuilder).Append("")
+		b.Field(1).(*array.Int64Builder).Append(0)
+	})
+	_, err := decodeArrowToSheet(buf, "S")
+	if err == nil || !strings.Contains(err.Error(), "duplicate") {
+		t.Errorf("err = %v, want duplicate-column error", err)
+	}
+}
+
+// TestDataframe_BadBytes rejects a non-Arrow blob with a hint pointing at
+// pandas df.to_feather so users see what producer is expected without having
+// to grep the docs.
+func TestDataframe_BadBytes(t *testing.T) {
+	t.Parallel()
+	_, err := decodeArrowToSheet([]byte("not arrow"), "S")
+	if err == nil || !strings.Contains(err.Error(), "Arrow") {
+		t.Errorf("err = %v, want Arrow-decode error", err)
+	}
+}
+
+// TestDataframe_EncodeRoundTrip checks --dataframe-out's encoder against its
+// own decoder: build a +table-get-shaped sheet map (the same one
+// readSheetAsSpec emits), encode to Arrow IPC, decode back via the put-side
+// decoder, and require the column types / formats / row values to match. If
+// any encoder choice drifts from what the decoder expects, the round-trip
+// breaks here long before a real put → get round-trip in production would.
+func TestDataframe_EncodeRoundTrip(t *testing.T) {
+	t.Parallel()
+	sheet := map[string]interface{}{
+		"name":    "S1",
+		"columns": []interface{}{"name", "qty", "price", "active", "ts"},
+		"dtypes": map[string]interface{}{
+			"name":   "object",
+			"qty":    "float64",
+			"price":  "float64",
+			"active": "bool",
+			"ts":     "datetime64[ns]",
+		},
+		"formats": map[string]interface{}{
+			// `@` is the writer convention for string columns; readSheetAsSpec
+			// strips it via isTextNumberFormat, so an Arrow file built from a
+			// real read won't carry @ either. Keep it absent here to mirror
+			// the production wire shape.
+			"price": "$#,##0.00",
+		},
+		"data": []interface{}{
+			[]interface{}{"alice", json.Number("42"), json.Number("19.95"), true, "2024-01-15"},
+			[]interface{}{"bob", nil, json.Number("8.5"), false, "2024-02-02"},
+		},
+	}
+	blob, err := encodeSheetMapToArrowIPC(sheet)
+	if err != nil {
+		t.Fatalf("encodeSheetMapToArrowIPC: %v", err)
+	}
+	spec, err := decodeArrowToSheet(blob, "S1")
+	if err != nil {
+		t.Fatalf("decodeArrowToSheet: %v", err)
+	}
+	wantTypes := []string{"string", "number", "number", "bool", "date"}
+	wantFormats := []string{"@", "", "$#,##0.00", "", "yyyy-mm-dd"}
+	if len(spec.Columns) != len(wantTypes) {
+		t.Fatalf("got %d columns, want %d", len(spec.Columns), len(wantTypes))
+	}
+	for i, w := range wantTypes {
+		if spec.Columns[i].Type != w {
+			t.Errorf("columns[%d].Type = %q, want %q", i, spec.Columns[i].Type, w)
+		}
+		if spec.Columns[i].Format != wantFormats[i] {
+			t.Errorf("columns[%d].Format = %q, want %q", i, spec.Columns[i].Format, wantFormats[i])
+		}
+	}
+	if len(spec.Rows) != 2 {
+		t.Fatalf("got %d rows, want 2", len(spec.Rows))
+	}
+	if spec.Rows[0][0] != "alice" {
+		t.Errorf("row0[name] = %#v, want alice", spec.Rows[0][0])
+	}
+	if n, ok := spec.Rows[0][1].(json.Number); !ok || n.String() != "42" {
+		t.Errorf("row0[qty] = %#v, want json.Number(\"42\")", spec.Rows[0][1])
+	}
+	if spec.Rows[0][3] != true {
+		t.Errorf("row0[active] = %#v, want true", spec.Rows[0][3])
+	}
+	if spec.Rows[0][4] != "2024-01-15" {
+		t.Errorf("row0[ts] = %#v, want 2024-01-15", spec.Rows[0][4])
+	}
+	// qty is null on row1, must come back as nil (not a zero-valued
+	// json.Number that would later round-trip as 0).
+	if spec.Rows[1][1] != nil {
+		t.Errorf("row1[qty] = %#v, want nil (null arrow cell)", spec.Rows[1][1])
+	}
+}
+
+// TestDataframe_EncodeAcceptsBothRowShapes pins the encoder against the two
+// shapes `sheet["data"]` actually arrives in: `[][]interface{}` from a live
+// readSheetAsSpec call (production), and `[]interface{}` from a JSON
+// unmarshal (round-trip / fixtures). Either must produce non-empty Arrow
+// output — early on the production shape silently fell through the
+// `[]interface{}` type assertion and we shipped a 0-row Arrow blob.
+func TestDataframe_EncodeAcceptsBothRowShapes(t *testing.T) {
+	t.Parallel()
+	base := func(data interface{}) map[string]interface{} {
+		return map[string]interface{}{
+			"name":    "S",
+			"columns": []interface{}{"city"},
+			"dtypes":  map[string]interface{}{"city": "object"},
+			"data":    data,
+		}
+	}
+	for label, data := range map[string]interface{}{
+		"production [][]interface{}": [][]interface{}{{"BJ"}, {"SH"}},
+		"unmarshal []interface{}":    []interface{}{[]interface{}{"BJ"}, []interface{}{"SH"}},
+	} {
+		blob, err := encodeSheetMapToArrowIPC(base(data))
+		if err != nil {
+			t.Errorf("%s: encode: %v", label, err)
+			continue
+		}
+		spec, err := decodeArrowToSheet(blob, "S")
+		if err != nil {
+			t.Errorf("%s: decode: %v", label, err)
+			continue
+		}
+		if len(spec.Rows) != 2 {
+			t.Errorf("%s: got %d rows, want 2", label, len(spec.Rows))
+		}
+	}
+}
+
+// TestDataframe_DtypeToInternalType pins the inverse of typeToDtype so
+// readSheetAsSpec's dtype labels recover the right internal type. Covers the
+// dtype families +table-get emits today plus the safe fallback for unknown
+// labels (string, lossless).
+func TestDataframe_DtypeToInternalType(t *testing.T) {
+	t.Parallel()
+	cases := map[string]string{
+		"float64":         "number",
+		"int64":           "number",
+		"Int64":           "number",
+		"bool":            "bool",
+		"boolean":         "bool",
+		"datetime64[ns]":  "date",
+		"datetime64[ms]":  "date",
+		"object":          "string",
+		"":                "string",
+		"weird-new-dtype": "string",
+	}
+	for in, want := range cases {
+		if got := dtypeToInternalType(in); got != want {
+			t.Errorf("dtypeToInternalType(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// TestDataframe_BytesWriterSeeker confirms the in-memory WriteSeeker handles
+// the Seek-and-overwrite pattern ipc.NewFileWriter uses to patch the footer
+// offset: write some bytes, seek back to the middle, overwrite, end up with
+// the buffer reflecting the overwritten bytes (not a tail-extended duplicate).
+func TestDataframe_BytesWriterSeeker(t *testing.T) {
+	t.Parallel()
+	var w bytesWriterSeeker
+	if _, err := w.Write([]byte("hello world")); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := w.Seek(6, 0); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := w.Write([]byte("WORLD")); err != nil {
+		t.Fatal(err)
+	}
+	if got := string(w.buf); got != "hello WORLD" {
+		t.Errorf("buf = %q, want \"hello WORLD\"", got)
+	}
+}
--- a/shortcuts/sheets/lark_sheet_object_crud.go
+++ b/shortcuts/sheets/lark_sheet_object_crud.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	"sort"
 	"strings"

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

 import (
+	"encoding/json"
+	"sort"
 	"strings"
 	"testing"

@@ -137,25 +139,24 @@ func TestObjectCRUDShortcuts_DryRun(t *testing.T) {
 		// covered separately in the +pivot-create empty-selector / mutex
 		// tests below.
 		{
-			name: "+pivot-create with placement / source / range flags",
+			name: "+pivot-create with placement / source / target-position flags",
 			sc:   PivotCreate,
 			args: []string{
 				"--url", testURL, "--target-sheet-id", testSheetID,
 				"--properties", `{"rows":[{"field":"A"}]}`,
 				"--source", "Sheet1!A1:F1000",
-				"--range", "F1",
 				"--target-position", "B5",
 			},
 			toolName: "manage_pivot_table_object",
 			wantInput: map[string]interface{}{
-				"excel_id":        testToken,
-				"sheet_id":        testSheetID,
-				"operation":       "create",
-				"target_position": "B5",
+				"excel_id":  testToken,
+				"sheet_id":  testSheetID,
+				"operation": "create",
 				"properties": map[string]interface{}{
 					"rows":   []interface{}{map[string]interface{}{"field": "A"}},
 					"source": "Sheet1!A1:F1000",
-					"range":  "F1",
+					// --target-position 映射到 properties.range。
+					"range": "B5",
 				},
 			},
 		},
@@ -202,7 +203,7 @@ func TestObjectCRUDShortcuts_DryRun(t *testing.T) {
 			args: []string{
 				"--url", testURL, "--sheet-id", testSheetID,
 				"--rule-id", "ruleA",
-				"--properties", `{"attrs":[{"operator":"greaterThan","value":"100"}],"style":{"back_color":"#FFD7D7"}}`,
+				"--properties", `{"attrs":[{"compare_type":"greaterThan","value":"100"}],"style":{"back_color":"#FFD7D7"}}`,
 				"--rule-type", "cellIs",
 				"--ranges", `["A1:A100"]`,
 			},
@@ -214,7 +215,7 @@ func TestObjectCRUDShortcuts_DryRun(t *testing.T) {
 				"conditional_format_id": "ruleA",
 				"properties": map[string]interface{}{
 					"rule_type": "cellIs",
-					"attrs":     []interface{}{map[string]interface{}{"operator": "greaterThan", "value": "100"}},
+					"attrs":     []interface{}{map[string]interface{}{"compare_type": "greaterThan", "value": "100"}},
 					"style":     map[string]interface{}{"back_color": "#FFD7D7"},
 					"ranges":    []interface{}{"A1:A100"},
 				},
@@ -507,6 +508,55 @@ func TestPivotCreate_SheetSelectorSemantics(t *testing.T) {
 	})
 }

+// TestPivotCreate_TargetPositionRangeMutex regresses the "--target-position
+// and --range cannot both be set" guardrail on +pivot-create. They map to
+// the same wire field (properties.range), so two non-default values are
+// ambiguous; the CLI rejects up front (mirrors the --target-sheet-id /
+// --target-sheet-name mutex). --target-position=A1 is the documented default
+// and is treated as "not set" — pairing it with --range still works.
+func TestPivotCreate_TargetPositionRangeMutex(t *testing.T) {
+	t.Parallel()
+
+	t.Run("both non-default values rejected", func(t *testing.T) {
+		t.Parallel()
+		_, stderr, err := runShortcutCapturingErr(t, PivotCreate, []string{
+			"--url", testURL,
+			"--target-sheet-id", testSheetID,
+			"--properties", `{"rows":[{"field":"A"}]}`,
+			"--source", "Sheet1!A1:F1000",
+			"--target-position", "B5",
+			"--range", "F1",
+		})
+		if err == nil {
+			t.Fatalf("expected CLI to reject --target-position with --range; stderr=%s", stderr)
+		}
+		combined := stderr + err.Error()
+		if !strings.Contains(combined, "mutually exclusive") {
+			t.Errorf("expected error to say 'mutually exclusive'; got=%s|%v", stderr, err)
+		}
+		if !strings.Contains(combined, "--target-position") || !strings.Contains(combined, "--range") {
+			t.Errorf("expected error to quote both --target-position and --range; got=%s|%v", stderr, err)
+		}
+	})
+
+	t.Run("default A1 with --range is accepted (range wins)", func(t *testing.T) {
+		t.Parallel()
+		body := parseDryRunBody(t, PivotCreate, []string{
+			"--url", testURL,
+			"--target-sheet-id", testSheetID,
+			"--properties", `{"rows":[{"field":"A"}]}`,
+			"--source", "Sheet1!A1:F1000",
+			"--target-position", "A1",
+			"--range", "F1",
+		})
+		input := decodeToolInput(t, body, "manage_pivot_table_object")
+		props, _ := input["properties"].(map[string]interface{})
+		if got, _ := props["range"].(string); got != "F1" {
+			t.Errorf("properties.range = %q, want %q", got, "F1")
+		}
+	})
+}
+
 // TestPivotCreate_SchemaValidates exercises the schema-driven
 // validator wired into objectCreateInput. The pivot create schema
 // doesn't constrain rows/columns/values to be present (the backend
@@ -614,6 +664,182 @@ func TestSparklineUpdate_MissingSparklineID(t *testing.T) {
 	}
 }

+// TestCondFormatAttrs_ShapeMatchesRuleType regresses the cross-field
+// guard that rejects attrs whose shape doesn't match the sibling
+// rule_type — the gap behind the "缺 color 的 colorScale 脏数据导致表格
+// 打不开" report: a colorScale rule fed cellIs-shaped attrs
+// ({compare_type,value}, no color) passed both the CLI's per-entry oneOf
+// schema check and the tool, writing a color-less segment that crashed
+// the frontend on open. The check covers create and update symmetrically.
+func TestCondFormatAttrs_ShapeMatchesRuleType(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name    string
+		sc      common.Shortcut
+		args    []string
+		wantErr bool
+		wantMsg string // substring expected in the error, when wantErr
+	}{
+		{
+			name: "colorScale fed cellIs-shaped attrs (missing color) is rejected",
+			sc:   CondFormatCreate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID,
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"compare_type":"greaterThan","value":"0"},{"compare_type":"lessThan","value":"100"}]}`, "--dry-run",
+			},
+			wantErr: true,
+			wantMsg: "colorScale",
+		},
+		{
+			name: "colorScale with empty color string is rejected",
+			sc:   CondFormatCreate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID,
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"value_type":"minValue","color":""},{"value_type":"maxValue","color":"#FF0000"}]}`, "--dry-run",
+			},
+			wantErr: true,
+			wantMsg: `"color"`,
+		},
+		{
+			name: "well-formed colorScale attrs pass",
+			sc:   CondFormatCreate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID,
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"value_type":"minValue","color":"#FFFFFF"},{"value_type":"maxValue","color":"#FF0000"}]}`, "--dry-run",
+			},
+			wantErr: false,
+		},
+		{
+			name: "update path is guarded too (colorScale + cellIs attrs)",
+			sc:   CondFormatUpdate,
+			args: []string{
+				"--url", testURL, "--sheet-id", testSheetID, "--rule-id", "ruleA",
+				"--rule-type", "colorScale", "--ranges", `["C1:C10"]`,
+				"--properties", `{"style":{},"attrs":[{"compare_type":"greaterThan","value":"0"}]}`, "--dry-run",
+			},
+			wantErr: true,
+			wantMsg: "colorScale",
+		},
+	}
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			_, stderr, err := runShortcutCapturingErr(t, tt.sc, tt.args)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatalf("expected rejection; stderr=%s", stderr)
+				}
+				if combined := stderr + err.Error(); tt.wantMsg != "" && !strings.Contains(combined, tt.wantMsg) {
+					t.Errorf("expected error to mention %q; got=%s|%v", tt.wantMsg, stderr, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("expected acceptance (dry-run); got err=%v stderr=%s", err, stderr)
+			}
+		})
+	}
+}
+
+// TestCondFormatAttrsRequired_MatchesSchemaOneOf guards against drift
+// between the hand-maintained condFormatAttrsRequired table (the source
+// validateCondFormatAttrs enforces) and the embedded flag-schemas.json
+// attrs oneOf (the authoritative shape contract synced from the spec
+// repo). The cross-field validator only works if its per-rule_type
+// required keys mirror the schema branches; if a future schema sync adds
+// or drops a required key on any branch without updating the table, the
+// CLI would silently under- or over-validate. They share no compile-time
+// link, so this test is the only thing pinning them together.
+//
+// The schema oneOf branches are NOT labeled by rule_type (that's the whole
+// point — rule_type is a sibling field the per-entry oneOf can't see), so
+// we can't match branch→rule_type. We instead compare the *multiset* of
+// required-key sets: every branch's required array must appear as some
+// table entry's value and vice versa. This catches any added/dropped
+// required key (real drift); it tolerates only a relabeling between two
+// branches that happen to share an identical required set (dataBar and
+// colorScale both require {color,value_type}), which is harmless here.
+func TestCondFormatAttrsRequired_MatchesSchemaOneOf(t *testing.T) {
+	t.Parallel()
+
+	// multiset key: required keys sorted + joined, so order within a
+	// branch's required array doesn't matter.
+	keyOf := func(req []string) string {
+		s := append([]string(nil), req...)
+		sort.Strings(s)
+		return strings.Join(s, "+")
+	}
+
+	tableMS := map[string]int{}
+	for _, req := range condFormatAttrsRequired {
+		tableMS[keyOf(req)]++
+	}
+
+	schemaMS := func(t *testing.T, command string) map[string]int {
+		idx, err := loadFlagSchemas()
+		if err != nil {
+			t.Fatalf("loadFlagSchemas: %v", err)
+		}
+		raw, ok := idx.Flags[command]["properties"]
+		if !ok {
+			t.Fatalf("no embedded schema for %s --properties", command)
+		}
+		var schema map[string]interface{}
+		if err := json.Unmarshal(raw, &schema); err != nil {
+			t.Fatalf("unmarshal %s properties schema: %v", command, err)
+		}
+		dig := func(m map[string]interface{}, key string) map[string]interface{} {
+			next, _ := m[key].(map[string]interface{})
+			if next == nil {
+				t.Fatalf("%s: missing %q while navigating to attrs oneOf", command, key)
+			}
+			return next
+		}
+		attrs := dig(dig(schema, "properties"), "attrs")
+		items := dig(attrs, "items")
+		oneOf, ok := items["oneOf"].([]interface{})
+		if !ok || len(oneOf) == 0 {
+			t.Fatalf("%s: attrs.items.oneOf is missing or empty", command)
+		}
+		ms := map[string]int{}
+		for i, branchRaw := range oneOf {
+			branch, ok := branchRaw.(map[string]interface{})
+			if !ok {
+				t.Fatalf("%s: oneOf[%d] is not an object", command, i)
+			}
+			reqRaw, _ := branch["required"].([]interface{})
+			req := make([]string, 0, len(reqRaw))
+			for _, r := range reqRaw {
+				if s, ok := r.(string); ok {
+					req = append(req, s)
+				}
+			}
+			ms[keyOf(req)]++
+		}
+		return ms
+	}
+
+	for _, command := range []string{"+cond-format-create", "+cond-format-update"} {
+		got := schemaMS(t, command)
+		if len(got) != len(tableMS) {
+			t.Errorf("%s: schema oneOf has %d distinct required-sets, table has %d", command, len(got), len(tableMS))
+		}
+		for k, n := range tableMS {
+			if got[k] != n {
+				t.Errorf("%s: required-set %q appears %d× in schema but %d× in condFormatAttrsRequired — table drifted from schema; re-sync the table", command, k, got[k], n)
+			}
+		}
+		for k, n := range got {
+			if tableMS[k] != n {
+				t.Errorf("%s: schema branch with required-set %q (×%d) has no matching condFormatAttrsRequired entry — add it to the table", command, k, n)
+			}
+		}
+	}
+}
+
 // Note: +float-image-update's image_name / position / size are cobra-required
 // (flag-defs.json), so the standalone path is gated by the flag layer — its
 // "required flag(s) … not set" wording is framework-owned and intentionally not
--- a/shortcuts/sheets/lark_sheet_object_list.go
+++ b/shortcuts/sheets/lark_sheet_object_list.go
@@ -57,7 +57,7 @@ func newObjectListShortcut(spec objectListSpec) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindRead, spec.toolName, objectListInput(runtime, token, sheetID, sheetName, spec))
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
--- a/shortcuts/sheets/lark_sheet_range_operations.go
+++ b/shortcuts/sheets/lark_sheet_range_operations.go
@@ -45,7 +45,7 @@ var CellsClear = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "clear_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -163,7 +163,7 @@ func newMergeShortcut(command, desc, op string, withMergeType bool) common.Short
 			return invokeToolDryRun(token, ToolKindWrite, "merge_cells", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -239,7 +239,7 @@ var RowsResize = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "resize_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -279,7 +279,7 @@ var ColsResize = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "resize_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -451,7 +451,7 @@ var RangeFill = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "transform_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -490,7 +490,7 @@ var RangeSort = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "transform_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
--- a/shortcuts/sheets/lark_sheet_read_data.go
+++ b/shortcuts/sheets/lark_sheet_read_data.go
@@ -5,8 +5,6 @@ package sheets

 import (
 	"context"
-	"encoding/csv"
-	"regexp"
 	"strconv"
 	"strings"

@@ -59,7 +57,7 @@ var CellsGet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_cell_ranges", cellsGetInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -152,7 +150,7 @@ var CsvGet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_range_as_csv", csvGetInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -164,12 +162,7 @@ var CsvGet = common.Shortcut{
 		if err != nil {
 			return err
 		}
-		switch {
-		case runtime.Bool("rows-json"):
-			// --rows-json reshapes the CSV response into structured rows
-			// ({row_number, values:{col→cell}}); see assembleRowsJSON.
-			out = assembleRowsJSON(out, strings.TrimSpace(runtime.Str("range")))
-		case !runtime.Bool("include-row-prefix"):
+		if !runtime.Bool("include-row-prefix") {
 			out = stripRowPrefixFromCsvOutput(out)
 		}
 		runtime.Out(out, nil)
@@ -219,141 +212,6 @@ func stripRowPrefixFromCsvOutput(out interface{}) interface{} {
 	return m
 }

-// rowPrefixRe matches the leading "[row=N] " (or "[row=N],") annotation that
-// the tool prepends to the first physical line of each logical CSV record.
-var rowPrefixRe = regexp.MustCompile(`^\[row=(\d+)\][ ,]?`)
-
-// assembleRowsJSON reshapes the tool's annotated_csv string into structured
-// rows so callers never have to regex-parse "[row=N]" or RFC-4180 CSV by hand:
-//
-//	{
-//	  "range": "A1:K3380",
-//	  "current_region": "...",        // passthrough, if the tool returned it
-//	  "rows": [{"row_number":1,"values":{"A":"姓名", ..., "K":"时间差_分钟"}},
-//	           {"row_number":2,"values":{"A":"张三", ..., "K":"8.5"}}, ...]
-//	}
-//
-// Every logical row is emitted, including the first — no row is assumed to be a
-// header, since sheet data is not always tabular. Each cell is keyed by its
-// column letter (from the tool's col_indices when present, else derived from the
-// requested range's start column). On any parsing trouble it returns the
-// original output unchanged.
-func assembleRowsJSON(out interface{}, requestedRange string) interface{} {
-	m, ok := out.(map[string]interface{})
-	if !ok {
-		return out
-	}
-	csvStr, ok := m["annotated_csv"].(string)
-	if !ok {
-		return out
-	}
-
-	// Group physical lines into logical records by [row=N] boundaries; lines
-	// without a prefix are embedded-newline continuations of the current record.
-	type logicalRow struct {
-		num  int
-		text string
-	}
-	var groups []logicalRow
-	for _, line := range strings.Split(csvStr, "\n") {
-		if mm := rowPrefixRe.FindStringSubmatch(line); mm != nil {
-			n, _ := strconv.Atoi(mm[1])
-			groups = append(groups, logicalRow{num: n, text: line[len(mm[0]):]})
-		} else if len(groups) > 0 {
-			groups[len(groups)-1].text += "\n" + line
-		}
-	}
-	if len(groups) == 0 {
-		return out
-	}
-
-	// Parse every logical row; widest row sets the column count. No row is
-	// singled out as a header — that would assume the data is tabular, which it
-	// often is not. The model reads row 1 like any other row and decides for
-	// itself whether it is a header.
-	parsed := make([][]string, len(groups))
-	maxCols := 0
-	for i, g := range groups {
-		parsed[i] = parseCSVRecord(g.text)
-		if len(parsed[i]) > maxCols {
-			maxCols = len(parsed[i])
-		}
-	}
-	if maxCols == 0 {
-		return out
-	}
-
-	// Column letters key each cell. Prefer the tool's col_indices (authoritative,
-	// length == col_count); otherwise derive from the requested range's start col.
-	letters := coerceStringSlice(m["col_indices"])
-	if len(letters) < maxCols {
-		start := csvStartColIndex(requestedRange)
-		letters = make([]string, maxCols)
-		for j := 0; j < maxCols; j++ {
-			letters[j] = csvColLetter(start + j)
-		}
-	}
-
-	rows := make([]map[string]interface{}, 0, len(groups))
-	for i := range groups {
-		fields := parsed[i]
-		values := make(map[string]interface{}, len(letters))
-		for j := range letters {
-			v := ""
-			if j < len(fields) {
-				v = fields[j]
-			}
-			values[letters[j]] = v
-		}
-		rows = append(rows, map[string]interface{}{
-			"row_number": groups[i].num,
-			"values":     values,
-		})
-	}
-
-	result := map[string]interface{}{}
-	for k, v := range m {
-		result[k] = v
-	}
-	result["range"] = requestedRange
-	result["rows"] = rows
-
-	// Surface the backend's "数据没读全" signal structurally instead of leaving it
-	// buried in warning_message prose. The tool flags it when current_region (the
-	// true data extent) reaches past actual_range (what was actually read) — the
-	// single most important anti-under-read hint. Mirror that same comparison
-	// (regionEndRow > actualEndRow) from the already-passthrough A1 ranges so the
-	// model gets the real data range as a first-class field, never having to
-	// parse it out of prose.
-	if cr, _ := m["current_region"].(string); cr != "" {
-		ar, _ := m["actual_range"].(string)
-		regionEnd := a1EndRow(cr)
-		readEnd := a1EndRow(ar)
-		if regionEnd > 0 && readEnd > 0 && regionEnd > readEnd {
-			result["data_not_fully_read"] = map[string]interface{}{
-				"read_through_row":         readEnd,
-				"data_extends_through_row": regionEnd,
-				"unread_rows":              regionEnd - readEnd,
-				"reread_range":             cr,
-			}
-		}
-	}
-
-	// Drop the fields whose information rows-json fully carries elsewhere:
-	//   - annotated_csv / row_indices / col_indices → reconstructed into
-	//     columns + rows (with integer row_number), losslessly.
-	//   - warning_message → its two halves are both handled: the static
-	//     "[row=N] / col_indices[j]" parse nag is moot once those fields exist,
-	//     and the dynamic "数据没读全" half is now the structured
-	//     data_not_fully_read field above. (Confirmed against the backend's
-	//     get-range-as-csv.ts — warning_message has no other content.)
-	delete(result, "annotated_csv")
-	delete(result, "row_indices")
-	delete(result, "col_indices")
-	delete(result, "warning_message")
-	return result
-}
-
 // a1EndRow extracts the ending row number from an A1 range, e.g. "A1:N51" → 51,
 // "Sheet1!B2:D9" → 9, "C5" → 5. Returns 0 when no row number is present.
 func a1EndRow(rng string) int {
@@ -377,89 +235,6 @@ func a1EndRow(rng string) int {
 	return n
 }

-// parseCSVRecord parses a single logical CSV record (which may span multiple
-// physical lines via quoted embedded newlines) into its fields. An empty record
-// yields no fields; a malformed record falls back to a naive comma split so a
-// stray quote never drops a whole row.
-func parseCSVRecord(text string) []string {
-	if strings.TrimSpace(text) == "" {
-		return nil
-	}
-	r := csv.NewReader(strings.NewReader(text))
-	r.FieldsPerRecord = -1
-	fields, err := r.Read()
-	if err != nil {
-		return strings.Split(text, ",")
-	}
-	return fields
-}
-
-// coerceStringSlice returns v as []string when it is a homogeneous []interface{}
-// of strings (the shape of the tool's col_indices), else nil.
-func coerceStringSlice(v interface{}) []string {
-	arr, ok := v.([]interface{})
-	if !ok {
-		return nil
-	}
-	out := make([]string, 0, len(arr))
-	for _, e := range arr {
-		s, ok := e.(string)
-		if !ok {
-			return nil
-		}
-		out = append(out, s)
-	}
-	return out
-}
-
-// csvStartColIndex returns the 0-based column index of a range's start column,
-// e.g. "A1:K3380" → 0, "C5:F9" → 2, "Sheet1!D2" → 3. Unparseable input → 0.
-func csvStartColIndex(rng string) int {
-	rng = strings.TrimSpace(rng)
-	if i := strings.LastIndex(rng, "!"); i >= 0 {
-		rng = rng[i+1:]
-	}
-	var letters strings.Builder
-	for _, c := range rng {
-		if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
-			letters.WriteRune(c)
-			continue
-		}
-		break
-	}
-	if letters.Len() == 0 {
-		return 0
-	}
-	return csvColToIndex(letters.String())
-}
-
-// csvColToIndex converts a column letter to its 0-based index ("A"→0, "K"→10,
-// "AA"→26). Non-letter input → -1.
-func csvColToIndex(s string) int {
-	n := 0
-	for _, c := range strings.ToUpper(s) {
-		if c < 'A' || c > 'Z' {
-			break
-		}
-		n = n*26 + int(c-'A'+1)
-	}
-	return n - 1
-}
-
-// csvColLetter converts a 0-based column index back to its letter (0→"A",
-// 25→"Z", 26→"AA"). Negative input → "".
-func csvColLetter(idx int) string {
-	if idx < 0 {
-		return ""
-	}
-	var b []byte
-	for idx >= 0 {
-		b = append([]byte{byte('A' + idx%26)}, b...)
-		idx = idx/26 - 1
-	}
-	return string(b)
-}
-
 // DropdownGet wraps get_cell_ranges scoped to data_validation: read the
 // dropdown configuration on a range. Aligned with its sibling +cells-get
 // — sheet selection is via --sheet-id / --sheet-name (XOR), and --range
@@ -494,7 +269,7 @@ var DropdownGet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_cell_ranges", dropdownGetInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
--- a/shortcuts/sheets/lark_sheet_read_data_test.go
+++ b/shortcuts/sheets/lark_sheet_read_data_test.go
@@ -63,20 +63,6 @@ func TestReadDataShortcuts_DryRun(t *testing.T) {
 				"value_render_option": "formatted_value",
 			},
 		},
-		{
-			// --rows-json is post-processing on +csv-get's response; it must
-			// NOT leak into the get_range_as_csv input.
-			name:     "+csv-get --rows-json builds the same input (flag is post-process)",
-			sc:       CsvGet,
-			args:     []string{"--url", testURL, "--sheet-id", testSheetID, "--range", "A1:C10", "--rows-json"},
-			toolName: "get_range_as_csv",
-			wantInput: map[string]interface{}{
-				"excel_id": testToken,
-				"sheet_id": testSheetID,
-				"range":    "A1:C10",
-				"max_rows": float64(unboundedReadLimit),
-			},
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -179,113 +165,3 @@ func TestCsvGet_StripRowPrefix(t *testing.T) {
 		t.Errorf("other field corrupted: %v", out["other"])
 	}
 }
-
-// TestAssembleRowsJSON covers the --rows-json reshaping: every logical row
-// emitted (no header singled out), integer row_number, column-letter keyed
-// values, embedded newlines inside quoted fields, and current_region passthrough.
-func TestAssembleRowsJSON(t *testing.T) {
-	t.Parallel()
-	in := map[string]interface{}{
-		"annotated_csv":   "[row=1] 姓名,备注,时间差_分钟\n[row=2] 张三,\"line1\nline2\",8.5\n[row=3] 李四,ok,3",
-		"current_region":  "A1:C3",
-		"col_indices":     []interface{}{"A", "B", "C"},
-		"row_indices":     []interface{}{1, 2, 3},
-		"warning_message": "①定位行号…②定位列字母…",
-	}
-	out, ok := assembleRowsJSON(in, "A1:C3").(map[string]interface{})
-	if !ok {
-		t.Fatalf("assembleRowsJSON did not return a map")
-	}
-
-	// Fields whose info rows-json carries elsewhere are dropped (annotated_csv /
-	// indices → rows; warning_message → moot static nag + structured
-	// data_not_fully_read). Unrelated metadata like current_region is preserved.
-	if _, exists := out["annotated_csv"]; exists {
-		t.Errorf("annotated_csv should be dropped")
-	}
-	if _, exists := out["col_indices"]; exists {
-		t.Errorf("col_indices should be dropped")
-	}
-	if _, exists := out["warning_message"]; exists {
-		t.Errorf("warning_message should be dropped in rows-json mode")
-	}
-	if _, exists := out["columns"]; exists {
-		t.Errorf("columns field should not exist (no header assumption)")
-	}
-	if out["current_region"] != "A1:C3" {
-		t.Errorf("current_region passthrough lost: %v", out["current_region"])
-	}
-
-	rows, _ := out["rows"].([]map[string]interface{})
-	if len(rows) != 3 {
-		t.Fatalf("want all 3 rows (incl. row 1), got %d: %+v", len(rows), rows)
-	}
-	// Row 1 is emitted as a normal row, not consumed as a header.
-	if rows[0]["row_number"].(int) != 1 {
-		t.Errorf("first row_number = %v, want 1", rows[0]["row_number"])
-	}
-	if v := rows[0]["values"].(map[string]interface{}); v["A"] != "姓名" || v["C"] != "时间差_分钟" {
-		t.Errorf("row 1 values wrong: %+v", v)
-	}
-	// Row 2 keeps its embedded newline inside a single cell.
-	v1 := rows[1]["values"].(map[string]interface{})
-	if rows[1]["row_number"].(int) != 2 || v1["A"] != "张三" || v1["B"] != "line1\nline2" || v1["C"] != "8.5" {
-		t.Errorf("row 2 wrong (embedded newline?): %+v", rows[1])
-	}
-}
-
-// TestAssembleRowsJSON_DerivedLetters verifies cell letters are derived from the
-// range start when the tool omits col_indices (e.g. a C-anchored read).
-func TestAssembleRowsJSON_DerivedLetters(t *testing.T) {
-	t.Parallel()
-	in := map[string]interface{}{
-		"annotated_csv": "[row=5] h1,h2\n[row=6] a,b",
-	}
-	out := assembleRowsJSON(in, "C5:D6").(map[string]interface{})
-	rows := out["rows"].([]map[string]interface{})
-	if len(rows) != 2 {
-		t.Fatalf("want 2 rows, got %d", len(rows))
-	}
-	if rows[0]["row_number"].(int) != 5 {
-		t.Errorf("first row_number = %v, want 5", rows[0]["row_number"])
-	}
-	if v := rows[0]["values"].(map[string]interface{}); v["C"] != "h1" || v["D"] != "h2" {
-		t.Errorf("derived-letter values wrong: %+v", v)
-	}
-	if v := rows[1]["values"].(map[string]interface{}); v["C"] != "a" || v["D"] != "b" {
-		t.Errorf("row 6 values wrong: %+v", v)
-	}
-}
-
-// TestAssembleRowsJSON_DataNotFullyRead verifies the structured under-read hint:
-// when current_region extends past actual_range, rows-json surfaces the true data
-// range as a first-class field (mirroring the backend's prose warning).
-func TestAssembleRowsJSON_DataNotFullyRead(t *testing.T) {
-	t.Parallel()
-	// Read only A1:D2, but the data region reaches D4 → 2 rows unread.
-	in := map[string]interface{}{
-		"annotated_csv":  "[row=1] 序号,姓名\n[row=2] 101,张三",
-		"actual_range":   "A1:D2",
-		"current_region": "A1:D4",
-	}
-	out := assembleRowsJSON(in, "A1:D2").(map[string]interface{})
-	hint, ok := out["data_not_fully_read"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("data_not_fully_read missing; out=%+v", out)
-	}
-	if hint["read_through_row"] != 2 || hint["data_extends_through_row"] != 4 ||
-		hint["unread_rows"] != 2 || hint["reread_range"] != "A1:D4" {
-		t.Errorf("data_not_fully_read wrong: %+v", hint)
-	}
-
-	// Fully-read case: no hint emitted.
-	in2 := map[string]interface{}{
-		"annotated_csv":  "[row=1] 序号,姓名\n[row=2] 101,张三",
-		"actual_range":   "A1:D2",
-		"current_region": "A1:D2",
-	}
-	out2 := assembleRowsJSON(in2, "A1:D2").(map[string]interface{})
-	if _, exists := out2["data_not_fully_read"]; exists {
-		t.Errorf("data_not_fully_read should be absent when fully read")
-	}
-}
--- a/shortcuts/sheets/lark_sheet_search_replace.go
+++ b/shortcuts/sheets/lark_sheet_search_replace.go
@@ -46,7 +46,7 @@ var CellsSearch = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "search_data", searchInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -122,7 +122,7 @@ var CellsReplace = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "replace_data", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
--- a/shortcuts/sheets/lark_sheet_sheet_structure.go
+++ b/shortcuts/sheets/lark_sheet_sheet_structure.go
@@ -51,7 +51,7 @@ var SheetInfo = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindRead, "get_sheet_structure", sheetInfoInput(runtime, token, sheetID, sheetName))
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -136,7 +136,7 @@ var DimInsert = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -211,7 +211,7 @@ var DimDelete = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -300,7 +300,7 @@ var DimFreeze = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -395,7 +395,7 @@ func newDimRangeOpShortcut(command, desc, op, risk string) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -439,7 +439,7 @@ func newDimGroupShortcut(command, desc, op string) common.Shortcut {
 			return invokeToolDryRun(token, ToolKindWrite, "modify_sheet_structure", input)
 		},
 		Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-			token, err := resolveSpreadsheetToken(runtime)
+			token, err := resolveSpreadsheetTokenExec(runtime)
 			if err != nil {
 				return err
 			}
@@ -593,7 +593,7 @@ var DimMove = common.Shortcut{
 			Set("spreadsheet_token", token)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
--- a/shortcuts/sheets/lark_sheet_style_alias_test.go
+++ b/shortcuts/sheets/lark_sheet_style_alias_test.go
@@ -0,0 +1,199 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// TestNormalizeCellStyleAliases pins the shorthand → canonical renaming for a
+// single cell_styles map: the alignment shorthands models commonly hallucinate
+// are rewritten in place, values are preserved, and a shorthand colliding with
+// its canonical key is a hard error rather than a silent pick.
+func TestNormalizeCellStyleAliases(t *testing.T) {
+	t.Parallel()
+
+	t.Run("renames *_align shorthands, keeps values and other fields", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{
+			"horizontal_align": "center",
+			"vertical_align":   "middle",
+			"font_weight":      "bold",
+		}
+		if err := normalizeCellStyleAliases(style, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if style["horizontal_alignment"] != "center" || style["vertical_alignment"] != "middle" {
+			t.Errorf("alignment not renamed: %#v", style)
+		}
+		if _, ok := style["horizontal_align"]; ok {
+			t.Errorf("shorthand horizontal_align should be removed: %#v", style)
+		}
+		if _, ok := style["vertical_align"]; ok {
+			t.Errorf("shorthand vertical_align should be removed: %#v", style)
+		}
+		if style["font_weight"] != "bold" {
+			t.Errorf("unrelated field font_weight dropped: %#v", style)
+		}
+	})
+
+	t.Run("renames halign/valign shorthands", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{"halign": "left", "valign": "top"}
+		if err := normalizeCellStyleAliases(style, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if style["horizontal_alignment"] != "left" || style["vertical_alignment"] != "top" {
+			t.Errorf("halign/valign not renamed: %#v", style)
+		}
+	})
+
+	t.Run("shorthand colliding with canonical is an error", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{
+			"horizontal_align":     "center",
+			"horizontal_alignment": "left",
+		}
+		err := normalizeCellStyleAliases(style, "cell_styles[0]")
+		if err == nil {
+			t.Fatalf("expected conflict error, got nil")
+		}
+		if !strings.Contains(err.Error(), "conflicts with horizontal_alignment") {
+			t.Errorf("error should name the conflict: %v", err)
+		}
+	})
+
+	t.Run("no shorthand leaves the map untouched", func(t *testing.T) {
+		t.Parallel()
+		style := map[string]interface{}{"font_weight": "bold", "horizontal_alignment": "center"}
+		if err := normalizeCellStyleAliases(style, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if len(style) != 2 || style["font_weight"] != "bold" || style["horizontal_alignment"] != "center" {
+			t.Errorf("map should be unchanged: %#v", style)
+		}
+	})
+
+	t.Run("empty map is a no-op", func(t *testing.T) {
+		t.Parallel()
+		if err := normalizeCellStyleAliases(map[string]interface{}{}, "x"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	})
+}
+
+// TestNormalizeTypedCellsStyleAliases pins the 2D --cells walk: every cell's
+// inline cell_styles is normalized, malformed shapes are skipped (matching the
+// pass-through contract) rather than rejected, and a conflict propagates.
+func TestNormalizeTypedCellsStyleAliases(t *testing.T) {
+	t.Parallel()
+
+	t.Run("normalizes inline cell_styles across the grid", func(t *testing.T) {
+		t.Parallel()
+		cells := []interface{}{
+			[]interface{}{
+				map[string]interface{}{
+					"value":       "x",
+					"cell_styles": map[string]interface{}{"horizontal_align": "center"},
+				},
+				map[string]interface{}{"value": "y"}, // no cell_styles → untouched
+			},
+		}
+		if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		row := cells[0].([]interface{})
+		st := row[0].(map[string]interface{})["cell_styles"].(map[string]interface{})
+		if st["horizontal_alignment"] != "center" {
+			t.Errorf("cell_styles not normalized: %#v", st)
+		}
+		if _, ok := st["horizontal_align"]; ok {
+			t.Errorf("shorthand should be removed: %#v", st)
+		}
+	})
+
+	t.Run("malformed shapes are skipped, not rejected", func(t *testing.T) {
+		t.Parallel()
+		cells := []interface{}{
+			"not-a-row",
+			[]interface{}{
+				"not-a-cell",
+				map[string]interface{}{"cell_styles": "not-a-map"},
+			},
+		}
+		if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
+			t.Fatalf("lenient walk should not error on odd shapes: %v", err)
+		}
+	})
+
+	t.Run("conflict inside a cell propagates", func(t *testing.T) {
+		t.Parallel()
+		cells := []interface{}{
+			[]interface{}{
+				map[string]interface{}{
+					"cell_styles": map[string]interface{}{
+						"valign":             "top",
+						"vertical_alignment": "middle",
+					},
+				},
+			},
+		}
+		err := normalizeTypedCellsStyleAliases(cells, "--cells")
+		if err == nil {
+			t.Fatalf("expected conflict error, got nil")
+		}
+		if !strings.Contains(err.Error(), "--cells[0][0].cell_styles") {
+			t.Errorf("error should carry the cell path: %v", err)
+		}
+	})
+}
+
+// TestCellsSet_StyleAliasesNormalized is the end-to-end guard for +cells-set:
+// a typed --cells payload using alignment shorthands reaches set_cell_range
+// with canonical field names so the backend doesn't silently drop them.
+func TestCellsSet_StyleAliasesNormalized(t *testing.T) {
+	t.Parallel()
+	cells := `[[{"value":"Header","cell_styles":{"horizontal_align":"center","vertical_align":"middle","font_weight":"bold"}}]]`
+	body := parseDryRunBody(t, CellsSet, []string{
+		"--url", testURL, "--sheet-id", testSheetID,
+		"--range", "A1", "--cells", cells,
+	})
+	input := decodeToolInput(t, body, "set_cell_range")
+	raw, _ := json.Marshal(input["cells"])
+	s := string(raw)
+	if !strings.Contains(s, `"horizontal_alignment":"center"`) || !strings.Contains(s, `"vertical_alignment":"middle"`) {
+		t.Errorf("alignment shorthands not normalized in cells: %s", s)
+	}
+	if strings.Contains(s, `"horizontal_align":`) || strings.Contains(s, `"vertical_align":`) {
+		t.Errorf("shorthand keys leaked through to backend payload: %s", s)
+	}
+}
+
+// TestWorkbookCreate_StyleAliasesNormalized is the end-to-end guard for
+// +workbook-create --styles: alignment shorthands in a cell_styles op are
+// accepted (no "unsupported style field" error) and emitted as canonical
+// field names merged into the fill cells.
+func TestWorkbookCreate_StyleAliasesNormalized(t *testing.T) {
+	t.Parallel()
+	calls := parseDryRunAPI(t, WorkbookCreate, []string{
+		"--title", "Sales",
+		"--values", `[["Name","Score"],["alice",95]]`,
+		"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:B2","horizontal_align":"center","vertical_align":"middle"}]}]}`,
+	})
+	if len(calls) != 2 {
+		t.Fatalf("api calls = %d, want 2 (create + fill)", len(calls))
+	}
+	body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+	input := decodeToolInput(t, body, "set_cell_range")
+	raw, _ := json.Marshal(input["cells"])
+	s := string(raw)
+	if c := strings.Count(s, `"horizontal_alignment":"center"`); c != 4 {
+		t.Errorf("horizontal_alignment occurrences = %d, want 4 in 2x2 range; cells=%s", c, s)
+	}
+	if strings.Contains(s, `"horizontal_align":`) || strings.Contains(s, `"vertical_align":`) {
+		t.Errorf("shorthand keys leaked through after normalization: %s", s)
+	}
+}
--- a/shortcuts/sheets/lark_sheet_table_io.go
+++ b/shortcuts/sheets/lark_sheet_table_io.go
--- a/shortcuts/sheets/lark_sheet_table_io_test.go
+++ b/shortcuts/sheets/lark_sheet_table_io_test.go
--- a/shortcuts/sheets/lark_sheet_workbook.go
+++ b/shortcuts/sheets/lark_sheet_workbook.go
--- a/shortcuts/sheets/lark_sheet_workbook_export_test.go
+++ b/shortcuts/sheets/lark_sheet_workbook_export_test.go
@@ -0,0 +1,72 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/httpmock"
+)
+
+// TestWorkbookExport_ExecuteExportOnly covers the no-download path: without
+// --output-path, +workbook-export delegates to the shared drive export core
+// with OutputDir="" so it creates + polls the export task and returns the ready
+// file token without writing a local file (downloaded=false).
+func TestWorkbookExport_ExecuteExportOnly(t *testing.T) {
+	stubs := []*httpmock.Stub{
+		{
+			Method: "POST",
+			URL:    "/open-apis/drive/v1/export_tasks",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"ticket": "tk_export"},
+			},
+		},
+		{
+			Method: "GET",
+			URL:    "/open-apis/drive/v1/export_tasks/tk_export",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"result": map[string]interface{}{
+					"job_status": float64(0),
+					"file_token": "ftk_xlsx",
+					"file_name":  "report.xlsx",
+					"file_size":  float64(2048),
+				}},
+			},
+		},
+	}
+
+	out, err := runShortcutWithStubs(t, WorkbookExport, []string{
+		"--url", testURL, "--file-extension", "xlsx", "--as", "user",
+	}, stubs...)
+	if err != nil {
+		t.Fatalf("export-only execute failed: %v\n%s", err, out)
+	}
+
+	idx := strings.Index(out, "{")
+	if idx < 0 {
+		t.Fatalf("no JSON envelope:\n%s", out)
+	}
+	var env struct {
+		Data map[string]interface{} `json:"data"`
+	}
+	if err := json.Unmarshal([]byte(out[idx:]), &env); err != nil {
+		t.Fatalf("decode envelope: %v\nraw=%s", err, out)
+	}
+	if env.Data["ready"] != true {
+		t.Errorf("ready = %v, want true", env.Data["ready"])
+	}
+	if env.Data["downloaded"] != false {
+		t.Errorf("downloaded = %v, want false (no --output-path)", env.Data["downloaded"])
+	}
+	if env.Data["file_token"] != "ftk_xlsx" {
+		t.Errorf("file_token = %v, want ftk_xlsx", env.Data["file_token"])
+	}
+	if env.Data["doc_type"] != "sheet" {
+		t.Errorf("doc_type = %v, want sheet", env.Data["doc_type"])
+	}
+}
--- a/shortcuts/sheets/lark_sheet_workbook_import_test.go
+++ b/shortcuts/sheets/lark_sheet_workbook_import_test.go
@@ -0,0 +1,135 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/httpmock"
+	_ "github.com/larksuite/cli/internal/vfs/localfileio"
+)
+
+// chdirTemp switches into a fresh temp dir for the duration of the test and
+// restores the original cwd afterwards. +workbook-import is the first sheets
+// shortcut that stat()s a real local file, so these tests need a working dir.
+func chdirTemp(t *testing.T) {
+	t.Helper()
+	orig, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("getwd: %v", err)
+	}
+	if err := os.Chdir(t.TempDir()); err != nil {
+		t.Fatalf("chdir: %v", err)
+	}
+	t.Cleanup(func() { _ = os.Chdir(orig) })
+}
+
+// TestWorkbookImport_DryRunPinsSheetType verifies the shortcut delegates to the
+// shared drive import core and hard-codes the import target type to "sheet".
+func TestWorkbookImport_DryRunPinsSheetType(t *testing.T) {
+	chdirTemp(t)
+	if err := os.WriteFile("data.xlsx", []byte("fake-xlsx"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+
+	calls := parseDryRunAPI(t, WorkbookImport, []string{"--file", "./data.xlsx"})
+
+	var createBody map[string]interface{}
+	for _, c := range calls {
+		cm, _ := c.(map[string]interface{})
+		if u, _ := cm["url"].(string); u == "/open-apis/drive/v1/import_tasks" {
+			createBody, _ = cm["body"].(map[string]interface{})
+		}
+	}
+	if createBody == nil {
+		t.Fatalf("no import_tasks create call in dry-run: %#v", calls)
+	}
+	if createBody["type"] != "sheet" {
+		t.Errorf("import type = %v, want sheet (must be pinned regardless of file)", createBody["type"])
+	}
+	if createBody["file_extension"] != "xlsx" {
+		t.Errorf("file_extension = %v, want xlsx", createBody["file_extension"])
+	}
+}
+
+// TestWorkbookImport_RejectsNonSheetFile ensures a file that cannot become a
+// spreadsheet (e.g. .docx) is rejected up front by the pinned-sheet validation.
+func TestWorkbookImport_RejectsNonSheetFile(t *testing.T) {
+	chdirTemp(t)
+	if err := os.WriteFile("notes.docx", []byte("fake-docx"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+
+	// Validate runs before DryRun, so the pinned-sheet check rejects .docx up
+	// front and the error surfaces through the normal envelope/err path.
+	stdout, stderr, err := runShortcutCapturingErr(t, WorkbookImport, []string{"--file", "./notes.docx", "--dry-run"})
+	if err == nil || !strings.Contains(stdout+stderr+err.Error(), "can only be imported") {
+		t.Errorf("expected .docx → sheet type-mismatch rejection; got stdout=%s stderr=%s err=%v", stdout, stderr, err)
+	}
+}
+
+// TestWorkbookImport_ExecuteCreatesSheet runs the full upload → create → poll
+// flow against stubs and asserts the resulting URL is a /sheets/ link.
+func TestWorkbookImport_ExecuteCreatesSheet(t *testing.T) {
+	chdirTemp(t)
+	if err := os.WriteFile("data.csv", []byte("a,b\n1,2\n"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+
+	stubs := []*httpmock.Stub{
+		{
+			Method: "POST",
+			URL:    "/open-apis/drive/v1/medias/upload_all",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"file_token": "file_import_media"},
+			},
+		},
+		{
+			Method: "POST",
+			URL:    "/open-apis/drive/v1/import_tasks",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"ticket": "tk_sheet"},
+			},
+		},
+		{
+			Method: "GET",
+			URL:    "/open-apis/drive/v1/import_tasks/tk_sheet",
+			Body: map[string]interface{}{
+				"code": 0, "msg": "ok",
+				"data": map[string]interface{}{"result": map[string]interface{}{
+					"token":      "shtcn_imported",
+					"type":       "sheet",
+					"job_status": float64(0),
+				}},
+			},
+		},
+	}
+
+	out, err := runShortcutWithStubs(t, WorkbookImport, []string{"--file", "./data.csv", "--as", "user"}, stubs...)
+	if err != nil {
+		t.Fatalf("import execute failed: %v\n%s", err, out)
+	}
+
+	idx := strings.Index(out, "{")
+	if idx < 0 {
+		t.Fatalf("execute output has no JSON envelope:\n%s", out)
+	}
+	var env struct {
+		Data map[string]interface{} `json:"data"`
+	}
+	if err := json.Unmarshal([]byte(out[idx:]), &env); err != nil {
+		t.Fatalf("decode envelope: %v\nraw=%s", err, out)
+	}
+	if url, _ := env.Data["url"].(string); !strings.Contains(url, "/sheets/") {
+		t.Errorf("imported url = %q, want a /sheets/ link", url)
+	}
+	if tok, _ := env.Data["token"].(string); tok != "shtcn_imported" {
+		t.Errorf("token = %q, want shtcn_imported", tok)
+	}
+}
--- a/shortcuts/sheets/lark_sheet_workbook_test.go
+++ b/shortcuts/sheets/lark_sheet_workbook_test.go
@@ -4,14 +4,10 @@
 package sheets

 import (
-	"errors"
-	"net/http"
+	"encoding/json"
 	"strings"
 	"testing"

-	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
-
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/shortcuts/common"
 )

@@ -145,6 +141,28 @@ func TestWorkbookShortcuts_DryRun(t *testing.T) {
 				"tab_color": "",
 			},
 		},
+		{
+			name:     "+sheet-show-gridline",
+			sc:       SheetShowGridline,
+			args:     []string{"--url", testURL, "--sheet-id", testSheetID},
+			toolName: "modify_workbook_structure",
+			wantInput: map[string]interface{}{
+				"excel_id":  testToken,
+				"operation": "show_gridline",
+				"sheet_id":  testSheetID,
+			},
+		},
+		{
+			name:     "+sheet-hide-gridline",
+			sc:       SheetHideGridline,
+			args:     []string{"--url", testURL, "--sheet-id", testSheetID},
+			toolName: "modify_workbook_structure",
+			wantInput: map[string]interface{}{
+				"excel_id":  testToken,
+				"operation": "hide_gridline",
+				"sheet_id":  testSheetID,
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -288,7 +306,7 @@ func TestWorkbookCreate_DryRun(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookCreate, []string{"--title", "MySheet"})
 		if len(calls) != 1 {
-			t.Fatalf("api calls = %d, want 1 (no headers/data)", len(calls))
+			t.Fatalf("api calls = %d, want 1 (no values)", len(calls))
 		}
 		c := calls[0].(map[string]interface{})
 		if c["url"] != "/open-apis/sheets/v3/spreadsheets" {
@@ -300,12 +318,11 @@ func TestWorkbookCreate_DryRun(t *testing.T) {
 		}
 	})

-	t.Run("with headers and data → 2-step plan", func(t *testing.T) {
+	t.Run("with values → 2-step plan", func(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookCreate, []string{
 			"--title", "Sales",
-			"--headers", `["Name","Score"]`,
-			"--values", `[["alice",95],["bob",88]]`,
+			"--values", `[["Name","Score"],["alice",95],["bob",88]]`,
 		})
 		if len(calls) != 2 {
 			t.Fatalf("api calls = %d, want 2 (create + fill)", len(calls))
@@ -317,7 +334,88 @@ func TestWorkbookCreate_DryRun(t *testing.T) {
 		body, _ := fill["body"].(map[string]interface{})
 		input := decodeToolInput(t, body, "set_cell_range")
 		if input["range"] != "A1:B3" {
-			t.Errorf("fill range = %v, want A1:B3 (1 header + 2 data rows × 2 cols)", input["range"])
+			t.Errorf("fill range = %v, want A1:B3 (3 rows × 2 cols)", input["range"])
+		}
+	})
+
+	t.Run("with styles merges into set_cell_range cells", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "Sales",
+			"--values", `[["Name","Score"],["alice",95]]`,
+			"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","font_weight":"bold","background_color":"#f5f5f5"},{"range":"B1","number_format":"0","border_styles":{"bottom":{"style":"solid","weight":"thin","color":"#000000"}}},{"range":"B2","font_color":"#0f7b0f"}]}]}`,
+		})
+		if len(calls) != 2 {
+			t.Fatalf("api calls = %d, want 2 (create + fill)", len(calls))
+		}
+		body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+		input := decodeToolInput(t, body, "set_cell_range")
+		cells, _ := input["cells"].([]interface{})
+		if len(cells) != 2 {
+			t.Fatalf("cells rows = %#v, want 2", input["cells"])
+		}
+		headerRow, _ := cells[0].([]interface{})
+		firstHeader, _ := headerRow[0].(map[string]interface{})
+		firstStyle, _ := firstHeader["cell_styles"].(map[string]interface{})
+		if firstStyle["font_weight"] != "bold" || firstStyle["background_color"] != "#f5f5f5" {
+			t.Errorf("first header style = %#v, want bold + background", firstStyle)
+		}
+		secondHeader, _ := headerRow[1].(map[string]interface{})
+		if secondHeader["border_styles"] == nil {
+			t.Errorf("second header missing border_styles: %#v", secondHeader)
+		}
+		secondStyle, _ := secondHeader["cell_styles"].(map[string]interface{})
+		if secondStyle["number_format"] != "0" {
+			t.Errorf("second header number_format = %#v, want 0", secondStyle)
+		}
+		dataRow, _ := cells[1].([]interface{})
+		firstData, _ := dataRow[0].(map[string]interface{})
+		if _, ok := firstData["cell_styles"]; ok {
+			t.Errorf("null style should leave first data cell unstyled: %#v", firstData)
+		}
+		secondData, _ := dataRow[1].(map[string]interface{})
+		secondDataStyle, _ := secondData["cell_styles"].(map[string]interface{})
+		if secondDataStyle["font_color"] != "#0f7b0f" {
+			t.Errorf("second data style = %#v, want font color", secondDataStyle)
+		}
+	})
+
+	t.Run("cell style range can cover the whole initial range", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "Sales",
+			"--values", `[["Name","Score"],["alice",95]]`,
+			"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:B2","horizontal_alignment":"center"}]}]}`,
+		})
+		body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+		input := decodeToolInput(t, body, "set_cell_range")
+		raw, _ := json.Marshal(input["cells"])
+		if got := strings.Count(string(raw), "horizontal_alignment"); got != 4 {
+			t.Errorf("horizontal_alignment occurrences = %d, want 4 in 2x2 range; cells=%s", got, raw)
+		}
+	})
+	t.Run("overlapping cell_styles deep-merge fields, no cross-cell pollution", func(t *testing.T) {
+		t.Parallel()
+		calls := parseDryRunAPI(t, WorkbookCreate, []string{
+			"--title", "X",
+			"--values", `[["a","b"]]`,
+			"--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1:B1","font_weight":"bold"},{"range":"B1","font_color":"#ff0000"}]}]}`,
+		})
+		body, _ := calls[1].(map[string]interface{})["body"].(map[string]interface{})
+		input := decodeToolInput(t, body, "set_cell_range")
+		cells, _ := input["cells"].([]interface{})
+		row0, _ := cells[0].([]interface{})
+		// B1 hit by both ops → must keep BOTH font_weight (op1) and font_color (op2).
+		b1, _ := row0[1].(map[string]interface{})
+		b1s, _ := b1["cell_styles"].(map[string]interface{})
+		if b1s["font_weight"] != "bold" || b1s["font_color"] != "#ff0000" {
+			t.Errorf("B1 should deep-merge both ops, got %#v", b1s)
+		}
+		// A1 hit only by op1 → must NOT be polluted by op2's font_color (shared submap).
+		a1, _ := row0[0].(map[string]interface{})
+		a1s, _ := a1["cell_styles"].(map[string]interface{})
+		if a1s["font_color"] != nil {
+			t.Errorf("A1 must not be polluted by op2, got %#v", a1s)
 		}
 	})
 }
@@ -330,8 +428,18 @@ func TestWorkbookCreate_DataValidation(t *testing.T) {
 		args []string
 		want string
 	}{
-		{"headers not array", []string{"--title", "X", "--headers", `"abc"`}, "must be a JSON array"},
 		{"values not 2D", []string{"--title", "X", "--values", `["a","b"]`}, "must be an array"},
+		{"styles not object", []string{"--title", "X", "--styles", `"bold"`}, `shaped as {"styles":[...]}`},
+		{"styles missing array", []string{"--title", "X", "--styles", `{"value":"x"}`}, "--styles.styles is required"},
+		{"styles item missing groups", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","value":"x"}]}`}, "must include at least one of cell_styles/row_sizes/col_sizes/cell_merges"},
+		{"cell styles must be array", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":{"range":"A1","font_weight":"bold"}}]}`}, "cell_styles must be an array"},
+		{"cell style needs range", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"font_weight":"bold"}]}]}`}, "range is required"},
+		{"nested cell_styles rejected", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","cell_styles":{"font_weight":"bold"}}]}]}`}, "put style fields directly"},
+		{"row size needs row range", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","row_sizes":[{"range":"A1","type":"pixel","size":20}]}]}`}, "must use row numbers"},
+		{"col size needs pixel size", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","col_sizes":[{"range":"A:A","type":"pixel"}]}]}`}, "requires size"},
+		{"border bad style enum", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","border_styles":{"bottom":{"style":"NONSENSE"}}}]}]}`}, `style "NONSENSE" is invalid`},
+		{"border invalid side", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","border_styles":{"diagonal":{"style":"solid"}}}]}]}`}, "not a valid side"},
+		{"border bad weight", []string{"--title", "X", "--values", `[["a"]]`, "--styles", `{"styles":[{"name":"Sheet1","cell_styles":[{"range":"A1","border_styles":{"top":{"weight":"xxl"}}}]}]}`}, `weight "xxl" is invalid`},
 	}
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
@@ -344,21 +452,21 @@ func TestWorkbookCreate_DataValidation(t *testing.T) {
 	}
 }

-// TestWorkbookExport_DryRun checks the 2-or-3 step plan depending on
-// --output-path. The order should be: POST → GET (poll) → optional GET
-// (download).
+// TestWorkbookExport_DryRun verifies the export dry-run now delegates to the
+// shared drive export core: a single create-task POST (poll + download are
+// described inline rather than as separate api entries).
 func TestWorkbookExport_DryRun(t *testing.T) {
 	t.Parallel()

-	t.Run("xlsx without --output-path → 2 steps", func(t *testing.T) {
+	t.Run("xlsx create-task body pins type=sheet", func(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookExport, []string{"--url", testURL, "--file-extension", "xlsx"})
-		if len(calls) != 2 {
-			t.Fatalf("api calls = %d, want 2 (create + poll)", len(calls))
+		if len(calls) != 1 {
+			t.Fatalf("api calls = %d, want 1 (create export task)", len(calls))
 		}
 		create := calls[0].(map[string]interface{})
 		if create["url"] != "/open-apis/drive/v1/export_tasks" {
-			t.Errorf("first url = %v", create["url"])
+			t.Errorf("url = %v", create["url"])
 		}
 		body, _ := create["body"].(map[string]interface{})
 		if body["type"] != "sheet" || body["file_extension"] != "xlsx" || body["token"] != testToken {
@@ -366,22 +474,18 @@ func TestWorkbookExport_DryRun(t *testing.T) {
 		}
 	})

-	t.Run("csv → 3 steps, with sub_id", func(t *testing.T) {
+	t.Run("csv includes sub_id from --sheet-id", func(t *testing.T) {
 		t.Parallel()
 		calls := parseDryRunAPI(t, WorkbookExport, []string{
 			"--url", testURL, "--file-extension", "csv", "--sheet-id", "sh1",
 			"--output-path", "/tmp/out.csv",
 		})
-		if len(calls) != 3 {
-			t.Fatalf("api calls = %d, want 3", len(calls))
+		if len(calls) != 1 {
+			t.Fatalf("api calls = %d, want 1", len(calls))
 		}
 		body, _ := calls[0].(map[string]interface{})["body"].(map[string]interface{})
-		if body["sub_id"] != "sh1" {
-			t.Errorf("csv export missing sub_id: %#v", body)
-		}
-		dl := calls[2].(map[string]interface{})
-		if !strings.Contains(dl["url"].(string), "/export_tasks/file/") {
-			t.Errorf("download url = %v", dl["url"])
+		if body["type"] != "sheet" || body["sub_id"] != "sh1" {
+			t.Errorf("csv export body = %#v (want type=sheet, sub_id=sh1)", body)
 		}
 	})

@@ -396,92 +500,6 @@ func TestWorkbookExport_DryRun(t *testing.T) {
 	})
 }

-func TestWorkbookExportDownloadErrorClassification(t *testing.T) {
-	t.Parallel()
-
-	t.Run("preserves typed request errors", func(t *testing.T) {
-		t.Parallel()
-		in := errs.NewAPIError(errs.SubtypeServerError, "typed upstream").WithCode(123)
-		got := sheetsDownloadRequestError(in)
-		if got != in {
-			t.Fatalf("typed error was not preserved: got %T %v", got, got)
-		}
-	})
-
-	t.Run("wraps raw request errors as network transport", func(t *testing.T) {
-		t.Parallel()
-		got := sheetsDownloadRequestError(errors.New("dial refused"))
-		p, ok := errs.ProblemOf(got)
-		if !ok {
-			t.Fatalf("expected typed problem, got %T %v", got, got)
-		}
-		if p.Category != errs.CategoryNetwork || p.Subtype != errs.SubtypeNetworkTransport {
-			t.Fatalf("problem = %s/%s, want %s/%s", p.Category, p.Subtype, errs.CategoryNetwork, errs.SubtypeNetworkTransport)
-		}
-	})
-
-	tests := []struct {
-		name          string
-		status        int
-		wantCategory  errs.Category
-		wantSubtype   errs.Subtype
-		wantRetryable bool
-	}{
-		{
-			name:          "5xx is retryable network server error",
-			status:        http.StatusBadGateway,
-			wantCategory:  errs.CategoryNetwork,
-			wantSubtype:   errs.SubtypeNetworkServer,
-			wantRetryable: true,
-		},
-		{
-			name:         "404 is API not found",
-			status:       http.StatusNotFound,
-			wantCategory: errs.CategoryAPI,
-			wantSubtype:  errs.SubtypeNotFound,
-		},
-		{
-			name:          "429 is retryable API rate limit",
-			status:        http.StatusTooManyRequests,
-			wantCategory:  errs.CategoryAPI,
-			wantSubtype:   errs.SubtypeRateLimit,
-			wantRetryable: true,
-		},
-		{
-			name:         "other 4xx is API unknown",
-			status:       http.StatusForbidden,
-			wantCategory: errs.CategoryAPI,
-			wantSubtype:  errs.SubtypeUnknown,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			got := sheetsDownloadHTTPStatusError(&larkcore.ApiResp{
-				StatusCode: tt.status,
-				RawBody:    []byte("body"),
-				Header:     http.Header{larkcore.HttpHeaderKeyLogId: []string{"log123"}},
-			})
-			p, ok := errs.ProblemOf(got)
-			if !ok {
-				t.Fatalf("expected typed problem, got %T %v", got, got)
-			}
-			if p.Category != tt.wantCategory || p.Subtype != tt.wantSubtype {
-				t.Fatalf("problem = %s/%s, want %s/%s", p.Category, p.Subtype, tt.wantCategory, tt.wantSubtype)
-			}
-			if p.Code != tt.status {
-				t.Fatalf("code = %d, want %d", p.Code, tt.status)
-			}
-			if p.LogID != "log123" {
-				t.Fatalf("log_id = %q, want log123", p.LogID)
-			}
-			if p.Retryable != tt.wantRetryable {
-				t.Fatalf("retryable = %v, want %v", p.Retryable, tt.wantRetryable)
-			}
-		})
-	}
-}
-
 // assertInputEquals compares the decoded tool input map against the wanted
 // fields. Extra fields in `got` are allowed (defaults, optional fields);
 // every key in `want` must match exactly.
--- a/shortcuts/sheets/lark_sheet_write_cells.go
+++ b/shortcuts/sheets/lark_sheet_write_cells.go
@@ -56,7 +56,7 @@ var CellsSet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -88,6 +88,9 @@ func cellsSetInput(runtime flagView, token, sheetID, sheetName string) (map[stri
 	if err != nil {
 		return nil, err
 	}
+	if err := normalizeTypedCellsStyleAliases(cells, "--cells"); err != nil {
+		return nil, err
+	}
 	input := map[string]interface{}{
 		"excel_id": token,
 		"range":    strings.TrimSpace(runtime.Str("range")),
@@ -129,7 +132,7 @@ var CellsSetStyle = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -197,12 +200,12 @@ func cellsSetStyleInput(runtime flagView, token, sheetID, sheetName string) (map
 	return input, nil
 }

-// CsvPut wraps set_range_from_csv: dump a CSV blob into a sheet, only writing
-// plain values. Use +cells-set for anything richer (formula / style / note).
+// CsvPut wraps set_range_from_csv: dump a CSV blob into a sheet. A cell whose
+// text starts with = is evaluated as a formula; use +cells-set for styles / notes / images.
 var CsvPut = common.Shortcut{
 	Service:     "sheets",
 	Command:     "+csv-put",
-	Description: "Paste RFC-4180 CSV into a sheet at --start-cell (plain values only, auto-expands sheet if needed).",
+	Description: "Paste RFC-4180 CSV into a sheet at --start-cell (values or formulas: a leading = is evaluated as a formula; no styles / comments; auto-expands sheet if needed).",
 	Risk:        "write",
 	Scopes:      []string{"sheets:spreadsheet:write_only"},
 	AuthTypes:   []string{"user", "bot"},
@@ -237,7 +240,7 @@ var CsvPut = common.Shortcut{
 		return dr
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -414,7 +417,7 @@ var DropdownSet = common.Shortcut{
 		return invokeToolDryRun(token, ToolKindWrite, "set_cell_range", input)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
@@ -801,7 +804,7 @@ var CellsSetImage = common.Shortcut{
 			Body(setCellBody)
 	},
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		token, err := resolveSpreadsheetToken(runtime)
+		token, err := resolveSpreadsheetTokenExec(runtime)
 		if err != nil {
 			return err
 		}
--- a/shortcuts/sheets/lark_sheet_write_cells_test.go
+++ b/shortcuts/sheets/lark_sheet_write_cells_test.go
@@ -4,6 +4,7 @@
 package sheets

 import (
+	"fmt"
 	"strings"
 	"testing"

@@ -427,6 +428,44 @@ func TestCellsSet_RequiresJSONArray(t *testing.T) {
 	}
 }

+// TestCellsSet_RejectsUnsupportedMentionType pins the mention_type enum in
+// data/flag-schemas.json (synced from the upstream tool schema): a rich_text
+// mention whose mention_type is outside MENTION_FILE_TYPE (here 6 = cloud
+// shared folder) is rejected by the schema validator at flag-parse time,
+// before it can reach the server and blow up pb serialization
+// ("mentionFileInfo.fileType: enum value expected").
+func TestCellsSet_RejectsUnsupportedMentionType(t *testing.T) {
+	t.Parallel()
+	cells := `[[{"rich_text":[{"type":"mention","text":"x","mention_type":6,"mention_token":"t"}]}]]`
+	stdout, stderr, err := runShortcutCapturingErr(t, CellsSet, []string{
+		"--url", testURL, "--sheet-id", testSheetID,
+		"--range", "A1", "--cells", cells, "--dry-run",
+	})
+	if err == nil {
+		t.Fatalf("expected validation error; stdout=%s stderr=%s", stdout, stderr)
+	}
+	combined := stdout + stderr + err.Error()
+	if !strings.Contains(combined, "mention_type") || !strings.Contains(combined, "not in enum") {
+		t.Errorf("expected mention_type enum guard; got=%s|%s|%v", stdout, stderr, err)
+	}
+}
+
+// TestCellsSet_AllowsValidMentionTypes confirms the guard lets through a
+// user @mention (mention_type 0) and a render-supported file type (22 = DOCX).
+func TestCellsSet_AllowsValidMentionTypes(t *testing.T) {
+	t.Parallel()
+	for _, mt := range []int{0, 22} {
+		cells := fmt.Sprintf(`[[{"rich_text":[{"type":"mention","text":"x","mention_type":%d,"mention_token":"t"}]}]]`, mt)
+		stdout, stderr, err := runShortcutCapturingErr(t, CellsSet, []string{
+			"--url", testURL, "--sheet-id", testSheetID,
+			"--range", "A1", "--cells", cells, "--dry-run",
+		})
+		if err != nil {
+			t.Errorf("mention_type %d: unexpected error: stdout=%s stderr=%s err=%v", mt, stdout, stderr, err)
+		}
+	}
+}
+
 // TestCellsSetImage_DryRun verifies the 2-step plan (upload + embed) is
 // rendered, including the parent_type=sheet_image upload metadata.
 func TestCellsSetImage_DryRun(t *testing.T) {
--- a/shortcuts/sheets/shortcuts.go
+++ b/shortcuts/sheets/shortcuts.go
@@ -3,7 +3,11 @@

 package sheets

-import "github.com/larksuite/cli/shortcuts/common"
+import (
+	"github.com/larksuite/cli/shortcuts/common"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)

 // Shortcuts returns all lark-sheets shortcuts. The list is grouped by
 // canonical skill to mirror the sheet-skill-spec layout
@@ -22,10 +26,46 @@ func Shortcuts() []common.Shortcut {
 		if _, ok := commandsWithSchema[all[i].Command]; ok {
 			all[i].PrintFlagSchema = printFlagSchemaFor(all[i].Command)
 		}
+		// Accept --token as a parse-time alias for --spreadsheet-token (the
+		// single highest-frequency reflex misspelling in eval traces) on every
+		// shortcut that registers --spreadsheet-token, so the typo costs zero
+		// round-trips instead of an unknown-flag failure. Wired through the
+		// existing PostMount hook and composed onto any prior PostMount, so the
+		// common framework needs no change at all.
+		if hasFlag(all[i].Flags, "spreadsheet-token") {
+			all[i].PostMount = withTokenAlias(all[i].PostMount)
+		}
 	}
 	return all
 }

+func hasFlag(flags []common.Flag, name string) bool {
+	for _, fl := range flags {
+		if fl.Name == name {
+			return true
+		}
+	}
+	return false
+}
+
+// withTokenAlias wraps an optional PostMount so that, after it runs, --token
+// resolves to --spreadsheet-token at parse time via pflag's normalize hook (no
+// duplicate flag in --help). It preserves any pre-existing PostMount — e.g.
+// +csv-put's --range / --start-cell flag-group setup — by running it first.
+func withTokenAlias(prev func(cmd *cobra.Command)) func(cmd *cobra.Command) {
+	return func(cmd *cobra.Command) {
+		if prev != nil {
+			prev(cmd)
+		}
+		cmd.Flags().SetNormalizeFunc(func(_ *pflag.FlagSet, name string) pflag.NormalizedName {
+			if name == "token" {
+				return pflag.NormalizedName("spreadsheet-token")
+			}
+			return pflag.NormalizedName(name)
+		})
+	}
+}
+
 func shortcutList() []common.Shortcut {
 	return []common.Shortcut{
 		// lark_sheet_workbook
@@ -38,8 +78,11 @@ func shortcutList() []common.Shortcut {
 		SheetHide,
 		SheetUnhide,
 		SheetSetTabColor,
+		SheetShowGridline,
+		SheetHideGridline,
 		WorkbookCreate,
 		WorkbookExport,
+		WorkbookImport,

 		// lark_sheet_sheet_structure
 		SheetInfo,
@@ -56,6 +99,7 @@ func shortcutList() []common.Shortcut {
 		CellsGet,
 		CsvGet,
 		DropdownGet,
+		TableGet,

 		// lark_sheet_search_replace
 		CellsSearch,
@@ -67,6 +111,7 @@ func shortcutList() []common.Shortcut {
 		CellsSetImage,
 		CsvPut,
 		DropdownSet,
+		TablePut,

 		// lark_sheet_range_operations
 		CellsClear,
--- a/shortcuts/sheets/shortcuts_alias_test.go
+++ b/shortcuts/sheets/shortcuts_alias_test.go
@@ -0,0 +1,53 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package sheets
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+// TestWithTokenAlias verifies the PostMount-based --token → --spreadsheet-token
+// alias: it resolves at parse time, and it composes onto (rather than replaces)
+// any pre-existing PostMount — the property that lets it coexist with
+// +csv-put's --range/--start-cell flag-group setup.
+func TestWithTokenAlias(t *testing.T) {
+	t.Parallel()
+
+	// Alias resolves to the canonical flag.
+	cmd := &cobra.Command{Use: "x"}
+	cmd.Flags().String("spreadsheet-token", "", "")
+	withTokenAlias(nil)(cmd)
+	if err := cmd.Flags().Parse([]string{"--token", "shtABC"}); err != nil {
+		t.Fatalf("--token should resolve as an alias: %v", err)
+	}
+	if got := cmd.Flags().Lookup("spreadsheet-token").Value.String(); got != "shtABC" {
+		t.Errorf("--token should set --spreadsheet-token; got %q", got)
+	}
+
+	// Composes with an existing PostMount instead of dropping it.
+	prevRan := false
+	cmd2 := &cobra.Command{Use: "y"}
+	cmd2.Flags().String("spreadsheet-token", "", "")
+	withTokenAlias(func(_ *cobra.Command) { prevRan = true })(cmd2)
+	if !prevRan {
+		t.Error("pre-existing PostMount should still run")
+	}
+	if err := cmd2.Flags().Parse([]string{"--token", "shtZ"}); err != nil {
+		t.Fatalf("--token should still resolve when composed: %v", err)
+	}
+}
+
+// TestShortcuts_TokenAliasOnSpreadsheetTokenCommands asserts every shortcut that
+// takes --spreadsheet-token ends up with a PostMount (the composed token alias),
+// so the reflex typo is forgiven wherever the canonical flag exists.
+func TestShortcuts_TokenAliasOnSpreadsheetTokenCommands(t *testing.T) {
+	t.Parallel()
+	for _, s := range Shortcuts() {
+		if hasFlag(s.Flags, "spreadsheet-token") && s.PostMount == nil {
+			t.Errorf("%s takes --spreadsheet-token but has no PostMount (token alias missing)", s.Command)
+		}
+	}
+}
--- a/shortcuts/slides/shortcuts.go
+++ b/shortcuts/slides/shortcuts.go
@@ -11,6 +11,5 @@ func Shortcuts() []common.Shortcut {
 		SlidesCreate,
 		SlidesMediaUpload,
 		SlidesReplaceSlide,
-		SlidesScreenshot,
 	}
 }
--- a/shortcuts/slides/slides_screenshot.go
+++ b/shortcuts/slides/slides_screenshot.go
@@ -1,537 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package slides
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/util"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const defaultSlidesScreenshotDir = ".lark-slides/screenshots"
-
-var unsafeScreenshotFileCharRegex = regexp.MustCompile(`[^A-Za-z0-9._-]+`)
-
-// SlidesScreenshot fetches server-rendered slide screenshots and writes them to
-// local files. The raw API returns Base64 image payloads; this shortcut keeps
-// those payloads out of stdout so agents only see small file metadata.
-var SlidesScreenshot = common.Shortcut{
-	Service:     "slides",
-	Command:     "+screenshot",
-	Description: "Save slide screenshots to local files without printing Base64 image data",
-	Risk:        "read",
-	Scopes:      []string{"slides:presentation:screenshot"},
-	// wiki:node:read is required only when --presentation is a wiki URL.
-	ConditionalScopes: []string{"wiki:node:read"},
-	AuthTypes:         []string{"user", "bot"},
-	Flags: []common.Flag{
-		{Name: "presentation", Desc: "xml_presentation_id, slides URL, or wiki URL that resolves to slides; list mode only"},
-		{Name: "slide-id", Type: "string_array", Desc: "slide page identifier (repeat for multiple slides)"},
-		{Name: "slide-number", Type: "int_array", Desc: "slide page number (repeat for multiple slides)"},
-		{Name: "content", Desc: "slide XML content to render directly instead of fetching existing slides", Input: []string{common.File, common.Stdin}},
-		{Name: "output-dir", Default: defaultSlidesScreenshotDir, Desc: "relative directory for saved screenshots"},
-		{Name: "output-name", Desc: "file name stem for --content render output"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		renderMode := runtime.Changed("content")
-		if renderMode {
-			if strings.TrimSpace(runtime.Str("content")) == "" {
-				return slidesScreenshotFlagErrorf("--content cannot be empty")
-			}
-			if len(normalizeSlideIDs(runtime.StrArray("slide-id"))) > 0 || len(runtime.IntArray("slide-number")) > 0 {
-				return slidesScreenshotFlagErrorf("--content cannot be used with --slide-id or --slide-number")
-			}
-			if runtime.Changed("presentation") {
-				return slidesScreenshotFlagErrorf("--presentation cannot be used with --content")
-			}
-		} else {
-			ref, err := parsePresentationRef(runtime.Str("presentation"))
-			if err != nil {
-				return err
-			}
-			if ref.Kind == "wiki" {
-				if err := runtime.EnsureScopes([]string{"wiki:node:read"}); err != nil {
-					return err
-				}
-			}
-			if _, err := normalizeSlideNumbers(runtime.IntArray("slide-number")); err != nil {
-				return err
-			}
-			if !hasSlideScreenshotSelector(runtime) {
-				return slidesScreenshotFlagErrorf("--slide-id or --slide-number is required")
-			}
-		}
-		if _, err := validateScreenshotOutputDir(runtime, runtime.Str("output-dir")); err != nil {
-			return err
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		if runtime.Changed("content") {
-			return dryRunRenderScreenshot(runtime)
-		}
-		ref, err := parsePresentationRef(runtime.Str("presentation"))
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		slideIDs := normalizeSlideIDs(runtime.StrArray("slide-id"))
-		slideNumbers, err := normalizeSlideNumbers(runtime.IntArray("slide-number"))
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		if len(slideIDs) == 0 && len(slideNumbers) == 0 {
-			return common.NewDryRunAPI().Set("error", "--slide-id or --slide-number is required")
-		}
-
-		presentationID := ref.Token
-		dry := common.NewDryRunAPI()
-		if ref.Kind == "wiki" {
-			presentationID = "<resolved_slides_token>"
-			dry.Desc("2-step orchestration: resolve wiki → fetch slide screenshot(s)").
-				GET("/open-apis/wiki/v2/spaces/get_node").
-				Desc("[1] Resolve wiki node to slides presentation").
-				Params(map[string]interface{}{"token": ref.Token})
-		} else {
-			dry.Desc(fmt.Sprintf("Fetch %d slide screenshot(s) and save files under %s", len(slideIDs)+len(slideNumbers), runtime.Str("output-dir")))
-		}
-		body := map[string]interface{}{}
-		if len(slideIDs) > 0 {
-			body["slide_ids"] = slideIDs
-		}
-		if len(slideNumbers) > 0 {
-			body["slide_numbers"] = slideNumbers
-		}
-		dry.POST(fmt.Sprintf(
-			"/open-apis/slides_ai/v1/xml_presentations/%s/slide_images",
-			validate.EncodePathSegment(presentationID),
-		)).
-			Body(body)
-		return dry.Set("output_dir", runtime.Str("output-dir")).Set("base64_output", "suppressed; decoded to local files during execution")
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if runtime.Changed("content") {
-			return executeRenderScreenshot(runtime)
-		}
-		ref, err := parsePresentationRef(runtime.Str("presentation"))
-		if err != nil {
-			return err
-		}
-		presentationID, err := resolvePresentationID(runtime, ref)
-		if err != nil {
-			return err
-		}
-
-		slideIDs := normalizeSlideIDs(runtime.StrArray("slide-id"))
-		slideNumbers, err := normalizeSlideNumbers(runtime.IntArray("slide-number"))
-		if err != nil {
-			return err
-		}
-		if len(slideIDs) == 0 && len(slideNumbers) == 0 {
-			return slidesScreenshotFlagErrorf("--slide-id or --slide-number is required")
-		}
-		outputDir := runtime.Str("output-dir")
-		safeOutputDir, err := ensureScreenshotOutputDir(runtime, outputDir)
-		if err != nil {
-			return err
-		}
-
-		url := fmt.Sprintf(
-			"/open-apis/slides_ai/v1/xml_presentations/%s/slide_images",
-			validate.EncodePathSegment(presentationID),
-		)
-		query := larkcore.QueryParams{}
-		body := map[string]interface{}{}
-		if len(slideIDs) > 0 {
-			body["slide_ids"] = slideIDs
-		}
-		if len(slideNumbers) > 0 {
-			body["slide_numbers"] = slideNumbers
-		}
-		data, err := doSlidesScreenshotAPIJSONWithLogID(runtime, "POST", url, query, body)
-		if err != nil {
-			return enrichSlidesScreenshotSelectorError(err, slideNumbers)
-		}
-
-		saved, err := saveSlideScreenshots(runtime, data, safeOutputDir, presentationID)
-		if err != nil {
-			return err
-		}
-		runtime.Out(map[string]interface{}{
-			"xml_presentation_id": presentationID,
-			"output_dir":          outputDir,
-			"screenshots":         saved,
-		}, nil)
-		return nil
-	},
-}
-
-func dryRunRenderScreenshot(runtime *common.RuntimeContext) *common.DryRunAPI {
-	content := runtime.Str("content")
-	if strings.TrimSpace(content) == "" {
-		return common.NewDryRunAPI().Set("error", "--content cannot be empty")
-	}
-	if len(normalizeSlideIDs(runtime.StrArray("slide-id"))) > 0 || len(runtime.IntArray("slide-number")) > 0 {
-		return common.NewDryRunAPI().Set("error", "--content cannot be used with --slide-id or --slide-number")
-	}
-	if runtime.Changed("presentation") {
-		return common.NewDryRunAPI().Set("error", "--presentation cannot be used with --content")
-	}
-	dry := common.NewDryRunAPI().Desc("Render slide XML content to a screenshot file")
-	dry.POST("/open-apis/slides_ai/v1/slide_image/render").
-		Body(map[string]interface{}{
-			"content": fmt.Sprintf("<xml omitted; length=%d>", len(content)),
-		})
-	return dry.Set("output_dir", runtime.Str("output-dir")).Set("base64_output", "suppressed; decoded to local file during execution")
-}
-
-func executeRenderScreenshot(runtime *common.RuntimeContext) error {
-	content := runtime.Str("content")
-	if strings.TrimSpace(content) == "" {
-		return slidesScreenshotFlagErrorf("--content cannot be empty")
-	}
-	if len(normalizeSlideIDs(runtime.StrArray("slide-id"))) > 0 || len(runtime.IntArray("slide-number")) > 0 {
-		return slidesScreenshotFlagErrorf("--content cannot be used with --slide-id or --slide-number")
-	}
-	if runtime.Changed("presentation") {
-		return slidesScreenshotFlagErrorf("--presentation cannot be used with --content")
-	}
-	outputDir := runtime.Str("output-dir")
-	safeOutputDir, err := ensureScreenshotOutputDir(runtime, outputDir)
-	if err != nil {
-		return err
-	}
-
-	data, err := doSlidesScreenshotAPIJSONWithLogID(runtime, "POST", "/open-apis/slides_ai/v1/slide_image/render", larkcore.QueryParams{}, map[string]interface{}{
-		"content": content,
-	})
-	if err != nil {
-		return err
-	}
-	saved, err := saveRenderedSlideScreenshot(runtime, data, safeOutputDir, runtime.Str("output-name"))
-	if err != nil {
-		return err
-	}
-	runtime.Out(map[string]interface{}{
-		"output_dir":  outputDir,
-		"screenshots": saved,
-	}, nil)
-	return nil
-}
-
-func normalizeSlideIDs(values []string) []string {
-	out := make([]string, 0, len(values))
-	seen := map[string]struct{}{}
-	for _, v := range values {
-		s := strings.TrimSpace(v)
-		if s == "" {
-			continue
-		}
-		if _, ok := seen[s]; ok {
-			continue
-		}
-		seen[s] = struct{}{}
-		out = append(out, s)
-	}
-	return out
-}
-
-func normalizeSlideNumbers(values []int) ([]int, error) {
-	out := make([]int, 0, len(values))
-	seen := map[int]struct{}{}
-	for _, n := range values {
-		if n < 1 {
-			return nil, slidesScreenshotFlagErrorf("--slide-number must be a positive integer")
-		}
-		if _, ok := seen[n]; ok {
-			continue
-		}
-		seen[n] = struct{}{}
-		out = append(out, n)
-	}
-	return out, nil
-}
-
-func hasSlideScreenshotSelector(runtime *common.RuntimeContext) bool {
-	return len(normalizeSlideIDs(runtime.StrArray("slide-id"))) > 0 || len(runtime.IntArray("slide-number")) > 0
-}
-
-func slidesScreenshotFlagErrorf(format string, args ...interface{}) error {
-	return errs.NewValidationError(errs.SubtypeInvalidArgument, format, args...)
-}
-
-func validateScreenshotOutputDir(runtime *common.RuntimeContext, outputDir string) (string, error) {
-	if _, err := runtime.ResolveSavePath(filepath.Join(outputDir, "probe.png")); err != nil {
-		return "", slidesScreenshotFlagErrorf("--output-dir invalid: %v", err)
-	}
-	return outputDir, nil
-}
-
-func ensureScreenshotOutputDir(runtime *common.RuntimeContext, outputDir string) (string, error) {
-	return validateScreenshotOutputDir(runtime, outputDir)
-}
-
-func saveSlideScreenshots(runtime *common.RuntimeContext, data map[string]interface{}, outputDir string, presentationID string) ([]map[string]interface{}, error) {
-	items := common.GetSlice(data, "slide_images")
-	if len(items) == 0 {
-		return nil, slidesScreenshotAPIDataError(data, "slides screenshot returned no slide_images")
-	}
-	saved := make([]map[string]interface{}, 0, len(items))
-	for i, item := range items {
-		m, ok := item.(map[string]interface{})
-		if !ok {
-			return nil, slidesScreenshotAPIDataError(data, "slides screenshot returned invalid slide_images[%d]", i)
-		}
-		item, err := saveSlideScreenshotImage(runtime, m, outputDir, slideScreenshotListFileBase(presentationID, m, i), "")
-		if err != nil {
-			if isSlidesScreenshotPassthroughError(err) {
-				return nil, err
-			}
-			return nil, slidesScreenshotAPIDataError(data, "slides screenshot returned invalid slide_images[%d]: %v", i, err)
-		}
-		saved = append(saved, item)
-	}
-	return saved, nil
-}
-
-func saveRenderedSlideScreenshot(runtime *common.RuntimeContext, data map[string]interface{}, outputDir string, outputName string) ([]map[string]interface{}, error) {
-	item := common.GetMap(data, "slide_image")
-	if item == nil {
-		return nil, slidesScreenshotAPIDataError(data, "slides render screenshot returned no slide_image")
-	}
-	saved, err := saveSlideScreenshotImage(runtime, item, outputDir, outputName, "rendered-slide")
-	if err != nil {
-		if isSlidesScreenshotPassthroughError(err) {
-			return nil, err
-		}
-		return nil, slidesScreenshotAPIDataError(data, "slides render screenshot returned invalid slide_image: %v", err)
-	}
-	return []map[string]interface{}{saved}, nil
-}
-
-func saveSlideScreenshotImage(runtime *common.RuntimeContext, item map[string]interface{}, outputDir string, outputName string, fallbackName string) (map[string]interface{}, error) {
-	slideID := strings.TrimSpace(common.GetString(item, "slide_id"))
-	ext, label, err := slideScreenshotFormat(item)
-	if err != nil {
-		return nil, slidesScreenshotImageDataError(slideID, "%s", err)
-	}
-	encoded := strings.TrimSpace(common.GetString(item, "data"))
-	if encoded == "" {
-		return nil, slidesScreenshotImageDataError(slideID, "empty image data")
-	}
-	imageBytes, err := base64.StdEncoding.DecodeString(encoded)
-	if err != nil {
-		return nil, slidesScreenshotImageDataCauseError(slideID, err, "decode screenshot: %s", err)
-	}
-	fileBase := strings.TrimSpace(outputName)
-	if fileBase == "" {
-		fileBase = slideID
-	}
-	if fileBase == "" {
-		fileBase = fallbackName
-	}
-	path, err := writeUniqueScreenshotFile(runtime, outputDir, fileBase, ext, imageBytes)
-	if err != nil {
-		return nil, err
-	}
-	return map[string]interface{}{
-		"slide_id":     slideID,
-		"slide_number": slideScreenshotInt(item, "slide_number"),
-		"format":       label,
-		"path":         path,
-		"size":         len(imageBytes),
-	}, nil
-}
-
-func slideScreenshotListFileBase(presentationID string, item map[string]interface{}, index int) string {
-	presentationID = strings.TrimSpace(presentationID)
-	slideID := strings.TrimSpace(common.GetString(item, "slide_id"))
-	slideNumber := slideScreenshotInt(item, "slide_number")
-	if presentationID != "" {
-		switch {
-		case slideNumber > 0 && slideID != "":
-			return fmt.Sprintf("%s_p%03d_%s", presentationID, slideNumber, slideID)
-		case slideNumber > 0:
-			return fmt.Sprintf("%s_p%03d", presentationID, slideNumber)
-		case slideID != "":
-			return fmt.Sprintf("%s_%s", presentationID, slideID)
-		}
-	}
-	if slideID != "" {
-		return slideID
-	}
-	if slideNumber := slideScreenshotInt(item, "slide_number"); slideNumber > 0 {
-		return fmt.Sprintf("slide-%d", slideNumber)
-	}
-	return fmt.Sprintf("slide-%d", index+1)
-}
-
-func slideScreenshotFormat(item map[string]interface{}) (string, string, error) {
-	format := slideScreenshotInt(item, "format")
-	switch format {
-	case 1:
-		return "png", "png", nil
-	case 2:
-		return "jpg", "jpeg", nil
-	default:
-		return "", "", errs.NewAPIError(errs.SubtypeInvalidResponse, "unsupported screenshot format %d", format)
-	}
-}
-
-func slidesScreenshotImageDataError(slideID string, format string, args ...interface{}) error {
-	msg := fmt.Sprintf(format, args...)
-	if slideID != "" {
-		msg = fmt.Sprintf("%s for slide %s", msg, slideID)
-	}
-	return errs.NewAPIError(errs.SubtypeInvalidResponse, "%s", msg)
-}
-
-func slidesScreenshotImageDataCauseError(slideID string, cause error, format string, args ...interface{}) error {
-	msg := fmt.Sprintf(format, args...)
-	if slideID != "" {
-		msg = fmt.Sprintf("%s for slide %s", msg, slideID)
-	}
-	return errs.NewAPIError(errs.SubtypeInvalidResponse, "%s", msg).WithCause(cause)
-}
-
-func slideScreenshotInt(item map[string]interface{}, key string) int {
-	n, ok := util.ToFloat64(item[key])
-	if !ok {
-		return 0
-	}
-	return int(n)
-}
-
-func doSlidesScreenshotAPIJSONWithLogID(runtime *common.RuntimeContext, method string, apiPath string, query larkcore.QueryParams, body interface{}) (map[string]interface{}, error) {
-	req := &larkcore.ApiReq{
-		HttpMethod:  method,
-		ApiPath:     apiPath,
-		QueryParams: query,
-	}
-	if body != nil {
-		req.Body = body
-	}
-	resp, err := runtime.DoAPI(req)
-	if err != nil {
-		return nil, errs.WrapInternal(err)
-	}
-	data, err := runtime.ClassifyAPIResponse(resp)
-	if err != nil {
-		return data, err
-	}
-	if data == nil {
-		data = map[string]interface{}{}
-	}
-	if logID := strings.TrimSpace(resp.Header.Get("x-tt-logid")); logID != "" {
-		data["log_id"] = logID
-	}
-	return data, nil
-}
-
-func enrichSlidesScreenshotSelectorError(err error, slideNumbers []int) error {
-	if len(slideNumbers) == 0 {
-		return err
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		return err
-	}
-	if p.Hint == "" {
-		p.Hint = "slide_numbers was rejected by the server; verify the page number exists in this presentation, or retry with --slide-id."
-	}
-	return err
-}
-
-func slidesScreenshotAPIDataError(data map[string]interface{}, format string, args ...interface{}) error {
-	msg := fmt.Sprintf(format, args...)
-	err := errs.NewAPIError(errs.SubtypeInvalidResponse, "%s; raw_data=%v", msg, summarizeScreenshotAPIData(data))
-	if logID := strings.TrimSpace(common.GetString(data, "log_id")); logID != "" {
-		err = err.WithLogID(logID)
-	}
-	return err
-}
-
-func isSlidesScreenshotPassthroughError(err error) bool {
-	_, ok := errs.ProblemOf(err)
-	return ok
-}
-
-func summarizeScreenshotAPIData(v interface{}) interface{} {
-	switch x := v.(type) {
-	case map[string]interface{}:
-		out := make(map[string]interface{}, len(x))
-		for k, val := range x {
-			out[k] = summarizeScreenshotAPIData(val)
-		}
-		return out
-	case []interface{}:
-		out := make([]interface{}, 0, len(x))
-		for i, val := range x {
-			if i >= 20 {
-				out = append(out, fmt.Sprintf("<omitted %d more items>", len(x)-i))
-				break
-			}
-			out = append(out, summarizeScreenshotAPIData(val))
-		}
-		return out
-	case string:
-		if len(x) > 512 {
-			return fmt.Sprintf("<omitted string length=%d prefix=%q>", len(x), x[:64])
-		}
-		return x
-	default:
-		return x
-	}
-}
-
-func safeScreenshotFileBase(base string) string {
-	name := unsafeScreenshotFileCharRegex.ReplaceAllString(base, "_")
-	name = strings.Trim(name, "._-")
-	if name == "" {
-		name = "slide"
-	}
-	return name
-}
-
-func writeUniqueScreenshotFile(runtime *common.RuntimeContext, outputDir string, fileBase string, ext string, imageBytes []byte) (string, error) {
-	base := safeScreenshotFileBase(fileBase)
-	for i := 0; i < 1000; i++ {
-		candidateBase := base
-		if i > 0 {
-			candidateBase = fmt.Sprintf("%s_%d", base, i+1)
-		}
-		path := filepath.Join(outputDir, candidateBase+"."+ext)
-		if _, err := runtime.FileIO().Stat(path); err == nil {
-			continue
-		} else if !isScreenshotFileNotExist(err) {
-			return "", errs.NewInternalError(errs.SubtypeFileIO, "write screenshot %s: %v", path, err).WithCause(err)
-		}
-		if _, err := runtime.FileIO().Save(path, fileio.SaveOptions{}, bytes.NewReader(imageBytes)); err != nil {
-			return "", common.WrapSaveErrorTyped(err)
-		}
-		resolvedPath, err := runtime.ResolveSavePath(path)
-		if err != nil {
-			return "", errs.NewInternalError(errs.SubtypeFileIO, "resolve saved screenshot path %s: %v", path, err).WithCause(err)
-		}
-		return resolvedPath, nil
-	}
-	path := filepath.Join(outputDir, base+"."+ext)
-	return "", errs.NewInternalError(errs.SubtypeFileIO, "write screenshot %s: too many duplicate file names", path)
-}
-
-func isScreenshotFileNotExist(err error) bool {
-	return os.IsNotExist(err)
-}
--- a/shortcuts/slides/slides_screenshot_test.go
+++ b/shortcuts/slides/slides_screenshot_test.go
@@ -1,506 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package slides
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func TestSlidesScreenshotDeclaredScopes(t *testing.T) {
-	got := SlidesScreenshot.DeclaredScopesForIdentity("user")
-	want := []string{"slides:presentation:screenshot", "wiki:node:read"}
-	if len(got) != len(want) || got[0] != want[0] || got[1] != want[1] {
-		t.Fatalf("declared scopes = %#v, want %#v", got, want)
-	}
-}
-
-func TestSlidesScreenshotWritesFilesAndSuppressesBase64(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-
-	imageBytes := []byte("png-bytes")
-	jpegBytes := []byte("jpeg-bytes")
-	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_abc/slide_images",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"slide_images": []map[string]interface{}{
-					{
-						"slide_id": "slide_1",
-						"format":   1,
-						"data":     base64.StdEncoding.EncodeToString(imageBytes),
-					},
-					{
-						"slide_id":     "slide_2",
-						"slide_number": 2,
-						"format":       2,
-						"data":         base64.StdEncoding.EncodeToString(jpegBytes),
-					},
-				},
-			},
-		},
-	}
-	reg.Register(stub)
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-id", "slide_1",
-		"--output-dir", "shots",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	path := filepath.Join(dir, "shots", "pres_abc_slide_1.png")
-	gotBytes, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("read screenshot: %v", err)
-	}
-	if string(gotBytes) != string(imageBytes) {
-		t.Fatalf("written bytes = %q, want %q", gotBytes, imageBytes)
-	}
-	jpegPath := filepath.Join(dir, "shots", "pres_abc_p002_slide_2.jpg")
-	gotJPEGBytes, err := os.ReadFile(jpegPath)
-	if err != nil {
-		t.Fatalf("read jpeg screenshot: %v", err)
-	}
-	if string(gotJPEGBytes) != string(jpegBytes) {
-		t.Fatalf("written jpeg bytes = %q, want %q", gotJPEGBytes, jpegBytes)
-	}
-	if strings.Contains(stdout.String(), base64.StdEncoding.EncodeToString(imageBytes)) {
-		t.Fatalf("stdout leaked base64 image data: %s", stdout.String())
-	}
-
-	data := decodeShortcutData(t, stdout)
-	if data["xml_presentation_id"] != "pres_abc" {
-		t.Fatalf("xml_presentation_id = %v", data["xml_presentation_id"])
-	}
-	items, ok := data["screenshots"].([]interface{})
-	if !ok || len(items) != 2 {
-		t.Fatalf("screenshots = %#v, want two items", data["screenshots"])
-	}
-	item, _ := items[0].(map[string]interface{})
-	if item["slide_id"] != "slide_1" {
-		t.Fatalf("slide_id = %v, want slide_1", item["slide_id"])
-	}
-	gotPath := item["path"].(string)
-	if !filepath.IsAbs(gotPath) {
-		t.Fatalf("path = %v, want absolute path", gotPath)
-	}
-	if !strings.HasSuffix(gotPath, filepath.Join("shots", "pres_abc_slide_1.png")) {
-		t.Fatalf("path = %v, want shots/pres_abc_slide_1.png suffix", item["path"])
-	}
-	item2, _ := items[1].(map[string]interface{})
-	if item2["format"] != "jpeg" {
-		t.Fatalf("format = %v, want jpeg", item2["format"])
-	}
-	gotPath2 := item2["path"].(string)
-	if !filepath.IsAbs(gotPath2) {
-		t.Fatalf("path = %v, want absolute path", gotPath2)
-	}
-	if !strings.HasSuffix(gotPath2, filepath.Join("shots", "pres_abc_p002_slide_2.jpg")) {
-		t.Fatalf("path = %v, want shots/pres_abc_p002_slide_2.jpg suffix", item2["path"])
-	}
-
-	var body struct {
-		SlideIDs []string `json:"slide_ids"`
-	}
-	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
-		t.Fatalf("decode request body: %v", err)
-	}
-	if len(body.SlideIDs) != 1 || body.SlideIDs[0] != "slide_1" {
-		t.Fatalf("slide_ids = %#v, want [slide_1]", body.SlideIDs)
-	}
-}
-
-func TestSlidesScreenshotListBySlideNumber(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_abc/slide_images",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"slide_images": []map[string]interface{}{
-					{
-						"slide_number": 2,
-						"format":       1,
-						"data":         base64.StdEncoding.EncodeToString([]byte("png-bytes")),
-					},
-				},
-			},
-		},
-	}
-	reg.Register(stub)
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-number", "2",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var body struct {
-		SlideNumbers []int `json:"slide_numbers"`
-	}
-	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
-		t.Fatalf("decode request body: %v", err)
-	}
-	if len(body.SlideNumbers) != 1 || body.SlideNumbers[0] != 2 {
-		t.Fatalf("slide_numbers = %#v, want [2]", body.SlideNumbers)
-	}
-	path := filepath.Join(dir, defaultSlidesScreenshotDir, "pres_abc_p002.png")
-	if _, err := os.ReadFile(path); err != nil {
-		t.Fatalf("read screenshot without slide_id: %v", err)
-	}
-}
-
-func TestSlidesScreenshotAvoidsOverwritingExistingFile(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-	outputDir := filepath.Join(dir, "shots")
-	if err := os.MkdirAll(outputDir, 0o755); err != nil {
-		t.Fatalf("create output dir: %v", err)
-	}
-	existingPath := filepath.Join(outputDir, "pres_abc_p002.png")
-	if err := os.WriteFile(existingPath, []byte("existing"), 0o644); err != nil {
-		t.Fatalf("write existing screenshot: %v", err)
-	}
-
-	imageBytes := []byte("new-png")
-	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_abc/slide_images",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"slide_images": []map[string]interface{}{
-					{
-						"slide_number": 2,
-						"format":       1,
-						"data":         base64.StdEncoding.EncodeToString(imageBytes),
-					},
-				},
-			},
-		},
-	})
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-number", "2",
-		"--output-dir", "shots",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	gotExisting, err := os.ReadFile(existingPath)
-	if err != nil {
-		t.Fatalf("read existing screenshot: %v", err)
-	}
-	if string(gotExisting) != "existing" {
-		t.Fatalf("existing screenshot = %q, want unchanged", gotExisting)
-	}
-	newPath := filepath.Join(outputDir, "pres_abc_p002_2.png")
-	gotNew, err := os.ReadFile(newPath)
-	if err != nil {
-		t.Fatalf("read deduplicated screenshot: %v", err)
-	}
-	if string(gotNew) != string(imageBytes) {
-		t.Fatalf("deduplicated screenshot = %q, want %q", gotNew, imageBytes)
-	}
-	data := decodeShortcutData(t, stdout)
-	items, ok := data["screenshots"].([]interface{})
-	if !ok || len(items) != 1 {
-		t.Fatalf("screenshots = %#v, want one item", data["screenshots"])
-	}
-	item, _ := items[0].(map[string]interface{})
-	if !strings.HasSuffix(item["path"].(string), filepath.Join("shots", "pres_abc_p002_2.png")) {
-		t.Fatalf("path = %v, want shots/pres_abc_p002_2.png suffix", item["path"])
-	}
-}
-
-func TestSlidesScreenshotListRequiresSelector(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), "--slide-id or --slide-number is required") {
-		t.Fatalf("error = %v, want missing selector error", err)
-	}
-}
-
-func TestSlidesScreenshotRenderContentWritesFile(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-
-	content := `<slide xmlns="http://www.larkoffice.com/sml/2.0"><data></data></slide>`
-	if err := os.WriteFile(filepath.Join(dir, "slide.xml"), []byte(content), 0o644); err != nil {
-		t.Fatalf("write input xml: %v", err)
-	}
-	imageBytes := []byte("rendered-png")
-	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/slides_ai/v1/slide_image/render",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"slide_image": map[string]interface{}{
-					"slide_id":     "render_slide",
-					"slide_number": 1,
-					"format":       1,
-					"data":         base64.StdEncoding.EncodeToString(imageBytes),
-				},
-			},
-		},
-	}
-	reg.Register(stub)
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--content", "@slide.xml",
-		"--output-dir", "shots",
-		"--output-name", "preview",
-		"--as", "user",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	path := filepath.Join(dir, "shots", "preview.png")
-	gotBytes, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("read rendered screenshot: %v", err)
-	}
-	if string(gotBytes) != string(imageBytes) {
-		t.Fatalf("written bytes = %q, want %q", gotBytes, imageBytes)
-	}
-	if strings.Contains(stdout.String(), base64.StdEncoding.EncodeToString(imageBytes)) {
-		t.Fatalf("stdout leaked base64 image data: %s", stdout.String())
-	}
-
-	var body struct {
-		Content string `json:"content"`
-	}
-	if err := json.Unmarshal(stub.CapturedBody, &body); err != nil {
-		t.Fatalf("decode request body: %v", err)
-	}
-	if body.Content != content {
-		t.Fatalf("content = %q, want input XML", body.Content)
-	}
-
-	data := decodeShortcutData(t, stdout)
-	items, ok := data["screenshots"].([]interface{})
-	if !ok || len(items) != 1 {
-		t.Fatalf("screenshots = %#v, want one item", data["screenshots"])
-	}
-	item, _ := items[0].(map[string]interface{})
-	if !strings.HasSuffix(item["path"].(string), filepath.Join("shots", "preview.png")) {
-		t.Fatalf("path = %v, want shots/preview.png suffix", item["path"])
-	}
-}
-
-func TestSlidesScreenshotRenderRejectsSlideSelectors(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--content", `<slide xmlns="http://www.larkoffice.com/sml/2.0"><data></data></slide>`,
-		"--slide-id", "slide_1",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), "--content cannot be used with --slide-id or --slide-number") {
-		t.Fatalf("error = %v, want content/slide selector conflict", err)
-	}
-}
-
-func TestSlidesScreenshotRenderRejectsListOnlyFlags(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--content", `<slide xmlns="http://www.larkoffice.com/sml/2.0"><data></data></slide>`,
-		"--presentation", "pres_abc",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), "--presentation cannot be used with --content") {
-		t.Fatalf("error = %v, want presentation/content conflict", err)
-	}
-}
-
-func TestSlidesScreenshotDryRunSelectsListOrRenderAPI(t *testing.T) {
-	t.Run("list", func(t *testing.T) {
-		f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-		err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-			"+screenshot",
-			"--presentation", "pres_abc",
-			"--slide-number", "2",
-			"--dry-run",
-			"--as", "user",
-		})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		out := stdout.String()
-		if !strings.Contains(out, "/xml_presentations/pres_abc/slide_images") {
-			t.Fatalf("dry-run missing list endpoint: %s", out)
-		}
-		if !strings.Contains(out, "slide_numbers") {
-			t.Fatalf("dry-run missing slide_numbers body: %s", out)
-		}
-	})
-
-	t.Run("render", func(t *testing.T) {
-		f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-		err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-			"+screenshot",
-			"--content", `<slide xmlns="http://www.larkoffice.com/sml/2.0"><data></data></slide>`,
-			"--dry-run",
-			"--as", "user",
-		})
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		out := stdout.String()
-		if !strings.Contains(out, "/slide_image/render") {
-			t.Fatalf("dry-run missing render endpoint: %s", out)
-		}
-		if !strings.Contains(out, "base64_output") {
-			t.Fatalf("dry-run missing base64 suppression note: %s", out)
-		}
-	})
-}
-
-func TestSlidesScreenshotRejectsBadOutputDir(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-id", "slide_1",
-		"--output-dir", "../outside",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error for unsafe output dir")
-	}
-	if !strings.Contains(err.Error(), "--output-dir invalid") {
-		t.Fatalf("error = %v, want output-dir validation", err)
-	}
-}
-
-func TestSlidesScreenshotNoImagesErrorIncludesRawDataAndLogID(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_abc/slide_images",
-		Headers: map[string][]string{
-			"Content-Type": {"application/json"},
-			"X-Tt-Logid":   {"log-123"},
-		},
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"unexpected": "shape",
-			},
-		},
-	})
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-id", "pJJ",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error type = %T, want typed problem", err)
-	}
-	if p.LogID != "log-123" {
-		t.Fatalf("log_id = %v, want log-123", p.LogID)
-	}
-	if !strings.Contains(p.Message, "unexpected:shape") {
-		t.Fatalf("message = %q, want raw_data summary", p.Message)
-	}
-}
-
-func TestSlidesScreenshotSlideNumberAPIErrorAddsHint(t *testing.T) {
-	dir := t.TempDir()
-	withSlidesTestWorkingDir(t, dir)
-
-	f, stdout, _, reg := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/slides_ai/v1/xml_presentations/pres_abc/slide_images",
-		Headers: map[string][]string{
-			"Content-Type": {"application/json"},
-			"X-Tt-Logid":   {"log-slide-number"},
-		},
-		Body: map[string]interface{}{
-			"code": 99992402,
-			"msg":  "field validation failed",
-		},
-	})
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-number", "25",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error type = %T, want typed problem", err)
-	}
-	if p.LogID != "log-slide-number" {
-		t.Fatalf("log_id = %v, want log-slide-number", p.LogID)
-	}
-	if !strings.Contains(p.Hint, "--slide-id") {
-		t.Fatalf("hint = %q, want --slide-id guidance", p.Hint)
-	}
-}
--- a/shortcuts/task/shortcuts.go
+++ b/shortcuts/task/shortcuts.go
@@ -242,6 +242,7 @@ func Shortcuts() []common.Shortcut {
 		GetMyTasks,
 		GetRelatedTasks,
 		SearchTask,
+		SubscribeTaskEvent,
 		UploadAttachmentTask,
 		CreateTasklist,
 		SearchTasklist,
--- a/shortcuts/task/task_search.go
+++ b/shortcuts/task/task_search.go
@@ -73,16 +73,12 @@ var SearchTask = common.Shortcut{
 		var rawItems []interface{}
 		var lastPageToken string
 		var lastHasMore bool
-		var notice string
 		currentBody := body
 		for page := 0; page < pageLimit; page++ {
 			data, err := callTaskAPITyped(runtime, http.MethodPost, "/open-apis/task/v2/tasks/search", nil, currentBody)
 			if err != nil {
 				return err
 			}
-			if notice == "" {
-				notice, _ = data["notice"].(string)
-			}
 			items, _ := data["items"].([]interface{})
 			rawItems = append(rawItems, items...)
 			lastHasMore, _ = data["has_more"].(bool)
@@ -119,9 +115,6 @@ var SearchTask = common.Shortcut{
 			"page_token": lastPageToken,
 			"has_more":   lastHasMore,
 		}
-		if notice != "" {
-			outData["notice"] = notice
-		}
 		runtime.OutFormat(outData, &output.Meta{Count: len(enriched)}, func(w io.Writer) {
 			if len(enriched) == 0 {
 				fmt.Fprintln(w, "No tasks found.")
--- a/shortcuts/task/task_search_test.go
+++ b/shortcuts/task/task_search_test.go
@@ -153,7 +153,6 @@ func TestSearchTask_DryRun(t *testing.T) {
 	}
 }

-// TestSearchTask_Execute verifies task search output, enrichment, and notices.
 func TestSearchTask_Execute(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -172,7 +171,6 @@ func TestSearchTask_Execute(t *testing.T) {
 						"code": 0,
 						"msg":  "success",
 						"data": map[string]interface{}{
-							"notice":     "The query is too long and has been truncated to the first 50 characters for search.",
 							"has_more":   false,
 							"page_token": "",
 							"items": []interface{}{
@@ -193,7 +191,7 @@ func TestSearchTask_Execute(t *testing.T) {
 					},
 				})
 			},
-			wantParts: []string{`"guid": "task-123"`, `"summary": "Search Result"`, `"notice": "The query is too long and has been truncated to the first 50 characters for search."`},
+			wantParts: []string{`"guid": "task-123"`, `"summary": "Search Result"`},
 		},
 		{
 			name: "fallback to app link",
--- a/shortcuts/task/task_subscribe_event.go
+++ b/shortcuts/task/task_subscribe_event.go
@@ -0,0 +1,40 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package task
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+var SubscribeTaskEvent = common.Shortcut{
+	Service:     "task",
+	Command:     "+subscribe-event",
+	Description: "subscribe to task events",
+	Risk:        "write",
+	Scopes:      []string{"task:task:read"},
+	AuthTypes:   []string{"user", "bot"},
+	HasFormat:   true,
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		return common.NewDryRunAPI().
+			POST("/open-apis/task/v2/task_v2/task_subscription").
+			Params(map[string]interface{}{"user_id_type": "open_id"})
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		params := map[string]interface{}{"user_id_type": "open_id"}
+		if _, err := callTaskAPITyped(runtime, http.MethodPost, "/open-apis/task/v2/task_v2/task_subscription", params, nil); err != nil {
+			return err
+		}
+
+		outData := map[string]interface{}{"ok": true}
+		runtime.OutFormat(outData, nil, func(w io.Writer) {
+			fmt.Fprintln(w, "✅ Task event subscription created successfully!")
+		})
+		return nil
+	},
+}
--- a/shortcuts/task/task_subscribe_event_test.go
+++ b/shortcuts/task/task_subscribe_event_test.go
@@ -0,0 +1,163 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package task
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/shortcuts/common"
+)
+
+func TestSubscribeTaskEvent(t *testing.T) {
+	tests := []struct {
+		name      string
+		mode      string
+		args      []string
+		register  func(*httpmock.Registry)
+		wantErr   bool
+		wantParts []string
+	}{
+		{
+			name: "execute json (user identity)",
+			mode: "execute",
+			args: []string{"+subscribe-event", "--as", "user", "--format", "json"},
+			register: func(reg *httpmock.Registry) {
+				reg.Register(&httpmock.Stub{
+					Method: "POST",
+					URL:    "/open-apis/task/v2/task_v2/task_subscription",
+					Body: map[string]interface{}{
+						"code": 0,
+						"msg":  "success",
+						"data": map[string]interface{}{},
+					},
+				})
+			},
+			wantParts: []string{`"ok": true`},
+		},
+		{
+			name: "execute json (bot identity)",
+			mode: "execute",
+			args: []string{"+subscribe-event", "--as", "bot", "--format", "json"},
+			register: func(reg *httpmock.Registry) {
+				reg.Register(&httpmock.Stub{
+					Method: "POST",
+					URL:    "/open-apis/task/v2/task_v2/task_subscription",
+					Body: map[string]interface{}{
+						"code": 0,
+						"msg":  "success",
+						"data": map[string]interface{}{},
+					},
+				})
+			},
+			wantParts: []string{`"ok": true`},
+		},
+		{
+			name: "execute api error",
+			mode: "execute",
+			args: []string{"+subscribe-event", "--as", "bot", "--format", "json"},
+			register: func(reg *httpmock.Registry) {
+				reg.Register(&httpmock.Stub{
+					Method: "POST",
+					URL:    "/open-apis/task/v2/task_v2/task_subscription",
+					Body: map[string]interface{}{
+						"code": 401,
+						"msg":  "Unauthorized",
+						"error": map[string]interface{}{
+							"log_id": "test-log-id",
+						},
+					},
+				})
+			},
+			wantErr:   true,
+			wantParts: []string{"Unauthorized"},
+		},
+		{
+			name:      "dry run",
+			mode:      "dryrun",
+			wantParts: []string{"POST /open-apis/task/v2/task_v2/task_subscription"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			switch tt.mode {
+			case "execute":
+				f, stdout, _, reg := taskShortcutTestFactory(t)
+				warmTenantToken(t, f, reg)
+				if tt.register != nil {
+					tt.register(reg)
+				}
+
+				err := runMountedTaskShortcut(t, SubscribeTaskEvent, tt.args, f, stdout)
+				if tt.wantErr {
+					if err == nil {
+						t.Fatal("expected error, got nil")
+					}
+					out := err.Error()
+					for _, want := range tt.wantParts {
+						if !strings.Contains(out, want) {
+							t.Fatalf("error missing %q: %s", want, out)
+						}
+					}
+					return
+				}
+				if err != nil {
+					t.Fatalf("runMountedTaskShortcut() error = %v", err)
+				}
+
+				out := stdout.String()
+				outNorm := strings.ReplaceAll(out, `":"`, `": "`)
+				for _, want := range tt.wantParts {
+					if !strings.Contains(out, want) && !strings.Contains(outNorm, want) {
+						t.Fatalf("output missing %q: %s", want, out)
+					}
+				}
+			case "dryrun":
+				runtime := common.TestNewRuntimeContextWithIdentity(&cobra.Command{Use: "test"}, taskTestConfig(t), "user")
+				out := SubscribeTaskEvent.DryRun(nil, runtime).Format()
+				for _, want := range tt.wantParts {
+					if !strings.Contains(out, want) {
+						t.Fatalf("dry run output missing %q: %s", want, out)
+					}
+				}
+			}
+		})
+	}
+}
+
+// TestSubscribeTaskEvent_MalformedResponse covers the parse-response arm: a 200
+// with an unparseable body surfaces a typed internal invalid_response error
+// (exit 5).
+func TestSubscribeTaskEvent_MalformedResponse(t *testing.T) {
+	f, stdout, _, reg := taskShortcutTestFactory(t)
+	warmTenantToken(t, f, reg)
+
+	reg.Register(&httpmock.Stub{
+		Method:  "POST",
+		URL:     "/open-apis/task/v2/task_v2/task_subscription",
+		Status:  200,
+		RawBody: []byte("{not-json"),
+	})
+
+	args := []string{"+subscribe-event", "--as", "bot", "--format", "json"}
+	err := runMountedTaskShortcut(t, SubscribeTaskEvent, args, f, stdout)
+
+	var ie *errs.InternalError
+	if !errors.As(err, &ie) {
+		t.Fatalf("err = %T, want *errs.InternalError; err = %v", err, err)
+	}
+	if ie.Subtype != errs.SubtypeInvalidResponse {
+		t.Errorf("subtype = %q, want %q", ie.Subtype, errs.SubtypeInvalidResponse)
+	}
+	if got := output.ExitCodeOf(err); got != output.ExitInternal {
+		t.Errorf("exit code = %d, want %d", got, output.ExitInternal)
+	}
+}
--- a/shortcuts/task/task_tasklist_search.go
+++ b/shortcuts/task/task_tasklist_search.go
@@ -70,16 +70,12 @@ var SearchTasklist = common.Shortcut{
 		var rawItems []interface{}
 		var lastPageToken string
 		var lastHasMore bool
-		var notice string
 		currentBody := body
 		for page := 0; page < pageLimit; page++ {
 			data, err := callTaskAPITyped(runtime, http.MethodPost, "/open-apis/task/v2/tasklists/search", nil, currentBody)
 			if err != nil {
 				return err
 			}
-			if notice == "" {
-				notice, _ = data["notice"].(string)
-			}
 			items, _ := data["items"].([]interface{})
 			rawItems = append(rawItems, items...)
 			lastHasMore, _ = data["has_more"].(bool)
@@ -122,9 +118,6 @@ var SearchTasklist = common.Shortcut{
 			"page_token": lastPageToken,
 			"has_more":   lastHasMore,
 		}
-		if notice != "" {
-			outData["notice"] = notice
-		}
 		runtime.OutFormat(outData, &output.Meta{Count: len(tasklists)}, func(w io.Writer) {
 			if len(tasklists) == 0 {
 				fmt.Fprintln(w, "No tasklists found.")
--- a/shortcuts/task/task_tasklist_search_test.go
+++ b/shortcuts/task/task_tasklist_search_test.go
@@ -126,7 +126,6 @@ func TestSearchTasklist_DryRun(t *testing.T) {
 	}
 }

-// TestSearchTasklist_Execute verifies tasklist search output, enrichment, and notices.
 func TestSearchTasklist_Execute(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -145,7 +144,6 @@ func TestSearchTasklist_Execute(t *testing.T) {
 						"code": 0,
 						"msg":  "success",
 						"data": map[string]interface{}{
-							"notice":     "The query is too long and has been truncated to the first 50 characters for search.",
 							"has_more":   false,
 							"page_token": "",
 							"items":      []interface{}{map[string]interface{}{"id": "tl-123"}},
@@ -164,7 +162,7 @@ func TestSearchTasklist_Execute(t *testing.T) {
 					},
 				})
 			},
-			wantParts: []string{`"guid": "tl-123"`, `"name": "Q2 Plan"`, `"notice": "The query is too long and has been truncated to the first 50 characters for search."`},
+			wantParts: []string{`"guid": "tl-123"`, `"name": "Q2 Plan"`},
 		},
 		{
 			name: "fallback on detail error",
--- a/shortcuts/vc/vc_search.go
+++ b/shortcuts/vc/vc_search.go
@@ -236,9 +236,6 @@ var VCSearch = common.Shortcut{
 			"has_more":   data["has_more"],
 			"page_token": data["page_token"],
 		}
-		if notice, _ := data["notice"].(string); notice != "" {
-			outData["notice"] = notice
-		}
 		hasMore, _ := data["has_more"].(bool)
 		runtime.OutFormat(outData, &output.Meta{Count: len(items)}, func(w io.Writer) {
 			if len(items) == 0 {
--- a/Show More
+++ b/Show More