feat(msgcrypto): 新增 safechat 消息加解密与 vendorAuthCode 客户端

.changes/1050-shortcut-functional-hardening.md

@@ -1,5 +0,0 @@
----
-category: Fixed
----
-
-- **Shortcut functional workflows** (#1050) — fixes truthful Drive push/sync previews, strict AITable write verification and deletion accounting, lossless Wiki feeds, and false-success handling across task, Contact, Minutes, and Wiki operations.

.changes/released/1.0.59-beta.4/1045-attendance-mail-shortcuts.md

@@ -1,14 +0,0 @@
----
-category: Changed
----
-
-- **Attendance and Mail Shortcuts** (#1045) — publishes only capabilities with
-  strict response, identity, pagination, and real-data verification while
-  retaining historical CLI discovery and argument compatibility for commands
-  that remain unavailable to agents. Mailbox auto-resolution now accepts both
-  reviewed string and object response shapes, and Attendance date ranges cover
-  the complete requested end date without dropping cross-midnight punches whose
-  actual check time is inside the requested range. The schedule query remains
-  CLI-compatible but is withheld from the Agent catalog because its downstream
-  service returns a successful process exit with a null body for both populated
-  and empty ranges.

.changes/released/1.0.59-beta.4/1058-chat-group-role-single-flag.md

@@ -1,5 +0,0 @@
----
-category: Changed
----
-
-- **Chat group roles** (#1058) — exposes the single-value `--role-id` flag for assigning one custom group role while preserving hidden `--role-ids` compatibility.

.changes/released/1.0.59-beta.4/976-recruit-job.md

@@ -1,5 +0,0 @@
----
-category: Added
----
-
-- **招聘职位管理** (#976) — 新增招聘职位列表、详情查询和职位创建命令。

.changes/released/1.0.59-beta.4/chat-user-mention-tokens.md

@@ -1,6 +0,0 @@
----
-category: Fixed
----
-
-- **Chat user mentions** — preserves literal `<@openDingTalkId>` tokens in current-user Markdown messages and rejects mismatches between message-body mentions and mention flags before sending.
-- **Chat direct media** — uses the IM upload target field for current-user direct file, audio, and video uploads, then uses the Chat receiver field for final message delivery.

.changes/released/1.0.59-beta.4/command-path-migration-governance.md

@@ -1,5 +0,0 @@
----
-category: Changed
----
-
-- **CLI compatibility governance** — adds a reviewed two-stage path for hiding retained legacy commands or optional `NoOpt=true` boolean flags from Help and Schema when their activated capability moves to a dedicated command, with legacy-leaf, complete parameter/constant mapping, durable runtime constant evidence, protected framework bridges, dry-run preservation, parameter-collision, and fail-closed required-parameter checks.

.changes/released/1.0.59-beta.4/oa-approval-list-by-admin.md

@@ -1,5 +0,0 @@
----
-category: Added
----
-
-- **OA admin approval query** — `oa approval list-by-admin` queries approval instances of a template with admin scope, with simple flags and an advanced `--request` mode; `startTime`/`endTime` use `yyyy-MM-dd HH:mm:ss` strings per the 2026-08 MCP contract update (ISO-8601 flag inputs auto-convert), and pageSize/time format are validated client-side with localized errors.

.github/workflows/ci.yml

@@ -512,12 +512,6 @@ jobs:
         if: steps.classify.outputs.changelog_only != 'true' && steps.classify.outputs.docs_only != 'true'
         run: node .github/reviewer-routing.test.js
 
-      - name: Test npm installer smoke (prune, backup, publish)
-        if: steps.classify.outputs.changelog_only != 'true' && steps.classify.outputs.docs_only != 'true'
-        env:
-          XDG_CONFIG_HOME: ""
-        run: node test/scripts/install_js_smoke.mjs
-
   test-focused:
     name: "Test (focused: ${{ matrix.shard }})"
     needs: lint
@@ -617,13 +611,7 @@ jobs:
 
       - name: Install archive tooling
         if: ${{ matrix.shard == 'release-scripts' && steps.select.outputs.affected == 'true' }}
-        run: |
-          if command -v zip >/dev/null && command -v unzip >/dev/null; then
-            echo "zip and unzip are already available"
-          else
-            sudo apt-get update
-            sudo apt-get install -y zip unzip
-          fi
+        run: sudo apt-get update && sudo apt-get install -y zip unzip
 
       - name: Test shard with Race Detection
         if: ${{ steps.select.outputs.affected == 'true' }}
@@ -763,13 +751,7 @@ jobs:
           go-version-file: go.mod
 
       - name: Install archive tooling
-        run: |
-          if command -v zip >/dev/null && command -v unzip >/dev/null; then
-            echo "zip and unzip are already available"
-          else
-            sudo apt-get update
-            sudo apt-get install -y zip unzip
-          fi
+        run: sudo apt-get update && sudo apt-get install -y zip unzip
 
       - name: Test release scripts
         shell: bash
@@ -1147,13 +1129,7 @@ jobs:
           go-version-file: go.mod
 
       - name: Install archive tooling
-        run: |
-          if command -v zip >/dev/null && command -v unzip >/dev/null; then
-            echo "zip and unzip are already available"
-          else
-            sudo apt-get update
-            sudo apt-get install -y zip unzip
-          fi
+        run: sudo apt-get update && sudo apt-get install -y zip unzip
 
       - name: Build
         run: make build
@@ -1204,13 +1180,7 @@ jobs:
           go-version-file: go.mod
 
       - name: Install archive tooling
-        run: |
-          if command -v zip >/dev/null && command -v unzip >/dev/null; then
-            echo "zip and unzip are already available"
-          else
-            sudo apt-get update
-            sudo apt-get install -y zip unzip
-          fi
+        run: sudo apt-get update && sudo apt-get install -y zip unzip
 
       - name: Run policy and shortcut coverage
         run: |
@@ -1291,13 +1261,7 @@ jobs:
 
       - name: Install archive tooling
         if: needs.lint.outputs.full_suite == 'true' && steps.baseline-cache.outputs.cache-hit != 'true'
-        run: |
-          if command -v zip >/dev/null && command -v unzip >/dev/null; then
-            echo "zip and unzip are already available"
-          else
-            sudo apt-get update
-            sudo apt-get install -y zip unzip
-          fi
+        run: sudo apt-get update && sudo apt-get install -y zip unzip
 
       - name: Run baseline unit tests with coverage
         if: steps.baseline-cache.outputs.cache-hit != 'true'

CONTRIBUTING.md

@@ -74,9 +74,9 @@ coverage is additionally selected for platform-sensitive code.
    `make authoritative-interface-integrity BASE_REF=<merge-base> STABLE_REF=<latest-GA-tag> CANDIDATE_REF=<candidate-sha>`.
    The Make target delegates to the authoritative wrapper; CI does not invoke a
    second comparator or the legacy fixture checker. See
-   [CLI Help / Schema compatibility migration governance](docs/cli-interface-flag-migrations.md)
+   [CLI flag compatibility migration governance](docs/cli-interface-flag-migrations.md)
    for the reviewed two-stage `pending` → `consumed` lifecycle.
-   Agent-visible flag or command-path migrations must also run
+   Agent-visible flag migrations must also run
    `make schema-compatibility BASE_REF=<merge-base> STABLE_REF=<latest-GA-tag> CANDIDATE_REF=<candidate-sha>`;
    it consumes the same base-owned ledger rather than a second exception list.
 5. Run `./scripts/policy/check-generated-drift.sh` when generated artifacts may

Formula/dingtalk-workspace-cli-beta.rb

@@ -1,33 +1,33 @@
 class DingtalkWorkspaceCliBeta < Formula
   desc "Automate DingTalk workspace tasks from the terminal (beta channel)"
   homepage "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli"
-  version "1.0.59-beta.4"
+  version "1.0.59-beta.3"
   license "Apache-2.0"
   keg_only "it is the beta channel and conflicts with dingtalk-workspace-cli"
 
   on_macos do
     if Hardware::CPU.arm?
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.4/dws-darwin-arm64.tar.gz"
-      sha256 "f788467e9979c70ef210b411ac915b1506ea77ffa496e26b53cfa99650158721"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.3/dws-darwin-arm64.tar.gz"
+      sha256 "9c99adcefd9104368eb443f0a1b4af8e7aceaa1ffdd4462e486854c1692bb6ce"
     else
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.4/dws-darwin-amd64.tar.gz"
-      sha256 "a01988709c0dc99dd5874859eb265ba08a6fda412a7ead8303c68e61d2a8b195"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.3/dws-darwin-amd64.tar.gz"
+      sha256 "f5cc8efb1f982d68ae549190fd683292359c2ab542b532fa52bb35e6b5c049af"
     end
   end
 
   on_linux do
     if Hardware::CPU.arm?
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.4/dws-linux-arm64.tar.gz"
-      sha256 "8e1a993b2137a082a8cc1d9535dfc2d7b3e4399c76d295840f9dc1f15cca7a0d"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.3/dws-linux-arm64.tar.gz"
+      sha256 "7a4efd04b417ce8013b1e431274b396179958da244164f59974358ba327ff093"
     else
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.4/dws-linux-amd64.tar.gz"
-      sha256 "26e4cd72cfb96b38ef808863391b81a5c45c3170bca56b5eac457fc601b000c5"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.3/dws-linux-amd64.tar.gz"
+      sha256 "90181e8f2e9010c1943a5773c3d45d7d3ac85d6bc93e18a9aaa7c69909e553d7"
     end
   end
 
   resource "skills" do
-    url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.4/dws-skills.zip"
-    sha256 "a75107bdc14b5476e097842acc92f798301d8ffb59de9ade01f863d166a89435"
+    url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.59-beta.3/dws-skills.zip"
+    sha256 "e7028914a4a826af9b18ed4922d68fa8f279473817fed4f305465bc8a7aad363"
   end
 
   def install

Makefile

@@ -10,7 +10,7 @@ SCHEMA_META_INDEX_OUTPUT ?= artifacts/schema_meta_index.gob
 POLICY_ENV = DWS_POLICY_TMPDIR="$(DWS_POLICY_TMPDIR)" GOTMPDIR="$(POLICY_GOTMPDIR)"
 GO_SOURCE_LIST = git ls-files -z --cached --others --exclude-standard -- '*.go'
 
-.PHONY: all help build rebuild test test-plan test-auth-legacy-compat lint format-check fmt policy edition-test interface-integrity authoritative-interface-integrity coverage-gate coverage-gate-platform update-interface-baseline reset-interface-baseline schema-compatibility skill-command-integrity skill-context-budget multi-im-skill-chain-integrity cli-smoke mock-mcp-smoke test-schema-agent-examples generate-schema fetch-mcp-metadata generate-schema-catalog package release release-pre release-stable changelog-pre changelog-stable publish-homebrew-formula setup-hooks
+.PHONY: all help build check-safechat test-safechat rebuild test test-plan test-auth-legacy-compat lint format-check fmt policy edition-test interface-integrity authoritative-interface-integrity coverage-gate coverage-gate-platform update-interface-baseline reset-interface-baseline schema-compatibility skill-command-integrity skill-context-budget multi-im-skill-chain-integrity cli-smoke mock-mcp-smoke test-schema-agent-examples generate-schema fetch-mcp-metadata generate-schema-catalog package release release-pre release-stable changelog-pre changelog-stable publish-homebrew-formula setup-hooks
 
 all: setup-hooks fmt lint build test rebuild
 
@@ -18,6 +18,8 @@ help:
 	@printf "Available targets:\n"
 	@printf "  make build         - Build the dws CLI binary\n"
 	@printf "  make test          - Run the Go test suite\n"
+	@printf "  make check-safechat - Compile and vet the SafeChat message-crypto backend (needs CGO)\n"
+	@printf "  make test-safechat - Run the message-crypto tests against the SafeChat backend\n"
 	@printf "  make test-plan     - Verify CI test and full-suite coverage package plans cover their scopes exactly once\n"
 	@printf "  make test-auth-legacy-compat - Run stable legacy authentication compatibility regressions\n"
 	@printf "  make lint          - Run formatting checks, go vet, and staticcheck\n"
@@ -52,6 +54,16 @@ build:
 rebuild:
 	@./scripts/dev/build.sh
 
+# No dws command imports internal/msgcrypto yet, so a tagged CLI build would
+# link nothing extra and look identical to the default binary. Gate the package
+# itself until a caller wires it in.
+check-safechat:
+	@CGO_ENABLED=1 $(GO) build -tags safechat ./internal/msgcrypto/...
+	@CGO_ENABLED=1 $(GO) vet -tags safechat ./internal/msgcrypto/...
+
+test-safechat:
+	@CGO_ENABLED=1 $(GO) test -count=1 -tags safechat ./internal/msgcrypto/...
+
 test:
 	@DWS_PACKAGE_VERSION="$(DWS_PACKAGE_VERSION)" $(GO) test -count=1 -timeout=10m ./...
 

README.md

@@ -210,7 +210,7 @@ The verifier uses isolated directories and does not replace the `dws` on the cur
 The upgrade process follows a two-phase atomic flow to ensure consistency:
 
 1. **Prepare** — downloads the platform-specific binary and skill packages to a temporary directory, verifies SHA256 checksums, and extracts/validates all files. If any step fails, the upgrade aborts without modifying the existing installation.
-2. **Apply** — only after all preparations succeed, the binary is replaced and skills are flattened into the canonical `~/.agents/skills` root. Agents classified by the pinned compatibility registry as supporting the universal root read it directly; other detected Agents receive links to the canonical copy, with a direct-copy fallback when links are unavailable. Older DWS-managed agent-specific copies are backed up and retired so the same Skill is not discovered twice.
+2. **Apply** — only after all preparations succeed, the binary is replaced and skills are flattened into detected agent-specific roots (for example `~/.codex/skills/dingtalk-chat`). `~/.agents/skills` is used only when no specific Agent is detected; once a specific root is active, older DWS-managed generic copies are backed up and retired so the same Skill is not discovered twice.
 
 A backup of the current version is automatically created before each upgrade. Use `dws upgrade --rollback` to restore the previous version if needed.
 
@@ -405,7 +405,7 @@ After installing, AI tools like Claude Code / Cursor can operate DingTalk direct
 curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install-skills.sh | sh
 ```
 
-> Installers use `$HOME/.agents/skills/` as the canonical global store, following the universal `.agents/skills` convention. Agents classified by the pinned compatibility registry as universal read that root directly; detected non-universal Agents receive links to it (or copies when links are unavailable). Multi layout is per-product siblings, while mono uses the `dws/` subdirectory.
+> Installers prefer detected agent-specific roots such as `$HOME/.codex/skills/`. They use `.agents/skills/` only as the generic fallback when no specific Agent is detected; multi layout is per-product siblings, while mono uses the `dws/` subdirectory.
 >
 > China users: prefix `DWS_GITEE_REPO` to use the Gitee mirror — see [China mirror](#china-mirror).
 
@@ -482,7 +482,7 @@ Env vars: `DWS_SKILL_MODE=mono|multi` (also honored by `install.sh` / `install.p
 <details>
 <summary><strong>Personal Event Subscription</strong> — real-time DingTalk messages for event-driven agents</summary>
 
-`dws event consume` subscribes as the currently logged-in user over a managed Stream WebSocket and emits each event as one NDJSON line on stdout. The public catalog covers scoped and all one-to-one/group messages, specified senders, read/recall/reaction events, group lifecycle events, and seven OA approval task/instance events.
+`dws event consume` subscribes as the currently logged-in user over a managed Stream WebSocket and emits each event as one NDJSON line on stdout. The public catalog covers scoped and all one-to-one/group messages, specified senders, read/recall/reaction events, group lifecycle events, and six OA approval task/instance events.
 
 The default `ndjson`, `json`, and `pretty` output preserves the transport envelope (`type`, `event_type`, string `data`, and `headers`) for existing scripts; `compact` retains its existing processor. Add `--flatten` to emit the stable top-level business fields used by Agent workflows. `--format` controls JSON serialization; `--flatten` controls the data structure and cannot be combined with `-f raw` or `--debug-raw-events`.
 
@@ -530,13 +530,12 @@ dws event consume user_im_group_disbanded --group <openConversationId> --flatten
 dws event +listen-im --kind sender --user <userId> \
   --events message,read,recall -f ndjson
 
-# Listen for all seven public OA approval events in one process
+# Listen for all six public OA approval events in one process
 dws event consume \
   user_oa_approval_task_created \
   user_oa_approval_task_finished \
   user_oa_approval_task_redirected \
   user_oa_approval_instance_started \
-  user_oa_approval_instance_cc \
   user_oa_approval_instance_terminated \
   user_oa_approval_instance_finished \
   --flatten -f ndjson

README_zh.md

@@ -476,7 +476,7 @@ multi setup 或 upgrade 后，DWS 会把官方 bundle 快照和统一所有权
 <details>
 <summary><strong>个人事件订阅</strong> — 实时接收钉钉消息，驱动事件触发的 Agent</summary>
 
-`dws event consume` 使用当前 OAuth 登录用户建立托管的 Stream WebSocket 长连接，并把每条事件以 NDJSON 一行输出到 stdout。当前公开目录覆盖指定范围和全量单聊/群消息、指定发送人、已读/撤回/表情回应、群生命周期，以及七个 OA 审批任务/实例事件。
+`dws event consume` 使用当前 OAuth 登录用户建立托管的 Stream WebSocket 长连接，并把每条事件以 NDJSON 一行输出到 stdout。当前公开目录覆盖指定范围和全量单聊/群消息、指定发送人、已读/撤回/表情回应、群生命周期，以及六个 OA 审批任务/实例事件。
 
 默认 `ndjson`、`json`、`pretty` 输出保留兼容 transport envelope（`type`、`event_type`、字符串 `data`、`headers`），`compact` 继续沿用原 processor。Agent 或新脚本显式加 `--flatten` 后，输出稳定的顶层业务字段。`--format` 控制 JSON 序列化，`--flatten` 控制数据结构，且不能与 `-f raw` 或 `--debug-raw-events` 同时使用。
 
@@ -524,13 +524,12 @@ dws event consume user_im_group_disbanded --group <openConversationId> --flatten
 dws event +listen-im --kind sender --user <userId> \
   --events message,read,recall -f ndjson
 
-# 一个进程监听全部七个公开 OA 审批事件
+# 一个进程监听全部六个公开 OA 审批事件
 dws event consume \
   user_oa_approval_task_created \
   user_oa_approval_task_finished \
   user_oa_approval_task_redirected \
   user_oa_approval_instance_started \
-  user_oa_approval_instance_cc \
   user_oa_approval_instance_terminated \
   user_oa_approval_instance_finished \
   --flatten -f ndjson

build/npm/package.json.tmpl

@@ -32,6 +32,6 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=16.7.0"
+    "node": ">=16"
   }
 }

cmd/interface-snapshot/main.go

@@ -157,16 +157,6 @@ func runCompare(args []string, stdout, stderr io.Writer) (bool, error) {
 		"",
 		"candidate flag migration manifest",
 	)
-	approvedCommandMigrationsPath := flags.String(
-		"approved-command-migrations",
-		"",
-		"merge-base-owned approved command migration manifest",
-	)
-	candidateCommandMigrationsPath := flags.String(
-		"candidate-command-migrations",
-		"",
-		"candidate command migration manifest",
-	)
 	if err := flags.Parse(args); err != nil {
 		return false, err
 	}
@@ -184,13 +174,8 @@ func runCompare(args []string, stdout, stderr io.Writer) (bool, error) {
 			"--approved-flag-migrations and --candidate-flag-migrations must be provided together",
 		)
 	}
-	if (*approvedCommandMigrationsPath == "") != (*candidateCommandMigrationsPath == "") {
-		return false, fmt.Errorf(
-			"--approved-command-migrations and --candidate-command-migrations must be provided together",
-		)
-	}
-	if (*approvedMigrationsPath != "" || *approvedCommandMigrationsPath != "") && (*basePath == "" || *stablePath == "") {
-		return false, fmt.Errorf("migration compare requires both --base and --stable")
+	if *approvedMigrationsPath != "" && (*basePath == "" || *stablePath == "") {
+		return false, fmt.Errorf("flag migration compare requires both --base and --stable")
 	}
 
 	current, err := readSnapshot(*currentPath)
@@ -212,39 +197,7 @@ func runCompare(args []string, stdout, stderr io.Writer) (bool, error) {
 	}
 
 	report := interfacesnapshot.CompareAll(current, references)
-	if *approvedCommandMigrationsPath != "" {
-		flagApproved := interfacesnapshot.FlagMigrationManifest{Version: interfacesnapshot.FlagMigrationManifestVersion, Migrations: []interfacesnapshot.FlagMigration{}}
-		flagCandidate := flagApproved
-		if *approvedMigrationsPath != "" {
-			flagApproved, err = readFlagMigrationManifest(*approvedMigrationsPath)
-			if err != nil {
-				return false, fmt.Errorf("read approved flag migrations: %w", err)
-			}
-			flagCandidate, err = readFlagMigrationManifest(*candidateMigrationsPath)
-			if err != nil {
-				return false, fmt.Errorf("read candidate flag migrations: %w", err)
-			}
-		}
-		commandApproved, readErr := readCommandMigrationManifest(*approvedCommandMigrationsPath)
-		if readErr != nil {
-			return false, fmt.Errorf("read approved command migrations: %w", readErr)
-		}
-		commandCandidate, readErr := readCommandMigrationManifest(*candidateCommandMigrationsPath)
-		if readErr != nil {
-			return false, fmt.Errorf("read candidate command migrations: %w", readErr)
-		}
-		report, err = interfacesnapshot.CompareAllWithInterfaceMigrations(
-			current,
-			references,
-			flagApproved,
-			flagCandidate,
-			commandApproved,
-			commandCandidate,
-		)
-		if err != nil {
-			return false, fmt.Errorf("validate interface migration lifecycle: %w", err)
-		}
-	} else if *approvedMigrationsPath != "" {
+	if *approvedMigrationsPath != "" {
 		approved, readErr := readFlagMigrationManifest(*approvedMigrationsPath)
 		if readErr != nil {
 			return false, fmt.Errorf("read approved flag migrations: %w", readErr)
@@ -281,15 +234,6 @@ func readFlagMigrationManifest(path string) (interfacesnapshot.FlagMigrationMani
 	return interfacesnapshot.ReadFlagMigrationManifest(file)
 }
 
-func readCommandMigrationManifest(path string) (interfacesnapshot.CommandMigrationManifest, error) {
-	file, err := os.Open(filepath.Clean(path))
-	if err != nil {
-		return interfacesnapshot.CommandMigrationManifest{}, err
-	}
-	defer file.Close()
-	return interfacesnapshot.ReadCommandMigrationManifest(file)
-}
-
 func validateHelpRendering(root *cobra.Command, snapshot interfacesnapshot.Snapshot) error {
 	for _, command := range snapshot.Commands {
 		path := strings.TrimPrefix(command.Path, "dws")
@@ -336,5 +280,5 @@ func readSnapshot(path string) (interfacesnapshot.Snapshot, error) {
 func printUsage(w io.Writer) {
 	fmt.Fprintln(w, "usage:")
 	fmt.Fprintln(w, "  interface-snapshot generate [--output FILE]")
-	fmt.Fprintln(w, "  interface-snapshot compare --current FILE [--base FILE] [--stable FILE] [--approved-flag-migrations FILE --candidate-flag-migrations FILE] [--approved-command-migrations FILE --candidate-command-migrations FILE]")
+	fmt.Fprintln(w, "  interface-snapshot compare --current FILE [--base FILE] [--stable FILE] [--approved-flag-migrations FILE --candidate-flag-migrations FILE]")
 }

cmd/interface-snapshot/main_test.go

@@ -166,102 +166,6 @@ func TestCrossPlatformCoverageRunCompareRequiresBothFlagMigrationInputs(t *testi
 	}
 }
 
-func TestCrossPlatformCoverageRunCompareCommandMigrationInputs(t *testing.T) {
-	dir := t.TempDir()
-	snapshotPath := writeSnapshot(t, dir, "snapshot.json", commandSnapshot("dws"))
-	emptyFlag := writeManifest(t, dir, "empty-flags.json", `{"version":1,"migrations":[]}`)
-	emptyCommand := writeManifest(t, dir, "empty-commands.json", `{"version":1,"migrations":[]}`)
-	invalid := writeManifest(t, dir, "invalid-commands.json", `{`)
-
-	var stdout, stderr bytes.Buffer
-	args := []string{
-		"compare",
-		"--current", snapshotPath,
-		"--base", snapshotPath,
-		"--stable", snapshotPath,
-		"--approved-flag-migrations", emptyFlag,
-		"--candidate-flag-migrations", emptyFlag,
-		"--approved-command-migrations", emptyCommand,
-		"--candidate-command-migrations", emptyCommand,
-	}
-	if exitCode := run(args, &stdout, &stderr); exitCode != 0 {
-		t.Fatalf("combined migration compare exit=%d stderr=%s", exitCode, stderr.String())
-	}
-	for _, test := range []struct {
-		name      string
-		approved  string
-		candidate string
-		want      string
-	}{
-		{"approved flag", invalid, emptyFlag, "read approved flag migrations"},
-		{"candidate flag", emptyFlag, invalid, "read candidate flag migrations"},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			stdout.Reset()
-			stderr.Reset()
-			testArgs := []string{
-				"compare", "--current", snapshotPath, "--base", snapshotPath, "--stable", snapshotPath,
-				"--approved-flag-migrations", test.approved,
-				"--candidate-flag-migrations", test.candidate,
-				"--approved-command-migrations", emptyCommand,
-				"--candidate-command-migrations", emptyCommand,
-			}
-			if exitCode := run(testArgs, &stdout, &stderr); exitCode != 2 || !strings.Contains(stderr.String(), test.want) {
-				t.Fatalf("combined flag error exit=%d stderr=%s", exitCode, stderr.String())
-			}
-		})
-	}
-
-	for _, test := range []struct {
-		name      string
-		approved  string
-		candidate string
-		want      string
-	}{
-		{"approved", invalid, emptyCommand, "read approved command migrations"},
-		{"candidate", emptyCommand, invalid, "read candidate command migrations"},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			stdout.Reset()
-			stderr.Reset()
-			testArgs := []string{
-				"compare", "--current", snapshotPath, "--base", snapshotPath, "--stable", snapshotPath,
-				"--approved-command-migrations", test.approved,
-				"--candidate-command-migrations", test.candidate,
-			}
-			if exitCode := run(testArgs, &stdout, &stderr); exitCode != 2 || !strings.Contains(stderr.String(), test.want) {
-				t.Fatalf("command manifest error exit=%d stderr=%s", exitCode, stderr.String())
-			}
-		})
-	}
-
-	stderr.Reset()
-	if exitCode := run([]string{
-		"compare", "--current", snapshotPath, "--base", snapshotPath,
-		"--approved-command-migrations", emptyCommand,
-	}, &stdout, &stderr); exitCode != 2 || !strings.Contains(stderr.String(), "provided together") {
-		t.Fatalf("one-sided command manifest exit=%d stderr=%s", exitCode, stderr.String())
-	}
-
-	if _, err := readCommandMigrationManifest(filepath.Join(dir, "missing.json")); err == nil {
-		t.Fatal("missing command migration manifest unexpectedly read")
-	}
-	if _, err := readCommandMigrationManifest(invalid); err == nil {
-		t.Fatal("invalid command migration manifest unexpectedly read")
-	}
-
-	pending := writeManifest(t, dir, "pending-command.json", commandMigrationManifestJSON("pending"))
-	consumed := writeManifest(t, dir, "consumed-command.json", commandMigrationManifestJSON("consumed"))
-	stderr.Reset()
-	if exitCode := run([]string{
-		"compare", "--current", snapshotPath, "--base", snapshotPath, "--stable", snapshotPath,
-		"--approved-command-migrations", pending,
-		"--candidate-command-migrations", consumed,
-	}, &stdout, &stderr); exitCode != 2 || !strings.Contains(stderr.String(), "validate interface migration lifecycle") {
-		t.Fatalf("command lifecycle error exit=%d stderr=%s", exitCode, stderr.String())
-	}
-}
-
 func TestCrossPlatformCoverageRunCompareRequiresBothReferencesForFlagMigrations(t *testing.T) {
 	dir := t.TempDir()
 	currentPath := writeSnapshot(t, dir, "current.json", commandSnapshot("dws"))
@@ -663,33 +567,6 @@ func flagMigrationManifestJSON(state string) string {
 }`, "STATE", state, 1)
 }
 
-func commandMigrationManifestJSON(state string) string {
-	return strings.Replace(`{
-  "version": 1,
-  "migrations": [{
-    "kind": "command_move",
-    "legacy": {
-      "command": "dws chat message old",
-      "before": {"present": true, "runnable": true},
-      "after": {"present": true, "runnable": true, "hidden": true}
-    },
-    "replacement": {
-      "command": "dws chat topic new",
-      "before": {"present": false},
-      "after": {"present": true, "runnable": true}
-    },
-    "schema": {
-      "product_id": "chat",
-      "source_tool_id": "chat.move",
-      "replacement_tool_id": "chat.move",
-      "parameters": []
-    },
-    "state": "STATE",
-    "reason": "reviewed command migration"
-  }]
-}`, "STATE", state, 1)
-}
-
 func hasFlag(flags []interfacesnapshot.Flag, name, flagType string) bool {
 	for _, flag := range flags {
 		if flag.Name == name && flag.Type == flagType {

docs/ci-pr-gates.md

@@ -184,11 +184,11 @@ candidate SHA。
 `check-interface-baseline.sh` 不再作为本地或 CI 的兼容性审批入口，也不能用于批准
 flag 迁移。
 
-Schema compatibility 使用同一组 base、stable、candidate refs，以及 base-owned flag
-与 command migration ledgers。merge-base-owned checker 分别规范化 merge-base 与
-stable 的完整 Schema，并让 candidate 对两份历史 contract 独立执行检查；它只把已通过
-Interface lifecycle 的 exact rename、command move 或 flag extraction 规范化到当前历史
-副本，不会维护第二份 allowlist，也不会放宽其他 Schema 历史字段。
+Schema compatibility 使用同一组 base、stable、candidate refs 和同一份 base-owned flag
+migration ledger。merge-base-owned checker 分别规范化 merge-base 与 stable 的完整
+Schema，并让 candidate 对两份历史 contract 独立执行检查；它只把已通过 Interface
+lifecycle 的 exact rename 规范化到当前历史副本，不会维护第二份 allowlist，也不会
+放宽其他 Schema 历史字段。
 
 For a release-seal branch that archives rendered fragments:
 

docs/cli-interface-flag-migrations.md

@@ -1,9 +1,7 @@
-# CLI Help / Schema 兼容迁移治理
+# CLI flag 兼容迁移治理
 
 本文定义一种受控迁移：保留旧 flag 的可执行兼容性，但把它从 Help 与 Agent Schema 中隐藏，并将新的规范 flag 设为唯一可见入口。迁移必须保持原 flag 的 requiredness：optional 只能迁到 optional，required 只能迁到 required。它只解决这一种精确变更，不是通用 breaking-change 豁免。
 
-同一套 base-owned lifecycle 也治理两类跨命令迁移：旧命令保留执行能力但从 Help / Schema 导航隐藏，并迁到新的公开命令路径；或把旧命令中的一个可选 flag 拆成新的专用命令。跨命令迁移只允许清单精确声明的 `command_became_hidden` / `flag_became_hidden` 及其 Schema 投影，不是通用 command-path breaking-change 豁免。
-
 同名 flag 的精确类型迁移属于另一类评审机制，只能进入
 `internal/interfacesnapshot/reviewed.go` 与 legacy smoke helper 的镜像表；flag rename
 只能进入本文的 JSON lifecycle ledger。一项迁移不得跨两种机制组合授权。
@@ -33,7 +31,7 @@ Smoke fixture，不参与迁移审批。
 同时提供 `--base` 与 `--stable`；核心 lifecycle 也拒绝缺失 stable 的非空清单，避免
 调用方因漏传历史参考而提前清理 consumed receipt。
 
-PR merge-base 同时拥有快照生成器、比较器和已审批清单。门禁用这套 base-owned helper 检查同一个已提交 candidate revision、merge-base 与 stable，candidate 不能通过修改自己的 Go 比较 helper 来放宽规则。candidate 中的清单只参与迁移状态流转，不能批准同一个 PR 引入的接口变化。首次引入 flag 机制时，merge-base 尚无迁移解析器；bootstrap 会用 merge-base 已有的 modern Interface Snapshot 做不带豁免的普通比较，并只接受 candidate 中逐字匹配的空 flag 清单。后续引入 command migration 扩展时，base 已拥有 flag comparator；bootstrap 仍只执行 base-owned 普通比较，不向旧 helper 传入新的 command ledger，因此允许随治理 PR 提交仍处于 before 的 pending 计划，也不会授予任何迁移豁免。bootstrap 无法让旧 helper 证明新治理实现本身正确，因此本治理 PR 的新 parser、lifecycle、launcher 与 hostile tests 仍是必须由真人评审的受保护策略变更；它们合入后才成为后续 PR 的 base-owned authority。
+PR merge-base 同时拥有快照生成器、比较器和已审批清单。门禁用这套 base-owned helper 检查同一个已提交 candidate revision、merge-base 与 stable，candidate 不能通过修改自己的 Go 比较 helper 来放宽规则。candidate 中的清单只参与迁移状态流转，不能批准同一个 PR 引入的接口变化。首次引入本机制时，merge-base 尚无迁移解析器；bootstrap 会用 merge-base 已有的 modern Interface Snapshot 做不带豁免的普通比较，并只接受 candidate 中逐字匹配的空清单，不会让 candidate 新增的 comparator 决定本 PR 是否兼容。bootstrap 无法让旧 helper 证明新治理实现本身正确，因此本治理 PR 的新 parser、lifecycle、launcher 与 hostile tests 仍是必须由真人评审的受保护策略变更；它们合入后才成为后续 PR 的 base-owned authority。
 
 这条边界保护比较规则和审批数据，不是任意代码沙箱。GitHub workflow / launcher 的变更仍由仓库保护规则和真人评审负责；candidate Cobra 构建也会执行 candidate 代码，因此对同一 runner 上的主动恶意代码，需要独立进程或文件系统隔离，不能把本门禁描述成已经解决。
 
@@ -41,55 +39,10 @@ PR merge-base 同时拥有快照生成器、比较器和已审批清单。门禁
 
 ```text
 scripts/policy/interface-migrations/approved-flag-migrations-v1.json
-scripts/policy/interface-migrations/approved-command-migrations-v1.json
 ```
 
 清单使用严格 JSON 解析：版本、字段名大小写、JSON 值类型、命令路径和 flag 名都必须精确；拒绝重复键、未知键、scalar `null` 与尾随 JSON 值，`reason` 不能为空；禁止 `*`、`?`、前缀规则或其他 wildcard。清单中的 `pending` 记录只记录已评审计划，并授权其精确列出的后续产品迁移；候选与 merge-base 仍必须精确匹配 `before`，不能授权同一个提交中的接口变化，也不能作为其他命令或参数的通配豁免。
 
-## 跨命令迁移原语
-
-`approved-command-migrations-v1.json` 只接受两种 `kind`：
-
-| kind | CLI after 状态 | Schema 允许的精确投影 |
-|---|---|---|
-| `command_move` | legacy 命令仍 runnable、由 visible 变 hidden；replacement 由 absent 变 visible runnable | 同一 stable tool identity 的 `primary_cli_path` 改到 replacement；只允许清单列出的参数改名，参数类型、property、requiredness、default 等必须等价 |
-| `flag_extraction` | legacy 命令保持 visible runnable；指定 legacy flag 仍可执行但由 visible 变 hidden；replacement 由 absent 变 visible runnable | source tool 只删除指定参数；replacement tool 必须位于精确的新路径，并保持 source 的 interface 与 safety identity；清单必须完整列出每个 source 参数到 replacement 参数或常量 property 的承接关系 |
-
-`command_move` 只能隐藏没有子命令的 legacy leaf，且 legacy 与 replacement
-不得互为祖先路径；整棵命令树的迁移需要单独设计逐叶治理，不能复用这一原语。
-稳定 Schema tool 可以继续接受普通的 optional 参数新增，但不得借路径迁移引入清单未登记的
-`required`、`cli_required` 或 `required_when` 参数；参数改名的目标也不得与历史
-Schema 中已有的其他参数重名，避免把两个历史参数静默合并。`flag_extraction` 只接受
-optional bool legacy flag，不能隐藏仍由 Cobra hard-required 的参数。它必须对 source tool
-的全部历史参数逐项声明：普通参数使用精确 `from` → `to`（同名也必须显式写出），且恰好
-一个与 legacy flag 同名的 `from` 使用 `replacement_constant`，不得同时声明 `to`；所有
-`from` 与 replacement 参数/property 目标必须唯一。legacy bool flag 的 `no_opt` 必须等于
-常量布尔值的字符串形式。v1 只治理 optional bool flag 的 `NoOpt=true` 激活分支，因此
-`replacement_constant.value` 与 legacy `no_opt` 都必须是 `true`；negative flag、默认即
-`true` 或固定 `false` 的语义不在本轮证明范围，必须另行设计，不能借本清单放行。
-
-`replacement_constant` 不是清单自报即可成立的例外。after 阶段的 Interface Snapshot
-必须从 replacement 命令的同一份框架运行时声明中捕获完全一致的 property/value，缺失、
-值不符或额外常量都会使 lifecycle 落入 partial。对于 #1054，`dws chat topic create`
-必须通过 `NewLeafCommand` 的 `ConstParams` 声明并实际注入
-`convThreadEnabled=true`；手写 `RunE` 固定值、Cobra annotation 或只改清单都不能提供这份
-同源证据，Snapshot 只读取 `corecmd` 包内私有注册表公开的只读副本。第一次向旧快照增加
-bool 常量证据属于 bootstrap；一旦任一历史快照已记录该
-证据，普通 Interface Compare 会持续要求 property/value 集合完全一致，因此 ledger 清理后
-删除、翻转或增加常量仍会阻塞。若 candidate 改动 command ledger，则
-`internal/corecmd/corecmd.go`、`internal/corecmd/interface_const_params.go` 与
-`internal/helpers/leaf.go` 三份执行/证据桥必须保持 base Git blob 不变；框架演进必须先用
-独立 PR 合入，不能和产品消费混在一起。
-
-replacement 必须保留 source 已发布的 dry-run 能力：历史 `dry_run` 非空时不得删除或改值；
-历史未声明时允许 replacement 新增 dry-run。这与普通 Schema 兼容规则保持同一单调边界。
-
-两种迁移都要求旧 argv 继续可执行。删除旧命令、删除旧 flag、把 legacy 改成 non-runnable、改变未登记的历史参数、改变 interface / safety，或只完成部分 before → after 转换都会 fail closed。命令别名会先规范到 reference 的 canonical path，但清单本身仍只能记录精确 canonical 命令，不能用 alias 或前缀扩大授权。
-
-跨命令清单复用下文同一套 `pending → consumed → cleanup` 生命周期。治理 PR 只能新增 `pending` 且产品 surface 必须仍是 before；后续产品 PR 才能一次性切到 after 并改为 `consumed`。candidate 新增的 pending 记录不能批准自己的改动。
-
-当前首批 pending 记录覆盖 `chat topic` 收口：`chat group create --thread` 拆到 `chat topic create`，以及 `chat message list-topic-replies` / `forward-topic` 迁到对应的 `chat topic` 命令。前一条完整登记 `name` / `type` / `users` 的同名承接，以及 `thread` → `convThreadEnabled=true` 的常量承接。产品 PR 消费这些记录时只能把三条 `state` 改为 `consumed`，不得改写其 before、after、Schema mapping、constant 或 reason。
-
 ## 两阶段迁移与回执清理
 
 每条迁移以 `(command, legacy flag, canonical flag)` 为唯一精确键，并经历以下生命周期：

docs/rfc-skill-installation-and-upgrade.md

@@ -54,8 +54,8 @@ DWS 对任何外部实现的持续兼容义务。后续设计以 DWS 自身约
 
 | 模式 | Agent 目录布局 | 选择方式 |
 |---|---|---|
-| multi（默认） | canonical `~/.agents/skills/dingtalk-*/`；非 universal Agent 使用链接或复制兼容层 | 默认；`dws skill setup --mode multi` |
-| mono（兼容） | canonical `~/.agents/skills/dws/`；非 universal Agent 使用链接或复制兼容层 | `dws skill setup --mode mono` 或安装器的 mono opt-in |
+| multi（默认） | `<agent-home>/dingtalk-*/` 与必选 `dingtalk-shared/` | 默认；`dws skill setup --mode multi` |
+| mono（兼容） | `<agent-home>/dws/` | `dws skill setup --mode mono` 或安装器的 mono opt-in |
 
 模式切换通过重新执行 setup 完成。安装 multi 前备份并移除 mono 的 `dws/`；安装
 mono 前只备份并移除能够证明由 DWS 管理的 multi 目录。两个方向都不提供隐式、
@@ -140,26 +140,10 @@ Agent 仍只需以 `SKILL.md` 发现和加载 Skill；统一元数据位于 Agen
 
 ## 8. Upgrade 与恢复语义
 
-升级器始终先发布 `~/.agents/skills` canonical 集合。固定兼容注册表中被分类为
-universal 的 Agent 不再保留 Agent 私有副本；检测到的
-非 universal Agent（如 Claude、OpenClaw、Hermes、Windsurf）使用指向 canonical
-的目录链接：npm 与 PowerShell 安装器在 Windows 上创建 junction，`dws upgrade` /
-`dws skill setup` 创建符号链接（`os.Symlink`）。链接不可用时回退为内容完整的
-直接复制，包括未开启开发者模式、因而无法创建符号链接的 Windows。
-自定义 `CODEX_HOME`、`CLAUDE_CONFIG_DIR`、`HERMES_HOME`、`AUTOHAND_HOME`、
-`GROK_HOME`、`VIBE_HOME`、`XDG_CONFIG_HOME` 与 OpenClaw 历史目录 `.clawdbot`、
-`.moltbot` 必须按 Agent 实际优先级解析。
+升级器对每个 Agent 目标执行：
 
-Agent 兼容矩阵以 `vercel-labs/skills` 的 `agents.ts` 与 `installer.ts`（基准提交
-`c6f69c6`）为契约：76 个 ID 必须完整登记，其中 19 个 universal、57 个
-non-universal。`eve`、`promptscript` 没有全局目录，因此全局安装时跳过；多个 Agent
-解析到同一个 XDG 目录时按最终绝对路径去重（Windows 大小写不敏感）。DWS 额外支持
-Qoderwork（按 non-universal Agent 建立兼容链接）；旧版使用的 `.github/skills`、
-`.amp/skills`、`.cline/skills` 与
-`.windsurf/skills` 仅作为可恢复迁移清理目标，不计入上游 Agent 枚举。
-对 universal Agent，上游 installer 的 global 模式明确选择 canonical 并跳过
-Agent 私有 global 目录；注册表中的 `globalSkillsDir` 仍用于识别和退役历史 native
-路径，不作为 universal symlink 模式的发布目标。
+- 先探测具体 Agent home；只在没有任何具体 Agent 时使用 `~/.agents/skills` 通用 fallback；
+- 具体 Agent 安装成功后，将 `~/.agents/skills` 中旧的 DWS 受管副本可恢复地迁入备份，避免 Codex 等同时扫描两个根目录时重复发现同名 Skill；
 
 1. 只读计算对面布局、过期受管 Skill 和同名官方 Skill；
 2. 在目标文件系统的 staging 中复制完整新集合；
@@ -167,14 +151,6 @@ Agent 私有 global 目录；注册表中的 `globalSkillsDir` 仍用于识别
 4. 逐项发布 staging；任一发布失败时删除已发布的新目录，并逆序恢复该目标的全部旧目录；
 5. 仅在没有目标失败且至少一个目标成功时更新状态快照。
 
-旧集合可能位于外部卷或自定义 Agent 根，而备份固定写入
-`~/.dws/skill-backups`。因此备份与反向恢复统一采用 rename-first：同卷直接原子
-rename；遇到跨文件系统错误时，在目标所在文件系统创建临时 staging，词法复制并
-保留目录/文件权限、普通文件、符号链接及 dangling symlink，校验路径类型、目录项、
-文件大小与 SHA256、链接目标后，再将 staging 原子 rename 为正式目标。正式目标
-再次校验成功后才删除源路径。复制、校验或发布失败时保留源并清理 staging；源删除
-失败时允许源与正式目标同时存在，但必须返回明确错误，不能报告成功。
-
 Go upgrade 当前提供 **单 Agent 目标级事务恢复**：复制失败发生在旧目录移动前；
 备份中途失败会恢复此前已移动的目录；发布中途失败会恢复该目标的完整旧集合。不同
 Agent 目标仍彼此独立，一个目标失败不会回滚此前已经成功升级的其他目标，这与
@@ -183,31 +159,11 @@ Agent 目标仍彼此独立，一个目标失败不会回滚此前已经成功
 ## 9. 备份合同
 
 - 路径：`~/.dws/skill-backups/<UTC 时间戳>/...`；
-- 主要操作：同一文件系统内使用 rename 移动；跨文件系统使用目标卷 staging 的
-  copy → verify → publish → remove 回退；
+- 主要操作：同一文件系统内使用 rename 移动；
 - 失败语义：备份失败时原目录保持不变，目标安装失败；
-- 恢复语义：反向恢复使用相同回退；若删除备份源失败，原路径和备份可同时存在，
-  但恢复必须失败并明确提示两份均被保留；
 - 可见性：计划和执行日志显示原路径与备份路径；
 - 保留策略：自动修剪，仅保留最近 5 批。
 
-跨卷回退只有 staging → 正式目标的发布 rename 是原子的，整次迁移不是跨文件系统
-原子事务；该边界由“发布前不删源、发布后再次校验、删除失败保留两份”补偿。Shell
-入口继续使用系统 `mv` 的跨文件系统复制/删除能力；Go、npm 与 PowerShell 显式实现
-上述验证和失败合同。
-
-原子 no-replace 发布（Linux `RENAME_NOREPLACE`、Darwin `RENAME_EXCL`）依赖底层文件
-系统支持：`rename(2)` 只列出 ext4、btrfs、tmpfs 与 cifs，因此 NFS、FUSE 与
-overlayfs 家目录会以 `EINVAL` 拒绝该 flag。这些文件系统不得让安装整体失败，而是降级
-为原子占位发布：目录目标用 `mkdir` 认领（已占用即 `EEXIST`，认领期间目标始终被本事务
-持有，源子项逐个移入认领目录，最终以 rename 覆盖仅属于本事务的空认领或直接移入）；
-普通文件目标用硬链接占位（同样以 `EEXIST` 拒绝已占用路径）后删除源。任何一步失败都会
-回迁已移动的子项并只撤销本事务的占位，被并发创建的对象（文件、符号链接或目录）既不会
-被覆盖，也不会被链接进内部。逐子项移动路径不是全量原子可见（降级文件系统上的可接受
-边界），但不覆盖契约在所有平台保持不变。Windows `MoveFile` 本身即拒绝已存在的目标，
-无需降级。npm 与 Shell 安装面遵循同一占位模型：目录用 `mkdir`/子项移动，链接直接在
-目标路径创建（symlink(2) 原子拒绝已占用路径）。
-
 备份是安装安全机制，不等于独立 rollback 产品。需要切回 mono 时重新运行
 `dws skill setup --mode mono`。
 
@@ -236,7 +192,6 @@ setup 在未显式指定 `--source` 时的本地回退缓存。
 | `scripts/install.ps1` | multi | 任一检测到的目标失败则脚本非零 |
 | `scripts/install-skills.sh` | multi | 任一检测到的目标失败则脚本非零 |
 | npm `install.js` | multi | 任一检测到的目标失败则 postinstall 失败 |
-| `scripts/install-event.sh` / `install-devapp.*` | 产品 multi 子集 | 同样使用 canonical 与 Agent 兼容层 |
 
 Homebrew 不直接向 Agent home 铺设 Skill；安装 CLI 后由 setup 执行相同流程。
 
@@ -254,12 +209,6 @@ Homebrew 不直接向 Agent home 铺设 Skill；安装 CLI 后由 setup 执行
 - 复制失败不留下 Agent 可见的残缺官方目录；
 - 普通 upgrade 恢复被删除的预制 Skill，并安装新增官方 Skill；
 - Windows、macOS、Linux 的路径和覆盖率门禁；
-- symlinked parent、npm/PowerShell 的 Windows junction、`dws upgrade` /
-  `dws skill setup` 的符号链接、链接失败复制回退与 broken link 修复；
-- Claude/Codex/Hermes 自定义根目录及 OpenClaw 历史目录优先级；
-- `CLAUDE_CONFIG_DIR`、`HERMES_HOME`、`XDG_CONFIG_HOME` 等自定义根跨文件系统时的
-  正向备份、反向恢复、普通链接及 dangling symlink 词法保留；
-- copy、verify、publish、remove 各阶段故障，以及非跨设备权限错误不得进入复制回退；
 - npm、Shell、PowerShell 与包管理器安装冒烟。
 
 ## 13. 后续演进

docs/shortcut-downstream-requirements/attendance.md

@@ -1,310 +0,0 @@
-# Attendance Shortcut 下游业务能力需求规格
-
-> 日期：2026-08-18
-> Rebased executable 基线：`69bda96e49c7a478729b5f9232677fd9055e5d7d`；最终 clean PR HEAD 的 live SHA 与发布复核结果记录在 PR 证据中
-> 对比基线：Lark CLI 1.0.87
-> 范围：Attendance Shortcut only；不改 DWS 产品 Skill 的路由、流程或业务逻辑。仓库 policy 强制的可见 Shortcut 自动生成块单独机械同步。
-
-## 1. 执行摘要
-
-- Attendance 共审核 35 个源码 Shortcut；8 个具备 Agent 公开条件，27 个保持 unavailable。为守住已发布 CLI 的 argv/Help 兼容，其中 11 个历史可见入口继续以 compatibility-visible 形式可发现，但仍从 Agent public Catalog 排除、保持 legacy 输出且不发布 Result/Pagination；其余 16 个保持 hidden。公开数量按「严格响应合同 + 稳定身份 + 安全真实 fixture」的发布门计算，不把空数组或仅退出码 0 计为通过。
-- 这 11 个 compatibility-visible 入口在完整 Schema 中保留历史 `availability=available` 与既有 workflow property，仅表示旧调用仍可执行；它们的 Shortcut 语义状态仍为 `public=false/unavailable`，默认 Shortcut 列表与 Agent public Catalog 均不发布。底层 MCP 字段名由 Execute 的显式 adapter 负责，不能在未经过版本化迁移时重定向已发布 Schema property。
-- `+check-result` 已覆盖 Lark CLI 当前唯一 Attendance 用户任务 `attendance user_tasks query`；DWS inventory 还包含打卡流水、审批、班次、规则、设置、假期和个人视图等更宽能力。排班查询入口虽然保留历史 CLI 兼容，但因 `DS-ATTENDANCE-008` 当前保持 Agent-unavailable。
-- 已确认 8 组下游需求：补卡规则详情返回空结果、报表合同不足、打卡结果分页缺少服务端确定终止证据、缺少安全可回收的管理员/写操作 fixture、6 个读场景缺少请求绑定字段或 nonempty/zero 双态 fixture、班次详情不回显稳定 ID、个人设置缺少逐场景权限发现与安全 fixture，以及排班查询对合法非空/空请求均返回 `exit 0 + literal null`。
-- 审批模板的同类型多模板问题已在上游修复：以 `processCode` 作为资源身份，`approveType` 只做请求绑定，并要求 `submitUrl` 非空。班次详情与个人设置仍有下游合同/权限前置，不能以请求 echo 或部分场景成功伪造整体可用。
-
-| ID | 优先级 | 类型 | 用户任务 | 当前状态 | 建议 Owner | 解锁的 Shortcut |
-|---|---|---|---|---|---|---|
-| `DS-ATTENDANCE-001` | P1 | business-service defect / contract insufficient | 搜索后读取补卡规则详情 | unavailable | Attendance Wukong 规则服务 | `+get-adjustment-rule` |
-| `DS-ATTENDANCE-002` | P1 | business-service defect / contract insufficient | 发现报表列并查询考勤/假期报表 | unavailable | Attendance 报表服务 / MCP adapter | `+list-report-columns`, `+query-report-data`, `+query-report-leave` |
-| `DS-ATTENDANCE-003` | P2 | contract insufficient | 可靠翻完打卡结果 | partial | Attendance 打卡查询服务 | `+check-result` 完整分页 |
-| `DS-ATTENDANCE-004` | P1 | tenant-or-fixture / permission | 验证考勤组、全局设置、余额和写操作 | blocked / unavailable | Attendance 产品测试基础设施 / 权限 Owner | 14 个读写 Shortcut |
-| `DS-ATTENDANCE-005` | P1 | response contract / tenant-or-fixture | 可验证地读取摘要、假期、签到和个人考勤 | blocked / unavailable | Attendance 查询服务 / 产品测试基础设施 | 6 个读 Shortcut |
-| `DS-ATTENDANCE-006` | P1 | response contract | 用搜索得到的班次 ID 精确读取同一班次详情 | unavailable | Attendance Wukong 班次服务 | `+get-class` |
-| `DS-ATTENDANCE-007` | P1 | capability / permission fixture | 可发现地读取全部个人设置场景 | blocked / unavailable | Attendance 设置服务 / 权限 Owner / 测试基础设施 | `+get-self-setting` |
-| `DS-ATTENDANCE-008` | P1 | response contract | 可验证地读取员工排班 | unavailable | Attendance Wukong 排班服务 / MCP adapter | `+get-schedule` |
-
-## 2. 用户任务与能力缺口总览
-
-| 用户任务 / Golden Route | DWS Shortcut | Lark CLI 对应 | 当前能力 | 缺口分类 | 临时处置 |
-|---|---|---|---|---|---|
-| 批量查询员工打卡结果 | `attendance +check-result` | `attendance user_tasks query` | covered；框架分页 token 由当前页保守派生 | contract insufficient | 声明 `Pagination(kind=cursor,cursor_parameter=offset)`；续页只放 `meta.pagination`，业务 `data` 仅含 `count/records` |
-| 搜索并读取班次 | `+search-class` → `+get-class` | 无同级入口 | partial | response contract | 只公开搜索；详情因不回显请求 classId 而 unavailable |
-| 搜索并读取补卡规则 | `+search-adjustment-rule` → `+get-adjustment-rule` | 无同级入口 | partial | business-service defect | 只公开搜索；详情 unavailable |
-| 发现字段并查询考勤报表 | `+list-report-columns` → `+query-report-data` | 无同级入口 | unavailable | contract insufficient | 两个入口均不进入 Agent Catalog；历史 `+query-report-data` 仅保留 CLI 兼容可见性 |
-| 查询假期报表 | `+query-report-leave` | 无同级入口 | unavailable | business-service defect | hidden/unavailable |
-| 搜索并读取考勤组 | `+search-group` → `+get-group` | 无同级入口 | blocked | tenant-or-fixture | 无已知非空安全 fixture；历史 `+search-group` 仅保留 CLI 兼容可见性，二者都不进入 Agent Catalog |
-| 查询企业全局设置和假期余额 | `+get-global-setting`, `+get-leave-balance` | 无同级入口 | blocked | permission / fixture | hidden/unavailable |
-| 查询个人设置 | `+get-self-setting` | 无同级入口 | partial | capability / permission fixture | 前五个场景已验证；全部场景发布前保持 Agent-unavailable，仅保留历史 CLI 兼容可见性 |
-| 查询员工排班 | `+get-schedule` | 无同级入口 | unavailable | response contract | 合法非空与保证零命中请求均收到 `exit 0 + literal null`；旧 CLI 兼容可见，但不进入 Agent Catalog |
-| 修改排班、班次、考勤组、假期和打卡结果 | 9 个写 Shortcut | 无同级入口 | unsafe to verify | tenant-or-fixture / contract insufficient | hidden/unavailable，不以 dry-run 记通过 |
-
-## 3. 下游需求明细
-
-### `DS-ATTENDANCE-001` — 让搜索得到的补卡规则可被稳定读取
-
-#### A. 用户任务与现状
-
-- 用户任务：先按名称浏览补卡规则，再用结果中的稳定主键读取完整规则。
-- canonical Shortcut：`attendance +search-adjustment-rule`、`attendance +get-adjustment-rule`。
-- atomic/raw route：`attendance adjustment search`、`attendance adjustment get`。
-- Exact Shortcut 与 atomic/raw 均使用搜索返回的同一候选主键；搜索明确成功且非空，详情调用明确 `success=true`，但 `result=null`。
-- 已排除上游空数组投影、整数解析和候选字段遗漏：多个可作为候选的数值字段均未得到非空详情；加班规则的相邻搜索→详情闭环正常。
-- 置信度：高。仍需下游确认“搜索 ID 与详情 ID 不同”还是详情服务未返回对象。
-- 安全证据句柄：`ATT-DETAIL-NULL-01`；仓库不保存 raw body、资源 ID 或 trace。
-
-#### B. 需要下游提供的合同
-
-- 明确 `get_adjustment_rule` 列表项中哪个字段是 `get_adjustment_rule_detail.adjustmentId` 的稳定主键；名称和类型必须在 Schema 中一致。
-- 对存在且有权限的规则返回 `success=true` 和非空对象 `result`，对象必须回显同一稳定规则 ID。
-- 对不存在、已删除、无权限、租户未开通分别返回稳定的 typed error；不得以 `success=true + result=null` 表示任一失败。
-- 如详情接口不受支持，提供可发现的 capability/feature 状态，或在搜索结果中返回足以完成详情任务的完整对象并声明字段稳定性。
-- 改动应 additive/versioned；旧字段保留兼容期，禁止静默改变现有 ID 的语义。
-
-#### C. 验收标准
-
-1. 创建或选择隔离规则，atomic search 非空并取得稳定 ID。
-2. atomic detail 和 exact `+get-adjustment-rule` 均返回同一 ID 的非空对象。
-3. 不存在 ID、无权限和已删除 ID 分别返回非零 typed error。
-4. 上游恢复公开后，搜索→详情 E2E 通过且仓库/远端无测试残留。
-
-#### D. 临时处置
-
-`+get-adjustment-rule` 保持 Agent-unavailable 并从公开 Catalog 排除；旧 CLI 入口仅为 argv/Help 兼容继续可见，`+search-adjustment-rule` 不再承诺详情入口可用。
-
-### `DS-ATTENDANCE-002` — 提供可发现、可验证的考勤报表合同
-
-#### A. 用户任务与现状
-
-- Golden Route：列出企业可查询报表列 → 选择稳定列 ID → 查询一批员工的列值；另一路径按假期类型查询时长报表。
-- canonical Shortcut：`+list-report-columns`、`+query-report-data`、`+query-report-leave`。
-- atomic/raw operations：`get_report_columns`、`get_report_columns_value`、`get_leave_time_by_leave_names`。
-- 观察：列发现与假期报表调用均退出码 0 且 payload 为 JSON `null`；使用未经验证的列 ID 查询列值仅得到显式空数组，不能证明列 ID 有效或查询正确。
-- 已排除上游投影丢失：原子调用本身即返回 `null`；Shortcut 现已拒绝把 `null` 当作合法空集合。
-- 置信度：高。权限/租户功能可能是触发条件，但接口没有返回可区分的状态。
-- 安全证据句柄：`ATT-REPORT-NULL-01`。
-
-#### B. 需要下游提供的合同
-
-- `get_report_columns`：成功时必须返回显式列数组；每项含稳定 `columnId`、显示名、值类型、单位、支持的日期/人员范围和是否需要管理员权限。
-- 合法无列必须是 `success=true + result=[]`；未开通、无权限和服务异常必须是不同 typed error，不得返回裸 `null`。
-- `get_report_columns_value`：返回值必须绑定请求的用户集合、列 ID 和时间范围；未知列返回 `COLUMN_NOT_FOUND`，不能静默得到空数组。
-- `get_leave_time_by_leave_names`：返回显式数组并包含稳定用户身份、假期类型标识、单位和数值；合法零记录为显式空数组。
-- 列值和假期报表若分页，必须提供 page/cursor、hasMore 和终止证据；批量用户存在部分失败时返回逐项 ledger 与整体 partial status。
-- 提供安全 capability discovery：租户是否开通、调用身份所需权限、最大用户数、最大列数、最大时间跨度。
-
-#### C. 验收标准
-
-1. 管理员测试租户中列发现有已知非空和明确空租户两组 E2E。
-2. 使用发现的同一 `columnId` 执行 atomic 与 exact Shortcut，返回与请求用户/区间绑定的非空值。
-3. 未知列、无权限、未开通和超范围分别产生稳定非零错误。
-4. 假期报表至少覆盖已知非空、合法空和未知假期类型。
-5. 分页/partial 分支和远端零残留通过。
-
-#### D. 临时处置
-
-三个报表 Shortcut 均保持 Agent-unavailable；其中历史 `+query-report-data` 只保留 CLI 兼容可见性。不得用 `null`、请求 echo 或未验证列产生的空数组标记 PASS。
-
-### `DS-ATTENDANCE-003` — 为打卡结果提供确定的分页终止证据
-
-#### A. 用户任务与现状
-
-- `+check-result` 已真实返回非空打卡结果并覆盖 Lark 任务；当前接口只接受 `offset/limit`，响应缺少稳定总量、hasMore 或 nextOffset。
-- DWS 只能在返回条数小于 limit 时证明结束；满页时保守输出 `meta.pagination.endpoint_exhausted=false` 和 `next_token=offset+count`，不能声明全量完成。`complete/nextOffset/limit` 仅保留在 legacy 兼容输出，unified 业务 `data` 不冒充分页协议。
-- 安全证据句柄：`ATT-CHECK-PAGE-01`。
-
-#### B. 需要下游提供的合同
-
-- 响应增加 `hasMore` 与 `nextOffset`，或 `totalCount`；这些字段必须与同一快照/排序一致。
-- 固定稳定排序键和同 offset 重放语义；说明并发新增/修改是否可能造成重复或漏项。
-- 空页且 `hasMore=true` 必须仍给出前进 token/offset；重复或倒退 offset 为协议错误。
-- 声明最大 limit、最大时间跨度和超过上限的 typed validation error。
-
-#### C. 验收标准与临时处置
-
-- 验收覆盖多页、最后一页、零记录、满页但仍有下一页、重复 token/offset 和并发变更。
-- 下游完成前，DWS 使用框架 `PaginationSpec` 和 `meta.pagination`表达保守续页；`cursor_parameter=offset` 表示调用者将 `next_token` 作为下一次 `--offset`，不表示下游已提供服务端 opaque cursor。满页始终不会被当作已完整。
-
-### `DS-ATTENDANCE-004` — 建立可回收的 Attendance 管理员与写操作测试资源
-
-#### A. 用户任务与现状
-
-- 受影响读取：`+search-group`、`+get-group`、`+get-group-filtered`、`+get-global-setting`、`+get-leave-balance`。
-- 受影响写入：`+import-schedule`、`+create-class`、`+update-class`、`+update-group-members`、`+create-group`、`+update-group`、`+update-leave-type`、`+save-leave-balance`、`+boss-check`。
-- 当前安全身份没有已知非空考勤组 fixture；全局设置被权限拒绝；余额读取没有可验证结果。写操作会影响真实员工规则，且部分资源缺删除/恢复能力，因此未执行生产数据写入。
-- 这不是对业务接口必然有 bug 的结论，而是可测试性和权限前置不足。
-- 安全证据句柄：`ATT-FIXTURE-GAP-01`。
-
-#### B. 需要的测试基础设施与合同
-
-- 提供隔离租户或专用测试组织，包含：管理员测试身份、两个无业务含义测试成员、一个可删除考勤组、一个可删除班次、一个可恢复假期类型、可控排班与打卡结果。
-- 只授予完成相应接口所需的最小 scopes；提供 capability discovery，区分权限不足、功能未开通和资源不存在。
-- 写接口返回稳定资源 ID、逐项结果、幂等/commit-unknown 语义；所有更新支持精确读回。
-- 为不可删除的企业设置提供 snapshot/restore 或专用 reset API；余额和 BOSS 改签必须能恢复原值。
-- Fixture 有 TTL、Owner 和自动清理告警；日志只保留受控 evidence handle，不输出业务内容或身份值。
-
-#### C. 验收标准与临时处置
-
-1. 考勤组搜索有已知非空和保证零命中；详情绑定同一 ID。
-2. create→get→update→restore/delete 覆盖班次、考勤组与排班。
-3. 成员、余额和打卡结果写入均有 before/after 精确读回并恢复原值。
-4. 未确认时远程写调用为 0；任一 partial/commit-unknown 非零退出。
-5. 测试结束远端和本地均零残留。
-
-在完整 fixture 到位前，相关 Shortcut 保持 hidden/unavailable。
-
-### `DS-ATTENDANCE-005` — 为 6 个读场景提供请求绑定与双态 fixture
-
-#### A. 用户任务与现状
-
-- `+get-summary`：真实响应只含统计项，不回显请求 user、period 或 statsType，上游无法证明返回属于哪个请求。
-- `+list-leave-types`：当前安全租户只有已知非空列表，而命令无筛选参数；不能用越界分页或错误请求伪造合法空结果。
-- `+get-leave-records`、`+get-checkin-record`：当前只取得合法空结果，缺少已知非空流水 fixture，无法排除响应投影或请求绑定错误。
-- `+my-attendance`、`+this-month`：上游已严格验证当前用户 profile 与每条打卡 ID，但当前期间仅有合法空数组，缺少同一身份下的已知非空 fixture。
-- 安全证据句柄：`ATT-READ-FIXTURE-GAP-01`；不保存 raw body、用户 ID 或打卡时间。
-
-#### B. 需要下游提供的合同与 fixture
-
-- 摘要响应回显稳定 userId、统计周期起止和 statsType，或返回可校验的请求摘要；任一字段不一致必须 typed failure。
-- 提供隔离的「无假期类型」测试租户，以显式 `success=true + result=[]` 证明 `+list-leave-types` 的合法空语义。
-- 提供可创建、读取并清理的假期变更流水、签到流水和打卡流水；每项都必须包含稳定 ID、请求用户和时间范围回显。
-- 为 nonempty 与 guaranteed-zero 提供独立 fixture；未知用户、无权限、未开通和合法空集合必须可区分，不得都返回裸 `null` 或无标识空数组。
-
-#### C. 验收标准与临时处置
-
-1. 每个集合叶子都用 exact Shortcut 和 owning atomic/raw 在同一参数下各证明一次已知非空和一次合法保证零命中。
-2. 非空项的稳定 ID、用户和时间绑定在两层结果中一致；空结果仍有显式业务 success 和正确集合容器。
-3. malformed/null/success=false/错身份/超范围均非零失败，且不会继续调用后续考勤接口。
-
-在上述证据完整前，6 个 Shortcut 均保持 Agent-unavailable，并仅为历史 argv/Help 保留 CLI 兼容可见性；已实现的严格校验不等于已获得发布证据。
-
-### `DS-ATTENDANCE-006` — 让班次详情回显可验证的稳定身份
-
-#### A. 用户任务与现状
-
-- 用户任务：先用 `+search-class` 浏览班次并取得稳定 `classId`，再用同一 ID 读取班次详情。
-- canonical Shortcut：`+search-class`、`+get-class`；atomic/raw route：`attendance class search`、`attendance class get`。
-- 在 clean discovery HEAD 上，搜索 exact/raw 均返回同一组非空正整数 `classId`；使用其中真实 ID 调用 raw detail，服务端返回 `success=true` 和非空 `shiftVO`，但对象没有 `id` 或 `classId`。
-- 上游不能把请求 ID 注入响应来伪造 readback，也不能仅凭“非空详情”证明详情属于请求资源。因此 `+get-class` 保持 unavailable。
-- 安全证据句柄：`ATT-CLASS-ID-ECHO-GAP-01`；不保存 raw body、资源 ID 或 trace。
-
-#### B. 需要下游提供的合同
-
-- `get_class_detail` 成功对象必须回显与请求精确一致的稳定 `id`/`classId`，类型与 `get_class_list` 列表身份字段一致。
-- 存在、已删除、不存在、无权限和租户未开通必须返回可区分的 typed terminal 状态；不得以非空但无身份对象表示可验证成功。
-- 明确班次 ID 的租户作用域、生命周期和搜索→详情一致性；如详情存在版本号，也应返回稳定版本字段以支持更新前读回。
-- 改动需 additive/versioned；现有详情业务字段保持兼容。
-
-#### C. 验收标准与临时处置
-
-1. exact/raw 搜索得到同一非空 `classId`，同 ID detail 均返回身份精确匹配的非空对象。
-2. 不存在、已删除和无权限分别非零 typed failure，不能成为 `success=true + result=null` 或无身份对象。
-3. 上游 `+get-class` 的 missing/false/null/malformed/wrong-ID 回归与真实 E2E 全部通过。
-
-下游补齐稳定 ID 回显前，`+get-class` 保持 hidden/unavailable；`+search-class` 仍可独立公开。
-
-### `DS-ATTENDANCE-007` — 提供个人设置逐场景 capability 与权限安全 fixture
-
-#### A. 用户任务与现状
-
-- `+get-self-setting` 公开参数包含 6 个场景。clean discovery HEAD 上，前 5 个场景的 exact/raw 均能精确绑定请求 userId、场景字段和已观测类型；`bossAttendStatNotify` 在两层均返回稳定业务错误 `NO_PERMISSION`。
-- 当前接口没有 capability discovery 告知调用身份可读哪些场景，也没有可安全授权的隔离 fixture。只验证 5/6 不能宣称整个公开枚举可用。
-- 这不是把权限错误误判为业务空结果；exact/raw 均非零退出。上游保留严格 user/scene/type 校验，但发布面整体降级。
-- 安全证据句柄：`ATT-SELF-SETTING-PERMISSION-GAP-01`。
-
-#### B. 需要下游提供的合同与 fixture
-
-- 提供 capability discovery，返回当前调用身份逐场景的 readable/forbidden/unsupported 状态、所需最小 scope/角色和租户功能开通状态。
-- 为 6 个场景提供字段名、类型、可空性和版本化语义；成功必须回显请求 userId，并明确返回对应场景字段。
-- 提供隔离测试身份或可撤销的临时最小权限授权 fixture，使 6 个场景均能完成 exact/raw 同场景验证；测试后权限必须回收。
-- 无权限、场景不支持、用户不存在和设置未配置必须返回不同 typed error；不得统一为 `null`、空对象或无标识空成功。
-
-#### C. 验收标准与临时处置
-
-1. capability discovery 与 6 个场景实际调用一致，不遗漏权限前置。
-2. 每个场景 exact/raw 的 userId、场景字段、类型和对象内容一致；`null`、错类型、错用户均非零。
-3. bogus user、invalid scene、无权限和未开通均返回可区分非零错误。
-4. 权限 fixture 全程最小化、可撤销，结束后无授权残留。
-
-能力发现和安全 fixture 到位前，`+get-self-setting` 保持 Agent-unavailable；旧 CLI 入口仅保留兼容可见性。
-
-### `DS-ATTENDANCE-008` — 让排班查询返回可判定的成功集合或业务错误
-
-#### A. 用户任务与现状
-
-- 用户任务：按员工和日期范围读取逐日排班，用稳定排班 ID 继续执行只读分析或受控的 BOSS 改签。
-- canonical Shortcut：`attendance +get-schedule`；owning raw route：`attendance-wukong/getScheduleByRange`。
-- 两次独立 clean HEAD 的真实验证中，已知历史非空区间与保证零命中的未来区间都得到同一结果：owning raw 进程退出 0，但响应为 literal `null`；Exact Shortcut 均以 `response_validation/empty_tool_response` 非零拒绝。
-- 这既不能证明排班非空，也不能证明合法为空。上游严格校验已避免把 `null` 投影成 `[]`，但在下游提供可判定合同前无法公开该能力。
-- 安全证据句柄：`ATT-SCHEDULE-NULL-01`；仓库不保存用户、日期、排班 ID、raw body 或 trace。
-
-#### B. 需要下游提供的合同
-
-- 成功查询必须返回显式排班数组；每项包含稳定非空排班 ID、请求用户身份、业务日期、班次身份和是否休息等字段。
-- 合法零结果必须返回 `success=true + result=[]`（或等价的已审核显式集合），不得以裸 `null`、缺字段或空 body 表示。
-- 无权限、用户不存在、租户未开通、日期范围非法和服务异常必须返回可区分的 typed nonzero error；不得继续用进程退出 0 掩盖业务失败。
-- 如服务存在分页，必须提供页大小、前进 token/页号、hasMore/total 和明确终止证据；同一请求的 item identity 不得跨页重复。
-
-#### C. 验收标准与临时处置
-
-1. 已知非空 fixture 的 raw 与 exact 均返回同一显式数组，稳定 ID 集合、用户和日期绑定一致。
-2. 保证零命中 fixture 的 raw 与 exact 均返回显式空数组，并有明确终止证据。
-3. `null`、缺集合、错型 item、重复/空 ID、错用户和越界日期全部非零；错误 reason 可稳定区分。
-4. 新 clean HEAD 完成 nonempty/zero 双层 E2E，仓库和远端均无测试残留。
-
-下游修复前，`+get-schedule` 保持 `public=false/unavailable`、legacy 输出且不发布 Result/Pagination；旧 CLI/Help/full Schema 仅为历史兼容继续可发现，不代表 Agent 可用。
-
-## 4. Lark 对齐与平台差异
-
-| Lark 用户任务 | 所需下游能力 | 可精确对齐 | 平台差异 | DWS 推荐结论 |
-|---|---|---|---|---|
-| `attendance user_tasks query` 查询打卡结果 | 现有 `query_check_result`；最好补分页终止证据 | yes，分页完整性 partial | Lark 当前没有同级的排班、规则、报表和企业设置任务 | 保留 `+check-result` 为主对齐入口，报告分页边界 |
-
-无法对齐的不是 DWS 缺入口，而是部分钉钉管理面缺少可验证下游合同或安全 fixture；不能为追求同名率伪造成功。
-
-## 5. 超越 Lark 的产品机会
-
-| 产品原生能力 | 所需下游支持 | 可形成的 DWS Shortcut | 安全/验证要求 | 优先级 |
-|---|---|---|---|---|
-| 异常考勤处置队列 | 稳定异常记录 ID、原因、关联审批、处理状态、分页和可恢复更正 | `attendance +exceptions` / `+resolve-exception` | 读写分离；更正确认；写后同 ID 终态读回；可恢复 | P2 |
-| 跨员工考勤汇总 | 可按组织/成员批量聚合迟到、缺卡、加班、请假并给出统计口径版本 | `attendance +team-summary` | 最小权限、聚合脱敏、口径版本、分页完整性 | P2 |
-| 规则影响预览 | 更新班次/考勤组/假期前返回受影响成员与日期范围，不提交写入 | `attendance +rule-impact-preview` | 只读、稳定影响计数、无副作用、与最终写请求同参数语义 | P1 |
-
-## 6. 无需下游变更的上游修复
-
-| Shortcut | 上游根因 | 已完成修复 | 回归证据 |
-|---|---|---|---|
-| 最终保留公开的 Attendance 集合查询 | 容错 projector 可能把缺字段、错型或坏元素投成 `[]` | 共享严格 success/result/collection 校验；显式空数组才合法；稳定 ID 和请求用户/时间/类型必须绑定 | 单元负向矩阵与最终 clean runtime tree 的 8 个公开入口真实 nonempty/zero、详情或模板 exact/raw 双层复核均完成 |
-| `+check-record` | 初版误用业务归属日 `workDate` 校验按 `checkDateFrom/checkDateTo` 发起的实际打卡查询，导致跨午夜下班卡被静默丢弃 | 改用 `userCheckTime` 严格绑定请求日期范围；`workDate` 只作为班次归属日原样保留。完整 raw 集合仍必须先通过显式 collection、全量正整数唯一 ID、请求用户和实际打卡时间校验；任何实际时间越界都整次 fail-closed，不再静默过滤 | 最终 live 复核 exact/raw 均为 157 条且完整对象一致；旧轮 `workDate=start-24h`、`userCheckTime` 在范围内的跨午夜 OffDuty 记录明确保留；fresh zero 双层显式空，不由过滤制造 |
-| `+check-result`, `+list-approve` | 初版把裸日期 `--end` 解析为当天 00:00，可能拒绝结束日白天的结果；旧 end-of-day 语义还会漏最后 999ms | 裸日期结束边界改为本地下一日 00:00 前 1ms；显式 datetime 保持精确值；结束日中午与最后 1ms 可接受，下一日 00:00 非零拒绝 | Execute 回归覆盖结束日中午/最后毫秒/下一日并锁定 reason；最终 live 的 `+check-result` 有真实 end-date item，`+list-approve` end-date 单日 probe exact/raw 一致 |
-| `+get-approve-template` | 把请求维度 `approveType` 误作集合唯一身份，会拒绝同一类型下多个合法模板 | 改用非空唯一 `processCode` 作为资源身份；`approveType` 仅做请求精确绑定；每项 `submitUrl` 必须非空；允许 TRAVEL/OUT 同类型多项 | missing/wrong/duplicate processCode、wrong approveType、missing/blank submitUrl 负向矩阵；clean HEAD 上 5 个类型 exact/raw 全通过，TRAVEL/OUT 双项集合一致 |
-| `+search-class`, `+search-adjustment-rule`, `+search-overtime-rule` | 嵌套 `shiftVO/entityVO` 导致身份投影风险 | 固定审核路径、展开 wrapper、要求正整数且不重复的稳定 ID，严格校验分页矛盾与无前进页 | 坏 item/空 ID/重复 ID/分页矛盾单元回归通过；clean HEAD 上 nonempty/guaranteed-zero 与 raw 对照通过，班次/加班规则另完成实际多页前进与终止 |
-| `+get-overtime-rule` | 能力存在但缺少请求 ID 与响应对象的强绑定 | 详情对象要求非空且 `id` 与请求精确一致 | missing/false/null/malformed/wrong-ID/valid Execute 级矩阵；clean HEAD 上 exact/raw 同真实搜索 ID 对象一致，raw 对不存在 ID 返回错对象时 exact 非零拒绝 |
-| `+get-class` | 上游已严格要求 `shiftVO.id`，但真实下游详情不回显任何 ID | 没有注入请求 ID 或放宽校验；按真实合同降级 unavailable | discovery HEAD 上真实搜索→raw detail 非空但 ID 缺失；等待 `DS-ATTENDANCE-006`，修复后再重跑 |
-| `+get-self-setting` | 仅检查场景 key 存在会让 `null` 伪成功；用户外围空白可造成下传/比较漂移 | 用户输入只归一化一次并以同值下传/比较；场景字段必须非空且符合已观测 object/boolean/integer 类型；因 1/6 场景权限不可验证而整体 unavailable | 5 个 scene exact/raw 对照通过；boss scene exact/raw 均 `NO_PERMISSION`，等待 `DS-ATTENDANCE-007`，不把部分场景成功当整体 PASS |
-| `+my-attendance`, `+this-month` | 旧的当前用户解析可跳过 malformed row，也可把 success=false 中的 stale result 当身份 | 改为严格 business success/result/唯一用户身份，坏 profile 后考勤 raw 调用为 0；每条打卡要求唯一正整数 ID | 静态/Execute 回归已通过；因当前只有合法空集合而保持 unavailable，不记 live PASS |
-
-### 6.1 clean-HEAD live 发布门状态
-
-| 叶子 | clean executable HEAD 双层证据 | 发布状态 |
-|---|---|---|
-| `+check-result` | exact/raw known-nonempty 以 20/20/8 三页前进并终止；48 个 ID、用户绑定与逐页对象一致；合法未来日显式空双层一致 | `PASS`；最终 SHA 见 PR 证据 |
-| `+check-record` | exact/raw 均 157 条且完整对象、稳定 ID 集合一致；跨午夜 `workDate=start-24h`、`userCheckTime` 在范围内的记录已保留；fresh zero 两层均为显式空 | `PASS`；最终 SHA 见 PR 证据 |
-| `+list-approve` | exact/raw known-nonempty 为 7 条，稳定 ID、用户、类型、日期范围及完整数组一致；合法未来日显式空双层一致 | `PASS`；最终 SHA 见 PR 证据 |
-| `+get-schedule` | 两次独立 clean HEAD 的 known-nonempty 与 guaranteed-zero 均为 raw `exit 0 + literal null`，Exact Shortcut 均非零 `empty_tool_response`；没有把未知结果投影成空数组 | unavailable；等待 `DS-ATTENDANCE-008`，旧 CLI 仅兼容可见 |
-| `+search-class`, `+search-adjustment-rule`, `+search-overtime-rule` | exact/raw known-nonempty 与随机唯一词 guaranteed-zero 通过；稳定 ID 集合与分页终止一致，班次为 5/5/3 三页，加班规则为 1/1/1 三页 | `PASS`；最终 SHA 见 PR 证据 |
-| `+get-overtime-rule` | 使用本轮真实搜索取得的 ID，exact 与 raw 单项对象一致；不存在 ID 的 raw 返回错 ID 对象时 exact 非零拒绝 | `PASS`；最终 SHA 见 PR 证据 |
-| `+get-approve-template` | 5 个 approveType 全部 exact/raw 通过，数量 1/1/1/2/2；TRAVEL/OUT 多项 `processCode` 非空唯一且集合一致，类型绑定和提交入口有效 | `PASS`；最终 SHA 见 PR 证据 |
-| `+get-class` | raw 非空但不回显请求 ID | unavailable；等待下游合同，不以旧调用记 PASS |
-| `+get-self-setting` | 5 个场景通过，1 个场景 `NO_PERMISSION` | unavailable；等待 capability/权限 fixture，不以部分结果记 PASS |
-
-pre-rebase discovery 轮次的多页加班规则 raw 验证曾一次返回字面量 `null` 且进程退出 0；该次结果没有计为 PASS，重试后才完成同场景双层分页核对。这是 owning atomic/raw 的下游/renderer 终态合同风险：atomic 不应把 transport/null 失败表示为零退出。Shortcut 自身对 `null` 仍严格非零，不会把它投影为空集合；后续最终轮次未再出现该 transient。
-
-上述 8 个公开入口均在最终 clean runtime tree 从零重跑，未继承 discovery PASS；最终可执行 SHA 写入 PR 证据，本文只保留脱敏业务断言。`+get-schedule` 的四次 raw `null` 与 Exact 非零结果作为降级证据保留，不计入公开通过数。
-
-## 7. 安全与脱敏声明
-
-- 本文不含真实用户、组织、租户、profile、规则、排班、考勤组或打卡记录 ID。
-- 本文不含 trace/request ID、token、签名 URL、邮箱、电话、业务标题正文或真实日程内容。
-- Raw 响应仅在仓库外临时目录中处理并已删除；本文只保留不可反查的证据句柄和聚合事实。
-- 进入 Git 前必须扫描最终树、未跟踪文件和 `origin/main..HEAD` 全部历史。

docs/shortcut-downstream-requirements/mail.md

@@ -1,198 +0,0 @@
-# Mail Shortcut 下游业务能力需求规格
-
-> 日期：2026-08-18
-> Rebased executable 基线：`3fc3be37c67d14f60273a702a7a6b38f6ba32d4c`；最终 clean PR HEAD 的 live SHA 与发布复核结果记录在 PR 证据中
-> 对比基线：lark-cli 1.0.87
-> 范围：Shortcut only；不改 `skills/multi` 或 `skills/mono` 的路由、流程或业务逻辑。仓库 policy 强制的可见 Shortcut 自动生成块单独机械同步。
-> 发布属性：仓库安全版本；不包含真实邮箱、人员、组织、邮件内容、资源 ID 或请求标识。
-
-## 1. 执行摘要
-
-本轮对 18 个 Mail Shortcut 完成严格 success、固定集合路径、稳定 ID、分页完整性和统一 Result 收口。8 个公开只读入口已在相同 runtime tree 逐条完成 Shortcut 与原子层的真实数据双层复核；`+unread-mail`、`+recent-mail`、`+thread-list`、`+tag-list`、`+template-list`、`+contact-list` 因缺少可控 guaranteed-zero fixture 保持 Agent-unavailable，但为守住既有 argv/Help 合同继续以 compatibility-visible 形式留在 CLI；4 个草稿/模板写入口因无法证明清理终态同样不进入公开 Catalog。
-
-上述 6 个 compatibility-visible 入口在完整 Schema 中保留历史 `availability=available` 与既有 workflow property，仅表示旧调用仍可执行；其 Shortcut 语义状态仍为 `public=false/unavailable`，默认 Shortcut 列表与 Agent public Catalog 均不发布。底层 `folderId`、`size` 等 MCP 字段继续由 Execute 显式适配，不能在未经过版本化迁移时改写已发布 Schema property。
-
-仍不能诚实对齐的任务集中在草稿/模板清理终态、发送终态、回复/转发草稿语义、批量修改/删除逐项结果、回执、签名、事件监听、模板附件事务和联系人创建身份回执。它们不是再包一层 Shortcut 就能解决，需要下游业务接口或安全测试 fixture 补足可验证合同。
-
-| ID | 优先级 | 类型 | 用户任务 | 当前状态 | 下游 Owner | 解锁的 Shortcut |
-|---|---|---|---|---|---|---|
-| `DS-Mail-001` | P0 | contract insufficient | 发信/发送草稿并确认最终投递 | partial | Mail service / adapter | `+send`、`+draft-send` |
-| `DS-Mail-002` | P0 | missing capability | 回复、回复全部、转发默认保存草稿 | partial | Mail service | `+reply`、`+reply-all`、`+forward` |
-| `DS-Mail-003` | P0 | contract insufficient | 批量修改、移动、软删除邮件 | partial | Mail service / adapter | `+message-modify`、`+message-trash` |
-| `DS-Mail-004` | P1 | missing capability | 处理已读回执与邮箱签名 | unavailable | Mail service | `+send-receipt`、`+decline-receipt`、`+signature` |
-| `DS-Mail-005` | P1 | missing capability | 持续监听新邮件 | unavailable | Event + Mail service | `+watch` |
-| `DS-Mail-006` | P1 | contract insufficient | 带附件/内联图片的模板创建更新 | partial | Mail + Drive adapters | 完整 `+template-create/update` |
-| `DS-Mail-007` | P1 | adapter defect | 创建联系人并取得稳定身份 | blocked | Mail adapter | `+contact-create/update/delete` |
-| `DS-Mail-008` | P1 | adapter defect | 一致的成功、空结果与分页合同 | partial | Mail adapter | 全部 list/search Shortcut |
-| `DS-Mail-009` | P1 | tenant-or-fixture | 安全验证发送、回执、分享和监听 | blocked | Product QA / tenant admin | 全部高影响 Mail Shortcut |
-| `DS-Mail-010` | P0 | contract insufficient | 草稿/模板可证明的清理终态 | blocked | Mail service / adapter | `+draft-create/edit`、`+template-create/update` |
-
-## 2. 用户任务与能力缺口总览
-
-| 用户任务 / Golden Route | DWS Shortcut | Lark CLI 对应 | 当前能力 | 缺口分类 | 临时处置 |
-|---|---|---|---|---|---|
-| 浏览/筛选摘要 | `+triage`、`+search-mail` | `+triage` | covered | 无 | 公开，严格分页 |
-| 固定未读/近期列表 | `+unread-mail`、`+recent-mail` | Lark 对应任务入口 | blocked | 固定查询/文件夹缺可控 guaranteed-zero fixture | 保持 unavailable |
-| 读取一封、多封、会话 | `+message`、`+messages`、`+thread` | 同名入口 | covered | 无 | 公开，精确 ID 读回 |
-| 新建/编辑草稿 | `+draft-create`、`+draft-edit` | 同名入口 | blocked | 两次 batch-delete 后同 ID 仍可读，无法证明零残留 | 保持 unavailable |
-| 创建/更新基础模板 | `+template-create`、`+template-update` | 同名入口 | blocked | delete 后 get 没有 typed nonfound；from/isDraft 也不可读回 | 保持 unavailable |
-| 发送新邮件/已有草稿 | 无公开 Shortcut；存在 raw send | `+send`、`+draft-send` | partial | 终态、逐项结果、幂等不足 | 保持 raw，不宣称对齐 |
-| 回复/回复全部/转发 | 无公开 Shortcut；raw 路径会立即发送 | `+reply`、`+reply-all`、`+forward` | partial | 缺少默认草稿与邮件头保真合同 | 保持 raw，不宣称对齐 |
-| 修改/删除邮件 | 无公开 Shortcut；存在 raw batch route | `+message-modify`、`+message-trash` | partial | 无逐项 ledger 和严格终态 | 保持 raw，不宣称对齐 |
-| 发送/拒绝已读回执 | 无 | `+send-receipt`、`+decline-receipt` | unavailable | 专用业务接口与标签合同缺失 | 明确不可用 |
-| 邮箱签名 | 无 | `+signature` | unavailable | 签名读取接口缺失 | 明确不可用 |
-| 分享邮件到聊天 | raw 高风险入口 | `+share-to-chat` | partial | 缺安全 fixture、逐目标结果与读回 | 不公开 Shortcut |
-| HTML lint | 无 | `+lint-html` | unavailable | 缺统一邮件 HTML 规则包 | 下游或本地规则能力需求 |
-| 监听新邮件 | 无公开 Mail Shortcut | `+watch` | unavailable | 订阅生命周期和安全事件合同不足 | 不公开 Shortcut |
-| 文件夹/标签/联系人/企业邮箱用户 | `+folder-list`、`+user-search`、`+find-mail-user` 公开；其余列表不公开 | 无同名任务入口 | partial DWS extra | 标签/模板/联系人/会话列表缺安全双态 fixture | 无双态证据的入口保持 unavailable |
-
-## 3. 下游需求明细
-
-### `DS-Mail-001` — 可验证的发送生命周期
-
-- 用户任务：发送新邮件或一个/多个草稿，并知道每一封最终是成功、失败、部分成功还是状态未知。
-- 当前证据：raw 发送可返回业务 success 或发送标识，但不能统一证明最终投递；批量草稿发送没有逐项 ledger、请求顺序、未知提交和安全重试合同。
-- 所需接口合同：
-  - 创建/发送必须返回稳定 `messageId` 与 `internetMessageId`，并明确 `accepted/pending/sent/partial_failure/failure/unknown`。
-  - 提供按同一身份查询发送状态的接口；状态必须绑定请求邮件与收件人集合。
-  - 批量发送返回逐项结果，任何一项失败时整体不得退出 0 冒充全成功。
-  - 支持幂等键，或明确 unknown commit 不可自动重试。
-  - 失败错误区分参数、权限、风控、限流、收件人拒收和提交未知。
-- 验收：安全自发自收 fixture 完成 draft-create → exact get → send → 状态终态 → sent-folder exact read；批量中注入一项失败，验证 ledger 与非零整体结果；清理无测试草稿残留。
-
-### `DS-Mail-002` — 回复/转发的草稿优先与 MIME 保真
-
-- 用户任务：回复、回复全部或转发一封邮件，默认保存草稿，只有再次确认才发送。
-- 当前证据：DWS raw route 会创建回复/转发草稿后立即发送，无法对齐 Lark 的默认草稿语义；上游也无法证明 `In-Reply-To`、`References`、原始引用块和收件人集合正确。
-- 所需接口合同：
-  - 独立 `create_reply_draft`、`create_reply_all_draft`、`create_forward_draft`，返回稳定草稿 ID，不隐式发送。
-  - 服务端生成并可读回线程关系头、回复全部去重后的 To/CC、转发引用块和附件继承结果。
-  - 发送必须复用 `DS-Mail-001` 的确认、终态和幂等合同。
-- 验收：用隔离自发邮件分别创建三类草稿，精确 ID 读回核对父邮件、参与人集合和引用语义；未确认时远程发送调用为 0；确认发送后状态终态可验证。
-
-### `DS-Mail-003` — 邮件修改、移动和删除的逐项终态
-
-- 用户任务：批量标记已读/未读、增删标签、移动文件夹、软删除邮件。
-- 当前证据：raw batch route 多数只给聚合 success；删除后邮件仍可能可读，无法区分“移入已删除文件夹”“永久删除”“延迟可见”或“未生效”。
-- 所需接口合同：
-  - 每个输入 messageId 返回 `applied/already_applied/failed/unknown` 与稳定原因码。
-  - 修改/移动后详情或摘要必须可读回 `isRead/tags/folderId`；删除返回明确 tombstone 或 folder transition。
-  - 软删除和永久删除使用不同操作，危险级别与确认要求可声明。
-  - 任何部分失败整体 outcome 为 `partial_failure` 且进程非零。
-- 验收：创建隔离邮件，执行 mark-unread/read、标签增删、移动与软删除，每步同 ID 读回；错误 ID 与合法 ID 混合时逐项 ledger 完整且整体非零。
-
-### `DS-Mail-004` — 已读回执与签名
-
-- 用户任务：识别邮件是否请求回执；确认后发送标准回执，或拒绝并清除提示；列出和查看默认签名。
-- 当前证据：现有 Mail 接口没有稳定暴露回执请求标签、专用发送/拒绝操作或签名读取资源，上游无法安全组合普通回复替代。
-- 所需接口合同：
-  - 消息详情公开稳定回执请求状态和请求者身份类型。
-  - 专用 send/decline receipt 操作，幂等且返回状态；正文由服务端生成，不能让上游伪造。
-  - 签名列表/详情返回稳定 ID、默认发送场景、HTML/文本内容和敏感字段标注。
-- 验收：预置请求回执邮件，未确认零写调用；发送/拒绝后状态读回且重复调用幂等；签名已知非空与合法空均可证明。
-
-### `DS-Mail-005` — 新邮件监听的订阅生命周期
-
-- 用户任务：在限定时间内监听新邮件，得到稳定、可恢复、可去重的事件流。
-- 当前证据：通用事件基础设施不能证明 Mail scope、订阅状态、ready marker、断线续传和消息读取权限形成完整任务链。
-- 所需接口合同：订阅/查询/退订；明确 user/bot 身份、scope 和租户开关；ready marker；事件 `eventId/messageId/mailbox/time`；断线 cursor、去重和界限参数；心跳不冒充业务事件。
-- 验收：隔离邮箱订阅后注入一封测试邮件，只收到一次并能以 messageId 精确读取；超时、权限缺失、断线重连和退订后零事件均有确定结果。
-
-### `DS-Mail-006` — 模板附件与内联图片事务
-
-- 用户任务：创建或更新含普通附件、内联图片和 HTML 的模板，同时保留未修改 MIME 结构。
-- 当前证据：本轮只对齐名称、主题、正文核心字段；现有多步上传缺少模板级事务、附件稳定 ID、失败回滚和更新时的结构保真证明。
-- 所需接口合同：创建/更新草稿会话、附件上传会话、content-id 映射、提交/取消；返回逐附件 ledger；更新提供版本或 etag，避免 last-write-wins 覆盖；失败可回滚且无孤儿文件。
-- 验收：普通附件和内联图片各一，创建后按模板 ID 读取附件 ID/名称/大小/content-id；更新正文不丢附件；中途失败自动取消并证明零孤儿资源。
-
-### `DS-Mail-007` — 联系人写操作的稳定身份
-
-- 用户任务：创建、更新、删除个人邮件联系人并验证精确对象。
-- 当前证据：真实 create 返回 `success=true` 但没有 contactId；上游只能用随机显示名再扫列表定位，无法用于一般用户输入，因为名称/邮箱可能重复。
-- 所需接口合同：create 返回稳定 contactId；get-by-id；update/delete 返回同 ID 与版本；列表支持 exact email 或 ID filter；重复联系人规则明确。
-- 验收：创建回执直接得到 ID，get-by-id 精确核对，更新同 ID，删除后 not-found/tombstone；重复邮箱和同名联系人有稳定结果而非猜测。
-
-### `DS-Mail-008` — 统一成功、空结果与分页协议
-
-- 用户任务：可靠地区分“确实没有结果”“还有下一页”“服务异常或响应漂移”。
-- 当前证据：同一产品的 success 同时出现布尔和字符串；hasMore 也出现两种编码；搜索终页用 `$`，部分列表用空串；零命中邮件会返回 `total=0` 加一个只有空收件人字段的占位对象。当前租户又没有空邮箱或空邮件文件夹，不能为无筛选列表证明 guaranteed-zero。
-- 所需接口合同：
-  - success 与 hasMore 统一为布尔；所有列表显式数组，合法空只返回 `[]`。
-  - 统一 `nextCursor` 与 `endpointExhausted`；终页不使用业务哨兵对象或魔法值。
-  - 每项稳定 ID 必填；total 使用整数；服务错误必须 `success=false` 和稳定错误码。
-  - 保留兼容期，但提供 capability/version 让上游安全切换。
-- 验收：每个列表/搜索执行已知非空、保证零命中、坏 item、缺集合、错型、hasMore 无游标、重复游标；只有显式合法空成功。
-
-### `DS-Mail-009` — 安全租户与真实 E2E fixture
-
-- 用户任务：在不触达真实业务收件人和内容的前提下验证所有高影响 Mail Shortcut。
-- 所需 fixture：隔离自发自收邮箱、可控第二收件人、回执请求邮件、可分享的测试聊天、安全事件订阅、测试签名、可回收附件；所有资源用随机无业务含义标记并有自动清理。
-- 权限：最小 Mail read/write/event、Drive attachment、IM share scopes 分离；可测试 user/bot 差异和缺权限错误。
-- 验收：stdout 只输出 PASS 标签与聚合计数；原始 JSON 只在临时目录；finally 清理；远端零测试草稿/模板/联系人/邮件/订阅残留；仓库和历史扫描无身份数据。
-
-### `DS-Mail-010` — 草稿/模板可证明的清理终态
-
-- 用户任务：用可回收 fixture 验证草稿与模板写 Shortcut，不留下无法确认的远端测试对象。
-- 当前证据：草稿创建/更新回执和 exact-ID 读回成功，但同一 ID 连续两次 batch-delete 后仍可读；模板 delete 返回成功后，get 仅为未分类失败，既非 typed nonfound 也不能证明 tombstone。
-- 所需接口合同：分离软删除与永久删除；返回稳定 ID、终态和幂等证据；get-by-id 对已永久删除对象返回稳定 `not_found/deleted` 错误或已审核 tombstone，不得空 body、通用失败或继续返回对象。
-- 验收：create/update → exact-ID readback → permanent delete → exact Shortcut + raw get 双层 typed absence；有界轮询后仍可读或终态未知时整体非零，且不得发布 Shortcut。
-- 临时处置：四个写 Shortcut 保持 `public=false` / `unavailable`，直到安全 fixture 与 typed absence 同时可证明。
-
-## 4. Lark 对齐与平台差异
-
-| Lark 用户任务 | 可精确对齐 | 平台差异 | DWS 推荐结论 |
-|---|---|---|---|
-| `+message` / `+messages` / `+thread` / `+triage` | yes | DWS 额外自动解析邮箱和收件箱，并严格发布完整性 | 已公开 |
-| `+draft-create` / `+draft-edit` | blocked | 核心写回可证，但删除后同 ID 仍可读，无安全清理终态 | 不公开，保持 unavailable |
-| `+template-create` / `+template-update` | blocked | 核心字段可读回，但 from/isDraft 不可验且删除后缺 typed nonfound | 不公开，保持 unavailable |
-| `+send` / `+draft-send` | no | DWS raw 偏立即发送且缺统一终态/逐项 ledger | 暂不公开 Shortcut |
-| `+reply` / `+reply-all` / `+forward` | no | DWS raw 会立即发送，Lark 默认保存草稿 | 暂不公开 Shortcut |
-| `+message-modify` / `+message-trash` | no | 聚合 success 不足以证明逐项终态 | 暂不公开 Shortcut |
-| `+send-receipt` / `+decline-receipt` | no | 缺专用接口和可验证标签 | platform unavailable |
-| `+signature` | no | 缺签名读取资源 | platform unavailable |
-| `+watch` | no | 缺完整订阅生命周期与安全 fixture | fixture + capability blocked |
-| `+share-to-chat` | partial | raw 可调用但缺逐目标验证和安全 fixture | 保持 raw |
-| `+lint-html` | no | DWS 未提供统一规则包 | downstream/local capability needed |
-
-## 5. 超越 Lark 的产品机会
-
-| 产品原生能力 | 可形成的 DWS Shortcut | 安全/验证要求 | 优先级 |
-|---|---|---|---|
-| 文件夹、标签与联系人目录 | `+organize`：规则化移动、标记与标签组合 | 逐项 ledger、写后读回、补偿恢复 | P1 |
-| 收信规则、白名单、黑名单、自动回复 | `+inbox-policy-audit` | 只读汇总优先；写操作强确认和版本化 | P2 |
-| 邮箱日历 | `+mail-calendar-conflicts` | 与主 Calendar 的 ownership boundary 明确，禁止双写 | P2 |
-| 发送状态与召回 | `+delivery-audit` | 终态、收件人粒度、召回结果和不可逆提示 | P1 |
-| 附件导出与分享 | `+archive-message` | 精确 messageId、原子本地写入、敏感路径与清理 | P2 |
-
-## 6. 无需下游变更的上游修复
-
-| Shortcut | 上游根因 | 已完成修复 | 回归证据 |
-|---|---|---|---|
-| 全部 list/search | 容忍式探测任意 result/data/list/items，坏元素静默丢弃 | 固定已观测路径、严格 success/数组/item/ID；无双态 fixture 的 leaf 不发布 | deterministic 响应矩阵；live 证据逐 leaf 记录，不作泛化 |
-| `+search-mail` / `+triage` | `$` 终止游标被误作下一页；零命中占位对象被当邮件 | 明确 `$` 终页；仅窄规则归一化已观测哨兵 | 各完成 known-nonempty 20；3 个 fresh 零命中 raw 均为 `total=0` + 无稳定 ID/正文且收件字段全空的 reviewed sentinel + terminal cursor，exact 才归一化为显式 `[]`；不把该下游特例描述成 raw 空数组 |
-| `+search-mail` / `+triage` 自动邮箱解析 | 严格化时只接受顶层对象数组，会拒绝历史已观测的字符串数组和 `result/data.emailAccounts` 包装 | 仅接受三个审核路径 `emailAccounts` / `result.emailAccounts` / `data.emailAccounts`，每项可为非空邮箱字符串或含非空 `email` 的对象；缺集合、错型、坏项或多路径冲突全部 fail-closed；空发件人也不再投影为空字符串成功 | top/result/data × string/object、blank/wrong/multiple-path 与 sender missing/null/wrong-type 回归覆盖；最终 live 未传 `--email` 执行 `+search-mail`/`+triage`，owning 响应为顶层 object-item 形态并成功解析 |
-| `+unread-mail` / `+recent-mail` / `+thread-list` | 固定条件或文件夹不能保证零命中 | 严格响应代码已完成，但没有空邮箱/空文件夹证据时关闭发布 | BLOCKED fixture；不得修改真实邮件状态造空 |
-| `+user-search` / `+find-mail-user` | `hasMore`/`nextCursor` 未交付；零命中被误报 validation error | 发布 complete/nextCursor；合法空成功 | 各完成 known-nonempty 20 + fresh raw 显式空；stable identity set 与 raw pagination/meta 精确一致；`+user-search` 同轮实跑历史 string `--limit` |
-| `+tag-list` / `+template-list` / `+contact-list` | 无 query 的列表容易把末页/删除后列表误作合法空 | 严格响应代码已完成；无专用空邮箱和 typed cleanup 时关闭发布 | BLOCKED fixture；不把临时资源从列表消失记为零态 PASS |
-| `+message(s)` / `+thread` | 缺任务层完整读取和身份绑定 | 自动邮箱解析、精确请求 ID 读回、保序多读 | `+message`/`+thread` 与同稳定 ID raw 完整对象一致；`+messages` 用两个不同 ID 验证输入顺序与逐对象一致 |
-| 草稿/模板写 | 仅写回执会产生假成功 | 稳定 ID + exact get + 请求字段核对；清理无法证明时保持 unavailable | deterministic 回执/读回矩阵 PASS；live cleanup BLOCKED |
-
-### 6.1 clean executable HEAD 双层证据
-
-| 公开入口 | exact Shortcut + owning raw 证据 | 状态 |
-|---|---|---|
-| `+search-mail`, `+triage` | 各 20 条 known-nonempty；3 个独立 fresh 零命中由 raw `total=0`、无稳定 ID/正文的单 sentinel 与 terminal cursor 共同证明，exact 严格归一化为显式空；稳定 message ID 集合和分页状态一致 | `PASS_WITH_REVIEWED_ZERO_ENCODING`；最终 SHA 见 PR 证据 |
-| `+user-search`, `+find-mail-user` | 各 20 条 known-nonempty 与 raw 显式 fresh zero；条件身份集合和分页状态一致 | `PASS`；最终 SHA 见 PR 证据 |
-| `+folder-list` | 顶层 5 条 nonempty；本轮先由 raw 验证同一父文件夹确实为空，再由 Shortcut 返回显式空；ID 集合一致 | `PASS`；最终 SHA 见 PR 证据 |
-| `+message`, `+messages`, `+thread` | 单邮件/会话同稳定 ID 完整对象一致；批量用两个不同 ID 验证请求顺序和逐对象一致 | `PASS`；最终 SHA 见 PR 证据 |
-
-8 个公开入口均在最终 clean runtime tree 从零重跑；其中 6 个使用标准 raw 显式空或精确对象证据，2 个邮件搜索使用上述审核过的下游零命中 sentinel 编码。最终可执行 SHA 写入 PR 证据，本文只保留脱敏业务断言。
-
-## 7. 安全与脱敏声明
-
-- 本文不含用户、组织、租户、profile、邮箱、人员姓名、邮件/会话/模板/联系人/聊天真实 ID。
-- 本文不含邮件主题正文、收发件人、trace/request ID、token、签名 URL、电话或真实业务时间。
-- 真实 E2E 原始响应仅在仓库外临时目录解析；普通输出只保留能力标签、计数和布尔断言。
-- 临时草稿虽已执行两次 batch-delete 但仍可按同 ID 读取；临时模板删除后也未获得 typed nonfound。两者都不记为清理 PASS，四个写 Shortcut 因此保持 unavailable。
-- 当前邮箱没有已验证的空邮件文件夹或专用空邮箱；因此 `+unread-mail`、`+recent-mail`、`+thread-list`、`+tag-list`、`+template-list`、`+contact-list` 不记 live 双态 PASS，并保持 unavailable。
-- 最终提交前仍需扫描最终树、未跟踪文件和 `origin/main..HEAD` 全部历史。

docs/shortcut-public-catalog.json

@@ -1,6 +1,6 @@
 {
-  "generated_at": "2026-08-19T10:35:58.304269",
-  "count": 423,
+  "generated_at": "2026-08-18T17:38:50.904696",
+  "count": 436,
   "results": [
     {
       "suite": "semantic",
@@ -933,84 +933,137 @@
       "availability": "available"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "attendance",
       "command": "+check-record",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "查询原始打卡流水；只有显式成功数组可表示空结果，每条必须有唯一正整数 ID 并绑定请求用户和日期。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "attendance",
       "command": "+check-result",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "对齐 Lark attendance user_tasks query；严格校验正整数 ID 及请求用户/日期绑定，以 cursor_parameter=offset 将保守续页证据发布到 meta.pagination。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "attendance",
+      "command": "+get-adjustment-rule",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "attendance",
       "command": "+get-approve-template",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "把补卡、请假、加班、外出、出差映射为审批模板类型；每项以非空唯一 processCode 作为稳定身份，approveType 精确绑定请求且 submitUrl 必须非空，允许同类型返回多个模板。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "attendance",
+      "command": "+get-checkin-record",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "attendance",
+      "command": "+get-leave-records",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "attendance",
       "command": "+get-overtime-rule",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "schema_leaf",
-      "semantic_delta": "使用搜索得到的加班规则 ID 读取详情，严格拒绝空 result，且响应 id 必须与请求 overtimeId 精确一致。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "attendance",
+      "command": "+get-schedule",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "attendance",
+      "command": "+get-self-setting",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "attendance",
+      "command": "+get-summary",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "attendance",
       "command": "+list-approve",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "把审批类型语义映射为业务枚举；每条审批必须有唯一正整数 ID，并精确绑定请求用户、类型与时间范围。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "attendance",
+      "command": "+list-leave-types",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "attendance",
+      "command": "+my-attendance",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "attendance",
+      "command": "+query-report-data",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "attendance",
       "command": "+search-adjustment-rule",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "严格读取 result.adjustmentList、展开 entityVO、要求稳定规则 ID，并公开分页完整性证据。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "attendance",
       "command": "+search-class",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "严格读取 result.items、展开 shiftVO、要求唯一正整数 classId，并将无矛盾的 totalCount/totalPage 续页证据发布到 meta.pagination。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "attendance",
+      "command": "+search-group",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "attendance",
       "command": "+search-overtime-rule",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "严格读取 result.atRuleList、展开 entityVO、要求稳定规则 ID，并公开分页完整性证据。",
-      "availability": "available"
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "attendance",
+      "command": "+this-month",
+      "risk": "read",
+      "status": "real-ok"
     },
     {
       "suite": "semantic",
@@ -3252,84 +3305,74 @@
       "availability": "available"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "mail",
+      "command": "+contact-list",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "mail",
       "command": "+find-mail-user",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "primary_smart",
-      "semantic_delta": "面向联系人解析的精简用户搜索；修复零命中被误报为调用失败，并严格验证用户数组、身份和分页。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "mail",
       "command": "+folder-list",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "只接受显式 folders 数组及稳定 folder ID；缺字段、错型和坏元素不再退化为空列表。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "mail",
-      "command": "+message",
+      "command": "+recent-mail",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "primary_smart",
-      "semantic_delta": "对齐 Lark 单封完整读入口；自动解析邮箱，要求顶层 message 非空且返回 ID 与请求 messageId 精确一致。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
-      "service": "mail",
-      "command": "+messages",
-      "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "primary_smart",
-      "semantic_delta": "对齐 Lark 多封完整读入口；最多 100 个 ID，保持请求顺序，任何单封缺失、错型或身份不一致都会使整次调用失败。",
-      "availability": "available"
-    },
-    {
-      "suite": "semantic",
+      "suite": "read",
       "service": "mail",
       "command": "+search-mail",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "用 KQL 搜索邮件摘要；只接受已观测 messages 数组、稳定 messageId 和完整分页证据，窄化支持 Mail 专属 total=0 占位哨兵。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "mail",
-      "command": "+thread",
+      "command": "+tag-list",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "primary_smart",
-      "semantic_delta": "对齐 Lark 完整会话读取；自动解析邮箱并要求 conversation.id 与请求精确一致。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
       "service": "mail",
-      "command": "+triage",
+      "command": "+template-list",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "primary_smart",
-      "semantic_delta": "对齐 Lark triage 任务入口，并超过其显式邮箱要求：可自动解析当前邮箱与收件箱，严格处理邮件搜索的终止游标和零命中哨兵。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
-      "suite": "semantic",
+      "suite": "read",
+      "service": "mail",
+      "command": "+thread-list",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
+      "service": "mail",
+      "command": "+unread-mail",
+      "risk": "read",
+      "status": "real-ok"
+    },
+    {
+      "suite": "read",
       "service": "mail",
       "command": "+user-search",
       "risk": "read",
-      "status": "reviewed_available",
-      "disposition": "semantic_adapter",
-      "semantic_delta": "搜索企业邮箱用户并保留 hasMore/nextCursor；显式空数组合法，坏用户或缺稳定 ID 失败。",
-      "availability": "available"
+      "status": "real-ok"
     },
     {
       "suite": "semantic",

go.mod

@@ -4,6 +4,8 @@ go 1.25.9
 
 replace gitlab.alibaba-inc.com/aes/aem-go-sdk => ./third_party/aem-go-sdk
 
+replace safechat-go-sdk => ./third_party/safechat-go-sdk
+
 require (
 	github.com/Microsoft/go-winio v0.6.2
 	github.com/RealAlexandreAI/json-repair v0.0.15
@@ -24,6 +26,7 @@ require (
 	golang.org/x/crypto v0.49.0
 	golang.org/x/sys v0.42.0
 	golang.org/x/text v0.35.0
+	safechat-go-sdk v0.0.0
 )
 
 require (

internal/app/event_command.go

@@ -403,7 +403,7 @@ SIGTERM、关 stdin，或先用 dws event stop <subscribe_id> --dry-run 预览
 			Selection: contract.SelectionSpec{
 				AgentSummary: "消费 OA、群生命周期或需要底层控制的个人事件流；Agent 通常使用 --flatten 输出 NDJSON",
 				UseWhen: []string{
-					"需要监听七个公开 OA 审批任务/实例 EventKey 中的一个或多个事件",
+					"需要监听六个公开 OA 审批任务/实例 EventKey 中的一个或多个事件",
 					"需要监听指定群的标题变更、成员进退群或群解散事件",
 					"用户显式给出原始 EventKey、Filter DSL、subscribe_id，要求原始 transport envelope，或需要普通 IM facade 不提供的高级多事件控制",
 				},

internal/app/event_personal_attempts_test.go

@@ -152,8 +152,8 @@ func TestCrossPlatformCoveragePersonalSubscriptionProtectionCoversAllPublicEvent
 		}
 	}
 
-	if publicCount != 23 {
-		t.Fatalf("public personal events = %d, want 23 (16 IM + 7 OA)", publicCount)
+	if publicCount != 22 {
+		t.Fatalf("public personal events = %d, want 22 (16 IM + 6 OA)", publicCount)
 	}
 	for _, ruleType := range []string{"at", "all", "singleChat", "sender", "group"} {
 		if !ruleTypes[ruleType] {

internal/app/event_personal_oa_test.go

@@ -61,13 +61,6 @@ func TestPersonalOAEventListAndSchemaCommands(t *testing.T) {
 				"process_code", "title", "status", "create_time", "event_time",
 			},
 		},
-		{
-			eventKey: personal.EventOAApprovalInstanceCC,
-			properties: []string{
-				"type", "event_id", "timestamp", "subscribe_id", "process_instance_id",
-				"process_code", "title", "status", "create_time", "event_time",
-			},
-		},
 		{
 			eventKey: personal.EventOAApprovalInstanceTerminated,
 			properties: []string{
@@ -168,7 +161,6 @@ func TestPersonalOAEventConsumeDryRunAndValidation(t *testing.T) {
 		personal.EventOAApprovalTaskFinished,
 		personal.EventOAApprovalTaskRedirected,
 		personal.EventOAApprovalInstanceStarted,
-		personal.EventOAApprovalInstanceCC,
 		personal.EventOAApprovalInstanceTerminated,
 		personal.EventOAApprovalInstanceFinished,
 	}
@@ -422,7 +414,6 @@ func TestPersonalOAMultiConsumeCreatesIndependentAllSubscriptionsOnSharedBus(t *
 		personal.EventOAApprovalTaskFinished,
 		personal.EventOAApprovalTaskRedirected,
 		personal.EventOAApprovalInstanceStarted,
-		personal.EventOAApprovalInstanceCC,
 		personal.EventOAApprovalInstanceTerminated,
 		personal.EventOAApprovalInstanceFinished,
 	}

internal/app/param_alias_e2e_test.go

@@ -51,38 +51,7 @@ func (c *paramAliasCaptureCaller) CallTool(_ context.Context, server, tool strin
 func (c *paramAliasCaptureCaller) paramAliasResponseForTool(tool string) string {
 	switch tool {
 	case "list_calendar_events":
-		return `{"success":true,"result":{"events":[],"hasMore":false,"nextCursor":""}}`
-	case "get_calendar_detail":
-		return c.paramAliasCalendarDetailResponse()
-	case "get_calendar_participants":
-		return `{"success":true,"result":{"participants":[{"userId":"fixture-user","displayName":"Fixture User"},{"userId":"user-2","displayName":"User Two"}]}}`
-	case "search_calendar":
-		return `{"success":true,"result":{"calendars":[]}}`
-	case "search_rooms":
-		return `{"success":true,"result":{"rooms":[]}}`
-	case "query_available_meeting_room":
-		return `{"success":true,"result":{"rooms":[],"hasMore":false}}`
-	case "list_meeting_room_groups":
-		return `{"success":true,"result":{"groups":[]}}`
-	case "query_busy_status":
-		return `{"success":true,"result":[]}`
-	case "list_suggested_event_times":
-		return `{"success":true,"result":{"recommendEventTimes":[]}}`
-	case "create_calendar_event":
-		return `{"success":true,"result":{"eventId":"event-1"}}`
-	case "update_calendar_event", "delete_calendar_event", "add_calendar_participant", "remove_calendar_participant":
-		return `{"success":true}`
-	case "respond":
-		status := "accepted"
-		if call := c.lastParamAliasCall(); call != nil {
-			if value, ok := call.args["responseStatus"].(string); ok && value != "" {
-				status = value
-			}
-		}
-		encoded, _ := json.Marshal(map[string]any{"success": true, "result": map[string]any{"responseStatus": status}})
-		return string(encoded)
-	case "get_current_user_profile":
-		return `{"success":true,"result":{"userId":"user-1","name":"Fixture Current User"}}`
+		return `{"result":{"events":[]}}`
 	case "query_records":
 		return `{"success":true,"status":"success","error":{},"data":{}}`
 	case "search_mail_users":
@@ -158,41 +127,6 @@ func (c *paramAliasCaptureCaller) paramAliasResponseForTool(tool string) string
 	}
 }
 
-func (c *paramAliasCaptureCaller) lastParamAliasCall() *paramAliasToolCall {
-	if len(c.calls) == 0 {
-		return nil
-	}
-	return &c.calls[len(c.calls)-1]
-}
-
-func (c *paramAliasCaptureCaller) paramAliasCalendarDetailResponse() string {
-	event := map[string]any{
-		"eventId":       "event-1",
-		"summary":       "Fixture Meeting",
-		"description":   "fixture description",
-		"startDateTime": "2026-03-10T09:00:00+08:00",
-		"endDateTime":   "2026-03-10T10:00:00+08:00",
-	}
-	for _, call := range c.calls {
-		switch call.tool {
-		case "create_calendar_event", "update_calendar_event":
-			for _, key := range []string{"eventId", "summary", "description", "startDateTime", "endDateTime", "timeZone", "location", "freeBusy"} {
-				if value, ok := call.args[key]; ok {
-					event[key] = value
-				}
-			}
-		case "respond":
-			if value, ok := call.args["responseStatus"]; ok {
-				event["responseStatus"] = value
-			}
-		case "delete_calendar_event":
-			event["status"] = "cancelled"
-		}
-	}
-	encoded, _ := json.Marshal(map[string]any{"success": true, "result": event})
-	return string(encoded)
-}
-
 func (*paramAliasCaptureCaller) Format() string { return "json" }
 func (*paramAliasCaptureCaller) DryRun() bool   { return false }
 func (*paramAliasCaptureCaller) Fields() string { return "" }

internal/app/param_alias_payload_equivalence_test.go

@@ -5,8 +5,6 @@ package app
 
 import (
 	"errors"
-	"os"
-	"os/exec"
 	"reflect"
 	"strings"
 	"testing"
@@ -19,8 +17,6 @@ import (
 const (
 	appFixtureCurrentDOpenID  = "DAAAAAAAAAAAiE"
 	appFixtureCurrentDOpenID2 = "DAQEBAQEBAQEiE"
-
-	paramAliasCalendarPayloadChildEnv = "DWS_TEST_CALENDAR_PARAM_ALIAS_PAYLOAD_CHILD"
 )
 
 // paramAliasCompleteCommands is deliberately keyed by the exact reviewed
@@ -50,37 +46,7 @@ var paramAliasCompleteCommands = map[string][]string{
 	"aitable workflow run":                     {"aitable", "workflow", "run", "--base-id", "base-1", "--workflow-id", "workflow-1", "--table-id", "table-1", "--record-ids", "record-1", "--yes"},
 	"attendance check result":                  {"attendance", "check", "result", "--users", "user-1,user-2", "--start", "2026-03-01", "--end", "2026-03-02"},
 	"attendance +check-result":                 {"attendance", "+check-result", "--users", "user-1,user-2", "--start", "2026-03-01", "--end", "2026-03-02"},
-	"calendar +agenda":                         {"calendar", "+agenda", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00", "--calendar-id", "primary", "--cursor", "cursor-1", "--limit", "7"},
-	"calendar +attendee-list":                  {"calendar", "+attendee-list", "--event", "event-1", "--calendar-id", "primary"},
-	"calendar +book":                           {"calendar", "+book", "--title", "Fixture Meeting", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T10:00:00+08:00", "--with", "Fixture User", "--yes"},
-	"calendar +book-search":                    {"calendar", "+book-search", "--query", "fixture"},
-	"calendar +cancel-event":                   {"calendar", "+cancel-event", "--event", "event-1", "--yes"},
-	"calendar +conflicts":                      {"calendar", "+conflicts", "--in-days", "1"},
-	"calendar +create":                         {"calendar", "+create", "--title", "Fixture Meeting", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T10:00:00+08:00", "--desc", "fixture description", "--attendees", "user-1,user-2", "--rooms", "room-1,room-2", "--calendar-id", "primary", "--yes"},
-	"calendar +free":                           {"calendar", "+free", "--who", "Fixture User", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00"},
-	"calendar +free-slots":                     {"calendar", "+free-slots", "--from", "9", "--to", "18", "--in-days", "1"},
-	"calendar +freebusy":                       {"calendar", "+freebusy", "--users", "user-1,user-2", "--rooms", "room-1,room-2", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00"},
-	"calendar +get":                            {"calendar", "+get", "--event", "event-1", "--calendar-id", "primary"},
-	"calendar +invite":                         {"calendar", "+invite", "--event", "event-1", "--with", "Fixture User", "--yes"},
-	"calendar +my-free":                        {"calendar", "+my-free", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00"},
-	"calendar +reschedule":                     {"calendar", "+reschedule", "--event", "event-1", "--start", "2026-03-10T10:00:00+08:00", "--end", "2026-03-10T11:00:00+08:00", "--yes"},
-	"calendar +room-find":                      {"calendar", "+room-find", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T10:00:00+08:00", "--room-name", "Fixture Room", "--group-id", "group-1", "--page", "1", "--limit", "7"},
-	"calendar +room-groups":                    {"calendar", "+room-groups", "--page", "1", "--limit", "7"},
-	"calendar +room-search":                    {"calendar", "+room-search", "--room-name", "Fixture Room"},
-	"calendar +rsvp":                           {"calendar", "+rsvp", "--event", "event-1", "--status", "accept", "--calendar-id", "primary", "--yes"},
-	"calendar +search-event":                   {"calendar", "+search-event", "--query", "fixture", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00", "--calendar-id", "primary", "--cursor", "cursor-1", "--limit", "7"},
-	"calendar +suggest-time":                   {"calendar", "+suggest-time", "--with", "Fixture User", "--duration", "30", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00"},
-	"calendar +suggestion":                     {"calendar", "+suggestion", "--users", "user-1,user-2", "--duration", "30", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00", "--timezone", "Asia/Shanghai"},
-	"calendar +update":                         {"calendar", "+update", "--event", "event-1", "--title", "Fixture Updated Meeting", "--desc", "fixture updated description", "--start", "2026-03-10T10:00:00+08:00", "--end", "2026-03-10T11:00:00+08:00", "--add-attendees", "user-2", "--remove-attendees", "user-1", "--yes"},
-	"calendar busy search":                     {"calendar", "busy", "search", "--users", "user-1,user-2", "--rooms", "room-1,room-2", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00"},
-	"calendar event create":                    {"calendar", "event", "create", "--title", "Fixture Meeting", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T10:00:00+08:00", "--remind-minutes", "15", "--timezone", "Asia/Shanghai", "--rooms", "room-1,room-2"},
 	"calendar event list":                      {"calendar", "event", "list", "--start", "2026-03-10T14:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00", "--calendar-id", "primary", "--cursor", "cursor-1", "--limit", "7"},
-	"calendar event respond":                   {"calendar", "event", "respond", "--id", "event-1", "--status", "accepted"},
-	"calendar event suggest":                   {"calendar", "event", "suggest", "--users", "user-1,user-2", "--duration", "30", "--start", "2026-03-10T09:00:00+08:00", "--end", "2026-03-10T18:00:00+08:00", "--timezone", "Asia/Shanghai"},
-	"calendar event update":                    {"calendar", "event", "update", "--id", "event-1", "--timezone", "Asia/Shanghai"},
-	"calendar room add":                        {"calendar", "room", "add", "--event", "event-1", "--rooms", "room-1,room-2"},
-	"calendar room delete":                     {"calendar", "room", "delete", "--event", "event-1", "--rooms", "room-1,room-2"},
-	"calendar room search":                     {"calendar", "room", "search", "--room-name", "Fixture Room", "--group-id", "group-1", "--start", "2027-03-10T09:00:00+08:00", "--end", "2027-03-10T10:00:00+08:00", "--page", "1", "--limit", "7"},
 	"chat +chat-messages":                      {"chat", "+chat-messages", "--group", "fixture-conversation"},
 	"chat +chat-add-bot":                       {"chat", "+chat-add-bot", "--id", "fixture-conversation", "--robot-code", "robot-1", "--yes"},
 	"chat +chat-audit-join":                    {"chat", "+chat-audit-join", "--group", "fixture-conversation", "--record-id", "7", "--applicant", "user-1", "--inviter", "user-2", "--status", "AuditApprove", "--yes"},
@@ -600,108 +566,6 @@ var paramAliasRepresentativePayloadCases = map[string]bool{
 	paramAliasPayloadCaseKey("report list", "from-date"):                             true, // date-range concept alias
 }
 
-// paramAliasCalendarPayloadCases keeps the full reviewed Calendar expansion
-// separate from the long-lived app-c race process. Each case still executes
-// both canonical and alias argv through the real PreParse/Cobra path and
-// compares the final captured transport calls; the owning top-level test runs
-// these allocations in a short-lived race-instrumented subprocess so all Root
-// registrations are released together when that process exits.
-var paramAliasCalendarPayloadCases = map[string]bool{
-	paramAliasPayloadCaseKey("calendar +agenda", "from"):                    true,
-	paramAliasPayloadCaseKey("calendar +agenda", "to"):                      true,
-	paramAliasPayloadCaseKey("calendar +agenda", "max-results"):             true,
-	paramAliasPayloadCaseKey("calendar +agenda", "next-cursor"):             true,
-	paramAliasPayloadCaseKey("calendar +agenda", "calendar-book-id"):        true,
-	paramAliasPayloadCaseKey("calendar +attendee-list", "event-id"):         true,
-	paramAliasPayloadCaseKey("calendar +attendee-list", "calendar-book-id"): true,
-	paramAliasPayloadCaseKey("calendar +book", "summary"):                   true,
-	paramAliasPayloadCaseKey("calendar +book", "attendee-names"):            true,
-	paramAliasPayloadCaseKey("calendar +book-search", "keyword"):            true,
-	paramAliasPayloadCaseKey("calendar +book-search", "search"):             true,
-	paramAliasPayloadCaseKey("calendar +book-search", "name"):               true,
-	paramAliasPayloadCaseKey("calendar +cancel-event", "event-id"):          true,
-	paramAliasPayloadCaseKey("calendar +cancel-event", "id"):                true,
-	paramAliasPayloadCaseKey("calendar +free", "name"):                      true,
-	paramAliasPayloadCaseKey("calendar +free-slots", "start-hour"):          true,
-	paramAliasPayloadCaseKey("calendar +free-slots", "end-hour"):            true,
-	paramAliasPayloadCaseKey("calendar +free-slots", "day-offset"):          true,
-	paramAliasPayloadCaseKey("calendar +freebusy", "user-ids"):              true,
-	paramAliasPayloadCaseKey("calendar +freebusy", "room-ids"):              true,
-	paramAliasPayloadCaseKey("calendar +freebusy", "room-id"):               true,
-	paramAliasPayloadCaseKey("calendar +my-free", "from"):                   true,
-	paramAliasPayloadCaseKey("calendar +my-free", "to"):                     true,
-	paramAliasPayloadCaseKey("calendar +invite", "id"):                      true,
-	paramAliasPayloadCaseKey("calendar +invite", "participant-names"):       true,
-	paramAliasPayloadCaseKey("calendar +reschedule", "id"):                  true,
-	paramAliasPayloadCaseKey("calendar +reschedule", "from"):                true,
-	paramAliasPayloadCaseKey("calendar +reschedule", "to"):                  true,
-	paramAliasPayloadCaseKey("calendar +room-groups", "page-size"):          true,
-	paramAliasPayloadCaseKey("calendar +room-groups", "page-index"):         true,
-	paramAliasPayloadCaseKey("calendar +room-search", "query"):              true,
-	paramAliasPayloadCaseKey("calendar +suggest-time", "duration-minutes"):  true,
-	paramAliasPayloadCaseKey("calendar +suggest-time", "attendee-names"):    true,
-	paramAliasPayloadCaseKey("calendar +conflicts", "day-offset"):           true,
-	paramAliasPayloadCaseKey("calendar busy search", "room-id"):             true,
-	paramAliasPayloadCaseKey("calendar event create", "reminder-minutes"):   true,
-	paramAliasPayloadCaseKey("calendar event create", "tz"):                 true,
-	paramAliasPayloadCaseKey("calendar event create", "room-id"):            true,
-	paramAliasPayloadCaseKey("calendar event respond", "response-status"):   true,
-	paramAliasPayloadCaseKey("calendar event suggest", "duration-minutes"):  true,
-	paramAliasPayloadCaseKey("calendar event update", "tz"):                 true,
-	paramAliasPayloadCaseKey("calendar room add", "room-id"):                true,
-	paramAliasPayloadCaseKey("calendar room delete", "room-id"):             true,
-	paramAliasPayloadCaseKey("calendar room search", "room-group-id"):       true,
-	paramAliasPayloadCaseKey("calendar +create", "summary"):                 true,
-	paramAliasPayloadCaseKey("calendar +create", "description"):             true,
-	paramAliasPayloadCaseKey("calendar +create", "user-ids"):                true,
-	paramAliasPayloadCaseKey("calendar +create", "room-ids"):                true,
-	paramAliasPayloadCaseKey("calendar +create", "room-id"):                 true,
-	paramAliasPayloadCaseKey("calendar +create", "calendar-book-id"):        true,
-	paramAliasPayloadCaseKey("calendar +create", "to"):                      true,
-	paramAliasPayloadCaseKey("calendar +create", "from"):                    true,
-	paramAliasPayloadCaseKey("calendar +get", "event-id"):                   true,
-	paramAliasPayloadCaseKey("calendar +get", "calendar-book-id"):           true,
-	paramAliasPayloadCaseKey("calendar +room-find", "from"):                 true,
-	paramAliasPayloadCaseKey("calendar +room-find", "to"):                   true,
-	paramAliasPayloadCaseKey("calendar +room-find", "page-size"):            true,
-	paramAliasPayloadCaseKey("calendar +room-find", "page-index"):           true,
-	paramAliasPayloadCaseKey("calendar +room-find", "room-group-id"):        true,
-	paramAliasPayloadCaseKey("calendar +room-find", "query"):                true,
-	paramAliasPayloadCaseKey("calendar +rsvp", "event-id"):                  true,
-	paramAliasPayloadCaseKey("calendar +rsvp", "response-status"):           true,
-	paramAliasPayloadCaseKey("calendar +search-event", "keyword"):           true,
-	paramAliasPayloadCaseKey("calendar +search-event", "from"):              true,
-	paramAliasPayloadCaseKey("calendar +search-event", "to"):                true,
-	paramAliasPayloadCaseKey("calendar +search-event", "next-cursor"):       true,
-	paramAliasPayloadCaseKey("calendar +search-event", "max-results"):       true,
-	paramAliasPayloadCaseKey("calendar +suggestion", "user-ids"):            true,
-	paramAliasPayloadCaseKey("calendar +suggestion", "duration-minutes"):    true,
-	paramAliasPayloadCaseKey("calendar +suggestion", "from"):                true,
-	paramAliasPayloadCaseKey("calendar +suggestion", "to"):                  true,
-	paramAliasPayloadCaseKey("calendar +suggestion", "tz"):                  true,
-	paramAliasPayloadCaseKey("calendar +update", "event-id"):                true,
-	paramAliasPayloadCaseKey("calendar +update", "from"):                    true,
-	paramAliasPayloadCaseKey("calendar +update", "summary"):                 true,
-	paramAliasPayloadCaseKey("calendar +update", "description"):             true,
-	paramAliasPayloadCaseKey("calendar +update", "add-user-ids"):            true,
-	paramAliasPayloadCaseKey("calendar +update", "remove-user-ids"):         true,
-}
-
-// paramAliasCalendarConfirmationCases selects one newly reviewed alias for
-// every Calendar Shortcut whose runtime contract requires user confirmation.
-// The complete Calendar matrix proves confirmed canonical/alias payload
-// equality; these representatives additionally prove semantic normalization
-// cannot cross the confirmation boundary before the first transport call.
-var paramAliasCalendarConfirmationCases = map[string]bool{
-	paramAliasPayloadCaseKey("calendar +book", "summary"):          true,
-	paramAliasPayloadCaseKey("calendar +cancel-event", "event-id"): true,
-	paramAliasPayloadCaseKey("calendar +create", "summary"):        true,
-	paramAliasPayloadCaseKey("calendar +invite", "id"):             true,
-	paramAliasPayloadCaseKey("calendar +reschedule", "from"):       true,
-	paramAliasPayloadCaseKey("calendar +rsvp", "response-status"):  true,
-	paramAliasPayloadCaseKey("calendar +update", "event-id"):       true,
-}
-
 func TestCrossPlatformCoverageReviewedParamAliasesHaveCompleteTemplatesAndRepresentativeFinalPayloads(t *testing.T) {
 	concepts, err := cli.LoadParamConcepts()
 	if err != nil {
@@ -735,7 +599,28 @@ func TestCrossPlatformCoverageReviewedParamAliasesHaveCompleteTemplatesAndRepres
 		}
 		executedRepresentatives[caseKey] = true
 		t.Run(fixture.Command+"/"+fixture.Emitted, func(t *testing.T) {
-			assertParamAliasFinalPayloadEquivalent(t, fixture.Command, canonicalArgs, aliasArgs)
+
+			canonicalCaller := &paramAliasCaptureCaller{}
+			_, canonicalErr := executeParamAliasPayloadE2E(t, canonicalCaller, canonicalArgs...)
+			if canonicalErr != nil {
+				t.Fatalf("complete canonical command failed: %v\nargs=%v\ncalls=%#v", canonicalErr, canonicalArgs, canonicalCaller.calls)
+			}
+			if len(canonicalCaller.calls) == 0 {
+				t.Fatalf("complete canonical command reached no final transport payload: args=%v", canonicalArgs)
+			}
+
+			aliasCaller := &paramAliasCaptureCaller{}
+			ctx, aliasErr := executeParamAliasPayloadE2E(t, aliasCaller, aliasArgs...)
+			if aliasErr != nil {
+				t.Fatalf("complete alias command failed: %v\nargs=%v\ncalls=%#v", aliasErr, aliasArgs, aliasCaller.calls)
+			}
+			if ctx == nil {
+				t.Fatal("complete alias command skipped PreParse")
+			}
+			normalizeParamAliasVolatileDefaults(fixture.Command, canonicalCaller, aliasCaller)
+			if !reflect.DeepEqual(aliasCaller.calls, canonicalCaller.calls) {
+				t.Fatalf("final transport calls differ\ncanonical args: %v\nalias args: %v\ncanonical calls: %#v\nalias calls: %#v", canonicalArgs, aliasArgs, canonicalCaller.calls, aliasCaller.calls)
+			}
 		})
 	}
 
@@ -765,118 +650,6 @@ func TestCrossPlatformCoverageReviewedParamAliasesHaveCompleteTemplatesAndRepres
 	}
 }
 
-func TestCrossPlatformCoverageReviewedCalendarParamAliasesReachCanonicalEquivalentFinalPayloads(t *testing.T) {
-	if os.Getenv(paramAliasCalendarPayloadChildEnv) != "1" {
-		command := exec.Command(
-			os.Args[0],
-			"-test.run=^TestCrossPlatformCoverageReviewedCalendarParamAliasesReachCanonicalEquivalentFinalPayloads$",
-			"-test.count=1",
-			"-test.timeout=5m",
-		)
-		command.Env = append(os.Environ(), paramAliasCalendarPayloadChildEnv+"=1")
-		output, err := command.CombinedOutput()
-		if err != nil {
-			t.Fatalf("Calendar param-alias payload subprocess failed: %v\n%s", err, strings.TrimSpace(string(output)))
-		}
-		return
-	}
-
-	concepts, err := cli.LoadParamConcepts()
-	if err != nil {
-		t.Fatalf("LoadParamConcepts() error = %v", err)
-	}
-
-	executed := make(map[string]bool)
-	executedConfirmation := make(map[string]bool)
-	for _, fixture := range concepts.Fixture {
-		caseKey := paramAliasPayloadCaseKey(fixture.Command, fixture.Emitted)
-		if !paramAliasCalendarPayloadCases[caseKey] {
-			continue
-		}
-		executed[caseKey] = true
-		fixture := fixture
-		t.Run(fixture.Command+"/"+fixture.Emitted, func(t *testing.T) {
-			complete, ok := paramAliasCompleteCommand(fixture.Command, fixture.Expect)
-			if !ok {
-				t.Fatal("reviewed Calendar alias has no complete-command E2E template")
-			}
-			canonicalArgs := append([]string(nil), complete...)
-			aliasArgs, replacements := replaceLongFlag(canonicalArgs, fixture.Expect, fixture.Emitted)
-			if replacements != 1 {
-				t.Fatalf("complete Calendar command must contain canonical --%s exactly once; replacements=%d args=%v", fixture.Expect, replacements, canonicalArgs)
-			}
-			assertParamAliasFinalPayloadEquivalent(t, fixture.Command, canonicalArgs, aliasArgs)
-			if paramAliasCalendarConfirmationCases[caseKey] {
-				executedConfirmation[caseKey] = true
-				assertParamAliasCannotBypassConfirmation(t, aliasArgs)
-			}
-		})
-	}
-
-	for caseKey := range paramAliasCalendarPayloadCases {
-		if !executed[caseKey] {
-			t.Errorf("Calendar final-payload case %q has no active reviewed fixture", caseKey)
-		}
-	}
-	if len(executed) != len(paramAliasCalendarPayloadCases) {
-		t.Fatalf("Calendar final-payload coverage = %d, want %d", len(executed), len(paramAliasCalendarPayloadCases))
-	}
-	for caseKey := range paramAliasCalendarConfirmationCases {
-		if !executedConfirmation[caseKey] {
-			t.Errorf("Calendar confirmation case %q has no active reviewed fixture", caseKey)
-		}
-	}
-	if len(executedConfirmation) != len(paramAliasCalendarConfirmationCases) {
-		t.Fatalf("Calendar confirmation coverage = %d, want %d", len(executedConfirmation), len(paramAliasCalendarConfirmationCases))
-	}
-}
-
-func assertParamAliasCannotBypassConfirmation(t *testing.T, aliasArgs []string) {
-	t.Helper()
-	unconfirmedArgs, removals := removeExactArg(aliasArgs, "--yes")
-	if removals != 1 {
-		t.Fatalf("confirmation template must contain --yes exactly once; removals=%d args=%v", removals, aliasArgs)
-	}
-
-	caller := &paramAliasCaptureCaller{}
-	ctx, err := executeParamAliasPayloadE2E(t, caller, unconfirmedArgs...)
-	if ctx == nil {
-		t.Fatal("unconfirmed Calendar alias command skipped PreParse")
-	}
-	var appErr *apperrors.Error
-	if !errors.As(err, &appErr) || appErr.Reason != "confirmation_required" {
-		t.Fatalf("unconfirmed Calendar alias command error = %#v, want confirmation_required\nargs=%v", err, unconfirmedArgs)
-	}
-	if len(caller.calls) != 0 {
-		t.Fatalf("unconfirmed Calendar alias crossed the transport boundary: args=%v calls=%#v", unconfirmedArgs, caller.calls)
-	}
-}
-
-func assertParamAliasFinalPayloadEquivalent(t *testing.T, command string, canonicalArgs, aliasArgs []string) {
-	t.Helper()
-	canonicalCaller := &paramAliasCaptureCaller{}
-	_, canonicalErr := executeParamAliasPayloadE2E(t, canonicalCaller, canonicalArgs...)
-	if canonicalErr != nil {
-		t.Fatalf("complete canonical command failed: %v\nargs=%v\ncalls=%#v", canonicalErr, canonicalArgs, canonicalCaller.calls)
-	}
-	if len(canonicalCaller.calls) == 0 {
-		t.Fatalf("complete canonical command reached no final transport payload: args=%v", canonicalArgs)
-	}
-
-	aliasCaller := &paramAliasCaptureCaller{}
-	ctx, aliasErr := executeParamAliasPayloadE2E(t, aliasCaller, aliasArgs...)
-	if aliasErr != nil {
-		t.Fatalf("complete alias command failed: %v\nargs=%v\ncalls=%#v", aliasErr, aliasArgs, aliasCaller.calls)
-	}
-	if ctx == nil {
-		t.Fatal("complete alias command skipped PreParse")
-	}
-	normalizeParamAliasVolatileDefaults(command, canonicalCaller, aliasCaller)
-	if !reflect.DeepEqual(aliasCaller.calls, canonicalCaller.calls) {
-		t.Fatalf("final transport calls differ\ncanonical args: %v\nalias args: %v\ncanonical calls: %#v\nalias calls: %#v", canonicalArgs, aliasArgs, canonicalCaller.calls, aliasCaller.calls)
-	}
-}
-
 func TestCrossPlatformCoverageNewIMParamAliasesReachCanonicalEquivalentFinalPayloads(t *testing.T) {
 	activeAliases := 0
 	for _, test := range paramAliasNewIMCases {

internal/app/schema_agent_examples_dry_run_test.go

@@ -274,7 +274,6 @@ type agentExampleFiles struct {
 	markdown string
 	json     string
 	batch    string
-	job      string
 	binary   string
 	image    string
 }
@@ -284,14 +283,12 @@ func newAgentExampleFiles(t testing.TB, root string) agentExampleFiles {
 	markdown := filepath.Join(root, "content.md")
 	jsonFile := filepath.Join(root, "report.json")
 	batch := filepath.Join(root, "styles.json")
-	job := filepath.Join(root, "job.json")
 	binary := filepath.Join(root, "report.pdf")
 	image := filepath.Join(root, "chart.png")
 	for path, content := range map[string][]byte{
 		markdown: []byte("# Agent dry-run fixture\n\nNo business call is allowed.\n"),
 		jsonFile: []byte(`[{"content":"Agent dry-run fixture","sort":"0","key":"fixture","contentType":"markdown","type":"1"}]`),
 		batch:    []byte(`[{"sheetId":"Sheet1","range":"A1:B2","fontWeight":"bold"}]`),
-		job:      []byte(`{"name":"Java 工程师","description":"服务端开发","jobNature":"FULL-TIME","requiredEdu":6,"minSalary":20000,"maxSalary":35000,"extData":{"headCount":1,"fullTimeExtData":{"salaryMonth":12}},"creatorUserId":"creator-user-id","ownerUserIds":["owner-user-id"]}`),
 		binary:   []byte("%PDF-1.4\n%%EOF\n"),
 		image:    {0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'},
 	} {
@@ -304,7 +301,6 @@ func newAgentExampleFiles(t testing.TB, root string) agentExampleFiles {
 		markdown: "./" + filepath.Base(markdown),
 		json:     "./" + filepath.Base(jsonFile),
 		batch:    "./" + filepath.Base(batch),
-		job:      "./" + filepath.Base(job),
 		binary:   "./" + filepath.Base(binary),
 		image:    "./" + filepath.Base(image),
 	}
@@ -355,10 +351,6 @@ func materializeAgentExampleArgv(argv []string, files agentExampleFiles) []strin
 			replacement = files.markdown
 		case "contents-file":
 			replacement = files.json
-		case "from":
-			if strings.HasSuffix(strings.ToLower(value), "job.json") {
-				replacement = files.job
-			}
 		case "batch":
 			if strings.HasSuffix(strings.ToLower(value), "styles.json") {
 				replacement = files.batch

internal/app/schema_recruit_contract_test.go

@@ -1,74 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-
-package app
-
-import (
-	"bytes"
-	"encoding/json"
-	"reflect"
-	"testing"
-)
-
-func recruitSchemaLeaf(t *testing.T, canonical string, compact bool) map[string]any {
-	t.Helper()
-	root := NewRootCommand()
-	var stdout, stderr bytes.Buffer
-	root.SetOut(&stdout)
-	root.SetErr(&stderr)
-	args := []string{"schema", canonical, "--format", "json"}
-	if compact {
-		args = append(args, "--compact")
-	}
-	root.SetArgs(args)
-	if err := root.Execute(); err != nil {
-		t.Fatalf("execute schema %s compact=%v: %v; stderr=%s", canonical, compact, err, stderr.String())
-	}
-	var payload map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
-		t.Fatalf("decode schema %s compact=%v: %v", canonical, compact, err)
-	}
-	return payload
-}
-
-func TestRecruitDeliveredSchemaPublishesResultAndPagination(t *testing.T) {
-	for _, canonical := range []string{"recruit.list_jobs", "recruit.get_job_detail", "recruit.create_job"} {
-		t.Run(canonical, func(t *testing.T) {
-			full := recruitSchemaLeaf(t, canonical, false)
-			compact := recruitSchemaLeaf(t, canonical, true)
-			if full["result"] == nil || compact["result"] == nil {
-				t.Fatalf("result missing: full=%#v compact=%#v", full["result"], compact["result"])
-			}
-			if !reflect.DeepEqual(full["result"], compact["result"]) {
-				t.Fatalf("full/compact result mismatch\nfull=%#v\ncompact=%#v", full["result"], compact["result"])
-			}
-			if canonical == "recruit.list_jobs" {
-				if full["pagination"] == nil || compact["pagination"] == nil {
-					t.Fatalf("list pagination missing: full=%#v compact=%#v", full["pagination"], compact["pagination"])
-				}
-				if !reflect.DeepEqual(full["pagination"], compact["pagination"]) {
-					t.Fatalf("full/compact pagination mismatch\nfull=%#v\ncompact=%#v", full["pagination"], compact["pagination"])
-				}
-				parameters, _ := full["parameters"].(map[string]any)
-				cursor, _ := parameters["cursor"].(map[string]any)
-				if cursor["type"] != "string" || cursor["interface_type"] != "number" {
-					t.Fatalf("cursor contract = %#v, want CLI string converted to MCP number", cursor)
-				}
-				size, _ := parameters["size"].(map[string]any)
-				if required, _ := size["required"].(bool); required {
-					t.Fatalf("size required = true, want false: %#v", size)
-				}
-				if size["default"] != "20" {
-					t.Fatalf("size default = %#v, want 20", size["default"])
-				}
-				compactParameters, _ := compact["parameters"].(map[string]any)
-				compactSize, _ := compactParameters["size"].(map[string]any)
-				if compactRequired, _ := compactSize["required"].(bool); compactRequired || compactSize["default"] != "20" {
-					t.Fatalf("compact size contract = %#v, want required=false default=20", compactSize)
-				}
-			} else if full["pagination"] != nil || compact["pagination"] != nil {
-				t.Fatalf("non-list pagination must be absent: full=%#v compact=%#v", full["pagination"], compact["pagination"])
-			}
-		})
-	}
-}

internal/app/schema_shortcut_contract_test.go

@@ -16,12 +16,12 @@ import (
 )
 
 const (
-	publicShortcutCount = 422
+	publicShortcutCount = 435
 	// schemaPublishedShortcutCount counts every delivered *.shortcut_* tool,
 	// including the hidden historical minutes.shortcut_minutes_search contract.
-	schemaPublishedShortcutCount = 447
+	schemaPublishedShortcutCount = 438
 	// publiclyDeliveredShortcutCount is the public-catalog subset of that surface.
-	publiclyDeliveredShortcutCount = 422
+	publiclyDeliveredShortcutCount = 435
 )
 
 func TestDeliverySchemaCoversOrExactlyExcludesEveryPublicShortcutContract(t *testing.T) {

internal/app/skill_command.go

@@ -117,114 +117,38 @@ type CliSkillDTO struct {
 // (skill_setup.go) MUST have a matching path value here — enforced by
 // TestAgentSkillPathsCoversSetupHomes.
 var agentSkillPaths = map[string]string{
-	// Universal agents. Those without an independent global directory map
-	// directly to the canonical ~/.agents/skills store.
-	"agents":          ".agents/skills",
-	"amp":             filepath.Join(".config", "agents", "skills"),
-	"antigravity":     ".gemini/antigravity/skills",
-	"antigravity-cli": ".gemini/antigravity-cli/skills",
-	"codex":           ".codex/skills",
-	"cursor":          ".cursor/skills",
-	"deepagents":      ".deepagents/agent/skills",
-	"firebender":      ".firebender/skills",
-	"gemini-cli":      ".gemini/skills",
-	"github-copilot":  ".copilot/skills",
-	"opencode":        filepath.Join(".config", "opencode", "skills"),
-	"replit":          filepath.Join(".config", "agents", "skills"),
-	"universal":       filepath.Join(".config", "agents", "skills"),
-	"cline":           ".agents/skills",
-	"dexto":           ".agents/skills",
-	"kimi-code-cli":   ".agents/skills",
-	"loaf":            ".agents/skills",
-	"warp":            ".agents/skills",
-	"zed":             ".agents/skills",
-
-	// Non-universal agents with global Skill directories.
-	"aider-desk":     ".aider-desk/skills",
-	"astrbot":        ".astrbot/data/skills",
-	"autohand-code":  ".autohand/skills",
-	"augment":        ".augment/skills",
-	"bob":            ".bob/skills",
-	"claude-code":    ".claude/skills",
-	"openclaw":       ".openclaw/skills",
-	"codearts-agent": ".codeartsdoer/skills",
-	"codebuddy":      ".codebuddy/skills",
-	"codemaker":      ".codemaker/skills",
-	"codestudio":     ".codestudio/skills",
-	"command-code":   ".commandcode/skills",
-	"continue":       ".continue/skills",
-	"cortex":         ".snowflake/cortex/skills",
-	"crush":          filepath.Join(".config", "crush", "skills"),
-	"devin":          filepath.Join(".config", "devin", "skills"),
-	"droid":          ".factory/skills",
-	"forgecode":      ".forge/skills",
-	"goose":          filepath.Join(".config", "goose", "skills"),
-	"grok":           ".grok/skills",
-	"hermes-agent":   ".hermes/skills",
-	"inference-sh":   ".inferencesh/skills",
-	"jazz":           ".jazz/skills",
-	"junie":          ".junie/skills",
-	"iflow-cli":      ".iflow/skills",
-	"kilo":           ".kilocode/skills",
-	"kimchi":         filepath.Join(".config", "kimchi", "harness", "skills"),
-	"kiro-cli":       ".kiro/skills",
-	"kode":           ".kode/skills",
-	"lingma":         ".lingma/skills",
-	"mcpjam":         ".mcpjam/skills",
-	"minimax-code":   ".minimax/skills",
-	"mistral-vibe":   ".vibe/skills",
-	"moxby":          ".moxby/skills",
-	"mux":            ".mux/skills",
-	"openhands":      ".openhands/skills",
-	"ona":            ".ona/skills",
-	"pi":             ".pi/agent/skills",
-	"qoder":          ".qoder/skills",
-	"qoder-cn":       ".qoder-cn/skills",
-	"qwen-code":      ".qwen/skills",
-	"reasonix":       ".reasonix/skills",
-	"rovodev":        ".rovodev/skills",
-	"roo":            ".roo/skills",
-	"tabnine-cli":    ".tabnine/agent/skills",
-	"terramind":      ".terramind/skills",
-	"tinycloud":      ".tinycloud/skills",
-	"trae":           ".trae/skills",
-	"trae-cn":        ".trae-cn/skills",
-	"windsurf":       ".codeium/windsurf/skills",
-	"zcode":          ".zcode/skills",
-	"zencoder":       ".zencoder/skills",
-	"zenflow":        ".zencoder/skills",
-	"neovate":        ".neovate/skills",
-	"pochi":          ".pochi/skills",
-	"adal":           ".adal/skills",
-
-	// DWS compatibility aliases and DWS-only integrations.
-	"claude":    ".claude/skills",
-	"gemini":    ".gemini/skills",
-	"github":    ".copilot/skills",
-	"hermes":    ".hermes/skills",
-	"kiro":      ".kiro/skills",
+	// `agents` is the generic-agent sentinel: install scripts and `setup`
+	// special-case ~/.agents/skills as a no-checks-required fallback so a
+	// fresh machine without any IDE/agent registry still gets skills.
+	"agents":    ".agents/skills",
+	"qoder":     ".qoder/skills",
 	"qoderwork": ".qoderwork/skills",
-}
-
-// Eve has project-scoped Skill directories but no upstream globalSkillsDir.
-// Keep it in the advertised enumeration while failing explicitly instead of
-// pretending that a global install configured Eve.
-var unsupportedGlobalAgentTargets = map[string]string{
-	"eve":          "Eve 不支持全局 Skill 安装，请在 Eve 项目内配置 agent/skills",
-	"promptscript": "PromptScript 不支持全局 Skill 安装，请在项目内使用 .agents/skills",
+	"claude":    ".claude/skills",
+	"cursor":    ".cursor/skills",
+	"codex":     ".codex/skills",
+	"zcode":     ".zcode/skills",
+	"opencode":  filepath.Join(".config", "opencode", "skills"),
+	// IDE / agent registries also probed by `dws skill setup --target all`.
+	"gemini":   ".gemini/skills",
+	"github":   ".github/skills",
+	"windsurf": ".windsurf/skills",
+	"augment":  ".augment/skills",
+	"cline":    ".cline/skills",
+	"amp":      ".amp/skills",
+	"kiro":     ".kiro/skills",
+	"trae":     ".trae/skills",
+	"openclaw": ".openclaw/skills",
+	"hermes":   ".hermes/skills",
 }
 
 // supportedTargets returns a sorted, comma-separated list of supported
 // targets. Sorted so help text and error messages stay stable across runs
 // (Go map iteration order is intentionally randomized).
 func supportedTargets() string {
-	targets := make([]string, 0, len(agentSkillPaths)+len(unsupportedGlobalAgentTargets)+1)
+	targets := make([]string, 0, len(agentSkillPaths)+1)
 	for target := range agentSkillPaths {
 		targets = append(targets, target)
 	}
-	for target := range unsupportedGlobalAgentTargets {
-		targets = append(targets, target)
-	}
 	sort.Strings(targets)
 	targets = append(targets, ".")
 	return strings.Join(targets, ", ")
@@ -258,28 +182,11 @@ func formatAgentSkillPathsForHelp() string {
 	sort.Strings(names)
 	var b strings.Builder
 	for _, n := range names {
-		installPath := agentSkillPaths[n]
-		if isUniversalSkillInstallTarget(n) {
-			installPath = ".agents/skills"
-		}
-		fmt.Fprintf(&b, "  %-*s -> ~/%s/\n", maxWidth, n, installPath)
+		fmt.Fprintf(&b, "  %-*s -> ~/%s/\n", maxWidth, n, agentSkillPaths[n])
 	}
 	return b.String()
 }
 
-// Universal Agents discover the shared ~/.agents/skills store directly. A
-// marketplace install addressed to one of those Agent IDs must therefore
-// publish to canonical instead of recreating an Agent-private duplicate.
-func isUniversalSkillInstallTarget(target string) bool {
-	rel, ok := agentSkillPaths[target]
-	if !ok {
-		return false
-	}
-	base := filepath.Join("__home__", rel)
-	canonical := filepath.Join("__home__", ".agents", "skills")
-	return sameSkillSetupPath(base, canonical) || isUniversalSkillSetupBase(base)
-}
-
 func buildSkillCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:               "skill",
@@ -578,13 +485,8 @@ func resolveSkillTargetPath(target string) (string, error) {
 		return os.Getwd()
 	}
 
-	target = strings.ToLower(target)
-	if reason, unsupported := unsupportedGlobalAgentTargets[target]; unsupported {
-		return "", errors.New(reason)
-	}
-
-	// Look up predefined agent paths.
-	_, ok := agentSkillPaths[target]
+	// Look up predefined agent paths
+	relPath, ok := agentSkillPaths[strings.ToLower(target)]
 	if !ok {
 		return "", fmt.Errorf("unsupported target")
 	}
@@ -594,11 +496,7 @@ func resolveSkillTargetPath(target string) (string, error) {
 		return "", fmt.Errorf("failed to get home directory: %w", err)
 	}
 
-	destination := resolveSkillSetupBase(homeDir, target)
-	if isUniversalSkillInstallTarget(target) {
-		destination = filepath.Join(homeDir, ".agents", "skills")
-	}
-	return destination, nil
+	return filepath.Join(homeDir, relPath), nil
 }
 
 // fetchSkillDownloadInfo calls the download API to get the skill download URL.

internal/app/skill_command_test.go

@@ -28,7 +28,6 @@ import (
 	"time"
 
 	authpkg "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/auth"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
 )
 
 func TestResolveSkillTargetPath(t *testing.T) {
@@ -58,19 +57,19 @@ func TestResolveSkillTargetPath(t *testing.T) {
 		{
 			name:       "cursor target",
 			target:     "cursor",
-			wantSuffix: filepath.Join(".agents", "skills"),
+			wantSuffix: filepath.Join(".cursor", "skills"),
 			wantErr:    false,
 		},
 		{
 			name:       "codex target",
 			target:     "codex",
-			wantSuffix: filepath.Join(".agents", "skills"),
+			wantSuffix: filepath.Join(".codex", "skills"),
 			wantErr:    false,
 		},
 		{
 			name:       "opencode target",
 			target:     "opencode",
-			wantSuffix: filepath.Join(".agents", "skills"),
+			wantSuffix: filepath.Join(".config", "opencode", "skills"),
 			wantErr:    false,
 		},
 		{
@@ -119,37 +118,6 @@ func TestResolveSkillTargetPath(t *testing.T) {
 	}
 }
 
-func TestCrossPlatformCoverageUniversalSkillInstallTargetsUseCanonical(t *testing.T) {
-	home := t.TempDir()
-	testseam.Swap(t, &skillUserHomeDir, func() (string, error) { return home, nil })
-	if isUniversalSkillInstallTarget("missing-agent") {
-		t.Fatal("unknown Agent target classified as universal")
-	}
-	for _, target := range []string{
-		"amp", "antigravity", "antigravity-cli", "cline", "codex", "cursor",
-		"deepagents", "dexto", "firebender", "gemini", "gemini-cli", "github",
-		"github-copilot", "kimi-code-cli", "loaf", "opencode", "replit",
-		"universal", "warp", "zed",
-	} {
-		got, err := resolveSkillTargetPath(target)
-		if err != nil {
-			t.Fatalf("resolve %s: %v", target, err)
-		}
-		if want := filepath.Join(home, ".agents", "skills"); got != want {
-			t.Errorf("resolve %s = %s, want canonical %s", target, got, want)
-		}
-	}
-	for target, want := range map[string]string{
-		"claude": filepath.Join(home, ".claude", "skills"),
-		"qoder":  filepath.Join(home, ".qoder", "skills"),
-		"zcode":  filepath.Join(home, ".zcode", "skills"),
-	} {
-		if got, err := resolveSkillTargetPath(target); err != nil || got != want {
-			t.Errorf("resolve non-universal %s = %s, %v; want %s", target, got, err, want)
-		}
-	}
-}
-
 func TestResolveSkillTargetPathCurrentDir(t *testing.T) {
 	// Test "." target returns current working directory
 	cwd, err := os.Getwd()
@@ -509,12 +477,8 @@ func TestAgentSkillPathsCoversSetupHomes(t *testing.T) {
 	for _, p := range agentSkillPaths {
 		paths[p] = true
 	}
-	legacyCleanupOnly := map[string]bool{
-		".github/skills": true, ".windsurf/skills": true,
-		".cline/skills": true, ".amp/skills": true,
-	}
 	for _, home := range skillSetupAgentHomes {
-		if !paths[home] && !legacyCleanupOnly[home] {
+		if !paths[home] {
 			t.Errorf("skillSetupAgentHomes entry %q has no matching agentSkillPaths value — "+
 				"add it to agentSkillPaths so users can address it via --target <name>", home)
 		}

internal/app/skill_setup.go

@@ -6,7 +6,6 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"runtime"
 	"sort"
 	"strings"
 	"time"
@@ -24,77 +23,22 @@ import (
 // agree on the install footprint.
 var skillSetupAgentHomes = []string{
 	".agents/skills",
-	".config/agents/skills",
-	".gemini/antigravity/skills",
-	".gemini/antigravity-cli/skills",
-	".deepagents/agent/skills",
-	".firebender/skills",
-	".copilot/skills",
-	".config/opencode/skills",
-	".aider-desk/skills",
-	".astrbot/data/skills",
-	".autohand/skills",
-	".augment/skills",
-	".bob/skills",
 	".claude/skills",
-	".openclaw/skills",
-	".codeartsdoer/skills",
-	".codebuddy/skills",
-	".codemaker/skills",
-	".codestudio/skills",
-	".commandcode/skills",
-	".continue/skills",
-	".snowflake/cortex/skills",
-	".config/crush/skills",
-	".config/devin/skills",
-	".factory/skills",
-	".forge/skills",
-	".config/goose/skills",
-	".grok/skills",
-	".hermes/skills",
-	".inferencesh/skills",
-	".jazz/skills",
-	".junie/skills",
-	".iflow/skills",
-	".kilocode/skills",
-	".config/kimchi/harness/skills",
-	".kiro/skills",
-	".kode/skills",
-	".lingma/skills",
-	".mcpjam/skills",
-	".minimax/skills",
-	".vibe/skills",
-	".moxby/skills",
-	".mux/skills",
-	".openhands/skills",
-	".ona/skills",
-	".pi/agent/skills",
-	".qoder/skills",
-	".qoder-cn/skills",
-	".qwen/skills",
-	".reasonix/skills",
-	".rovodev/skills",
-	".roo/skills",
-	".tabnine/agent/skills",
-	".terramind/skills",
-	".tinycloud/skills",
-	".trae/skills",
-	".trae-cn/skills",
-	".codeium/windsurf/skills",
-	".zcode/skills",
-	".zencoder/skills",
-	".neovate/skills",
-	".pochi/skills",
-	".adal/skills",
-	".qoderwork/skills",
-	// beta.6 compatibility roots: cleanup only.
 	".cursor/skills",
+	".qoder/skills",
+	".qoderwork/skills",
 	".gemini/skills",
 	".codex/skills",
+	".zcode/skills",
 	".github/skills",
 	".windsurf/skills",
+	".augment/skills",
 	".cline/skills",
 	".amp/skills",
+	".kiro/skills",
+	".trae/skills",
+	".openclaw/skills",
+	".hermes/skills",
 }
 
 const (
@@ -121,20 +65,15 @@ var (
 	skillSetupInteractive     = isInteractiveTerminal
 	skillSetupReadDir         = os.ReadDir
 	skillSetupStat            = os.Stat
-	skillSetupLstat           = os.Lstat
-	skillSetupGetenv          = os.Getenv
-	skillSetupSymlink         = os.Symlink
 	skillSetupExecutable      = os.Executable
 	skillSetupGetwd           = os.Getwd
 	skillSetupUserHomeDir     = os.UserHomeDir
 	skillSetupRemoveAll       = os.RemoveAll
 	skillSetupBackupAndRemove = upgrade.BackupAndRemoveSkillDir
-	skillSetupRestoreBackup   = upgrade.RestoreSkillPath
 	skillSetupMkdirAll        = os.MkdirAll
 	skillSetupWalk            = filepath.Walk
 	skillSetupRel             = filepath.Rel
 	skillSetupReadlink        = os.Readlink
-	skillSetupEvalSymlinks    = filepath.EvalSymlinks
 	skillSetupOpen            = os.Open
 	skillSetupOpenFile        = os.OpenFile
 	skillSetupWriteFile       = os.WriteFile
@@ -143,10 +82,7 @@ var (
 	skillSetupReadState       = skillstate.Read
 	skillSetupWriteState      = skillstate.Write
 	skillSetupRemoveState     = skillstate.Remove
-	skillSetupPublishPath     = upgrade.PublishSkillPathNoReplace
-	skillSetupRollbackPaths   = upgrade.RollbackSkillPathPublications
 	skillSetupNow             = time.Now
-	skillSetupFoldPathCase    = runtime.GOOS == "windows"
 )
 
 type skillSetupBackup struct {
@@ -155,11 +91,9 @@ type skillSetupBackup struct {
 }
 
 type skillSetupTargetPlan struct {
-	Destination   string
-	CanonicalBase string
-	Backups       []skillSetupBackup
-	CleanupOnly   bool
-	LinkCanonical bool
+	Destination string
+	Backups     []skillSetupBackup
+	CleanupOnly bool
 }
 
 type skillSetupPlan struct {
@@ -215,9 +149,8 @@ multi 模式支持按产品挑选：
     备份失败时保留原目录并跳过该目标，绝不静默删除。
   · 所有将被移除的目录都会在确认前逐条列出。
 
-不带 --mode 时进入交互式询问；Skill 统一安装到 ~/.agents/skills。
-DWS 会自动适配本机上检测到的 Agent；共享安装方式不可用时会自动改用兼容安装，
-无需用户手动处理，也不会让同一个 Skill 重复出现。
+不带 --mode 时进入交互式询问；不带 --target 时铺到检测到的具体 Agent 目录；
+未检测到具体 Agent 时才回退到 ~/.agents/skills，避免同一 Agent 扫描两份 Skill。
 skill 源默认取二进制内嵌的版本（升级二进制即升级 skill）；--source / DWS_SKILL_SOURCE 可显式覆盖。`,
 		Example: `  dws skill setup --mode multi --target claude --dry-run
   dws skill setup --mode multi --target claude`,
@@ -310,6 +243,7 @@ func runSkillSetup(cmd *cobra.Command, _ []string) error {
 			}
 		}
 	}
+
 	// filtered 决定 multi 安装的清理语义：带 -s/--skill 或 -x/--exclude
 	// 时保持 additive（不动未列出的 sibling）；全量安装与 install.sh /
 	// install.js 对齐，清掉不在 bundle 内且有明确 DWS 所有权记录的过期 Skill。
@@ -382,17 +316,6 @@ func runSkillSetup(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return err
 	}
-	if mode == skillSetupModeMulti && len(migrateEventMiscTargets) > 0 {
-		retiredNames := append([]string(nil), multiSkillNames...)
-		if installsEventMiscCompanion && !containsSkillName(retiredNames, multiMiscSkill) {
-			retiredNames = append(retiredNames, multiMiscSkill)
-		}
-		if retireErr := retireMigratedUniversalSkills(migrateEventMiscTargets, retiredNames, out); retireErr != nil {
-			// Retiring an obsolete universal copy installs nothing; report it and
-			// keep the successful installation rather than failing the run.
-			fmt.Fprintf(errOut, "  ⚠️  %v\n", retireErr)
-		}
-	}
 	if skipped > 0 {
 		return fmt.Errorf(
 			"Skill 安装不完整（mode=%s, installed=%d, skipped=%d）；修复失败原因后请重试 setup，或运行普通 upgrade 全量刷新预制 Skill",
@@ -427,9 +350,7 @@ func runSkillSetup(cmd *cobra.Command, _ []string) error {
 		}
 	}
 	fmt.Fprintf(out, "\n✅ Skill 安装完成（mode=%s, installed=%d, skipped=%d）\n", mode, installed, skipped)
-	fmt.Fprintln(out, "   统一安装位置：~/.agents/skills")
-	fmt.Fprintln(out, "   已自动适配本机上检测到的 Agent")
-	fmt.Fprintln(out, "ℹ️  下一步：请重启已打开的 Agent，使新 Skills 生效。")
+	fmt.Fprintln(out, "ℹ️  若 Agent 会话已打开，请重启 Agent 或重新加载 Skills 后再验证路由。")
 	return nil
 }
 
@@ -989,9 +910,8 @@ func isSkillSourceRoot(path, mode string) bool {
 }
 
 // resolveSkillSetupTargets returns the list of absolute Agent home destinations.
-// The canonical ~/.agents/skills destination is always first. If target ==
-// "all", detected concrete Agent roots follow it. A specific target follows
-// canonical as well so unknown/future Agents retain the universal copy.
+// If target == "all", returns every agent home whose parent directory exists.
+// Otherwise returns the single matching home (whether or not it currently exists).
 //
 // 末段约定：
 //   - mono  → <agent-home>/dws   （单 skill，整个 src 拷成一个 dws 目录）
@@ -1003,88 +923,15 @@ func resolveSkillSetupTargets(target, mode string) ([]string, error) {
 	}
 
 	target = strings.ToLower(strings.TrimSpace(target))
-	canonical := agentHomeForMode(filepath.Join(home, skillSetupAgentHomes[0]), mode)
 	if target == "" || target == "all" {
 		return detectExistingAgentHomes(home, mode), nil
 	}
 
-	if reason, unsupported := unsupportedGlobalAgentTargets[target]; unsupported {
-		return nil, errors.New(reason)
-	}
-	_, ok := agentSkillPaths[target]
+	rel, ok := agentSkillPaths[target]
 	if !ok {
 		return nil, fmt.Errorf("不支持的 --target 值: %s（可选 all, %s）", target, supportedTargets())
 	}
-	dest := agentHomeForMode(resolveSkillSetupBase(home, target), mode)
-	if sameSkillSetupPath(dest, canonical) {
-		return []string{canonical}, nil
-	}
-	return []string{canonical, dest}, nil
-}
-
-func resolveOpenClawSetupBase(home string) string {
-	for _, name := range []string{".openclaw", ".clawdbot", ".moltbot"} {
-		base := filepath.Join(home, name)
-		if info, err := skillSetupStat(base); err == nil && info.IsDir() {
-			return filepath.Join(base, "skills")
-		}
-	}
-	return filepath.Join(home, ".openclaw", "skills")
-}
-
-func resolveSkillSetupBase(home, target string) string {
-	switch target {
-	case "claude", "claude-code":
-		if custom := strings.TrimSpace(skillSetupGetenv("CLAUDE_CONFIG_DIR")); custom != "" {
-			return filepath.Join(custom, "skills")
-		}
-	case "codex":
-		if custom := strings.TrimSpace(skillSetupGetenv("CODEX_HOME")); custom != "" {
-			return filepath.Join(custom, "skills")
-		}
-	case "hermes", "hermes-agent":
-		if custom := strings.TrimSpace(skillSetupGetenv("HERMES_HOME")); custom != "" {
-			return filepath.Join(custom, "skills")
-		}
-	case "autohand-code":
-		if custom := strings.TrimSpace(skillSetupGetenv("AUTOHAND_HOME")); custom != "" {
-			return filepath.Join(custom, "skills")
-		}
-	case "grok":
-		if custom := strings.TrimSpace(skillSetupGetenv("GROK_HOME")); custom != "" {
-			return filepath.Join(custom, "skills")
-		}
-	case "mistral-vibe":
-		if custom := strings.TrimSpace(skillSetupGetenv("VIBE_HOME")); custom != "" {
-			return filepath.Join(custom, "skills")
-		}
-	case "openclaw":
-		return resolveOpenClawSetupBase(home)
-	case "opencode", "amp", "replit", "universal", "crush", "devin", "goose", "kimchi":
-		configHome := strings.TrimSpace(skillSetupGetenv("XDG_CONFIG_HOME"))
-		if configHome == "" {
-			configHome = filepath.Join(home, ".config")
-		}
-		switch target {
-		case "opencode":
-			return filepath.Join(configHome, "opencode", "skills")
-		case "amp", "replit", "universal":
-			return filepath.Join(configHome, "agents", "skills")
-		case "crush":
-			return filepath.Join(configHome, "crush", "skills")
-		case "devin":
-			return filepath.Join(configHome, "devin", "skills")
-		case "goose":
-			return filepath.Join(configHome, "goose", "skills")
-		case "kimchi":
-			return filepath.Join(configHome, "kimchi", "harness", "skills")
-		}
-	case "github", "github-copilot":
-		return filepath.Join(home, ".copilot", "skills")
-	case "windsurf":
-		return filepath.Join(home, ".codeium", "windsurf", "skills")
-	}
-	return filepath.Join(home, agentSkillPaths[target])
+	return []string{agentHomeForMode(filepath.Join(home, rel), mode)}, nil
 }
 
 // agentHomeForMode appends the mode-specific tail segment to an agent home base.
@@ -1096,141 +943,79 @@ func agentHomeForMode(base, mode string) string {
 }
 
 func detectExistingAgentHomes(home, mode string) []string {
-	canonical := agentHomeForMode(filepath.Join(home, skillSetupAgentHomes[0]), mode)
-	dests := []string{canonical}
-	canonicalKey := skillSetupPathKey(canonical)
-	seen := map[string]bool{canonicalKey: true}
-	addDetected := func(rel, base string) {
-		detectedDir := filepath.Dir(base)
-		switch filepath.ToSlash(filepath.Clean(rel)) {
-		case ".config/kimchi/harness/skills", ".tabnine/agent/skills":
-			detectedDir = filepath.Dir(filepath.Dir(base))
-		case ".zcode/skills":
-			// Application bundles are machine-scoped detection signals. Keep this
-			// independent of HOME so setup matches npm, Shell, and PowerShell.
-			if info, err := skillSetupStat(filepath.Join(string(filepath.Separator), "Applications", "ZCode.app")); err == nil && info.IsDir() {
-				detectedDir = ""
-			}
-		case ".minimax/skills":
-			if info, err := skillSetupStat(filepath.Join(string(filepath.Separator), "Applications", "MiniMax Code.app")); err == nil && info.IsDir() {
-				detectedDir = ""
-			}
-		}
-		if detectedDir != "" {
-			if info, err := skillSetupStat(detectedDir); err != nil || !info.IsDir() {
-				return
-			}
-		}
-		dest := agentHomeForMode(base, mode)
-		key := skillSetupPathKey(dest)
-		if !seen[key] {
-			seen[key] = true
-			dests = append(dests, dest)
-		}
-	}
+	var specific []string
 	for i, rel := range skillSetupAgentHomes {
 		if i == 0 {
 			continue
 		}
 		base := filepath.Join(home, rel)
-		switch filepath.ToSlash(filepath.Clean(rel)) {
-		case ".claude/skills":
-			base = resolveSkillSetupBase(home, "claude-code")
-		case ".codex/skills":
-			base = resolveSkillSetupBase(home, "codex")
-		case ".hermes/skills":
-			base = resolveSkillSetupBase(home, "hermes-agent")
-		case ".autohand/skills":
-			base = resolveSkillSetupBase(home, "autohand-code")
-		case ".grok/skills":
-			base = resolveSkillSetupBase(home, "grok")
-		case ".vibe/skills":
-			base = resolveSkillSetupBase(home, "mistral-vibe")
-		case ".openclaw/skills":
-			base = resolveSkillSetupBase(home, "openclaw")
-		case ".config/opencode/skills":
-			base = resolveSkillSetupBase(home, "opencode")
-		case ".config/agents/skills":
-			base = resolveSkillSetupBase(home, "amp")
-		case ".config/crush/skills":
-			base = resolveSkillSetupBase(home, "crush")
-		case ".config/devin/skills":
-			base = resolveSkillSetupBase(home, "devin")
-		case ".config/goose/skills":
-			base = resolveSkillSetupBase(home, "goose")
-		case ".config/kimchi/harness/skills":
-			base = resolveSkillSetupBase(home, "kimchi")
+		parent := filepath.Dir(base)
+		if info, err := skillSetupStat(parent); err != nil || !info.IsDir() {
+			continue
 		}
-		addDetected(rel, base)
+		specific = append(specific, agentHomeForMode(base, mode))
 	}
-	for _, target := range []string{"github-copilot", "windsurf"} {
-		addDetected(agentSkillPaths[target], resolveSkillSetupBase(home, target))
+	if len(specific) > 0 {
+		return specific
 	}
-	return dests
+	return []string{agentHomeForMode(filepath.Join(home, skillSetupAgentHomes[0]), mode)}
 }
 
-func skillSetupBaseForMode(dest, mode string) string {
-	if mode == skillSetupModeMono {
-		return filepath.Dir(dest)
-	}
-	return dest
-}
-
-func isUniversalSkillSetupBase(base string) bool {
-	cleanBase := filepath.Clean(base)
-	if custom := strings.TrimSpace(skillSetupGetenv("CODEX_HOME")); custom != "" && sameSkillSetupPath(cleanBase, filepath.Join(custom, "skills")) {
-		return true
-	}
-	if custom := strings.TrimSpace(skillSetupGetenv("XDG_CONFIG_HOME")); custom != "" {
-		if sameSkillSetupPath(cleanBase, filepath.Join(custom, "agents", "skills")) ||
-			sameSkillSetupPath(cleanBase, filepath.Join(custom, "opencode", "skills")) {
-			return true
-		}
-	}
-	base = filepath.ToSlash(cleanBase)
-	for rel := range map[string]bool{
-		".config/agents/skills": true, ".gemini/antigravity/skills": true,
-		".gemini/antigravity-cli/skills": true, ".codex/skills": true,
-		".cursor/skills": true, ".deepagents/agent/skills": true,
-		".firebender/skills": true, ".gemini/skills": true,
-		".copilot/skills": true, ".config/opencode/skills": true,
-		// beta.6 compatibility roots are cleanup-only.
-		".github/skills": true, ".windsurf/skills": true,
-		".cline/skills": true, ".amp/skills": true,
-	} {
-		if strings.HasSuffix(base, "/"+rel) {
-			return true
-		}
-	}
-	return false
-}
-
-func sameSkillSetupPath(left, right string) bool {
-	return skillSetupPathKey(left) == skillSetupPathKey(right)
-}
-
-func skillSetupPathKey(path string) string {
-	clean := filepath.Clean(path)
-	if skillSetupFoldPathCase {
-		clean = strings.ToLower(clean)
-	}
-	return clean
-}
-
-func canonicalSkillSetupBase(dests []string, mode string) string {
+func genericSkillCleanupTarget(dests []string, managed map[string]bool) (*skillSetupTargetPlan, error) {
+	// Derive HOME from a concrete Agent destination instead of resolving it a
+	// second time. The destinations were already resolved from HOME by the
+	// caller, and a later/transient UserHomeDir failure must not turn an
+	// otherwise valid setup plan into an error. Direct/custom destinations that
+	// do not match a known concrete Agent root have no generic-root migration.
+	home := ""
 	for _, dest := range dests {
-		base := filepath.ToSlash(filepath.Clean(skillSetupBaseForMode(dest, mode)))
-		if strings.HasSuffix(base, "/.agents/skills") {
-			return skillSetupBaseForMode(dest, mode)
+		base := dest
+		if filepath.Base(dest) == "dws" {
+			base = filepath.Dir(dest)
+		}
+		base = filepath.Clean(base)
+		for i, rel := range skillSetupAgentHomes {
+			if i == 0 {
+				continue
+			}
+			suffix := filepath.Clean(filepath.FromSlash(rel))
+			needle := string(filepath.Separator) + suffix
+			if strings.HasSuffix(base, needle) {
+				home = strings.TrimSuffix(base, needle)
+				break
+			}
+		}
+		if home != "" {
+			break
 		}
 	}
-	return ""
-}
+	if home == "" {
+		return nil, nil
+	}
+	genericBase := filepath.Join(home, ".agents", "skills")
 
-func samePhysicalSkillSetupPath(left, right string) bool {
-	leftReal, leftErr := skillSetupEvalSymlinks(left)
-	rightReal, rightErr := skillSetupEvalSymlinks(right)
-	return leftErr == nil && rightErr == nil && sameSkillSetupPath(leftReal, rightReal)
+	target := &skillSetupTargetPlan{Destination: genericBase, CleanupOnly: true}
+	add := func(path, reason string) {
+		if info, statErr := skillSetupStat(path); statErr == nil && info.IsDir() {
+			target.Backups = append(target.Backups, skillSetupBackup{Path: path, Reason: reason})
+		}
+	}
+	add(filepath.Join(genericBase, "dws"), skillSetupBackupMutual)
+	entries, readErr := skillSetupReadDir(genericBase)
+	if readErr != nil && !errors.Is(readErr, os.ErrNotExist) {
+		return nil, fmt.Errorf("扫描通用 Skill 根目录失败 %s: %w", genericBase, readErr)
+	}
+	for _, entry := range entries {
+		path := filepath.Join(genericBase, entry.Name())
+		if entry.IsDir() && isManagedDWSMultiSkillDir(path, managed) {
+			target.Backups = append(target.Backups, skillSetupBackup{Path: path, Reason: skillSetupBackupStale})
+		}
+	}
+	if len(target.Backups) == 0 {
+		return nil, nil
+	}
+	sort.Slice(target.Backups, func(i, j int) bool { return target.Backups[i].Path < target.Backups[j].Path })
+	return target, nil
 }
 
 func buildSkillSetupPlan(mode, src string, dests, multiSkillNames []string, filtered bool) (*skillSetupPlan, error) {
@@ -1245,26 +1030,10 @@ func buildSkillSetupPlan(mode, src string, dests, multiSkillNames []string, filt
 	}
 	sort.Strings(plan.MultiSkillNames)
 	sortedDests := append([]string(nil), dests...)
-	sort.Slice(sortedDests, func(i, j int) bool {
-		leftCanonical := strings.HasSuffix(filepath.ToSlash(filepath.Clean(skillSetupBaseForMode(sortedDests[i], mode))), "/.agents/skills")
-		rightCanonical := strings.HasSuffix(filepath.ToSlash(filepath.Clean(skillSetupBaseForMode(sortedDests[j], mode))), "/.agents/skills")
-		if leftCanonical != rightCanonical {
-			return leftCanonical
-		}
-		return sortedDests[i] < sortedDests[j]
-	})
+	sort.Strings(sortedDests)
 	managedNames := currentManagedSkillNames()
-	canonicalBase := canonicalSkillSetupBase(sortedDests, mode)
 	for _, dest := range sortedDests {
-		base := skillSetupBaseForMode(dest, mode)
-		target := skillSetupTargetPlan{Destination: dest, CanonicalBase: canonicalBase}
-		if canonicalBase != "" && filepath.Clean(base) != filepath.Clean(canonicalBase) {
-			if isUniversalSkillSetupBase(base) {
-				target.CleanupOnly = true
-			} else {
-				target.LinkCanonical = true
-			}
-		}
+		target := skillSetupTargetPlan{Destination: dest}
 		seen := map[string]bool{}
 		add := func(path, reason string) {
 			if seen[path] {
@@ -1308,22 +1077,26 @@ func buildSkillSetupPlan(mode, src string, dests, multiSkillNames []string, filt
 			}
 		}
 		for _, path := range replacements {
-			if target.LinkCanonical && samePhysicalSkillSetupPath(path, filepath.Join(target.CanonicalBase, filepath.Base(path))) {
-				continue
-			}
-			_, statErr := skillSetupLstat(path)
+			info, statErr := skillSetupStat(path)
 			if statErr != nil {
 				if errors.Is(statErr, os.ErrNotExist) {
 					continue
 				}
 				return nil, fmt.Errorf("检查将被替换的 Skill 失败 %s: %w", path, statErr)
 			}
-			add(path, skillSetupBackupReplace)
+			if info.IsDir() {
+				add(path, skillSetupBackupReplace)
+			}
 		}
 		sort.Slice(target.Backups, func(i, j int) bool { return target.Backups[i].Path < target.Backups[j].Path })
-		if !target.CleanupOnly || len(target.Backups) > 0 {
-			plan.Targets = append(plan.Targets, target)
-		}
+		plan.Targets = append(plan.Targets, target)
+	}
+	cleanupTarget, cleanupErr := genericSkillCleanupTarget(sortedDests, managedNames)
+	if cleanupErr != nil {
+		return nil, cleanupErr
+	}
+	if cleanupTarget != nil {
+		plan.Targets = append(plan.Targets, *cleanupTarget)
 	}
 	return plan, nil
 }
@@ -1367,33 +1140,6 @@ func configureEventMiscMigrationPlan(plan *skillSetupPlan, targets []string, ins
 	}
 }
 
-func retireMigratedUniversalSkills(targets, names []string, out io.Writer) error {
-	home, err := skillSetupUserHomeDir()
-	if err != nil {
-		return fmt.Errorf("无法解析 HOME 以退役 universal Agent 旧副本: %w", err)
-	}
-	seen := map[string]bool{}
-	var victims []skillSetupBackup
-	for _, target := range targets {
-		if !isUniversalSkillSetupBase(target) {
-			continue
-		}
-		for _, name := range names {
-			path := filepath.Join(target, name)
-			if seen[path] {
-				continue
-			}
-			seen[path] = true
-			victims = append(victims, skillSetupBackup{Path: path, Reason: skillSetupBackupReplace})
-		}
-	}
-	sort.Slice(victims, func(i, j int) bool { return victims[i].Path < victims[j].Path })
-	if _, err := backupSkillSetupTarget(home, victims, out); err != nil {
-		return fmt.Errorf("退役 universal Agent Event/misc 旧副本失败，已回滚: %w", err)
-	}
-	return nil
-}
-
 func renderSkillSetupPlan(out io.Writer, plan *skillSetupPlan) {
 	fmt.Fprintf(out, "📦 将安装 skill：\n  mode: %s\n  source: %s\n", plan.Mode, plan.Source)
 	if plan.Mode == skillSetupModeMulti {
@@ -1402,14 +1148,12 @@ func renderSkillSetupPlan(out io.Writer, plan *skillSetupPlan) {
 			fmt.Fprintf(out, "    · %s\n", name)
 		}
 	}
-	fmt.Fprintln(out, "  安装与适配位置:")
+	fmt.Fprintln(out, "  destinations:")
 	for _, target := range plan.Targets {
 		if target.CleanupOnly {
-			fmt.Fprintf(out, "    - %s（移除该 Agent 中的旧版 DWS Skills，改用统一安装位置）\n", target.Destination)
-		} else if target.LinkCanonical {
-			fmt.Fprintf(out, "    - %s（自动配置此 Agent 使用统一安装位置）\n", target.Destination)
+			fmt.Fprintf(out, "    - %s (仅迁移旧的通用 DWS 副本)\n", target.Destination)
 		} else {
-			fmt.Fprintf(out, "    - %s（统一安装位置）\n", target.Destination)
+			fmt.Fprintf(out, "    - %s\n", target.Destination)
 		}
 	}
 	fmt.Fprintln(out, "  将备份并移除（先保存到 ~/.dws/skill-backups/）：")
@@ -1580,12 +1324,8 @@ func installMultiSkillsWithEventMigration(
 	}
 
 	migrationSet := make(map[string]struct{}, len(migrationTargets))
-	physicalMigrationTargets := make([]string, 0, len(migrationTargets))
 	for _, dest := range migrationTargets {
 		migrationSet[dest] = struct{}{}
-		if !isUniversalSkillSetupBase(dest) {
-			physicalMigrationTargets = append(physicalMigrationTargets, dest)
-		}
 	}
 	var ordinaryTargets []string
 	for _, dest := range dests {
@@ -1594,47 +1334,23 @@ func installMultiSkillsWithEventMigration(
 		}
 	}
 
-	var canonicalTargets, otherOrdinaryTargets []string
-	for _, dest := range ordinaryTargets {
-		base := filepath.ToSlash(filepath.Clean(skillSetupBaseForMode(dest, skillSetupModeMulti)))
-		if strings.HasSuffix(base, "/.agents/skills") {
-			canonicalTargets = append(canonicalTargets, dest)
-		} else {
-			otherOrdinaryTargets = append(otherOrdinaryTargets, dest)
-		}
-	}
-	installOrdinary := func(names, targets []string) error {
-		if len(targets) == 0 {
-			return nil
-		}
+	if len(ordinaryTargets) > 0 {
 		var n, nSkipped int
-		n, nSkipped, err = skillSetupInstallMulti(src, names, targets, out, errOut, filtered)
+		n, nSkipped, err = skillSetupInstallMulti(src, skillNames, ordinaryTargets, out, errOut, filtered)
 		installed += n
 		skipped += nSkipped
 		if err != nil {
-			return err
+			return installed, skipped, err
 		}
 		if nSkipped > 0 {
-			return fmt.Errorf("multi Skill 安装不完整（skipped=%d）；已保留折叠版 Event/misc，未执行迁移", nSkipped)
+			return installed, skipped, fmt.Errorf("multi Skill 安装不完整（skipped=%d）；已保留折叠版 Event/misc，未执行迁移", nSkipped)
 		}
-		return nil
-	}
-	canonicalNames := append([]string(nil), skillNames...)
-	if !containsSkillName(canonicalNames, multiMiscSkill) {
-		canonicalNames = append(canonicalNames, multiMiscSkill)
-		sort.Strings(canonicalNames)
-	}
-	if err := installOrdinary(canonicalNames, canonicalTargets); err != nil {
-		return installed, skipped, err
-	}
-	if err := installOrdinary(skillNames, otherOrdinaryTargets); err != nil {
-		return installed, skipped, err
 	}
 
 	// The folded pair is excluded from the ordinary best-effort installer. All
 	// other selected skills (especially dingtalk-shared) must succeed before the
 	// old Event route is touched.
-	for _, dest := range physicalMigrationTargets {
+	for _, dest := range migrationTargets {
 		if cleanupErr := cleanupMutualExclusion(dest, skillSetupModeMulti, out, errOut); cleanupErr != nil {
 			return installed, skipped + len(skillNames), cleanupErr
 		}
@@ -1645,9 +1361,9 @@ func installMultiSkillsWithEventMigration(
 			prerequisiteNames = append(prerequisiteNames, name)
 		}
 	}
-	if len(prerequisiteNames) > 0 && len(physicalMigrationTargets) > 0 {
+	if len(prerequisiteNames) > 0 {
 		var n, nSkipped int
-		n, nSkipped, err = skillSetupInstallMulti(src, prerequisiteNames, physicalMigrationTargets, out, errOut, true)
+		n, nSkipped, err = skillSetupInstallMulti(src, prerequisiteNames, migrationTargets, out, errOut, true)
 		installed += n
 		skipped += nSkipped
 		if err != nil {
@@ -1658,7 +1374,7 @@ func installMultiSkillsWithEventMigration(
 		}
 	}
 
-	migrated, migrationErr := migrateEventMiscAtomically(src, physicalMigrationTargets, out, errOut)
+	migrated, migrationErr := migrateEventMiscAtomically(src, migrationTargets, out, errOut)
 	installed += migrated
 	if migrationErr != nil {
 		return installed, skipped, migrationErr
@@ -1930,32 +1646,9 @@ func stageSkillSetupTarget(plan *skillSetupPlan, target skillSetupTargetPlan) (s
 			err = errors.Join(err, fmt.Errorf("清理 Skill staging 失败 %s: %w", stageRoot, cleanupErr))
 		}
 	}()
-	realStageParent, realParentErr := skillSetupEvalSymlinks(stageParent)
-	if realParentErr != nil {
-		return stageRoot, nil, fmt.Errorf("解析 Agent Skill 物理目录失败 %s: %w", stageParent, realParentErr)
-	}
 
 	stageOne := func(src, dest string) error {
 		stagedDir := filepath.Join(stageRoot, filepath.Base(dest))
-		if target.LinkCanonical {
-			canonicalTarget := filepath.Join(target.CanonicalBase, filepath.Base(dest))
-			if samePhysicalSkillSetupPath(dest, canonicalTarget) {
-				return nil
-			}
-			realCanonicalTarget, realTargetErr := skillSetupEvalSymlinks(canonicalTarget)
-			if realTargetErr != nil {
-				return fmt.Errorf("解析 canonical Skill 失败 %s: %w", canonicalTarget, realTargetErr)
-			}
-			relTarget, relErr := skillSetupRel(realStageParent, realCanonicalTarget)
-			if relErr != nil {
-				return fmt.Errorf("计算 Skill 相对链接失败 %s: %w", canonicalTarget, relErr)
-			}
-			if linkErr := skillSetupSymlink(relTarget, stagedDir); linkErr != nil {
-				return fmt.Errorf("创建 Skill 链接失败 %s -> %s: %w", stagedDir, relTarget, linkErr)
-			}
-			staged = append(staged, skillSetupStagedDir{staged: stagedDir, dest: dest})
-			return nil
-		}
 		if err := skillSetupMkdirAll(stagedDir, 0o755); err != nil {
 			return fmt.Errorf("创建 Skill staging 目录失败 %s: %w", stagedDir, err)
 		}
@@ -1982,11 +1675,16 @@ func stageSkillSetupTarget(plan *skillSetupPlan, target skillSetupTargetPlan) (s
 
 // restoreSkillSetupTarget removes a partially published replacement and
 // restores every original directory from its exact backup path.
-func restoreSkillSetupTarget(published []upgrade.SkillPathPublication, backups []skillSetupBackedUpDir) error {
-	restoreErr := skillSetupRollbackPaths(published)
+func restoreSkillSetupTarget(published []string, backups []skillSetupBackedUpDir) error {
+	var restoreErr error
+	for i := len(published) - 1; i >= 0; i-- {
+		if err := skillSetupRemoveAll(published[i]); err != nil {
+			restoreErr = errors.Join(restoreErr, fmt.Errorf("移除失败发布目录 %s: %w", published[i], err))
+		}
+	}
 	for i := len(backups) - 1; i >= 0; i-- {
 		item := backups[i]
-		if _, err := skillSetupLstat(item.original); err == nil {
+		if _, err := skillSetupStat(item.original); err == nil {
 			restoreErr = errors.Join(restoreErr, fmt.Errorf("恢复目标仍存在 %s；备份保留于 %s", item.original, item.backup))
 			continue
 		} else if !errors.Is(err, os.ErrNotExist) {
@@ -1997,7 +1695,7 @@ func restoreSkillSetupTarget(published []upgrade.SkillPathPublication, backups [
 			restoreErr = errors.Join(restoreErr, fmt.Errorf("创建 Skill 恢复目录失败 %s: %w；备份保留于 %s", filepath.Dir(item.original), err, item.backup))
 			continue
 		}
-		if err := skillSetupRestoreBackup(item.backup, item.original); err != nil {
+		if err := skillSetupPublishRename(item.backup, item.original); err != nil {
 			restoreErr = errors.Join(restoreErr, fmt.Errorf("恢复原 Skill 失败 %s: %w；备份保留于 %s", item.original, err, item.backup))
 		}
 	}
@@ -2030,53 +1728,45 @@ func backupSkillSetupTarget(home string, planned []skillSetupBackup, out io.Writ
 }
 
 func publishSkillSetupTarget(staged []skillSetupStagedDir, backups []skillSetupBackedUpDir) error {
-	published := make([]upgrade.SkillPathPublication, 0, len(staged))
+	published := make([]string, 0, len(staged))
 	for _, item := range staged {
-		publication, err := skillSetupPublishPath(item.staged, item.dest)
-		if err != nil {
+		// Record before rename so rollback also removes a destination created by
+		// a platform-specific partial failure.
+		published = append(published, item.dest)
+		if err := skillSetupPublishRename(item.staged, item.dest); err != nil {
 			publishErr := fmt.Errorf("发布 Skill 失败 %s: %w", item.dest, err)
 			if restoreErr := restoreSkillSetupTarget(published, backups); restoreErr != nil {
 				return errors.Join(publishErr, fmt.Errorf("Skill setup 回滚不完整: %w", restoreErr))
 			}
 			return publishErr
 		}
-		published = append(published, publication)
 	}
 	return nil
 }
 
 func executeSkillSetupPlan(plan *skillSetupPlan, out, errOut io.Writer) (installed, skipped int, err error) {
 	home, homeErr := skillSetupUserHomeDir()
-	hasCanonicalDependents := false
-	for _, candidate := range plan.Targets {
-		if candidate.CanonicalBase != "" && !sameSkillSetupPath(skillSetupBaseForMode(candidate.Destination, plan.Mode), candidate.CanonicalBase) {
-			hasCanonicalDependents = true
-			break
-		}
+	perTarget := 1
+	if plan.Mode == skillSetupModeMulti {
+		perTarget = len(plan.MultiSkillNames)
 	}
 	for _, target := range plan.Targets {
-		perTarget := 1
-		if plan.Mode == skillSetupModeMulti {
-			perTarget = len(plan.MultiSkillNames)
-		}
-		isCanonical := target.CanonicalBase != "" && sameSkillSetupPath(skillSetupBaseForMode(target.Destination, plan.Mode), target.CanonicalBase)
 		if target.CleanupOnly {
-			// Nothing is installed below a universal root, so a stale copy that
-			// resists retirement must not count as a skipped install: any skipped
-			// count fails the whole setup, even when every real target succeeded.
+			if skipped > 0 {
+				continue
+			}
 			if homeErr != nil {
-				fmt.Fprintf(errOut, "  ⚠️  无法解析 HOME，保留 universal Agent 旧副本 %s: %v\n", target.Destination, homeErr)
+				fmt.Fprintf(errOut, "  ✗ 无法解析 HOME，保留通用 Skill 副本 %s: %v\n", target.Destination, homeErr)
+				skipped++
 				continue
 			}
 			if _, cleanupErr := backupSkillSetupTarget(home, target.Backups, out); cleanupErr != nil {
-				fmt.Fprintf(errOut, "  ⚠️  universal Agent 旧副本迁移失败，已回滚，可手动删除 %s: %v\n", target.Destination, cleanupErr)
+				fmt.Fprintf(errOut, "  ✗ 通用 Skill 副本迁移失败，已回滚 %s: %v\n", target.Destination, cleanupErr)
+				skipped++
 			}
 			continue
 		}
 		if len(target.Backups) > 0 && homeErr != nil {
-			if isCanonical && hasCanonicalDependents {
-				return installed, skipped + perTarget, fmt.Errorf("无法解析 HOME，canonical Skill 刷新中止 %s: %w", target.Destination, homeErr)
-			}
 			if plan.Mode == skillSetupModeMono {
 				fmt.Fprintf(errOut, "  ✗ 无法解析 HOME，跳过刷新（保留原目录） %s: %v\n", target.Destination, homeErr)
 			} else {
@@ -2087,16 +1777,7 @@ func executeSkillSetupPlan(plan *skillSetupPlan, out, errOut io.Writer) (install
 		}
 
 		stageRoot, staged, stageErr := stageSkillSetupTarget(plan, target)
-		if stageErr != nil && target.LinkCanonical {
-			fmt.Fprintf(errOut, "  ℹ️  %s 无法使用共享安装方式，正在自动改用兼容安装\n", target.Destination)
-			fallback := target
-			fallback.LinkCanonical = false
-			stageRoot, staged, stageErr = stageSkillSetupTarget(plan, fallback)
-		}
 		if stageErr != nil {
-			if isCanonical && hasCanonicalDependents {
-				return installed, skipped + perTarget, fmt.Errorf("canonical Skill staging 失败 %s: %w", target.Destination, stageErr)
-			}
 			fmt.Fprintf(errOut, "  ✗ Skill staging 失败，保留原集合 %s: %v\n", target.Destination, stageErr)
 			skipped += perTarget
 			continue
@@ -2106,9 +1787,6 @@ func executeSkillSetupPlan(plan *skillSetupPlan, out, errOut io.Writer) (install
 			if cleanupErr := skillSetupRemoveAll(stageRoot); cleanupErr != nil {
 				backupErr = errors.Join(backupErr, fmt.Errorf("清理 Skill staging 失败 %s: %w", stageRoot, cleanupErr))
 			}
-			if isCanonical && hasCanonicalDependents {
-				return installed, skipped + perTarget, fmt.Errorf("canonical Skill 备份失败，已执行回滚 %s: %w", target.Destination, backupErr)
-			}
 			fmt.Fprintf(errOut, "  ✗ Skill 备份失败，已执行回滚，跳过整个 Agent 目标 %s: %v\n", target.Destination, backupErr)
 			skipped += perTarget
 			continue
@@ -2119,19 +1797,7 @@ func executeSkillSetupPlan(plan *skillSetupPlan, out, errOut io.Writer) (install
 			if cleanupErr != nil {
 				publishErr = errors.Join(publishErr, fmt.Errorf("清理 Skill staging 失败 %s: %w", stageRoot, cleanupErr))
 			}
-			if isCanonical && hasCanonicalDependents {
-				if errors.Is(publishErr, upgrade.ErrSkillPathPublicationUncertain) {
-					return installed, skipped + perTarget, fmt.Errorf("canonical Skill 发布状态不确定，目标可能属于并发写入并已保留 %s: %w", target.Destination, publishErr)
-				}
-				return installed, skipped + perTarget, fmt.Errorf("canonical Skill 发布失败，已执行回滚 %s: %w", target.Destination, publishErr)
-			}
-			if errors.Is(publishErr, upgrade.ErrSkillPathPublicationUncertain) {
-				// The destination may belong to a concurrent writer and was
-				// deliberately retained; the rollback refuses to displace it.
-				fmt.Fprintf(errOut, "  ✗ Skill 发布状态不确定，目标可能属于并发写入并已保留 %s: %v\n", target.Destination, publishErr)
-			} else {
-				fmt.Fprintf(errOut, "  ✗ Skill 发布失败，已执行回滚，跳过整个 Agent 目标 %s: %v\n", target.Destination, publishErr)
-			}
+			fmt.Fprintf(errOut, "  ✗ Skill 发布失败，已执行回滚，跳过整个 Agent 目标 %s: %v\n", target.Destination, publishErr)
 			skipped += perTarget
 			continue
 		}
@@ -2170,7 +1836,7 @@ func staleMultiSkillVictimsWithError(dest string, keep []string, managed ...map[
 	}
 	var victims []string
 	for _, e := range entries {
-		if (!e.IsDir() && e.Type()&os.ModeSymlink == 0) || keepSet[e.Name()] {
+		if !e.IsDir() || keepSet[e.Name()] {
 			continue
 		}
 		if !isManagedDWSMultiSkillDir(filepath.Join(dest, e.Name()), managed...) {

internal/app/skill_setup_canonical_failures_test.go

@@ -1,160 +0,0 @@
-package app
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/upgrade"
-)
-
-func canonicalFailurePlan(t *testing.T) (string, *skillSetupPlan) {
-	t.Helper()
-	home := t.TempDir()
-	src := t.TempDir()
-	skill := filepath.Join(src, "dingtalk-chat")
-	if err := os.MkdirAll(skill, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(skill, "SKILL.md"), []byte("chat"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	canonical := filepath.Join(home, ".agents", "skills")
-	dependent := filepath.Join(home, ".claude", "skills")
-	plan, err := buildSkillSetupPlan(skillSetupModeMulti, src, []string{canonical, dependent}, []string{"dingtalk-chat"}, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return home, plan
-}
-
-func TestCrossPlatformCoverageSkillSetupCanonicalHomeBackupAndPublishFailures(t *testing.T) {
-	t.Run("home", func(t *testing.T) {
-		_, plan := canonicalFailurePlan(t)
-		canonical := filepath.Join(plan.Targets[0].Destination, "dingtalk-chat")
-		if err := os.MkdirAll(canonical, 0o755); err != nil {
-			t.Fatal(err)
-		}
-		plan.Targets[0].Backups = []skillSetupBackup{{Path: canonical, Reason: skillSetupBackupReplace}}
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return "", errors.New("home denied") })
-		if _, _, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, &bytes.Buffer{}); err == nil || !strings.Contains(err.Error(), "canonical Skill 刷新中止") {
-			t.Fatalf("home failure = %v", err)
-		}
-	})
-
-	t.Run("backup", func(t *testing.T) {
-		home, plan := canonicalFailurePlan(t)
-		victim := filepath.Join(plan.Targets[0].Destination, "dingtalk-chat")
-		if err := os.MkdirAll(victim, 0o755); err != nil {
-			t.Fatal(err)
-		}
-		plan.Targets[0].Backups = []skillSetupBackup{{Path: victim, Reason: skillSetupBackupReplace}}
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-		testseam.Swap(t, &skillSetupBackupAndRemove, func(string, string) (string, error) { return "", errors.New("backup denied") })
-		if _, _, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, &bytes.Buffer{}); err == nil || !strings.Contains(err.Error(), "canonical Skill 备份失败") {
-			t.Fatalf("backup failure = %v", err)
-		}
-	})
-
-	t.Run("publish", func(t *testing.T) {
-		home, plan := canonicalFailurePlan(t)
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-		testseam.Swap(t, &skillSetupPublishPath, func(string, string) (upgrade.SkillPathPublication, error) {
-			return upgrade.SkillPathPublication{}, errors.New("publish denied")
-		})
-		if _, _, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, &bytes.Buffer{}); err == nil || !strings.Contains(err.Error(), "canonical Skill 发布失败") {
-			t.Fatalf("publish failure = %v", err)
-		}
-	})
-
-	t.Run("uncertain-publish", func(t *testing.T) {
-		home, plan := canonicalFailurePlan(t)
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-		testseam.Swap(t, &skillSetupPublishPath, func(string, string) (upgrade.SkillPathPublication, error) {
-			return upgrade.SkillPathPublication{}, fmt.Errorf("并发写入: %w", upgrade.ErrSkillPathPublicationUncertain)
-		})
-		errOut := &bytes.Buffer{}
-		_, _, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, errOut)
-		if err == nil || !strings.Contains(err.Error(), "canonical Skill 发布状态不确定") {
-			t.Fatalf("uncertain publish = %v", err)
-		}
-		// The destination was deliberately retained, so the canonical error
-		// must not claim a rollback happened.
-		if strings.Contains(err.Error(), "回滚") {
-			t.Fatalf("uncertain error must not claim a rollback: %v", err)
-		}
-	})
-
-	t.Run("uncertain dependent target is retained and reported", func(t *testing.T) {
-		home, plan := canonicalFailurePlan(t)
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-		originalPublish := skillSetupPublishPath
-		testseam.Swap(t, &skillSetupPublishPath, func(staged, destination string) (upgrade.SkillPathPublication, error) {
-			if strings.HasPrefix(destination, filepath.Join(home, ".claude")) {
-				return upgrade.SkillPathPublication{}, fmt.Errorf("并发写入: %w", upgrade.ErrSkillPathPublicationUncertain)
-			}
-			return originalPublish(staged, destination)
-		})
-		errOut := &bytes.Buffer{}
-		_, skipped, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, errOut)
-		if err != nil {
-			t.Fatalf("dependent uncertain publish = %v", err)
-		}
-		if skipped != 1 {
-			t.Fatalf("skipped = %d, want 1", skipped)
-		}
-		if !strings.Contains(errOut.String(), "发布状态不确定") || strings.Contains(errOut.String(), "已执行回滚") {
-			t.Fatalf("errOut = %q, want retained-destination notice", errOut.String())
-		}
-	})
-}
-
-func TestCrossPlatformCoverageSkillSetupLinkResolutionFailures(t *testing.T) {
-	home, plan := canonicalFailurePlan(t)
-	canonicalTarget := filepath.Join(plan.Targets[0].Destination, "dingtalk-chat")
-	if err := os.MkdirAll(canonicalTarget, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(canonicalTarget, "SKILL.md"), []byte("chat"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	linked := plan.Targets[1]
-
-	t.Run("physical-parent", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupEvalSymlinks, func(path string) (string, error) {
-			if path == linked.Destination {
-				return "", errors.New("parent denied")
-			}
-			return filepath.EvalSymlinks(path)
-		})
-		if _, _, err := stageSkillSetupTarget(plan, linked); err == nil || !strings.Contains(err.Error(), "物理目录") {
-			t.Fatalf("physical parent error = %v", err)
-		}
-	})
-
-	t.Run("canonical-target", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupEvalSymlinks, func(path string) (string, error) {
-			if path == canonicalTarget {
-				return "", errors.New("canonical denied")
-			}
-			return filepath.EvalSymlinks(path)
-		})
-		if _, _, err := stageSkillSetupTarget(plan, linked); err == nil || !strings.Contains(err.Error(), "解析 canonical") {
-			t.Fatalf("canonical target error = %v", err)
-		}
-	})
-
-	t.Run("relative-path", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupRel, func(string, string) (string, error) { return "", errors.New("relative denied") })
-		if _, _, err := stageSkillSetupTarget(plan, linked); err == nil || !strings.Contains(err.Error(), "相对链接") {
-			t.Fatalf("relative path error = %v", err)
-		}
-	})
-
-	_ = home
-}

internal/app/skill_setup_canonical_test.go

@@ -1,395 +0,0 @@
-package app
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
-)
-
-func TestCrossPlatformCoverageSkillSetupCanonicalTargetsAndAgentCapabilities(t *testing.T) {
-	home := t.TempDir()
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-	testseam.Swap(t, &skillSetupAgentHomes, []string{
-		".agents/skills", ".codex/skills", ".claude/skills", ".openclaw/skills",
-	})
-	for _, parent := range []string{".codex", ".claude", ".openclaw"} {
-		if err := os.MkdirAll(filepath.Join(home, parent), 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	dests, err := resolveSkillSetupTargets("all", skillSetupModeMulti)
-	if err != nil {
-		t.Fatal(err)
-	}
-	canonical := filepath.Join(home, ".agents", "skills")
-	if len(dests) != 4 || dests[0] != canonical {
-		t.Fatalf("targets = %v", dests)
-	}
-
-	src := t.TempDir()
-	for _, name := range []string{"dingtalk-chat", "dingtalk-shared"} {
-		dir := filepath.Join(src, name)
-		if err := os.MkdirAll(dir, 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte(name), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	oldCodex := filepath.Join(home, ".codex", "skills", "dingtalk-chat")
-	if err := os.MkdirAll(oldCodex, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(oldCodex, "SKILL.md"), []byte("beta.6"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	claudeSkills := filepath.Join(home, ".claude", "skills")
-	if err := os.MkdirAll(claudeSkills, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(claudeSkills, "dingtalk-chat"), []byte("unexpected file"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink("missing-target", filepath.Join(claudeSkills, "dingtalk-shared")); err != nil {
-		t.Fatal(err)
-	}
-
-	plan, err := buildSkillSetupPlan(skillSetupModeMulti, src, dests, []string{"dingtalk-chat", "dingtalk-shared"}, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	installed, skipped, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, &bytes.Buffer{})
-	if err != nil || skipped != 0 || installed != 6 { // canonical + two linked Agents, two Skills each
-		t.Fatalf("execute = installed %d skipped %d err %v", installed, skipped, err)
-	}
-	if _, err := os.Lstat(oldCodex); !os.IsNotExist(err) {
-		t.Fatalf("Codex duplicate remains: %v", err)
-	}
-	for _, name := range []string{"dingtalk-chat", "dingtalk-shared"} {
-		if _, err := os.Stat(filepath.Join(canonical, name, "SKILL.md")); err != nil {
-			t.Fatalf("canonical %s missing: %v", name, err)
-		}
-		for _, agent := range []string{".claude", ".openclaw"} {
-			link := filepath.Join(home, agent, "skills", name)
-			info, err := os.Lstat(link)
-			if err != nil || info.Mode()&os.ModeSymlink == 0 {
-				t.Fatalf("link %s = %#v, %v", link, info, err)
-			}
-		}
-	}
-	// Re-running setup must recognize the existing links as already correct;
-	// canonical refreshes in place without turning links into copied trees.
-	plan, err = buildSkillSetupPlan(skillSetupModeMulti, src, dests, []string{"dingtalk-chat", "dingtalk-shared"}, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, &bytes.Buffer{}); err != nil {
-		t.Fatal(err)
-	}
-	for _, agent := range []string{".claude", ".openclaw"} {
-		info, err := os.Lstat(filepath.Join(home, agent, "skills", "dingtalk-chat"))
-		if err != nil || info.Mode()&os.ModeSymlink == 0 {
-			t.Fatalf("idempotent setup replaced %s link: %#v, %v", agent, info, err)
-		}
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupDetectsShallowAndApplicationAgents(t *testing.T) {
-	// Keep the destination HOME synthetic: app-bundle detection is deliberately
-	// machine-scoped and must not depend on the selected installation HOME.
-	home := t.TempDir()
-	testseam.Swap(t, &skillSetupGetenv, func(string) string { return "" })
-	for _, dir := range []string{filepath.Join(home, ".config", "kimchi"), filepath.Join(home, ".tabnine")} {
-		if err := os.MkdirAll(dir, 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-	sentinel := filepath.Join(home, "app-sentinel")
-	if err := os.MkdirAll(sentinel, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	appInfo, err := os.Stat(sentinel)
-	if err != nil {
-		t.Fatal(err)
-	}
-	zcodeApp := filepath.Join(string(filepath.Separator), "Applications", "ZCode.app")
-	minimaxApp := filepath.Join(string(filepath.Separator), "Applications", "MiniMax Code.app")
-	originalStat := skillSetupStat
-	testseam.Swap(t, &skillSetupStat, func(path string) (os.FileInfo, error) {
-		if path == zcodeApp || path == minimaxApp {
-			return appInfo, nil
-		}
-		return originalStat(path)
-	})
-	dests := detectExistingAgentHomes(home, skillSetupModeMulti)
-	for _, target := range []string{
-		filepath.Join(home, ".config", "kimchi", "harness", "skills"),
-		filepath.Join(home, ".tabnine", "agent", "skills"),
-		filepath.Join(home, ".zcode", "skills"),
-		filepath.Join(home, ".minimax", "skills"),
-	} {
-		if !containsSkillName(dests, target) {
-			t.Errorf("detected targets %v missing %s", dests, target)
-		}
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupCustomRootsAliasesAndUniversalTargets(t *testing.T) {
-	home := t.TempDir()
-	customClaude := filepath.Join(t.TempDir(), "claude")
-	customCodex := filepath.Join(t.TempDir(), "codex")
-	customHermes := filepath.Join(t.TempDir(), "hermes")
-	for _, root := range []string{customClaude, customCodex, customHermes, filepath.Join(home, ".moltbot"), filepath.Join(home, ".copilot"), filepath.Join(home, ".config", "opencode"), filepath.Join(home, ".config", "agents"), filepath.Join(home, ".codeium", "windsurf")} {
-		if err := os.MkdirAll(root, 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-	testseam.Swap(t, &skillSetupGetenv, func(name string) string {
-		switch name {
-		case "CLAUDE_CONFIG_DIR":
-			return customClaude
-		case "CODEX_HOME":
-			return customCodex
-		case "HERMES_HOME":
-			return customHermes
-		default:
-			return ""
-		}
-	})
-
-	dests, err := resolveSkillSetupTargets("all", skillSetupModeMulti)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, want := range []string{
-		filepath.Join(home, ".agents", "skills"),
-		filepath.Join(customClaude, "skills"),
-		filepath.Join(customCodex, "skills"),
-		filepath.Join(customHermes, "skills"),
-		filepath.Join(home, ".moltbot", "skills"),
-		filepath.Join(home, ".copilot", "skills"),
-		filepath.Join(home, ".config", "opencode", "skills"),
-		filepath.Join(home, ".config", "agents", "skills"),
-		filepath.Join(home, ".codeium", "windsurf", "skills"),
-	} {
-		found := false
-		for _, got := range dests {
-			if sameSkillSetupPath(got, want) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Fatalf("resolved targets %v missing %s", dests, want)
-		}
-	}
-	if !isUniversalSkillSetupBase(filepath.Join(customCodex, "skills")) || !isUniversalSkillSetupBase(filepath.Join(home, ".config", "opencode", "skills")) || !isUniversalSkillSetupBase(filepath.Join(home, ".config", "agents", "skills")) {
-		t.Fatal("custom Codex, OpenCode, and Amp must be universal cleanup-only targets")
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupCanonicalFailureStopsDependentTargets(t *testing.T) {
-	home := t.TempDir()
-	canonical := filepath.Join(home, ".agents", "skills")
-	claude := filepath.Join(home, ".claude", "skills")
-	if err := os.MkdirAll(claude, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	oldClaude := filepath.Join(claude, "dingtalk-chat")
-	if err := os.MkdirAll(oldClaude, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(oldClaude, "SKILL.md"), []byte("old remains"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	src := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(src, "dingtalk-chat"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(src, "dingtalk-chat", "SKILL.md"), []byte("new"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-	plan, err := buildSkillSetupPlan(skillSetupModeMulti, src, []string{canonical, claude}, []string{"dingtalk-chat"}, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	testseam.Swap(t, &skillSetupCopyDir, func(string, string) error { return errors.New("canonical copy denied") })
-	if _, _, err := executeSkillSetupPlan(plan, &bytes.Buffer{}, &bytes.Buffer{}); err == nil || !strings.Contains(err.Error(), "canonical") {
-		t.Fatalf("canonical failure = %v", err)
-	}
-	body, readErr := os.ReadFile(filepath.Join(oldClaude, "SKILL.md"))
-	if readErr != nil || string(body) != "old remains" {
-		t.Fatalf("dependent Claude target changed: %q, %v", body, readErr)
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupCanonicalCopyFallbackMessage(t *testing.T) {
-	home := t.TempDir()
-	canonical := filepath.Join(home, ".agents", "skills")
-	claude := filepath.Join(home, ".claude", "skills")
-	src := t.TempDir()
-	skillSrc := filepath.Join(src, "dingtalk-chat")
-	if err := os.MkdirAll(skillSrc, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(skillSrc, "SKILL.md"), []byte("chat"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-	testseam.Swap(t, &skillSetupSymlink, func(string, string) error { return errors.New("links unavailable") })
-
-	plan, err := buildSkillSetupPlan(
-		skillSetupModeMulti,
-		src,
-		[]string{canonical, claude},
-		[]string{"dingtalk-chat"},
-		false,
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var out, errOut bytes.Buffer
-	installed, skipped, err := executeSkillSetupPlan(plan, &out, &errOut)
-	if err != nil || installed != 2 || skipped != 0 {
-		t.Fatalf("execute = installed %d skipped %d err %v", installed, skipped, err)
-	}
-	if !strings.Contains(errOut.String(), "自动改用兼容安装") {
-		t.Fatalf("human-readable fallback message missing: %s", errOut.String())
-	}
-	info, err := os.Lstat(filepath.Join(claude, "dingtalk-chat"))
-	if err != nil || !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
-		t.Fatalf("copy fallback = %#v, %v", info, err)
-	}
-}
-
-func TestCrossPlatformCoverageUpstreamAgentEnumerationAndEffectiveRoots(t *testing.T) {
-	home := t.TempDir()
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-	testseam.Swap(t, &skillUserHomeDir, func() (string, error) { return home, nil })
-	testseam.Swap(t, &skillSetupGetenv, func(string) string { return "" })
-
-	expected := map[string]string{
-		"aider-desk": ".aider-desk/skills", "amp": ".config/agents/skills",
-		"antigravity": ".gemini/antigravity/skills", "antigravity-cli": ".gemini/antigravity-cli/skills",
-		"astrbot": ".astrbot/data/skills", "autohand-code": ".autohand/skills",
-		"augment": ".augment/skills", "bob": ".bob/skills", "claude-code": ".claude/skills",
-		"openclaw": ".openclaw/skills", "cline": ".agents/skills", "codearts-agent": ".codeartsdoer/skills",
-		"codebuddy": ".codebuddy/skills", "codemaker": ".codemaker/skills", "codestudio": ".codestudio/skills",
-		"codex": ".codex/skills", "command-code": ".commandcode/skills", "continue": ".continue/skills",
-		"cortex": ".snowflake/cortex/skills", "crush": ".config/crush/skills", "cursor": ".cursor/skills",
-		"deepagents": ".deepagents/agent/skills", "devin": ".config/devin/skills", "dexto": ".agents/skills",
-		"droid": ".factory/skills", "firebender": ".firebender/skills", "forgecode": ".forge/skills",
-		"gemini-cli": ".gemini/skills", "github-copilot": ".copilot/skills", "goose": ".config/goose/skills",
-		"grok": ".grok/skills", "hermes-agent": ".hermes/skills", "inference-sh": ".inferencesh/skills",
-		"jazz": ".jazz/skills", "junie": ".junie/skills", "iflow-cli": ".iflow/skills",
-		"kilo": ".kilocode/skills", "kimchi": ".config/kimchi/harness/skills", "kimi-code-cli": ".agents/skills",
-		"kiro-cli": ".kiro/skills", "kode": ".kode/skills", "lingma": ".lingma/skills", "loaf": ".agents/skills",
-		"mcpjam": ".mcpjam/skills", "minimax-code": ".minimax/skills", "mistral-vibe": ".vibe/skills",
-		"moxby": ".moxby/skills", "mux": ".mux/skills", "opencode": ".config/opencode/skills",
-		"openhands": ".openhands/skills", "ona": ".ona/skills", "pi": ".pi/agent/skills",
-		"qoder": ".qoder/skills", "qoder-cn": ".qoder-cn/skills", "qwen-code": ".qwen/skills",
-		"replit": ".config/agents/skills", "reasonix": ".reasonix/skills", "rovodev": ".rovodev/skills",
-		"roo": ".roo/skills", "tabnine-cli": ".tabnine/agent/skills", "terramind": ".terramind/skills",
-		"tinycloud": ".tinycloud/skills", "trae": ".trae/skills", "trae-cn": ".trae-cn/skills",
-		"universal": ".config/agents/skills", "warp": ".agents/skills", "windsurf": ".codeium/windsurf/skills",
-		"zed": ".agents/skills", "zcode": ".zcode/skills", "zencoder": ".zencoder/skills",
-		"zenflow": ".zencoder/skills", "neovate": ".neovate/skills", "pochi": ".pochi/skills", "adal": ".adal/skills",
-	}
-	if got := len(expected) + len(unsupportedGlobalAgentTargets); got != 76 {
-		t.Fatalf("upstream agent enumeration = %d, want 76", got)
-	}
-	for target, rel := range expected {
-		mapped, ok := agentSkillPaths[target]
-		if !ok || filepath.Clean(mapped) != filepath.Clean(rel) {
-			t.Errorf("agent %s map = %q, want %q", target, mapped, rel)
-		}
-		if got := resolveSkillSetupBase(home, target); !sameSkillSetupPath(got, filepath.Join(home, filepath.FromSlash(rel))) {
-			t.Errorf("agent %s effective root = %q, want %q", target, got, filepath.Join(home, rel))
-		}
-	}
-	for _, target := range []string{"eve", "promptscript"} {
-		if _, err := resolveSkillSetupTargets(target, skillSetupModeMulti); err == nil {
-			t.Errorf("%s unexpectedly resolved a global setup root", target)
-		}
-		if _, err := resolveSkillTargetPath(target); err == nil {
-			t.Errorf("%s unexpectedly resolved a marketplace install root", target)
-		}
-	}
-	if got := supportedTargets(); !strings.Contains(got, "eve") || !strings.Contains(got, "promptscript") {
-		t.Fatalf("supported targets omit no-global upstream agents: %s", got)
-	}
-
-	custom := map[string]string{
-		"AUTOHAND_HOME": filepath.Join(home, "autohand-home"), "CLAUDE_CONFIG_DIR": filepath.Join(home, "claude-home"),
-		"CODEX_HOME": filepath.Join(home, "codex-home"), "GROK_HOME": filepath.Join(home, "grok-home"),
-		"HERMES_HOME": filepath.Join(home, "hermes-home"), "VIBE_HOME": filepath.Join(home, "vibe-home"),
-		"XDG_CONFIG_HOME": filepath.Join(home, "xdg"),
-	}
-	testseam.Swap(t, &skillSetupGetenv, func(name string) string { return custom[name] })
-	customCases := map[string]string{
-		"autohand-code": filepath.Join(custom["AUTOHAND_HOME"], "skills"),
-		"claude-code":   filepath.Join(custom["CLAUDE_CONFIG_DIR"], "skills"),
-		"codex":         filepath.Join(custom["CODEX_HOME"], "skills"),
-		"grok":          filepath.Join(custom["GROK_HOME"], "skills"),
-		"hermes-agent":  filepath.Join(custom["HERMES_HOME"], "skills"),
-		"mistral-vibe":  filepath.Join(custom["VIBE_HOME"], "skills"),
-		"amp":           filepath.Join(custom["XDG_CONFIG_HOME"], "agents", "skills"),
-		"replit":        filepath.Join(custom["XDG_CONFIG_HOME"], "agents", "skills"),
-		"universal":     filepath.Join(custom["XDG_CONFIG_HOME"], "agents", "skills"),
-		"crush":         filepath.Join(custom["XDG_CONFIG_HOME"], "crush", "skills"),
-		"devin":         filepath.Join(custom["XDG_CONFIG_HOME"], "devin", "skills"),
-		"goose":         filepath.Join(custom["XDG_CONFIG_HOME"], "goose", "skills"),
-		"kimchi":        filepath.Join(custom["XDG_CONFIG_HOME"], "kimchi", "harness", "skills"),
-		"opencode":      filepath.Join(custom["XDG_CONFIG_HOME"], "opencode", "skills"),
-	}
-	for target, want := range customCases {
-		if got := resolveSkillSetupBase(home, target); !sameSkillSetupPath(got, want) {
-			t.Errorf("custom %s root = %q, want %q", target, got, want)
-		}
-	}
-	for _, target := range []string{"codex", "amp", "opencode"} {
-		if !isUniversalSkillSetupBase(resolveSkillSetupBase(home, target)) {
-			t.Errorf("custom %s root not classified universal", target)
-		}
-	}
-}
-
-func TestCrossPlatformCoverageOpenClawAliasPriority(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		dirs []string
-		want string
-	}{
-		{name: "default", want: ".openclaw"},
-		{name: "moltbot", dirs: []string{".moltbot"}, want: ".moltbot"},
-		{name: "clawdbot-before-moltbot", dirs: []string{".moltbot", ".clawdbot"}, want: ".clawdbot"},
-		{name: "openclaw-first", dirs: []string{".moltbot", ".clawdbot", ".openclaw"}, want: ".openclaw"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			home := t.TempDir()
-			for _, dir := range tc.dirs {
-				if err := os.MkdirAll(filepath.Join(home, dir), 0o755); err != nil {
-					t.Fatal(err)
-				}
-			}
-			if got := resolveOpenClawSetupBase(home); got != filepath.Join(home, tc.want, "skills") {
-				t.Fatalf("OpenClaw root = %q", got)
-			}
-		})
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupWindowsPathNormalization(t *testing.T) {
-	testseam.Swap(t, &skillSetupFoldPathCase, true)
-	if !sameSkillSetupPath(filepath.Join("Root", "Skills"), filepath.Join("root", "skills")) {
-		t.Fatal("case-insensitive platform path normalization failed")
-	}
-}

internal/app/skill_setup_cleanup_coverage_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/skillprovenance"
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/skillstate"
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/upgrade"
 )
 
 func useManagedSkillNames(t *testing.T, names ...string) {
@@ -337,12 +336,12 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailuresRestoreOldSet(t *test
 					return originalBackup(homeDir, dir)
 				})
 			} else {
-				originalPublish := skillSetupPublishPath
-				testseam.Swap(t, &skillSetupPublishPath, func(oldPath, newPath string) (upgrade.SkillPathPublication, error) {
+				originalRename := skillSetupPublishRename
+				testseam.Swap(t, &skillSetupPublishRename, func(oldPath, newPath string) error {
 					if newPath == second && strings.HasPrefix(filepath.Base(filepath.Dir(oldPath)), ".dws-setup-set-") {
-						return upgrade.SkillPathPublication{}, failure
+						return failure
 					}
-					return originalPublish(oldPath, newPath)
+					return originalRename(oldPath, newPath)
 				})
 			}
 
@@ -433,8 +432,8 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailureEdges(t *testing.T) {
 
 	t.Run("restore failure aggregation", func(t *testing.T) {
 		t.Run("remove published", func(t *testing.T) {
-			testseam.Swap(t, &skillSetupRollbackPaths, func([]upgrade.SkillPathPublication) error { return failure })
-			if err := restoreSkillSetupTarget([]upgrade.SkillPathPublication{{Destination: "published"}}, nil); !errors.Is(err, failure) {
+			testseam.Swap(t, &skillSetupRemoveAll, func(string) error { return failure })
+			if err := restoreSkillSetupTarget([]string{"published"}, nil); !errors.Is(err, failure) {
 				t.Fatalf("remove published error = %v", err)
 			}
 		})
@@ -446,14 +445,14 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailureEdges(t *testing.T) {
 			}
 		})
 		t.Run("stat", func(t *testing.T) {
-			testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, failure })
+			testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, failure })
 			err := restoreSkillSetupTarget(nil, []skillSetupBackedUpDir{{original: "original", backup: "backup"}})
 			if !errors.Is(err, failure) || !strings.Contains(err.Error(), "检查 Skill 恢复目标失败") {
 				t.Fatalf("restore stat error = %v", err)
 			}
 		})
 		t.Run("mkdir", func(t *testing.T) {
-			testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
+			testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
 			testseam.Swap(t, &skillSetupMkdirAll, func(string, os.FileMode) error { return failure })
 			err := restoreSkillSetupTarget(nil, []skillSetupBackedUpDir{{original: "original", backup: "backup"}})
 			if !errors.Is(err, failure) || !strings.Contains(err.Error(), "创建 Skill 恢复目录失败") {
@@ -461,9 +460,9 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailureEdges(t *testing.T) {
 			}
 		})
 		t.Run("rename", func(t *testing.T) {
-			testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
+			testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
 			testseam.Swap(t, &skillSetupMkdirAll, func(string, os.FileMode) error { return nil })
-			testseam.Swap(t, &skillSetupRestoreBackup, func(string, string) error { return failure })
+			testseam.Swap(t, &skillSetupPublishRename, func(string, string) error { return failure })
 			err := restoreSkillSetupTarget(nil, []skillSetupBackedUpDir{{original: "original", backup: "backup"}})
 			if !errors.Is(err, failure) || !strings.Contains(err.Error(), "恢复原 Skill 失败") {
 				t.Fatalf("restore rename error = %v", err)
@@ -480,10 +479,10 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailureEdges(t *testing.T) {
 			}
 			return "", failure
 		})
-		testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
+		testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
 		testseam.Swap(t, &skillSetupMkdirAll, func(string, os.FileMode) error { return nil })
 		restoreErr := errors.New("restore failure")
-		testseam.Swap(t, &skillSetupRestoreBackup, func(string, string) error { return restoreErr })
+		testseam.Swap(t, &skillSetupPublishRename, func(string, string) error { return restoreErr })
 		_, err := backupSkillSetupTarget("home", []skillSetupBackup{{Path: "first"}, {Path: "second"}}, io.Discard)
 		if !errors.Is(err, failure) || !errors.Is(err, restoreErr) {
 			t.Fatalf("backup rollback error = %v", err)
@@ -491,11 +490,8 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailureEdges(t *testing.T) {
 	})
 
 	t.Run("publish rollback failure", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupPublishPath, func(string, string) (upgrade.SkillPathPublication, error) {
-			return upgrade.SkillPathPublication{}, failure
-		})
-		testseam.Swap(t, &skillSetupRestoreBackup, func(string, string) error { return failure })
-		testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
+		testseam.Swap(t, &skillSetupPublishRename, func(string, string) error { return failure })
+		testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
 		testseam.Swap(t, &skillSetupMkdirAll, func(string, os.FileMode) error { return nil })
 		err := publishSkillSetupTarget(
 			[]skillSetupStagedDir{{staged: "staged", dest: "dest"}},
@@ -534,12 +530,12 @@ func TestCrossPlatformCoverageSkillSetupTransactionFailureEdges(t *testing.T) {
 
 		t.Run("after publish failure", func(t *testing.T) {
 			plan := newPlan(t)
-			originalPublish := skillSetupPublishPath
-			testseam.Swap(t, &skillSetupPublishPath, func(oldPath, newPath string) (upgrade.SkillPathPublication, error) {
+			originalRename := skillSetupPublishRename
+			testseam.Swap(t, &skillSetupPublishRename, func(oldPath, newPath string) error {
 				if strings.HasPrefix(filepath.Base(filepath.Dir(oldPath)), ".dws-setup-set-") {
-					return upgrade.SkillPathPublication{}, failure
+					return failure
 				}
-				return originalPublish(oldPath, newPath)
+				return originalRename(oldPath, newPath)
 			})
 			originalRemoveAll := skillSetupRemoveAll
 			cleanupErr := errors.New("cleanup after publish failure")

internal/app/skill_setup_event_migration_universal_test.go

@@ -1,139 +0,0 @@
-package app
-
-import (
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
-)
-
-// TestCrossPlatformCoverageSkillSetupEventMigrationRetiresUniversalFoldedCopies
-// pins the P0 fix: when a beta.6 folded dingtalk-misc (carrying the personal
-// Event route) exists only in a UNIVERSAL agent home (~/.codex/skills), the
-// Event/misc migration must not leave physical duplicates there. Universal
-// homes read ~/.agents/skills directly, so their old folded copies are retired
-// (backed up) and the split standalone event + clean misc land in canonical.
-func TestCrossPlatformCoverageSkillSetupEventMigrationRetiresUniversalFoldedCopies(t *testing.T) {
-	home := t.TempDir()
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-
-	codexSkills := filepath.Join(home, ".codex", "skills")
-	writeFoldedEventMisc(t, codexSkills)
-	// beta.6 physical copies alongside the folded misc.
-	for _, name := range []string{multiEventSkill, multiSharedSkill} {
-		if err := os.MkdirAll(filepath.Join(codexSkills, name), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(codexSkills, name, "SKILL.md"), []byte("beta6 "+name+"\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	canonical := filepath.Join(home, ".agents", "skills")
-	src := writeMultiSkillSource(t, []string{multiEventSkill, multiSharedSkill, multiMiscSkill})
-
-	stdout, stderr, err := executeMultiSkillSetupTest(t, src, []string{canonical, codexSkills}, "--skill", "event", "--yes")
-	if err != nil {
-		t.Fatalf("setup failed: %v\nstderr=%s\nstdout=%s", err, stderr, stdout)
-	}
-
-	// P0: the universal home must not retain any physical dingtalk-* copy.
-	for _, name := range []string{multiEventSkill, multiMiscSkill, multiSharedSkill} {
-		if _, err := os.Stat(filepath.Join(codexSkills, name)); !os.IsNotExist(err) {
-			t.Fatalf("universal .codex/skills still has physical %s (stat err=%v)", name, err)
-		}
-	}
-	// canonical owns the new standalone event + clean misc (+ shared).
-	for _, name := range []string{multiEventSkill, multiMiscSkill, multiSharedSkill} {
-		if _, err := os.Stat(filepath.Join(canonical, name, "SKILL.md")); err != nil {
-			t.Fatalf("canonical missing %s: %v", name, err)
-		}
-	}
-	if err := validateCleanEventMiscRoot(filepath.Join(canonical, multiMiscSkill)); err != nil {
-		t.Fatalf("canonical misc still contains folded Event content: %v", err)
-	}
-	if _, _, err := executeMultiSkillSetupTest(t, src, []string{canonical, codexSkills}, "--skill", "event", "--yes"); err != nil {
-		t.Fatalf("idempotent rerun failed: %v", err)
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupUnrelatedSelectionPreservesUniversalFoldedPair(t *testing.T) {
-	home := t.TempDir()
-	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-	canonical := filepath.Join(home, ".agents", "skills")
-	codexSkills := filepath.Join(home, ".codex", "skills")
-	writeFoldedEventMisc(t, codexSkills)
-	writeOldStandaloneEvent(t, codexSkills)
-	chat := filepath.Join(codexSkills, "dingtalk-chat")
-	if err := os.MkdirAll(chat, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(chat, "SKILL.md"), []byte("keep chat\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	src := writeMultiSkillSource(t, []string{multiEventSkill, multiSharedSkill, multiMiscSkill, "dingtalk-doc"})
-	stdout, stderr, err := executeMultiSkillSetupTest(t, src, []string{canonical, codexSkills}, "--skill", "doc", "--yes")
-	if err != nil {
-		t.Fatalf("selective doc install failed: %v\nstdout=%s\nstderr=%s", err, stdout, stderr)
-	}
-	if strings.Contains(stdout, "Event 原子迁移") {
-		t.Fatalf("unrelated selection migrated Event/misc: %s", stdout)
-	}
-	assertOldEventMiscPair(t, codexSkills)
-	if body, err := os.ReadFile(filepath.Join(chat, "SKILL.md")); err != nil || string(body) != "keep chat\n" {
-		t.Fatalf("unselected chat changed: body=%q err=%v", body, err)
-	}
-}
-
-func TestCrossPlatformCoverageSkillSetupUniversalRetirementFailures(t *testing.T) {
-	failure := errors.New("retirement denied")
-
-	t.Run("home", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return "", failure })
-		codex := filepath.Join(t.TempDir(), ".codex", "skills")
-		if err := retireMigratedUniversalSkills([]string{codex}, []string{multiEventSkill}, io.Discard); !errors.Is(err, failure) {
-			t.Fatalf("home failure = %v, want %v", err, failure)
-		}
-	})
-
-	t.Run("deduplicate", func(t *testing.T) {
-		home := t.TempDir()
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-		codex := filepath.Join(home, ".codex", "skills")
-		if err := retireMigratedUniversalSkills(
-			[]string{codex, codex},
-			[]string{multiEventSkill, multiEventSkill},
-			io.Discard,
-		); err != nil {
-			t.Fatalf("deduplicated retirement failed: %v", err)
-		}
-	})
-
-	// Retiring an obsolete universal copy installs nothing, so its failure is
-	// surfaced as a warning and the successful installation is kept.
-	t.Run("backup failure warns without failing the command", func(t *testing.T) {
-		home := t.TempDir()
-		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return home, nil })
-		codex := filepath.Join(home, ".codex", "skills")
-		writeFoldedEventMisc(t, codex)
-		src := writeMultiSkillSource(t, []string{multiEventSkill, multiSharedSkill, multiMiscSkill})
-		testseam.Swap(t, &skillSetupBackupAndRemove, func(string, string) (string, error) {
-			return "", failure
-		})
-		_, stderr, err := executeMultiSkillSetupTest(
-			t,
-			src,
-			[]string{filepath.Join(home, ".agents", "skills"), codex},
-			"--skill", "event", "--yes",
-		)
-		if err != nil {
-			t.Fatalf("retirement backup failure must not fail the command: %v", err)
-		}
-		if !strings.Contains(stderr, "退役 universal Agent") {
-			t.Fatalf("retirement backup failure must be reported, stderr = %q", stderr)
-		}
-	})
-}

internal/app/skill_setup_full_coverage_test.go

@@ -523,45 +523,15 @@ func TestCrossPlatformCoverageSkillSetupEventMigrationFailureBranches(t *testing
 		}
 	})
 
-	t.Run("ordinary install error", func(t *testing.T) {
-		src := writeMultiSkillSource(t, []string{multiEventSkill, multiMiscSkill})
-		copyCalls := 0
-		testseam.Swap(t, &skillSetupCopyDir, func(string, string) error { copyCalls++; return fail })
+	t.Run("ordinary and prerequisite install errors", func(t *testing.T) {
+		testseam.Swap(t, &skillSetupInstallMulti, func(string, []string, []string, io.Writer, io.Writer, bool) (int, int, error) {
+			return 0, 0, fail
+		})
 		migration := filepath.Join(t.TempDir(), "migration")
 		ordinary := filepath.Join(t.TempDir(), "ordinary")
-		if _, _, err := installMultiSkillsWithEventMigration(src, []string{multiEventSkill}, []string{migration, ordinary}, []string{migration}, true, io.Discard, io.Discard); err == nil || !strings.Contains(err.Error(), "未执行迁移") {
+		if _, _, err := installMultiSkillsWithEventMigration("src", []string{multiEventSkill}, []string{migration, ordinary}, []string{migration}, true, io.Discard, io.Discard); !errors.Is(err, fail) {
 			t.Fatalf("ordinary install failure = %v", err)
 		}
-		if copyCalls == 0 {
-			t.Fatal("ordinary staging failure seam was not exercised")
-		}
-	})
-
-	t.Run("canonical ordinary install error", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupInstallMulti, func(string, []string, []string, io.Writer, io.Writer, bool) (int, int, error) {
-			return 0, 0, fail
-		})
-		home := t.TempDir()
-		canonical := filepath.Join(home, ".agents", "skills")
-		universalMigration := filepath.Join(home, ".codex", "skills")
-		if _, _, err := installMultiSkillsWithEventMigration(
-			"src",
-			[]string{multiEventSkill},
-			[]string{canonical, universalMigration},
-			[]string{universalMigration},
-			true,
-			io.Discard,
-			io.Discard,
-		); !errors.Is(err, fail) {
-			t.Fatalf("canonical ordinary install failure = %v, want %v", err, fail)
-		}
-	})
-
-	t.Run("prerequisite install error", func(t *testing.T) {
-		testseam.Swap(t, &skillSetupInstallMulti, func(string, []string, []string, io.Writer, io.Writer, bool) (int, int, error) {
-			return 0, 0, fail
-		})
-		migration := filepath.Join(t.TempDir(), "migration")
 		if _, _, err := installMultiSkillsWithEventMigration("src", []string{multiEventSkill, multiMiscSkill, multiSharedSkill}, []string{migration}, []string{migration}, true, io.Discard, io.Discard); !errors.Is(err, fail) {
 			t.Fatalf("prerequisite install failure = %v", err)
 		}

internal/app/skill_setup_plan_test.go

@@ -48,13 +48,16 @@ func TestCrossPlatformCoverageSkillSetupPlanPreviewDeclineAndExecutionMatch(t *t
 	backupCalls, copyCalls := []string{}, 0
 	testseam.Swap(t, &skillSetupBackupAndRemove, func(_ string, path string) (string, error) {
 		backupCalls = append(backupCalls, path)
-		if err := os.RemoveAll(path); err != nil {
-			return "", err
-		}
 		return "backup", nil
 	})
 	testseam.Swap(t, &skillSetupCopyDir, func(string, string) error { copyCalls++; return nil })
 	testseam.Swap(t, &skillSetupWriteFile, func(string, []byte, os.FileMode) error { return nil })
+	testseam.Swap(t, &skillSetupPublishRename, func(src, dest string) error {
+		if err := os.RemoveAll(dest); err != nil {
+			return err
+		}
+		return os.Rename(src, dest)
+	})
 	dryRunCmd := skillSetupCoverageCommand(t, skillSetupModeMulti, false)
 	var dryRunOut bytes.Buffer
 	dryRunCmd.SetOut(&dryRunOut)
@@ -116,9 +119,6 @@ func TestCrossPlatformCoverageSkillSetupPlanPreviewDeclineAndExecutionMatch(t *t
 
 	// A filtered multi plan replaces only selected same-name skills and leaves
 	// unselected siblings out of the backup set.
-	if err := os.MkdirAll(filepath.Join(dest, "dws"), 0o755); err != nil {
-		t.Fatal(err)
-	}
 	filtered, err := buildSkillSetupPlan(skillSetupModeMulti, source, []string{dest}, []string{"dingtalk-a"}, true)
 	if err != nil {
 		t.Fatal(err)
@@ -149,38 +149,55 @@ func TestCrossPlatformCoverageSkillSetupMonoPlanIncludesSameNameTarget(t *testin
 func TestCrossPlatformCoverageSkillSetupGenericCleanupDerivesHomeFromConcreteTarget(t *testing.T) {
 	home := t.TempDir()
 	dest := filepath.Join(home, ".codex", "skills")
-	canonical := filepath.Join(home, ".agents", "skills")
-	oldCodex := filepath.Join(dest, "dingtalk-chat")
-	if err := os.MkdirAll(oldCodex, 0o755); err != nil {
+	genericMono := filepath.Join(home, ".agents", "skills", "dws")
+	if err := os.MkdirAll(genericMono, 0o755); err != nil {
 		t.Fatal(err)
 	}
 	testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) {
 		return "", errors.New("transient HOME failure")
 	})
 
-	plan, err := buildSkillSetupPlan(skillSetupModeMulti, "source", []string{canonical, dest}, []string{"dingtalk-chat"}, true)
+	plan, err := buildSkillSetupPlan(skillSetupModeMulti, "source", []string{dest}, []string{"dingtalk-chat"}, true)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(plan.Targets) != 2 || !plan.Targets[1].CleanupOnly || plan.Targets[1].Destination != dest {
-		t.Fatalf("universal cleanup target = %#v", plan.Targets)
+	if len(plan.Targets) != 2 || !plan.Targets[1].CleanupOnly || plan.Targets[1].Destination != filepath.Dir(genericMono) {
+		t.Fatalf("generic cleanup target = %#v", plan.Targets)
 	}
-	if len(plan.Targets[1].Backups) != 1 || plan.Targets[1].Backups[0].Path != oldCodex {
-		t.Fatalf("universal cleanup backups = %#v", plan.Targets[1].Backups)
+	if len(plan.Targets[1].Backups) != 1 || plan.Targets[1].Backups[0].Path != genericMono {
+		t.Fatalf("generic cleanup backups = %#v", plan.Targets[1].Backups)
 	}
 	var preview bytes.Buffer
 	renderSkillSetupPlan(&preview, plan)
-	if !strings.Contains(preview.String(), "改用统一安装位置") {
-		t.Fatalf("universal cleanup preview missing: %s", preview.String())
+	if !strings.Contains(preview.String(), "仅迁移旧的通用 DWS 副本") {
+		t.Fatalf("generic cleanup preview missing: %s", preview.String())
 	}
 
+	t.Run("managed multi and scan failure", func(t *testing.T) {
+		managedDir := filepath.Join(home, ".agents", "skills", "dingtalk-chat")
+		if err := os.MkdirAll(managedDir, 0o755); err != nil {
+			t.Fatal(err)
+		}
+		target, targetErr := genericSkillCleanupTarget([]string{dest}, map[string]bool{"dingtalk-chat": true})
+		if targetErr != nil || target == nil || len(target.Backups) != 2 {
+			t.Fatalf("managed generic cleanup = %#v, %v", target, targetErr)
+		}
+		failure := errors.New("generic scan failure")
+		testseam.Swap(t, &skillSetupReadDir, func(string) ([]os.DirEntry, error) { return nil, failure })
+		if _, targetErr := genericSkillCleanupTarget([]string{dest}, nil); !errors.Is(targetErr, failure) {
+			t.Fatalf("generic scan error = %v", targetErr)
+		}
+		if _, planErr := buildSkillSetupPlan(skillSetupModeMulti, "source", []string{dest}, []string{"dingtalk-chat"}, true); !errors.Is(planErr, failure) {
+			t.Fatalf("generic cleanup plan error = %v", planErr)
+		}
+	})
 }
 
 func TestCrossPlatformCoverageSkillSetupCleanupOnlyExecutionBranches(t *testing.T) {
 	failure := errors.New("cleanup failure")
 	cleanup := skillSetupTargetPlan{Destination: "generic", CleanupOnly: true, Backups: []skillSetupBackup{{Path: "old"}}}
 
-	t.Run("cleanup runs even after an install skip", func(t *testing.T) {
+	t.Run("prior skip suppresses cleanup", func(t *testing.T) {
 		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return t.TempDir(), nil })
 		plan := &skillSetupPlan{Mode: skillSetupModeMono, Source: "missing", Targets: []skillSetupTargetPlan{{Destination: "install"}, cleanup}}
 		installed, skipped, err := executeSkillSetupPlan(plan, io.Discard, io.Discard)
@@ -189,14 +206,11 @@ func TestCrossPlatformCoverageSkillSetupCleanupOnlyExecutionBranches(t *testing.
 		}
 	})
 
-	// A cleanup-only target installs nothing, so its failure is a warning and
-	// must never increment skipped — runSkillSetup turns any skipped count into
-	// a hard error and would fail an otherwise complete installation.
 	t.Run("home failure keeps generic copy", func(t *testing.T) {
 		testseam.Swap(t, &skillSetupUserHomeDir, func() (string, error) { return "", failure })
 		var stderr bytes.Buffer
 		_, skipped, err := executeSkillSetupPlan(&skillSetupPlan{Mode: skillSetupModeMono, Targets: []skillSetupTargetPlan{cleanup}}, io.Discard, &stderr)
-		if err != nil || skipped != 0 || !strings.Contains(stderr.String(), "保留 universal Agent 旧副本") {
+		if err != nil || skipped != 1 || !strings.Contains(stderr.String(), "保留通用 Skill 副本") {
 			t.Fatalf("cleanup HOME failure = (%d, %v, %q)", skipped, err, stderr.String())
 		}
 	})
@@ -206,7 +220,7 @@ func TestCrossPlatformCoverageSkillSetupCleanupOnlyExecutionBranches(t *testing.
 		testseam.Swap(t, &skillSetupBackupAndRemove, func(string, string) (string, error) { return "", failure })
 		var stderr bytes.Buffer
 		_, skipped, err := executeSkillSetupPlan(&skillSetupPlan{Mode: skillSetupModeMono, Targets: []skillSetupTargetPlan{cleanup}}, io.Discard, &stderr)
-		if err != nil || skipped != 0 || !strings.Contains(stderr.String(), "迁移失败") {
+		if err != nil || skipped != 1 || !strings.Contains(stderr.String(), "迁移失败") {
 			t.Fatalf("cleanup backup failure = (%d, %v, %q)", skipped, err, stderr.String())
 		}
 	})
@@ -233,13 +247,11 @@ func TestCrossPlatformCoverageSkillSetupPlanDeduplicatesAndFailsClosed(t *testin
 		t.Fatal(err)
 	}
 	testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, failure })
-	testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, failure })
 	if _, err := buildSkillSetupPlan(skillSetupModeMono, "source", []string{monoDest}, nil, false); err == nil || !strings.Contains(err.Error(), "\u68c0\u67e5\u5c06\u88ab\u66ff\u6362") {
 		t.Fatalf("replacement stat error = %v", err)
 	}
 
 	testseam.Swap(t, &skillSetupStat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
-	testseam.Swap(t, &skillSetupLstat, func(string) (os.FileInfo, error) { return nil, os.ErrNotExist })
 	testseam.Swap(t, &skillSetupReadDir, func(string) ([]os.DirEntry, error) { return nil, failure })
 	if _, err := buildSkillSetupPlan(skillSetupModeMulti, "source", []string{dest}, []string{"dingtalk-a"}, false); err == nil || !strings.Contains(err.Error(), "\u626b\u63cf\u8fc7\u671f") {
 		t.Fatalf("stale scan error = %v", err)

internal/app/skill_setup_publication_race_test.go

@@ -1,85 +0,0 @@
-package app
-
-import (
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/upgrade"
-)
-
-func TestCrossPlatformCoverageSkillSetupRollbackRetainsConcurrentReplacement(t *testing.T) {
-	home := t.TempDir()
-	base := filepath.Join(home, ".agents", "skills")
-	first := filepath.Join(base, "dingtalk-first")
-	second := filepath.Join(base, "dingtalk-second")
-	writeSkillSetupFile(t, first, "old first")
-	writeSkillSetupFile(t, second, "old second")
-	backups, err := backupSkillSetupTarget(home, []skillSetupBackup{{Path: first}, {Path: second}}, io.Discard)
-	if err != nil {
-		t.Fatal(err)
-	}
-	stageRoot := filepath.Join(base, ".stage")
-	stagedFirst := filepath.Join(stageRoot, "dingtalk-first")
-	stagedSecond := filepath.Join(stageRoot, "dingtalk-second")
-	writeSkillSetupFile(t, stagedFirst, "new first")
-	writeSkillSetupFile(t, stagedSecond, "new second")
-
-	failure := errors.New("injected second setup publication failure")
-	originalPublish := skillSetupPublishPath
-	calls := 0
-	testseam.Swap(t, &skillSetupPublishPath, func(staged, destination string) (upgrade.SkillPathPublication, error) {
-		calls++
-		if calls == 2 {
-			if err := os.RemoveAll(first); err != nil {
-				t.Fatal(err)
-			}
-			writeSkillSetupFile(t, first, "concurrent")
-			return upgrade.SkillPathPublication{}, failure
-		}
-		return originalPublish(staged, destination)
-	})
-
-	err = publishSkillSetupTarget([]skillSetupStagedDir{
-		{staged: stagedFirst, dest: first},
-		{staged: stagedSecond, dest: second},
-	}, backups)
-	if !errors.Is(err, failure) || !strings.Contains(err.Error(), "拒绝删除非本事务") {
-		t.Fatalf("setup transaction error = %v", err)
-	}
-	assertSkillSetupFile(t, first, "concurrent")
-	assertSkillSetupFile(t, second, "old second")
-	var firstBackup string
-	for _, item := range backups {
-		if item.original == first {
-			firstBackup = item.backup
-			break
-		}
-	}
-	if firstBackup == "" {
-		t.Fatal("first backup was not recorded")
-	}
-	assertSkillSetupFile(t, firstBackup, "old first")
-}
-
-func writeSkillSetupFile(t *testing.T, dir, content string) {
-	t.Helper()
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func assertSkillSetupFile(t *testing.T, dir, want string) {
-	t.Helper()
-	content, err := os.ReadFile(filepath.Join(dir, "SKILL.md"))
-	if err != nil || string(content) != want {
-		t.Fatalf("Skill content at %s = %q, %v; want %q", dir, content, err, want)
-	}
-}

internal/app/skill_setup_test.go

@@ -297,12 +297,12 @@ func TestResolveSkillSetupTargetsSingleAgent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected err: %v", err)
 	}
-	if len(got) != 2 {
-		t.Fatalf("expected canonical + Claude, got %d", len(got))
+	if len(got) != 1 {
+		t.Fatalf("expected 1 dest, got %d", len(got))
 	}
 	want := filepath.Join(home, ".claude", "skills", "dws")
-	if filepath.Clean(got[1]) != filepath.Clean(want) {
-		t.Fatalf("expected %s, got %s", want, got[1])
+	if filepath.Clean(got[0]) != filepath.Clean(want) {
+		t.Fatalf("expected %s, got %s", want, got[0])
 	}
 }
 
@@ -321,12 +321,12 @@ func TestResolveSkillSetupTargetsMultiOmitsDwsTail(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected err: %v", err)
 	}
-	if len(got) != 2 {
-		t.Fatalf("expected canonical + Claude, got %d", len(got))
+	if len(got) != 1 {
+		t.Fatalf("expected 1 dest, got %d", len(got))
 	}
 	want := filepath.Join(home, ".claude", "skills")
-	if filepath.Clean(got[1]) != filepath.Clean(want) {
-		t.Fatalf("expected %s, got %s", want, got[1])
+	if filepath.Clean(got[0]) != filepath.Clean(want) {
+		t.Fatalf("expected %s, got %s", want, got[0])
 	}
 }
 
@@ -343,8 +343,8 @@ func TestCrossPlatformCoverageResolveSkillSetupTargetsPrefersSpecificAgentRoot(t
 		t.Fatal(err)
 	}
 	want := filepath.Join(home, ".codex", "skills")
-	if len(got) != 2 || filepath.Clean(got[1]) != filepath.Clean(want) {
-		t.Fatalf("targets = %v, want canonical + %s", got, want)
+	if len(got) != 1 || filepath.Clean(got[0]) != filepath.Clean(want) {
+		t.Fatalf("targets = %v, want [%s]", got, want)
 	}
 }
 
@@ -360,8 +360,8 @@ func TestCrossPlatformCoverageResolveSkillSetupTargetsDetectsZCode(t *testing.T)
 		t.Fatal(err)
 	}
 	want := filepath.Join(home, ".zcode", "skills")
-	if len(got) != 2 || filepath.Clean(got[1]) != filepath.Clean(want) {
-		t.Fatalf("targets = %v, want canonical + %s", got, want)
+	if len(got) != 1 || filepath.Clean(got[0]) != filepath.Clean(want) {
+		t.Fatalf("targets = %v, want [%s]", got, want)
 	}
 
 	explicit, err := resolveSkillSetupTargets("zcode", skillSetupModeMono)
@@ -369,8 +369,8 @@ func TestCrossPlatformCoverageResolveSkillSetupTargetsDetectsZCode(t *testing.T)
 		t.Fatal(err)
 	}
 	wantMono := filepath.Join(want, "dws")
-	if len(explicit) != 2 || filepath.Clean(explicit[1]) != filepath.Clean(wantMono) {
-		t.Fatalf("explicit zcode targets = %v, want canonical + %s", explicit, wantMono)
+	if len(explicit) != 1 || filepath.Clean(explicit[0]) != filepath.Clean(wantMono) {
+		t.Fatalf("explicit zcode targets = %v, want [%s]", explicit, wantMono)
 	}
 }
 
@@ -1055,11 +1055,12 @@ func TestCrossPlatformCoverageSkillSetupSelectiveEventMigratesOnlyFoldedTargets(
 	if err := os.WriteFile(filepath.Join(foldedHome, "dingtalk-chat", "SKILL.md"), []byte("keep sibling\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
+
 	stdout, stderr, err := executeMultiSkillSetupTest(t, src, []string{freshHome, foldedHome}, "--skill", "event", "--yes")
 	if err != nil {
 		t.Fatalf("selective event setup failed: %v\nstderr=%s\nstdout=%s", err, stderr, stdout)
 	}
-	if !strings.Contains(stdout, "请重启已打开的 Agent") {
+	if !strings.Contains(stdout, "重新加载 Skills") {
 		t.Fatalf("completion should tell the user to reload skills: %s", stdout)
 	}
 

internal/app/upgrade.go

@@ -620,9 +620,6 @@ func runUpgrade(ctx context.Context, opts upgradeOptions) error {
 		for _, d := range succeeded {
 			fmt.Printf("         %s %s\n", ugDim("→"), ugCyan(shortenHome(d.Dir)))
 		}
-		for _, d := range result.RetireWarnings() {
-			fmt.Printf("       %s %s %s\n", ugYellow("⚠"), shortenHome(d.Dir), ugDim("旧副本未能迁移，可手动删除: "+d.Err.Error()))
-		}
 	} else {
 		fmt.Printf(" %s\n", ugGreen("✓"))
 	}

internal/app/upgrade_full_coverage_test.go

@@ -292,12 +292,6 @@ func TestCrossPlatformCoverageRunUpgradeAllStagesCoverage(t *testing.T) {
 			if stage == "install-failed-dir" {
 				return &upgradepkg.SkillUpgradeResult{Results: []upgradepkg.SkillDirResult{{Dir: "/failed", Status: upgradepkg.SkillDirFailed, Err: fail}}}, nil
 			}
-			if stage == "install-retire-warning" {
-				return &upgradepkg.SkillUpgradeResult{Results: []upgradepkg.SkillDirResult{
-					{Dir: "/ok", Status: upgradepkg.SkillDirOK},
-					{Dir: "/stale", Status: upgradepkg.SkillDirRetireWarning, Err: errors.New("retirement refused")},
-				}}, nil
-			}
 			return &upgradepkg.SkillUpgradeResult{Results: []upgradepkg.SkillDirResult{{Dir: "/ok", Status: upgradepkg.SkillDirOK}}}, nil
 		}
 	}
@@ -306,7 +300,7 @@ func TestCrossPlatformCoverageRunUpgradeAllStagesCoverage(t *testing.T) {
 		"ensure", "tag-error", "latest-error", "not-needed", "cancel", "find-binary", "temp-fallback", "temp-both",
 		"backup", "checksum-download", "checksum-read", "binary-download", "skills-download", "verify-binary", "verify-skills",
 		"extract-binary", "extract-tar", "binary-missing", "validate", "extract-skills", "skill-missing", "replace", "install", "install-failed-dir",
-		"success", "success-no-skills", "install-retire-warning",
+		"success", "success-no-skills",
 	} {
 		t.Run(stage, func(t *testing.T) {
 			configure(stage)
@@ -336,14 +330,14 @@ func TestCrossPlatformCoverageRunUpgradeAllStagesCoverage(t *testing.T) {
 				opts.skipSkills = true
 			}
 			err := runUpgrade(context.Background(), opts)
-			wantError := stage != "not-needed" && stage != "cancel" && stage != "backup" && stage != "checksum-download" && stage != "checksum-read" && stage != "success" && stage != "success-no-skills" && stage != "install-retire-warning"
+			wantError := stage != "not-needed" && stage != "cancel" && stage != "backup" && stage != "checksum-download" && stage != "checksum-read" && stage != "success" && stage != "success-no-skills"
 			if wantError && err == nil {
 				t.Fatalf("stage %s succeeded", stage)
 			}
 			if !wantError && err != nil {
 				t.Fatalf("stage %s failed: %v", stage, err)
 			}
-			if (stage == "success" || stage == "success-no-skills" || stage == "install-retire-warning") && !rb.cleaned {
+			if (stage == "success" || stage == "success-no-skills") && !rb.cleaned {
 				t.Fatal("successful upgrade did not clean backups")
 			}
 			if stage == "success" {

internal/auth/endpoints.go

@@ -113,9 +113,10 @@ const (
 	ClientIDPath            = "/cli/clientId"
 
 	// MCP OAuth endpoints (used when clientId is fetched from MCP).
-	MCPOAuthTokenPath   = "/oauth2/getToken"
-	MCPRefreshTokenPath = "/oauth2/refreshToken"
-	MCPRevokeTokenPath  = "/oauth2/revokeToken"
+	MCPOAuthTokenPath     = "/oauth2/getToken"
+	MCPRefreshTokenPath   = "/oauth2/refreshToken"
+	MCPRevokeTokenPath    = "/oauth2/revokeToken"
+	MCPVendorAuthCodePath = "/oauth2/vendorAuthCode"
 
 	// App-level access token endpoints (for dws api raw calls).
 

internal/auth/vendor_authcode.go

@@ -0,0 +1,192 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package auth
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/config"
+)
+
+const (
+	headerUserAccessToken = "x-user-access-token"
+	headerDWSClientID     = "x-dws-client-id"
+	headerDWSCLIVersion   = "x-dws-cli-version"
+
+	// VendorAuthCode default / documented portal expiresIn, used only when
+	// the success body omits a positive value. Callers must still prefer
+	// the response field.
+	DefaultVendorAuthCodeExpiresIn = 120
+
+	VendorAuthCodeParamError        = "PARAM_ERROR"
+	VendorAuthCodeVendorUnsupported = "VENDOR_UNSUPPORTED"
+	VendorAuthCodeTokenInvalid      = "TOKEN_INVALID"
+	VendorAuthCodeOrgMismatch       = "ORG_MISMATCH"
+	VendorAuthCodeUserNotInOrg      = "USER_NOT_IN_ORG"
+	VendorAuthCodeVendorNotEnabled  = "VENDOR_NOT_ENABLED"
+	VendorAuthCodeRateLimited       = "RATE_LIMITED"
+	VendorAuthCodeInternalError     = "INTERNAL_ERROR"
+)
+
+// VendorAuthCodeInput is a POST /oauth2/vendorAuthCode call. The body is
+// only vendor + corpId; redirectURI and domain must not be sent.
+type VendorAuthCodeInput struct {
+	AccessToken string
+	ClientID    string
+	CLIVersion  string
+	LoginRegion LoginRegion
+	Vendor      string
+	CorpID      string
+	HTTPClient  *http.Client
+	// BaseURL overrides MCPBaseURLForLoginRegion. Tests use it; production
+	// callers leave it empty.
+	BaseURL string
+}
+
+// VendorAuthCodeResult is the success VO from portal.
+type VendorAuthCodeResult struct {
+	AuthCode  string
+	ExpiresIn int
+}
+
+// VendorAuthCodeError is a portal business error carried in an HTTP 200
+// ServiceResult body (same envelope as /oauth2/getToken).
+type VendorAuthCodeError struct {
+	Code    string
+	Message string
+}
+
+func (e *VendorAuthCodeError) Error() string {
+	if e == nil {
+		return "vendorAuthCode failed"
+	}
+	if strings.TrimSpace(e.Message) != "" {
+		return fmt.Sprintf("vendorAuthCode %s: %s", e.Code, e.Message)
+	}
+	return fmt.Sprintf("vendorAuthCode %s", e.Code)
+}
+
+// Retryable reports whether DWS should retry this portal error once.
+func (e *VendorAuthCodeError) Retryable() bool {
+	if e == nil {
+		return false
+	}
+	switch e.Code {
+	case VendorAuthCodeTokenInvalid, VendorAuthCodeRateLimited, VendorAuthCodeInternalError:
+		return true
+	default:
+		return false
+	}
+}
+
+// FetchVendorAuthCode POSTs {vendor, corpId} to /oauth2/vendorAuthCode.
+// HTTP is expected to be 200; errors are read from body.errorCode.
+func FetchVendorAuthCode(ctx context.Context, in VendorAuthCodeInput) (*VendorAuthCodeResult, error) {
+	vendor := strings.ToLower(strings.TrimSpace(in.Vendor))
+	corpID := strings.TrimSpace(in.CorpID)
+	token := strings.TrimSpace(in.AccessToken)
+	clientID := strings.TrimSpace(in.ClientID)
+	if token == "" || clientID == "" || vendor == "" || corpID == "" {
+		return nil, &VendorAuthCodeError{
+			Code:    VendorAuthCodeParamError,
+			Message: "token, clientId, vendor and corpId are required",
+		}
+	}
+
+	base := strings.TrimRight(strings.TrimSpace(in.BaseURL), "/")
+	if base == "" {
+		base = strings.TrimRight(MCPBaseURLForLoginRegion(in.LoginRegion), "/")
+	}
+	endpoint := base + MCPVendorAuthCodePath
+
+	payload, err := json.Marshal(struct {
+		Vendor string `json:"vendor"`
+		CorpID string `json:"corpId"`
+	}{Vendor: vendor, CorpID: corpID})
+	if err != nil {
+		return nil, fmt.Errorf("marshaling vendorAuthCode request: %w", err)
+	}
+
+	req, err := oauthNewRequest(ctx, http.MethodPost, endpoint, bytes.NewReader(payload))
+	if err != nil {
+		return nil, fmt.Errorf("creating vendorAuthCode request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set(headerUserAccessToken, token)
+	req.Header.Set(headerDWSClientID, clientID)
+	if ver := strings.TrimSpace(in.CLIVersion); ver != "" {
+		req.Header.Set(headerDWSCLIVersion, ver)
+	}
+	applyEditionEnterpriseCredentialHeaders(req)
+
+	client := in.HTTPClient
+	if client == nil {
+		client = oauthHTTPClient
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("sending vendorAuthCode request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	data, readErr := io.ReadAll(io.LimitReader(resp.Body, config.MaxResponseBodySize))
+	if resp.StatusCode != http.StatusOK {
+		if readErr != nil {
+			data = nil
+		}
+		return nil, &HTTPStatusError{
+			StatusCode:   resp.StatusCode,
+			responseBody: truncateBody(data, 200),
+		}
+	}
+	if readErr != nil {
+		return nil, fmt.Errorf("reading vendorAuthCode response: %w", readErr)
+	}
+	return parseVendorAuthCodeResponse(data)
+}
+
+func parseVendorAuthCodeResponse(body []byte) (*VendorAuthCodeResult, error) {
+	var resp struct {
+		AuthCode  string `json:"authCode"`
+		ExpiresIn int    `json:"expiresIn"`
+		Success   *bool  `json:"success"`
+		ErrorCode string `json:"errorCode"`
+		ErrorMsg  string `json:"errorMsg"`
+	}
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return nil, fmt.Errorf("parsing vendorAuthCode response: %w", err)
+	}
+	if resp.ErrorCode != "" || resp.ErrorMsg != "" || (resp.Success != nil && !*resp.Success) {
+		code := strings.TrimSpace(resp.ErrorCode)
+		if code == "" {
+			code = VendorAuthCodeInternalError
+		}
+		return nil, &VendorAuthCodeError{Code: code, Message: resp.ErrorMsg}
+	}
+	authCode := strings.TrimSpace(resp.AuthCode)
+	if authCode == "" {
+		return nil, fmt.Errorf("vendorAuthCode response missing authCode")
+	}
+	expiresIn := resp.ExpiresIn
+	if expiresIn <= 0 {
+		expiresIn = DefaultVendorAuthCodeExpiresIn
+	}
+	return &VendorAuthCodeResult{AuthCode: authCode, ExpiresIn: expiresIn}, nil
+}

internal/auth/vendor_authcode_test.go

@@ -0,0 +1,178 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package auth
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestFetchVendorAuthCodeSuccessEnvelope(t *testing.T) {
+	var gotBody map[string]string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != MCPVendorAuthCodePath {
+			t.Fatalf("path = %q, want %s", r.URL.Path, MCPVendorAuthCodePath)
+		}
+		if r.Method != http.MethodPost {
+			t.Fatalf("method = %s, want POST", r.Method)
+		}
+		if got := r.Header.Get("x-user-access-token"); got != "user-token" {
+			t.Fatalf("x-user-access-token = %q", got)
+		}
+		if got := r.Header.Get("x-dws-client-id"); got != "dws-client" {
+			t.Fatalf("x-dws-client-id = %q", got)
+		}
+		if got := r.Header.Get("x-dws-cli-version"); got != "1.2.3" {
+			t.Fatalf("x-dws-cli-version = %q", got)
+		}
+		if err := json.NewDecoder(r.Body).Decode(&gotBody); err != nil {
+			t.Fatalf("decode body: %v", err)
+		}
+		w.Header().Set("Cache-Control", "no-store")
+		_, _ = io.WriteString(w, `{"authCode":"tmp-code","expiresIn":120}`)
+	}))
+	defer srv.Close()
+
+	got, err := FetchVendorAuthCode(context.Background(), VendorAuthCodeInput{
+		AccessToken: "user-token",
+		ClientID:    "dws-client",
+		CLIVersion:  "1.2.3",
+		Vendor:      "SafeChat",
+		CorpID:      "dingxxxxxxxxxxxx",
+		HTTPClient:  srv.Client(),
+		BaseURL:     srv.URL,
+	})
+	if err != nil {
+		t.Fatalf("FetchVendorAuthCode() = %v", err)
+	}
+	if got.AuthCode != "tmp-code" || got.ExpiresIn != 120 {
+		t.Fatalf("result = %+v", got)
+	}
+	if gotBody["vendor"] != "safechat" || gotBody["corpId"] != "dingxxxxxxxxxxxx" {
+		t.Fatalf("posted body = %v", gotBody)
+	}
+	if _, ok := gotBody["redirectURI"]; ok {
+		t.Fatalf("posted redirectURI, body = %v", gotBody)
+	}
+	if _, ok := gotBody["domain"]; ok {
+		t.Fatalf("posted domain, body = %v", gotBody)
+	}
+}
+
+func TestFetchVendorAuthCodeParsesAlways200ServiceResult(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = io.WriteString(w, `{"success":false,"errorCode":"VENDOR_NOT_ENABLED","errorMsg":"not installed"}`)
+	}))
+	defer srv.Close()
+
+	_, err := FetchVendorAuthCode(context.Background(), VendorAuthCodeInput{
+		AccessToken: "user-token",
+		ClientID:    "dws-client",
+		Vendor:      "safechat",
+		CorpID:      "dingxxxxxxxxxxxx",
+		HTTPClient:  srv.Client(),
+		BaseURL:     srv.URL,
+	})
+	var verr *VendorAuthCodeError
+	if !errors.As(err, &verr) || verr.Code != VendorAuthCodeVendorNotEnabled {
+		t.Fatalf("error = %v, want VENDOR_NOT_ENABLED", err)
+	}
+	if verr.Retryable() {
+		t.Fatal("VENDOR_NOT_ENABLED must not be retryable")
+	}
+}
+
+func TestFetchVendorAuthCodeRequiresLocalFields(t *testing.T) {
+	_, err := FetchVendorAuthCode(context.Background(), VendorAuthCodeInput{Vendor: "safechat", CorpID: "ding"})
+	var verr *VendorAuthCodeError
+	if !errors.As(err, &verr) || verr.Code != VendorAuthCodeParamError {
+		t.Fatalf("error = %v, want PARAM_ERROR", err)
+	}
+}
+
+func TestFetchVendorAuthCodeKeepsHTTPStatusOnNon200(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		http.Error(w, "oops", http.StatusBadGateway)
+	}))
+	defer srv.Close()
+
+	_, err := FetchVendorAuthCode(context.Background(), VendorAuthCodeInput{
+		AccessToken: "user-token",
+		ClientID:    "dws-client",
+		Vendor:      "safechat",
+		CorpID:      "dingxxxxxxxxxxxx",
+		HTTPClient:  srv.Client(),
+		BaseURL:     srv.URL,
+	})
+	var statusErr *HTTPStatusError
+	if !errors.As(err, &statusErr) || statusErr.StatusCode != http.StatusBadGateway {
+		t.Fatalf("error = %v, want HTTP 502", err)
+	}
+}
+
+func TestParseVendorAuthCodeResponseDefaultsExpiresIn(t *testing.T) {
+	got, err := parseVendorAuthCodeResponse([]byte(`{"authCode":"x"}`))
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if got.ExpiresIn != DefaultVendorAuthCodeExpiresIn {
+		t.Fatalf("expiresIn = %d, want %d", got.ExpiresIn, DefaultVendorAuthCodeExpiresIn)
+	}
+}
+
+func TestVendorAuthCodeErrorRetryable(t *testing.T) {
+	for _, code := range []string{VendorAuthCodeTokenInvalid, VendorAuthCodeRateLimited, VendorAuthCodeInternalError} {
+		if !(&VendorAuthCodeError{Code: code}).Retryable() {
+			t.Fatalf("%s should be retryable", code)
+		}
+	}
+	if (&VendorAuthCodeError{Code: VendorAuthCodeOrgMismatch}).Retryable() {
+		t.Fatal("ORG_MISMATCH must not be retryable")
+	}
+}
+
+func TestFetchVendorAuthCodeDoesNotSendBlankCLIVersionHeader(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if got := r.Header.Get("x-dws-cli-version"); got != "" {
+			t.Fatalf("x-dws-cli-version = %q, want empty", got)
+		}
+		_, _ = io.WriteString(w, `{"authCode":"tmp-code","expiresIn":90}`)
+	}))
+	defer srv.Close()
+
+	got, err := FetchVendorAuthCode(context.Background(), VendorAuthCodeInput{
+		AccessToken: "user-token",
+		ClientID:    "dws-client",
+		Vendor:      "safechat",
+		CorpID:      "dingxxxxxxxxxxxx",
+		HTTPClient:  srv.Client(),
+		BaseURL:     srv.URL,
+	})
+	if err != nil {
+		t.Fatalf("FetchVendorAuthCode() = %v", err)
+	}
+	if got.ExpiresIn != 90 {
+		t.Fatalf("expiresIn = %d, want 90 from response", got.ExpiresIn)
+	}
+	if strings.Contains(got.AuthCode, "redirect") {
+		t.Fatalf("unexpected code %q", got.AuthCode)
+	}
+}

internal/cli/param_aliases_generated.go

@@ -1773,439 +1773,6 @@ var generatedParamAliases = []ParamAliasEntry{
 		},
 		Blocked: []string{"at-user-ids", "staff-id", "uid", "user", "user-id", "userid"},
 	},
-	{
-		CLIPath: "calendar +agenda",
-		Aliases: map[string]string{
-			"begin":            "start",
-			"calendar":         "calendar-id",
-			"calendar-book-id": "calendar-id",
-			"end-date":         "end",
-			"end-time":         "end",
-			"from":             "start",
-			"from-date":        "start",
-			"max-result":       "limit",
-			"max-results":      "limit",
-			"max-time":         "end",
-			"min-time":         "start",
-			"next-cursor":      "cursor",
-			"next-page-token":  "cursor",
-			"next-token":       "cursor",
-			"page-size":        "limit",
-			"page-token":       "cursor",
-			"per-page":         "limit",
-			"since":            "start",
-			"size":             "limit",
-			"start-date":       "start",
-			"start-time":       "start",
-			"take":             "limit",
-			"time-max":         "end",
-			"time-min":         "start",
-			"to":               "end",
-			"top":              "limit",
-		},
-		Blocked: []string{"acl-id", "count", "date", "event", "event-id", "id", "offset", "page", "room-id", "time"},
-	},
-	{
-		CLIPath: "calendar +attendee-list",
-		Aliases: map[string]string{
-			"calendar":          "calendar-id",
-			"calendar-book-id":  "calendar-id",
-			"calendar-event-id": "event",
-			"event-id":          "event",
-		},
-		Blocked:   []string{"acl-id", "room-id"},
-		Ambiguous: []string{"id"},
-	},
-	{
-		CLIPath: "calendar +book",
-		Aliases: map[string]string{
-			"attendee-names":    "with",
-			"begin":             "start",
-			"end-time":          "end",
-			"from":              "start",
-			"names":             "with",
-			"participant-names": "with",
-			"start-time":        "start",
-			"subject":           "title",
-			"summary":           "title",
-			"to":                "end",
-		},
-		Blocked: []string{"attendees", "calendar-id", "calendar-name", "date", "end-date", "name", "open-dingtalk-ids", "participants", "room-id", "room-ids", "room-name", "rooms", "start-date", "time", "time-max", "time-min", "user", "user-id", "user-ids", "users"},
-	},
-	{
-		CLIPath: "calendar +book-search",
-		Aliases: map[string]string{
-			"keyword":     "query",
-			"keywords":    "query",
-			"name":        "query",
-			"q":           "query",
-			"search":      "query",
-			"search-word": "query",
-		},
-		Blocked: []string{"subject", "text", "title"},
-	},
-	{
-		CLIPath: "calendar +cancel-event",
-		Aliases: map[string]string{
-			"calendar-event-id": "event",
-			"event-id":          "event",
-			"id":                "event",
-		},
-		Blocked: []string{"acl-id", "calendar-book-id", "calendar-id", "room-id"},
-	},
-	{
-		CLIPath: "calendar +conflicts",
-		Aliases: map[string]string{
-			"day-offset":      "in-days",
-			"days-from-today": "in-days",
-		},
-		Blocked: []string{"days", "duration", "end", "from", "start", "to"},
-	},
-	{
-		CLIPath: "calendar +create",
-		Aliases: map[string]string{
-			"attendee-ids":     "attendees",
-			"begin":            "start",
-			"calendar":         "calendar-id",
-			"calendar-book-id": "calendar-id",
-			"description":      "desc",
-			"end-time":         "end",
-			"freebusy":         "free-busy",
-			"from":             "start",
-			"room-id":          "rooms",
-			"room-ids":         "rooms",
-			"start-time":       "start",
-			"subject":          "title",
-			"summary":          "title",
-			"time-zone":        "timezone",
-			"to":               "end",
-			"tz":               "timezone",
-			"user-ids":         "attendees",
-			"users":            "attendees",
-		},
-		Blocked: []string{"acl-id", "attendee-name", "attendee-names", "calendar-name", "config", "date", "end-date", "event", "event-id", "field-description", "group-id", "id", "locale", "name", "offset", "open-dingtalk-ids", "participant-name", "participant-names", "rich-text-desc", "room", "room-name", "start-date", "time", "time-max", "time-min", "utc-offset", "who", "with"},
-	},
-	{
-		CLIPath: "calendar +free",
-		Aliases: map[string]string{
-			"begin":       "start",
-			"end-date":    "end",
-			"end-time":    "end",
-			"from":        "start",
-			"from-date":   "start",
-			"max-time":    "end",
-			"min-time":    "start",
-			"name":        "who",
-			"person":      "who",
-			"person-name": "who",
-			"since":       "start",
-			"start-date":  "start",
-			"start-time":  "start",
-			"time-max":    "end",
-			"time-min":    "start",
-			"to":          "end",
-		},
-		Blocked: []string{"date", "time", "user", "user-id", "user-ids", "users", "with"},
-	},
-	{
-		CLIPath: "calendar +free-slots",
-		Aliases: map[string]string{
-			"day-offset":      "in-days",
-			"days-from-today": "in-days",
-			"end-hour":        "to",
-			"start-hour":      "from",
-		},
-		Blocked: []string{"days", "duration", "end", "end-time", "start", "start-time", "time-max", "time-min"},
-	},
-	{
-		CLIPath: "calendar +freebusy",
-		Aliases: map[string]string{
-			"begin":      "start",
-			"end-date":   "end",
-			"end-time":   "end",
-			"from":       "start",
-			"from-date":  "start",
-			"max-time":   "end",
-			"min-time":   "start",
-			"room-id":    "rooms",
-			"room-ids":   "rooms",
-			"since":      "start",
-			"start-date": "start",
-			"start-time": "start",
-			"time-max":   "end",
-			"time-min":   "start",
-			"to":         "end",
-			"user-ids":   "users",
-		},
-		Blocked: []string{"at-user-ids", "attendee-names", "date", "group-id", "location", "name", "names", "participant-names", "room", "room-name", "staff-id", "time", "uid", "user", "user-id", "userid", "who", "with"},
-	},
-	{
-		CLIPath: "calendar +get",
-		Aliases: map[string]string{
-			"calendar":          "calendar-id",
-			"calendar-book-id":  "calendar-id",
-			"calendar-event-id": "event",
-			"event-id":          "event",
-		},
-		Blocked:   []string{"acl-id", "room-id"},
-		Ambiguous: []string{"id"},
-	},
-	{
-		CLIPath: "calendar +invite",
-		Aliases: map[string]string{
-			"attendee-names":    "with",
-			"calendar-event-id": "event",
-			"event-id":          "event",
-			"id":                "event",
-			"names":             "with",
-			"participant-names": "with",
-		},
-		Blocked: []string{"acl-id", "attendees", "calendar-book-id", "calendar-id", "open-dingtalk-ids", "participants", "room-id", "user", "user-id", "user-ids", "users"},
-	},
-	{
-		CLIPath: "calendar +my-free",
-		Aliases: map[string]string{
-			"begin":      "start",
-			"end-date":   "end",
-			"end-time":   "end",
-			"from":       "start",
-			"from-date":  "start",
-			"max-time":   "end",
-			"min-time":   "start",
-			"since":      "start",
-			"start-date": "start",
-			"start-time": "start",
-			"time-max":   "end",
-			"time-min":   "start",
-			"to":         "end",
-		},
-		Blocked: []string{"date", "time"},
-	},
-	{
-		CLIPath: "calendar +reschedule",
-		Aliases: map[string]string{
-			"begin":             "start",
-			"calendar-event-id": "event",
-			"end-time":          "end",
-			"event-id":          "event",
-			"from":              "start",
-			"id":                "event",
-			"start-time":        "start",
-			"to":                "end",
-		},
-		Blocked: []string{"acl-id", "calendar-book-id", "calendar-id", "date", "end-date", "room-id", "start-date", "time", "time-max", "time-min"},
-	},
-	{
-		CLIPath: "calendar +room-find",
-		Aliases: map[string]string{
-			"begin":         "start",
-			"end-date":      "end",
-			"end-time":      "end",
-			"from":          "start",
-			"from-date":     "start",
-			"group":         "group-id",
-			"max-result":    "limit",
-			"max-results":   "limit",
-			"max-time":      "end",
-			"min-time":      "start",
-			"name":          "room-name",
-			"page-index":    "page",
-			"page-size":     "limit",
-			"per-page":      "limit",
-			"query":         "room-name",
-			"room-group-id": "group-id",
-			"since":         "start",
-			"size":          "limit",
-			"start-date":    "start",
-			"start-time":    "start",
-			"take":          "limit",
-			"time-max":      "end",
-			"time-min":      "start",
-			"to":            "end",
-			"top":           "limit",
-		},
-		Blocked: []string{"count", "cursor", "date", "location", "next-cursor", "page-token", "room", "room-id", "room-ids", "rooms", "time"},
-	},
-	{
-		CLIPath: "calendar +room-groups",
-		Aliases: map[string]string{
-			"max-result":  "limit",
-			"max-results": "limit",
-			"page-index":  "page",
-			"page-size":   "limit",
-			"per-page":    "limit",
-			"size":        "limit",
-			"take":        "limit",
-			"top":         "limit",
-		},
-		Blocked: []string{"count", "cursor", "page-token"},
-	},
-	{
-		CLIPath: "calendar +room-search",
-		Aliases: map[string]string{
-			"name":  "room-name",
-			"query": "room-name",
-		},
-		Blocked: []string{"group-id", "location", "room", "room-id", "room-ids", "rooms"},
-	},
-	{
-		CLIPath: "calendar +rsvp",
-		Aliases: map[string]string{
-			"calendar":          "calendar-id",
-			"calendar-book-id":  "calendar-id",
-			"calendar-event-id": "event",
-			"event-id":          "event",
-			"response":          "status",
-			"response-status":   "status",
-		},
-		Blocked:   []string{"acl-id", "availability", "done", "free-busy", "room-id", "state"},
-		Ambiguous: []string{"id"},
-	},
-	{
-		CLIPath: "calendar +search-event",
-		Aliases: map[string]string{
-			"begin":            "start",
-			"calendar":         "calendar-id",
-			"calendar-book-id": "calendar-id",
-			"end-date":         "end",
-			"end-time":         "end",
-			"from":             "start",
-			"from-date":        "start",
-			"keyword":          "query",
-			"keywords":         "query",
-			"max-result":       "limit",
-			"max-results":      "limit",
-			"max-time":         "end",
-			"min-time":         "start",
-			"next-cursor":      "cursor",
-			"next-page-token":  "cursor",
-			"next-token":       "cursor",
-			"page-size":        "limit",
-			"page-token":       "cursor",
-			"per-page":         "limit",
-			"q":                "query",
-			"search":           "query",
-			"search-word":      "query",
-			"since":            "start",
-			"size":             "limit",
-			"start-date":       "start",
-			"start-time":       "start",
-			"take":             "limit",
-			"time-max":         "end",
-			"time-min":         "start",
-			"to":               "end",
-			"top":              "limit",
-		},
-		Blocked: []string{"acl-id", "count", "date", "event", "event-id", "id", "name", "offset", "page", "page-index", "room-id", "subject", "text", "time", "title"},
-	},
-	{
-		CLIPath: "calendar +suggest-time",
-		Aliases: map[string]string{
-			"attendee-names":           "with",
-			"begin":                    "start",
-			"duration-minutes":         "duration",
-			"end-date":                 "end",
-			"end-time":                 "end",
-			"from":                     "start",
-			"from-date":                "start",
-			"max-time":                 "end",
-			"meeting-duration-minutes": "duration",
-			"min-time":                 "start",
-			"names":                    "with",
-			"participant-names":        "with",
-			"since":                    "start",
-			"start-date":               "start",
-			"start-time":               "start",
-			"time-max":                 "end",
-			"time-min":                 "start",
-			"to":                       "end",
-		},
-		Blocked: []string{"attendees", "date", "open-dingtalk-ids", "participants", "remind-minutes", "time", "user", "user-id", "user-ids", "users"},
-	},
-	{
-		CLIPath: "calendar +suggestion",
-		Aliases: map[string]string{
-			"begin":                    "start",
-			"duration-minutes":         "duration",
-			"end-date":                 "end",
-			"end-time":                 "end",
-			"from":                     "start",
-			"from-date":                "start",
-			"max-time":                 "end",
-			"meeting-duration-minutes": "duration",
-			"min-time":                 "start",
-			"since":                    "start",
-			"start-date":               "start",
-			"start-time":               "start",
-			"time-max":                 "end",
-			"time-min":                 "start",
-			"time-zone":                "timezone",
-			"to":                       "end",
-			"tz":                       "timezone",
-			"user-ids":                 "users",
-		},
-		Blocked: []string{"at-user-ids", "attendee-name", "attendee-names", "date", "locale", "name", "names", "offset", "open-dingtalk-ids", "participant-name", "participant-names", "remind-minutes", "room-id", "room-ids", "room-name", "rooms", "staff-id", "time", "uid", "user", "user-id", "userid", "utc-offset", "who", "with"},
-	},
-	{
-		CLIPath: "calendar +update",
-		Aliases: map[string]string{
-			"add-user-ids":      "add-attendees",
-			"add-users":         "add-attendees",
-			"begin":             "start",
-			"calendar":          "calendar-id",
-			"calendar-book-id":  "calendar-id",
-			"calendar-event-id": "event",
-			"description":       "desc",
-			"end-time":          "end",
-			"event-id":          "event",
-			"freebusy":          "free-busy",
-			"from":              "start",
-			"remove-user-ids":   "remove-attendees",
-			"remove-users":      "remove-attendees",
-			"start-time":        "start",
-			"subject":           "title",
-			"summary":           "title",
-			"time-zone":         "timezone",
-			"to":                "end",
-			"tz":                "timezone",
-		},
-		Blocked:   []string{"acl-id", "attendee-name", "attendee-names", "calendar-name", "config", "date", "end-date", "field-description", "group-id", "locale", "name", "offset", "open-dingtalk-ids", "participant-name", "participant-names", "remind-minutes", "reminder-minutes", "rich-text-desc", "room-id", "room-ids", "room-name", "rooms", "start-date", "time", "time-max", "time-min", "utc-offset", "who", "with"},
-		Ambiguous: []string{"attendees", "id", "user-ids", "users"},
-	},
-	{
-		CLIPath: "calendar acl delete",
-		Blocked: []string{"calendar-book-id", "calendar-id", "event", "event-id", "room-id", "user-id"},
-	},
-	{
-		CLIPath: "calendar attachment add",
-		Blocked: []string{"attachments", "file", "file-id", "file-ids"},
-	},
-	{
-		CLIPath: "calendar attendee add",
-		Blocked: []string{"attendee-name", "attendee-names", "open-dingtalk-ids", "participant-name", "participant-names", "who", "with"},
-	},
-	{
-		CLIPath: "calendar attendee delete",
-		Blocked: []string{"attendee-name", "attendee-names", "open-dingtalk-ids", "participant-name", "participant-names", "who", "with"},
-	},
-	{
-		CLIPath: "calendar busy search",
-		Aliases: map[string]string{
-			"room-id": "rooms",
-		},
-		Blocked: []string{"attendee-name", "attendee-names", "group-id", "location", "name", "names", "participant-names", "room", "room-name", "who", "with"},
-	},
-	{
-		CLIPath: "calendar event create",
-		Aliases: map[string]string{
-			"reminder-minutes":        "remind-minutes",
-			"reminder-offset-minutes": "remind-minutes",
-			"room-id":                 "rooms",
-			"time-zone":               "timezone",
-			"tz":                      "timezone",
-		},
-		Blocked: []string{"at", "attendee-name", "attendee-names", "due", "duration", "group-id", "locale", "offset", "participant-name", "participant-names", "remind-at", "reminder-time", "room", "room-name", "utc-offset", "who", "with"},
-	},
 	{
 		CLIPath: "calendar event list",
 		Aliases: map[string]string{
@@ -2222,54 +1789,6 @@ var generatedParamAliases = []ParamAliasEntry{
 		},
 		Blocked: []string{"offset", "page", "time"},
 	},
-	{
-		CLIPath: "calendar event respond",
-		Aliases: map[string]string{
-			"response":        "status",
-			"response-status": "status",
-		},
-		Blocked: []string{"availability", "done", "free-busy", "state"},
-	},
-	{
-		CLIPath: "calendar event suggest",
-		Aliases: map[string]string{
-			"duration-minutes":         "duration",
-			"meeting-duration-minutes": "duration",
-			"time-zone":                "timezone",
-			"tz":                       "timezone",
-		},
-		Blocked: []string{"attendee-name", "attendee-names", "from", "locale", "name", "names", "offset", "open-dingtalk-ids", "participant-names", "remind-minutes", "to", "utc-offset", "who", "with"},
-	},
-	{
-		CLIPath: "calendar event update",
-		Aliases: map[string]string{
-			"time-zone": "timezone",
-			"tz":        "timezone",
-		},
-		Blocked: []string{"attendees", "group-id", "locale", "offset", "participants", "remind-minutes", "reminder-minutes", "room-id", "room-ids", "room-name", "rooms", "utc-offset"},
-	},
-	{
-		CLIPath: "calendar room add",
-		Aliases: map[string]string{
-			"room-id": "rooms",
-		},
-		Blocked: []string{"group-id", "location", "room", "room-name"},
-	},
-	{
-		CLIPath: "calendar room delete",
-		Aliases: map[string]string{
-			"room-id": "rooms",
-		},
-		Blocked: []string{"group-id", "location", "room", "room-name"},
-	},
-	{
-		CLIPath: "calendar room search",
-		Aliases: map[string]string{
-			"group":         "group-id",
-			"room-group-id": "group-id",
-		},
-		Blocked: []string{"location", "room", "room-id", "room-ids", "rooms"},
-	},
 	{
 		CLIPath: "chat +bot-find",
 		Aliases: map[string]string{
@@ -3422,7 +2941,7 @@ var generatedParamAliases = []ParamAliasEntry{
 			"uid":      "user",
 			"userid":   "user",
 		},
-		Blocked: []string{"at-user-ids", "conversation-ids", "dest-conversation-id", "group-id", "group-ids", "group-name", "name", "open-conversation-ids", "source", "src-conversation-id", "target", "to-user", "user-ids", "users"},
+		Blocked: []string{"at-user-ids", "conversation-ids", "dest-conversation-id", "group-id", "group-ids", "group-name", "name", "open-conversation-ids", "role-id", "source", "src-conversation-id", "target", "to-user", "user-ids", "users"},
 	},
 	{
 		CLIPath: "chat group-role update",

internal/corecmd/corecmd.go

@@ -230,10 +230,9 @@ const (
 //   - Validate / PostMount — orchestration only; must not register business flags
 //     or assemble business params that belong in Flags/ConstParams.
 //
-// Exactly one of RunE / Invoke / ResultInvoke / Orchestrate must be set; New
-// validates this at construction time. corecmd stays dispatch-agnostic and
-// never calls a backend: the adapters (FromLeafSpec / FromShortcut) supply the
-// body.
+// Exactly one of RunE / Invoke / Orchestrate must be set; New validates this at
+// construction time. corecmd stays dispatch-agnostic and never calls a backend:
+// the adapters (FromLeafSpec / FromShortcut) supply the body.
 type Spec struct {
 	Use           string
 	Short         string
@@ -260,8 +259,7 @@ type Spec struct {
 	// backend call).
 	ConfirmFirst bool
 	// ConstParams are fixed toolArgs merged after flag assembly (e.g. precheckOnly).
-	// They are payload declaration, not user flags, never satisfy Required, and
-	// require an Invoke or ResultInvoke dispatcher that consumes assembled args.
+	// They are payload declaration, not user flags, and never satisfy Required.
 	ConstParams map[string]any
 	// Contract is the authoring-time leaf contract declaration (selection /
 	// interface / parameters / dry-run / identity). When non-empty, embed
@@ -373,9 +371,7 @@ func (c *Ctx) Yes() bool { return BoolFlag(c.cmd, "yes") }
 // malformed spec can never run the pipeline — write-confirmation prompt
 // included — and then silently exit 0 having done nothing.
 func New(spec Spec) *cobra.Command {
-	spec.ConstParams = cloneConstParams(spec.ConstParams)
 	validateDispatchDecl(spec)
-	validateConstParamsDecl(spec)
 	validateSafetySpec(spec)
 	validateContractDecl(spec)
 	validateInputSpecs(spec.Use, spec.Flags)
@@ -403,7 +399,6 @@ func New(spec Spec) *cobra.Command {
 	if spec.PostMount != nil {
 		spec.PostMount(cmd)
 	}
-	attachInterfaceBoolConstParams(cmd, spec.ConstParams)
 	if spec.OutputRollout != "" {
 		output.SetCommandRollout(cmd, spec.OutputRollout)
 	}
@@ -467,17 +462,6 @@ func New(spec Spec) *cobra.Command {
 	return cmd
 }
 
-func cloneConstParams(params map[string]any) map[string]any {
-	if params == nil {
-		return nil
-	}
-	frozen := make(map[string]any, len(params))
-	for key, value := range params {
-		frozen[key] = value
-	}
-	return frozen
-}
-
 // ConfirmFirstAnnotation marks commands whose Spec declared ConfirmFirst. The
 // delivery gate reads it to tell a declared guard-first command apart from an
 // accidental confirm-before-validate inversion: guard-first is only legitimate
@@ -553,21 +537,6 @@ func validateDispatchDecl(spec Spec) {
 	}
 }
 
-func validateConstParamsDecl(spec Spec) {
-	if len(spec.ConstParams) == 0 {
-		return
-	}
-	if spec.Invoke == nil && spec.ResultInvoke == nil {
-		panic(fmt.Sprintf("command %q ConstParams require Invoke or ResultInvoke", spec.Use))
-	}
-	for _, flag := range spec.Flags {
-		key := bindKey(flag)
-		if _, conflicts := spec.ConstParams[key]; conflicts {
-			panic(fmt.Sprintf("command %q ConstParams key %q conflicts with flag --%s", spec.Use, key, flag.Name))
-		}
-	}
-}
-
 // validateSafetySpec rejects partial safety declarations. A zero value remains
 // the historical read-only default, but once any field is authored all four
 // independent Schema dimensions must be explicit.

internal/corecmd/corecmd_test.go

@@ -26,7 +26,6 @@ import (
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd/contractfinal"
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd/runtimeannotate"
 	apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/output"
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
 	"github.com/spf13/cobra"
 )
@@ -1416,23 +1415,17 @@ func TestCrossPlatformCoverageBuildArgsIntArgDefaultFloor(t *testing.T) {
 	}
 }
 
-func TestCrossPlatformCoverageNewCommandFreezesAndMergesConstParams(t *testing.T) {
+func TestNewCommandMergesConstParams(t *testing.T) {
 	var got map[string]any
-	declared := map[string]any{
-		"precheckOnly":      false,
-		"convThreadEnabled": true,
-	}
 	cmd := New(Spec{
 		Use:         "pub",
 		Flags:       []FlagSpec{{Name: "id", Usage: "ID", Bind: "versionId", Trim: true}},
-		ConstParams: declared,
+		ConstParams: map[string]any{"precheckOnly": false},
 		Invoke: func(_ *Ctx, toolArgs map[string]any) error {
 			got = toolArgs
 			return nil
 		},
 	})
-	declared["precheckOnly"] = true
-	declared["forgedAfterNew"] = true
 	_ = cmd.Flags().Set("id", "V1")
 	if err := cmd.RunE(cmd, nil); err != nil {
 		t.Fatal(err)
@@ -1443,95 +1436,6 @@ func TestCrossPlatformCoverageNewCommandFreezesAndMergesConstParams(t *testing.T
 	if got["precheckOnly"] != false {
 		t.Fatalf("precheckOnly = %#v, want false", got["precheckOnly"])
 	}
-	if got["convThreadEnabled"] != true {
-		t.Fatalf("convThreadEnabled = %#v, want true", got["convThreadEnabled"])
-	}
-	if _, exists := got["forgedAfterNew"]; exists {
-		t.Fatalf("caller mutation leaked into dispatch args: %#v", got)
-	}
-	evidence := InterfaceBoolConstParams(cmd)
-	if !reflect.DeepEqual(evidence, map[string]bool{"convThreadEnabled": true, "precheckOnly": false}) {
-		t.Fatalf("bool ConstParams evidence = %#v", evidence)
-	}
-	if got["precheckOnly"] != evidence["precheckOnly"] {
-		t.Fatalf("dispatch/evidence drift: args=%#v evidence=%#v", got, evidence)
-	}
-}
-
-func TestCrossPlatformCoverageNewCommandDoesNotProjectMixedConstParamsEvidence(t *testing.T) {
-	var got map[string]any
-	cmd := New(Spec{
-		Use: "mixed",
-		ConstParams: map[string]any{
-			"convThreadEnabled": true,
-			"retryLimit":        3,
-		},
-		Invoke: func(_ *Ctx, toolArgs map[string]any) error {
-			got = toolArgs
-			return nil
-		},
-	})
-
-	if evidence := InterfaceBoolConstParams(cmd); evidence != nil {
-		t.Fatalf("mixed ConstParams evidence = %#v; want missing evidence", evidence)
-	}
-	if err := cmd.RunE(cmd, nil); err != nil {
-		t.Fatal(err)
-	}
-	if got["convThreadEnabled"] != true || got["retryLimit"] != 3 {
-		t.Fatalf("mixed ConstParams dispatch args = %#v", got)
-	}
-}
-
-func TestCrossPlatformCoverageNewCommandRejectsInvalidConstParamsDispatch(t *testing.T) {
-	mustPanic := func(name string, spec Spec, needle string) {
-		t.Helper()
-		defer func() {
-			r := recover()
-			if r == nil {
-				t.Fatalf("%s: expected panic", name)
-			}
-			if msg, _ := r.(string); !strings.Contains(msg, needle) {
-				t.Fatalf("%s: panic=%v, want %q", name, r, needle)
-			}
-		}()
-		New(spec)
-	}
-
-	mustPanic("RunE", Spec{
-		Use:         "run-e",
-		ConstParams: map[string]any{"fixed": true},
-		RunE:        func(*cobra.Command, []string) error { return nil },
-	}, "ConstParams require Invoke or ResultInvoke")
-	mustPanic("Orchestrate", Spec{
-		Use:         "orchestrate",
-		ConstParams: map[string]any{"fixed": true},
-		Orchestrate: func(*Ctx) error { return nil },
-	}, "ConstParams require Invoke or ResultInvoke")
-	mustPanic("explicit bind conflict", Spec{
-		Use:         "bind-conflict",
-		Flags:       []FlagSpec{{Name: "thread", Usage: "T", Bind: "convThreadEnabled"}},
-		ConstParams: map[string]any{"convThreadEnabled": true},
-		Invoke:      func(*Ctx, map[string]any) error { return nil },
-	}, "conflicts with flag --thread")
-	mustPanic("default bind conflict", Spec{
-		Use:         "default-bind-conflict",
-		Flags:       []FlagSpec{{Name: "fixed-value", Usage: "F"}},
-		ConstParams: map[string]any{"fixedValue": true},
-		Invoke:      func(*Ctx, map[string]any) error { return nil },
-	}, "conflicts with flag --fixed-value")
-
-	result := New(Spec{
-		Use:           "result",
-		OutputRollout: output.RolloutUnifiedActive,
-		ConstParams:   map[string]any{"fixed": true},
-		ResultInvoke: func(*Ctx, map[string]any) (output.CommandResult, error) {
-			return output.Success(nil), nil
-		},
-	})
-	if evidence := InterfaceBoolConstParams(result); !evidence["fixed"] {
-		t.Fatalf("ResultInvoke ConstParams evidence = %#v", evidence)
-	}
 }
 
 func TestCrossPlatformCoverageNewCommandConfirmFirstAnnotationAndOrder(t *testing.T) {

internal/corecmd/interface_const_params.go

@@ -1,63 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package corecmd
-
-import (
-	"sync"
-
-	"github.com/spf13/cobra"
-)
-
-var interfaceBoolConstParamsRegistry sync.Map
-
-// attachInterfaceBoolConstParams records framework-owned ConstParams evidence.
-// Only a non-empty, entirely boolean declaration is representable in v1;
-// empty or mixed declarations remove any evidence for the command.
-func attachInterfaceBoolConstParams(cmd *cobra.Command, params map[string]any) {
-	if cmd == nil {
-		return
-	}
-	if len(params) == 0 {
-		interfaceBoolConstParamsRegistry.Delete(cmd)
-		return
-	}
-	bools := make(map[string]bool, len(params))
-	for key, value := range params {
-		boolValue, ok := value.(bool)
-		if !ok {
-			interfaceBoolConstParamsRegistry.Delete(cmd)
-			return
-		}
-		bools[key] = boolValue
-	}
-	interfaceBoolConstParamsRegistry.Store(cmd, bools)
-}
-
-// InterfaceBoolConstParams returns a clone of framework-owned boolean
-// ConstParams evidence. Callers cannot mutate the private registry.
-func InterfaceBoolConstParams(cmd *cobra.Command) map[string]bool {
-	if cmd == nil {
-		return nil
-	}
-	stored, ok := interfaceBoolConstParamsRegistry.Load(cmd)
-	if !ok {
-		return nil
-	}
-	params := stored.(map[string]bool)
-	clone := make(map[string]bool, len(params))
-	for key, value := range params {
-		clone[key] = value
-	}
-	return clone
-}

internal/corecmd/interface_const_params_test.go

@@ -1,44 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-
-package corecmd
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-func TestCrossPlatformCoverageInterfaceBoolConstParamsRegistryClonesAndDeletes(t *testing.T) {
-	attachInterfaceBoolConstParams(nil, map[string]any{"ignored": true})
-	if got := InterfaceBoolConstParams(nil); got != nil {
-		t.Fatalf("nil command evidence = %#v, want nil", got)
-	}
-
-	cmd := &cobra.Command{Use: "send"}
-	declared := map[string]any{"convThreadEnabled": true, "precheckOnly": false}
-	attachInterfaceBoolConstParams(cmd, declared)
-	declared["convThreadEnabled"] = false
-
-	want := map[string]bool{"convThreadEnabled": true, "precheckOnly": false}
-	got := InterfaceBoolConstParams(cmd)
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("registered bool ConstParams = %#v, want %#v", got, want)
-	}
-	got["convThreadEnabled"] = false
-	if again := InterfaceBoolConstParams(cmd); !reflect.DeepEqual(again, want) {
-		t.Fatalf("reader leaked mutable registry state: %#v", again)
-	}
-
-	attachInterfaceBoolConstParams(cmd, map[string]any{"convThreadEnabled": true, "retryLimit": 3})
-	if got := InterfaceBoolConstParams(cmd); got != nil {
-		t.Fatalf("mixed ConstParams retained evidence: %#v", got)
-	}
-
-	attachInterfaceBoolConstParams(cmd, map[string]any{"convThreadEnabled": true})
-	attachInterfaceBoolConstParams(cmd, nil)
-	if got := InterfaceBoolConstParams(cmd); got != nil {
-		t.Fatalf("empty ConstParams retained evidence: %#v", got)
-	}
-}

internal/event/personal/client_test.go

@@ -132,7 +132,6 @@ func TestClientCreateRuleBasedSubscriptionsUsesDocumentedRuleParam(t *testing.T)
 		{"oa_approval_task_finished", EventOAApprovalTaskFinished, RuleOptions{}, map[string]any{}},
 		{"oa_approval_task_redirected", EventOAApprovalTaskRedirected, RuleOptions{}, map[string]any{}},
 		{"oa_approval_instance_started", EventOAApprovalInstanceStarted, RuleOptions{}, map[string]any{}},
-		{"oa_approval_instance_cc", EventOAApprovalInstanceCC, RuleOptions{}, map[string]any{}},
 		{"oa_approval_instance_terminated", EventOAApprovalInstanceTerminated, RuleOptions{}, map[string]any{}},
 		{"oa_approval_instance_finished", EventOAApprovalInstanceFinished, RuleOptions{}, map[string]any{}},
 		{"read_group", EventReadGroup, RuleOptions{GroupID: "cid-1"}, map[string]any{"openConversationId": "cid-1"}},

internal/event/personal/output.go

@@ -180,19 +180,6 @@ type OAApprovalInstanceStartedOutput struct {
 	EventTime         int64  `json:"event_time" description:"审批实例事件业务时间" format:"timestamp_ms"`
 }
 
-type OAApprovalInstanceCCOutput struct {
-	Type              string `json:"type" description:"事件类型，固定为当前 event_key"`
-	EventID           string `json:"event_id" description:"事件 ID，可用于去重"`
-	Timestamp         int64  `json:"timestamp" description:"事件发生时间戳" format:"timestamp_ms"`
-	SubscribeID       string `json:"subscribe_id" description:"订阅 ID"`
-	ProcessInstanceID string `json:"process_instance_id" description:"审批实例 ID"`
-	ProcessCode       string `json:"process_code" description:"审批流程模板编码"`
-	Title             string `json:"title" description:"审批标题"`
-	Status            string `json:"status" description:"审批实例到达抄送节点时的状态"`
-	CreateTime        int64  `json:"create_time" description:"审批实例创建时间" format:"timestamp_ms"`
-	EventTime         int64  `json:"event_time" description:"审批抄送事件业务时间" format:"timestamp_ms"`
-}
-
 type OAApprovalInstanceTerminatedOutput struct {
 	Type              string `json:"type" description:"事件类型，固定为当前 event_key"`
 	EventID           string `json:"event_id" description:"事件 ID，可用于去重"`
@@ -680,19 +667,6 @@ func projectOAApprovalEvent(ev transport.Event, base baseEventOutput, raw json.R
 			CreateTime:        payload.Body.CreateTime,
 			EventTime:         payload.EventTime,
 		}, nil
-	case EventOAApprovalInstanceCC:
-		return OAApprovalInstanceCCOutput{
-			Type:              base.Type,
-			EventID:           base.EventID,
-			Timestamp:         base.Timestamp,
-			SubscribeID:       base.SubscribeID,
-			ProcessInstanceID: payload.Body.ProcessInstanceID,
-			ProcessCode:       payload.Body.ProcessCode,
-			Title:             payload.Body.Title,
-			Status:            payload.Body.Status,
-			CreateTime:        payload.Body.CreateTime,
-			EventTime:         payload.EventTime,
-		}, nil
 	case EventOAApprovalInstanceTerminated:
 		return OAApprovalInstanceTerminatedOutput{
 			Type:              base.Type,
@@ -897,8 +871,6 @@ func outputTypeForEvent(eventKey string) reflect.Type {
 		return reflect.TypeOf(OAApprovalTaskRedirectedOutput{})
 	case eventKey == EventOAApprovalInstanceStarted:
 		return reflect.TypeOf(OAApprovalInstanceStartedOutput{})
-	case eventKey == EventOAApprovalInstanceCC:
-		return reflect.TypeOf(OAApprovalInstanceCCOutput{})
 	case eventKey == EventOAApprovalInstanceTerminated:
 		return reflect.TypeOf(OAApprovalInstanceTerminatedOutput{})
 	case eventKey == EventOAApprovalInstanceFinished:
@@ -934,7 +906,6 @@ func isOAEvent(eventKey string) bool {
 		eventKey == EventOAApprovalTaskFinished ||
 		eventKey == EventOAApprovalTaskRedirected ||
 		eventKey == EventOAApprovalInstanceStarted ||
-		eventKey == EventOAApprovalInstanceCC ||
 		eventKey == EventOAApprovalInstanceTerminated ||
 		eventKey == EventOAApprovalInstanceFinished
 }

internal/event/personal/output_test.go

@@ -173,8 +173,6 @@ func personalOAData(eventKey string) string {
 		body["finishTime"] = int64(1785229199000)
 	case EventOAApprovalInstanceStarted:
 		body["status"] = "RUNNING"
-	case EventOAApprovalInstanceCC:
-		body["status"] = "RUNNING"
 	case EventOAApprovalInstanceTerminated:
 		body["status"] = "TERMINATED"
 		body["finishTime"] = int64(1785229199000)
@@ -523,21 +521,6 @@ func TestCrossPlatformCoverageProjectOutputOAEvents(t *testing.T) {
 				EventTime:         1785229199000,
 			},
 		},
-		{
-			eventKey: EventOAApprovalInstanceCC,
-			want: OAApprovalInstanceCCOutput{
-				Type:              EventOAApprovalInstanceCC,
-				EventID:           "oa-event",
-				Timestamp:         1785229200123,
-				SubscribeID:       "outer-sub",
-				ProcessInstanceID: "process-instance-1",
-				ProcessCode:       "PROC-TEST-1",
-				Title:             "测试审批",
-				Status:            "RUNNING",
-				CreateTime:        1785229100000,
-				EventTime:         1785229199000,
-			},
-		},
 		{
 			eventKey: EventOAApprovalInstanceTerminated,
 			want: OAApprovalInstanceTerminatedOutput{
@@ -802,7 +785,6 @@ func TestCrossPlatformCoverageProjectOutputRejectsInvalidOAPayloads(t *testing.T
 		EventOAApprovalTaskFinished,
 		EventOAApprovalTaskRedirected,
 		EventOAApprovalInstanceStarted,
-		EventOAApprovalInstanceCC,
 		EventOAApprovalInstanceTerminated,
 		EventOAApprovalInstanceFinished,
 	} {

internal/event/personal/registry.go

@@ -43,7 +43,6 @@ const (
 	EventOAApprovalTaskFinished       = "user_oa_approval_task_finished"
 	EventOAApprovalTaskRedirected     = "user_oa_approval_task_redirected"
 	EventOAApprovalInstanceStarted    = "user_oa_approval_instance_started"
-	EventOAApprovalInstanceCC         = "user_oa_approval_instance_cc"
 	EventOAApprovalInstanceTerminated = "user_oa_approval_instance_terminated"
 	EventOAApprovalInstanceFinished   = "user_oa_approval_instance_finished"
 )
@@ -324,17 +323,6 @@ var definitions = []Definition{
 		Auth:           map[string]any{"identity": "user"},
 		Public:         true,
 	},
-	{
-		EventKey:       EventOAApprovalInstanceCC,
-		DisplayName:    "审批单抄送",
-		Description:    "审批实例到达抄送节点，发送给被抄送人",
-		Category:       "oa",
-		RuleType:       "all",
-		Status:         StatusEnabled,
-		RequiredParams: nil,
-		Auth:           map[string]any{"identity": "user"},
-		Public:         true,
-	},
 	{
 		EventKey:       EventOAApprovalInstanceTerminated,
 		DisplayName:    "审批单终止",

internal/event/personal/registry_test.go

@@ -50,7 +50,6 @@ func TestCatalogEnabledEvents(t *testing.T) {
 		EventOAApprovalTaskFinished,
 		EventOAApprovalTaskRedirected,
 		EventOAApprovalInstanceStarted,
-		EventOAApprovalInstanceCC,
 		EventOAApprovalInstanceTerminated,
 		EventOAApprovalInstanceFinished,
 	}
@@ -66,7 +65,6 @@ func TestOAEventCatalogDefinitions(t *testing.T) {
 		EventOAApprovalTaskFinished,
 		EventOAApprovalTaskRedirected,
 		EventOAApprovalInstanceStarted,
-		EventOAApprovalInstanceCC,
 		EventOAApprovalInstanceTerminated,
 		EventOAApprovalInstanceFinished,
 	}
@@ -160,7 +158,6 @@ func TestSchemaDocumentsDefaultToTransportEnvelope(t *testing.T) {
 		EventOAApprovalTaskFinished,
 		EventOAApprovalTaskRedirected,
 		EventOAApprovalInstanceStarted,
-		EventOAApprovalInstanceCC,
 		EventOAApprovalInstanceTerminated,
 		EventOAApprovalInstanceFinished,
 	} {
@@ -512,13 +509,6 @@ func TestOAEventSchemaDocumentsMatchOutputDTO(t *testing.T) {
 				"process_code", "title", "status", "create_time", "event_time",
 			},
 		},
-		{
-			eventKey: EventOAApprovalInstanceCC,
-			properties: []string{
-				"type", "event_id", "timestamp", "subscribe_id", "process_instance_id",
-				"process_code", "title", "status", "create_time", "event_time",
-			},
-		},
 		{
 			eventKey: EventOAApprovalInstanceTerminated,
 			properties: []string{
@@ -643,7 +633,6 @@ func TestBuildRuleParamAllEvents(t *testing.T) {
 		EventOAApprovalTaskFinished,
 		EventOAApprovalTaskRedirected,
 		EventOAApprovalInstanceStarted,
-		EventOAApprovalInstanceCC,
 		EventOAApprovalInstanceTerminated,
 		EventOAApprovalInstanceFinished,
 	} {
@@ -856,7 +845,6 @@ func TestSupportsMessageFilter(t *testing.T) {
 		EventOAApprovalTaskFinished,
 		EventOAApprovalTaskRedirected,
 		EventOAApprovalInstanceStarted,
-		EventOAApprovalInstanceCC,
 		EventOAApprovalInstanceTerminated,
 		EventOAApprovalInstanceFinished,
 		"unknown_event",

internal/helpers/aitable.go

@@ -7,8 +7,6 @@ import (
 	"io"
 	"math"
 	"os"
-	"reflect"
-	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -128,83 +126,6 @@ func resolveWorkflowDSL(cmd *cobra.Command) (map[string]any, error) {
 	return dsl, nil
 }
 
-// executeAitableWorkflowPublish executes a publish exactly once, then requires
-// the reviewed valid/flowId envelope before rendering any success output.
-// create_workflow is non-idempotent, so transport uncertainty is never retried.
-func executeAitableWorkflowPublish(toolName string, args map[string]any) error {
-	if deps.Caller.DryRun() {
-		return callMCPToolOnServer("aitable", toolName, args)
-	}
-	raw, err := callMCPToolReturnTextOnServer(context.Background(), "aitable", toolName, args)
-	if err != nil {
-		return err
-	}
-	var envelope map[string]any
-	if err := json.Unmarshal([]byte(raw), &envelope); err != nil || envelope == nil {
-		return fmt.Errorf("%s response is not a JSON object", toolName)
-	}
-	valid, validFound, flowID, err := strictAitableWorkflowPublishResult(envelope)
-	if err != nil {
-		return fmt.Errorf("%s response validation failed: %w", toolName, err)
-	}
-	if !validFound {
-		return fmt.Errorf("%s response is missing valid", toolName)
-	}
-	if !valid {
-		return fmt.Errorf("%s returned valid=false; inspect issues and correct the workflow DSL", toolName)
-	}
-	if flowID == "" {
-		return fmt.Errorf("%s response is missing a non-empty flowId", toolName)
-	}
-	return RenderLegacyMCPText(toolName, raw)
-}
-
-func strictAitableWorkflowPublishResult(envelope map[string]any) (valid bool, validFound bool, flowID string, err error) {
-	var visit func(map[string]any) error
-	visit = func(object map[string]any) error {
-		if raw, exists := object["valid"]; exists {
-			value, ok := raw.(bool)
-			if !ok {
-				return fmt.Errorf("valid must be boolean, got %T", raw)
-			}
-			if validFound && valid != value {
-				return fmt.Errorf("conflicting valid values")
-			}
-			valid, validFound = value, true
-		}
-		for _, key := range []string{"flowId", "workflowId"} {
-			raw, exists := object[key]
-			if !exists {
-				continue
-			}
-			value, ok := raw.(string)
-			value = strings.TrimSpace(value)
-			if !ok || value == "" {
-				return fmt.Errorf("%s must be a non-empty string", key)
-			}
-			if flowID != "" && flowID != value {
-				return fmt.Errorf("conflicting workflow IDs")
-			}
-			flowID = value
-		}
-		for _, key := range []string{"data", "result", "response"} {
-			if nested, ok := object[key].(map[string]any); ok {
-				if err := visit(nested); err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	}
-	if envelope == nil {
-		return false, false, "", fmt.Errorf("empty response")
-	}
-	if err := visit(envelope); err != nil {
-		return false, false, "", err
-	}
-	return valid, validFound, flowID, nil
-}
-
 func validateWorkflowRunFlags(cmd *cobra.Command, _ []string) error {
 	tableID, _ := cmd.Flags().GetString("table-id")
 	tableID = strings.TrimSpace(tableID)
@@ -1263,290 +1184,6 @@ func runAitableViewUpdateArray(cmd *cobra.Command, blockKey string) error {
 	return callUpdateViewWithBlock(baseID, tableID, viewID, blockKey, cfgMap[blockKey], nil)
 }
 
-func runAitableViewUpdateFilter(cmd *cobra.Command) error {
-	baseID, tableID, viewID, _, err := viewUpdateCommonPreflight(cmd, "filter", nil, false)
-	if err != nil {
-		return err
-	}
-	jsonStr, _ := cmd.Flags().GetString("json")
-	if jsonStr == "" {
-		return fmt.Errorf("必须指定 --json 传入 filter JSON 数组")
-	}
-	var parsed any
-	if err := json.Unmarshal([]byte(jsonStr), &parsed); err != nil {
-		return fmt.Errorf("--json 解析失败: %v", err)
-	}
-	cfgMap := map[string]any{"filter": parsed}
-	if err := normalizeViewConfigBlock(cfgMap); err != nil {
-		return err
-	}
-	filter, _ := cfgMap["filter"].([]any)
-	fieldTypes, err := loadAitableFieldTypes(context.Background(), baseID, tableID)
-	if err != nil {
-		return err
-	}
-	if err := validateAitableViewFilter(filter, fieldTypes); err != nil {
-		return err
-	}
-	toolArgs := map[string]any{
-		"baseId": baseID, "tableId": tableID, "viewId": viewID,
-		"config": map[string]any{"filter": filter},
-	}
-	if deps.Caller.DryRun() {
-		return deps.Out.PrintJSON(map[string]any{
-			"dry_run": true, "executed": false, "tool": "update_view", "arguments": toolArgs,
-		})
-	}
-	if _, err := callMCPToolReturnTextOnServer(context.Background(), "aitable", "update_view", toolArgs); err != nil {
-		return err
-	}
-	var actual any
-	var readBackErr error
-	for attempt := 0; attempt < aitableViewFilterReadbackAttempts; attempt++ {
-		if attempt > 0 {
-			backoff := time.Duration(1<<(attempt-1)) * time.Second
-			if backoff > 8*time.Second {
-				backoff = 8 * time.Second
-			}
-			aitableViewFilterReadbackSleep(backoff)
-		}
-		view, _, err := getViewRaw(context.Background(), baseID, tableID, viewID)
-		if err != nil {
-			readBackErr = err
-			continue
-		}
-		actualViewID, _ := view["viewId"].(string)
-		if actualViewID != viewID {
-			readBackErr = fmt.Errorf("update_view read-back returned viewId %q, want %q", actualViewID, viewID)
-			continue
-		}
-		actual = walkViewPath(view, "filter")
-		if persistedViewFilterMatches(actual, filter) {
-			readBackErr = nil
-			break
-		}
-		readBackErr = fmt.Errorf("update_view filter read-back mismatch: got %s, want %s", compactJSON(actual), compactJSON(filter))
-	}
-	if readBackErr != nil {
-		return &CLIError{Code: CodeMCPToolError, Message: readBackErr.Error(), Suggestion: "重新读取 view get filter，确认服务端支持所用字段类型和操作符后再试"}
-	}
-	return deps.Out.PrintJSON(map[string]any{
-		"success": true,
-		"data":    map[string]any{"baseId": baseID, "tableId": tableID, "viewId": viewID, "filter": filter, "verified": true},
-	})
-}
-
-const aitableViewFilterReadbackAttempts = 6
-
-var aitableViewFilterReadbackSleep = time.Sleep
-
-func persistedViewFilterMatches(actual any, expected []any) bool {
-	if reflect.DeepEqual(actual, expected) {
-		return true
-	}
-	root, ok := actual.(map[string]any)
-	if !ok || root["operator"] != "and" {
-		return false
-	}
-	operands, ok := root["operands"].([]any)
-	return ok && reflect.DeepEqual(operands, expected)
-}
-
-func loadAitableFieldTypes(ctx context.Context, baseID, tableID string) (map[string]string, error) {
-	raw, err := callMCPReadToolReturnTextOnServer(ctx, "aitable", "get_fields", map[string]any{"baseId": baseID, "tableId": tableID})
-	if err != nil {
-		return nil, err
-	}
-	var payload any
-	if err := json.Unmarshal([]byte(raw), &payload); err != nil {
-		return nil, fmt.Errorf("get_fields response is not valid JSON: %v", err)
-	}
-	fields, ok := findAitableObjectList(payload, "fields", "fieldList")
-	if !ok {
-		return nil, fmt.Errorf("get_fields response is missing the fields collection")
-	}
-	types := make(map[string]string, len(fields))
-	for index, field := range fields {
-		fieldID, _ := field["fieldId"].(string)
-		if strings.TrimSpace(fieldID) == "" {
-			fieldID, _ = field["id"].(string)
-		}
-		fieldType, _ := field["type"].(string)
-		if strings.TrimSpace(fieldType) == "" {
-			fieldType, _ = field["fieldType"].(string)
-		}
-		if strings.TrimSpace(fieldID) == "" || strings.TrimSpace(fieldType) == "" {
-			return nil, fmt.Errorf("get_fields field %d is missing fieldId or type", index)
-		}
-		types[strings.TrimSpace(fieldID)] = strings.TrimSpace(fieldType)
-	}
-	return types, nil
-}
-
-func findAitableObjectList(value any, names ...string) ([]map[string]any, bool) {
-	wanted := make([]string, 0, len(names))
-	seen := make(map[string]bool, len(names))
-	for _, name := range names {
-		name = strings.ToLower(name)
-		if !seen[name] {
-			wanted = append(wanted, name)
-			seen[name] = true
-		}
-	}
-	var walk func(any) ([]map[string]any, bool)
-	walk = func(current any) ([]map[string]any, bool) {
-		switch typed := current.(type) {
-		case map[string]any:
-			keys := make([]string, 0, len(typed))
-			for key := range typed {
-				keys = append(keys, key)
-			}
-			sort.Strings(keys)
-			for _, name := range wanted {
-				for _, key := range keys {
-					if !strings.EqualFold(key, name) {
-						continue
-					}
-					items, ok := typed[key].([]any)
-					if !ok {
-						return nil, false
-					}
-					out := make([]map[string]any, 0, len(items))
-					for _, item := range items {
-						object, ok := item.(map[string]any)
-						if !ok {
-							return nil, false
-						}
-						out = append(out, object)
-					}
-					return out, true
-				}
-			}
-			for _, key := range keys {
-				if found, ok := walk(typed[key]); ok {
-					return found, true
-				}
-			}
-		case []any:
-			for _, child := range typed {
-				if found, ok := walk(child); ok {
-					return found, true
-				}
-			}
-		}
-		return nil, false
-	}
-	return walk(value)
-}
-
-func validateAitableViewFilter(filter []any, fieldTypes map[string]string) error {
-	for index, raw := range filter {
-		condition, ok := raw.(map[string]any)
-		if !ok {
-			return fmt.Errorf("filter[%d] must be an object", index)
-		}
-		if err := validateAitableViewFilterCondition(condition, fieldTypes); err != nil {
-			return fmt.Errorf("filter[%d]: %w", index, err)
-		}
-	}
-	return nil
-}
-
-func validateAitableViewFilterCondition(condition map[string]any, fieldTypes map[string]string) error {
-	operator, _ := condition["operator"].(string)
-	operator = strings.TrimSpace(operator)
-	if operator == "" || !validFilterOperators[operator] {
-		return fmt.Errorf("unsupported operator %q", operator)
-	}
-	operands, ok := condition["operands"].([]any)
-	if !ok {
-		return fmt.Errorf("operator %s requires an operands array", operator)
-	}
-	if operator == "and" || operator == "or" {
-		return fmt.Errorf("logical operator %s is not supported by the persisted view protocol; pass a flat array of leaf conditions (combined as AND)", operator)
-	}
-	wantOperands := 2
-	if operator == "exist" || operator == "un_exist" {
-		wantOperands = 1
-	}
-	if len(operands) != wantOperands {
-		return fmt.Errorf("operator %s requires %d operands", operator, wantOperands)
-	}
-	fieldID, ok := operands[0].(string)
-	fieldID = strings.TrimSpace(fieldID)
-	if !ok || fieldID == "" {
-		return fmt.Errorf("operator %s requires a fieldId as its first operand", operator)
-	}
-	fieldType, exists := fieldTypes[fieldID]
-	if !exists {
-		return fmt.Errorf("filter references unknown fieldId %q", fieldID)
-	}
-	if isAitableDateFieldType(fieldType) && !isAitableDateFilterOperator(operator) {
-		return fmt.Errorf("operator %s is invalid for %s field %s; use date_eq/before/after/not_before/not_after/exist/un_exist", operator, fieldType, fieldID)
-	}
-	if operator == "any_of" || operator == "all_of" || operator == "none_of" {
-		if !strings.EqualFold(fieldType, "multipleSelect") && !strings.EqualFold(fieldType, "multiSelect") {
-			return fmt.Errorf("operator %s requires a multipleSelect field, got %s", operator, fieldType)
-		}
-		if operator == "any_of" {
-			if values, ok := operands[1].([]any); ok {
-				if err := validateAitableMultiSelectOptionNames(values); err != nil {
-					return err
-				}
-				return fmt.Errorf("multipleSelect any_of with multiple values is not supported by the persisted view protocol; use one scalar option or separate views")
-			}
-		}
-		if err := validateAitableMultiSelectFilterValue(operands[1]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func validateAitableMultiSelectOptionNames(values []any) error {
-	if len(values) == 0 {
-		return fmt.Errorf("multipleSelect any_of array must not be empty")
-	}
-	for index, value := range values {
-		text, ok := value.(string)
-		text = strings.TrimSpace(text)
-		if !ok || text == "" {
-			return fmt.Errorf("multipleSelect any_of value %d must be a non-empty option-name string", index)
-		}
-	}
-	return nil
-}
-
-func isAitableDateFieldType(fieldType string) bool {
-	return strings.EqualFold(fieldType, "date") ||
-		strings.EqualFold(fieldType, "createdTime") ||
-		strings.EqualFold(fieldType, "lastModifiedTime")
-}
-
-func isAitableDateFilterOperator(operator string) bool {
-	switch operator {
-	case "date_eq", "before", "after", "not_before", "not_after", "exist", "un_exist":
-		return true
-	default:
-		return false
-	}
-}
-
-func validateAitableMultiSelectFilterValue(value any) error {
-	if typed, ok := value.(string); ok && strings.TrimSpace(typed) != "" {
-		return nil
-	}
-	return fmt.Errorf("multipleSelect filter value must be one option-name string; the persisted view protocol does not support a multi-value OR expression")
-}
-
-func compactJSON(value any) string {
-	raw, err := json.Marshal(value)
-	if err != nil {
-		return fmt.Sprintf("%#v", value)
-	}
-	return string(raw)
-}
-
 func newAitableCommand() *cobra.Command {
 	// Product-level Agent routing Decl (migrated from selection/aitable.json
 	// products.aitable). Catalog assembly stamps provenance contract_final.
@@ -4439,7 +4076,7 @@ colorConfigs (JSON 数组) / officialHoliday (bool)。`,
 若传对象会自动 wrap 为数组；其他非法格式拒绝。`,
 		Example: `  dws aitable view update filter --view-id VIEW_ID --json '[{"operator":"and","operands":[{"operator":"eq","operands":["fldX","value"]}]}]'`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runAitableViewUpdateFilter(cmd)
+			return runAitableViewUpdateArray(cmd, "filter")
 		},
 	}
 	DeclareLeafMetadata(viewUpdateFilterCmd, LeafSpec{
@@ -5645,7 +5282,7 @@ valid=false 仍表示 DSL 校验或发布未通过，必须读取 issues 修正
 			}
 			// create_workflow is non-idempotent. Bypass the retry wrapper to
 			// prevent an uncertain first response from creating a duplicate.
-			return executeAitableWorkflowPublish("create_workflow", toolArgs)
+			return callMCPToolOnServer("aitable", "create_workflow", toolArgs)
 		},
 	}
 	DeclareLeafMetadata(workflowCreateCmd, LeafSpec{
@@ -5739,7 +5376,7 @@ valid=false 仍表示 DSL 校验或发布未通过，必须读取 issues 修正
 			if locale, _ := cmd.Flags().GetString("locale"); strings.TrimSpace(locale) != "" {
 				toolArgs["locale"] = locale
 			}
-			return executeAitableWorkflowPublish("update_workflow", toolArgs)
+			return callAitableTool("update_workflow", toolArgs)
 		},
 	}
 	DeclareLeafMetadata(workflowUpdateCmd, LeafSpec{

internal/helpers/aitable_command_edges_test.go

@@ -361,228 +361,3 @@ func TestCrossPlatformCoverageAitableDeleteCancellationEdges(t *testing.T) {
 		_ = runAitableCoverageCommand(t, &aitableCommandCoverageCaller{}, args...)
 	}
 }
-
-func TestCrossPlatformCoverageAitableViewFilterValidationAndReadBack(t *testing.T) {
-	testseam.Swap(t, &aitableViewFilterReadbackSleep, func(time.Duration) {})
-	oldArgs := os.Args
-	t.Cleanup(func() { os.Args = oldArgs })
-	os.Args = []string{"dws", "aitable"}
-	filter := `[{"operator":"eq","operands":["fldA","x"]},{"operator":"any_of","operands":["fldMulti","A"]}]`
-	fields := `{"data":{"fields":[{"fieldId":"fldA","type":"text"},{"fieldId":"fldB","type":"text"},{"fieldId":"fldMulti","type":"multipleSelect"}]}}`
-	readBack := `{"data":{"views":[{"viewId":"view","viewType":"Grid","filter":[{"operator":"eq","operands":["fldA","x"]},{"operator":"any_of","operands":["fldMulti","A"]}]}]}}`
-
-	t.Run("flat leaf filters are written then exactly verified", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{fields, `{"success":true}`, readBack}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json="+filter)
-		if err != nil || len(caller.calls) != 3 || caller.calls[0].tool != "get_fields" || caller.calls[1].tool != "update_view" || caller.calls[2].tool != "get_views" {
-			t.Fatalf("verified view filter = err:%v calls:%#v", err, caller.calls)
-		}
-		config, _ := caller.calls[1].args["config"].(map[string]any)
-		if _, ok := config["filter"].([]any); !ok {
-			t.Fatalf("update_view filter encoding = %#v", caller.calls[1].args)
-		}
-	})
-
-	t.Run("logical groups fail closed before write", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{fields}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", `--json=[{"operator":"or","operands":[{"operator":"eq","operands":["fldA","x"]},{"operator":"eq","operands":["fldB","y"]}]}]`)
-		if err == nil || !strings.Contains(err.Error(), "persisted view protocol") || len(caller.calls) != 1 || caller.calls[0].tool != "get_fields" {
-			t.Fatalf("logical filter group fail-closed = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("unknown field is rejected before write", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{fields}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", `--json=[{"operator":"eq","operands":["missing","x"]}]`)
-		if err == nil || !strings.Contains(err.Error(), "unknown fieldId") || len(caller.calls) != 1 {
-			t.Fatalf("unknown filter field = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("eventual persisted and wrapper is retried then verified", func(t *testing.T) {
-		input := `[{"operator":"any_of","operands":["fldMulti","A"]}]`
-		stale := `{"data":{"views":[{"viewId":"view","viewType":"Grid","filter":{"operator":"and","operands":[]}}]}}`
-		terminal := `{"data":{"views":[{"viewId":"view","viewType":"Grid","filter":{"operator":"and","operands":[{"operator":"any_of","operands":["fldMulti","A"]}]}}]}}`
-		caller := &aitableTestCaller{responses: []string{fields, `{"success":true}`, stale, terminal}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json="+input)
-		if err != nil || len(caller.calls) != 4 || caller.calls[2].tool != "get_views" || caller.calls[3].tool != "get_views" {
-			t.Fatalf("eventual wrapped filter = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("multi-select operator rejects text field", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{fields}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", `--json=[{"operator":"any_of","operands":["fldA",["A"]]}]`)
-		if err == nil || !strings.Contains(err.Error(), "requires a multipleSelect field") || len(caller.calls) != 1 {
-			t.Fatalf("wrong filter field type = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("multi-select array fails closed before write", func(t *testing.T) {
-		input := `[{"operator":"any_of","operands":["fldMulti",["A","B"]]}]`
-		caller := &aitableTestCaller{responses: []string{fields}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json="+input)
-		if err == nil || !strings.Contains(err.Error(), "persisted view protocol") || len(caller.calls) != 1 || caller.calls[0].tool != "get_fields" {
-			t.Fatalf("multi-select array fail-closed = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("multi-select invalid array value fails before write", func(t *testing.T) {
-		input := `[{"operator":"any_of","operands":["fldMulti",["A",""]]}]`
-		caller := &aitableTestCaller{responses: []string{fields}}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json="+input)
-		if err == nil || !strings.Contains(err.Error(), "non-empty option-name") || len(caller.calls) != 1 {
-			t.Fatalf("invalid multi-select array = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("date and system-time fields require date operators", func(t *testing.T) {
-		fieldTypes := map[string]string{"date": "date", "created": "createdTime", "modified": "lastModifiedTime"}
-		for fieldID := range fieldTypes {
-			valid := []any{map[string]any{"operator": "date_eq", "operands": []any{fieldID, "2026-08-18"}}}
-			if err := validateAitableViewFilter(valid, fieldTypes); err != nil {
-				t.Fatalf("date_eq for %s: %v", fieldID, err)
-			}
-			invalid := []any{map[string]any{"operator": "eq", "operands": []any{fieldID, "2026-08-18"}}}
-			if err := validateAitableViewFilter(invalid, fieldTypes); err == nil || !strings.Contains(err.Error(), "invalid for") {
-				t.Fatalf("eq for %s = %v, want date-operator error", fieldID, err)
-			}
-		}
-	})
-
-	t.Run("dry-run validates but performs no write or read-back", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{fields}, dryRun: true}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json="+filter, "--dry-run")
-		if err != nil || len(caller.calls) != 1 || caller.calls[0].tool != "get_fields" {
-			t.Fatalf("view filter dry-run = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("read-back mismatch is not success", func(t *testing.T) {
-		responses := []string{fields, `{"success":true}`}
-		for range aitableViewFilterReadbackAttempts {
-			responses = append(responses, `{"data":{"views":[{"viewId":"view","viewType":"Grid","filter":[]}]}}`)
-		}
-		caller := &aitableTestCaller{responses: responses}
-		err := runAitableCoverageCommand(t, caller, "view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json="+filter)
-		if err == nil || !strings.Contains(err.Error(), "read-back mismatch") || len(caller.calls) != 2+aitableViewFilterReadbackAttempts {
-			t.Fatalf("mismatched filter readback = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-}
-
-func TestCrossPlatformCoverageAitableViewFilterFailureAndShapeEdges(t *testing.T) {
-	testseam.Swap(t, &aitableViewFilterReadbackSleep, func(time.Duration) {})
-	testseam.Protect(t, &os.Args)
-	os.Args = []string{"dws", "aitable"}
-	fields := `{"data":{"fields":[{"fieldId":"fldA","type":"text"}]}}`
-	filter := `[{"operator":"eq","operands":["fldA","x"]}]`
-	args := []string{"view", "update", "filter", "--base-id=b", "--table-id=t", "--view-id=view", "--json=" + filter}
-
-	t.Run("update transport error", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{fields}, errors: []error{nil, context.Canceled}}
-		if err := runAitableCoverageCommand(t, caller, args...); err == nil || !strings.Contains(err.Error(), context.Canceled.Error()) || len(caller.calls) != 2 {
-			t.Fatalf("update error = %v, calls=%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("readback transport errors exhaust", func(t *testing.T) {
-		errs := []error{nil, nil}
-		for range aitableViewFilterReadbackAttempts {
-			errs = append(errs, context.DeadlineExceeded)
-		}
-		caller := &aitableTestCaller{responses: []string{fields, `{"success":true}`}, errors: errs}
-		if err := runAitableCoverageCommand(t, caller, args...); err == nil || len(caller.calls) != 2+aitableViewFilterReadbackAttempts {
-			t.Fatalf("readback errors = %v, calls=%d", err, len(caller.calls))
-		}
-	})
-
-	t.Run("readback wrong identity exhausts", func(t *testing.T) {
-		responses := []string{fields, `{"success":true}`}
-		for range aitableViewFilterReadbackAttempts {
-			responses = append(responses, `{"data":{"views":[{"viewId":"other","filter":[]}]}}`)
-		}
-		caller := &aitableTestCaller{responses: responses}
-		if err := runAitableCoverageCommand(t, caller, args...); err == nil || !strings.Contains(err.Error(), "returned viewId") {
-			t.Fatalf("wrong readback identity = %v", err)
-		}
-	})
-
-	loadCases := []struct {
-		name      string
-		response  string
-		callErr   error
-		wantError string
-	}{
-		{name: "transport", callErr: context.Canceled, wantError: "context canceled"},
-		{name: "invalid json", response: `{`, wantError: "not valid JSON"},
-		{name: "missing collection", response: `{}`, wantError: "missing the fields collection"},
-		{name: "missing identity", response: `{"fields":[{"type":"text"}]}`, wantError: "missing fieldId or type"},
-	}
-	for _, tc := range loadCases {
-		t.Run("load fields "+tc.name, func(t *testing.T) {
-			caller := &aitableTestCaller{responses: []string{tc.response}, errors: []error{tc.callErr}}
-			installAitableDeps(t, caller)
-			if _, err := loadAitableFieldTypes(context.Background(), "b", "t"); err == nil || !strings.Contains(err.Error(), tc.wantError) {
-				t.Fatalf("load fields error = %v, want %q", err, tc.wantError)
-			}
-		})
-	}
-	t.Run("load legacy field keys", func(t *testing.T) {
-		caller := &aitableTestCaller{responses: []string{`{"fieldList":[{"id":"legacy","fieldType":"text"}]}`}}
-		installAitableDeps(t, caller)
-		got, err := loadAitableFieldTypes(context.Background(), "b", "t")
-		if err != nil || got["legacy"] != "text" {
-			t.Fatalf("legacy field keys = %#v, %v", got, err)
-		}
-	})
-
-	if _, ok := findAitableObjectList(map[string]any{"fields": "bad"}, "fields"); ok {
-		t.Fatal("scalar fields collection must fail")
-	}
-	if _, ok := findAitableObjectList(map[string]any{"fields": []any{"bad"}}, "fields"); ok {
-		t.Fatal("scalar field item must fail")
-	}
-	if got, ok := findAitableObjectList([]any{"skip", map[string]any{"nested": map[string]any{"fields": []any{map[string]any{"fieldId": "f"}}}}}, "fields"); !ok || len(got) != 1 {
-		t.Fatalf("recursive fields = %#v, %v", got, ok)
-	}
-	if got, ok := findAitableObjectList(map[string]any{
-		"fieldList": []any{map[string]any{"fieldId": "legacy"}},
-		"fields":    []any{map[string]any{"fieldId": "canonical"}},
-	}, "fields", "fieldList"); !ok || len(got) != 1 || got[0]["fieldId"] != "canonical" {
-		t.Fatalf("declared collection priority = %#v, %v", got, ok)
-	}
-
-	invalidFilters := []struct {
-		filter []any
-		want   string
-	}{
-		{filter: []any{"bad"}, want: "must be an object"},
-		{filter: []any{map[string]any{"operator": "bogus", "operands": []any{}}}, want: "unsupported operator"},
-		{filter: []any{map[string]any{"operator": "eq", "operands": "bad"}}, want: "requires an operands array"},
-		{filter: []any{map[string]any{"operator": "and", "operands": []any{}}}, want: "logical operator"},
-		{filter: []any{map[string]any{"operator": "exist", "operands": []any{"f", "extra"}}}, want: "requires 1 operands"},
-		{filter: []any{map[string]any{"operator": "eq", "operands": []any{1, "x"}}}, want: "requires a fieldId"},
-		{filter: []any{map[string]any{"operator": "any_of", "operands": []any{"multi", 1}}}, want: "one option-name string"},
-	}
-	for _, tc := range invalidFilters {
-		if err := validateAitableViewFilter(tc.filter, map[string]string{"f": "text", "multi": "multipleSelect"}); err == nil || !strings.Contains(err.Error(), tc.want) {
-			t.Errorf("validate filter %#v = %v, want %q", tc.filter, err, tc.want)
-		}
-	}
-	if err := validateAitableMultiSelectOptionNames(nil); err == nil {
-		t.Fatal("empty any_of array must fail")
-	}
-	if err := validateAitableMultiSelectOptionNames([]any{"ok", 1}); err == nil {
-		t.Fatal("non-string any_of option must fail")
-	}
-	if err := validateAitableMultiSelectOptionNames([]any{"first", " second "}); err != nil {
-		t.Fatalf("valid any_of option names = %v", err)
-	}
-	if got := compactJSON(make(chan int)); !strings.HasPrefix(got, "(chan int)") {
-		t.Fatalf("compactJSON fallback = %q", got)
-	}
-	if persistedViewFilterMatches("bad", nil) || persistedViewFilterMatches(map[string]any{"operator": "or"}, nil) {
-		t.Fatal("invalid persisted wrapper must not match")
-	}
-}

internal/helpers/aitable_core_test.go

@@ -24,7 +24,6 @@ type aitableTestCaller struct {
 	responses []string
 	errors    []error
 	calls     []aitableTestCall
-	dryRun    bool
 }
 
 func (c *aitableTestCaller) CallTool(_ context.Context, server, tool string, args map[string]any) (*edition.ToolResult, error) {
@@ -39,11 +38,8 @@ func (c *aitableTestCaller) CallTool(_ context.Context, server, tool string, arg
 	}
 	return textToolResult(response), nil
 }
-func (c *aitableTestCaller) CallReadTool(ctx context.Context, server, tool string, args map[string]any) (*edition.ToolResult, error) {
-	return c.CallTool(ctx, server, tool, args)
-}
 func (*aitableTestCaller) Format() string { return "json" }
-func (c *aitableTestCaller) DryRun() bool { return c.dryRun }
+func (*aitableTestCaller) DryRun() bool   { return false }
 func (*aitableTestCaller) Fields() string { return "" }
 func (*aitableTestCaller) JQ() string     { return "" }
 

internal/helpers/aitable_workflow_write_test.go

@@ -23,42 +23,27 @@ type aitableWorkflowCall struct {
 }
 
 type aitableWorkflowCaller struct {
-	calls    []aitableWorkflowCall
-	response string
-	err      error
-	dryRun   bool
+	calls []aitableWorkflowCall
 }
 
 func (c *aitableWorkflowCaller) CallTool(_ context.Context, productID, toolName string, args map[string]any) (*edition.ToolResult, error) {
 	c.calls = append(c.calls, aitableWorkflowCall{productID: productID, toolName: toolName, args: args})
-	if c.err != nil {
-		return nil, c.err
-	}
-	response := c.response
-	if response == "" {
-		response = `{"status":"success","data":{"valid":true,"flowId":"flow-test","issues":[]}}`
-	}
 	return &edition.ToolResult{Content: []edition.ContentBlock{{
 		Type: "text",
-		Text: response,
+		Text: `{"status":"success","data":{"valid":true,"flowId":"flow-test","issues":[]}}`,
 	}}}, nil
 }
 
 func (*aitableWorkflowCaller) Format() string { return "json" }
-func (c *aitableWorkflowCaller) DryRun() bool { return c.dryRun }
+func (*aitableWorkflowCaller) DryRun() bool   { return false }
 func (*aitableWorkflowCaller) Fields() string { return "" }
 func (*aitableWorkflowCaller) JQ() string     { return "" }
 
 func runAitableWorkflowCommand(t *testing.T, stdin io.Reader, args ...string) (*aitableWorkflowCaller, error) {
-	t.Helper()
-	caller := &aitableWorkflowCaller{}
-	return caller, runAitableWorkflowCommandWithCaller(t, caller, stdin, args...)
-}
-
-func runAitableWorkflowCommandWithCaller(t *testing.T, caller *aitableWorkflowCaller, stdin io.Reader, args ...string) error {
 	t.Helper()
 	testseam.Protect(t, &os.Args)
 
+	caller := &aitableWorkflowCaller{}
 	InitDepsForTest(t, caller)
 	deps.Out.w = io.Discard
 	os.Args = append([]string{"dws", "aitable", "workflow"}, args...)
@@ -66,7 +51,6 @@ func runAitableWorkflowCommandWithCaller(t *testing.T, caller *aitableWorkflowCa
 	cmd := newAitableCommand()
 	cmd.PersistentFlags().String("format", "json", "output format")
 	cmd.PersistentFlags().Bool("yes", false, "skip confirmation")
-	cmd.PersistentFlags().Bool("dry-run", false, "preview only")
 	cmd.SilenceErrors = true
 	cmd.SilenceUsage = true
 	cmd.SetArgs(append([]string{"workflow"}, args...))
@@ -74,10 +58,10 @@ func runAitableWorkflowCommandWithCaller(t *testing.T, caller *aitableWorkflowCa
 		stdin = strings.NewReader("")
 	}
 	cmd.SetIn(stdin)
-	return cmd.Execute()
+	return caller, cmd.Execute()
 }
 
-func TestCrossPlatformCoverageAitableWorkflowCreateMapsDSLWithoutRetry(t *testing.T) {
+func TestAitableWorkflowCreateMapsDSLWithoutRetry(t *testing.T) {
 	wantDSL := map[string]any{
 		"version": "workflow-dsl/v1",
 		"name":    "create test",
@@ -108,65 +92,6 @@ func TestCrossPlatformCoverageAitableWorkflowCreateMapsDSLWithoutRetry(t *testin
 	}
 }
 
-func TestCrossPlatformCoverageAitableWorkflowPublishRejectsFalseSuccess(t *testing.T) {
-	tests := []struct {
-		name     string
-		response string
-		want     string
-	}{
-		{name: "valid false", response: `{"status":"success","data":{"valid":false,"issues":[{"message":"bad dsl"}]}}`, want: "valid=false"},
-		{name: "missing valid", response: `{"status":"success","data":{"flowId":"flow-test"}}`, want: "missing valid"},
-		{name: "missing flow id", response: `{"status":"success","data":{"valid":true}}`, want: "missing a non-empty flowId"},
-		{name: "wrong valid type", response: `{"status":"success","data":{"valid":"true","flowId":"flow-test"}}`, want: "valid must be boolean"},
-		{name: "malformed response", response: `{`, want: "not a JSON object"},
-		{name: "null response", response: `null`, want: "not a JSON object"},
-		{name: "conflicting valid", response: `{"valid":true,"data":{"valid":false,"flowId":"flow-test"}}`, want: "conflicting valid values"},
-		{name: "invalid flow id", response: `{"valid":true,"flowId":1}`, want: "flowId must be a non-empty string"},
-		{name: "conflicting workflow ids", response: `{"valid":true,"flowId":"one","data":{"workflowId":"two"}}`, want: "conflicting workflow IDs"},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			caller := &aitableWorkflowCaller{response: tc.response}
-			err := runAitableWorkflowCommandWithCaller(t, caller, nil,
-				"create", "--base-id", "base", "--dsl", `{"version":"workflow-dsl/v1","name":"test"}`)
-			if err == nil || !strings.Contains(err.Error(), tc.want) || len(caller.calls) != 1 {
-				t.Fatalf("workflow false success = err:%v calls:%#v", err, caller.calls)
-			}
-		})
-	}
-
-	t.Run("update uses the same strict contract", func(t *testing.T) {
-		caller := &aitableWorkflowCaller{response: `{"status":"success","data":{"valid":false}}`}
-		err := runAitableWorkflowCommandWithCaller(t, caller, nil,
-			"update", "--base-id", "base", "--workflow-id", "flow", "--dsl", `{"version":"workflow-dsl/v1","name":"test"}`)
-		if err == nil || !strings.Contains(err.Error(), "valid=false") || len(caller.calls) != 1 || caller.calls[0].toolName != "update_workflow" {
-			t.Fatalf("workflow update false success = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("dry-run does not call publish tool", func(t *testing.T) {
-		caller := &aitableWorkflowCaller{dryRun: true}
-		err := runAitableWorkflowCommandWithCaller(t, caller, nil,
-			"create", "--base-id", "base", "--dsl", `{"version":"workflow-dsl/v1","name":"test"}`, "--dry-run")
-		if err != nil || len(caller.calls) != 0 {
-			t.Fatalf("workflow create dry-run = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	t.Run("transport error", func(t *testing.T) {
-		caller := &aitableWorkflowCaller{err: context.Canceled}
-		err := runAitableWorkflowCommandWithCaller(t, caller, nil,
-			"create", "--base-id", "base", "--dsl", `{"version":"workflow-dsl/v1","name":"test"}`)
-		if err == nil || !strings.Contains(err.Error(), context.Canceled.Error()) || len(caller.calls) != 1 {
-			t.Fatalf("workflow transport error = err:%v calls:%#v", err, caller.calls)
-		}
-	})
-
-	if _, _, _, err := strictAitableWorkflowPublishResult(nil); err == nil || !strings.Contains(err.Error(), "empty response") {
-		t.Fatalf("nil workflow envelope = %v", err)
-	}
-}
-
 func TestAitableWorkflowEditExampleMapsEmptyArguments(t *testing.T) {
 	caller, err := runAitableWorkflowCommand(t, nil, "edit-example")
 	if err != nil {

internal/helpers/chat.go

@@ -27,38 +27,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func resolveChatGroupRoleSetUserRoleIDs(cmd *cobra.Command) ([]string, error) {
-	roleIDChanged := cmd.Flags().Changed("role-id")
-	roleIDsChanged := cmd.Flags().Changed("role-ids")
-	switch {
-	case roleIDChanged && roleIDsChanged:
-		// PreRunE rejects callers that explicitly pass both flags. Reaching this
-		// branch means the hidden legacy flag was promoted to satisfy Cobra's
-		// required marker on the public canonical flag.
-		return parseCSVValues(mustGetFlag(cmd, "role-ids")), nil
-	case roleIDChanged:
-		roleIDs := parseCSVValues(mustGetFlag(cmd, "role-id"))
-		if len(roleIDs) == 0 {
-			return nil, apperrors.NewValidation("--role-id 不能为空")
-		}
-		if len(roleIDs) > 1 {
-			return nil, apperrors.NewValidation("--role-id 只允许指定一个群身份")
-		}
-		return roleIDs, nil
-	case roleIDsChanged:
-		return parseCSVValues(mustGetFlag(cmd, "role-ids")), nil
-	default:
-		return nil, apperrors.NewValidation("缺少必填参数 --role-id")
-	}
-}
-
-func prepareChatGroupRoleSetUserRoleID(cmd *cobra.Command) error {
-	if cmd.Flags().Changed("role-id") && cmd.Flags().Changed("role-ids") {
-		return apperrors.NewValidation("--role-id 与 --role-ids 不能同时指定")
-	}
-	return promoteLegacyChatString(cmd, "role-id", "role-ids")
-}
-
 // promoteLegacyChatString copies an explicitly supplied legacy flag into the
 // new canonical flag. Cobra validates MarkFlagRequired after PreRunE, and the
 // overwrite also preserves the migration rule that a legacy value wins when
@@ -7785,23 +7753,17 @@ flow-status 取值：1=处理中(PROCESSING)，2=输入中(INPUTTING)，3=完成
 	chatGroupRoleSetUserCmd := &cobra.Command{
 		Use:   "set-user",
 		Short: "设置用户的群身份（覆盖该用户的全部群身份）",
-		Example: `  dws chat group-role set-user --conversation-id <openConversationId> --user <userId> --role-id <openRoleId>
+		Example: `  dws chat group-role set-user --conversation-id <openConversationId> --user <userId> --role-ids roleId1,roleId2
   # 查询人员: dws contact user search --keyword "姓名" --format json
   # 查询 role-id: dws chat group-role list --conversation-id <openConversationId>`,
-		PreRunE: func(cmd *cobra.Command, args []string) error {
-			return prepareChatGroupRoleSetUserRoleID(cmd)
-		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if err := validateRequiredFlags(cmd, "conversation-id"); err != nil {
+			if err := validateRequiredFlags(cmd, "conversation-id", "role-ids"); err != nil {
 				return err
 			}
 			if err := validateRequiredFlagWithAliases(cmd, "user", "userId"); err != nil {
 				return err
 			}
-			roleIDs, err := resolveChatGroupRoleSetUserRoleIDs(cmd)
-			if err != nil {
-				return err
-			}
+			roleIDs := parseCSVValues(mustGetFlag(cmd, "role-ids"))
 			user := flagOrFallback(cmd, "user", "userId")
 			toolArgs := map[string]any{
 				"openConversationId": flagOrFallback(cmd, "conversation-id", "group", "id", "chat"),
@@ -7836,13 +7798,13 @@ flow-status 取值：1=处理中(PROCESSING)，2=输入中(INPUTTING)，3=完成
 			},
 			Selection: contract.SelectionSpec{
 				AgentSummary: "为指定群成员设置自定义角色",
-				UseWhen:      []string{"需要把一个已有角色分配给成员时"},
+				UseWhen:      []string{"需要把一个或多个已有角色分配给成员时"},
 				AvoidWhen:    []string{"创建新角色定义时使用 chat group-role add"},
-				Examples:     []string{"dws chat group-role set-user --conversation-id <openConversationId> --user <userId> --role-id <openRoleId>"},
+				Examples:     []string{"dws chat group-role set-user --conversation-id <openConversationId> --user <userId> --role-ids roleId1,roleId2"},
 			},
 			Parameters: []contract.ParamDecl{
 				{Name: "conversation-id", Property: "openConversationId"},
-				{Name: "role-id", Property: "openRoleIds"},
+				{Name: "role-ids", Property: "openRoleIds"},
 				{Name: "user", Property: "openDingTalkId"},
 			},
 		},
@@ -7852,11 +7814,8 @@ flow-status 取值：1=处理中(PROCESSING)，2=输入中(INPUTTING)，3=完成
 	chatGroupRoleSetUserCmd.Flags().String("user", "", "用户 userId（必填）")
 	chatGroupRoleSetUserCmd.Flags().String("userId", "", "--user 的别名")
 	_ = chatGroupRoleSetUserCmd.Flags().MarkHidden("userId")
-	chatGroupRoleSetUserCmd.Flags().String("role-id", "", "群身份 openRoleId，由 group-role list 返回 (必填)")
-	chatGroupRoleSetUserCmd.Flags().String("role-ids", "", "已隐藏的兼容参数：群身份 openRoleId 列表，逗号分隔")
-	_ = chatGroupRoleSetUserCmd.Flags().MarkHidden("role-ids")
-	corecmd.AnnotateFlagAlias(chatGroupRoleSetUserCmd, "role-ids", "role-id")
-	_ = chatGroupRoleSetUserCmd.MarkFlagRequired("role-id")
+	chatGroupRoleSetUserCmd.Flags().String("role-ids", "", "群身份 openRoleId 列表，逗号分隔 (必填)，传空字符串则清除该用户所有群身份")
+	_ = chatGroupRoleSetUserCmd.MarkFlagRequired("role-ids")
 
 	chatGroupRoleRemoveUserCmd := &cobra.Command{
 		Use:     "remove-user",

internal/helpers/chat_command_edges_test.go

@@ -243,155 +243,6 @@ func TestCrossPlatformCoverageChatGroupUpdateIconRejectsBlankMediaID(t *testing.
 	}
 }
 
-func TestChatGroupRoleSetUserAcceptsSingleRoleIDAndLegacyRoleIDs(t *testing.T) {
-	previousDeps, previousArgs := deps, os.Args
-	os.Args = []string{"dws", "chat"}
-	t.Cleanup(func() { deps, os.Args = previousDeps, previousArgs })
-
-	tests := []struct {
-		name string
-		args []string
-		want []string
-	}{
-		{
-			name: "public single role id",
-			args: []string{"group-role", "set-user", "--group=cid", "--user=D1", "--role-id=r1"},
-			want: []string{"r1"},
-		},
-		{
-			name: "hidden legacy role ids",
-			args: []string{"group-role", "set-user", "--group=cid", "--user=D1", "--role-ids=r1,r2"},
-			want: []string{"r1", "r2"},
-		},
-		{
-			name: "hidden legacy empty role ids",
-			args: []string{"group-role", "set-user", "--group=cid", "--user=D1", "--role-ids="},
-			want: nil,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			caller := &scriptedToolCaller{}
-			if err := runChatCoverageCommand(t, caller, tc.args...); err != nil {
-				t.Fatal(err)
-			}
-			if caller.calls != 1 {
-				t.Fatalf("tool calls = %d, want 1", caller.calls)
-			}
-			if got := caller.args["openRoleIds"]; !reflect.DeepEqual(got, tc.want) {
-				t.Fatalf("openRoleIds = %#v, want %#v", got, tc.want)
-			}
-		})
-	}
-}
-
-func TestChatGroupRoleSetUserRejectsConflictingRoleFlags(t *testing.T) {
-	previousDeps, previousArgs := deps, os.Args
-	os.Args = []string{"dws", "chat"}
-	t.Cleanup(func() { deps, os.Args = previousDeps, previousArgs })
-
-	caller := &scriptedToolCaller{}
-	err := runChatCoverageCommand(t, caller,
-		"group-role", "set-user", "--group=cid", "--user=D1", "--role-id=r1", "--role-ids=r2")
-	if err == nil {
-		t.Fatal("set-user accepted --role-id with --role-ids, want validation error")
-	}
-	if !strings.Contains(err.Error(), "--role-id 与 --role-ids 不能同时指定") {
-		t.Fatalf("error = %v", err)
-	}
-	if caller.calls != 0 {
-		t.Fatalf("tool calls = %d, want 0", caller.calls)
-	}
-}
-
-func TestChatGroupRoleSetUserRejectsMultiplePublicRoleIDs(t *testing.T) {
-	previousDeps, previousArgs := deps, os.Args
-	os.Args = []string{"dws", "chat"}
-	t.Cleanup(func() { deps, os.Args = previousDeps, previousArgs })
-
-	caller := &scriptedToolCaller{}
-	err := runChatCoverageCommand(t, caller,
-		"group-role", "set-user", "--group=cid", "--user=D1", "--role-id=r1,r2")
-	if err == nil {
-		t.Fatal("set-user accepted multiple --role-id values, want validation error")
-	}
-	if !strings.Contains(err.Error(), "--role-id 只允许指定一个群身份") {
-		t.Fatalf("error = %v", err)
-	}
-	if caller.calls != 0 {
-		t.Fatalf("tool calls = %d, want 0", caller.calls)
-	}
-}
-
-func TestChatGroupRoleSetUserRejectsMissingOrEmptyPublicRoleID(t *testing.T) {
-	previousDeps, previousArgs := deps, os.Args
-	os.Args = []string{"dws", "chat"}
-	t.Cleanup(func() { deps, os.Args = previousDeps, previousArgs })
-
-	tests := []struct {
-		name string
-		args []string
-		want string
-	}{
-		{
-			name: "missing public role id",
-			args: []string{"group-role", "set-user", "--group=cid", "--user=D1"},
-			want: "role-id",
-		},
-		{
-			name: "empty public role id",
-			args: []string{"group-role", "set-user", "--group=cid", "--user=D1", "--role-id="},
-			want: "--role-id 不能为空",
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			caller := &scriptedToolCaller{}
-			err := runChatCoverageCommand(t, caller, tc.args...)
-			if err == nil {
-				t.Fatal("set-user accepted a missing or empty --role-id, want validation error")
-			}
-			if !strings.Contains(err.Error(), tc.want) {
-				t.Fatalf("error = %v, want substring %q", err, tc.want)
-			}
-			if caller.calls != 0 {
-				t.Fatalf("tool calls = %d, want 0", caller.calls)
-			}
-		})
-	}
-}
-
-func TestChatGroupRoleSetUserRoleIDResolverDefensiveBranches(t *testing.T) {
-	newCommand := func(t *testing.T) *cobra.Command {
-		t.Helper()
-		cmd := &cobra.Command{}
-		cmd.Flags().String("role-id", "", "")
-		cmd.Flags().String("role-ids", "", "")
-		return cmd
-	}
-
-	t.Run("legacy flag without pre-run promotion", func(t *testing.T) {
-		cmd := newCommand(t)
-		if err := cmd.Flags().Set("role-ids", "r1,r2"); err != nil {
-			t.Fatal(err)
-		}
-		got, err := resolveChatGroupRoleSetUserRoleIDs(cmd)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if want := []string{"r1", "r2"}; !reflect.DeepEqual(got, want) {
-			t.Fatalf("role IDs = %#v, want %#v", got, want)
-		}
-	})
-
-	t.Run("no role flag", func(t *testing.T) {
-		_, err := resolveChatGroupRoleSetUserRoleIDs(newCommand(t))
-		if err == nil || !strings.Contains(err.Error(), "缺少必填参数 --role-id") {
-			t.Fatalf("error = %v, want missing --role-id validation", err)
-		}
-	})
-}
-
 func TestCrossPlatformCoverageChatCommandValidationAndSuccessEdges(t *testing.T) {
 	previousDeps, previousArgs := deps, os.Args
 	os.Args = []string{"dws", "chat"}
@@ -442,7 +293,7 @@ func TestCrossPlatformCoverageChatCommandValidationAndSuccessEdges(t *testing.T)
 		{"group", "audit-join-validation", "--conversation-id=cid", "--record-id=1", "--applicant=D1", "--inviter=D2", "--status=AuditApprove", "--description=ok"},
 		{"mark-read", "--conversation-id=cid", "--message-id=mid"},
 		{"text", "translate", "--query=hello", "--to=zh_CN"},
-		{"group-role", "set-user", "--group=cid", "--user=D1", "--role-id=r1"},
+		{"group-role", "set-user", "--group=cid", "--user=D1", "--role-ids=r1"},
 		{"group-role", "remove-user", "--group=cid", "--user=D1", "--role-ids=r1"},
 		{"group-role", "query-user", "--group=cid", "--user=D1"},
 		{"group", "set-admin", "--group=cid", "--users=u1,D1"},
@@ -672,7 +523,7 @@ func TestCrossPlatformCoverageChatIMIDMigrationRequiredFlagErrors(t *testing.T)
 		{name: "role add missing conversation", path: []string{"group-role", "add"}, flag: map[string]string{"name": "role"}, want: "conversation-id"},
 		{name: "role update missing conversation", path: []string{"group-role", "update"}, flag: map[string]string{"role-id": "r1", "name": "role"}, want: "conversation-id"},
 		{name: "role remove missing conversation", path: []string{"group-role", "remove"}, flag: map[string]string{"role-id": "r1"}, want: "conversation-id"},
-		{name: "role set user missing conversation", path: []string{"group-role", "set-user"}, flag: map[string]string{"user": "D1", "role-id": "r1"}, want: "conversation-id"},
+		{name: "role set user missing conversation", path: []string{"group-role", "set-user"}, flag: map[string]string{"user": "D1", "role-ids": "r1"}, want: "conversation-id"},
 		{name: "role remove user missing conversation", path: []string{"group-role", "remove-user"}, flag: map[string]string{"user": "D1", "role-ids": "r1"}, want: "conversation-id"},
 		{name: "role query user missing conversation", path: []string{"group-role", "query-user"}, flag: map[string]string{"user": "D1"}, want: "conversation-id"},
 		{name: "bots missing legacy group", path: []string{"group", "bots"}, want: "group"},

internal/helpers/drive_folder_contract.go

@@ -108,7 +108,7 @@ func driveFolderPushResultSpec() *contract.ResultSpec {
     "preview_kind":{"type":"string","description":"预览类型","enum":["plan"]},
     "operation":{"type":"string","description":"预览的命令"},
     "if_exists":{"type":"string","description":"远端同名文件处理策略"},
-    "plan":{"type":"object","description":"预览的推送计划","properties":{"summary":{"type":"object","description":"计划动作计数；兼容执行计数 uploaded/skipped 在预览中保持为零","properties":{"uploaded":{"type":"integer","description":"兼容字段；预览未执行上传，固定为零"},"skipped":{"type":"integer","description":"兼容字段；预览未执行跳过，固定为零"},"failed":{"type":"integer","description":"预检失败的条目数"},"aborted":{"type":"boolean","description":"计划是否会中止"},"planned_uploads":{"type":"integer","description":"计划上传或覆盖的文件数"},"planned_skips":{"type":"integer","description":"计划按策略跳过的文件数"},"planned_folders":{"type":"integer","description":"计划创建的远端目录数"}},"required":["uploaded","skipped","failed","aborted"],"additionalProperties":false},"items":{"type":"array","description":"计划中的逐条目动作","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件或目录路径"},"action":{"type":"string","description":"未执行的 planned_* 计划动作或已确认的预检失败"},"size_bytes":{"type":"integer","description":"文件字节数"},"error":{"type":"string","description":"预检失败原因"}},"required":["rel_path","action"],"additionalProperties":false}}},"required":["summary","items"],"additionalProperties":false}
+    "plan":{"type":"object","description":"预览的推送计划","properties":{"summary":{"type":"object","description":"计划动作计数","properties":{"uploaded":{"type":"integer","description":"计划上传或覆盖的文件数"},"skipped":{"type":"integer","description":"计划跳过的文件数"},"failed":{"type":"integer","description":"预检失败的条目数"},"aborted":{"type":"boolean","description":"计划是否会中止"}},"required":["uploaded","skipped","failed","aborted"],"additionalProperties":false},"items":{"type":"array","description":"计划中的逐条目动作","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件或目录路径"},"action":{"type":"string","description":"计划动作"},"size_bytes":{"type":"integer","description":"文件字节数"},"error":{"type":"string","description":"预检失败原因"}},"required":["rel_path","action"],"additionalProperties":false}}},"required":["summary","items"],"additionalProperties":false}
   },
   "additionalProperties":false
 }`),
@@ -134,7 +134,7 @@ func driveFolderSyncResultSpec() *contract.ResultSpec {
     "executed":{"type":"boolean","description":"是否执行了写操作","const":false},
     "preview_kind":{"type":"string","description":"预览类型","enum":["plan"]},
     "operation":{"type":"string","description":"预览的命令","const":"drive sync"},
-    "plan":{"type":"object","description":"预览的同步计划","properties":{"detection":{"type":"string","description":"计划使用的差异检测模式","enum":["exact","quick"]},"diff":{"type":"object","description":"计划执行前的双端差异","properties":{"new_local":{"type":"array","description":"仅本地存在的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"new_remote":{"type":"array","description":"仅钉盘存在的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"modified":{"type":"array","description":"双端都存在但内容或时间不同的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"unchanged":{"type":"array","description":"双端一致的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"unknown":{"type":"array","description":"exact 模式下因缺少可靠远端哈希而无法判定的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}}},"required":["new_local","new_remote","modified","unchanged","unknown"],"additionalProperties":false},"summary":{"type":"object","description":"计划动作计数；兼容执行计数 pulled/pushed/skipped 在预览中保持为零","properties":{"pulled":{"type":"integer","description":"兼容字段；预览未执行拉取，固定为零"},"pushed":{"type":"integer","description":"兼容字段；预览未执行推送，固定为零"},"skipped":{"type":"integer","description":"兼容字段；预览未执行跳过，固定为零"},"failed":{"type":"integer","description":"预检失败的条目数"},"planned_pulls":{"type":"integer","description":"计划拉取的文件数"},"planned_pushes":{"type":"integer","description":"计划上传或覆盖的文件数"},"planned_skips":{"type":"integer","description":"计划按策略跳过的文件数"},"planned_folders":{"type":"integer","description":"计划创建的远端目录数"}},"required":["pulled","pushed","skipped","failed"],"additionalProperties":false},"items":{"type":"array","description":"计划中的逐条目动作","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件或目录路径"},"action":{"type":"string","description":"未执行的 planned_* 计划动作、待决策动作或预检失败"},"direction":{"type":"string","description":"同步方向"},"error":{"type":"string","description":"失败或跳过原因"}},"required":["rel_path","action"],"additionalProperties":false}}},"required":["detection","diff","summary","items"],"additionalProperties":false}
+    "plan":{"type":"object","description":"预览的同步计划","properties":{"detection":{"type":"string","description":"计划使用的差异检测模式","enum":["exact","quick"]},"diff":{"type":"object","description":"计划执行前的双端差异","properties":{"new_local":{"type":"array","description":"仅本地存在的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"new_remote":{"type":"array","description":"仅钉盘存在的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"modified":{"type":"array","description":"双端都存在但内容或时间不同的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"unchanged":{"type":"array","description":"双端一致的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}},"unknown":{"type":"array","description":"exact 模式下因缺少可靠远端哈希而无法判定的文件","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件路径"}},"required":["rel_path"],"additionalProperties":false}}},"required":["new_local","new_remote","modified","unchanged","unknown"],"additionalProperties":false},"summary":{"type":"object","description":"计划动作计数","properties":{"pulled":{"type":"integer","description":"计划拉取的条目数"},"pushed":{"type":"integer","description":"计划推送的条目数"},"skipped":{"type":"integer","description":"计划跳过的条目数"},"failed":{"type":"integer","description":"预检失败的条目数"}},"required":["pulled","pushed","skipped","failed"],"additionalProperties":false},"items":{"type":"array","description":"计划中的逐条目动作","items":{"type":"object","properties":{"rel_path":{"type":"string","description":"相对文件或目录路径"},"action":{"type":"string","description":"计划动作"},"direction":{"type":"string","description":"同步方向"},"error":{"type":"string","description":"失败或跳过原因"}},"required":["rel_path","action"],"additionalProperties":false}}},"required":["detection","diff","summary","items"],"additionalProperties":false}
   },
   "oneOf":[
     {"required":["detection","diff","summary","items"]},

internal/helpers/drive_folder_contract_test.go

@@ -93,26 +93,10 @@ func TestCrossPlatformCoverageDriveFolderContractsPublishResultAndDryRun(t *test
 			if name == "sync" {
 				assertDriveSyncResultSchema(t, final.Result.DataSchema)
 			}
-			if name == "push" {
-				assertDrivePushResultSchema(t, final.Result.DataSchema)
-			}
 		})
 	}
 }
 
-func assertDrivePushResultSchema(t *testing.T, raw json.RawMessage) {
-	t.Helper()
-	properties := resultSchemaProperties(t, raw)
-	plan := schemaObjectProperty(t, properties, "plan")
-	summary := schemaObjectProperty(t, schemaProperties(t, plan), "summary")
-	summaryProperties := schemaProperties(t, summary)
-	for _, name := range []string{"planned_uploads", "planned_skips", "planned_folders"} {
-		if _, ok := summaryProperties[name]; !ok {
-			t.Fatalf("push plan summary schema is missing %s", name)
-		}
-	}
-}
-
 func resultSchemaProperties(t *testing.T, raw json.RawMessage) map[string]any {
 	t.Helper()
 	var schema map[string]any
@@ -149,13 +133,6 @@ func assertDriveSyncResultSchema(t *testing.T, raw json.RawMessage) {
 	planProperties := schemaProperties(t, plan)
 	planDiff := schemaObjectProperty(t, planProperties, "diff")
 	assertSchemaRequired(t, planDiff, "new_local", "new_remote", "modified", "unchanged", "unknown")
-	planSummary := schemaObjectProperty(t, planProperties, "summary")
-	planSummaryProperties := schemaProperties(t, planSummary)
-	for _, name := range []string{"planned_pulls", "planned_pushes", "planned_skips", "planned_folders"} {
-		if _, ok := planSummaryProperties[name]; !ok {
-			t.Fatalf("sync plan summary schema is missing %s", name)
-		}
-	}
 
 	var schema map[string]any
 	if err := json.Unmarshal(raw, &schema); err != nil {

internal/helpers/drive_push.go

@@ -39,11 +39,6 @@ const (
 	pushActionSkipped       = "skipped"        // 按 --if-exists 跳过
 	pushActionFolderCreated = "folder_created" // 新建远端目录（不计入 uploaded）
 	pushActionFailed        = "failed"
-
-	pushActionPlannedUpload       = "planned_upload"
-	pushActionPlannedOverwrite    = "planned_overwrite"
-	pushActionPlannedSkip         = "planned_skip"
-	pushActionPlannedFolderCreate = "planned_folder_create"
 )
 
 // localPushFile 描述一个待推送的本地常规文件。
@@ -84,13 +79,10 @@ type drivePushItem struct {
 
 // drivePushSummary 是各动作的计数汇总。uploaded 同时统计新建与覆盖。
 type drivePushSummary struct {
-	Uploaded       int  `json:"uploaded"`
-	Skipped        int  `json:"skipped"`
-	Failed         int  `json:"failed"`
-	Aborted        bool `json:"aborted"`
-	PlannedUploads int  `json:"planned_uploads,omitempty"`
-	PlannedSkips   int  `json:"planned_skips,omitempty"`
-	PlannedFolders int  `json:"planned_folders,omitempty"`
+	Uploaded int  `json:"uploaded"`
+	Skipped  int  `json:"skipped"`
+	Failed   int  `json:"failed"`
+	Aborted  bool `json:"aborted"`
 }
 
 type drivePushResult struct {
@@ -388,8 +380,7 @@ func printDrivePushDryRunWithPreflight(ifExists string, remoteFiles map[string]*
 			continue
 		}
 		plannedFolders[dir] = "dry-run-planned-folder"
-		plan.Summary.PlannedFolders++
-		plan.Items = append(plan.Items, drivePushItem{RelPath: dir, Action: pushActionPlannedFolderCreate})
+		plan.Items = append(plan.Items, drivePushItem{RelPath: dir, Action: pushActionFolderCreated})
 	}
 	for _, lf := range localFiles {
 		size := lf.Size
@@ -399,25 +390,25 @@ func printDrivePushDryRunWithPreflight(ifExists string, remoteFiles map[string]*
 			plan.Items = append(plan.Items, drivePushItem{RelPath: lf.RelPath, Action: pushActionFailed, SizeBytes: &size, Error: "父目录未能创建"})
 			continue
 		}
-		action := pushActionPlannedUpload
+		action := pushActionUploaded
 		if rf, exists := remoteFiles[lf.RelPath]; exists {
 			switch ifExists {
 			case ifExistsSkip:
-				action = pushActionPlannedSkip
+				action = pushActionSkipped
 			case ifExistsSmart:
 				if rf.ModifiedTimeValid && rf.ModifiedTime >= lf.ModTimeMillis {
-					action = pushActionPlannedSkip
+					action = pushActionSkipped
 				} else {
-					action = pushActionPlannedOverwrite
+					action = pushActionOverwritten
 				}
 			case ifExistsOverwrite:
-				action = pushActionPlannedOverwrite
+				action = pushActionOverwritten
 			}
 		}
-		if action == pushActionPlannedSkip {
-			plan.Summary.PlannedSkips++
+		if action == pushActionSkipped {
+			plan.Summary.Skipped++
 		} else {
-			plan.Summary.PlannedUploads++
+			plan.Summary.Uploaded++
 		}
 		plan.Items = append(plan.Items, drivePushItem{RelPath: lf.RelPath, Action: action, SizeBytes: &size})
 	}
@@ -820,10 +811,7 @@ func defaultPushPutOpenedFile(ctx context.Context, url string, headers map[strin
 	if _, err := file.Seek(0, io.SeekStart); err != nil {
 		return fmt.Errorf("failed to seek upload file: %w", err)
 	}
-	// net/http owns and closes Request.Body after RoundTrip. The *os.File belongs
-	// to pushUploadFilePinned, which must stat it after PUT before commit_upload;
-	// wrap it in a no-op closer so HTTP completion cannot close that shared handle.
-	req, err := http.NewRequestWithContext(ctx, http.MethodPut, url, io.NopCloser(file))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPut, url, file)
 	if err != nil {
 		return fmt.Errorf("failed to create upload request: %w", err)
 	}

internal/helpers/drive_push_sync_final_coverage_test.go

@@ -421,29 +421,6 @@ func TestCrossPlatformCoverageDrivePushFinalDefaultOpenedPUTAndCommit(t *testing
 	}
 }
 
-func TestCrossPlatformCoverageDrivePushOpenedPUTKeepsCallerOwnedHandle(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
-		_, _ = io.Copy(io.Discard, request.Body)
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer server.Close()
-
-	path := filepath.Join(t.TempDir(), "payload")
-	mustWrite(t, path, "payload")
-	file, err := os.Open(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer file.Close()
-
-	if err := defaultPushPutOpenedFile(context.Background(), server.URL, nil, file, 7); err != nil {
-		t.Fatalf("PUT failed: %v", err)
-	}
-	if _, err := file.Stat(); err != nil {
-		t.Fatalf("HTTP PUT closed its caller-owned file handle: %v", err)
-	}
-}
-
 func TestCrossPlatformCoverageDriveSyncFinalPreflightAndKeepBothErrors(t *testing.T) {
 	t.Run("local target preflight lstat error and directory", func(t *testing.T) {
 		_, root, _ := openDriveFinalCoverageRoot(t)

internal/helpers/drive_sync.go

@@ -65,14 +65,6 @@ const (
 	syncActionRenamedLocal  = "renamed_local"
 	syncActionSkipped       = "skipped"
 	syncActionFailed        = "failed"
-
-	syncActionPlannedDownload     = "planned_download"
-	syncActionPlannedUpload       = "planned_upload"
-	syncActionPlannedOverwrite    = "planned_overwrite"
-	syncActionPlannedFolderCreate = "planned_folder_create"
-	syncActionPlannedRenameLocal  = "planned_rename_local"
-	syncActionPlannedSkip         = "planned_skip"
-	syncActionDecisionRequired    = "decision_required"
 )
 
 // driveSyncItem 是输出 items[] 中每条操作的明细。
@@ -85,14 +77,10 @@ type driveSyncItem struct {
 
 // driveSyncSummary 是各方向的计数汇总。
 type driveSyncSummary struct {
-	Pulled         int `json:"pulled"`
-	Pushed         int `json:"pushed"`
-	Skipped        int `json:"skipped"`
-	Failed         int `json:"failed"`
-	PlannedPulls   int `json:"planned_pulls,omitempty"`
-	PlannedPushes  int `json:"planned_pushes,omitempty"`
-	PlannedSkips   int `json:"planned_skips,omitempty"`
-	PlannedFolders int `json:"planned_folders,omitempty"`
+	Pulled  int `json:"pulled"`
+	Pushed  int `json:"pushed"`
+	Skipped int `json:"skipped"`
+	Failed  int `json:"failed"`
 }
 
 // driveSyncDiff 是本次同步前算出的五类差异（与 status 同源）。
@@ -279,12 +267,6 @@ func runDriveSync(cmd *cobra.Command, _ []string) error {
 
 	// --dry-run：只算差异、不执行任何同步动作。
 	if deps.Caller.DryRun() {
-		if len(preflight) == 0 && res.Summary.Failed == 0 {
-			appendDriveSyncDryRunPlan(&res, driveSyncDryRunPlanInput{
-				LocalDirs: localDirs, LocalByRel: localByRel, RemoteFiles: remoteFiles, RemoteFolders: remoteFolders,
-				NewLocal: newLocal, NewRemote: newRemote, Modified: modified, Unknown: unknown, OnConflict: onConflict,
-			})
-		}
 		return deps.Out.PrintJSON(driveSyncDryRunResult{
 			DryRun: true, Executed: false, PreviewKind: "plan", Operation: "drive sync", Plan: res,
 		})
@@ -412,104 +394,6 @@ func runDriveSync(cmd *cobra.Command, _ []string) error {
 	return nil
 }
 
-type driveSyncDryRunPlanInput struct {
-	LocalDirs     []string
-	LocalByRel    map[string]localPushFile
-	RemoteFiles   map[string]*remoteFile
-	RemoteFolders map[string]string
-	NewLocal      []string
-	NewRemote     []string
-	Modified      []string
-	Unknown       []string
-	OnConflict    string
-}
-
-func appendDriveSyncDryRunPlan(res *driveSyncResult, input driveSyncDryRunPlanInput) {
-	for _, rel := range input.Unknown {
-		res.Summary.PlannedSkips++
-		res.Items = append(res.Items, driveSyncItem{
-			RelPath: rel, Action: syncActionPlannedSkip, Direction: syncDirectionConflict,
-			Error: "远端无可靠 md5，内容无法核对，执行时会跳过（可改用 --quick 按 modified_time 比对）",
-		})
-	}
-
-	plannedFolders := make(map[string]string, len(input.RemoteFolders)+len(input.LocalDirs))
-	for rel, fileID := range input.RemoteFolders {
-		plannedFolders[rel] = fileID
-	}
-	for _, dir := range input.LocalDirs {
-		if _, ok := plannedFolders[dir]; ok {
-			continue
-		}
-		parentRel, _ := splitRel(dir)
-		if plannedFolders[parentRel] == "" {
-			res.Summary.Failed++
-			res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionFailed, Direction: syncDirectionPush, Error: "父目录未能创建"})
-			continue
-		}
-		plannedFolders[dir] = "dry-run-planned-folder"
-		res.Summary.PlannedFolders++
-		res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionPlannedFolderCreate, Direction: syncDirectionPush})
-	}
-
-	for _, rel := range input.NewRemote {
-		res.Summary.PlannedPulls++
-		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedDownload, Direction: syncDirectionPull})
-	}
-	for _, rel := range input.NewLocal {
-		parentRel, _ := splitRel(rel)
-		if plannedFolders[parentRel] == "" {
-			res.Summary.Failed++
-			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionPush, Error: "父目录未能创建"})
-			continue
-		}
-		res.Summary.PlannedPushes++
-		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedUpload, Direction: syncDirectionPush})
-	}
-
-	occupied := make(map[string]bool, len(input.LocalByRel)+len(input.LocalDirs)+len(input.RemoteFiles)+len(input.RemoteFolders))
-	for rel := range input.LocalByRel {
-		occupied[rel] = true
-	}
-	for _, rel := range input.LocalDirs {
-		occupied[rel] = true
-	}
-	for rel := range input.RemoteFiles {
-		occupied[rel] = true
-	}
-	for rel := range input.RemoteFolders {
-		if rel != "" {
-			occupied[rel] = true
-		}
-	}
-	for _, rel := range input.Modified {
-		switch input.OnConflict {
-		case syncConflictRemoteWins:
-			res.Summary.PlannedPulls++
-			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedDownload, Direction: syncDirectionPull})
-		case syncConflictLocalWins:
-			res.Summary.PlannedPushes++
-			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedOverwrite, Direction: syncDirectionConflict})
-		case syncConflictKeepBoth:
-			candidate := driveSyncSuffixedRel(rel, input.RemoteFiles[rel].FileID, occupied)
-			occupied[candidate] = true
-			res.Summary.PlannedPulls++
-			res.Items = append(res.Items,
-				driveSyncItem{RelPath: candidate, Action: syncActionPlannedRenameLocal, Direction: syncDirectionConflict},
-				driveSyncItem{RelPath: rel, Action: syncActionPlannedDownload, Direction: syncDirectionPull},
-			)
-		case syncConflictAsk:
-			res.Items = append(res.Items, driveSyncItem{
-				RelPath: rel, Action: syncActionDecisionRequired, Direction: syncDirectionConflict,
-				Error: "执行时需要交互选择 remote-wins、local-wins、keep-both 或 skip",
-			})
-		default:
-			res.Summary.PlannedSkips++
-			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedSkip, Direction: syncDirectionConflict})
-		}
-	}
-}
-
 // syncPathBlockedByTypeConflict 判断 rel 本身或任一祖先是否是文件/目录类型冲突根。
 // 祖先检查保证冲突目录下的本地、远端后代不会绕过根路径的 fail-closed 结论。
 func syncPathBlockedByTypeConflict(rel string, conflicts map[string]string) bool {

internal/helpers/drive_sync_confirmation_test.go

@@ -3,7 +3,6 @@ package helpers
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"os"
 	"path/filepath"
 	"strings"
@@ -190,116 +189,6 @@ func TestCrossPlatformCoverageDrivePush_dryRunPlansWithoutRemoteWrites(t *testin
 	}
 }
 
-func TestCrossPlatformCoverageDrivePushDryRunPublishesPlannedNotExecutedActions(t *testing.T) {
-	dir := t.TempDir()
-	mustWrite(t, filepath.Join(dir, "local.txt"), "local")
-	caller := syncCaller(nil)
-	caller.dryRun = true
-
-	var out bytes.Buffer
-	testseam.Swap(t, &deps, &Deps{Caller: caller, Out: &Formatter{w: &out}})
-	testseam.Swap(t, &os.Args, []string{"dws", "drive", "push"})
-	cmd := findDriveSubcommand(t, "push")
-	mustSetFlags(t, cmd, map[string]string{"local-folder": dir, "remote-folder": "ROOT"})
-	if err := cmd.RunE(cmd, nil); err != nil {
-		t.Fatalf("dry-run push: %v", err)
-	}
-
-	var payload map[string]any
-	if err := json.Unmarshal(out.Bytes(), &payload); err != nil {
-		t.Fatalf("decode dry-run push: %v\n%s", err, out.String())
-	}
-	plan := payload["plan"].(map[string]any)
-	summary := plan["summary"].(map[string]any)
-	if summary["uploaded"] != float64(0) || summary["planned_uploads"] != float64(1) {
-		t.Fatalf("dry-run summary reports execution instead of a plan: %#v", summary)
-	}
-	items := plan["items"].([]any)
-	if got := items[0].(map[string]any)["action"]; got != "planned_upload" {
-		t.Fatalf("dry-run action = %v, want planned_upload", got)
-	}
-}
-
-func TestCrossPlatformCoverageDriveSyncDryRunReturnsRealActionPlan(t *testing.T) {
-	dir := t.TempDir()
-	mustWrite(t, filepath.Join(dir, "local.txt"), "local")
-	mustWrite(t, filepath.Join(dir, "shared.txt"), "shared")
-	if err := os.Mkdir(filepath.Join(dir, "empty-folder"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	caller := syncCaller(map[string]string{
-		"ROOT": `{"result":{"items":[{"name":"remote.txt","type":"file","fileId":"R","modifyTime":2},{"name":"shared.txt","type":"file","fileId":"S","modifyTime":2}],"nextToken":""}}`,
-	})
-	caller.dryRun = true
-
-	var out bytes.Buffer
-	testseam.Swap(t, &deps, &Deps{Caller: caller, Out: &Formatter{w: &out}})
-	testseam.Swap(t, &os.Args, []string{"dws", "drive", "sync"})
-	cmd := findDriveSubcommand(t, "sync")
-	mustSetFlags(t, cmd, map[string]string{"local-folder": dir, "remote-folder": "ROOT"})
-	if err := cmd.RunE(cmd, nil); err != nil {
-		t.Fatalf("dry-run sync: %v", err)
-	}
-
-	var payload driveSyncDryRunResult
-	if err := json.Unmarshal(out.Bytes(), &payload); err != nil {
-		t.Fatalf("decode dry-run sync: %v\n%s", err, out.String())
-	}
-	if payload.Executed || payload.Plan.Summary.Pulled != 0 || payload.Plan.Summary.Pushed != 0 || payload.Plan.Summary.Skipped != 0 {
-		t.Fatalf("dry-run plan summary = %+v, executed=%v", payload.Plan.Summary, payload.Executed)
-	}
-	if payload.Plan.Summary.PlannedPulls != 1 || payload.Plan.Summary.PlannedPushes != 1 ||
-		payload.Plan.Summary.PlannedSkips != 1 || payload.Plan.Summary.PlannedFolders != 1 {
-		t.Fatalf("dry-run planned summary = %+v", payload.Plan.Summary)
-	}
-	actions := map[string]int{}
-	for _, item := range payload.Plan.Items {
-		actions[item.Action]++
-	}
-	if len(payload.Plan.Items) != 4 || actions["planned_download"] != 1 || actions["planned_upload"] != 1 ||
-		actions["planned_skip"] != 1 || actions["planned_folder_create"] != 1 {
-		t.Fatalf("dry-run action plan = %#v", payload.Plan.Items)
-	}
-	for _, tool := range []string{"download_file", "get_upload_info", "commit_upload", "create_folder"} {
-		if calls := caller.callsFor(tool); len(calls) != 0 {
-			t.Fatalf("dry-run called %s: %#v", tool, calls)
-		}
-	}
-}
-
-func TestCrossPlatformCoverageDriveSyncDryRunPlanBranchMatrix(t *testing.T) {
-	remoteFiles := map[string]*remoteFile{
-		"conflict.txt": {FileID: "remote-file"},
-	}
-	remoteFolders := map[string]string{"": "root", "existing": "existing-id"}
-	localDirs := []string{"existing", "new", "missing/child"}
-	localFiles := map[string]localPushFile{"conflict.txt": {}, "new/file.txt": {}}
-
-	for _, policy := range []string{syncConflictRemoteWins, syncConflictLocalWins, syncConflictKeepBoth, syncConflictAsk, syncConflictSkip} {
-		t.Run(policy, func(t *testing.T) {
-			res := &driveSyncResult{}
-			appendDriveSyncDryRunPlan(res, driveSyncDryRunPlanInput{
-				LocalDirs: localDirs, LocalByRel: localFiles, RemoteFiles: remoteFiles, RemoteFolders: remoteFolders,
-				NewLocal: []string{"new/file.txt", "missing/file.txt"}, NewRemote: []string{"remote.txt"},
-				Modified: []string{"conflict.txt"}, Unknown: []string{"unknown.txt"}, OnConflict: policy,
-			})
-			if res.Summary.PlannedSkips == 0 || res.Summary.PlannedFolders == 0 || res.Summary.PlannedPulls == 0 || res.Summary.Failed != 2 {
-				t.Fatalf("dry-run plan summary for %s = %#v; items=%#v", policy, res.Summary, res.Items)
-			}
-			switch policy {
-			case syncConflictRemoteWins, syncConflictKeepBoth:
-				if res.Summary.PlannedPulls < 2 {
-					t.Fatalf("%s planned pulls = %d", policy, res.Summary.PlannedPulls)
-				}
-			case syncConflictLocalWins:
-				if res.Summary.PlannedPushes < 2 {
-					t.Fatalf("local wins planned pushes = %d", res.Summary.PlannedPushes)
-				}
-			}
-		})
-	}
-}
-
 func TestCrossPlatformCoverageDrivePull_dryRunPlanBranches(t *testing.T) {
 	root := t.TempDir()
 	mustWrite(t, filepath.Join(root, "skip.txt"), "skip")
@@ -353,7 +242,7 @@ func TestCrossPlatformCoverageDrivePush_dryRunPlanBranches(t *testing.T) {
 		[]string{"existing", "missing/child"}, files("orphan/a.txt", "skip.txt", "new.txt")); err != nil {
 		t.Fatalf("skip plan: %v", err)
 	}
-	if text := out.String(); !strings.Contains(text, pushActionFailed) || !strings.Contains(text, pushActionPlannedSkip) || !strings.Contains(text, pushActionPlannedUpload) {
+	if text := out.String(); !strings.Contains(text, pushActionFailed) || !strings.Contains(text, pushActionSkipped) || !strings.Contains(text, pushActionUploaded) {
 		t.Fatalf("skip plan did not cover failed/skipped/uploaded: %s", text)
 	}
 	out.Reset()
@@ -361,14 +250,14 @@ func TestCrossPlatformCoverageDrivePush_dryRunPlanBranches(t *testing.T) {
 		files("smart-skip.txt", "smart-overwrite.txt")); err != nil {
 		t.Fatalf("smart plan: %v", err)
 	}
-	if text := out.String(); !strings.Contains(text, pushActionPlannedSkip) || !strings.Contains(text, pushActionPlannedOverwrite) {
+	if text := out.String(); !strings.Contains(text, pushActionSkipped) || !strings.Contains(text, pushActionOverwritten) {
 		t.Fatalf("smart plan did not cover skip/overwrite: %s", text)
 	}
 	out.Reset()
 	if err := printDrivePushDryRun(ifExistsOverwrite, remoteFiles, remoteFolders, nil, files("overwrite.txt")); err != nil {
 		t.Fatalf("overwrite plan: %v", err)
 	}
-	if !strings.Contains(out.String(), pushActionPlannedOverwrite) {
+	if !strings.Contains(out.String(), pushActionOverwritten) {
 		t.Fatalf("overwrite plan must overwrite existing file: %s", out.String())
 	}
 }

internal/helpers/framework2_changed_lines_coverage_test.go

@@ -58,12 +58,6 @@ func TestCrossPlatformCoverageFramework2MCPDataEdges(t *testing.T) {
 		t.Fatalf("decoded data=%#v err=%v", data, err)
 	}
 
-	InitDeps(&coverageErrorCaller{result: &edition.ToolResult{Content: []edition.ContentBlock{{Type: "text", Text: `{"count":7}`}}}})
-	data, err = CallMCPToolDataOnServer(context.Background(), "dev", "get_thing", nil)
-	if err != nil || data.(map[string]any)["count"] != float64(7) {
-		t.Fatalf("legacy float64 number data=%#v err=%v", data, err)
-	}
-
 	InitDeps(&coverageErrorCaller{err: errors.New("transport failed")})
 	if _, err := CallMCPToolDataOnServer(context.Background(), "dev", "get_thing", nil); err == nil {
 		t.Fatal("expected transport error")
@@ -79,16 +73,6 @@ func TestCrossPlatformCoverageFramework2MCPDataEdges(t *testing.T) {
 	if _, err := CallMCPToolDataOnServer(context.Background(), "dev", "get_thing", nil); err == nil {
 		t.Fatal("expected invalid JSON error")
 	}
-
-	InitDeps(&coverageErrorCaller{result: &edition.ToolResult{Content: []edition.ContentBlock{{Type: "text", Text: `{} {}`}}}})
-	if _, err := CallMCPToolDataOnServer(context.Background(), "dev", "get_thing", nil); err == nil || !strings.Contains(err.Error(), "存在多个 JSON 值") {
-		t.Fatalf("multiple JSON values error = %v", err)
-	}
-
-	InitDeps(&coverageErrorCaller{result: &edition.ToolResult{Content: []edition.ContentBlock{{Type: "text", Text: `{} {`}}}})
-	if _, err := CallMCPToolDataOnServer(context.Background(), "dev", "get_thing", nil); err == nil || !strings.Contains(err.Error(), "解析 get_thing 返回失败") {
-		t.Fatalf("trailing invalid JSON error = %v", err)
-	}
 }
 
 func TestCrossPlatformCoverageFramework2LegacyTextAdapter(t *testing.T) {

internal/helpers/helpers.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
 	"os"
 	"strings"
 	"time"
@@ -306,14 +305,7 @@ func CallMCPToolDataOnServer(ctx context.Context, serverID, toolName string, arg
 		return map[string]any{}, nil
 	}
 	var data any
-	decoder := json.NewDecoder(strings.NewReader(text))
-	if err := decoder.Decode(&data); err != nil {
-		return nil, apperrors.NewInternal(fmt.Sprintf("解析 %s 返回失败: %v", toolName, err))
-	}
-	if err := decoder.Decode(&struct{}{}); err != io.EOF {
-		if err == nil {
-			err = fmt.Errorf("存在多个 JSON 值")
-		}
+	if err := json.Unmarshal([]byte(text), &data); err != nil {
 		return nil, apperrors.NewInternal(fmt.Sprintf("解析 %s 返回失败: %v", toolName, err))
 	}
 	return data, nil

internal/helpers/oa.go

@@ -8,7 +8,6 @@ import (
 	"io"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/cli"
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd"
@@ -323,95 +322,6 @@ func newOAAttachmentCommand() *cobra.Command {
 	return attachmentCmd
 }
 
-// oaAdminQueryMaxPageSize is the pageSize upper bound of
-// get_process_instances_by_admin.
-const oaAdminQueryMaxPageSize = float64(20)
-
-// validateOARequestProcessCode checks the processCode field of a decoded
-// --request payload: the tool requires it, and the backend answers a bad
-// processCode with success:true and an empty list, so reject it client-side.
-func validateOARequestProcessCode(request map[string]any) error {
-	v, ok := request["processCode"]
-	if !ok {
-		return fmt.Errorf("--request 缺少必填字段 processCode")
-	}
-	s, ok := v.(string)
-	if !ok || s == "" {
-		return fmt.Errorf("--request processCode 必须为非空字符串")
-	}
-	return nil
-}
-
-// validateOARequestPageSize checks the pageSize field of a decoded
-// --request payload (json.Number values from decodeOARequest).
-func validateOARequestPageSize(request map[string]any) error {
-	v, ok := request["pageSize"]
-	if !ok {
-		return nil
-	}
-	n, ok := v.(json.Number)
-	if !ok {
-		return fmt.Errorf("pageSize 必须为数字")
-	}
-	f, err := n.Float64()
-	if err != nil || f < 1 || f > oaAdminQueryMaxPageSize {
-		return fmt.Errorf("pageSize 必须在 1-%d 之间，got: %s", int(oaAdminQueryMaxPageSize), n.String())
-	}
-	return nil
-}
-
-// oaAdminTimeLayout is the startTime/endTime wire format of
-// get_process_instances_by_admin since the 2026-08 MCP contract update
-// (both fields changed from epoch millis to strings).
-const oaAdminTimeLayout = "2006-01-02 15:04:05"
-
-// oaAdminTimeLayoutHint is the user-facing spelling of the layout used in
-// error messages.
-const oaAdminTimeLayoutHint = "yyyy-MM-dd HH:mm:ss"
-
-var oaAdminTimeZone = time.FixedZone("Asia/Shanghai", 8*3600)
-
-// formatOAAdminQueryTime renders a millisecond timestamp into the
-// yyyy-MM-dd HH:mm:ss string required by get_process_instances_by_admin.
-func formatOAAdminQueryTime(ms int64) string {
-	return time.UnixMilli(ms).In(oaAdminTimeZone).Format(oaAdminTimeLayout)
-}
-
-// validateOARequestTimeRange checks startTime/endTime of a decoded
-// --request payload: startTime is required, both must be
-// yyyy-MM-dd HH:mm:ss strings, and endTime must be strictly after
-// startTime (matching simple mode's ValidateTimeRange).
-func validateOARequestTimeRange(request map[string]any) error {
-	startRaw, ok := request["startTime"]
-	if !ok {
-		return fmt.Errorf("--request 缺少必填字段 startTime")
-	}
-	startStr, ok := startRaw.(string)
-	if !ok {
-		return fmt.Errorf("startTime 必须为 %s 格式字符串", oaAdminTimeLayoutHint)
-	}
-	start, err := time.ParseInLocation(oaAdminTimeLayout, startStr, oaAdminTimeZone)
-	if err != nil {
-		return fmt.Errorf("startTime 必须为 %s 格式，got: %s", oaAdminTimeLayoutHint, startStr)
-	}
-	endRaw, ok := request["endTime"]
-	if !ok {
-		return nil
-	}
-	endStr, ok := endRaw.(string)
-	if !ok {
-		return fmt.Errorf("endTime 必须为 %s 格式字符串", oaAdminTimeLayoutHint)
-	}
-	end, err := time.ParseInLocation(oaAdminTimeLayout, endStr, oaAdminTimeZone)
-	if err != nil {
-		return fmt.Errorf("endTime 必须为 %s 格式，got: %s", oaAdminTimeLayoutHint, endStr)
-	}
-	if !end.After(start) {
-		return fmt.Errorf("--request endTime 必须晚于 startTime")
-	}
-	return nil
-}
-
 // ──────────────────────────────────────────────────────────
 // dws oa — OA 审批
 // MCP tools（tools/list）: list_pending_approvals, get_processInstance_detail,
@@ -419,8 +329,7 @@ func validateOARequestTimeRange(request map[string]any) error {
 // get_processInstance_records, list_initiated_instances, list_pending_tasks,
 // list_user_visible_process, append_task, search_form, oa_ding_user, revert_task,
 // get_inst_revert_activities, get_process_schema, forecast_process,
-// start_process_instance, get_process_instances_by_admin,
-// get_attachment_download_url, auth_download_file,
+// start_process_instance, get_attachment_download_url, auth_download_file,
 // auth_preview_attachment
 // ──────────────────────────────────────────────────────────
 
@@ -1523,129 +1432,6 @@ func newOaCommand() *cobra.Command {
 			},
 		},
 	})
-	// 以管理员身份查询审批实例列表
-	listByAdminSimpleFlags := []string{"process-code", "start", "end", "cursor", "limit", "user-ids", "statuses"}
-	approvalListByAdminCmd := &cobra.Command{
-		Use: "list-by-admin", Short: "以管理员身份查询审批模板的实例列表",
-		Example: `  dws oa approval list-by-admin --process-code <code> --start "2026-03-10T00:00:00+08:00" --cursor 0 --limit 20
-  dws oa approval list-by-admin --request '{"processCode":"PROC-xxx","startTime":"2026-03-10 00:00:00","cursor":0,"pageSize":20,"statuses":["RUNNING"]}'`,
-		PreRunE: func(cmd *cobra.Command, args []string) error {
-			// Cobra 的 flag group 校验（英文报错）在 PreRunE 之后执行，
-			// 这里先校验同一组约束，保证用户看到的是中文错误。
-			request, _ := cmd.Flags().GetString("request")
-			processCode, _ := cmd.Flags().GetString("process-code")
-			if request == "" && processCode == "" {
-				return fmt.Errorf("--request、--process-code 至少指定一个")
-			}
-			if request != "" {
-				for _, name := range listByAdminSimpleFlags {
-					if cmd.Flags().Changed(name) {
-						return fmt.Errorf("--request 与 --%s 不能同时指定", name)
-					}
-				}
-			}
-			if processCode != "" && !cmd.Flags().Changed("start") {
-				return fmt.Errorf("--process-code、--start 必须同时指定（缺少 --start）")
-			}
-			return nil
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if raw, _ := cmd.Flags().GetString("request"); raw != "" {
-				request, err := decodeOARequest(raw)
-				if err != nil {
-					return fmt.Errorf("--request JSON 解析失败: %w", err)
-				}
-				if err := validateOARequestProcessCode(request); err != nil {
-					return err
-				}
-				if err := validateOARequestPageSize(request); err != nil {
-					return err
-				}
-				if err := validateOARequestTimeRange(request); err != nil {
-					return err
-				}
-				return callMCPTool("get_process_instances_by_admin", map[string]any{"ProcessInstanceListQueryRequest": request})
-			}
-			if err := validateRequiredFlags(cmd, "process-code", "start"); err != nil {
-				return err
-			}
-			startMs, err := parseISOTimeToMillis("start", mustGetFlag(cmd, "start"))
-			if err != nil {
-				return err
-			}
-			cursor, err := strconv.ParseFloat(mustGetFlag(cmd, "cursor"), 64)
-			if err != nil {
-				return fmt.Errorf("--cursor 必须为数字: %w", err)
-			}
-			pageSize, err := strconv.ParseFloat(mustGetFlag(cmd, "limit"), 64)
-			if err != nil {
-				return fmt.Errorf("--limit 必须为数字: %w", err)
-			}
-			if pageSize < 1 || pageSize > oaAdminQueryMaxPageSize {
-				return fmt.Errorf("--limit 必须在 1-%d 之间，got: %s", int(oaAdminQueryMaxPageSize), mustGetFlag(cmd, "limit"))
-			}
-			request := map[string]any{
-				"processCode": mustGetFlag(cmd, "process-code"),
-				"startTime":   formatOAAdminQueryTime(startMs),
-				"cursor":      cursor,
-				"pageSize":    pageSize,
-			}
-			if v, _ := cmd.Flags().GetString("end"); v != "" {
-				endMs, err := parseISOTimeToMillis("end", v)
-				if err != nil {
-					return err
-				}
-				if err := validateTimeRange(startMs, endMs); err != nil {
-					return err
-				}
-				request["endTime"] = formatOAAdminQueryTime(endMs)
-			}
-			if v, _ := cmd.Flags().GetString("user-ids"); v != "" {
-				request["userIds"] = strings.Split(v, ",")
-			}
-			if v, _ := cmd.Flags().GetString("statuses"); v != "" {
-				request["statuses"] = strings.Split(v, ",")
-			}
-			return callMCPTool("get_process_instances_by_admin", map[string]any{"ProcessInstanceListQueryRequest": request})
-		},
-	}
-	DeclareLeafMetadata(approvalListByAdminCmd, LeafSpec{
-		Safety: contract.SafetySpec{
-			Effect: "read", Risk: "low",
-			Confirmation: "not_required", Idempotency: "idempotent",
-		},
-		Contract: LeafContract{
-			Identity: contract.ToolIdentitySpec{
-				ProductID:      "oa",
-				Name:           "get_process_instances_by_admin",
-				CanonicalPath:  "oa.get_process_instances_by_admin",
-				CLIPath:        "oa approval list-by-admin",
-				PrimaryCLIPath: "oa approval list-by-admin",
-			},
-			Description: "以管理员身份获取审批单列表",
-			Interface: &contract.InterfaceSpec{
-				Mode:         "mcp",
-				Availability: "available",
-				Ref:          &contract.InterfaceRefSpec{ProductID: "oa", RPCName: "get_process_instances_by_admin"},
-			},
-			Selection: contract.SelectionSpec{
-				AgentSummary: "以管理员身份按模板、时间范围、状态与用户查询企业内审批实例列表",
-				UseWhen:      []string{"具备 OA 审批管理员权限，需要跨用户统计或检索某模板下的审批实例时"},
-				AvoidWhen: []string{
-					"只查自己的待办/已办/已发起/抄送时改用 list-pending / list-executed / list-initiated / list-cc",
-					"无 OA 管理员权限时不要使用，该命令查不到数据",
-				},
-				Examples: []string{
-					"dws oa approval list-by-admin --process-code <code> --start \"2026-03-10T00:00:00+08:00\" --cursor 0 --limit 20",
-					"dws oa approval list-by-admin --process-code <code> --start \"2026-03-10T00:00:00+08:00\" --end \"2026-03-10T23:59:59+08:00\" --statuses RUNNING,COMPLETED --user-ids \"userId1,userId2\"",
-				},
-			},
-			// Simple-mode flags are mapping exclusions (encoded inside ProcessInstanceListQueryRequest).
-			Parameters: []contract.ParamDecl{
-				{Name: "request", Property: "ProcessInstanceListQueryRequest", InterfaceType: "object"},
-			},
-		},
-	})
 	approvalCreateCmd := &cobra.Command{
 		Use: "create-instance", Short: "发起审批实例（需要 --yes 确认）",
 		Example: "dws oa approval create-instance --process-code <processCode> --form-values '{\"事由\":\"测试\"}' --yes",
@@ -1824,27 +1610,6 @@ func newOaCommand() *cobra.Command {
 		RequireTogether:   [][]string{{"process-code", "dept-id", "form-values"}},
 	})
 
-	approvalListByAdminCmd.Flags().String("process-code", "", "审批模板 processCode（简单模式使用；与 --request 互斥）")
-	approvalListByAdminCmd.Flags().String("start", "", "开始时间 ISO-8601 (如 2026-03-10T00:00:00+08:00)（简单模式使用；与 --request 互斥）")
-	approvalListByAdminCmd.Flags().String("end", "", "结束时间 ISO-8601 (如 2026-03-10T23:59:59+08:00)（可选）")
-	approvalListByAdminCmd.Flags().String("cursor", "0", "分页游标，首次传 0")
-	approvalListByAdminCmd.Flags().String("limit", "20", "每页大小，最大 20")
-	approvalListByAdminCmd.Flags().String("user-ids", "", "按发起人 userId 过滤，多个用逗号分隔（可选）")
-	approvalListByAdminCmd.Flags().String("statuses", "", "按审批状态过滤，多个用逗号分隔（可选，如 RUNNING、TERMINATED、COMPLETED）")
-	approvalListByAdminCmd.Flags().String("request", "", "完整请求 JSON（高级模式；与简单模式参数互斥）")
-	approvalListByAdminCmd.MarkFlagsOneRequired("request", "process-code")
-	approvalListByAdminCmd.MarkFlagsRequiredTogether("process-code", "start")
-	listByAdminMutuallyExclusive := make([][]string, 0, len(listByAdminSimpleFlags))
-	for _, name := range listByAdminSimpleFlags {
-		approvalListByAdminCmd.MarkFlagsMutuallyExclusive("request", name)
-		listByAdminMutuallyExclusive = append(listByAdminMutuallyExclusive, []string{"request", name})
-	}
-	cli.AnnotateRuntimeConstraints(approvalListByAdminCmd, cli.RuntimeSchemaConstraints{
-		MutuallyExclusive: listByAdminMutuallyExclusive,
-		RequireOneOf:      [][]string{{"request", "process-code"}},
-		RequireTogether:   [][]string{{"process-code", "start"}},
-	})
-
 	approvalCreateCmd.Flags().String("process-code", "", "审批模板 processCode（简单模式使用；与 --request 互斥）")
 	approvalCreateCmd.Flags().String("dept-id", "-1", "发起人部门 ID")
 	approvalCreateCmd.Flags().String("form-values", "", "表单值 JSON（简单模式使用；与 --request 互斥）")
@@ -1891,7 +1656,6 @@ func newOaCommand() *cobra.Command {
 		approvalRevertTaskCmd,
 		approvalFormSchemaCmd,
 		approvalForecastCmd,
-		approvalListByAdminCmd,
 		approvalCreateCmd,
 	)
 	approvalCmd.AddCommand(newOAAttachmentCommand())

internal/helpers/oa_coverage_more_test.go

@@ -131,51 +131,6 @@ func TestCrossPlatformCoverageOAApprovalCreateInstanceRequiresExplicitYes(t *tes
 	}
 }
 
-func TestCrossPlatformCoverageOAApprovalListByAdminMapsSimpleOptions(t *testing.T) {
-	caller := &scriptedToolCaller{}
-	err := executeOACommand(t, caller,
-		"approval", "list-by-admin",
-		"--process-code", "PROC",
-		"--start", "2030-01-01T09:00:00+08:00",
-		"--end", "2030-01-01T10:00:00+08:00",
-		"--cursor", "5",
-		"--limit", "20",
-		"--user-ids", "user-1,user-2",
-		"--statuses", "RUNNING,COMPLETED",
-	)
-	if err != nil {
-		t.Fatalf("list by admin: %v", err)
-	}
-	if caller.server != "oa" || caller.tool != "get_process_instances_by_admin" {
-		t.Fatalf("called %s/%s, want oa/get_process_instances_by_admin", caller.server, caller.tool)
-	}
-	request, ok := caller.args["ProcessInstanceListQueryRequest"].(map[string]any)
-	if !ok {
-		t.Fatalf("request payload = %#v", caller.args)
-	}
-	if got := request["processCode"]; got != "PROC" {
-		t.Fatalf("processCode = %#v", got)
-	}
-	if got := request["cursor"]; got != float64(5) {
-		t.Fatalf("cursor = %#v", got)
-	}
-	if got := request["pageSize"]; got != float64(20) {
-		t.Fatalf("pageSize = %#v", got)
-	}
-	if got := request["startTime"]; got != "2030-01-01 09:00:00" {
-		t.Fatalf("startTime = %#v", got)
-	}
-	if got := request["endTime"]; got != "2030-01-01 10:00:00" {
-		t.Fatalf("endTime = %#v", got)
-	}
-	if got := request["userIds"]; len(got.([]string)) != 2 || got.([]string)[0] != "user-1" || got.([]string)[1] != "user-2" {
-		t.Fatalf("userIds = %#v", got)
-	}
-	if got := request["statuses"]; len(got.([]string)) != 2 || got.([]string)[0] != "RUNNING" || got.([]string)[1] != "COMPLETED" {
-		t.Fatalf("statuses = %#v", got)
-	}
-}
-
 func TestCrossPlatformCoverageOAApprovalNewCommandValidationAndRequestModes(t *testing.T) {
 	validCases := []struct {
 		name string
@@ -202,26 +157,6 @@ func TestCrossPlatformCoverageOAApprovalNewCommandValidationAndRequestModes(t *t
 			args: []string{"approval", "create-instance", "--request", `{"processCode":"PROC"}`, "--yes"},
 			tool: "start_process_instance",
 		},
-		{
-			name: "list-by-admin simple mode",
-			args: []string{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T09:00:00+08:00"},
-			tool: "get_process_instances_by_admin",
-		},
-		{
-			name: "list-by-admin request mode",
-			args: []string{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","cursor":0,"pageSize":20}`},
-			tool: "get_process_instances_by_admin",
-		},
-		{
-			name: "list-by-admin request mode without pageSize",
-			args: []string{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","cursor":0}`},
-			tool: "get_process_instances_by_admin",
-		},
-		{
-			name: "list-by-admin request mode with endTime",
-			args: []string{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","endTime":"2030-01-01 23:59:59","cursor":0,"pageSize":20}`},
-			tool: "get_process_instances_by_admin",
-		},
 	}
 	for _, tc := range validCases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -253,31 +188,6 @@ func TestCrossPlatformCoverageOAApprovalNewCommandValidationAndRequestModes(t *t
 		{"approval", "create-instance", "--process-code", "PROC", "--form-values", `{}`, "--dept-id", "bad", "--yes"},
 		{"approval", "create-instance", "--process-code", "PROC", "--form-values", `{}`, "--approvers", "u", "--approvers-action-type", "bad", "--yes"},
 		{"approval", "create-instance", "--process-code", "PROC", "--form-values", `{}`, "--cc-list", "u", "--cc-position", "bad", "--yes"},
-		{"approval", "list-by-admin"},
-		{"approval", "list-by-admin", "--process-code", "PROC"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "bad"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T10:00:00+08:00", "--end", "bad"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T10:00:00+08:00", "--end", "2030-01-01T09:00:00+08:00"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T09:00:00+08:00", "--cursor", "bad"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T09:00:00+08:00", "--limit", "bad"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T09:00:00+08:00", "--limit", "21"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", "2030-01-01T09:00:00+08:00", "--limit", "0"},
-		{"approval", "list-by-admin", "--process-code", "PROC", "--start", ""},
-		{"approval", "list-by-admin", "--request", "{"},
-		{"approval", "list-by-admin", "--request", "null"},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC"}`, "--process-code", "PROC"},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","cursor":0,"pageSize":21}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","cursor":0,"pageSize":"20"}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":1893459600000,"cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 10:00:00","endTime":"2030-01-01 09:00:00","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","endTime":1893463200000,"cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","endTime":"NOT-A-TIME","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","endTime":"2030-01-01","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"PROC","startTime":"2030-01-01 09:00:00","endTime":"2030-01-01 09:00:00","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"startTime":"2030-01-01 09:00:00","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":"","startTime":"2030-01-01 09:00:00","cursor":0,"pageSize":20}`},
-		{"approval", "list-by-admin", "--request", `{"processCode":123,"startTime":"2030-01-01 09:00:00","cursor":0,"pageSize":20}`},
 	}
 	for _, args := range invalidCases {
 		caller := &scriptedToolCaller{}

internal/helpers/recruit.go

@@ -1,678 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-
-package helpers
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd/contract"
-	apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/output"
-)
-
-const (
-	recruitServerID      = "recruit"
-	recruitCreateJobTool = "create_job"
-	recruitGetJobTool    = "get_job_detail"
-	recruitListJobsTool  = "list_jobs"
-)
-
-var recruitDryRun = &contract.DryRunSpec{
-	PreviewKind: contract.DryRunPreviewRequest,
-	RemoteReads: false,
-}
-
-var (
-	recruitListResult = &contract.ResultSpec{
-		Outcomes:   []contract.ResultOutcome{contract.ResultOutcomeSuccess, contract.ResultOutcomeFailure},
-		DataSchema: json.RawMessage(`{"type":"object","description":"当前页招聘职位查询结果；续页信息位于 meta.pagination","properties":{"jobs":{"type":"array","description":"当前页职位记录","items":{"type":"object","description":"招聘职位摘要","properties":{"jobId":{"type":"string","description":"职位 ID"},"name":{"type":"string","description":"职位名称"},"status":{"type":"number","description":"职位状态枚举值"}},"additionalProperties":true}}},"additionalProperties":true}`),
-	}
-	recruitJobDetailResult = &contract.ResultSpec{
-		Outcomes:   []contract.ResultOutcome{contract.ResultOutcomeSuccess, contract.ResultOutcomeFailure},
-		DataSchema: json.RawMessage(`{"type":"object","description":"招聘职位详情","properties":{"jobId":{"type":"string","description":"职位 ID"},"name":{"type":"string","description":"职位名称"},"description":{"type":"string","description":"职位描述"},"status":{"type":"number","description":"职位状态枚举值"}},"additionalProperties":true}`),
-	}
-	recruitCreateJobResult = &contract.ResultSpec{
-		Outcomes:   []contract.ResultOutcome{contract.ResultOutcomeSuccess, contract.ResultOutcomeFailure},
-		DataSchema: json.RawMessage(`{"type":"object","description":"招聘职位创建结果","properties":{"jobId":{"type":"string","description":"新创建的职位 ID"}},"required":["jobId"],"additionalProperties":true}`),
-	}
-)
-
-func recruitCursorPagination() *contract.PaginationSpec {
-	return &contract.PaginationSpec{Kind: contract.PaginationKindCursor, CursorParameter: "cursor"}
-}
-
-func newRecruitCommand() *cobra.Command {
-	contract.RegisterProductDecl(contract.ProductDecl{
-		ID: "recruit",
-		Selection: contract.ProductSelectionDecl{
-			AgentSummary: "查询和创建钉钉招聘职位",
-			UseWhen:      []string{"需要查询招聘职位列表、查看职位详情或创建职位时"},
-			AvoidWhen:    []string{"查询企业员工与组织架构使用 contact；查询人才池、职业历程或绩效使用 hrbrain"},
-		},
-	})
-
-	root := &cobra.Command{
-		Use:   "recruit",
-		Short: "钉钉招聘",
-		Long:  "查询和创建钉钉招聘中的职位信息。",
-		RunE:  groupRunE,
-	}
-	job := &cobra.Command{
-		Use:   "job",
-		Short: "招聘职位管理",
-		RunE:  groupRunE,
-	}
-	job.AddCommand(
-		newRecruitJobListCommand(),
-		newRecruitJobGetCommand(),
-		newRecruitJobCreateCommand(),
-	)
-	root.AddCommand(job)
-	return root
-}
-
-func newRecruitJobListCommand() *cobra.Command {
-	return NewLeafCommand(LeafSpec{
-		Use:           "list",
-		Short:         "查询招聘职位列表",
-		Long:          "按职位 ID、关键词、状态、创建人、职位性质等条件分页查询招聘职位。",
-		Example:       "  dws recruit job list --keyword Java --status open --size 20 --format json\n  dws recruit job list --job-ids JOB_ID_1,JOB_ID_2 --format json",
-		Server:        recruitServerID,
-		Tool:          recruitListJobsTool,
-		Safety:        recruitSafetyRead(),
-		OutputRollout: output.RolloutUnifiedActive,
-		Flags: []LeafFlag{
-			{Name: "job-ids", Usage: "职位 ID，多个值用逗号分隔", Kind: LeafStringSlice, Bind: "jobIds"},
-			{Name: "required-edu", Usage: "学历要求枚举值", Kind: LeafInt, Bind: "requiredEdu"},
-			{Name: "status", Usage: "职位状态：draft/open/invalid/closed，多个值用逗号分隔", Bind: "statusList", Trim: true, OmitEmpty: true, Transform: transformRecruitStatuses},
-			{Name: "job-nature", Usage: "职位性质", Bind: "jobNature", Trim: true, OmitEmpty: true},
-			{Name: "campus", Usage: "是否为校园招聘", Kind: LeafBool, Bind: "campus"},
-			{Name: "start-modified-time", Usage: "修改时间范围起点", Bind: "startModifiedTime", Trim: true, OmitEmpty: true},
-			{Name: "end-modified-time", Usage: "修改时间范围终点", Bind: "endModifiedTime", Trim: true, OmitEmpty: true},
-			{Name: "creator-user-ids", Usage: "创建人 userId，多个值用逗号分隔", Kind: LeafStringSlice, Bind: "creatorUserIds"},
-			{Name: "keyword", Usage: "职位搜索关键词", Bind: "keyword", Trim: true, OmitEmpty: true},
-			{Name: "category", Usage: "职位分类", Bind: "category", Trim: true, OmitEmpty: true},
-			{Name: "cursor", Usage: "分页游标；首次查询不传，翻页时原样回填返回的 nextCursor", Bind: "cursor", Trim: true, OmitEmpty: true, Transform: transformRecruitCursor},
-			{Name: "size", Usage: "分页大小，默认 20", Kind: LeafInt, Bind: "size", Default: "20", ArgDefault: "20"},
-		},
-		Validate:   validateRecruitList,
-		ResultCall: recruitResultCall,
-		Contract: LeafContract{
-			Identity:    contract.ToolIdentitySpec{ProductID: "recruit", Name: recruitListJobsTool, CanonicalPath: "recruit.list_jobs", CLIPath: "recruit job list", PrimaryCLIPath: "recruit job list"},
-			Description: "按条件分页查询招聘职位",
-			DryRun:      recruitDryRun,
-			Result:      recruitListResult,
-			Pagination:  recruitCursorPagination(),
-			Interface:   recruitMCPInterface(recruitListJobsTool),
-			Selection: contract.SelectionSpec{
-				AgentSummary: "按关键词、状态、创建人等条件分页查询招聘职位",
-				UseWhen:      []string{"需要查找职位、筛选在招职位或取得 jobId 时"},
-				AvoidWhen:    []string{"已经持有明确 jobId 且需要完整详情时使用 recruit job get"},
-				Examples:     []string{`dws recruit job list --keyword "Java" --status open --size 20 --format json`},
-			},
-			Parameters: recruitListParamDecls(),
-		},
-	})
-}
-
-func recruitListToolArgs(args map[string]any) map[string]any {
-	params := map[string]any{"param": map[string]any{}, "size": args["size"]}
-	query := params["param"].(map[string]any)
-	for key, value := range args {
-		switch key {
-		case "cursor":
-			params[key] = value
-		case "size":
-		default:
-			query[key] = value
-		}
-	}
-	return params
-}
-
-func recruitResultCall(cmd *cobra.Command, tool string, args map[string]any) (output.CommandResult, error) {
-	toolArgs := args
-	if tool == recruitListJobsTool {
-		toolArgs = recruitListToolArgs(args)
-	}
-	if deps.Caller.DryRun() {
-		return output.Success(map[string]any{
-			"tool": tool, "arguments": toolArgs, "executed": false,
-		}, output.WithDryRun()), nil
-	}
-	data, err := callRecruitMCPToolData(cmd.Context(), tool, toolArgs)
-	if err != nil {
-		return nil, err
-	}
-	clean, err := recruitBusinessResultData(data, tool)
-	if err != nil {
-		return recruitResponseFailure(err), nil
-	}
-	switch tool {
-	case recruitListJobsTool:
-		listData, meta, err := recruitListResultData(clean)
-		if err != nil {
-			return recruitInvalidResponse(err), nil
-		}
-		return output.Success(listData, output.WithMeta(meta)), nil
-	case recruitGetJobTool, recruitCreateJobTool:
-		if err := validateRecruitJobResult(clean, tool, args); err != nil {
-			return recruitInvalidResponse(err), nil
-		}
-		return output.Success(clean), nil
-	default:
-		return recruitInvalidResponse(fmt.Errorf("不支持校验 %s 的业务结果", tool)), nil
-	}
-}
-
-func validateRecruitJobResult(data map[string]any, tool string, args map[string]any) error {
-	jobID, ok := data["jobId"].(string)
-	if !ok || strings.TrimSpace(jobID) == "" {
-		return fmt.Errorf("%s 返回值缺少非空字符串字段 jobId", tool)
-	}
-	if tool != recruitGetJobTool {
-		return nil
-	}
-	requestedJobID, ok := args["jobId"].(string)
-	if !ok || strings.TrimSpace(requestedJobID) == "" {
-		return fmt.Errorf("%s 请求缺少非空字符串字段 jobId", tool)
-	}
-	if strings.TrimSpace(jobID) != strings.TrimSpace(requestedJobID) {
-		return fmt.Errorf("%s 返回的 jobId %q 与请求的 jobId %q 不一致", tool, jobID, requestedJobID)
-	}
-	return nil
-}
-
-func callRecruitMCPToolData(ctx context.Context, tool string, args map[string]any) (any, error) {
-	text, err := callMCPToolReturnTextOnServer(ctx, recruitServerID, tool, args)
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(text) == "" {
-		return map[string]any{}, nil
-	}
-	var data any
-	decoder := json.NewDecoder(strings.NewReader(text))
-	decoder.UseNumber()
-	if err := decoder.Decode(&data); err != nil {
-		return nil, apperrors.NewInternal(fmt.Sprintf("解析 %s 返回失败: %v", tool, err))
-	}
-	if err := decoder.Decode(&struct{}{}); err != io.EOF {
-		if err == nil {
-			err = fmt.Errorf("存在多个 JSON 值")
-		}
-		return nil, apperrors.NewInternal(fmt.Sprintf("解析 %s 返回失败: %v", tool, err))
-	}
-	return data, nil
-}
-
-func recruitResponseFailure(err error) output.CommandResult {
-	var businessFailure *recruitBusinessFailure
-	if errors.As(err, &businessFailure) {
-		return output.Failure(&output.ErrorInfo{
-			Type: "api", Message: businessFailure.Error(),
-		})
-	}
-	return recruitInvalidResponse(err)
-}
-
-type recruitBusinessFailure struct {
-	message string
-}
-
-func (e *recruitBusinessFailure) Error() string {
-	return e.message
-}
-
-func recruitBusinessResultData(data any, tool string) (map[string]any, error) {
-	object, ok := data.(map[string]any)
-	if !ok {
-		return nil, fmt.Errorf("%s 返回值必须是 JSON 对象", tool)
-	}
-	successValue, hasSuccess := object["success"]
-	resultValue, hasResult := object["result"]
-	if !hasSuccess && !hasResult {
-		return object, nil
-	}
-	if !hasSuccess || !hasResult {
-		return nil, fmt.Errorf("%s 返回的 Connector 信封必须同时包含 success 和 result", tool)
-	}
-	success, ok := successValue.(bool)
-	if !ok {
-		return nil, fmt.Errorf("%s 返回的 Connector 信封字段 success 必须是布尔值", tool)
-	}
-	if !success {
-		message, _ := object["message"].(string)
-		if strings.TrimSpace(message) == "" {
-			message = "Connector 返回 success=false"
-		}
-		return nil, &recruitBusinessFailure{message: fmt.Sprintf("%s 调用失败: %s", tool, message)}
-	}
-	result, ok := resultValue.(map[string]any)
-	if !ok {
-		return nil, fmt.Errorf("%s 返回值的 result 必须是 JSON 对象", tool)
-	}
-	return result, nil
-}
-
-func recruitInvalidResponse(err error) output.CommandResult {
-	return output.Failure(&output.ErrorInfo{
-		Type: "api", Subtype: "invalid_response", Message: err.Error(),
-		Hint: "保留原始响应并停止后续操作；不要依据不完整结果继续处理。",
-	})
-}
-
-func recruitListResultData(data any) (any, *output.Meta, error) {
-	object, ok := data.(map[string]any)
-	if !ok {
-		return nil, nil, fmt.Errorf("%s 返回值必须是 JSON 对象", recruitListJobsTool)
-	}
-	// The Connector envelope has already been removed by recruitResultCall.
-	// Only normalize the list business payload here so fields named success or
-	// result inside that payload cannot be mistaken for another envelope.
-	hasMore, ok := object["hasMore"].(bool)
-	if !ok {
-		return nil, nil, fmt.Errorf("list_jobs 返回值缺少布尔字段 hasMore")
-	}
-	nextToken := ""
-	if hasMore {
-		if raw, exists := object["nextCursor"]; exists && raw != nil {
-			var err error
-			nextToken, err = normalizeRecruitNextCursor(raw)
-			if err != nil {
-				return nil, nil, err
-			}
-		}
-		if nextToken == "" {
-			return nil, nil, fmt.Errorf("list_jobs 返回 hasMore=true 但缺少 nextCursor")
-		}
-	}
-	clean := make(map[string]any, len(object))
-	for key, value := range object {
-		if key != "hasMore" && key != "nextCursor" {
-			clean[key] = value
-		}
-	}
-	if jobs, exists := clean["list"]; exists {
-		if _, alreadyNormalized := clean["jobs"]; !alreadyNormalized {
-			clean["jobs"] = jobs
-		}
-		delete(clean, "list")
-	}
-	pagination := &output.Pagination{EndpointExhausted: !hasMore, NextToken: nextToken, Pages: 1}
-	meta := &output.Meta{Pagination: pagination}
-	if jobs, exists := clean["jobs"].([]any); exists {
-		meta.Count = output.NewCount(len(jobs))
-		pagination.Items = len(jobs)
-	}
-	return clean, meta, nil
-}
-
-func normalizeRecruitNextCursor(raw any) (string, error) {
-	var value string
-	switch cursor := raw.(type) {
-	case string:
-		value = strings.TrimSpace(cursor)
-	case json.Number:
-		value = string(cursor)
-	case float64:
-		value = strconv.FormatFloat(cursor, 'f', -1, 64)
-	default:
-		return "", fmt.Errorf("list_jobs 的 nextCursor 必须是字符串或数字")
-	}
-	parsed, err := strconv.ParseInt(value, 10, 64)
-	if err != nil || parsed < 0 {
-		return "", fmt.Errorf("list_jobs 的 nextCursor 必须是可回填的非负十进制 int64 游标")
-	}
-	return strconv.FormatInt(parsed, 10), nil
-}
-
-func newRecruitJobGetCommand() *cobra.Command {
-	return NewLeafCommand(LeafSpec{
-		Use:           "get",
-		Short:         "查询招聘职位详情",
-		Long:          "根据职位 ID 查询招聘职位详情。",
-		Example:       "  dws recruit job get --job-id JOB_ID --format json",
-		Server:        recruitServerID,
-		Tool:          recruitGetJobTool,
-		Safety:        recruitSafetyRead(),
-		OutputRollout: output.RolloutUnifiedActive,
-		ResultCall:    recruitResultCall,
-		Flags: []LeafFlag{{
-			Name: "job-id", Usage: "职位 ID（必填）", Bind: "jobId", Trim: true,
-			Required: true, RequiredHint: "--job-id 为必填",
-		}},
-		Contract: LeafContract{
-			Identity:    contract.ToolIdentitySpec{ProductID: "recruit", Name: recruitGetJobTool, CanonicalPath: "recruit.get_job_detail", CLIPath: "recruit job get", PrimaryCLIPath: "recruit job get"},
-			Description: "根据职位 ID 查询招聘职位详情",
-			DryRun:      recruitDryRun,
-			Result:      recruitJobDetailResult,
-			Interface:   recruitMCPInterface(recruitGetJobTool),
-			Selection: contract.SelectionSpec{
-				AgentSummary: "获取指定招聘职位的完整信息",
-				UseWhen:      []string{"已经持有明确 jobId，需要查看职位详情时"},
-				AvoidWhen:    []string{"不知道 jobId 时先使用 recruit job list 查询"},
-				Examples:     []string{"dws recruit job get --job-id <JOB_ID> --format json"},
-			},
-			Parameters: []contract.ParamDecl{{Name: "job-id", Property: "jobId", Required: boolPtr(true), InterfaceType: "string"}},
-		},
-	})
-}
-
-func newRecruitJobCreateCommand() *cobra.Command {
-	return NewLeafCommand(LeafSpec{
-		Use:           "create",
-		Short:         "创建招聘职位",
-		Long:          "从 JSON 文件读取职位信息并创建招聘职位。该操作会写入远端招聘系统，执行前必须确认。",
-		Example:       "  dws recruit job create --from ./job.json --dry-run --format json\n  dws recruit job create --from ./job.json --format json",
-		Server:        recruitServerID,
-		Tool:          recruitCreateJobTool,
-		Safety:        recruitSafetyCreate(),
-		OutputRollout: output.RolloutUnifiedActive,
-		ResultCall:    recruitResultCall,
-		Flags: []LeafFlag{{
-			Name: "from", Usage: "职位 JSON 文件路径（必填）", Bind: "atsAddJobParam", Trim: true,
-			Required: true, RequiredHint: "--from 为必填", Transform: loadRecruitJobFile,
-		}},
-		Contract: LeafContract{
-			Identity:    contract.ToolIdentitySpec{ProductID: "recruit", Name: recruitCreateJobTool, CanonicalPath: "recruit.create_job", CLIPath: "recruit job create", PrimaryCLIPath: "recruit job create"},
-			Description: "从 JSON 文件创建招聘职位",
-			DryRun:      recruitDryRun,
-			Result:      recruitCreateJobResult,
-			Interface:   recruitMCPInterface(recruitCreateJobTool),
-			Selection: contract.SelectionSpec{
-				AgentSummary: "使用结构化 JSON 创建招聘职位",
-				UseWhen:      []string{"用户明确要求新建职位，并已准备或同意生成职位 JSON 时；文件必须包含 name、description、jobNature、requiredEdu、extData、creatorUserId；jobNature 固定为 FULL-TIME；creatorUserId 必须使用真实创建人 userId；ownerUserIds 可选"},
-				AvoidWhen:    []string{"仅查询职位时使用 recruit job list 或 recruit job get"},
-				Examples:     []string{"dws recruit job create --from ./job.json --dry-run --format json"},
-			},
-			Parameters: []contract.ParamDecl{{Name: "from", Property: "atsAddJobParam", Required: boolPtr(true), InterfaceType: "object", Description: "职位 JSON 文件；CLI 校验后原样作为 atsAddJobParam 对象发送；creatorUserId 为必填的创建人 userId，ownerUserIds 为可选的负责人 userId 字符串数组"}},
-		},
-	})
-}
-
-func recruitListParamDecls() []contract.ParamDecl {
-	return []contract.ParamDecl{
-		{Name: "job-ids", Property: "param.jobIds", InterfaceType: "array"},
-		{Name: "required-edu", Property: "param.requiredEdu", InterfaceType: "number"},
-		{Name: "status", Property: "param.statusList", InterfaceType: "array", Enum: []string{"draft", "open", "invalid", "closed"}},
-		{Name: "job-nature", Property: "param.jobNature", InterfaceType: "string"},
-		{Name: "campus", Property: "param.campus", InterfaceType: "boolean"},
-		{Name: "start-modified-time", Property: "param.startModifiedTime", InterfaceType: "string"},
-		{Name: "end-modified-time", Property: "param.endModifiedTime", InterfaceType: "string"},
-		{Name: "creator-user-ids", Property: "param.creatorUserIds", InterfaceType: "array"},
-		{Name: "keyword", Property: "param.keyword", InterfaceType: "string"},
-		{Name: "category", Property: "param.category", InterfaceType: "string"},
-		{Name: "cursor", Property: "cursor", InterfaceType: "number"},
-		{Name: "size", Property: "size", InterfaceType: "number"},
-	}
-}
-
-func recruitMCPInterface(tool string) *contract.InterfaceSpec {
-	return &contract.InterfaceSpec{
-		Mode:         contract.InterfaceModeMCP,
-		Availability: contract.InterfaceAvailable,
-		Ref:          &contract.InterfaceRefSpec{ProductID: recruitServerID, RPCName: tool},
-	}
-}
-
-func recruitSafetyRead() contract.SafetySpec {
-	return contract.SafetySpec{Effect: "read", Risk: "low", Confirmation: "not_required", Idempotency: "idempotent"}
-}
-
-func recruitSafetyCreate() contract.SafetySpec {
-	return contract.SafetySpec{Effect: "write", Risk: "medium", Confirmation: "user_required", Idempotency: "non_idempotent"}
-}
-
-func transformRecruitStatuses(raw string) (any, error) {
-	values := strings.Split(raw, ",")
-	statuses := make([]int, 0, len(values))
-	seen := make(map[int]bool, len(values))
-	lookup := map[string]int{"draft": 0, "open": 1, "invalid": 2, "closed": 3}
-	for _, value := range values {
-		name := strings.ToLower(strings.TrimSpace(value))
-		if name == "" {
-			continue
-		}
-		status, ok := lookup[name]
-		if !ok {
-			return nil, apperrors.NewValidation(fmt.Sprintf("--status 不支持 %q，可选 draft/open/invalid/closed", value))
-		}
-		if !seen[status] {
-			statuses = append(statuses, status)
-			seen[status] = true
-		}
-	}
-	return statuses, nil
-}
-
-func transformRecruitCursor(raw string) (any, error) {
-	value := strings.TrimSpace(raw)
-	cursor, err := strconv.ParseInt(value, 10, 64)
-	if err != nil || cursor < 0 {
-		return nil, apperrors.NewValidation("--cursor 必须是大于或等于 0 的整数")
-	}
-	return cursor, nil
-}
-
-func validateRecruitList(cmd *cobra.Command, _ []string) error {
-	size, _ := cmd.Flags().GetInt("size")
-	if cmd.Flags().Changed("size") && (size < 1 || size > 100) {
-		return apperrors.NewValidation("--size 必须在 1 到 100 之间")
-	}
-	requiredEdu, _ := cmd.Flags().GetInt("required-edu")
-	if cmd.Flags().Changed("required-edu") && (requiredEdu < 1 || requiredEdu > 9) {
-		return apperrors.NewValidation("--required-edu 必须在 1 到 9 之间")
-	}
-	return nil
-}
-
-func loadRecruitJobFile(path string) (any, error) {
-	data, err := os.ReadFile(strings.TrimSpace(path))
-	if err != nil {
-		return nil, fmt.Errorf("读取职位 JSON 失败: %w", err)
-	}
-	var job map[string]any
-	if err := json.Unmarshal(data, &job); err != nil {
-		return nil, apperrors.NewValidation(fmt.Sprintf("职位文件不是有效的 JSON 对象: %v", err))
-	}
-	if job == nil {
-		return nil, apperrors.NewValidation("职位 JSON 顶层必须是对象")
-	}
-	if err := validateRecruitJob(job); err != nil {
-		return nil, err
-	}
-	return job, nil
-}
-
-func validateRecruitJob(job map[string]any) error {
-	for _, name := range []string{"name", "description", "jobNature", "requiredEdu", "extData", "creatorUserId"} {
-		value, ok := job[name]
-		if !ok || value == nil || (isString(value) && strings.TrimSpace(value.(string)) == "") {
-			return apperrors.NewValidation(fmt.Sprintf("职位 JSON 缺少必填字段 %s", name))
-		}
-	}
-	for _, name := range []string{"name", "description", "jobNature"} {
-		if !isString(job[name]) {
-			return apperrors.NewValidation(fmt.Sprintf("职位 JSON 字段 %s 必须是字符串", name))
-		}
-	}
-	if job["jobNature"].(string) != "FULL-TIME" {
-		return apperrors.NewValidation("职位 JSON 字段 jobNature 当前仅支持 FULL-TIME")
-	}
-	requiredEdu, ok := job["requiredEdu"].(float64)
-	if !ok {
-		return apperrors.NewValidation("职位 JSON 字段 requiredEdu 必须是数字")
-	}
-	if requiredEdu < 1 || requiredEdu > 9 || requiredEdu != float64(int(requiredEdu)) {
-		return apperrors.NewValidation("职位 JSON 字段 requiredEdu 必须是 1 到 9 的整数")
-	}
-
-	minSalary, hasMinSalary, err := optionalRecruitNumber(job, "minSalary")
-	if err != nil {
-		return err
-	}
-	maxSalary, hasMaxSalary, err := optionalRecruitNumber(job, "maxSalary")
-	if err != nil {
-		return err
-	}
-	if hasMinSalary && hasMaxSalary && minSalary > maxSalary {
-		return apperrors.NewValidation("职位 JSON 中 minSalary 不能大于 maxSalary")
-	}
-
-	for _, name := range []string{"province", "city", "district", "category"} {
-		if value, exists := job[name]; exists && value != nil && !isString(value) {
-			return apperrors.NewValidation(fmt.Sprintf("职位 JSON 字段 %s 必须是字符串", name))
-		}
-	}
-	if value, exists := job["campus"]; exists && value != nil {
-		if _, ok := value.(bool); !ok {
-			return apperrors.NewValidation("职位 JSON 字段 campus 必须是布尔值")
-		}
-	}
-	if err := validateRecruitIdentityFields(job); err != nil {
-		return err
-	}
-	if err := validateRecruitAddress(job); err != nil {
-		return err
-	}
-	extData, ok := job["extData"].(map[string]any)
-	if !ok {
-		return apperrors.NewValidation("职位 JSON 字段 extData 必须是对象")
-	}
-	if err := validateRecruitExtData(extData); err != nil {
-		return err
-	}
-	return nil
-}
-
-func optionalRecruitNumber(values map[string]any, name string) (float64, bool, error) {
-	value, exists := values[name]
-	if !exists || value == nil {
-		return 0, false, nil
-	}
-	number, ok := value.(float64)
-	if !ok {
-		return 0, false, apperrors.NewValidation(fmt.Sprintf("职位 JSON 字段 %s 必须是数字", name))
-	}
-	return number, true, nil
-}
-
-func validateRecruitIdentityFields(job map[string]any) error {
-	if _, ok := job["creatorUserId"].(string); !ok {
-		return apperrors.NewValidation("职位 JSON 字段 creatorUserId 必须是非空字符串")
-	}
-	if value, exists := job["ownerUserIds"]; exists && value != nil {
-		ownerUserIDs, ok := value.([]any)
-		if !ok {
-			return apperrors.NewValidation("职位 JSON 字段 ownerUserIds 必须是字符串数组")
-		}
-		for _, owner := range ownerUserIDs {
-			ownerUserID, ok := owner.(string)
-			if !ok || strings.TrimSpace(ownerUserID) == "" {
-				return apperrors.NewValidation("职位 JSON 字段 ownerUserIds 只能包含非空字符串")
-			}
-		}
-	}
-	return nil
-}
-
-func validateRecruitAddress(job map[string]any) error {
-	value, exists := job["address"]
-	if !exists || value == nil {
-		return nil
-	}
-	address, ok := value.(map[string]any)
-	if !ok {
-		return apperrors.NewValidation("职位 JSON 字段 address 必须是对象")
-	}
-	for _, name := range []string{"name", "detail", "longitude", "latitude"} {
-		field, exists := address[name]
-		text, ok := field.(string)
-		if !exists || !ok || strings.TrimSpace(text) == "" {
-			return apperrors.NewValidation(fmt.Sprintf("职位 JSON 字段 address.%s 必须是非空字符串", name))
-		}
-	}
-	return nil
-}
-
-func validateRecruitExtData(extData map[string]any) error {
-	if value, exists := extData["headCount"]; exists && value != nil {
-		headCount, ok := value.(float64)
-		if !ok || headCount < 1 || headCount > 999 || headCount != float64(int(headCount)) {
-			return apperrors.NewValidation("职位 JSON 字段 extData.headCount 必须是 1 到 999 的整数")
-		}
-	}
-	if value, exists := extData["source"]; exists && value != nil && !isString(value) {
-		return apperrors.NewValidation("职位 JSON 字段 extData.source 必须是字符串")
-	}
-	if value, exists := extData["fullTimeExtData"]; exists && value != nil {
-		fullTime, ok := value.(map[string]any)
-		if !ok {
-			return apperrors.NewValidation("职位 JSON 字段 extData.fullTimeExtData 必须是对象")
-		}
-		if err := validateRecruitFullTimeExtData(fullTime); err != nil {
-			return err
-		}
-	}
-	if value, exists := extData["tags"]; exists && value != nil {
-		tags, ok := value.([]any)
-		if !ok {
-			return apperrors.NewValidation("职位 JSON 字段 extData.tags 必须是数组")
-		}
-		for _, value := range tags {
-			tag, ok := value.(map[string]any)
-			if !ok {
-				return apperrors.NewValidation("职位 JSON 字段 extData.tags 只能包含对象")
-			}
-			name, ok := tag["name"].(string)
-			if !ok || strings.TrimSpace(name) == "" {
-				return apperrors.NewValidation("职位 JSON 字段 extData.tags[].name 必须是非空字符串")
-			}
-		}
-	}
-	return nil
-}
-
-func validateRecruitFullTimeExtData(fullTime map[string]any) error {
-	salaryMonth, hasSalaryMonth, err := optionalRecruitNumber(fullTime, "salaryMonth")
-	if err != nil {
-		return err
-	}
-	if hasSalaryMonth && (salaryMonth < 12 || salaryMonth > 24 || salaryMonth != float64(int(salaryMonth))) {
-		return apperrors.NewValidation("职位 JSON 字段 extData.fullTimeExtData.salaryMonth 必须是 12 到 24 的整数")
-	}
-	minExperience, hasMinExperience, err := optionalRecruitNumber(fullTime, "minJobExperience")
-	if err != nil {
-		return err
-	}
-	maxExperience, hasMaxExperience, err := optionalRecruitNumber(fullTime, "maxJobExperience")
-	if err != nil {
-		return err
-	}
-	if hasMinExperience && minExperience < 0 {
-		return apperrors.NewValidation("职位 JSON 字段 extData.fullTimeExtData.minJobExperience 不能小于 0")
-	}
-	if hasMaxExperience && maxExperience < 0 {
-		return apperrors.NewValidation("职位 JSON 字段 extData.fullTimeExtData.maxJobExperience 不能小于 0")
-	}
-	if hasMinExperience && hasMaxExperience && minExperience > maxExperience {
-		return apperrors.NewValidation("职位 JSON 中 minJobExperience 不能大于 maxJobExperience")
-	}
-	return nil
-}
-
-func isString(value any) bool {
-	_, ok := value.(string)
-	return ok
-}

internal/helpers/register_products_test.go

@@ -31,7 +31,7 @@ func TestCrossPlatformCoveragePublicProductCommandsBuildCompleteUniqueTrees(t *t
 	for _, want := range []string{
 		"agoal", "aisearch", "aitable", "attendance", "calendar", "chat",
 		"contact", "devdoc", "ding", "doc", "drive", "live", "mail",
-		"markdown", "minutes", "oa", "recruit", "report", "sheet", "todo", "wiki", "whiteboard",
+		"markdown", "minutes", "oa", "report", "sheet", "todo", "wiki", "whiteboard",
 	} {
 		if !seenProducts[want] {
 			t.Errorf("public product %q was not registered", want)

internal/helpers/register_recruit.go

@@ -1,11 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-
-package helpers
-
-// 招聘是开源库显式维护的公开命令，不依赖生成式产品注册表。
-func init() {
-	RegisterPublic(func() Handler {
-		return wukongHandler{name: "recruit", buildFn: newRecruitCommand}
-	})
-}

internal/helpers/wiki.go

@@ -10,7 +10,6 @@ import (
 	"time"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd/contract"
-	apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -558,17 +557,13 @@ func newWikiCommand() *cobra.Command {
 			if err := validateRequiredFlags(cmd, "role"); err != nil {
 				return err
 			}
-			role := normalizePermissionRole(mustGetFlag(cmd, "role"))
-			if role == "OWNER" {
-				return apperrors.NewValidation("OWNER 角色不可通过 wiki member add 添加")
-			}
 			userIds, err := collectUserIDs(cmd)
 			if err != nil {
 				return err
 			}
 			return callMCPTool("add_member", map[string]any{
 				"workspaceId": workspaceID,
-				"roleId":      role,
+				"roleId":      normalizePermissionRole(mustGetFlag(cmd, "role")),
 				"userIds":     userIds,
 			})
 		},

internal/helpers/wiki_coverage_more_test.go

@@ -1,13 +1,11 @@
 package helpers
 
 import (
-	stderrors "errors"
 	"io"
 	"os"
 	"strings"
 	"testing"
 
-	apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -108,17 +106,10 @@ func TestCrossPlatformCoverageProxySubCommandCoverage(t *testing.T) {
 }
 
 func executeWikiEdge(t *testing.T, args ...string) error {
-	t.Helper()
-	_, err := executeWikiEdgeWithCaller(t, args...)
-	return err
-}
-
-func executeWikiEdgeWithCaller(t *testing.T, args ...string) (*scriptedToolCaller, error) {
 	t.Helper()
 	oldDeps := deps
 	oldArgs := os.Args
-	caller := &scriptedToolCaller{}
-	InitDeps(caller)
+	InitDeps(&scriptedToolCaller{})
 	deps.Out.w = io.Discard
 	deps.Out.errW = io.Discard
 	t.Cleanup(func() {
@@ -134,7 +125,7 @@ func executeWikiEdgeWithCaller(t *testing.T, args ...string) (*scriptedToolCalle
 	root.SetIn(os.Stdin)
 	root.SetArgs(args)
 	os.Args = append([]string{"dws", "wiki"}, args...)
-	return caller, root.Execute()
+	return root.Execute()
 }
 
 func TestCrossPlatformCoverageWikiRoutingAndValidationEdges(t *testing.T) {
@@ -163,20 +154,6 @@ func TestCrossPlatformCoverageWikiRoutingAndValidationEdges(t *testing.T) {
 	}
 }
 
-func TestCrossPlatformCoverageWikiMemberAddRejectsOwner(t *testing.T) {
-	caller, err := executeWikiEdgeWithCaller(t, "member", "add", "--workspace", "space", "--users", "u1", "--role", "OWNER")
-	if err == nil || !strings.Contains(strings.ToUpper(err.Error()), "OWNER") {
-		t.Fatalf("member add OWNER error = %v, want local OWNER rejection", err)
-	}
-	var appErr *apperrors.Error
-	if !stderrors.As(err, &appErr) || appErr.Category != apperrors.CategoryValidation {
-		t.Fatalf("member add OWNER error = %#v, want validation category", err)
-	}
-	if caller.calls != 0 {
-		t.Fatalf("member add OWNER made %d remote calls, want 0", caller.calls)
-	}
-}
-
 func TestCrossPlatformCoverageWikiDeleteCancellationEdges(t *testing.T) {
 	oldStdin := os.Stdin
 	t.Cleanup(func() { os.Stdin = oldStdin })

internal/interfacesnapshot/command_migrations.go

@@ -1,639 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-
-package interfacesnapshot
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-const CommandMigrationManifestVersion = 1
-
-const (
-	CommandMigrationPending  = "pending"
-	CommandMigrationConsumed = "consumed"
-
-	CommandMigrationMove           = "command_move"
-	CommandMigrationFlagExtraction = "flag_extraction"
-)
-
-// CommandMigrationManifest governs compatibility-preserving surface moves that
-// cannot be represented as an in-command flag rename. The merge-base owns the
-// authorization; the candidate copy is only a lifecycle receipt.
-type CommandMigrationManifest struct {
-	Version    int                `json:"version"`
-	Migrations []CommandMigration `json:"migrations"`
-}
-
-type CommandMigration struct {
-	Kind        string                 `json:"kind"`
-	Legacy      CommandMigrationSide   `json:"legacy"`
-	Replacement CommandMigrationSide   `json:"replacement"`
-	LegacyFlag  CommandMigrationFlag   `json:"legacy_flag"`
-	Schema      CommandMigrationSchema `json:"schema"`
-	State       string                 `json:"state"`
-	Reason      string                 `json:"reason"`
-}
-
-type CommandMigrationSide struct {
-	Command string                `json:"command"`
-	Before  CommandMigrationState `json:"before"`
-	After   CommandMigrationState `json:"after"`
-}
-
-type CommandMigrationState struct {
-	Present  bool `json:"present"`
-	Runnable bool `json:"runnable,omitempty"`
-	Hidden   bool `json:"hidden,omitempty"`
-}
-
-type CommandMigrationFlag struct {
-	Name   string             `json:"name,omitempty"`
-	Before FlagMigrationState `json:"before"`
-	After  FlagMigrationState `json:"after"`
-}
-
-type CommandMigrationSchema struct {
-	ProductID         string                      `json:"product_id"`
-	SourceToolID      string                      `json:"source_tool_id"`
-	ReplacementToolID string                      `json:"replacement_tool_id"`
-	Parameters        []CommandParameterMigration `json:"parameters"`
-}
-
-type CommandParameterMigration struct {
-	From                string                      `json:"from"`
-	To                  string                      `json:"to,omitempty"`
-	ReplacementConstant *CommandReplacementConstant `json:"replacement_constant,omitempty"`
-}
-
-type CommandReplacementConstant struct {
-	Property string `json:"property"`
-	Value    bool   `json:"value"`
-}
-
-func ReadCommandMigrationManifest(r io.Reader) (CommandMigrationManifest, error) {
-	data, err := io.ReadAll(r)
-	if err != nil {
-		return CommandMigrationManifest{}, fmt.Errorf("read command migration manifest: %w", err)
-	}
-	var manifest CommandMigrationManifest
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	decoder.DisallowUnknownFields()
-	if err := decoder.Decode(&manifest); err != nil {
-		return CommandMigrationManifest{}, err
-	}
-	if err := decoder.Decode(&struct{}{}); err != io.EOF {
-		if err == nil {
-			return CommandMigrationManifest{}, fmt.Errorf("command migration manifest contains trailing multiple JSON values")
-		}
-		return CommandMigrationManifest{}, fmt.Errorf("read trailing command migration manifest data: %w", err)
-	}
-	strict := json.NewDecoder(bytes.NewReader(data))
-	strict.UseNumber()
-	if err := validateLabeledMigrationJSONValue(strict, "$", reflect.TypeOf(CommandMigrationManifest{}), "command"); err != nil {
-		return CommandMigrationManifest{}, err
-	}
-	if err := manifest.Validate(); err != nil {
-		return CommandMigrationManifest{}, err
-	}
-	return manifest, nil
-}
-
-func (m CommandMigrationManifest) Validate() error {
-	if m.Version != CommandMigrationManifestVersion {
-		return fmt.Errorf("unsupported command migration manifest version %d (want %d)", m.Version, CommandMigrationManifestVersion)
-	}
-	if m.Migrations == nil {
-		return fmt.Errorf("command migration manifest migrations must be an array")
-	}
-	seen := make(map[string]bool, len(m.Migrations))
-	for index, migration := range m.Migrations {
-		if err := migration.validate(); err != nil {
-			return fmt.Errorf("command migration %d: %w", index, err)
-		}
-		if seen[migration.key()] {
-			return fmt.Errorf("command migration %d duplicates %s", index, migration.displayKey())
-		}
-		seen[migration.key()] = true
-	}
-	return nil
-}
-
-func (m CommandMigration) validate() error {
-	if m.Kind != CommandMigrationMove && m.Kind != CommandMigrationFlagExtraction {
-		return fmt.Errorf("invalid kind %q", m.Kind)
-	}
-	if !isExactCommandPath(m.Legacy.Command) || !isExactCommandPath(m.Replacement.Command) {
-		return fmt.Errorf("legacy and replacement must be exact command paths rooted at dws")
-	}
-	if m.Legacy.Command == m.Replacement.Command {
-		return fmt.Errorf("legacy and replacement command paths must differ")
-	}
-	if strings.TrimSpace(m.Reason) == "" || m.Reason != strings.TrimSpace(m.Reason) {
-		return fmt.Errorf("migration must include a non-empty trimmed reason")
-	}
-	if m.State != CommandMigrationPending && m.State != CommandMigrationConsumed {
-		return fmt.Errorf("invalid state %q", m.State)
-	}
-	for label, state := range map[string]CommandMigrationState{
-		"legacy before":      m.Legacy.Before,
-		"legacy after":       m.Legacy.After,
-		"replacement before": m.Replacement.Before,
-		"replacement after":  m.Replacement.After,
-	} {
-		if err := state.validate(label); err != nil {
-			return err
-		}
-	}
-	if !m.Legacy.Before.Present || !m.Legacy.Before.Runnable || m.Legacy.Before.Hidden ||
-		!m.Legacy.After.Present || !m.Legacy.After.Runnable {
-		return fmt.Errorf("legacy command must remain runnable and start visible")
-	}
-	if m.Replacement.Before.Present || !m.Replacement.After.Present || !m.Replacement.After.Runnable || m.Replacement.After.Hidden {
-		return fmt.Errorf("replacement command must migrate exactly from absent to visible runnable")
-	}
-	if err := m.Schema.validate(m.Kind); err != nil {
-		return err
-	}
-	switch m.Kind {
-	case CommandMigrationMove:
-		if strings.HasPrefix(m.Replacement.Command, m.Legacy.Command+" ") ||
-			strings.HasPrefix(m.Legacy.Command, m.Replacement.Command+" ") {
-			return fmt.Errorf("command_move legacy and replacement command paths must not have an ancestor relationship")
-		}
-		if !m.Legacy.After.Hidden {
-			return fmt.Errorf("command_move legacy command must migrate exactly from visible to hidden")
-		}
-		if m.LegacyFlag != (CommandMigrationFlag{}) {
-			return fmt.Errorf("command_move must not declare legacy_flag")
-		}
-		if m.Schema.SourceToolID != m.Schema.ReplacementToolID {
-			return fmt.Errorf("command_move must retain one stable Schema tool identity")
-		}
-	case CommandMigrationFlagExtraction:
-		if m.Legacy.After.Hidden || m.Legacy.Before != m.Legacy.After {
-			return fmt.Errorf("flag_extraction legacy command must remain visible and unchanged")
-		}
-		if err := m.LegacyFlag.validate(); err != nil {
-			return err
-		}
-		if m.Schema.SourceToolID == m.Schema.ReplacementToolID {
-			return fmt.Errorf("flag_extraction requires a distinct replacement Schema tool")
-		}
-		if m.LegacyFlag.Before.Type != "bool" || m.LegacyFlag.After.Type != "bool" {
-			return fmt.Errorf("flag_extraction legacy_flag must be an optional bool")
-		}
-		var extracted *CommandParameterMigration
-		constantCount := 0
-		for index := range m.Schema.Parameters {
-			parameter := &m.Schema.Parameters[index]
-			if parameter.ReplacementConstant == nil {
-				continue
-			}
-			constantCount++
-			if parameter.From == m.LegacyFlag.Name {
-				extracted = parameter
-			}
-		}
-		if constantCount != 1 {
-			return fmt.Errorf("flag_extraction must declare exactly one replacement constant")
-		}
-		if extracted == nil {
-			return fmt.Errorf("flag_extraction must map the exact extracted flag to replacement_constant")
-		}
-		if !extracted.ReplacementConstant.Value {
-			return fmt.Errorf("flag_extraction v1 replacement_constant must be true")
-		}
-		wantNoOpt := strconv.FormatBool(extracted.ReplacementConstant.Value)
-		if m.LegacyFlag.Before.NoOpt != wantNoOpt || m.LegacyFlag.After.NoOpt != wantNoOpt {
-			return fmt.Errorf("flag_extraction legacy_flag no_opt must equal replacement constant %q", wantNoOpt)
-		}
-	}
-	return nil
-}
-
-func (s CommandMigrationState) validate(label string) error {
-	if !s.Present {
-		if s.Runnable || s.Hidden {
-			return fmt.Errorf("%s absent state must not declare command attributes", label)
-		}
-		return nil
-	}
-	if !s.Runnable {
-		return fmt.Errorf("%s present state must be runnable", label)
-	}
-	return nil
-}
-
-func (f CommandMigrationFlag) validate() error {
-	if !isExactFlagName(f.Name) {
-		return fmt.Errorf("legacy_flag name must be an exact flag")
-	}
-	if err := f.Before.validate("legacy_flag before"); err != nil {
-		return err
-	}
-	if err := f.After.validate("legacy_flag after"); err != nil {
-		return err
-	}
-	if !f.Before.Present || !f.After.Present || f.Before.Hidden || !f.After.Hidden {
-		return fmt.Errorf("legacy_flag must migrate exactly from visible to hidden while remaining present")
-	}
-	if f.Before.Required || f.After.Required {
-		return fmt.Errorf("legacy_flag must remain optional before and after extraction")
-	}
-	before := f.Before
-	after := f.After
-	before.Hidden = false
-	after.Hidden = false
-	if before != after {
-		return fmt.Errorf("legacy_flag may change only hidden visibility")
-	}
-	return nil
-}
-
-func (s CommandMigrationSchema) validate(kind string) error {
-	for label, value := range map[string]string{
-		"product_id":          s.ProductID,
-		"source_tool_id":      s.SourceToolID,
-		"replacement_tool_id": s.ReplacementToolID,
-	} {
-		if !isExactSchemaIdentifier(value) {
-			return fmt.Errorf("schema %s must be an exact identifier", label)
-		}
-	}
-	if s.Parameters == nil {
-		return fmt.Errorf("schema parameters must be an array")
-	}
-	seenFrom := map[string]bool{}
-	seenTo := map[string]bool{}
-	seenConstantProperty := map[string]bool{}
-	for index, parameter := range s.Parameters {
-		if !isExactFlagName(parameter.From) {
-			return fmt.Errorf("schema parameter %d from must be an exact parameter name", index)
-		}
-		if seenFrom[parameter.From] {
-			return fmt.Errorf("schema parameter %d duplicates from %q", index, parameter.From)
-		}
-		seenFrom[parameter.From] = true
-		if kind == CommandMigrationMove {
-			if parameter.ReplacementConstant != nil {
-				return fmt.Errorf("command_move schema parameter %d must not declare replacement_constant", index)
-			}
-			if !isExactFlagName(parameter.To) || parameter.To == parameter.From {
-				return fmt.Errorf("command_move schema parameter %d requires a distinct exact to name", index)
-			}
-			if seenTo[parameter.To] {
-				return fmt.Errorf("schema parameter %d duplicates to %q", index, parameter.To)
-			}
-			seenTo[parameter.To] = true
-			continue
-		}
-		if kind != CommandMigrationFlagExtraction {
-			return fmt.Errorf("invalid command migration kind %q", kind)
-		}
-
-		hasTo := parameter.To != ""
-		hasConstant := parameter.ReplacementConstant != nil
-		if !hasTo && !hasConstant {
-			return fmt.Errorf("flag_extraction schema parameter %d requires an exact to or replacement_constant", index)
-		}
-		if hasTo && hasConstant {
-			return fmt.Errorf("flag_extraction schema parameter %d must declare exactly one target", index)
-		}
-		if hasTo {
-			if !isExactFlagName(parameter.To) {
-				return fmt.Errorf("flag_extraction schema parameter %d to must be an exact parameter name", index)
-			}
-			if seenTo[parameter.To] {
-				return fmt.Errorf("schema parameter %d duplicates to %q", index, parameter.To)
-			}
-			if seenConstantProperty[parameter.To] {
-				return fmt.Errorf("schema parameter %d duplicates parameter target %q", index, parameter.To)
-			}
-			seenTo[parameter.To] = true
-			continue
-		}
-		property := parameter.ReplacementConstant.Property
-		if !isExactSchemaIdentifier(property) {
-			return fmt.Errorf("flag_extraction schema parameter %d replacement_constant requires an exact property", index)
-		}
-		if seenConstantProperty[property] {
-			return fmt.Errorf("schema parameter %d duplicates replacement_constant property %q", index, property)
-		}
-		if seenTo[property] {
-			return fmt.Errorf("schema parameter %d duplicates parameter target %q", index, property)
-		}
-		seenConstantProperty[property] = true
-	}
-	return nil
-}
-
-func isExactSchemaIdentifier(value string) bool {
-	return value != "" && value == strings.TrimSpace(value) &&
-		!strings.ContainsAny(value, "*?[]{} /\\\t\r\n")
-}
-
-func (m CommandMigration) key() string {
-	return strings.Join([]string{m.Kind, m.Legacy.Command, m.Replacement.Command, m.Schema.ProductID, m.Schema.SourceToolID, m.Schema.ReplacementToolID}, "\x00")
-}
-
-func (m CommandMigration) displayKey() string {
-	return fmt.Sprintf("%s %q -> %q", m.Kind, m.Legacy.Command, m.Replacement.Command)
-}
-
-type commandMigrationPhase string
-
-const (
-	commandMigrationBefore  commandMigrationPhase = "before"
-	commandMigrationAfter   commandMigrationPhase = "after"
-	commandMigrationPartial commandMigrationPhase = "partial"
-)
-
-func AuthorizeCommandMigrations(
-	current Snapshot,
-	references map[string]Snapshot,
-	authority CommandMigrationManifest,
-	candidate CommandMigrationManifest,
-) ([]CommandMigration, error) {
-	if err := current.Validate(); err != nil {
-		return nil, fmt.Errorf("validate current interface snapshot: %w", err)
-	}
-	for label, snapshot := range references {
-		if err := snapshot.Validate(); err != nil {
-			return nil, fmt.Errorf("validate %s interface snapshot: %w", label, err)
-		}
-	}
-	if err := authority.Validate(); err != nil {
-		return nil, fmt.Errorf("validate approved command migrations: %w", err)
-	}
-	if err := candidate.Validate(); err != nil {
-		return nil, fmt.Errorf("validate candidate command migrations: %w", err)
-	}
-	type commandMoveTopologyCheck struct {
-		label    string
-		snapshot Snapshot
-		manifest CommandMigrationManifest
-	}
-	topologyChecks := []commandMoveTopologyCheck{
-		{label: "approved", snapshot: current, manifest: authority},
-		{label: "candidate", snapshot: current, manifest: candidate},
-	}
-	if mergeBase, _, ok := flagMigrationAuthoritySnapshot(references); ok {
-		topologyChecks = append(topologyChecks,
-			commandMoveTopologyCheck{label: "approved base", snapshot: mergeBase, manifest: authority},
-			commandMoveTopologyCheck{label: "candidate base", snapshot: mergeBase, manifest: candidate},
-		)
-	}
-	for _, check := range topologyChecks {
-		if err := validateCommandMoveLegacyLeaves(check.snapshot, check.manifest); err != nil {
-			return nil, fmt.Errorf("validate %s command migration topology: %w", check.label, err)
-		}
-	}
-	return evaluateCommandMigrationLifecycle(current, references, authority, candidate)
-}
-
-func validateCommandMoveLegacyLeaves(snapshot Snapshot, manifest CommandMigrationManifest) error {
-	commands := commandIndex(snapshot)
-	for _, migration := range manifest.Migrations {
-		if migration.Kind != CommandMigrationMove {
-			continue
-		}
-		if _, present := commands[migration.Legacy.Command]; !present {
-			continue
-		}
-		for _, command := range snapshot.Commands {
-			if strings.HasPrefix(command.Path, migration.Legacy.Command+" ") {
-				return fmt.Errorf("command_move legacy command %q must be a leaf", migration.Legacy.Command)
-			}
-		}
-	}
-	return nil
-}
-
-func evaluateCommandMigrationLifecycle(
-	current Snapshot,
-	references map[string]Snapshot,
-	authority CommandMigrationManifest,
-	candidate CommandMigrationManifest,
-) ([]CommandMigration, error) {
-	if len(authority.Migrations) == 0 && len(candidate.Migrations) == 0 {
-		return nil, nil
-	}
-	if _, ok := references["stable"]; !ok {
-		return nil, fmt.Errorf("command migration lifecycle requires a stable reference")
-	}
-	mergeBase, label, ok := flagMigrationAuthoritySnapshot(references)
-	if !ok {
-		return nil, fmt.Errorf("command migration lifecycle requires a main or merge-base reference")
-	}
-	authorityByKey := commandMigrationIndex(authority)
-	candidateByKey := commandMigrationIndex(candidate)
-	authorizations := make([]CommandMigration, 0, len(authority.Migrations))
-	for _, approved := range authority.Migrations {
-		basePhase := matchCommandMigrationPhase(mergeBase, approved)
-		wantBase := commandMigrationBefore
-		if approved.State == CommandMigrationConsumed {
-			wantBase = commandMigrationAfter
-		}
-		if basePhase != wantBase {
-			return nil, fmt.Errorf("approved command migration %s is %s in %s, want exact %s state for %s", approved.displayKey(), basePhase, label, wantBase, approved.State)
-		}
-		proposed, exists := candidateByKey[approved.key()]
-		if exists && !sameCommandMigrationApproval(approved, proposed) {
-			return nil, fmt.Errorf("candidate modified base-owned command migration %s", approved.displayKey())
-		}
-		currentPhase := matchCommandMigrationPhase(current, approved)
-		switch approved.State {
-		case CommandMigrationPending:
-			if !exists {
-				return nil, fmt.Errorf("candidate removed pending command migration %s", approved.displayKey())
-			}
-			switch currentPhase {
-			case commandMigrationBefore:
-				if proposed.State != CommandMigrationPending {
-					return nil, fmt.Errorf("candidate falsely consumed unchanged command migration %s", approved.displayKey())
-				}
-			case commandMigrationAfter:
-				if proposed.State != CommandMigrationConsumed {
-					return nil, fmt.Errorf("candidate completed command migration %s without marking it consumed", approved.displayKey())
-				}
-				authorizations = append(authorizations, approved)
-			default:
-				return nil, fmt.Errorf("candidate partially applied command migration %s", approved.displayKey())
-			}
-		case CommandMigrationConsumed:
-			if currentPhase != commandMigrationAfter {
-				return nil, fmt.Errorf("candidate drifted from consumed command migration %s", approved.displayKey())
-			}
-			allAfter := true
-			for _, reference := range references {
-				if matchCommandMigrationPhase(reference, approved) != commandMigrationAfter {
-					allAfter = false
-					break
-				}
-			}
-			if allAfter {
-				if exists {
-					return nil, fmt.Errorf("consumed command migration %s is stale after all references reached the after state", approved.displayKey())
-				}
-				continue
-			}
-			if !exists || proposed.State != CommandMigrationConsumed {
-				return nil, fmt.Errorf("candidate must retain consumed command migration %s until every reference reaches the after state", approved.displayKey())
-			}
-			authorizations = append(authorizations, approved)
-		}
-	}
-	for _, proposed := range candidate.Migrations {
-		if _, exists := authorityByKey[proposed.key()]; exists {
-			continue
-		}
-		if proposed.State != CommandMigrationPending {
-			return nil, fmt.Errorf("candidate-added command migration %s must start pending", proposed.displayKey())
-		}
-		if matchCommandMigrationPhase(mergeBase, proposed) != commandMigrationBefore {
-			return nil, fmt.Errorf("candidate-added command migration %s does not match the merge-base before state", proposed.displayKey())
-		}
-		if matchCommandMigrationPhase(current, proposed) != commandMigrationBefore {
-			return nil, fmt.Errorf("candidate-added command migration %s cannot authorize its own interface change", proposed.displayKey())
-		}
-	}
-	return authorizations, nil
-}
-
-func commandMigrationIndex(manifest CommandMigrationManifest) map[string]CommandMigration {
-	index := make(map[string]CommandMigration, len(manifest.Migrations))
-	for _, migration := range manifest.Migrations {
-		index[migration.key()] = migration
-	}
-	return index
-}
-
-func sameCommandMigrationApproval(left, right CommandMigration) bool {
-	left.State = ""
-	right.State = ""
-	return reflect.DeepEqual(left, right)
-}
-
-func matchCommandMigrationPhase(snapshot Snapshot, migration CommandMigration) commandMigrationPhase {
-	commands := commandIndex(snapshot)
-	legacy := commandMigrationStateForCommand(commands, migration.Legacy.Command)
-	replacement := commandMigrationStateForCommand(commands, migration.Replacement.Command)
-	before := legacy == migration.Legacy.Before && replacement == migration.Replacement.Before
-	after := legacy == migration.Legacy.After && replacement == migration.Replacement.After
-	if migration.Kind == CommandMigrationFlagExtraction {
-		command, exists := commands[migration.Legacy.Command]
-		flagState := FlagMigrationState{}
-		if exists {
-			flagState = flagMigrationStateForCommand(command, migration.LegacyFlag.Name)
-		}
-		before = before && flagState == migration.LegacyFlag.Before
-		after = after && flagState == migration.LegacyFlag.After
-		if replacement, replacementExists := commands[migration.Replacement.Command]; replacementExists {
-			after = after && commandMigrationReplacementConstantsMatch(replacement, migration)
-		} else {
-			after = false
-		}
-	}
-	if before {
-		return commandMigrationBefore
-	}
-	if after {
-		return commandMigrationAfter
-	}
-	return commandMigrationPartial
-}
-
-func commandMigrationReplacementConstantsMatch(command Command, migration CommandMigration) bool {
-	expected := make(map[string]bool)
-	for _, parameter := range migration.Schema.Parameters {
-		if parameter.ReplacementConstant == nil {
-			continue
-		}
-		expected[parameter.ReplacementConstant.Property] = parameter.ReplacementConstant.Value
-	}
-	return reflect.DeepEqual(command.BoolConstParams, expected)
-}
-
-func commandMigrationStateForCommand(commands map[string]Command, path string) CommandMigrationState {
-	command, exists := commands[path]
-	if !exists {
-		return CommandMigrationState{}
-	}
-	return CommandMigrationState{Present: true, Runnable: command.Runnable, Hidden: command.Hidden}
-}
-
-// CompareAllWithInterfaceMigrations applies both migration families to one
-// ordinary report, so the two ledgers cannot mask each other's unrelated
-// findings.
-func CompareAllWithInterfaceMigrations(
-	current Snapshot,
-	references map[string]Snapshot,
-	flagAuthority FlagMigrationManifest,
-	flagCandidate FlagMigrationManifest,
-	commandAuthority CommandMigrationManifest,
-	commandCandidate CommandMigrationManifest,
-) (Report, error) {
-	flagAuthorizations, err := AuthorizeFlagMigrations(current, references, flagAuthority, flagCandidate)
-	if err != nil {
-		return Report{}, err
-	}
-	commandAuthorizations, err := AuthorizeCommandMigrations(current, references, commandAuthority, commandCandidate)
-	if err != nil {
-		return Report{}, err
-	}
-	report := CompareAll(current, references)
-	for index := range report.Comparisons {
-		comparison := &report.Comparisons[index]
-		reference := references[comparison.Reference]
-		filtered := comparison.Blocking[:0]
-		for _, change := range comparison.Blocking {
-			if flagMigrationAuthorizesChange(current, reference, change, flagAuthorizations) ||
-				commandMigrationAuthorizesChange(current, reference, change, commandAuthorizations) {
-				continue
-			}
-			filtered = append(filtered, change)
-		}
-		comparison.Blocking = filtered
-		comparison.Compatible = len(filtered) == 0
-	}
-	report.Compatible = true
-	for _, comparison := range report.Comparisons {
-		if !comparison.Compatible {
-			report.Compatible = false
-			break
-		}
-	}
-	return report, nil
-}
-
-func commandMigrationAuthorizesChange(current, reference Snapshot, change Change, authorizations []CommandMigration) bool {
-	canonicalPath := acceptedPathIndex(reference)[change.Path]
-	if canonicalPath == "" {
-		canonicalPath = change.Path
-	}
-	for _, migration := range authorizations {
-		if canonicalPath != migration.Legacy.Command ||
-			matchCommandMigrationPhase(reference, migration) != commandMigrationBefore ||
-			matchCommandMigrationPhase(current, migration) != commandMigrationAfter {
-			continue
-		}
-		switch migration.Kind {
-		case CommandMigrationMove:
-			if change.Kind == "command_became_hidden" && change.Flag == "" {
-				return true
-			}
-		case CommandMigrationFlagExtraction:
-			if change.Kind == "flag_became_hidden" && change.Flag == migration.LegacyFlag.Name {
-				return true
-			}
-		}
-	}
-	return false
-}

internal/interfacesnapshot/command_migrations_test.go

@@ -1,744 +0,0 @@
-// Copyright 2026 Alibaba Group
-// Licensed under the Apache License, Version 2.0 (the "License");
-
-package interfacesnapshot
-
-import (
-	"errors"
-	"os"
-	"strings"
-	"testing"
-)
-
-type commandMigrationErrorReader struct{}
-
-func (commandMigrationErrorReader) Read([]byte) (int, error) {
-	return 0, errors.New("command migration read failure")
-}
-
-func TestApprovedCommandMigrationManifestRemainsValid(t *testing.T) {
-	manifest, err := os.Open("../../scripts/policy/interface-migrations/approved-command-migrations-v1.json")
-	if err != nil {
-		t.Fatalf("open approved command migration manifest: %v", err)
-	}
-	defer manifest.Close()
-	if _, err := ReadCommandMigrationManifest(manifest); err != nil {
-		t.Fatalf("approved command migration manifest is invalid: %v", err)
-	}
-}
-
-func TestCrossPlatformCoverageReadCommandMigrationManifestFailsClosed(t *testing.T) {
-	valid := commandMigrationManifestJSON()
-	if _, err := ReadCommandMigrationManifest(strings.NewReader(valid)); err != nil {
-		t.Fatalf("valid command migration manifest: %v", err)
-	}
-	validExtraction := flagExtractionCommandMigrationManifestJSON()
-	if _, err := ReadCommandMigrationManifest(strings.NewReader(validExtraction)); err != nil {
-		t.Fatalf("valid flag extraction command migration manifest: %v", err)
-	}
-	for _, test := range []struct {
-		input string
-		want  string
-	}{
-		{strings.Replace(valid, `"state": "pending"`, `"state": "pending", "allow": true`, 1), "unknown field"},
-		{strings.Replace(valid, `"state": "pending"`, `"state": "pending", "state": "consumed"`, 1), "duplicate field"},
-		{strings.Replace(valid, `"version": 1`, `"version": null`, 1), "must be"},
-		{strings.Replace(valid, "dws chat message old", "dws chat *", 1), "exact command paths"},
-		{strings.Replace(valid, `"kind": "command_move"`, `"kind": "anything"`, 1), "invalid kind"},
-		{`{"version":1,"migrations":null}`, "must be an array"},
-		{strings.Replace(validExtraction, `"replacement_constant":{"property":"convThreadEnabled","value":true}`, `"replacement_constant":null`, 1), "must be an object"},
-		{strings.Replace(validExtraction, `,"value":true`, ``, 1), `must be true`},
-		{strings.Replace(validExtraction, `"value":true`, `"value":"true"`, 1), "bool"},
-	} {
-		if _, err := ReadCommandMigrationManifest(strings.NewReader(test.input)); err == nil || !strings.Contains(err.Error(), test.want) {
-			t.Fatalf("ReadCommandMigrationManifest() error=%v, want %q", err, test.want)
-		}
-	}
-	if _, err := ReadCommandMigrationManifest(commandMigrationErrorReader{}); err == nil || !strings.Contains(err.Error(), "read failure") {
-		t.Fatalf("reader error=%v", err)
-	}
-	for _, input := range []string{valid + ` {}`, valid + ` {`} {
-		if _, err := ReadCommandMigrationManifest(strings.NewReader(input)); err == nil || !strings.Contains(err.Error(), "trailing") {
-			t.Fatalf("trailing input error=%v", err)
-		}
-	}
-}
-
-func TestCrossPlatformCoverageCommandMigrationValidationEdges(t *testing.T) {
-	validMove := commandMigrationManifest(CommandMigrationPending).Migrations[0]
-	validExtraction := commandMigrationManifest(CommandMigrationPending).Migrations[1]
-
-	duplicate := CommandMigrationManifest{Version: CommandMigrationManifestVersion, Migrations: []CommandMigration{validMove, validMove}}
-	if err := duplicate.Validate(); err == nil || !strings.Contains(err.Error(), "duplicates") {
-		t.Fatalf("duplicate error=%v", err)
-	}
-	if err := (CommandMigrationManifest{Version: CommandMigrationManifestVersion}).Validate(); err == nil || !strings.Contains(err.Error(), "must be an array") {
-		t.Fatalf("nil migrations error=%v", err)
-	}
-
-	for _, test := range []struct {
-		name   string
-		mutate func(*CommandMigration)
-		want   string
-	}{
-		{"same command", func(m *CommandMigration) { m.Replacement.Command = m.Legacy.Command }, "must differ"},
-		{"empty reason", func(m *CommandMigration) { m.Reason = " " }, "non-empty trimmed"},
-		{"invalid state", func(m *CommandMigration) { m.State = "approved" }, "invalid state"},
-		{"invalid command state", func(m *CommandMigration) { m.Replacement.Before.Runnable = true }, "absent state"},
-		{"legacy contract", func(m *CommandMigration) { m.Legacy.Before.Hidden = true }, "remain runnable"},
-		{"replacement contract", func(m *CommandMigration) { m.Replacement.After.Hidden = true }, "absent to visible"},
-		{"schema contract", func(m *CommandMigration) { m.Schema.ProductID = "bad/id" }, "exact identifier"},
-		{"move not hidden", func(m *CommandMigration) { m.Legacy.After.Hidden = false }, "must migrate exactly"},
-		{"move flag", func(m *CommandMigration) { m.LegacyFlag.Name = "thread" }, "must not declare legacy_flag"},
-		{"move tool identity", func(m *CommandMigration) { m.Schema.ReplacementToolID = "chat.new" }, "stable Schema tool"},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			migration := validMove
-			test.mutate(&migration)
-			if err := migration.validate(); err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("validate error=%v, want %q", err, test.want)
-			}
-		})
-	}
-	for _, test := range []struct {
-		name   string
-		mutate func(*CommandMigration)
-		want   string
-	}{
-		{"legacy changed", func(m *CommandMigration) { m.Legacy.After.Hidden = true }, "remain visible"},
-		{"invalid legacy flag", func(m *CommandMigration) { m.LegacyFlag.Name = "bad name" }, "exact flag"},
-		{"same tool", func(m *CommandMigration) { m.Schema.ReplacementToolID = m.Schema.SourceToolID }, "distinct replacement"},
-		{"wrong parameter", func(m *CommandMigration) { m.Schema.Parameters[3].From = "other" }, "exact extracted flag"},
-		{"wrong type", func(m *CommandMigration) {
-			m.LegacyFlag.Before.Type = "string"
-			m.LegacyFlag.After.Type = "string"
-		}, "optional bool"},
-		{"wrong no opt", func(m *CommandMigration) {
-			m.LegacyFlag.Before.NoOpt = "false"
-			m.LegacyFlag.After.NoOpt = "false"
-		}, "no_opt"},
-		{"missing extracted mapping", func(m *CommandMigration) {
-			m.Schema.Parameters = m.Schema.Parameters[:3]
-		}, "exactly one replacement constant"},
-		{"duplicate extracted mapping", func(m *CommandMigration) {
-			m.Schema.Parameters = append(m.Schema.Parameters, m.Schema.Parameters[3])
-		}, "duplicates from"},
-		{"multiple constants", func(m *CommandMigration) {
-			m.Schema.Parameters[0] = CommandParameterMigration{
-				From: "name",
-				ReplacementConstant: &CommandReplacementConstant{
-					Property: "name",
-					Value:    true,
-				},
-			}
-		}, "exactly one replacement constant"},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			migration := cloneCommandMigration(validExtraction)
-			test.mutate(&migration)
-			if err := migration.validate(); err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("validate error=%v, want %q", err, test.want)
-			}
-		})
-	}
-	falseConstant := cloneCommandMigration(validExtraction)
-	falseConstant.Schema.Parameters[3].ReplacementConstant.Value = false
-	falseConstant.LegacyFlag.Before.NoOpt = "false"
-	falseConstant.LegacyFlag.After.NoOpt = "false"
-	if err := falseConstant.validate(); err == nil || !strings.Contains(err.Error(), "must be true") {
-		t.Fatalf("false replacement constant validation error=%v, want v1 true-only rejection", err)
-	}
-
-	for _, state := range []CommandMigrationState{
-		{Runnable: true},
-		{Present: true},
-	} {
-		if err := state.validate("state"); err == nil {
-			t.Fatalf("invalid command state accepted: %#v", state)
-		}
-	}
-
-	for _, test := range []struct {
-		name   string
-		mutate func(*CommandMigrationFlag)
-		want   string
-	}{
-		{"name", func(f *CommandMigrationFlag) { f.Name = "bad name" }, "exact flag"},
-		{"before state", func(f *CommandMigrationFlag) { f.Before = FlagMigrationState{Present: true} }, "requires type"},
-		{"after state", func(f *CommandMigrationFlag) { f.After = FlagMigrationState{Present: true} }, "requires type"},
-		{"visibility", func(f *CommandMigrationFlag) { f.After.Hidden = false }, "visible to hidden"},
-		{"attribute", func(f *CommandMigrationFlag) { f.After.Type = "string" }, "only hidden visibility"},
-	} {
-		t.Run("flag "+test.name, func(t *testing.T) {
-			flag := validExtraction.LegacyFlag
-			test.mutate(&flag)
-			if err := flag.validate(); err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("flag validate error=%v, want %q", err, test.want)
-			}
-		})
-	}
-
-	validSchema := validMove.Schema
-	for _, test := range []struct {
-		name   string
-		kind   string
-		mutate func(*CommandMigrationSchema)
-		want   string
-	}{
-		{"identifier", CommandMigrationMove, func(s *CommandMigrationSchema) { s.ProductID = "bad/id" }, "exact identifier"},
-		{"nil parameters", CommandMigrationMove, func(s *CommandMigrationSchema) { s.Parameters = nil }, "must be an array"},
-		{"bad from", CommandMigrationMove, func(s *CommandMigrationSchema) { s.Parameters[0].From = "bad name" }, "exact parameter"},
-		{"duplicate from", CommandMigrationMove, func(s *CommandMigrationSchema) { s.Parameters = append(s.Parameters, s.Parameters[0]) }, "duplicates from"},
-		{"bad to", CommandMigrationMove, func(s *CommandMigrationSchema) { s.Parameters[0].To = s.Parameters[0].From }, "distinct exact"},
-		{"duplicate to", CommandMigrationMove, func(s *CommandMigrationSchema) {
-			s.Parameters = append(s.Parameters, CommandParameterMigration{From: "other", To: s.Parameters[0].To})
-		}, "duplicates to"},
-		{"move constant", CommandMigrationMove, func(s *CommandMigrationSchema) {
-			s.Parameters[0].ReplacementConstant = &CommandReplacementConstant{Property: "property", Value: true}
-		}, "must not declare replacement_constant"},
-		{"invalid kind", "anything", func(*CommandMigrationSchema) {}, "invalid command migration kind"},
-	} {
-		t.Run("schema "+test.name, func(t *testing.T) {
-			schema := validSchema
-			schema.Parameters = append([]CommandParameterMigration(nil), validSchema.Parameters...)
-			test.mutate(&schema)
-			if err := schema.validate(test.kind); err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("schema validate error=%v, want %q", err, test.want)
-			}
-		})
-	}
-
-	for _, test := range []struct {
-		name   string
-		mutate func(*CommandMigrationSchema)
-		want   string
-	}{
-		{"missing target", func(s *CommandMigrationSchema) { s.Parameters[0].To = "" }, "requires an exact to or replacement_constant"},
-		{"both targets", func(s *CommandMigrationSchema) {
-			s.Parameters[0].ReplacementConstant = &CommandReplacementConstant{Property: "name", Value: true}
-		}, "exactly one target"},
-		{"bad to", func(s *CommandMigrationSchema) { s.Parameters[0].To = "bad name" }, "to must be an exact parameter name"},
-		{"bad constant property", func(s *CommandMigrationSchema) { s.Parameters[3].ReplacementConstant.Property = "bad/property" }, "exact property"},
-		{"duplicate parameter target", func(s *CommandMigrationSchema) { s.Parameters[1].To = s.Parameters[0].To }, "duplicates to"},
-		{"duplicate constant target", func(s *CommandMigrationSchema) {
-			s.Parameters[0] = CommandParameterMigration{From: "name", ReplacementConstant: &CommandReplacementConstant{Property: "convThreadEnabled", Value: true}}
-		}, "duplicates replacement_constant property"},
-		{"constant before parameter target", func(s *CommandMigrationSchema) {
-			s.Parameters[3].ReplacementConstant.Property = "name"
-			s.Parameters[0], s.Parameters[3] = s.Parameters[3], s.Parameters[0]
-		}, "duplicates parameter target"},
-		{"parameter target before constant", func(s *CommandMigrationSchema) {
-			s.Parameters[3].ReplacementConstant.Property = "name"
-		}, "duplicates parameter target"},
-	} {
-		t.Run("extraction schema "+test.name, func(t *testing.T) {
-			schema := cloneCommandMigration(validExtraction).Schema
-			test.mutate(&schema)
-			if err := schema.validate(CommandMigrationFlagExtraction); err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("schema validate error=%v, want %q", err, test.want)
-			}
-		})
-	}
-}
-
-func TestCrossPlatformCoverageFlagExtractionRejectsRequiredLegacyFlag(t *testing.T) {
-	for _, test := range []struct {
-		name   string
-		mutate func(*CommandMigrationFlag)
-	}{
-		{"before required", func(flag *CommandMigrationFlag) { flag.Before.Required = true }},
-		{"after required", func(flag *CommandMigrationFlag) { flag.After.Required = true }},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			migration := commandMigrationManifest(CommandMigrationPending).Migrations[1]
-			test.mutate(&migration.LegacyFlag)
-
-			if err := migration.validate(); err == nil || !strings.Contains(err.Error(), "optional") {
-				t.Fatalf("required legacy flag validation error=%v, want optional-only rejection", err)
-			}
-		})
-	}
-}
-
-func TestCrossPlatformCoverageCommandMoveRejectsRunnableParent(t *testing.T) {
-	migration := commandMigrationManifest(CommandMigrationPending).Migrations[0]
-	migration.Legacy.Command = "dws agoal"
-	migration.Replacement.Command = "dws goal"
-	migration.Schema = CommandMigrationSchema{
-		ProductID:         "agoal",
-		SourceToolID:      "agoal.root",
-		ReplacementToolID: "agoal.root",
-		Parameters:        []CommandParameterMigration{},
-	}
-	authority := CommandMigrationManifest{
-		Version:    CommandMigrationManifestVersion,
-		Migrations: []CommandMigration{migration},
-	}
-	consumed := authority
-	consumed.Migrations = append([]CommandMigration(nil), authority.Migrations...)
-	consumed.Migrations[0].State = CommandMigrationConsumed
-
-	before := testSnapshot(
-		testCommand("dws"),
-		testCommand("dws agoal"),
-		testCommand("dws agoal strategy"),
-		testCommand("dws agoal strategy list"),
-	)
-	after := testSnapshot(
-		testCommand("dws"),
-		Command{Path: "dws agoal", Runnable: true, Hidden: true},
-		testCommand("dws goal"),
-	)
-
-	_, err := AuthorizeCommandMigrations(
-		after,
-		map[string]Snapshot{"merge-base": before, "stable": before},
-		authority,
-		consumed,
-	)
-	if err == nil || !strings.Contains(err.Error(), "must be a leaf") {
-		t.Fatalf("runnable parent command_move error=%v, want leaf-only rejection", err)
-	}
-}
-
-func TestCrossPlatformCoverageCommandMoveAllowsReplacementParent(t *testing.T) {
-	before := commandMigrationSnapshot(false, false)
-	after := commandMigrationSnapshot(true, false)
-	after.Commands = append(after.Commands, testCommand("dws chat topic new detail"))
-	pending := singleCommandMigrationManifest(CommandMigrationPending)
-	consumed := singleCommandMigrationManifest(CommandMigrationConsumed)
-	if err := validateCommandMoveLegacyLeaves(testSnapshot(testCommand("dws")), pending); err != nil {
-		t.Fatalf("absent legacy topology should remain a lifecycle concern: %v", err)
-	}
-
-	got, err := AuthorizeCommandMigrations(
-		after,
-		map[string]Snapshot{"merge-base": before, "stable": before},
-		pending,
-		consumed,
-	)
-	if err != nil {
-		t.Fatalf("replacement parent command_move was rejected: %v", err)
-	}
-	if len(got) != 1 {
-		t.Fatalf("replacement parent command_move authorizations=%d, want 1", len(got))
-	}
-}
-
-func TestCrossPlatformCoverageCommandMoveRejectsAncestorOverlap(t *testing.T) {
-	for _, test := range []struct {
-		name        string
-		legacy      string
-		replacement string
-	}{
-		{
-			name:        "legacy ancestor",
-			legacy:      "dws chat message",
-			replacement: "dws chat message list",
-		},
-		{
-			name:        "replacement ancestor",
-			legacy:      "dws chat message list",
-			replacement: "dws chat message",
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			migration := commandMigrationManifest(CommandMigrationPending).Migrations[0]
-			migration.Legacy.Command = test.legacy
-			migration.Replacement.Command = test.replacement
-
-			if err := migration.validate(); err == nil || !strings.Contains(err.Error(), "must not have an ancestor relationship") {
-				t.Fatalf("overlapping command_move error=%v, want ancestor-overlap rejection", err)
-			}
-		})
-	}
-}
-
-func TestCrossPlatformCoverageCommandMigrationLifecycleEdges(t *testing.T) {
-	before := commandMigrationSnapshot(false, false)
-	after := commandMigrationSnapshot(true, false)
-	partial := commandMigrationSnapshot(false, false)
-	partial.Commands = append(partial.Commands, testCommand("dws chat topic new"))
-	pending := singleCommandMigrationManifest(CommandMigrationPending)
-	consumed := singleCommandMigrationManifest(CommandMigrationConsumed)
-	empty := CommandMigrationManifest{Version: CommandMigrationManifestVersion, Migrations: []CommandMigration{}}
-
-	if got, err := AuthorizeCommandMigrations(before, map[string]Snapshot{}, empty, empty); err != nil || len(got) != 0 {
-		t.Fatalf("empty lifecycle=%#v, %v", got, err)
-	}
-	for _, test := range []struct {
-		name       string
-		current    Snapshot
-		references map[string]Snapshot
-		authority  CommandMigrationManifest
-		candidate  CommandMigrationManifest
-		want       string
-	}{
-		{"missing stable", before, map[string]Snapshot{"main": before}, pending, pending, "stable reference"},
-		{"missing base", before, map[string]Snapshot{"stable": before}, pending, pending, "main or merge-base"},
-		{"pending base after", after, map[string]Snapshot{"main": after, "stable": before}, pending, pending, "want exact before"},
-		{"modified approval", before, map[string]Snapshot{"main": before, "stable": before}, pending, modifiedCommandManifest(pending), "modified base-owned"},
-		{"pending removed", before, map[string]Snapshot{"main": before, "stable": before}, pending, empty, "removed pending"},
-		{"false consumed", before, map[string]Snapshot{"main": before, "stable": before}, pending, consumed, "falsely consumed"},
-		{"after pending receipt", after, map[string]Snapshot{"main": before, "stable": before}, pending, pending, "without marking it consumed"},
-		{"partial", partial, map[string]Snapshot{"main": before, "stable": before}, pending, consumed, "partially applied"},
-		{"consumed drift", before, map[string]Snapshot{"main": after, "stable": before}, consumed, consumed, "drifted from consumed"},
-		{"stale receipt", after, map[string]Snapshot{"main": after, "stable": after}, consumed, consumed, "stale after all references"},
-		{"early cleanup", after, map[string]Snapshot{"main": after, "stable": before}, consumed, empty, "must retain consumed"},
-		{"consumed back to pending", after, map[string]Snapshot{"main": after, "stable": before}, consumed, pending, "must retain consumed"},
-		{"candidate added consumed", after, map[string]Snapshot{"main": before, "stable": before}, empty, consumed, "must start pending"},
-		{"candidate base mismatch", before, map[string]Snapshot{"main": after, "stable": before}, empty, pending, "does not match"},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			_, err := AuthorizeCommandMigrations(test.current, test.references, test.authority, test.candidate)
-			if err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("lifecycle error=%v, want %q", err, test.want)
-			}
-		})
-	}
-	if got, err := AuthorizeCommandMigrations(after, map[string]Snapshot{"main": after, "stable": before}, consumed, consumed); err != nil || len(got) != 1 {
-		t.Fatalf("retained consumed receipt=%#v, %v", got, err)
-	}
-	if got, err := AuthorizeCommandMigrations(after, map[string]Snapshot{"main": after, "stable": after}, consumed, empty); err != nil || len(got) != 0 {
-		t.Fatalf("cleaned stale receipt=%#v, %v", got, err)
-	}
-	if got, err := AuthorizeCommandMigrations(before, map[string]Snapshot{"main": before, "stable": before}, empty, pending); err != nil || len(got) != 0 {
-		t.Fatalf("candidate pending plan=%#v, %v", got, err)
-	}
-
-	invalidSnapshot := before
-	invalidSnapshot.SchemaVersion = 0
-	for _, test := range []struct {
-		name       string
-		current    Snapshot
-		references map[string]Snapshot
-		authority  CommandMigrationManifest
-		candidate  CommandMigrationManifest
-	}{
-		{"current", invalidSnapshot, map[string]Snapshot{"main": before}, empty, empty},
-		{"reference", before, map[string]Snapshot{"main": invalidSnapshot}, empty, empty},
-		{"authority", before, map[string]Snapshot{"main": before}, CommandMigrationManifest{}, empty},
-		{"candidate", before, map[string]Snapshot{"main": before}, empty, CommandMigrationManifest{}},
-	} {
-		t.Run("invalid "+test.name, func(t *testing.T) {
-			if _, err := AuthorizeCommandMigrations(test.current, test.references, test.authority, test.candidate); err == nil {
-				t.Fatal("invalid authorization input accepted")
-			}
-		})
-	}
-	invalidFlags := FlagMigrationManifest{}
-	validFlags := FlagMigrationManifest{Version: FlagMigrationManifestVersion, Migrations: []FlagMigration{}}
-	validCommands := CommandMigrationManifest{Version: CommandMigrationManifestVersion, Migrations: []CommandMigration{}}
-	if _, err := CompareAllWithInterfaceMigrations(before, map[string]Snapshot{"main": before}, invalidFlags, validFlags, validCommands, validCommands); err == nil {
-		t.Fatal("combined compare accepted invalid flag lifecycle")
-	}
-	if _, err := CompareAllWithInterfaceMigrations(before, map[string]Snapshot{"main": before}, validFlags, validFlags, CommandMigrationManifest{}, validCommands); err == nil {
-		t.Fatal("combined compare accepted invalid command lifecycle")
-	}
-	if commandMigrationAuthorizesChange(before, before, Change{Kind: "command_removed", Path: "dws unrelated"}, pending.Migrations) {
-		t.Fatal("unrelated command change was authorized")
-	}
-}
-
-func TestCrossPlatformCoverageCommandMigrationLifecycleAndExactFiltering(t *testing.T) {
-	before := commandMigrationSnapshot(false, false)
-	after := commandMigrationSnapshot(true, false)
-	pending := commandMigrationManifest(CommandMigrationPending)
-	consumed := commandMigrationManifest(CommandMigrationConsumed)
-	emptyFlags := FlagMigrationManifest{Version: FlagMigrationManifestVersion, Migrations: []FlagMigration{}}
-
-	report, err := CompareAllWithInterfaceMigrations(
-		after,
-		map[string]Snapshot{"merge-base": before, "stable": before},
-		emptyFlags,
-		emptyFlags,
-		pending,
-		consumed,
-	)
-	if err != nil {
-		t.Fatalf("governed command migration: %v", err)
-	}
-	if !report.Compatible {
-		t.Fatalf("exact command migration remained blocking: %#v", report.Comparisons)
-	}
-
-	unrelated := commandMigrationSnapshot(true, true)
-	report, err = CompareAllWithInterfaceMigrations(
-		unrelated,
-		map[string]Snapshot{"merge-base": before, "stable": before},
-		emptyFlags,
-		emptyFlags,
-		pending,
-		consumed,
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.Compatible || !hasChangeKind(report.Comparisons[0].Blocking, "flag_removed") {
-		t.Fatalf("unrelated flag removal was hidden: %#v", report.Comparisons)
-	}
-
-	emptyCommands := CommandMigrationManifest{Version: CommandMigrationManifestVersion, Migrations: []CommandMigration{}}
-	if _, err := AuthorizeCommandMigrations(
-		after,
-		map[string]Snapshot{"merge-base": before, "stable": before},
-		emptyCommands,
-		pending,
-	); err == nil || !strings.Contains(err.Error(), "cannot authorize its own interface change") {
-		t.Fatalf("candidate self-authorization error=%v", err)
-	}
-
-	partial := commandMigrationSnapshot(true, false)
-	partial.Commands = partial.Commands[:len(partial.Commands)-1]
-	if _, err := AuthorizeCommandMigrations(
-		partial,
-		map[string]Snapshot{"merge-base": before, "stable": before},
-		pending,
-		consumed,
-	); err == nil || !strings.Contains(err.Error(), "partially applied") {
-		t.Fatalf("partial command migration error=%v", err)
-	}
-}
-
-func TestCrossPlatformCoverageFlagExtractionRequiresReplacementConstantEvidence(t *testing.T) {
-	before := commandMigrationSnapshot(false, false)
-	after := commandMigrationSnapshot(true, false)
-	pending := flagExtractionCommandMigrationManifest(CommandMigrationPending)
-	consumed := flagExtractionCommandMigrationManifest(CommandMigrationConsumed)
-	empty := CommandMigrationManifest{Version: CommandMigrationManifestVersion, Migrations: []CommandMigration{}}
-	migration := pending.Migrations[0]
-
-	if phase := matchCommandMigrationPhase(before, migration); phase != commandMigrationBefore {
-		t.Fatalf("before phase=%s, want %s", phase, commandMigrationBefore)
-	}
-	if phase := matchCommandMigrationPhase(after, migration); phase != commandMigrationAfter {
-		t.Fatalf("after phase=%s, want %s", phase, commandMigrationAfter)
-	}
-
-	for _, test := range []struct {
-		name   string
-		values map[string]bool
-	}{
-		{name: "missing", values: nil},
-		{name: "wrong property", values: map[string]bool{"otherProperty": true}},
-		{name: "wrong value", values: map[string]bool{"convThreadEnabled": false}},
-		{name: "extra", values: map[string]bool{"convThreadEnabled": true, "otherProperty": true}},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			current := withCommandBoolConstParams(after, "dws chat topic create", test.values)
-			if phase := matchCommandMigrationPhase(current, migration); phase != commandMigrationPartial {
-				t.Fatalf("phase=%s, want %s", phase, commandMigrationPartial)
-			}
-			if _, err := AuthorizeCommandMigrations(
-				current,
-				map[string]Snapshot{"merge-base": before, "stable": before},
-				pending,
-				consumed,
-			); err == nil || !strings.Contains(err.Error(), "partially applied") {
-				t.Fatalf("constant evidence lifecycle error=%v, want partial rejection", err)
-			}
-			if _, err := AuthorizeCommandMigrations(
-				current,
-				map[string]Snapshot{"merge-base": before, "stable": before},
-				empty,
-				pending,
-			); err == nil || !strings.Contains(err.Error(), "cannot authorize its own interface change") {
-				t.Fatalf("constant evidence self-authorization error=%v", err)
-			}
-		})
-	}
-}
-
-func commandMigrationManifestJSON() string {
-	return `{
-  "version": 1,
-  "migrations": [{
-    "kind": "command_move",
-    "legacy": {
-      "command": "dws chat message old",
-      "before": {"present": true, "runnable": true},
-      "after": {"present": true, "runnable": true, "hidden": true}
-    },
-    "replacement": {
-      "command": "dws chat topic new",
-      "before": {"present": false},
-      "after": {"present": true, "runnable": true}
-    },
-    "schema": {
-      "product_id": "chat",
-      "source_tool_id": "chat.old",
-      "replacement_tool_id": "chat.old",
-      "parameters": [{"from": "old-id", "to": "new-id"}]
-    },
-    "state": "pending",
-    "reason": "Reviewed command move."
-  }]
-}`
-}
-
-func flagExtractionCommandMigrationManifestJSON() string {
-	return `{
-  "version": 1,
-  "migrations": [{
-    "kind": "flag_extraction",
-    "legacy": {
-      "command": "dws chat group create",
-      "before": {"present": true, "runnable": true},
-      "after": {"present": true, "runnable": true}
-    },
-    "replacement": {
-      "command": "dws chat topic create",
-      "before": {"present": false},
-      "after": {"present": true, "runnable": true}
-    },
-    "legacy_flag": {
-      "name": "thread",
-      "before": {"present": true, "type": "bool", "no_opt": "true", "scope": "local"},
-      "after": {"present": true, "type": "bool", "hidden": true, "no_opt": "true", "scope": "local"}
-    },
-    "schema": {
-      "product_id": "chat",
-      "source_tool_id": "chat.create_group",
-      "replacement_tool_id": "chat.create_topic",
-      "parameters": [
-        {"from":"name","to":"name"},
-        {"from":"type","to":"type"},
-        {"from":"users","to":"users"},
-        {"from":"thread","replacement_constant":{"property":"convThreadEnabled","value":true}}
-      ]
-    },
-    "state": "pending",
-    "reason": "Reviewed flag extraction."
-  }]
-}`
-}
-
-func commandMigrationManifest(state string) CommandMigrationManifest {
-	move := CommandMigration{
-		Kind: CommandMigrationMove,
-		Legacy: CommandMigrationSide{
-			Command: "dws chat message old",
-			Before:  CommandMigrationState{Present: true, Runnable: true},
-			After:   CommandMigrationState{Present: true, Runnable: true, Hidden: true},
-		},
-		Replacement: CommandMigrationSide{
-			Command: "dws chat topic new",
-			Before:  CommandMigrationState{},
-			After:   CommandMigrationState{Present: true, Runnable: true},
-		},
-		Schema: CommandMigrationSchema{
-			ProductID:         "chat",
-			SourceToolID:      "chat.old",
-			ReplacementToolID: "chat.old",
-			Parameters:        []CommandParameterMigration{{From: "old-id", To: "new-id"}},
-		},
-		State:  state,
-		Reason: "Reviewed command move.",
-	}
-	extraction := CommandMigration{
-		Kind: CommandMigrationFlagExtraction,
-		Legacy: CommandMigrationSide{
-			Command: "dws chat group create",
-			Before:  CommandMigrationState{Present: true, Runnable: true},
-			After:   CommandMigrationState{Present: true, Runnable: true},
-		},
-		Replacement: CommandMigrationSide{
-			Command: "dws chat topic create",
-			Before:  CommandMigrationState{},
-			After:   CommandMigrationState{Present: true, Runnable: true},
-		},
-		LegacyFlag: CommandMigrationFlag{
-			Name:   "thread",
-			Before: FlagMigrationState{Present: true, Type: "bool", NoOpt: "true", Scope: "local"},
-			After:  FlagMigrationState{Present: true, Type: "bool", Hidden: true, NoOpt: "true", Scope: "local"},
-		},
-		Schema: CommandMigrationSchema{
-			ProductID:         "chat",
-			SourceToolID:      "chat.create_group",
-			ReplacementToolID: "chat.create_topic",
-			Parameters: []CommandParameterMigration{
-				{From: "name", To: "name"},
-				{From: "type", To: "type"},
-				{From: "users", To: "users"},
-				{
-					From: "thread",
-					ReplacementConstant: &CommandReplacementConstant{
-						Property: "convThreadEnabled",
-						Value:    true,
-					},
-				},
-			},
-		},
-		State:  state,
-		Reason: "Reviewed flag extraction.",
-	}
-	return CommandMigrationManifest{Version: CommandMigrationManifestVersion, Migrations: []CommandMigration{move, extraction}}
-}
-
-func flagExtractionCommandMigrationManifest(state string) CommandMigrationManifest {
-	manifest := commandMigrationManifest(state)
-	manifest.Migrations = manifest.Migrations[1:]
-	return manifest
-}
-
-func cloneCommandMigration(source CommandMigration) CommandMigration {
-	cloned := source
-	cloned.Schema.Parameters = append([]CommandParameterMigration(nil), source.Schema.Parameters...)
-	for index, parameter := range source.Schema.Parameters {
-		if parameter.ReplacementConstant == nil {
-			continue
-		}
-		constant := *parameter.ReplacementConstant
-		cloned.Schema.Parameters[index].ReplacementConstant = &constant
-	}
-	return cloned
-}
-
-func singleCommandMigrationManifest(state string) CommandMigrationManifest {
-	manifest := commandMigrationManifest(state)
-	manifest.Migrations = manifest.Migrations[:1]
-	return manifest
-}
-
-func modifiedCommandManifest(source CommandMigrationManifest) CommandMigrationManifest {
-	modified := source
-	modified.Migrations = append([]CommandMigration(nil), source.Migrations...)
-	modified.Migrations[0].Reason = "Modified reason."
-	return modified
-}
-
-func commandMigrationSnapshot(after, removeUnrelated bool) Snapshot {
-	oldFlags := []Flag{{Name: "old-id", Type: "string", Required: true}, {Name: "keep", Type: "string"}}
-	groupFlags := []Flag{{Name: "thread", Type: "bool", NoOpt: "true"}}
-	commands := []Command{
-		testCommand("dws"),
-		testCommand("dws chat group create", groupFlags...),
-		testCommand("dws chat message old", oldFlags...),
-	}
-	if after {
-		commands[1].LocalFlags[0].Hidden = true
-		commands[2].Hidden = true
-		if removeUnrelated {
-			commands[2].LocalFlags = commands[2].LocalFlags[:1]
-		}
-		topicCreate := testCommand("dws chat topic create")
-		topicCreate.BoolConstParams = map[string]bool{"convThreadEnabled": true}
-		commands = append(commands,
-			topicCreate,
-			testCommand("dws chat topic new", Flag{Name: "new-id", Type: "string", Required: true}),
-		)
-	}
-	return testSnapshot(commands...)
-}
-
-func withCommandBoolConstParams(snapshot Snapshot, path string, values map[string]bool) Snapshot {
-	cloned := snapshot
-	cloned.Commands = append([]Command(nil), snapshot.Commands...)
-	for index := range cloned.Commands {
-		if cloned.Commands[index].Path == path {
-			cloned.Commands[index].BoolConstParams = values
-			break
-		}
-	}
-	return cloned
-}

internal/interfacesnapshot/compare.go

@@ -71,9 +71,6 @@ func CompareAll(current Snapshot, references map[string]Snapshot) Report {
 //     alias),
 //   - flags accepted at each command path may not disappear, change type, or
 //     become required; an existing path may not gain a new required flag,
-//   - once bool ConstParams evidence exists, its exact property/value map is a
-//     durable contract; adding the first evidence to an older snapshot remains
-//     a silent bootstrap,
 //   - new commands and flags are allowed.
 //
 // The single exception to the type rule is an individually reviewed migration
@@ -156,14 +153,6 @@ func Compare(current, baseline Snapshot, reference string) Comparison {
 }
 
 func compareCommandContract(result *Comparison, acceptedPath string, oldCommand, newCommand Command) {
-	if len(oldCommand.BoolConstParams) > 0 && !reflect.DeepEqual(oldCommand.BoolConstParams, newCommand.BoolConstParams) {
-		result.Blocking = append(result.Blocking, Change{
-			Kind:   "bool_const_params_changed",
-			Path:   acceptedPath,
-			Before: fmt.Sprintf("%v", oldCommand.BoolConstParams),
-			After:  fmt.Sprintf("%v", newCommand.BoolConstParams),
-		})
-	}
 	if oldCommand.Runnable && !newCommand.Runnable {
 		result.Blocking = append(result.Blocking, Change{
 			Kind:   "command_became_non_runnable",

internal/interfacesnapshot/compare_test.go

@@ -135,63 +135,6 @@ func TestCrossPlatformCoverageCompareAllowsRenameWhenOldPathIsAlias(t *testing.T
 	}
 }
 
-func TestCrossPlatformCoverageCompareAllowsBoolConstParamsBootstrapAddition(t *testing.T) {
-	base := testSnapshot(
-		testCommand("dws"),
-		testCommand("dws send"),
-	)
-	current := testSnapshot(
-		testCommand("dws"),
-		testCommand("dws send"),
-	)
-	current.Commands[1].BoolConstParams = map[string]bool{"convThreadEnabled": true}
-
-	comparison := Compare(current, base, "base")
-	if !comparison.Compatible || len(comparison.Blocking) != 0 || len(comparison.Additions) != 0 {
-		t.Fatalf("ordinary Compare treated bootstrapped bool ConstParams evidence as a compatibility change: %#v", comparison)
-	}
-}
-
-func TestCrossPlatformCoverageCompareBlocksBoolConstParamsDriftAfterBootstrap(t *testing.T) {
-	base := testSnapshot(
-		testCommand("dws"),
-		testCommand("dws send"),
-	)
-	base.Commands[1].BoolConstParams = map[string]bool{"convThreadEnabled": true}
-
-	for _, test := range []struct {
-		name    string
-		current map[string]bool
-	}{
-		{name: "removed", current: nil},
-		{name: "value flipped", current: map[string]bool{"convThreadEnabled": false}},
-		{name: "extra key", current: map[string]bool{"convThreadEnabled": true, "other": false}},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			current := testSnapshot(
-				testCommand("dws"),
-				testCommand("dws send"),
-			)
-			current.Commands[1].BoolConstParams = test.current
-
-			comparison := Compare(current, base, "base")
-			if comparison.Compatible {
-				t.Fatalf("historical bool ConstParams drift was accepted: %#v", comparison)
-			}
-			if len(comparison.Blocking) != 1 {
-				t.Fatalf("blocking=%#v, want exactly one durable contract change", comparison.Blocking)
-			}
-			change := comparison.Blocking[0]
-			if change.Kind != "bool_const_params_changed" || change.Path != "dws send" {
-				t.Fatalf("blocking=%#v, want bool_const_params_changed at dws send", comparison.Blocking)
-			}
-			if len(comparison.Additions) != 0 {
-				t.Fatalf("bool ConstParams drift also produced additions: %#v", comparison.Additions)
-			}
-		})
-	}
-}
-
 func TestCrossPlatformCoverageCompareBlocksRemovedAlias(t *testing.T) {
 	base := testSnapshot(
 		testCommand("dws"),

internal/interfacesnapshot/migrations.go

@@ -91,32 +91,22 @@ func validateFlagMigrationJSONSchema(data []byte) error {
 }
 
 func validateMigrationJSONValue(decoder *json.Decoder, path string, schema reflect.Type) error {
-	return validateLabeledMigrationJSONValue(decoder, path, schema, "flag")
-}
-
-func validateLabeledMigrationJSONValue(decoder *json.Decoder, path string, schema reflect.Type, label string) error {
 	token, err := decoder.Token()
 	if err != nil {
-		return fmt.Errorf("read %s migration manifest value at %s: %w", label, path, err)
-	}
-	for schema.Kind() == reflect.Pointer {
-		if token == nil {
-			return migrationJSONTypeError(path, schema.Elem(), token, label)
-		}
-		schema = schema.Elem()
+		return fmt.Errorf("read flag migration manifest value at %s: %w", path, err)
 	}
 
 	switch schema.Kind() {
 	case reflect.Struct:
 		if delimiter, ok := token.(json.Delim); !ok || delimiter != '{' {
-			return migrationJSONTypeError(path, schema, token, label)
+			return migrationJSONTypeError(path, schema, token)
 		}
 		fields := migrationJSONFields(schema)
 		seen := make(map[string]bool, len(fields))
 		for decoder.More() {
 			keyToken, keyErr := decoder.Token()
 			if keyErr != nil {
-				return fmt.Errorf("read %s migration manifest field at %s: %w", label, path, keyErr)
+				return fmt.Errorf("read flag migration manifest field at %s: %w", path, keyErr)
 			}
 			// encoding/json guarantees object member names are string tokens.
 			key := keyToken.(string)
@@ -125,58 +115,57 @@ func validateLabeledMigrationJSONValue(decoder *json.Decoder, path string, schem
 				for canonical := range fields {
 					if strings.EqualFold(key, canonical) {
 						return fmt.Errorf(
-							"%s migration manifest contains non-canonical field %q at %s (want %q)",
-							label,
+							"flag migration manifest contains non-canonical field %q at %s (want %q)",
 							key,
 							path,
 							canonical,
 						)
 					}
 				}
-				return fmt.Errorf("%s migration manifest contains unknown field %q at %s", label, key, path)
+				return fmt.Errorf("flag migration manifest contains unknown field %q at %s", key, path)
 			}
 			if seen[key] {
-				return fmt.Errorf("%s migration manifest contains duplicate field %q at %s", label, key, path)
+				return fmt.Errorf("flag migration manifest contains duplicate field %q at %s", key, path)
 			}
 			seen[key] = true
-			if err := validateLabeledMigrationJSONValue(decoder, path+"."+key, fieldSchema, label); err != nil {
+			if err := validateMigrationJSONValue(decoder, path+"."+key, fieldSchema); err != nil {
 				return err
 			}
 		}
 		if _, closeErr := decoder.Token(); closeErr != nil {
-			return fmt.Errorf("close %s migration manifest object at %s: %w", label, path, closeErr)
+			return fmt.Errorf("close flag migration manifest object at %s: %w", path, closeErr)
 		}
 		return nil
 	case reflect.Slice:
 		if delimiter, ok := token.(json.Delim); !ok || delimiter != '[' {
-			return migrationJSONTypeError(path, schema, token, label)
+			return migrationJSONTypeError(path, schema, token)
 		}
 		for index := 0; decoder.More(); index++ {
-			if err := validateLabeledMigrationJSONValue(decoder, fmt.Sprintf("%s[%d]", path, index), schema.Elem(), label); err != nil {
+			if err := validateMigrationJSONValue(decoder, fmt.Sprintf("%s[%d]", path, index), schema.Elem()); err != nil {
 				return err
 			}
 		}
 		if _, closeErr := decoder.Token(); closeErr != nil {
-			return fmt.Errorf("close %s migration manifest array at %s: %w", label, path, closeErr)
+			return fmt.Errorf("close flag migration manifest array at %s: %w", path, closeErr)
 		}
 		return nil
 	case reflect.String:
 		if _, ok := token.(string); !ok {
-			return migrationJSONTypeError(path, schema, token, label)
+			return migrationJSONTypeError(path, schema, token)
 		}
 		return nil
 	case reflect.Int:
 		if _, ok := token.(json.Number); !ok {
-			return migrationJSONTypeError(path, schema, token, label)
+			return migrationJSONTypeError(path, schema, token)
 		}
 		return nil
 	case reflect.Bool:
 		if _, ok := token.(bool); !ok {
-			return migrationJSONTypeError(path, schema, token, label)
+			return migrationJSONTypeError(path, schema, token)
 		}
 		return nil
 	default:
-		return fmt.Errorf("%s migration manifest value at %s has unsupported Go schema type %s", label, path, schema)
+		return fmt.Errorf("flag migration manifest value at %s has unsupported Go schema type %s", path, schema)
 	}
 }
 
@@ -199,10 +188,9 @@ func migrationJSONFields(schema reflect.Type) map[string]reflect.Type {
 	return fields
 }
 
-func migrationJSONTypeError(path string, want reflect.Type, token json.Token, label string) error {
+func migrationJSONTypeError(path string, want reflect.Type, token json.Token) error {
 	return fmt.Errorf(
-		"%s migration manifest value at %s must be %s, got %s",
-		label,
+		"flag migration manifest value at %s must be %s, got %s",
 		path,
 		migrationJSONKindDescription(want),
 		migrationJSONTokenDescription(token),

internal/interfacesnapshot/snapshot.go

@@ -22,13 +22,12 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd"
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd/runtimeannotate"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
 
-const SchemaVersion = 3
+const SchemaVersion = 2
 
 // FlagAliasOfAnnotation records a framework-originated reviewed relationship
 // between a retained compatibility flag and an exact canonical Cobra flag.
@@ -67,14 +66,13 @@ type Snapshot struct {
 // Command contains compatibility-relevant command metadata. Path always
 // includes the root command name (for example, "dws chat message send").
 type Command struct {
-	Path            string          `json:"path"`
-	Runnable        bool            `json:"runnable"`
-	Hidden          bool            `json:"hidden"`
-	Deprecated      string          `json:"deprecated,omitempty"`
-	Aliases         []string        `json:"aliases"`
-	LocalFlags      []Flag          `json:"local_flags"`
-	InheritedFlags  []Flag          `json:"inherited_flags"`
-	BoolConstParams map[string]bool `json:"bool_const_params,omitempty"`
+	Path           string   `json:"path"`
+	Runnable       bool     `json:"runnable"`
+	Hidden         bool     `json:"hidden"`
+	Deprecated     string   `json:"deprecated,omitempty"`
+	Aliases        []string `json:"aliases"`
+	LocalFlags     []Flag   `json:"local_flags"`
+	InheritedFlags []Flag   `json:"inherited_flags"`
 }
 
 // Flag contains the stable pflag contract visible at a command node.
@@ -128,16 +126,14 @@ func Capture(root *cobra.Command) Snapshot {
 		}
 		aliases = compactSorted(aliases)
 
-		boolConstParams := corecmd.InterfaceBoolConstParams(cmd)
 		snapshot.Commands = append(snapshot.Commands, Command{
-			Path:            path,
-			Runnable:        cmd.Runnable(),
-			Hidden:          cmd.Hidden,
-			Deprecated:      strings.TrimSpace(cmd.Deprecated),
-			Aliases:         aliases,
-			LocalFlags:      captureFlags(cmd.LocalFlags()),
-			InheritedFlags:  captureFlags(cmd.InheritedFlags()),
-			BoolConstParams: boolConstParams,
+			Path:           path,
+			Runnable:       cmd.Runnable(),
+			Hidden:         cmd.Hidden,
+			Deprecated:     strings.TrimSpace(cmd.Deprecated),
+			Aliases:        aliases,
+			LocalFlags:     captureFlags(cmd.LocalFlags()),
+			InheritedFlags: captureFlags(cmd.InheritedFlags()),
 		})
 
 		children := append([]*cobra.Command(nil), cmd.Commands()...)
@@ -202,9 +198,6 @@ func (s Snapshot) Validate() error {
 			return fmt.Errorf("interface snapshot contains duplicate command path %q", command.Path)
 		}
 		seenCommands[command.Path] = true
-		if command.BoolConstParams != nil && len(command.BoolConstParams) == 0 {
-			return fmt.Errorf("command %q must omit empty bool_const_params", command.Path)
-		}
 		if err := validateFlags(command.Path, "local", command.LocalFlags); err != nil {
 			return err
 		}

internal/interfacesnapshot/snapshot_test.go

@@ -17,7 +17,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"reflect"
-	"strings"
 	"testing"
 
 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd"
@@ -99,105 +98,16 @@ func TestCrossPlatformCoverageCaptureUsesStableNoiseRulesAndFlagScopes(t *testin
 
 func TestCrossPlatformCoverageReadRejectsUnknownSnapshotFields(t *testing.T) {
 	input := bytes.NewBufferString(`{
-	  "schema_version": 3,
-	  "rules": {"excluded_command_subtrees": [], "excluded_flags": []},
-	  "commands": [],
-	  "future_field": true
+  "schema_version": 2,
+  "rules": {"excluded_command_subtrees": [], "excluded_flags": []},
+  "commands": [],
+  "future_field": true
 }`)
 	if _, err := Read(input); err == nil {
 		t.Fatal("Read accepted an unknown field")
 	}
 }
 
-func TestCrossPlatformCoverageCaptureRoundTripsFrameworkBoolConstParams(t *testing.T) {
-	root := &cobra.Command{Use: "dws"}
-	leaf := corecmd.New(corecmd.Spec{
-		Use:         "send",
-		ConstParams: map[string]any{"convThreadEnabled": true, "precheckOnly": false},
-		Invoke:      func(*corecmd.Ctx, map[string]any) error { return nil },
-	})
-	root.AddCommand(leaf)
-
-	snapshot := Capture(root)
-	got := commandIndex(snapshot)["dws send"].BoolConstParams
-	want := map[string]bool{"convThreadEnabled": true, "precheckOnly": false}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("captured bool ConstParams = %#v, want %#v", got, want)
-	}
-
-	var encoded bytes.Buffer
-	if err := Write(&encoded, snapshot); err != nil {
-		t.Fatalf("Write: %v", err)
-	}
-	decoded, err := Read(bytes.NewReader(encoded.Bytes()))
-	if err != nil {
-		t.Fatalf("Read: %v", err)
-	}
-	if got := commandIndex(decoded)["dws send"].BoolConstParams; !reflect.DeepEqual(got, want) {
-		t.Fatalf("round-tripped bool ConstParams = %#v, want %#v", got, want)
-	}
-}
-
-func TestCrossPlatformCoverageCaptureIgnoresHandwrittenLegacyConstParamsAnnotations(t *testing.T) {
-	root := &cobra.Command{Use: "dws"}
-	direct := &cobra.Command{
-		Use: "direct",
-		Run: func(*cobra.Command, []string) {},
-		Annotations: map[string]string{
-			"dws.compat.bool_const_params":   `{"forged":true}`,
-			"dws.compat.const_params_origin": "corecmd.const_params.v1",
-		},
-	}
-	businessConstructor := func() *cobra.Command {
-		payloadKey := strings.Join([]string{"dws.compat.bool_", "const_params"}, "")
-		originKey := strings.Join([]string{"dws.compat.const_", "params_origin"}, "")
-		origin := strings.Join([]string{"corecmd.const_", "params.v1"}, "")
-		return &cobra.Command{
-			Use: "business",
-			Run: func(*cobra.Command, []string) {},
-			Annotations: map[string]string{
-				payloadKey: `{"forged":true}`,
-				originKey:  origin,
-			},
-		}
-	}
-	root.AddCommand(direct, businessConstructor())
-
-	snapshot := Capture(root)
-	if err := snapshot.Validate(); err != nil {
-		t.Fatalf("handwritten legacy annotations affected snapshot validity: %v", err)
-	}
-	for _, path := range []string{"dws direct", "dws business"} {
-		if got := commandIndex(snapshot)[path].BoolConstParams; got != nil {
-			t.Fatalf("%s forged bool ConstParams evidence = %#v", path, got)
-		}
-	}
-	var encoded bytes.Buffer
-	if err := Write(&encoded, snapshot); err != nil {
-		t.Fatalf("Write snapshot without forged evidence: %v", err)
-	}
-}
-
-func TestCrossPlatformCoverageReadRejectsMalformedBoolConstParams(t *testing.T) {
-	for _, payload := range []string{`{"fixed":"true"}`, `{}`} {
-		input := bytes.NewBufferString(`{
-		  "schema_version": 3,
-		  "rules": {"excluded_command_subtrees": [], "excluded_flags": []},
-		  "commands": [{
-		    "path": "dws send",
-		    "runnable": true,
-		    "aliases": [],
-		    "local_flags": [],
-		    "inherited_flags": [],
-		    "bool_const_params": ` + payload + `
-		  }]
-		}`)
-		if _, err := Read(input); err == nil {
-			t.Fatalf("Read accepted malformed bool_const_params %s", payload)
-		}
-	}
-}
-
 func TestCrossPlatformCoverageCaptureRoundTripsFrameworkFlagAlias(t *testing.T) {
 	if FlagAliasOfAnnotation != runtimeannotate.AnnotationFlagAliasOf {
 		t.Fatalf(

internal/keychain/coverage_edges_test.go

@@ -3,6 +3,7 @@
 package keychain
 
 import (
+	"bytes"
 	"encoding/base64"
 	"errors"
 	"os"
@@ -246,6 +247,45 @@ func TestCrossPlatformCoverageDarwinDEKKeyringEdges(t *testing.T) {
 	if got, err := getOrCreateDEK("generate-missing"); err != nil || len(got) != dekBytes {
 		t.Fatalf("generate missing = %d, %v", len(got), err)
 	}
+
+	existing := bytesOf(7, dekBytes)
+	setCalls := 0
+	keyringGet = func(string, string) (string, error) {
+		return base64.StdEncoding.EncodeToString(existing), nil
+	}
+	keyringSet = func(string, string, string) error {
+		setCalls++
+		return errors.New("duplicate write must not replace an existing DEK")
+	}
+	got, err := getOrCreateDEK("reuse-existing")
+	if err != nil || !bytes.Equal(got, existing) {
+		t.Fatalf("reuse existing = %d, %v", len(got), err)
+	}
+	if setCalls != 0 {
+		t.Fatalf("reuse existing set calls = %d, want 0", setCalls)
+	}
+
+	gets := 0
+	setCalls = 0
+	keyringGet = func(string, string) (string, error) {
+		gets++
+		if gets == 1 {
+			return "", keyring.ErrNotFound
+		}
+		return encoded, nil
+	}
+	keyringSet = func(string, string, string) error {
+		setCalls++
+		return errors.New("already exists")
+	}
+	got, err = getOrCreateDEK("create-race")
+	if err != nil || !bytes.Equal(got, valid) {
+		t.Fatalf("create race = %d, %v", len(got), err)
+	}
+	if setCalls != 1 {
+		t.Fatalf("create race set calls = %d, want 1", setCalls)
+	}
+	keyringGet = func(string, string) (string, error) { return "", keyring.ErrNotFound }
 	keychainRandRead = func([]byte) (int, error) { return 0, errKeychainInjected }
 	if _, err := getOrCreateDEK("rand"); err == nil {
 		t.Fatal("rand error expected")

internal/keychain/keychain_darwin.go

@@ -237,6 +237,26 @@ func getSystemDEKReadOnly(service string) ([]byte, error) {
 	return key, err
 }
 
+func decodeSystemDEK(encodedKey string) ([]byte, bool) {
+	key, err := base64.StdEncoding.DecodeString(encodedKey)
+	return key, err == nil && len(key) == dekBytes
+}
+
+func readStoredSystemDEK(service string, runtime darwinKeychainRuntime) ([]byte, error) {
+	encodedKey, err := runtime.get(service, "dek")
+	if err == nil {
+		key, ok := decodeSystemDEK(encodedKey)
+		if ok {
+			return key, nil
+		}
+		return nil, fmt.Errorf("read DEK from macOS Keychain: %w", ErrDEKMissing)
+	}
+	if errors.Is(err, keyring.ErrNotFound) {
+		return nil, fmt.Errorf("read DEK from macOS Keychain: %w", ErrDEKMissing)
+	}
+	return nil, NewUnavailableError("read DEK from macOS Keychain", err)
+}
+
 func getSystemDEKReadOnlyWithRuntime(service string, runtime darwinKeychainRuntime) ([]byte, error, <-chan struct{}) {
 	if err := runtime.checkAvailable(); err != nil {
 		return nil, err, finishedDarwinKeychainWorker()
@@ -244,18 +264,7 @@ func getSystemDEKReadOnlyWithRuntime(service string, runtime darwinKeychainRunti
 
 	const operation = "read DEK from macOS Keychain"
 	worker := startDarwinKeychainWorker(operation, func() ([]byte, error) {
-		encodedKey, err := runtime.get(service, "dek")
-		if err == nil {
-			key, decodeErr := base64.StdEncoding.DecodeString(encodedKey)
-			if decodeErr == nil && len(key) == dekBytes {
-				return key, nil
-			}
-			return nil, fmt.Errorf("read DEK from macOS Keychain: %w", ErrDEKMissing)
-		}
-		if errors.Is(err, keyring.ErrNotFound) {
-			return nil, fmt.Errorf("read DEK from macOS Keychain: %w", ErrDEKMissing)
-		}
-		return nil, NewUnavailableError("read DEK from macOS Keychain", err)
+		return readStoredSystemDEK(service, runtime)
 	})
 
 	return waitDarwinKeychainWorker(runtime.timeout, operation, worker)
@@ -276,28 +285,30 @@ func getOrCreateDEKWithRuntime(service string, runtime darwinKeychainRuntime) ([
 
 	const operation = "read or create DEK in macOS Keychain"
 	worker := startDarwinKeychainWorker(operation, func() ([]byte, error) {
-		// Try to get existing DEK from system Keychain
-		encodedKey, err := runtime.get(service, "dek")
+		key, err := readStoredSystemDEK(service, runtime)
 		if err == nil {
-			key, decodeErr := base64.StdEncoding.DecodeString(encodedKey)
-			if decodeErr == nil && len(key) == dekBytes {
-				return key, nil
-			}
-		} else if !errors.Is(err, keyring.ErrNotFound) {
-			return nil, NewUnavailableError("read DEK from macOS Keychain", err)
+			return key, nil
+		}
+		if !IsDEKMissing(err) {
+			return nil, err
 		}
 
-		// Generate new DEK if not found or invalid
-		key := make([]byte, dekBytes)
+		// Generate a candidate only when the slot is empty or unreadable.
+		// Concurrent writers must not replace a DEK another process just stored.
+		key = make([]byte, dekBytes)
 		if _, randErr := runtime.randRead(key); randErr != nil {
 			return nil, randErr
 		}
-
-		// Store in system Keychain
-		encodedKey = base64.StdEncoding.EncodeToString(key)
-		if setErr := runtime.set(service, "dek", encodedKey); setErr != nil {
+		if setErr := runtime.set(service, "dek", base64.StdEncoding.EncodeToString(key)); setErr != nil {
+			existing, getErr := readStoredSystemDEK(service, runtime)
+			if getErr == nil {
+				return existing, nil
+			}
 			return nil, NewUnavailableError("store DEK in macOS Keychain", setErr)
 		}
+		if existing, getErr := readStoredSystemDEK(service, runtime); getErr == nil {
+			return existing, nil
+		}
 		return key, nil
 	})
 

internal/msgcrypto/authcode.go

@@ -0,0 +1,127 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package msgcrypto
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// DefaultAuthCodeTTL is the unconsumed-cache window for a freshly minted
+// vendor authCode. The portal issues codes with expiresIn=120s and they are
+// one-shot, so the default stays under that server window. Prefer not wrapping
+// PortalAuthCode in CachedAuthCode: mint in goProxy and discard after the key
+// request.
+const DefaultAuthCodeTTL = 90 * time.Second
+
+// ErrNoAuthCode means the provider returned an empty code without an error.
+var ErrNoAuthCode = errors.New("msgcrypto: auth code provider returned an empty code")
+
+// AuthCodeProvider yields a DingTalk 免登 authCode for key-server
+// authentication. DWS does not mint the code itself, so integrations inject an
+// implementation. The backend calls this only from the vendor goProxy
+// callback, never on every encrypt or decrypt.
+//
+// Implementations must be safe for concurrent use; the backend may call this
+// from a CGO callback while an encrypt or decrypt call is in flight.
+type AuthCodeProvider interface {
+	AuthCode(ctx context.Context) (string, error)
+}
+
+// CorpAuthCodeProvider mints a code for a specific organization. PortalAuthCode
+// implements this so goProxy can pass the C library's corpID. Domain and
+// redirectURI are never part of this call.
+type CorpAuthCodeProvider interface {
+	AuthCodeProvider
+	AuthCodeForCorp(ctx context.Context, corpID string) (string, error)
+}
+
+// AuthCodeFunc adapts a function to AuthCodeProvider.
+type AuthCodeFunc func(ctx context.Context) (string, error)
+
+// AuthCode calls f.
+func (f AuthCodeFunc) AuthCode(ctx context.Context) (string, error) { return f(ctx) }
+
+// StaticAuthCode returns a provider that always yields code. It is meant for
+// tests and manual integration runs; a static code stops working once the
+// server-side five-minute window closes.
+func StaticAuthCode(code string) AuthCodeProvider {
+	return AuthCodeFunc(func(context.Context) (string, error) {
+		if code == "" {
+			return "", ErrNoAuthCode
+		}
+		return code, nil
+	})
+}
+
+// CachedAuthCode memoises an AuthCodeProvider for a TTL so a burst of key
+// requests does not trigger one upstream call each.
+type CachedAuthCode struct {
+	provider AuthCodeProvider
+	ttl      time.Duration
+	now      func() time.Time
+
+	mu        sync.Mutex
+	code      string
+	expiresAt time.Time
+}
+
+// NewCachedAuthCode wraps provider with a TTL cache. A ttl of zero or less
+// selects DefaultAuthCodeTTL.
+func NewCachedAuthCode(provider AuthCodeProvider, ttl time.Duration) *CachedAuthCode {
+	if ttl <= 0 {
+		ttl = DefaultAuthCodeTTL
+	}
+	return &CachedAuthCode{provider: provider, ttl: ttl, now: time.Now}
+}
+
+// AuthCode returns the cached code when it is still fresh, otherwise fetches a
+// new one. A failed fetch leaves no stale value behind.
+func (c *CachedAuthCode) AuthCode(ctx context.Context) (string, error) {
+	if c.provider == nil {
+		return "", ErrNoAuthCodeProvider
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.code != "" && c.now().Before(c.expiresAt) {
+		return c.code, nil
+	}
+
+	code, err := c.provider.AuthCode(ctx)
+	if err != nil {
+		c.code, c.expiresAt = "", time.Time{}
+		return "", fmt.Errorf("msgcrypto: fetch auth code: %w", err)
+	}
+	if code == "" {
+		c.code, c.expiresAt = "", time.Time{}
+		return "", ErrNoAuthCode
+	}
+
+	c.code = code
+	c.expiresAt = c.now().Add(c.ttl)
+	return code, nil
+}
+
+// Invalidate drops the cached code so the next AuthCode call refetches. The
+// backend calls this after the key server rejects a code.
+func (c *CachedAuthCode) Invalidate() {
+	c.mu.Lock()
+	c.code, c.expiresAt = "", time.Time{}
+	c.mu.Unlock()
+}

internal/msgcrypto/authcode_test.go

@@ -0,0 +1,228 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package msgcrypto
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"testing"
+	"time"
+)
+
+// countingProvider hands out a fresh code per call and records how often it was
+// asked, so cache behaviour can be asserted.
+type countingProvider struct {
+	mu    sync.Mutex
+	calls int
+	code  string
+	err   error
+}
+
+func (p *countingProvider) AuthCode(context.Context) (string, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.calls++
+	if p.err != nil {
+		return "", p.err
+	}
+	if p.code != "" {
+		return p.code, nil
+	}
+	return "code-" + string(rune('a'+p.calls-1)), nil
+}
+
+// callCount reports the number of upstream fetches.
+func (p *countingProvider) callCount() int {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.calls
+}
+
+func TestAuthCodeFuncAdaptsFunction(t *testing.T) {
+	provider := AuthCodeFunc(func(context.Context) (string, error) { return "abc", nil })
+	code, err := provider.AuthCode(context.Background())
+	if err != nil || code != "abc" {
+		t.Fatalf("AuthCode() = %q, %v; want abc, nil", code, err)
+	}
+}
+
+func TestStaticAuthCodeReturnsCode(t *testing.T) {
+	code, err := StaticAuthCode("fixed").AuthCode(context.Background())
+	if err != nil || code != "fixed" {
+		t.Fatalf("AuthCode() = %q, %v; want fixed, nil", code, err)
+	}
+}
+
+func TestStaticAuthCodeRejectsEmptyCode(t *testing.T) {
+	_, err := StaticAuthCode("").AuthCode(context.Background())
+	if !errors.Is(err, ErrNoAuthCode) {
+		t.Fatalf("AuthCode() = %v, want ErrNoAuthCode", err)
+	}
+}
+
+func TestCachedAuthCodeReusesCodeWithinTTL(t *testing.T) {
+	provider := &countingProvider{code: "same"}
+	cache := NewCachedAuthCode(provider, time.Minute)
+
+	for i := 0; i < 5; i++ {
+		code, err := cache.AuthCode(context.Background())
+		if err != nil {
+			t.Fatalf("AuthCode() #%d = %v", i+1, err)
+		}
+		if code != "same" {
+			t.Fatalf("AuthCode() #%d = %q, want same", i+1, code)
+		}
+	}
+	if got := provider.callCount(); got != 1 {
+		t.Fatalf("upstream called %d times, want 1 (the code must be cached)", got)
+	}
+}
+
+func TestCachedAuthCodeRefetchesAfterTTL(t *testing.T) {
+	provider := &countingProvider{}
+	cache := NewCachedAuthCode(provider, time.Minute)
+
+	now := time.Now()
+	cache.now = func() time.Time { return now }
+
+	first, err := cache.AuthCode(context.Background())
+	if err != nil {
+		t.Fatalf("first AuthCode() = %v", err)
+	}
+
+	// Move past the TTL. The DingTalk code expires server-side, so a stale
+	// one must not be reused.
+	now = now.Add(time.Minute + time.Second)
+
+	second, err := cache.AuthCode(context.Background())
+	if err != nil {
+		t.Fatalf("second AuthCode() = %v", err)
+	}
+	if first == second {
+		t.Fatalf("AuthCode() returned the same code %q after the TTL expired", first)
+	}
+	if got := provider.callCount(); got != 2 {
+		t.Fatalf("upstream called %d times, want 2", got)
+	}
+}
+
+func TestCachedAuthCodeDefaultTTLIsUnderServerWindow(t *testing.T) {
+	// Portal vendorAuthCode expiresIn is 120s and the code is one-shot.
+	// The unconsumed-cache window must stay under that server lifetime.
+	if DefaultAuthCodeTTL >= 120*time.Second {
+		t.Fatalf("DefaultAuthCodeTTL = %v, want less than the 120s portal expiresIn", DefaultAuthCodeTTL)
+	}
+	cache := NewCachedAuthCode(&countingProvider{}, 0)
+	if cache.ttl != DefaultAuthCodeTTL {
+		t.Fatalf("ttl = %v, want DefaultAuthCodeTTL %v", cache.ttl, DefaultAuthCodeTTL)
+	}
+}
+
+func TestCachedAuthCodeNegativeTTLFallsBackToDefault(t *testing.T) {
+	cache := NewCachedAuthCode(&countingProvider{}, -time.Second)
+	if cache.ttl != DefaultAuthCodeTTL {
+		t.Fatalf("ttl = %v, want DefaultAuthCodeTTL %v", cache.ttl, DefaultAuthCodeTTL)
+	}
+}
+
+func TestCachedAuthCodePropagatesUpstreamError(t *testing.T) {
+	wantErr := errors.New("token service down")
+	cache := NewCachedAuthCode(&countingProvider{err: wantErr}, time.Minute)
+
+	_, err := cache.AuthCode(context.Background())
+	if !errors.Is(err, wantErr) {
+		t.Fatalf("AuthCode() = %v, want it to wrap %v", err, wantErr)
+	}
+}
+
+func TestCachedAuthCodeDoesNotCacheFailures(t *testing.T) {
+	provider := &countingProvider{err: errors.New("transient")}
+	cache := NewCachedAuthCode(provider, time.Minute)
+
+	if _, err := cache.AuthCode(context.Background()); err == nil {
+		t.Fatal("AuthCode() = nil error, want failure")
+	}
+
+	provider.mu.Lock()
+	provider.err = nil
+	provider.code = "recovered"
+	provider.mu.Unlock()
+
+	code, err := cache.AuthCode(context.Background())
+	if err != nil {
+		t.Fatalf("AuthCode() after recovery = %v", err)
+	}
+	if code != "recovered" {
+		t.Fatalf("AuthCode() = %q, want recovered (a failure must not be cached)", code)
+	}
+}
+
+func TestCachedAuthCodeRejectsEmptyUpstreamCode(t *testing.T) {
+	// A provider that reports success with no code is a bug upstream; the
+	// cache must surface it instead of caching an unusable value.
+	cache := NewCachedAuthCode(AuthCodeFunc(func(context.Context) (string, error) {
+		return "", nil
+	}), time.Minute)
+
+	if _, err := cache.AuthCode(context.Background()); !errors.Is(err, ErrNoAuthCode) {
+		t.Fatalf("AuthCode() = %v, want ErrNoAuthCode", err)
+	}
+}
+
+func TestCachedAuthCodeInvalidateForcesRefetch(t *testing.T) {
+	provider := &countingProvider{}
+	cache := NewCachedAuthCode(provider, time.Hour)
+
+	if _, err := cache.AuthCode(context.Background()); err != nil {
+		t.Fatalf("first AuthCode() = %v", err)
+	}
+	cache.Invalidate()
+	if _, err := cache.AuthCode(context.Background()); err != nil {
+		t.Fatalf("second AuthCode() = %v", err)
+	}
+	if got := provider.callCount(); got != 2 {
+		t.Fatalf("upstream called %d times, want 2 after Invalidate", got)
+	}
+}
+
+func TestCachedAuthCodeWithoutProviderReportsMissingProvider(t *testing.T) {
+	cache := NewCachedAuthCode(nil, time.Minute)
+	if _, err := cache.AuthCode(context.Background()); !errors.Is(err, ErrNoAuthCodeProvider) {
+		t.Fatalf("AuthCode() = %v, want ErrNoAuthCodeProvider", err)
+	}
+}
+
+func TestCachedAuthCodeIsSafeForConcurrentUse(t *testing.T) {
+	// The backend may ask for a code from a CGO callback while another
+	// operation is in flight, so concurrent access must not race.
+	provider := &countingProvider{code: "shared"}
+	cache := NewCachedAuthCode(provider, time.Hour)
+
+	var wg sync.WaitGroup
+	for i := 0; i < 32; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if code, err := cache.AuthCode(context.Background()); err != nil || code != "shared" {
+				t.Errorf("AuthCode() = %q, %v; want shared, nil", code, err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if got := provider.callCount(); got != 1 {
+		t.Fatalf("upstream called %d times, want 1", got)
+	}
+}

internal/msgcrypto/cipher_safechat.go

@@ -0,0 +1,159 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The constraint below must stay in sync with cipher_stub.go, which negates it
+// verbatim. It encodes the platforms the vendor ships a libsafechat.a for:
+// darwin and linux on amd64/arm64, plus windows/amd64. windows/arm64 is
+// deliberately excluded because the vendor has not delivered that static
+// library, and DWS does release that target.
+
+//go:build safechat && cgo && (((darwin || linux) && (amd64 || arm64)) || (windows && amd64))
+
+package msgcrypto
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	safechat "safechat-go-sdk"
+)
+
+// BackendVersion identifies the compiled-in vendor SDK.
+const BackendVersion = "safechat " + safechat.Version
+
+// Available reports that this binary carries the SafeChat backend.
+func Available() bool { return true }
+
+// safechatCipher adapts the vendor client to Cipher.
+//
+// The vendor client serialises its own C calls internally, so this type adds no
+// further locking. Auth codes are minted only from AuthCodeHook, which the
+// vendor SDK calls inside goProxy when a key is actually missing.
+type safechatCipher struct {
+	client      *safechat.Client
+	codes       AuthCodeProvider
+	allowedHost string
+
+	mu          sync.Mutex
+	lastCodeErr error
+}
+
+// newBackend starts the vendor client against cfg's keystore.
+//
+// A warm keystore serves encrypt and decrypt without a key request, so no
+// authCode is fetched at open time. The hook runs only if goProxy fires.
+func newBackend(ctx context.Context, cfg Config) (Cipher, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+
+	var logf func(string, ...any)
+	if cfg.Debug {
+		logf = cfg.Logf
+	}
+
+	c := &safechatCipher{codes: cfg.AuthCode, allowedHost: cfg.AllowedRedirectHost}
+	client, err := safechat.New(safechat.Config{
+		DataPath:     cfg.KeystoreDir,
+		UserID:       cfg.UserID,
+		KeyServer:    cfg.KeyServer,
+		MaxRetry:     cfg.MaxRetry,
+		HTTPTimeout:  cfg.HTTPTimeout,
+		Logger:       newRedactingLogger(logf),
+		AuthCodeHook: c.authCodeHook,
+	})
+	if err != nil {
+		if errors.Is(err, safechat.ErrAlreadyInitialized) {
+			return nil, ErrAlreadyOpen
+		}
+		return nil, fmt.Errorf("msgcrypto: start safechat backend: %w", err)
+	}
+	c.client = client
+	return c, nil
+}
+
+// EncryptMessage encrypts plaintext and returns the vendor ciphertext.
+func (c *safechatCipher) EncryptMessage(ctx context.Context, corpID, staffID string, plaintext []byte) ([]byte, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	c.setLastCodeErr(nil)
+	out, err := c.client.EncryptMsg(corpID, staffID, plaintext)
+	if err != nil {
+		return nil, c.explain("encrypt", corpID, err)
+	}
+	return out, nil
+}
+
+// DecryptMessage decrypts a vendor ciphertext.
+func (c *safechatCipher) DecryptMessage(ctx context.Context, corpID, staffID string, ciphertext []byte) ([]byte, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	c.setLastCodeErr(nil)
+	out, err := c.client.DecryptMsg(corpID, staffID, ciphertext)
+	if err != nil {
+		return nil, c.explain("decrypt", corpID, err)
+	}
+	return out, nil
+}
+
+// Close releases the vendor client.
+func (c *safechatCipher) Close() error {
+	c.client.Close()
+	return nil
+}
+
+// authCodeHook is invoked from goProxy immediately before the key request.
+// domain is compared locally and never forwarded to portal. The returned
+// code is used once by the SDK and is not stored on the client.
+func (c *safechatCipher) authCodeHook(corpID, domain string) (string, error) {
+	code, err := mintAuthCodeForProxy(c.codes, c.allowedHost, corpID, domain)
+	c.setLastCodeErr(err)
+	return code, err
+}
+
+func (c *safechatCipher) setLastCodeErr(err error) {
+	c.mu.Lock()
+	c.lastCodeErr = err
+	c.mu.Unlock()
+}
+
+func (c *safechatCipher) lastAuthCodeErr() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.lastCodeErr
+}
+
+// explain turns a vendor error into an actionable one, folding in a failed
+// goProxy authCode mint and the admin-restricted case.
+func (c *safechatCipher) explain(op, corpID string, opErr error) error {
+	if c.client.IsBlocked(corpID) {
+		return fmt.Errorf("msgcrypto: %s blocked: the organization's key is restricted by its administrator: %w", op, opErr)
+	}
+
+	// A key fetch was needed but we had no usable code: that is the real
+	// cause, so report both.
+	if codeErr := c.lastAuthCodeErr(); codeErr != nil {
+		return fmt.Errorf("msgcrypto: %s failed and no usable auth code was available: %w (auth code error: %v)", op, opErr, codeErr)
+	}
+
+	if errors.Is(opErr, safechat.ErrMaxRetryExceeded) {
+		invalidateAuthCode(c.codes)
+		return fmt.Errorf("msgcrypto: %s failed: key material never became available: %w", op, opErr)
+	}
+
+	return fmt.Errorf("msgcrypto: %s failed: %w", op, opErr)
+}

internal/msgcrypto/cipher_safechat_test.go

@@ -0,0 +1,161 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Keep this constraint in sync with cipher_safechat.go.
+
+//go:build safechat && cgo && (((darwin || linux) && (amd64 || arm64)) || (windows && amd64))
+
+package msgcrypto
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// These tests exercise the real vendor backend, which means they link
+// libsafechat.a and initialise the C library. They never reach the key server:
+// an authCode is only spent when a key is actually fetched, and asserting that
+// encryption fails without one is exactly the behaviour we want pinned.
+
+func TestBackendIsReportedAvailable(t *testing.T) {
+	if !Available() {
+		t.Fatal("Available() = false in a safechat build")
+	}
+	if BackendVersion == "" {
+		t.Fatal("BackendVersion is empty in a safechat build")
+	}
+	if !strings.Contains(BackendVersion, "safechat") {
+		t.Fatalf("BackendVersion = %q, want it to name the vendor SDK", BackendVersion)
+	}
+}
+
+func TestOpenInitialisesCLibraryAndClosesCleanly(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "keystore")
+
+	cipher, err := Open(context.Background(), Config{
+		KeystoreDir: dir,
+		AuthCode:    StaticAuthCode("placeholder-code"),
+		KeyServer:   "https://key.example.test",
+	})
+	if err != nil {
+		t.Fatalf("Open() = %v, want the C library to initialise", err)
+	}
+
+	if info, statErr := os.Stat(dir); statErr != nil || !info.IsDir() {
+		t.Fatalf("Open did not prepare the keystore dir: %v", statErr)
+	}
+
+	if err := cipher.Close(); err != nil {
+		t.Fatalf("Close() = %v", err)
+	}
+
+	// The slot must be free again, otherwise a second Open in the same
+	// process would be refused forever.
+	second, err := Open(context.Background(), Config{
+		KeystoreDir: dir,
+		AuthCode:    StaticAuthCode("placeholder-code"),
+		KeyServer:   "https://key.example.test",
+	})
+	if err != nil {
+		t.Fatalf("second Open() after Close = %v, want success", err)
+	}
+	if err := second.Close(); err != nil {
+		t.Fatalf("second Close() = %v", err)
+	}
+}
+
+func TestOpenRefusesConcurrentSecondCipher(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "keystore")
+	first, err := Open(context.Background(), Config{
+		KeystoreDir: dir,
+		AuthCode:    StaticAuthCode("placeholder-code"),
+		KeyServer:   "https://key.example.test",
+	})
+	if err != nil {
+		t.Fatalf("Open() = %v", err)
+	}
+	defer first.Close()
+
+	_, err = Open(context.Background(), Config{
+		KeystoreDir: filepath.Join(t.TempDir(), "keystore"),
+		AuthCode:    StaticAuthCode("placeholder-code"),
+		KeyServer:   "https://key.example.test",
+	})
+	if !errors.Is(err, ErrAlreadyOpen) {
+		t.Fatalf("second Open() = %v, want ErrAlreadyOpen (the C library keeps global state)", err)
+	}
+}
+
+func TestOpenHonoursCancelledContext(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	_, err := Open(ctx, Config{
+		KeystoreDir: filepath.Join(t.TempDir(), "keystore"),
+		AuthCode:    StaticAuthCode("placeholder-code"),
+		KeyServer:   "https://key.example.test",
+	})
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("Open() with a cancelled context = %v, want context.Canceled", err)
+	}
+}
+
+func TestEncryptWithoutUsableKeyReportsAuthCodeCause(t *testing.T) {
+	// A cold keystore forces a key request. With no reachable key server the
+	// operation must fail with a message that names the auth code, rather
+	// than a bare vendor return code.
+	cipher, err := Open(context.Background(), Config{
+		KeystoreDir: filepath.Join(t.TempDir(), "keystore"),
+		AuthCode: AuthCodeFunc(func(context.Context) (string, error) {
+			return "", errors.New("no code available in test")
+		}),
+		KeyServer: "https://key.example.test",
+	})
+	if err != nil {
+		t.Fatalf("Open() = %v", err)
+	}
+	defer cipher.Close()
+
+	_, err = cipher.EncryptMessage(context.Background(), "test-corp", "test-staff", []byte("hello"))
+	if err == nil {
+		t.Skip("the environment served a key without an auth code; nothing to assert")
+	}
+	if !strings.Contains(err.Error(), "auth code") {
+		t.Fatalf("EncryptMessage() = %v, want the error to name the auth code cause", err)
+	}
+}
+
+func TestCipherRejectsBadArgumentsBeforeCallingC(t *testing.T) {
+	cipher, err := Open(context.Background(), Config{
+		KeystoreDir: filepath.Join(t.TempDir(), "keystore"),
+		AuthCode:    StaticAuthCode("placeholder-code"),
+		KeyServer:   "https://key.example.test",
+	})
+	if err != nil {
+		t.Fatalf("Open() = %v", err)
+	}
+	defer cipher.Close()
+
+	if _, err := cipher.EncryptMessage(context.Background(), "", "staff", []byte("x")); !errors.Is(err, ErrNoCorpID) {
+		t.Fatalf("EncryptMessage() with no corpID = %v, want ErrNoCorpID", err)
+	}
+	// The vendor SDK dereferences the first byte of the payload, so an empty
+	// slice must never reach it.
+	if _, err := cipher.DecryptMessage(context.Background(), "corp", "staff", nil); !errors.Is(err, ErrEmptyPayload) {
+		t.Fatalf("DecryptMessage() with no payload = %v, want ErrEmptyPayload", err)
+	}
+}

internal/msgcrypto/cipher_stub.go

@@ -0,0 +1,34 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The constraint below is the exact negation of the one in cipher_safechat.go;
+// change both together. This file covers every default DWS build: the release
+// binaries are cross-compiled with CGO_ENABLED=0, and windows/arm64 has no
+// vendor static library even when the tag is set.
+
+//go:build !(safechat && cgo && (((darwin || linux) && (amd64 || arm64)) || (windows && amd64)))
+
+package msgcrypto
+
+import "context"
+
+// BackendVersion is empty because no backend is compiled in.
+const BackendVersion = ""
+
+// Available reports that this binary has no SafeChat backend, so callers should
+// not offer message encryption.
+func Available() bool { return false }
+
+// newBackend always fails here. Open checks Available first, so this exists to
+// keep the package compiling and to fail safe if that check is ever bypassed.
+func newBackend(context.Context, Config) (Cipher, error) { return nil, ErrUnavailable }

internal/msgcrypto/goproxy_authcode.go

@@ -0,0 +1,54 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package msgcrypto
+
+import "context"
+
+// mintAuthCodeForProxy is the goProxy-only mint path. domain is compared
+// locally and never forwarded. A successful mint invalidates any unconsumed
+// cache so a one-shot code cannot be reused.
+func mintAuthCodeForProxy(codes AuthCodeProvider, allowedHost, corpID, domain string) (string, error) {
+	if err := matchRedirectHost(domain, allowedHost); err != nil {
+		return "", err
+	}
+	if codes == nil {
+		return "", ErrNoAuthCodeProvider
+	}
+
+	var (
+		code string
+		err  error
+	)
+	if provider, ok := codes.(CorpAuthCodeProvider); ok {
+		code, err = provider.AuthCodeForCorp(context.Background(), corpID)
+	} else {
+		code, err = codes.AuthCode(context.Background())
+	}
+	if err != nil {
+		invalidateAuthCode(codes)
+		return "", err
+	}
+	if code == "" {
+		invalidateAuthCode(codes)
+		return "", ErrNoAuthCode
+	}
+	invalidateAuthCode(codes)
+	return code, nil
+}
+
+func invalidateAuthCode(codes AuthCodeProvider) {
+	if invalidator, ok := codes.(interface{ Invalidate() }); ok {
+		invalidator.Invalidate()
+	}
+}

internal/msgcrypto/goproxy_authcode_test.go

@@ -0,0 +1,99 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package msgcrypto
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"testing"
+	"time"
+)
+
+type corpCountingProvider struct {
+	mu    sync.Mutex
+	calls []string
+	code  string
+	err   error
+}
+
+func (p *corpCountingProvider) AuthCode(context.Context) (string, error) {
+	return p.AuthCodeForCorp(context.Background(), "")
+}
+
+func (p *corpCountingProvider) AuthCodeForCorp(_ context.Context, corpID string) (string, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.calls = append(p.calls, corpID)
+	if p.err != nil {
+		return "", p.err
+	}
+	if p.code != "" {
+		return p.code, nil
+	}
+	return "code-for-" + corpID, nil
+}
+
+func TestMintAuthCodeForProxyUsesCorpProvider(t *testing.T) {
+	inner := &corpCountingProvider{}
+	code, err := mintAuthCodeForProxy(inner, "sso.anhei.test", "ding_corp", "https://sso.anhei.test/login")
+	if err != nil || code != "code-for-ding_corp" {
+		t.Fatalf("mint = %q, %v; want code-for-ding_corp, nil", code, err)
+	}
+	if len(inner.calls) != 1 || inner.calls[0] != "ding_corp" {
+		t.Fatalf("corpIDs = %v, want [ding_corp]", inner.calls)
+	}
+}
+
+func TestMintAuthCodeForProxyInvalidatesUnconsumedCache(t *testing.T) {
+	inner := &countingProvider{code: "once"}
+	cache := NewCachedAuthCode(inner, time.Hour)
+
+	if _, err := cache.AuthCode(context.Background()); err != nil {
+		t.Fatalf("seed cache: %v", err)
+	}
+	if got := inner.callCount(); got != 1 {
+		t.Fatalf("seed fetches = %d, want 1", got)
+	}
+
+	code, err := mintAuthCodeForProxy(cache, "sso.anhei.test", "ding_corp", "https://sso.anhei.test/login")
+	if err != nil || code != "once" {
+		t.Fatalf("mint = %q, %v; want once, nil", code, err)
+	}
+
+	// Cache was invalidated after spend; next mint hits upstream again.
+	if _, err := mintAuthCodeForProxy(cache, "sso.anhei.test", "ding_corp", "sso.anhei.test"); err != nil {
+		t.Fatalf("second mint: %v", err)
+	}
+	if got := inner.callCount(); got != 2 {
+		t.Fatalf("upstream calls = %d, want 2 (seed reused once, then refetch)", got)
+	}
+}
+
+func TestMintAuthCodeForProxyRejectsDomainMismatchWithoutFetching(t *testing.T) {
+	inner := &corpCountingProvider{code: "once"}
+	_, err := mintAuthCodeForProxy(inner, "sso.anhei.test", "ding_corp", "evil.example.test")
+	if !errors.Is(err, ErrRedirectHostMismatch) {
+		t.Fatalf("mint = %v, want ErrRedirectHostMismatch", err)
+	}
+	if got := len(inner.calls); got != 0 {
+		t.Fatalf("upstream called %d times on domain mismatch, want 0", got)
+	}
+}
+
+func TestMintAuthCodeForProxyRequiresProvider(t *testing.T) {
+	if _, err := mintAuthCodeForProxy(nil, "", "ding_corp", ""); !errors.Is(err, ErrNoAuthCodeProvider) {
+		t.Fatalf("mint = %v, want ErrNoAuthCodeProvider", err)
+	}
+}

internal/msgcrypto/keyserver.go

@@ -0,0 +1,83 @@
+// Copyright 2026 Alibaba Group
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package msgcrypto
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+)
+
+// validateKeyServer requires an HTTPS URL with a host so the vendor C
+// library cannot pick the key-request destination.
+func validateKeyServer(raw string) error {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ErrNoKeyServer
+	}
+	u, err := url.Parse(raw)
+	if err != nil || u.Host == "" || u.Scheme == "" {
+		return fmt.Errorf("%w: %q", ErrInvalidKeyServer, raw)
+	}
+	if !strings.EqualFold(u.Scheme, "https") {
+		return fmt.Errorf("%w: %q", ErrKeyServerNotHTTPS, raw)
+	}
+	if hostnameOf(raw) == "" {
+		return fmt.Errorf("%w: %q", ErrInvalidKeyServer, raw)
+	}
+	return nil
+}
+
+// matchRedirectHost compares the goProxy domain to AllowedRedirectHost.
+// Both sides are reduced to a hostname. An empty domain or an empty
+// allowed host skips the check; the domain is never sent to portal.
+func matchRedirectHost(domain, allowed string) error {
+	domain = strings.TrimSpace(domain)
+	allowed = strings.TrimSpace(allowed)
+	if domain == "" || allowed == "" {
+		return nil
+	}
+	got := hostnameOf(domain)
+	want := hostnameOf(allowed)
+	if got == "" || want == "" || got != want {
+		return fmt.Errorf("%w: got %q, want %q", ErrRedirectHostMismatch, got, want)
+	}
+	return nil
+}
+
+// hostnameOf returns the lower-cased hostname of a URL, host:port, or bare
+// host. Path, query, userinfo and port are ignored.
+func hostnameOf(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	if strings.Contains(raw, "://") {
+		u, err := url.Parse(raw)
+		if err == nil {
+			if host := strings.ToLower(u.Hostname()); host != "" {
+				return host
+			}
+		}
+	}
+	candidate := raw
+	if i := strings.IndexAny(candidate, "/?"); i >= 0 {
+		candidate = candidate[:i]
+	}
+	if host, _, err := net.SplitHostPort(candidate); err == nil {
+		return strings.ToLower(host)
+	}
+	return strings.ToLower(candidate)
+}