docs(changelog): add IM pagination release note

Merge remote-tracking branch 'origin/main' into codex/im-page-all
fix(chat): bound automatic page delays
2026-08-12 19:28:29 +08:00 · 2026-08-12 19:17:29 +08:00 · 2026-08-12 16:43:55 +08:00 · 2026-08-12 15:39:41 +08:00 · 2026-08-12 15:39:25 +08:00 · 2026-08-12 14:59:18 +08:00
49 changed files with 192 additions and 2484 deletions
@@ -1,8 +0,0 @@
---
-category: Added
---
-
- **Agent version and extended context passthrough** (Aone 85384225) — adds
-  validated `DWS_AGENT_VER` and sensitive JSON `DWS_AGENT_EXT` metadata to
-  ordinary non-plugin MCP requests without forwarding it to A2A, OAuth,
-  Discovery, or third-party plugins.
@@ -1,5 +0,0 @@
---
-category: Changed
---
-
- **Chat message send help** - Clarifies Markdown image syntax for inline mixed text and images.
@@ -1,5 +0,0 @@
---
-category: Changed
---
-
- **Doc/drive/wiki routing descriptions** — clarifies the document-space container-vs-content boundary across the doc, drive, and wiki skill descriptions for more predictable first-round Agent selection, without changing CLI behavior.
@@ -19,12 +19,3 @@

 # Cache directory (optional, defaults to ~/.dws/cache)
 # DWS_CACHE_DIR=
-
-# Agent integration metadata (optional; ordinary non-plugin MCP requests only)
-# DWS_AGENT_PRODUCT=example-agent
-# DWS_AGENT_HOST=cloud
-# DWS_AGENT_VER=0.1.5
-# DWS_AGENT_EXT='{"umt":"example-redacted","miniwua":"example-redacted","ua":"ExampleAgent/0.1.5"}'
-# The outer single quotes above are shell syntax and are not part of the value.
-# DWS_AGENT_EXT is sensitive caller-declared JSON (max 8 KiB); never put real
-# tokens in committed files or use this metadata alone for authentication.
@@ -24,7 +24,6 @@ jobs:
      pull-requests: read
    outputs:
      changelog_only: ${{ steps.classify.outputs.changelog_only }}
-      release_seal_only: ${{ steps.classify.outputs.release_seal_only }}
      changelog_changed: ${{ steps.classify.outputs.changelog_changed }}
      docs_only: ${{ steps.classify.outputs.docs_only }}
      full_suite: ${{ steps.classify.outputs.full_suite }}
@@ -40,7 +39,6 @@ jobs:
        with:
          script: |
            let changelogOnly = false;
-            let releaseSealOnly = false;
            let changelogChanged = false;
            let docsOnly = false;
            let fullSuite = context.eventName === 'push';
@@ -164,43 +162,6 @@ jobs:
                filename === 'go.mod' ||
                filename === 'go.sum'
              );
-            const isExactReleaseSeal = (candidates) => {
-              const changelog = candidates.filter(
-                ({ filename, status, previous_filename }) =>
-                  filename === 'CHANGELOG.md' &&
-                  status === 'modified' &&
-                  !previous_filename
-              );
-              if (changelog.length !== 1 || candidates.length < 2) {
-                return false;
-              }
-              let version = '';
-              return candidates.every((file) => {
-                if (file.filename === 'CHANGELOG.md') {
-                  return file.status === 'modified' && !file.previous_filename;
-                }
-                if (
-                  file.status !== 'renamed' ||
-                  typeof file.filename !== 'string' ||
-                  typeof file.previous_filename !== 'string' ||
-                  file.additions !== 0 ||
-                  file.deletions !== 0
-                ) {
-                  return false;
-                }
-                const target = file.filename.match(
-                  /^\.changes\/released\/([0-9]+\.[0-9]+\.[0-9]+(?:-beta\.[1-9][0-9]*)?)\/([a-z0-9][a-z0-9._-]*\.md)$/
-                );
-                if (!target || file.previous_filename !== `.changes/${target[2]}`) {
-                  return false;
-                }
-                if (version && version !== target[1]) {
-                  return false;
-                }
-                version = target[1];
-                return true;
-              });
-            };
            const classifyFiles = (complete) => {
              const paths = files.flatMap(({ filename, previous_filename }) =>
                [filename, previous_filename].filter(
@@ -287,26 +248,19 @@ jobs:
                );
              }

-              const exactChangelogDiff =
+              changelogOnly =
                files.length === 1 &&
                files[0].filename === 'CHANGELOG.md' &&
                files[0].status === 'modified' &&
                !files[0].previous_filename;
-              releaseSealOnly = isExactReleaseSeal(files);
-              changelogOnly = exactChangelogDiff || releaseSealOnly;
              changelogChanged = files.some(
                ({ filename, previous_filename }) =>
                  filename === 'CHANGELOG.md' ||
                  previous_filename === 'CHANGELOG.md'
              );
              classifyFiles(true);
-              if (releaseSealOnly) {
-                fullSuite = false;
-              }
              fastPathTrust = changelogOnly
-                ? releaseSealOnly
-                  ? 'exact release-seal fragment archival and synthetic merge policy'
-                  : 'exact CHANGELOG-only revision and synthetic merge policy'
+                ? 'exact pull-request revision and synthetic merge policy'
                : docsOnly
                  ? 'documentation-only focused admission'
                  : fullSuite
@@ -341,8 +295,7 @@ jobs:
                    per_page: 100,
                  });
                files = Array.isArray(comparison.files) ? comparison.files : [];
-                const pushFilesComplete = files.length < 300;
-                classifyFiles(pushFilesComplete);
+                classifyFiles(files.length < 300);
                const linearFromValidatedTip =
                  comparison.status === 'ahead' &&
                  comparison.merge_base_commit?.sha === expectedBefore &&
@@ -354,10 +307,8 @@ jobs:
                  files[0].filename === 'CHANGELOG.md' &&
                  files[0].status === 'modified' &&
                  !files[0].previous_filename;
-                const exactReleaseSealDiff =
-                  pushFilesComplete && isExactReleaseSeal(files);

-                if (linearFromValidatedTip && (exactChangelogDiff || exactReleaseSealDiff)) {
+                if (linearFromValidatedTip && exactChangelogDiff) {
                  const requiredContexts = [
                    'Lint',
                    'Test',
@@ -408,15 +359,9 @@ jobs:

                  if (missing.length === 0 && nonSuccess.length === 0) {
                    changelogOnly = true;
-                    releaseSealOnly = exactReleaseSealDiff;
                    changelogChanged = true;
-                    if (releaseSealOnly) {
-                      fullSuite = false;
-                    }
                    fastPathTrust =
-                      releaseSealOnly
-                        ? `exact release-seal successor of validated ${expectedBefore}`
-                        : `exact CHANGELOG-only successor of validated ${expectedBefore}`;
+                      `exact CHANGELOG-only successor of validated ${expectedBefore}`;
                  } else {
                    fastPathTrust =
                      'predecessor Code Admission is not fully successful; ' +
@@ -431,7 +376,6 @@ jobs:
            }

            core.setOutput('changelog_only', String(changelogOnly));
-            core.setOutput('release_seal_only', String(releaseSealOnly));
            core.setOutput('changelog_changed', String(changelogChanged));
            core.setOutput('docs_only', String(docsOnly));
            core.setOutput('full_suite', String(fullSuite));
@@ -443,8 +387,7 @@ jobs:
            await core.summary
              .addHeading('Code Admission scope')
              .addRaw(`- Event: \`${context.eventName}\`\n`)
-              .addRaw(`- Metadata-only fast path: \`${changelogOnly}\`\n`)
-              .addRaw(`- Release-seal fragments only: \`${releaseSealOnly}\`\n`)
+              .addRaw(`- Exact modified CHANGELOG only: \`${changelogOnly}\`\n`)
              .addRaw(`- CHANGELOG touched: \`${changelogChanged}\`\n`)
              .addRaw(`- Documentation-only: \`${docsOnly}\`\n`)
              .addRaw(`- Full suite: \`${fullSuite}\`\n`)
@@ -459,14 +402,7 @@ jobs:

      - name: Record CHANGELOG-only fast path
        if: steps.classify.outputs.changelog_only == 'true'
-        env:
-          RELEASE_SEAL_ONLY: ${{ steps.classify.outputs.release_seal_only }}
-        run: |
-          if [ "$RELEASE_SEAL_ONLY" = true ]; then
-            echo "Lint is satisfied by the trusted release-seal fragment Policy path." >> "$GITHUB_STEP_SUMMARY"
-          else
-            echo "Lint is satisfied by the trusted CHANGELOG-only Policy path." >> "$GITHUB_STEP_SUMMARY"
-          fi
+        run: echo "Lint is satisfied by the trusted CHANGELOG-only Policy path." >> "$GITHUB_STEP_SUMMARY"

      - name: Record documentation-only fast path
        if: steps.classify.outputs.changelog_only != 'true' && steps.classify.outputs.docs_only == 'true'
@@ -1320,7 +1256,6 @@ jobs:
        env:
          CLASSIFIED_CHANGELOG_CHANGED: ${{ needs.lint.outputs.changelog_changed }}
          CHANGELOG_ONLY: ${{ needs.lint.outputs.changelog_only }}
-          RELEASE_SEAL_ONLY: ${{ needs.lint.outputs.release_seal_only }}
          PR_BASE_SHA: ${{ github.event.pull_request.base.sha }}
        run: |
          set -eu
@@ -1347,7 +1282,7 @@ jobs:
          fi

          mode=--content-only
-          if [ "$CHANGELOG_ONLY" = true ] && [ "$RELEASE_SEAL_ONLY" != true ]; then
+          if [ "$CHANGELOG_ONLY" = true ]; then
            mode=--fast-path
          fi
          ./scripts/policy/check-changelog-pr.sh \
@@ -1359,41 +1294,25 @@ jobs:
          PR_BASE_SHA: ${{ github.event.pull_request.base.sha }}
        run: ./scripts/policy/check-release-fragments.sh "$PR_BASE_SHA" HEAD

-      - name: Validate trusted main metadata-only push
+      - name: Validate trusted main CHANGELOG-only push
        if: github.event_name == 'push' && needs.lint.outputs.changelog_only == 'true'
        env:
          PUSH_BEFORE_SHA: ${{ github.event.before }}
          PUSH_AFTER_SHA: ${{ github.event.after }}
-          RELEASE_SEAL_ONLY: ${{ needs.lint.outputs.release_seal_only }}
        run: |
          set -eu
          test "$(git rev-parse HEAD)" = "$PUSH_AFTER_SHA" || {
            echo "checked-out push revision does not match event after SHA" >&2
            exit 1
          }
-          mode=--fast-path
-          if [ "$RELEASE_SEAL_ONLY" = true ]; then
-            mode=--content-only
-          fi
          ./scripts/policy/check-changelog-pr.sh \
-            "$mode" "$PUSH_BEFORE_SHA" "$PUSH_AFTER_SHA"
-          if [ "$RELEASE_SEAL_ONLY" = true ]; then
-            ./scripts/policy/check-release-fragments.sh \
-              "$PUSH_BEFORE_SHA" "$PUSH_AFTER_SHA"
-          fi
+            --fast-path "$PUSH_BEFORE_SHA" "$PUSH_AFTER_SHA"

      - name: Record CHANGELOG-only fast path
        if: needs.lint.outputs.changelog_only == 'true'
-        env:
-          RELEASE_SEAL_ONLY: ${{ needs.lint.outputs.release_seal_only }}
        run: |
-          if [ "$RELEASE_SEAL_ONLY" = true ]; then
-            echo "Only the trusted release-seal and fragment validators ran; executable sources are unchanged." \
-              >> "$GITHUB_STEP_SUMMARY"
-          else
-            echo "Only the trusted base-equivalent CHANGELOG validator ran; executable sources are unchanged." \
-              >> "$GITHUB_STEP_SUMMARY"
-          fi
+          echo "Only the trusted base-equivalent CHANGELOG validator ran; executable sources are unchanged." \
+            >> "$GITHUB_STEP_SUMMARY"

      - name: Validate scoped policy
        if: ${{ needs.lint.outputs.changelog_only != 'true' && (needs.lint.outputs.docs_only == 'true' || (needs.lint.outputs.full_suite != 'true' && needs.lint.outputs.interface_sensitive != 'true')) }}
@@ -6,64 +6,6 @@ The format is inspired by [Keep a Changelog](https://keepachangelog.com/) and th

 ## [Unreleased]

-## [1.0.58] - 2026-08-13
-
-This release promotes the sealed `v1.0.58-beta.6` contents to stable.
-
-### Changed
-
- **Expanded collaborative workflows** — adds full AI Table, Sheet, Minutes,
-  approval-event, Drive-comment, document export, and CSV workflow support,
-  including safer validation, explicit confirmation for writes, and
-  machine-readable completion receipts.
- **More capable Chat operations** — adds robot image/file messages, toolbar
-  management, streaming-card mentions, automatic pagination controls, and
-  clearer post-send ID, Markdown-image, paging, and result-shape guidance.
- **Reliable Agent and CLI contracts** — expands Agent-visible Chat and
-  Minutes commands, aligns bundled skills, improves schema/result envelopes,
-  and hardens parameter, pagination, runtime-token, and write-result
-  verification so ambiguous or incomplete operations fail closed.
- **Multi-skill install and upgrade** — makes the multi-skill layout the
-  default for fresh installs and upgrades while preserving an explicit legacy
-  mono option.
- **Safer release delivery** — strengthens release-equivalent compatibility,
-  sealing, package verification, and evaluation-dispatch checks for more
-  reliable cross-platform releases.
-
-## [1.0.58-beta.6] - 2026-08-13
-
-### Fixed
-
- **npm package verification for multi-skill installs** (#991) — aligns the
-  release verifier with the installer’s concrete Agent skill-root selection,
-  preventing valid multi-skill package layouts from failing release delivery.
-
-### Changed
-
- **Release-seal CI classification** (#987) — recognizes the reviewed
-  CHANGELOG-and-fragment archival shape while retaining release-contract and
-  lifecycle validation, reducing unrelated CI work for release-seal PRs.
-
-## [1.0.58-beta.5] - 2026-08-13
-
-### Added
-
- **Agent version and extended context passthrough** (Aone 85384225) — adds
-  validated `DWS_AGENT_VER` and sensitive JSON `DWS_AGENT_EXT` metadata to
-  ordinary non-plugin MCP requests without forwarding it to A2A, OAuth,
-  Discovery, or third-party plugins.
-
- **Drive file comments** (#961) — adds `dws drive comment list` and `dws drive comment create` for comments on ordinary preview files.
-
- **Chat automatic pagination controls** (#970) — adds bounded `--max-items` and cancellable `--page-delay` support to the core IM list shortcuts, with safe continuation metadata and truncation reporting.
-
-### Changed
-
- **Chat message send help** - Clarifies Markdown image syntax for inline mixed text and images.
-
- **Doc/drive/wiki routing descriptions** — clarifies the document-space container-vs-content boundary across the doc, drive, and wiki skill descriptions for more predictable first-round Agent selection, without changing CLI behavior.
-
-
 ## [1.0.58-beta.4] - 2026-08-12

 ### Added
@@ -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.58-beta.6"
+  version "1.0.58-beta.4"
  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.58-beta.6/dws-darwin-arm64.tar.gz"
-      sha256 "8f55497b84113f81b318e087c723016a02eded1cb5784cbd0811fe527d5852ca"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.4/dws-darwin-arm64.tar.gz"
+      sha256 "5c2ac92e35b1f1dba80234af8b0c9505b2883f4a37c1e73892b8a1c3087b7702"
    else
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.6/dws-darwin-amd64.tar.gz"
-      sha256 "b1762f1640310fb4100634fe54d9baace46384bb270c59148fe306275554d491"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.4/dws-darwin-amd64.tar.gz"
+      sha256 "93ef787770105fe1f0d27585adcac7b740aa6c37ff490275c4113814541ae095"
    end
  end

  on_linux do
    if Hardware::CPU.arm?
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.6/dws-linux-arm64.tar.gz"
-      sha256 "55393310ef0e1f24ea2c0dc22f00c0eb3b343edc2deb18d0db7838cda65af25d"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.4/dws-linux-arm64.tar.gz"
+      sha256 "011ce16a73d8fd24275e34c3122d3d0832c60cde2480f496018eb654059b5c05"
    else
-      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.6/dws-linux-amd64.tar.gz"
-      sha256 "3830f77d09b4da4aa39f0c08d772ff3fa1ffb837eb15bb417f97edbccb073b7d"
+      url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.4/dws-linux-amd64.tar.gz"
+      sha256 "847b17ff8a8d80dce38f0013eb35c77c102be16c9f98b955a632b983cd5ec104"
    end
  end

  resource "skills" do
-    url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.6/dws-skills.zip"
-    sha256 "f304a883a4f9e938b26a44692cd5a8d3d8704ba70ee7f33ba7c288434da72b6f"
+    url "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli/releases/download/v1.0.58-beta.4/dws-skills.zip"
+    sha256 "f5e0c72cc92cb7e8886409319cf68bbbfc7740e969bd39a389b74af4befdbc66"
  end

  def install
@@ -1,6 +1,6 @@
 # CLI flag 兼容迁移治理

-本文定义一种受控迁移：保留旧 flag 的可执行兼容性，但把它从 Help 与 Agent Schema 中隐藏，并将新的规范 flag 设为唯一可见入口。迁移必须保持原 flag 的 requiredness：optional 只能迁到 optional，required 只能迁到 required。它只解决这一种精确变更，不是通用 breaking-change 豁免。
+本文定义一种受控迁移：保留旧 flag 的可执行兼容性，但把它从 Help 与 Agent Schema 中隐藏，并将新的规范 flag 提升为必填。它只解决这一种精确变更，不是通用 breaking-change 豁免。

 同名 flag 的精确类型迁移属于另一类评审机制，只能进入
 `internal/interfacesnapshot/reviewed.go` 与 legacy smoke helper 的镜像表；flag rename
@@ -50,7 +50,7 @@ scripts/policy/interface-migrations/approved-flag-migrations-v1.json
 | 阶段 | PR 可以做什么 | 必须满足的快照状态 |
 |---|---|---|
 | 1. 治理审批 | 新增 `state: pending` 的精确记录；不得在同一个 PR 修改产品 surface | candidate 和 merge-base 都与记录中的 `before` 完全一致；该记录不改变 stable 的判断 |
-| 2. 产品迁移 | merge-base 已拥有 `pending` 后，按记录一次性切到精确 `after`，并把记录改为 `state: consumed` | legacy 仍存在但由 visible 变 hidden，且声明 `alias_of`；canonical 的 requiredness 与 legacy 迁移前完全一致 |
+| 2. 产品迁移 | merge-base 已拥有 `pending` 后，按记录一次性切到精确 `after`，并把记录改为 `state: consumed` | legacy 仍存在但由 visible 变 hidden，且声明 `alias_of`；canonical 达到记录的必填状态 |
 | 3. 保留回执 | 产品 PR 合入后，如果 stable 仍是 `before`，继续保留 `consumed` | merge-base 或 stable 仍有任一份尚未达到 `after` |
 | 4. 单独清理 | 当 merge-base 和 stable 都已经是 `after`，在后续 PR 删除该记录 | 两份参考快照均精确匹配 `after`；继续保留过期回执会被门禁拒绝 |

@@ -122,7 +122,7 @@ scripts/policy/interface-migrations/approved-flag-migrations-v1.json
 一条 base-owned、状态正确且前后快照精确匹配的记录，只会从普通兼容报告中移除以下两类预期 finding：

 1. legacy flag 的 `flag_became_hidden`（visible → hidden）；
-2. required legacy 被新增的 required canonical 替代时产生的 `required_flag_added`；如果 canonical 在 before 阶段只是 hidden 占位符，则允许它在转为公开拼写时继承 legacy 的 requiredness。已有的 visible canonical 不允许借 rename 改变 requiredness。
+2. canonical flag 的 `required_flag_added`（新增时即必填）或 `flag_became_required`（已有 flag 从可选变必填）。

 以下变化仍按普通兼容规则阻塞，不能被迁移记录掩盖：

@@ -145,7 +145,7 @@ legacy 名改为 canonical 名。Schema adapter 只接受已经由三方 Interfa
  `required` / `cli_required` 或重写 constraint；
 - rename 前后的 `type`、`property`、`interface_type`、default、format、enum 与
  `required_when` 必须完全一致；
- `required` / `cli_required` 必须在 rename 前后完全一致，升高或降低都失败；
+- `required` / `cli_required` 只能保持不变或按审批从 `false` 提升为 `true`，禁止降低；
 - constraint 只允许在同一 tool 内按已枚举的 legacy → canonical map 做 member 替换、
  排序与去重；group kind、非迁移 member 或 group 增删仍然阻塞；
 - 多个 legacy 指向同一 canonical 时，所有历史 parameter signature 必须一致，否则
@@ -7,8 +7,6 @@
 | `DWS_CONFIG_DIR` | Override default config directory / 覆盖默认配置目录 |
 | `DWS_AGENT_PRODUCT` | Optional, caller-declared Agent product sent as `x-dws-agent-product` (for example `qwenwork`) for downstream logs/BI and used as the IM `clawType` display label when `--ai-tag` is enabled. `--ai-tag` defaults to `true`, so a configured Product changes the displayed label by default. With `--ai-tag=false`, native `chat message send` / `reply` calls send an empty `clawType`, while shortcut calls omit the argument. Surrounding ASCII spaces/tabs are trimmed; the remaining value must be at most 64 bytes and match `^[A-Za-z0-9][A-Za-z0-9_-]*$`. Unset or empty values omit the Header and use the edition's IM display default. This client never uses Product to change the separate HTTP `claw-type` PAT/routing label. / 可选、由调用方声明的 Agent 产品标识，经校验后作为 `x-dws-agent-product` 发送，并用于 IM 小尾巴；`--ai-tag` 默认为 `true`，因此配置 Product 后默认会改变展示标签。使用 `--ai-tag=false` 时，原生 `chat message send` / `reply` 发送空的 `clawType`，shortcut 调用则省略该参数。未设置时省略请求头且 IM 使用发行版默认值；本客户端不会用 Product 修改独立的 HTTP `claw-type` |
 | `DWS_AGENT_HOST` | Optional, caller-declared Agent runtime form sent as `x-dws-agent-host` (for example `cloud` or `desktop`) for downstream logs/BI. Surrounding ASCII spaces/tabs are trimmed; the remaining value must be at most 64 bytes and match `^[a-z0-9][a-z0-9_-]*$`; unset values are omitted. This client does not use Host for PAT, authentication, Discovery, or MCP endpoint selection. / 可选、由调用方声明的 Agent 运行形态，经校验后作为 `x-dws-agent-host` 发送给下游日志/BI；本客户端不使用该值进行 PAT、鉴权、Discovery 或 MCP 端点选择，未设置时省略 |
-| `DWS_AGENT_VER` | Optional caller-declared Agent version / 可选、由调用方声明的 Agent 版本。After trimming surrounding ASCII spaces/tabs, the value must be at most 64 bytes and match `^[A-Za-z0-9][A-Za-z0-9._+-]*$`; a non-empty valid value is sent as `x-dws-agent-ver`, while unset or empty values omit the Header. / 去除首尾 ASCII 空格和 Tab 后，值不得超过 64 字节且必须匹配上述格式；合法非空值通过 `x-dws-agent-ver` 发送，未设置或空值则省略请求头 |
-| `DWS_AGENT_EXT` | Optional caller-declared Agent extended context / 可选、由调用方声明的 Agent 扩展上下文。The value must be a UTF-8 JSON object no larger than 8 KiB, is compacted before being sent as the sensitive `x-dws-agent-ext` Header, and may use the recommended keys `umt`, `miniwua`, and `ua`; unknown keys remain supported. Unset or empty values omit the Header. / 值必须是 UTF-8 JSON 对象且不得超过 8 KiB，压缩后通过敏感请求头 `x-dws-agent-ext` 发送；推荐使用 `umt`、`miniwua`、`ua`，同时允许未知扩展键。未设置或空值则省略请求头 |
 | `DWS_<PRODUCT>_MCP_URL` | Override a product MCP endpoint for local development / 本地开发时覆盖指定产品 MCP endpoint |
 | `DWS_CLIENT_ID` | OAuth client ID (DingTalk AppKey) |
 | `DWS_CLIENT_SECRET` | OAuth client secret (DingTalk AppSecret) |
@@ -16,47 +14,6 @@
 | `DWS_ALLOW_HTTP_ENDPOINTS` | Set `1` to allow HTTP for loopback during dev / 设为 `1` 允许回环地址 HTTP，仅用于开发调试 |
 | `DWS_DISABLE_KEYCHAIN` | macOS only. Set `1` to skip system Keychain for the encryption key and use file-based storage (same scheme as Linux). For sandboxed runtimes (e.g. Codex App) that block Keychain APIs. Weakens at-rest protection — DEK and ciphertext live in the same directory. / 仅 macOS。设为 `1` 时跳过系统 Keychain，密钥以文件形式存储（与 Linux 一致）。用于 Keychain API 被拦截的沙盒环境（如 Codex App）。代价是 DEK 与密文同目录，保护强度低于默认方案 |

-### Agent Version and Extended Context / Agent 版本与扩展上下文
-
-`DWS_AGENT_VER` and `DWS_AGENT_EXT` are sent only on the CLI's ordinary,
-non-plugin MCP requests. They do not change the standard HTTP `User-Agent` or
-the separate `X-Cli-Version` that identifies the DWS CLI version, and they are
-not forwarded to A2A, OAuth, Discovery, or third-party plugin requests.
-
-`DWS_AGENT_EXT` is one JSON-object Header rather than a set of Headers. The
-recommended keys are `umt`, `miniwua`, and `ua`, but the open-source CLI keeps
-the object extensible and does not enforce a key allowlist. For example, using
-fictional, redacted values:
-
-```bash
-DWS_AGENT_VER=0.1.5
-DWS_AGENT_EXT='{"umt":"example-redacted","miniwua":"example-redacted","ua":"ExampleAgent/0.1.5"}'
-```
-
-The shell's outer single quotes group the JSON and are not part of the
-environment-variable value. The CLI trims surrounding ASCII spaces/tabs,
-omits either Header when its value is empty, and compacts EXT to a single-line
-JSON object. A representative current payload is about 657 bytes, well below
-the 8 KiB limit; integrations must still enforce the limit because values can
-grow. EXT may contain sensitive device or runtime signals: the CLI masks it in
-configuration and logs, and removes it on a cross-host redirect.
-
-Both values are declared by the caller and are therefore forgeable. They can
-support compatibility checks, diagnostics, and observability, but they are not
-credentials or attestations and must never be sufficient on their own to
-authenticate a caller or authorize access.
-
-`DWS_AGENT_VER` 与 `DWS_AGENT_EXT` 仅随 CLI 发起的普通非插件 MCP 请求发送，不会
-改变标准 HTTP `User-Agent`，也不会覆盖标识 DWS CLI 自身版本的 `X-Cli-Version`；
-二者不会进入 A2A、OAuth、Discovery 或第三方插件请求。EXT 使用单个 JSON 对象
-请求头，不拆成多个子请求头；推荐键为 `umt`、`miniwua`、`ua`，但开源 CLI 不限制
-扩展键。Shell 示例中的外层单引号只用于保护 JSON，不属于环境变量值。当前典型负载
-约为 657 字节，远低于 8 KiB 上限，但集成方仍须遵守大小限制。EXT 可能包含敏感的
-设备或运行时信号，配置展示和日志会对其脱敏，跨主机重定向时也会移除该请求头。
-
-这两个值都由调用方自行声明，可以被伪造；它们可用于兼容性判断、诊断和可观测性，
-但不是凭据或可信证明，不能单独用于身份认证或访问授权。
-
 ### Agent Product, Host, and `claw-type` / Agent 产品、运行形态与 `claw-type`

 `DWS_AGENT_PRODUCT` and `DWS_AGENT_HOST` are caller-declared observation
@@ -165,7 +165,7 @@ func TestResolveIdentityHeadersOmitsAbsentOrInvalidAgentHost(t *testing.T) {
 	}
 }

-func TestCrossPlatformCoverageRootRejectsInvalidAgentHostBeforeEditionHook(t *testing.T) {
+func TestRootRejectsInvalidAgentHostBeforeEditionHook(t *testing.T) {
 	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
 	const invalidValue = "DO_NOT_ECHO"
 	t.Setenv(envDWSAgentHost, invalidValue)
@@ -1,248 +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 app
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"os"
-	"regexp"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/executor"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/transport"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/configmeta"
-)
-
-const (
-	envDWSAgentVersion     = "DWS_AGENT_VER"
-	envDWSAgentExt         = "DWS_AGENT_EXT"
-	maxAgentVersionBytes   = 64
-	maxAgentExtensionBytes = 8 * 1024
-)
-
-var agentVersionPattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._+-]*$`)
-
-type agentMetadataSnapshot struct {
-	version    string
-	ext        string
-	versionErr error
-	extErr     error
-}
-
-type agentMetadataSnapshotContextKey struct{}
-
-func (snapshot agentMetadataSnapshot) validationError() error {
-	if snapshot.versionErr != nil {
-		return snapshot.versionErr
-	}
-	return snapshot.extErr
-}
-
-func contextWithAgentMetadataSnapshot(ctx context.Context, snapshot agentMetadataSnapshot) context.Context {
-	return context.WithValue(ctx, agentMetadataSnapshotContextKey{}, snapshot)
-}
-
-func agentMetadataSnapshotFromContext(ctx context.Context) (agentMetadataSnapshot, bool) {
-	if ctx == nil {
-		return agentMetadataSnapshot{}, false
-	}
-	snapshot, ok := ctx.Value(agentMetadataSnapshotContextKey{}).(agentMetadataSnapshot)
-	return snapshot, ok
-}
-
-func init() {
-	configmeta.Register(configmeta.ConfigItem{
-		Name:        envDWSAgentVersion,
-		Category:    configmeta.CategoryExternal,
-		Description: "调用 DWS 的 Agent 版本；仅作为 x-dws-agent-ver 透传到非插件 MCP 请求",
-		Example:     "1.2.3-beta.1+build.7",
-	})
-	configmeta.Register(configmeta.ConfigItem{
-		Name:        envDWSAgentExt,
-		Category:    configmeta.CategoryExternal,
-		Description: "调用 DWS 的 Agent 扩展上下文 JSON；仅作为 x-dws-agent-ext 透传到非插件 MCP 请求",
-		Example:     `{"umt":"<token>","miniwua":"<token>","ua":"agent/1.0"}`,
-		Sensitive:   true,
-	})
-}
-
-// parseAgentVersion normalizes and validates the caller-declared Agent
-// version. Only surrounding ASCII spaces and tabs are trimmed. An unset or
-// ASCII-whitespace-only value means "do not emit".
-func parseAgentVersion(raw string) (string, error) {
-	value := strings.Trim(raw, " \t")
-	if value == "" {
-		return "", nil
-	}
-	if len(value) > maxAgentVersionBytes || !agentVersionPattern.MatchString(value) {
-		return "", invalidAgentVersionError()
-	}
-	return value, nil
-}
-
-// parseAgentExt validates one generic JSON object and returns its compact
-// one-line representation. Raw control characters other than horizontal tab
-// are rejected before JSON parsing; escaped JSON control characters remain
-// valid because they are safe on the HTTP header wire.
-func parseAgentExt(raw string) (string, error) {
-	if len(raw) > maxAgentExtensionBytes || !utf8.ValidString(raw) {
-		return "", invalidAgentExtError()
-	}
-	for _, r := range raw {
-		if unicode.IsControl(r) && r != '\t' {
-			return "", invalidAgentExtError()
-		}
-	}
-
-	value := strings.Trim(raw, " \t")
-	if value == "" {
-		return "", nil
-	}
-
-	var compact bytes.Buffer
-	if err := json.Compact(&compact, []byte(value)); err != nil {
-		return "", invalidAgentExtError()
-	}
-	compactBytes := compact.Bytes()
-	if len(compactBytes) > maxAgentExtensionBytes || len(compactBytes) < 2 || compactBytes[0] != '{' {
-		return "", invalidAgentExtError()
-	}
-	return compact.String(), nil
-}
-
-func invalidAgentVersionError() error {
-	return apperrors.NewValidation(
-		"DWS_AGENT_VER must be at most 64 bytes and match ^[A-Za-z0-9][A-Za-z0-9._+-]*$",
-		apperrors.WithReason("invalid_agent_version"),
-	)
-}
-
-func invalidAgentExtError() error {
-	return apperrors.NewValidation(
-		"DWS_AGENT_EXT must be a UTF-8 JSON object of at most 8192 bytes without raw control characters",
-		apperrors.WithReason("invalid_agent_ext"),
-	)
-}
-
-// readAgentMetadataSnapshot reads both environment variables from one
-// os.Environ snapshot, then parses them once. Normal CLI execution retains the
-// validated result through the invocation so hooks and transport observe the
-// same pair even in an embedding process that mutates its environment.
-func readAgentMetadataSnapshot() agentMetadataSnapshot {
-	var rawVersion, rawExt string
-	for _, entry := range os.Environ() {
-		key, value, _ := strings.Cut(entry, "=")
-		switch key {
-		case envDWSAgentVersion:
-			rawVersion = value
-		case envDWSAgentExt:
-			rawExt = value
-		}
-	}
-	version, versionErr := parseAgentVersion(rawVersion)
-	ext, extErr := parseAgentExt(rawExt)
-	return agentMetadataSnapshot{
-		version:    version,
-		ext:        ext,
-		versionErr: versionErr,
-		extErr:     extErr,
-	}
-}
-
-// removeAgentMetadataHeaders removes every case variant so edition or
-// credential hooks cannot smuggle MCP-only metadata into shared transports.
-func removeAgentMetadataHeaders(headers map[string]string) {
-	for key := range headers {
-		if strings.EqualFold(key, transport.HeaderAgentVersion) ||
-			strings.EqualFold(key, transport.HeaderAgentExt) {
-			delete(headers, key)
-		}
-	}
-}
-
-// applyAgentMetadataHeaders applies validated environment values as the final
-// authority for non-plugin MCP requests. Invalid values are omitted on
-// library paths that bypass root validation; normal CLI execution rejects
-// them before hooks or network access.
-func applyAgentMetadataHeaders(headers map[string]string) map[string]string {
-	return applyAgentMetadataSnapshot(headers, readAgentMetadataSnapshot())
-}
-
-func applyAgentMetadataSnapshot(headers map[string]string, snapshot agentMetadataSnapshot) map[string]string {
-	removeAgentMetadataHeaders(headers)
-
-	if (snapshot.versionErr != nil || snapshot.version == "") && (snapshot.extErr != nil || snapshot.ext == "") {
-		return headers
-	}
-	if headers == nil {
-		headers = make(map[string]string)
-	}
-	if snapshot.versionErr == nil && snapshot.version != "" {
-		headers[transport.HeaderAgentVersion] = snapshot.version
-	}
-	if snapshot.extErr == nil && snapshot.ext != "" {
-		headers[transport.HeaderAgentExt] = snapshot.ext
-	}
-	return headers
-}
-
-// resolveMCPRequestHeaders adds Agent version and extension metadata only to
-// the built-in DingTalk MCP request path. Shared identity consumers (notably
-// A2A) continue to use resolveIdentityHeaders and never receive these fields.
-func resolveMCPRequestHeaders() map[string]string {
-	return resolveMCPRequestHeadersWithSnapshot(readAgentMetadataSnapshot())
-}
-
-func resolveMCPRequestHeadersWithSnapshot(snapshot agentMetadataSnapshot) map[string]string {
-	return applyAgentMetadataSnapshot(resolveIdentityHeaders(), snapshot)
-}
-
-// resolveMCPRequestHeadersForInvocation resolves one immutable Header snapshot
-// for an invocation. The helper-only mcp-meta server performs endpoint
-// discovery rather than an ordinary MCP product call, so caller-declared
-// Agent metadata must not cross that boundary.
-func resolveMCPRequestHeadersForInvocation(invocation executor.Invocation, snapshots ...agentMetadataSnapshot) map[string]string {
-	headers := resolveIdentityHeaders()
-	if strings.EqualFold(strings.TrimSpace(invocation.CanonicalProduct), mcpMetaServerID) {
-		return headers
-	}
-	snapshot := readAgentMetadataSnapshot()
-	if len(snapshots) > 0 {
-		snapshot = snapshots[0]
-	}
-	return applyAgentMetadataSnapshot(headers, snapshot)
-}
-
-// pluginRequestHeaders returns a private, sanitized copy of plugin-owned
-// Headers. Third-party plugins never receive DWS-owned Agent metadata, even if
-// their manifest tries to declare the reserved Header names itself.
-func pluginRequestHeaders(pluginAuth *PluginAuth) map[string]string {
-	if pluginAuth == nil || len(pluginAuth.ExtraHeaders) == 0 {
-		return nil
-	}
-	headers := make(map[string]string, len(pluginAuth.ExtraHeaders))
-	for key, value := range pluginAuth.ExtraHeaders {
-		headers[key] = value
-	}
-	removeAgentMetadataHeaders(headers)
-	if len(headers) == 0 {
-		return nil
-	}
-	return headers
-}
@@ -1,743 +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 app
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"maps"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/audit"
-	apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/executor"
-	outputpkg "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/output"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/pipeline"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/transport"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/agentproduct"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/configmeta"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/edition"
-	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/pkg/mcptypes"
-	"github.com/spf13/cobra"
-)
-
-func TestCrossPlatformCoverageParseAgentVersion(t *testing.T) {
-	var nilContext context.Context
-	if _, ok := agentMetadataSnapshotFromContext(nilContext); ok {
-		t.Fatal("nil context unexpectedly contained Agent metadata")
-	}
-	wantSnapshot := agentMetadataSnapshot{version: "context-version", ext: "{}"}
-	if got, ok := agentMetadataSnapshotFromContext(contextWithAgentMetadataSnapshot(context.Background(), wantSnapshot)); !ok || got != wantSnapshot {
-		t.Fatalf("context Agent metadata = %#v, %v; want %#v", got, ok, wantSnapshot)
-	}
-
-	valid := []struct {
-		name string
-		raw  string
-		want string
-	}{
-		{name: "unset", raw: "", want: ""},
-		{name: "ASCII whitespace only", raw: " \t ", want: ""},
-		{name: "semantic version", raw: "1.2.3", want: "1.2.3"},
-		{name: "pre-release and build", raw: " v1.2.3-rc.1+build_7 ", want: "v1.2.3-rc.1+build_7"},
-		{name: "maximum length", raw: strings.Repeat("a", maxAgentVersionBytes), want: strings.Repeat("a", maxAgentVersionBytes)},
-	}
-	for _, tc := range valid {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := parseAgentVersion(tc.raw)
-			if err != nil {
-				t.Fatalf("parseAgentVersion() error = %v", err)
-			}
-			if got != tc.want {
-				t.Fatalf("parseAgentVersion() = %q, want %q", got, tc.want)
-			}
-		})
-	}
-
-	invalid := []struct {
-		name string
-		raw  string
-	}{
-		{name: "leading punctuation", raw: "-1.2.3"},
-		{name: "internal space", raw: "1.2 3"},
-		{name: "slash", raw: "1.2/3"},
-		{name: "line feed", raw: "1.2.3\n"},
-		{name: "carriage return", raw: "1.2.3\r"},
-		{name: "NUL", raw: "1.2\x003"},
-		{name: "Unicode", raw: "版本1"},
-		{name: "too long", raw: strings.Repeat("a", maxAgentVersionBytes+1)},
-	}
-	for _, tc := range invalid {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := parseAgentVersion(tc.raw)
-			if err == nil || got != "" {
-				t.Fatalf("parseAgentVersion(%q) = %q, %v; want validation error", tc.raw, got, err)
-			}
-			assertAgentMetadataValidationError(t, err, "invalid_agent_version", tc.raw)
-		})
-	}
-}
-
-func TestCrossPlatformCoverageParseAgentExt(t *testing.T) {
-	boundary := `{"x":"` + strings.Repeat("a", maxAgentExtensionBytes-8) + `"}`
-	if len(boundary) != maxAgentExtensionBytes {
-		t.Fatalf("invalid boundary fixture size: %d", len(boundary))
-	}
-
-	valid := []struct {
-		name string
-		raw  string
-		want string
-	}{
-		{name: "unset", raw: "", want: ""},
-		{name: "ASCII whitespace only", raw: " \t ", want: ""},
-		{name: "empty object", raw: "{}", want: "{}"},
-		{name: "compact generic object", raw: " \t{ \"umt\": \"masked\",\t \"nested\": { \"ok\": true }, \"unknown\": [1, 2] }\t ", want: `{"umt":"masked","nested":{"ok":true},"unknown":[1,2]}`},
-		{name: "Unicode value", raw: `{"ua":"千问办公/1.0"}`, want: `{"ua":"千问办公/1.0"}`},
-		{name: "escaped control remains safe", raw: `{"ua":"line\nnext"}`, want: `{"ua":"line\nnext"}`},
-		{name: "maximum length", raw: boundary, want: boundary},
-	}
-	for _, tc := range valid {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := parseAgentExt(tc.raw)
-			if err != nil {
-				t.Fatalf("parseAgentExt() error = %v", err)
-			}
-			if got != tc.want {
-				t.Fatalf("parseAgentExt() = %q, want %q", got, tc.want)
-			}
-		})
-	}
-
-	invalidUTF8 := string([]byte{'{', '"', 'x', '"', ':', '"', 0xff, '"', '}'})
-	invalid := []struct {
-		name string
-		raw  string
-	}{
-		{name: "too long raw input", raw: strings.Repeat(" ", maxAgentExtensionBytes+1)},
-		{name: "invalid UTF-8", raw: invalidUTF8},
-		{name: "array", raw: `[]`},
-		{name: "string", raw: `"value"`},
-		{name: "number", raw: `1`},
-		{name: "boolean", raw: `true`},
-		{name: "null", raw: `null`},
-		{name: "malformed object", raw: `{"secret":"DO_NOT_ECHO"`},
-		{name: "trailing value", raw: `{} {}`},
-		{name: "line feed", raw: "{\n}"},
-		{name: "carriage return", raw: "{\r}"},
-		{name: "NUL", raw: "{\x00}"},
-		{name: "vertical tab", raw: "{\v}"},
-		{name: "form feed", raw: "{\f}"},
-		{name: "DEL", raw: "{\x7f}"},
-		{name: "C1 control", raw: "{\u0085}"},
-	}
-	for _, tc := range invalid {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := parseAgentExt(tc.raw)
-			if err == nil || got != "" {
-				t.Fatalf("parseAgentExt() = %q, %v; want validation error", got, err)
-			}
-			assertAgentMetadataValidationError(t, err, "invalid_agent_ext", tc.raw)
-		})
-	}
-}
-
-func assertAgentMetadataValidationError(t *testing.T, err error, reason, raw string) {
-	t.Helper()
-	var appErr *apperrors.Error
-	if !errors.As(err, &appErr) {
-		t.Fatalf("error type = %T, want *errors.Error", err)
-	}
-	if appErr.Category != apperrors.CategoryValidation || appErr.Reason != reason {
-		t.Fatalf("error = category %q reason %q, want validation/%s", appErr.Category, appErr.Reason, reason)
-	}
-	if strings.Contains(raw, "DO_NOT_ECHO") && strings.Contains(err.Error(), "DO_NOT_ECHO") {
-		t.Fatalf("error must not echo invalid value: %v", err)
-	}
-}
-
-func TestCrossPlatformCoverageAgentMetadataConfigRegistrationAndMasking(t *testing.T) {
-	items := configmeta.All()
-	var versionItem, extItem *configmeta.ConfigItem
-	for i := range items {
-		switch items[i].Name {
-		case envDWSAgentVersion:
-			versionItem = &items[i]
-		case envDWSAgentExt:
-			extItem = &items[i]
-		}
-	}
-	if versionItem == nil || extItem == nil {
-		t.Fatalf("Agent metadata config registration missing: version=%v ext=%v", versionItem != nil, extItem != nil)
-	}
-	if versionItem.Category != configmeta.CategoryExternal || versionItem.Sensitive {
-		t.Fatalf("version config metadata = %#v", *versionItem)
-	}
-	if extItem.Category != configmeta.CategoryExternal || !extItem.Sensitive {
-		t.Fatalf("extension config metadata = %#v", *extItem)
-	}
-
-	const canary = `{"umt":"SENSITIVE_CANARY"}`
-	t.Setenv(envDWSAgentExt, canary)
-	got, ok := configmeta.Resolve(envDWSAgentExt)
-	if !ok || got == "" || strings.Contains(got, "SENSITIVE_CANARY") || got == canary {
-		t.Fatalf("sensitive extension was not masked: value=%q ok=%v", got, ok)
-	}
-
-	t.Setenv(envDWSAgentVersion, "9.8.7")
-	command := newConfigListCommand()
-	var output strings.Builder
-	command.SetOut(&output)
-	command.SetArgs([]string{"--category", string(configmeta.CategoryExternal), "--show-values", "--json"})
-	if err := command.Execute(); err != nil {
-		t.Fatalf("config list failed: %v", err)
-	}
-	rawOutput := output.String()
-	if !json.Valid([]byte(rawOutput)) {
-		t.Fatalf("config list emitted invalid JSON: %q", rawOutput)
-	}
-	if !strings.Contains(rawOutput, envDWSAgentVersion) || !strings.Contains(rawOutput, envDWSAgentExt) {
-		t.Fatalf("config list omitted Agent metadata variables: %s", rawOutput)
-	}
-	if strings.Contains(rawOutput, "SENSITIVE_CANARY") || strings.Contains(rawOutput, canary) {
-		t.Fatalf("config list leaked Agent extension: %s", rawOutput)
-	}
-}
-
-func TestCrossPlatformCoverageResolveMCPRequestHeadersScopesAndFinalizesAgentMetadata(t *testing.T) {
-	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
-	t.Setenv(envDWSAgentHost, "")
-	t.Setenv(agentproduct.EnvName, "")
-	t.Setenv(envDWSAgentVersion, " 1.2.3-rc.1 ")
-	t.Setenv(envDWSAgentExt, " { \"umt\": \"masked\", \"unknown\": true } ")
-
-	oldEdition := edition.Get()
-	t.Cleanup(func() { edition.Override(oldEdition) })
-	edition.Override(&edition.Hooks{
-		MergeHeaders: func(headers map[string]string) map[string]string {
-			headers["X-Dws-Agent-Ver"] = "merge-must-not-win"
-			headers["X-Dws-Agent-Ext"] = `{"source":"merge"}`
-			return headers
-		},
-		EnterpriseCredentialHeaders: func(headers map[string]string) map[string]string {
-			headers[transport.HeaderAgentVersion] = "credential-must-not-win"
-			headers[transport.HeaderAgentExt] = `{"source":"credential"}`
-			return headers
-		},
-	})
-
-	for name, headers := range map[string]map[string]string{
-		"shared identity": resolveIdentityHeaders(),
-		"A2A export":      MCPIdentityHeaders(),
-	} {
-		if hasHeaderFold(headers, transport.HeaderAgentVersion) || hasHeaderFold(headers, transport.HeaderAgentExt) {
-			t.Fatalf("%s leaked MCP-only metadata: %#v", name, headers)
-		}
-	}
-
-	headers := resolveMCPRequestHeaders()
-	if got := headers[transport.HeaderAgentVersion]; got != "1.2.3-rc.1" {
-		t.Fatalf("%s = %q, want 1.2.3-rc.1", transport.HeaderAgentVersion, got)
-	}
-	if got := headers[transport.HeaderAgentExt]; got != `{"umt":"masked","unknown":true}` {
-		t.Fatalf("%s = %q", transport.HeaderAgentExt, got)
-	}
-	if got := headers[transport.HeaderVersion]; got != version {
-		t.Fatalf("%s = %q, want CLI version %q", transport.HeaderVersion, got, version)
-	}
-	if _, ok := headers["User-Agent"]; ok {
-		t.Fatal("Agent extension must not create or replace the standard User-Agent header")
-	}
-	for _, key := range []string{"umt", "miniwua", "ua", "x-dws-agent-umt", "x-dws-agent-miniwua", "x-dws-agent-ua"} {
-		if hasHeaderFold(headers, key) {
-			t.Fatalf("Agent extension was split into an extra header %q: %#v", key, headers)
-		}
-	}
-
-	// Library paths are best-effort: one invalid value is omitted without
-	// suppressing the other valid field or preserving hook-injected values.
-	t.Setenv(envDWSAgentExt, `{"secret":"DO_NOT_ECHO"`)
-	headers = resolveMCPRequestHeaders()
-	if got := headers[transport.HeaderAgentVersion]; got != "1.2.3-rc.1" {
-		t.Fatalf("valid version was suppressed: %q", got)
-	}
-	if hasHeaderFold(headers, transport.HeaderAgentExt) {
-		t.Fatalf("invalid extension or hook value leaked: %#v", headers)
-	}
-
-	// Exercise the nil-map and empty-input library paths. An absent environment
-	// must not allocate a map, while an EXT-only value must allocate one and
-	// remain a single compact Header.
-	t.Setenv(envDWSAgentVersion, "")
-	t.Setenv(envDWSAgentExt, "")
-	if got := applyAgentMetadataHeaders(nil); got != nil {
-		t.Fatalf("empty metadata allocated headers: %#v", got)
-	}
-	t.Setenv(envDWSAgentExt, " { } ")
-	headers = applyAgentMetadataHeaders(nil)
-	if got := headers[transport.HeaderAgentExt]; got != "{}" {
-		t.Fatalf("EXT-only metadata = %q, want {}", got)
-	}
-}
-
-func TestCrossPlatformCoverageRootRejectsInvalidAgentMetadataBeforeEditionHook(t *testing.T) {
-	oldEdition := edition.Get()
-	t.Cleanup(func() { edition.Override(oldEdition) })
-
-	tests := []struct {
-		name   string
-		env    string
-		value  string
-		reason string
-	}{
-		{name: "version", env: envDWSAgentVersion, value: "DO_NOT ECHO", reason: "invalid_agent_version"},
-		{name: "extension", env: envDWSAgentExt, value: `{"secret":"DO_NOT_ECHO"`, reason: "invalid_agent_ext"},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Setenv("DWS_CONFIG_DIR", t.TempDir())
-			t.Setenv(envDWSAgentHost, "")
-			t.Setenv(agentproduct.EnvName, "")
-			t.Setenv(envDWSAgentVersion, "")
-			t.Setenv(envDWSAgentExt, "")
-			t.Setenv(tc.env, tc.value)
-
-			headerHookCalled := false
-			afterHookCalled := false
-			edition.Override(&edition.Hooks{
-				MergeHeaders: func(headers map[string]string) map[string]string {
-					headerHookCalled = true
-					return headers
-				},
-				EnterpriseCredentialHeaders: func(headers map[string]string) map[string]string {
-					headerHookCalled = true
-					return headers
-				},
-				AfterPersistentPreRun: func(_ *cobra.Command, _ []string) error {
-					afterHookCalled = true
-					return nil
-				},
-			})
-
-			root := NewRootCommand()
-			root.SetOut(io.Discard)
-			root.SetErr(io.Discard)
-			root.SetArgs([]string{"version"})
-			err := root.Execute()
-			if err == nil {
-				t.Fatalf("root command accepted invalid %s", tc.env)
-			}
-			if headerHookCalled || afterHookCalled {
-				t.Fatalf("edition hook ran before %s validation", tc.env)
-			}
-			assertAgentMetadataValidationError(t, err, tc.reason, tc.value)
-		})
-	}
-}
-
-func TestCrossPlatformCoverageAgentMetadataProcessEntryValidationPrecedesRootConstruction(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		args []string
-		want bool
-	}{
-		{name: "default JSON", args: []string{"version"}, want: true},
-		{name: "long JSON", args: []string{"version", "--format", "JSON"}, want: true},
-		{name: "long table", args: []string{"--format=table", "version"}, want: false},
-		{name: "short attached JSON", args: []string{"version", "-fjson"}, want: true},
-		{name: "short table", args: []string{"version", "-f", "table"}, want: false},
-		{name: "last wins", args: []string{"--format", "table", "version", "-f=json"}, want: true},
-		{name: "terminator", args: []string{"version", "--format", "table", "--", "--format", "json"}, want: false},
-		{name: "missing value", args: []string{"version", "--format"}, want: false},
-	} {
-		t.Run("presentation/"+tc.name, func(t *testing.T) {
-			if got := processArgsRequestJSON(tc.args); got != tc.want {
-				t.Fatalf("processArgsRequestJSON(%q) = %v, want %v", tc.args, got, tc.want)
-			}
-		})
-	}
-
-	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
-	t.Setenv(envDWSAgentHost, "")
-	t.Setenv(agentproduct.EnvName, "")
-	t.Setenv(envDWSAgentVersion, "")
-	sensitiveRaw := "{\"umt\":\"must-not-leak\"}\n"
-	t.Setenv(envDWSAgentExt, sensitiveRaw)
-	oldEdition := edition.Get()
-	t.Cleanup(func() { edition.Override(oldEdition) })
-	extensionHookCalls := 0
-	edition.Override(&edition.Hooks{
-		Name: "presentation-test",
-		RegisterExtraCommands: func(*cobra.Command, edition.ToolCaller) {
-			extensionHookCalls++
-		},
-		VisibleProducts: func() []string {
-			extensionHookCalls++
-			return nil
-		},
-		StaticServers: func() []edition.ServerInfo {
-			extensionHookCalls++
-			return nil
-		},
-	})
-
-	oldArgs := os.Args
-	os.Args = []string{"dws", "version"}
-	t.Cleanup(func() { os.Args = oldArgs })
-
-	rootConstructed := false
-	preParseCalled := false
-	testseam.Swap(t, &rootNewRootCommandWithEngine, func(context.Context, *pipeline.Engine) *cobra.Command {
-		rootConstructed = true
-		return &cobra.Command{Use: "dws"}
-	})
-	testseam.Swap(t, &rootRunPreParse, func(*cobra.Command, *pipeline.Engine) error {
-		preParseCalled = true
-		return nil
-	})
-
-	stderrFile, err := os.CreateTemp(t.TempDir(), "agent-metadata-stderr-*")
-	if err != nil {
-		t.Fatalf("create stderr capture: %v", err)
-	}
-	oldStderr := os.Stderr
-	os.Stderr = stderrFile
-	t.Cleanup(func() {
-		os.Stderr = oldStderr
-		_ = stderrFile.Close()
-	})
-
-	if code := Execute(); code == 0 {
-		t.Fatal("process entry accepted invalid Agent metadata")
-	}
-	if rootConstructed || preParseCalled {
-		t.Fatalf("invalid Agent metadata reached root hooks: constructed=%v preParse=%v", rootConstructed, preParseCalled)
-	}
-	if extensionHookCalls != 0 {
-		t.Fatalf("invalid Agent metadata executed %d extension hooks", extensionHookCalls)
-	}
-	if err := stderrFile.Sync(); err != nil {
-		t.Fatalf("sync stderr capture: %v", err)
-	}
-	stderrOutput, err := os.ReadFile(stderrFile.Name())
-	if err != nil {
-		t.Fatalf("read stderr capture: %v", err)
-	}
-	if strings.Contains(string(stderrOutput), "must-not-leak") || strings.Contains(string(stderrOutput), sensitiveRaw) {
-		t.Fatalf("process validation error leaked raw EXT: %q", stderrOutput)
-	}
-	if !json.Valid(stderrOutput) || !strings.Contains(string(stderrOutput), `"reason": "invalid_agent_ext"`) {
-		t.Fatalf("default JSON error presentation = %q", stderrOutput)
-	}
-
-	stdoutFile, err := os.CreateTemp(t.TempDir(), "agent-metadata-stdout-*")
-	if err != nil {
-		t.Fatalf("create stdout capture: %v", err)
-	}
-	oldStdout := os.Stdout
-	os.Stdout = stdoutFile
-	t.Cleanup(func() {
-		os.Stdout = oldStdout
-		_ = stdoutFile.Close()
-	})
-	emitEarlyAgentMetadataValidationError(invalidAgentExtError(), []string{"drive", "+list", "--format", "json"})
-	if err := stdoutFile.Sync(); err != nil {
-		t.Fatalf("sync stdout capture: %v", err)
-	}
-	unifiedOutput, err := os.ReadFile(stdoutFile.Name())
-	if err != nil {
-		t.Fatalf("read stdout capture: %v", err)
-	}
-	if !json.Valid(unifiedOutput) || !strings.Contains(string(unifiedOutput), `"outcome": "failure"`) ||
-		!strings.Contains(string(unifiedOutput), `"subtype": "invalid_agent_ext"`) {
-		t.Fatalf("unified JSON error presentation = %q", unifiedOutput)
-	}
-	if extensionHookCalls != 0 {
-		t.Fatalf("presentation-only root executed %d extension hooks", extensionHookCalls)
-	}
-
-	if err := stderrFile.Truncate(0); err != nil {
-		t.Fatalf("truncate fallback stderr capture: %v", err)
-	}
-	if _, err := stderrFile.Seek(0, io.SeekStart); err != nil {
-		t.Fatalf("rewind fallback stderr capture: %v", err)
-	}
-	testseam.Swap(t, &rootEmitResult, func(*cobra.Command, outputpkg.CommandResult) (int, error) {
-		return 0, errors.New("injected result emission failure")
-	})
-	emitEarlyAgentMetadataValidationError(invalidAgentExtError(), []string{"drive", "+list", "--format", "json"})
-	if err := stderrFile.Sync(); err != nil {
-		t.Fatalf("sync fallback stderr capture: %v", err)
-	}
-	fallbackOutput, err := os.ReadFile(stderrFile.Name())
-	if err != nil {
-		t.Fatalf("read fallback stderr capture: %v", err)
-	}
-	if !json.Valid(fallbackOutput) || !strings.Contains(string(fallbackOutput), `"reason": "invalid_agent_ext"`) ||
-		strings.Contains(string(fallbackOutput), "must-not-leak") {
-		t.Fatalf("fallback validation error presentation = %q", fallbackOutput)
-	}
-
-	if err := stderrFile.Truncate(0); err != nil {
-		t.Fatalf("truncate stderr capture: %v", err)
-	}
-	if _, err := stderrFile.Seek(0, io.SeekStart); err != nil {
-		t.Fatalf("rewind stderr capture: %v", err)
-	}
-	emitEarlyAgentMetadataValidationError(invalidAgentExtError(), []string{"version", "--format", "table"})
-	if err := stderrFile.Sync(); err != nil {
-		t.Fatalf("sync human stderr capture: %v", err)
-	}
-	humanOutput, err := os.ReadFile(stderrFile.Name())
-	if err != nil {
-		t.Fatalf("read human stderr capture: %v", err)
-	}
-	if json.Valid(humanOutput) || !strings.Contains(string(humanOutput), "DWS_AGENT_EXT") ||
-		strings.Contains(string(humanOutput), "must-not-leak") {
-		t.Fatalf("human validation error presentation = %q", humanOutput)
-	}
-
-	var capturedRunner *runtimeRunner
-	testseam.Swap(t, &rootNewCommandRunnerWithFlags, func(flags *GlobalFlags) executor.Runner {
-		capturedRunner = newCommandRunnerWithFlags(flags).(*runtimeRunner)
-		return capturedRunner
-	})
-	cachedSnapshot := agentMetadataSnapshot{version: "9.8.7", ext: `{"ua":"cached"}`}
-	_ = newRootCommandWithMode(
-		contextWithAgentMetadataSnapshot(context.Background(), cachedSnapshot),
-		nil,
-		false,
-		true,
-		true,
-	)
-	if capturedRunner == nil || capturedRunner.agentMetadata == nil || *capturedRunner.agentMetadata != cachedSnapshot {
-		t.Fatalf("root runner Agent metadata = %#v, want %#v", capturedRunner, cachedSnapshot)
-	}
-}
-
-func TestCrossPlatformCoverageAgentMetadataExcludedFromServiceDiscovery(t *testing.T) {
-	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
-	t.Setenv(envDWSAgentHost, "")
-	t.Setenv(agentproduct.EnvName, "")
-	t.Setenv(envDWSAgentVersion, "3.0.0")
-	t.Setenv(envDWSAgentExt, `{"umt":"test-value"}`)
-
-	headers := resolveMCPRequestHeadersForInvocation(executor.Invocation{
-		CanonicalProduct: mcpMetaServerID,
-		Tool:             mcpMetaURLTool,
-	})
-	if hasHeaderFold(headers, transport.HeaderAgentVersion) || hasHeaderFold(headers, transport.HeaderAgentExt) {
-		t.Fatalf("service-discovery request leaked Agent metadata: %#v", headers)
-	}
-
-	headers = resolveMCPRequestHeadersForInvocation(executor.Invocation{CanonicalProduct: "doc", Tool: "read"})
-	if headers[transport.HeaderAgentVersion] != "3.0.0" || headers[transport.HeaderAgentExt] == "" {
-		t.Fatalf("ordinary MCP request omitted Agent metadata: %#v", headers)
-	}
-	cached := agentMetadataSnapshot{version: "3.1.0", ext: "{}"}
-	headers = resolveMCPRequestHeadersForInvocation(executor.Invocation{CanonicalProduct: "doc", Tool: "read"}, cached)
-	if headers[transport.HeaderAgentVersion] != "3.1.0" || headers[transport.HeaderAgentExt] != "{}" {
-		t.Fatalf("ordinary MCP request ignored its validated snapshot: %#v", headers)
-	}
-}
-
-func TestCrossPlatformCoverageAgentMetadataMCPAndPluginScoping(t *testing.T) {
-	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
-	t.Setenv(envDWSAgentHost, "")
-	t.Setenv(agentproduct.EnvName, "")
-	t.Setenv(envDWSAgentVersion, "2.0.0")
-	t.Setenv(envDWSAgentExt, `{"ua":"test-agent/2.0"}`)
-
-	oldEdition := edition.Get()
-	t.Cleanup(func() { edition.Override(oldEdition) })
-	edition.Override(&edition.Hooks{})
-
-	pluginAuthMu.Lock()
-	oldPluginRegistry := pluginAuthRegistry
-	pluginAuthRegistry = make(map[string]*PluginAuth)
-	pluginAuthMu.Unlock()
-	t.Cleanup(func() {
-		pluginAuthMu.Lock()
-		pluginAuthRegistry = oldPluginRegistry
-		pluginAuthMu.Unlock()
-	})
-	dynamicMu.Lock()
-	oldDynamicEndpoints := dynamicEndpoints
-	oldDynamicProducts := dynamicProducts
-	oldDynamicAliases := dynamicAliases
-	oldDynamicToolEndpoints := dynamicToolEndpoints
-	dynamicEndpoints = nil
-	dynamicProducts = nil
-	dynamicAliases = nil
-	dynamicToolEndpoints = nil
-	dynamicMu.Unlock()
-	t.Cleanup(func() {
-		dynamicMu.Lock()
-		dynamicEndpoints = oldDynamicEndpoints
-		dynamicProducts = oldDynamicProducts
-		dynamicAliases = oldDynamicAliases
-		dynamicToolEndpoints = oldDynamicToolEndpoints
-		dynamicMu.Unlock()
-	})
-
-	testseam.Swap(t, &runnerPreflightDocDownload, func(*runtimeRunner, context.Context, *transport.Client, string, executor.Invocation) error {
-		return nil
-	})
-	type capturedRequest struct {
-		headers map[string]string
-		token   string
-	}
-	var captured []capturedRequest
-	testseam.Swap(t, &runnerCallTool, func(client *transport.Client, _ context.Context, _, _ string, _ map[string]any) (transport.ToolCallResult, error) {
-		copyHeaders := make(map[string]string, len(client.ExtraHeaders))
-		for key, value := range client.ExtraHeaders {
-			copyHeaders[key] = value
-		}
-		captured = append(captured, capturedRequest{headers: copyHeaders, token: client.AuthToken})
-		return transport.ToolCallResult{Content: map[string]any{"value": "ok"}}, nil
-	})
-
-	created := newCommandRunnerWithFlags(&GlobalFlags{}).(*runtimeRunner)
-	if hasHeaderFold(created.transport.ExtraHeaders, transport.HeaderAgentVersion) ||
-		hasHeaderFold(created.transport.ExtraHeaders, transport.HeaderAgentExt) {
-		t.Fatalf("new runner resolved Agent metadata before invocation validation: %#v", created.transport.ExtraHeaders)
-	}
-
-	// runSingle must not cache ambient MCP metadata on the shared base transport.
-	// Use mock mode to exercise the path without authentication or network I/O.
-	t.Setenv(envDWSAgentVersion, "2.0.1")
-	refreshRunner := &runtimeRunner{
-		transport:   transport.NewClient(nil),
-		globalFlags: &GlobalFlags{Mock: true},
-		auditSink:   audit.NopSink{},
-	}
-	refreshInvocation := executor.Invocation{CanonicalProduct: "refresh", Tool: "tool", Params: map[string]any{}}
-	if _, err := refreshRunner.runSingle(context.Background(), refreshInvocation, false); err != nil {
-		t.Fatalf("mock runSingle failed: %v", err)
-	}
-	if hasHeaderFold(refreshRunner.transport.ExtraHeaders, transport.HeaderAgentVersion) {
-		t.Fatalf("runSingle mutated the shared transport Header map: %#v", refreshRunner.transport.ExtraHeaders)
-	}
-	t.Setenv(envDWSAgentVersion, "2.0.0")
-
-	r := &runtimeRunner{
-		transport:   transport.NewClient(nil),
-		globalFlags: &GlobalFlags{Token: "test-token"},
-		auditSink:   audit.NopSink{},
-		agentMetadata: &agentMetadataSnapshot{
-			version: "2.0.0",
-			ext:     `{"ua":"test-agent/2.0"}`,
-		},
-	}
-	builtIn := executor.Invocation{CanonicalProduct: "built-in", Tool: "tool", Params: map[string]any{}}
-	if _, err := r.executeInvocation(context.Background(), "https://example.test", builtIn); err != nil {
-		t.Fatalf("built-in invocation failed: %v", err)
-	}
-
-	pluginDescriptor := mcptypes.ServerDescriptor{
-		Key:      "third-party",
-		Endpoint: "https://plugin.example.test",
-		CLI:      mcptypes.CLIOverlay{ID: "third-party"},
-		AuthHeaders: map[string]string{
-			"X-Plugin":        "yes",
-			"X-Dws-Agent-Ver": "plugin-must-not-forge-version",
-			"X-Dws-Agent-Ext": `{"source":"plugin"}`,
-		},
-	}
-	registerPluginHTTPServer(pluginDescriptor)
-	registeredPlugin, pluginOwned := LookupPluginAuth("third-party")
-	if !pluginOwned || registeredPlugin == nil || registeredPlugin.Token != "" {
-		t.Fatalf("anonymous HTTP plugin ownership = %#v, %v", registeredPlugin, pluginOwned)
-	}
-	registerPluginHTTPServer(mcptypes.ServerDescriptor{
-		Key:      "anonymous-empty",
-		Endpoint: "https://anonymous.example.test",
-		CLI:      mcptypes.CLIOverlay{ID: "anonymous-empty"},
-	})
-	if emptyPlugin, owned := LookupPluginAuth("anonymous-empty"); !owned || emptyPlugin == nil || emptyPlugin.Token != "" || len(emptyPlugin.ExtraHeaders) != 0 {
-		t.Fatalf("headerless HTTP plugin ownership = %#v, %v", emptyPlugin, owned)
-	}
-	originalPluginHeaders := maps.Clone(registeredPlugin.ExtraHeaders)
-	pluginInvocation := executor.Invocation{CanonicalProduct: "third-party", Tool: "tool", Params: map[string]any{}}
-	if _, err := r.executeInvocation(context.Background(), "https://plugin.example.test", pluginInvocation); err != nil {
-		t.Fatalf("plugin invocation failed: %v", err)
-	}
-
-	if len(captured) != 2 {
-		t.Fatalf("captured %d calls, want 2", len(captured))
-	}
-	if captured[0].headers[transport.HeaderAgentVersion] != "2.0.0" || captured[0].headers[transport.HeaderAgentExt] != `{"ua":"test-agent/2.0"}` {
-		t.Fatalf("built-in MCP metadata = %#v", captured[0].headers)
-	}
-	if hasHeaderFold(captured[1].headers, transport.HeaderAgentVersion) || hasHeaderFold(captured[1].headers, transport.HeaderAgentExt) {
-		t.Fatalf("plugin request leaked Agent metadata: %#v", captured[1].headers)
-	}
-	if got := captured[1].headers["X-Plugin"]; got != "yes" {
-		t.Fatalf("plugin-owned header = %q, want yes", got)
-	}
-	if captured[1].token != "" {
-		t.Fatalf("anonymous plugin unexpectedly received default OAuth token")
-	}
-	if !maps.Equal(registeredPlugin.ExtraHeaders, originalPluginHeaders) {
-		t.Fatalf("plugin Header sanitization mutated registry state: got %#v want %#v", registeredPlugin.ExtraHeaders, originalPluginHeaders)
-	}
-	if got := pluginRequestHeaders(nil); got != nil {
-		t.Fatalf("nil plugin auth produced Headers: %#v", got)
-	}
-	if got := pluginRequestHeaders(&PluginAuth{ExtraHeaders: map[string]string{
-		"X-DWS-AGENT-VER": "forged",
-		"X-DWS-AGENT-EXT": `{"forged":true}`,
-	}}); got != nil {
-		t.Fatalf("reserved-only plugin Headers survived sanitization: %#v", got)
-	}
-
-	// Keep the execution-boundary auth guard independently testable: even if a
-	// future token provider returns an empty token without an error, built-in MCP
-	// calls must fail before preflight or transport while anonymous plugins remain
-	// valid above.
-	resolveCalled := false
-	testseam.Swap(t, &runnerResolveAuthToken, func(*runtimeRunner, context.Context) (string, error) {
-		resolveCalled = true
-		return "", nil
-	})
-	callsBefore := len(captured)
-	unauthenticated := &runtimeRunner{
-		transport:   transport.NewClient(nil),
-		globalFlags: &GlobalFlags{},
-		auditSink:   audit.NopSink{},
-	}
-	if _, err := unauthenticated.executeInvocation(context.Background(), "https://example.test", executor.Invocation{CanonicalProduct: "built-in-unauthenticated", Tool: "tool"}); err == nil || !isAuthError(err) {
-		t.Fatalf("unauthenticated built-in request = %v, want auth error", err)
-	}
-	if !resolveCalled {
-		t.Fatal("unauthenticated request did not exercise the token resolver")
-	}
-	if len(captured) != callsBefore {
-		t.Fatalf("unauthenticated built-in request reached transport: calls %d -> %d", callsBefore, len(captured))
-	}
-}
-
-func hasHeaderFold(headers map[string]string, want string) bool {
-	for key := range headers {
-		if strings.EqualFold(key, want) {
-			return true
-		}
-	}
-	return false
-}
@@ -158,7 +158,7 @@ func TestApplyAgentProductHeader(t *testing.T) {
 	}
 }

-func TestCrossPlatformCoverageRootRejectsInvalidAgentProductBeforeEditionHook(t *testing.T) {
+func TestRootRejectsInvalidAgentProductBeforeEditionHook(t *testing.T) {
 	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
 	const invalidValue = "DO_NOT ECHO"
 	t.Setenv(agentproduct.EnvName, invalidValue)
@@ -15,10 +15,11 @@ package app

 import "sync"

-// PluginAuth marks ownership of a plugin-owned streamable-http MCP server and
-// holds its optional authentication credentials. Every accepted HTTP plugin,
-// including an anonymous one, has a non-nil record keyed by canonical product
-// ID (CLI.ID) so execution never falls back to built-in DingTalk OAuth.
+// PluginAuth holds authentication credentials for a plugin-owned
+// streamable-http MCP server. Each server is keyed by its canonical
+// product ID (CLI.ID) so that different servers can use independent
+// tokens without interfering with each other or with the default
+// DingTalk OAuth token.
 type PluginAuth struct {
 	// Token is the Bearer token extracted from the plugin's
 	// "Authorization" header (e.g. a third-party API key).
@@ -38,25 +39,27 @@ var (
 	pluginAuthRegistry = make(map[string]*PluginAuth)
 )

-// RegisterPluginAuth stores ownership and optional authentication credentials
-// for a plugin server keyed by its canonical product ID.
+// RegisterPluginAuth stores authentication credentials for a plugin
+// server keyed by its canonical product ID. The runner looks up these
+// credentials at execution time to inject the correct Bearer token
+// instead of the default DingTalk OAuth token.
 func RegisterPluginAuth(productID string, auth *PluginAuth) {
 	pluginAuthMu.Lock()
 	defer pluginAuthMu.Unlock()
 	pluginAuthRegistry[productID] = auth
 }

-// ClearPluginAuth removes the ownership and credential record for a plugin
-// product.
+// ClearPluginAuth removes credentials for a plugin product. Registration uses
+// this before applying an accepted descriptor so a descriptor without custom
+// auth cannot inherit stale credentials from an earlier root construction.
 func ClearPluginAuth(productID string) {
 	pluginAuthMu.Lock()
 	defer pluginAuthMu.Unlock()
 	delete(pluginAuthRegistry, productID)
 }

-// LookupPluginAuth returns plugin ownership and optional authentication
-// credentials for the product ID. The bool denotes ownership, not whether a
-// Bearer token is present.
+// LookupPluginAuth returns the authentication credentials registered
+// for the given product ID, or nil if none exists.
 func LookupPluginAuth(productID string) (*PluginAuth, bool) {
 	pluginAuthMu.RLock()
 	defer pluginAuthMu.RUnlock()
@@ -61,16 +61,11 @@ func appRPCServer(t *testing.T, initOK, listOK bool) *httptest.Server {
 }

 func TestCrossPlatformCoveragePluginAuthCoverage(t *testing.T) {
-	fallback := pluginAuthFromServerDescriptor(mcptypes.ServerDescriptor{Key: "fallback", Endpoint: "%", AuthHeaders: map[string]string{"Authorization": "token"}})
-	if fallback == nil || fallback.Token != "token" || len(fallback.TrustedDomains) != 0 {
-		t.Fatalf("fallback plugin auth = %#v", fallback)
-	}
-	got := pluginAuthFromServerDescriptor(mcptypes.ServerDescriptor{Key: "server", Endpoint: "https://x.test", CLI: mcptypes.CLIOverlay{ID: "cli"}, AuthHeaders: map[string]string{"Authorization": "Bearer token", "X": "Y"}})
-	if got == nil || got.Token != "token" || got.ExtraHeaders["X"] != "Y" || len(got.TrustedDomains) != 2 {
-		t.Fatalf("plugin auth = %#v", got)
-	}
-	if anonymous := pluginAuthFromServerDescriptor(mcptypes.ServerDescriptor{Key: "none"}); anonymous == nil || anonymous.Token != "" {
-		t.Fatalf("anonymous plugin ownership = %#v", anonymous)
+	registerPluginAuthFromHeaders(mcptypes.ServerDescriptor{Key: "fallback", Endpoint: "%", AuthHeaders: map[string]string{"Authorization": "token"}})
+	registerPluginAuthFromHeaders(mcptypes.ServerDescriptor{Key: "server", Endpoint: "https://x.test", CLI: mcptypes.CLIOverlay{ID: "cli"}, AuthHeaders: map[string]string{"Authorization": "Bearer token", "X": "Y"}})
+	registerPluginAuthFromHeaders(mcptypes.ServerDescriptor{Key: "none"})
+	if got, ok := LookupPluginAuth("cli"); !ok || got == nil || got.Token != "token" {
+		t.Fatalf("registered plugin auth = %#v, %v", got, ok)
 	}
 }

@@ -13,9 +13,9 @@

 package app

-// MCPIdentityHeaders returns the shared identity header map used by non-MCP
-// transports such as the A2A gateway client. MCP-only Agent version and
-// extension metadata are intentionally excluded.
+// MCPIdentityHeaders returns the same header map used for MCP HTTP requests
+// (agent identity, env trace headers, edition MergeHeaders). Intended for
+// non-MCP transports such as the A2A gateway client.
 func MCPIdentityHeaders() map[string]string {
 	return resolveIdentityHeaders()
 }
@@ -79,7 +79,6 @@ var (
 	rootPluginSyncSkills            = plugin.SyncSkills
 	rootAuthLoadTokenData           = authpkg.LoadTokenData
 	rootNewCommandRunnerWithFlags   = newCommandRunnerWithFlags
-	rootEmitResult                  = output.EmitResult
 )

 // Execute runs the root command and returns the process exit code.
@@ -137,16 +136,6 @@ func Execute() (exitCode int) {
 	restoreArgs := rootNormalizeProcessProfileArgs()
 	defer restoreArgs()

-	// Validate MCP Agent metadata before constructing the command tree.
-	// Construction may invoke edition registration/static-server hooks and load
-	// plugin PreParse handlers, so PersistentPreRunE alone is too late for the
-	// process entry point. Retain this exact pair for the eventual invocation.
-	agentMetadata := readAgentMetadataSnapshot()
-	if err := agentMetadata.validationError(); err != nil {
-		emitEarlyAgentMetadataValidationError(err, os.Args[1:])
-		return apperrors.ExitCode(err)
-	}
-
 	timing := NewTimingCollector()
 	defer func() {
 		rootStopAllStdioClients() // Ensure child processes are terminated on exit
@@ -158,7 +147,6 @@ func Execute() (exitCode int) {

 	// Attach timing collector to context for use by child components
 	ctx := WithTimingCollector(context.Background(), timing)
-	ctx = contextWithAgentMetadataSnapshot(ctx, agentMetadata)
 	ctx, resultStore = output.WithResultStore(ctx)
 	var signalState *processSignalState
 	var stopSignals func()
@@ -272,70 +260,6 @@ func Execute() (exitCode int) {
 	return 0
 }

-// emitEarlyAgentMetadataValidationError preserves each built-in command's
-// legacy-vs-unified output contract without running extension hooks. The
-// presentation-only tree contains reviewed open-source commands and flags but
-// deliberately omits edition registration, plugin loading, and visibility
-// hooks; callers therefore still fail before any external hook executes.
-func emitEarlyAgentMetadataValidationError(err error, args []string) {
-	format := processArgsFormat(args)
-	presentationRoot := newRootPresentationCommand()
-	_ = presentationRoot.PersistentFlags().Set("format", format)
-	if target, _, findErr := presentationRoot.Find(args); findErr == nil && target != nil && output.UsesUnifiedResult(target) {
-		target.SetOut(os.Stdout)
-		target.SetErr(os.Stderr)
-		result := output.FailureWithExitCode(errorInfoFromExecutionError(err), apperrors.ExitCode(err))
-		if _, emitErr := rootEmitResult(target, result); emitErr == nil {
-			return
-		}
-	}
-	if strings.EqualFold(strings.TrimSpace(format), "json") {
-		_ = apperrors.PrintJSON(os.Stderr, err)
-		return
-	}
-	_ = apperrors.PrintHumanAt(os.Stderr, err, apperrors.VerbosityNormal)
-}
-
-// processArgsRequestJSON preserves the CLI's machine-readable error contract
-// for validation that must occur before Cobra and its presentation flags exist.
-// The global format defaults to JSON; an explicit non-JSON format switches to
-// the human diagnostic path. Last occurrence wins, matching pflag semantics.
-func processArgsRequestJSON(args []string) bool {
-	return strings.EqualFold(strings.TrimSpace(processArgsFormat(args)), "json")
-}
-
-func processArgsFormat(args []string) string {
-	format := "json"
-	for index := 0; index < len(args); index++ {
-		arg := args[index]
-		if arg == "--" {
-			break
-		}
-		if value, ok := strings.CutPrefix(arg, "--format="); ok {
-			format = value
-			continue
-		}
-		if value, ok := strings.CutPrefix(arg, "-f="); ok {
-			format = value
-			continue
-		}
-		if strings.HasPrefix(arg, "-f") && len(arg) > len("-f") {
-			format = strings.TrimPrefix(arg, "-f")
-			continue
-		}
-		if arg != "--format" && arg != "-f" {
-			continue
-		}
-		if index+1 >= len(args) {
-			format = ""
-			break
-		}
-		index++
-		format = args[index]
-	}
-	return format
-}
-
 // errorInfoFromExecutionError projects the repository error model into the unified
 // failure body. Exit code and category are derived from the same error value,
 // preventing the wire and process status from drifting apart.
@@ -709,25 +633,12 @@ func NewRootCommandWithEngine(rootCtx context.Context, engine *pipeline.Engine)
 }

 func newRootCommandWithEngine(rootCtx context.Context, engine *pipeline.Engine, loadRuntimeExtensions bool, declarationOnly bool) *cobra.Command {
-	return newRootCommandWithMode(rootCtx, engine, loadRuntimeExtensions, declarationOnly, false)
-}
-
-func newRootPresentationCommand() *cobra.Command {
-	return newRootCommandWithMode(context.Background(), nil, false, true, true)
-}
-
-func newRootCommandWithMode(rootCtx context.Context, engine *pipeline.Engine, loadRuntimeExtensions bool, declarationOnly bool, presentationOnly bool) *cobra.Command {
 	if rootCtx == nil {
 		rootCtx = context.Background()
 	}
 	flags := &GlobalFlags{}
 	authpkg.SetRuntimeProfile(preparseProfileFlag(os.Args[1:]))
 	runner := rootNewCommandRunnerWithFlags(flags)
-	if snapshot, ok := agentMetadataSnapshotFromContext(rootCtx); ok {
-		if runtime, ok := runner.(*runtimeRunner); ok {
-			runtime.agentMetadata = &snapshot
-		}
-	}

 	root := &cobra.Command{
 		Use:               "dws",
@@ -761,29 +672,15 @@ func newRootCommandWithMode(rootCtx context.Context, engine *pipeline.Engine, lo
 			// --output sink instead opens at Run entry (after Cobra's own
 			// validation), so validation failures still cannot strand a
 			// temporary file.
-			// Validate caller-provided identity and MCP metadata before command
-			// execution hooks or network activity. The process entry point additionally
-			// validates Agent metadata before command-tree construction; direct Cobra
-			// embedding retains this execution-boundary guard.
+			// Validate caller-provided identity labels before any edition hook
+			// or command network activity can run. Header-only library callers
+			// use the best-effort path in resolveIdentityHeaders instead.
 			if _, err := parseAgentHost(os.Getenv(envDWSAgentHost)); err != nil {
 				return err
 			}
 			if _, err := parseAgentProduct(os.Getenv(agentproduct.EnvName)); err != nil {
 				return err
 			}
-			agentMetadata, cached := agentMetadataSnapshotFromContext(cmd.Context())
-			if !cached {
-				agentMetadata = readAgentMetadataSnapshot()
-			}
-			if err := agentMetadata.validationError(); err != nil {
-				return err
-			}
-			if runtime, ok := runner.(*runtimeRunner); ok {
-				// Retain the exact validated pair for this command execution so a
-				// concurrently mutating embedding environment cannot change what is
-				// later applied after edition and credential hooks.
-				runtime.agentMetadata = &agentMetadata
-			}
 			if shouldDetectNestedSkillLayout(cmd) {
 				if found, err := detectNestedMultiSkillLayout(); err == nil && found {
 					fmt.Fprintln(cmd.ErrOrStderr(), "⚠️  检测到旧升级器留下的嵌套 Skill；请运行 dws skill setup --mode multi 查看迁移计划并确认")
@@ -880,12 +777,10 @@ func newRootCommandWithMode(rootCtx context.Context, engine *pipeline.Engine, lo
 	// PAT authorization commands (open-source core)
 	pat.RegisterCommands(root, patCaller)

-	if !presentationOnly {
-		if fn := edition.Get().RegisterExtraCommands; fn != nil {
-			caller := newToolCallerAdapter(runner, flags)
-			fn(root, caller)
-			deduplicateCommands(root)
-		}
+	if fn := edition.Get().RegisterExtraCommands; fn != nil {
+		caller := newToolCallerAdapter(runner, flags)
+		fn(root, caller)
+		deduplicateCommands(root)
 	}
 	if loadRuntimeExtensions {
 		// Resolve plugins only after the complete distribution command tree is
@@ -896,9 +791,7 @@ func newRootCommandWithMode(rootCtx context.Context, engine *pipeline.Engine, lo
 			addPluginCommandsSafe(root, pluginCmds)
 		}
 	}
-	if !presentationOnly {
-		hideNonDirectRuntimeCommands(root)
-	}
+	hideNonDirectRuntimeCommands(root)
 	configureRootHelp(root)
 	// Set custom flag error handler for better UX
 	root.SetFlagErrorFunc(flagErrorWithSuggestions)
@@ -1862,16 +1755,17 @@ func distributionRootOwns(root *cobra.Command, name string) bool {
 func registerPluginHTTPServer(srv mcptypes.ServerDescriptor) {
 	AppendDynamicServer(srv)
 	productID := firstNonEmptyPluginString(srv.CLI.ID, srv.Key)
-	// Register ownership for every accepted HTTP plugin, including anonymous
-	// plugins. Execution must never fall back to the built-in DingTalk OAuth or
-	// Agent-metadata path merely because a plugin has no Authorization Header.
-	RegisterPluginAuth(productID, pluginAuthFromServerDescriptor(srv))
+	ClearPluginAuth(productID)
+	if len(srv.AuthHeaders) > 0 {
+		registerPluginAuthFromHeaders(srv)
+	}
 }

-// pluginAuthFromServerDescriptor extracts plugin-owned credentials and custom
-// Headers. A non-nil result also acts as the HTTP plugin ownership marker for
-// anonymous plugins.
-func pluginAuthFromServerDescriptor(srv mcptypes.ServerDescriptor) *PluginAuth {
+// registerPluginAuthFromHeaders extracts authentication credentials from
+// a server descriptor's AuthHeaders and registers them in the global
+// PluginAuth registry. The runner uses this registry at execution time
+// to inject the correct Bearer token for third-party MCP servers.
+func registerPluginAuthFromHeaders(srv mcptypes.ServerDescriptor) {
 	authToken := ""
 	extraHeaders := make(map[string]string)
 	for key, value := range srv.AuthHeaders {
@@ -1882,18 +1776,20 @@ func pluginAuthFromServerDescriptor(srv mcptypes.ServerDescriptor) *PluginAuth {
 			extraHeaders[key] = value
 		}
 	}
+	if authToken == "" {
+		return
+	}
 	var trustedDomains []string
 	if parsed, err := url.Parse(srv.Endpoint); err == nil {
 		host := parsed.Hostname()
-		if host != "" {
-			trustedDomains = []string{host, "*." + host}
-		}
+		trustedDomains = []string{host, "*." + host}
 	}
-	return &PluginAuth{
+	productID := firstNonEmptyPluginString(srv.CLI.ID, srv.Key)
+	RegisterPluginAuth(productID, &PluginAuth{
 		Token:          authToken,
 		ExtraHeaders:   extraHeaders,
 		TrustedDomains: trustedDomains,
-	}
+	})
 }

 // newPipelineEngine creates and configures the pipeline engine with
@@ -137,6 +137,7 @@ func newCommandRunnerWithFlags(flags *GlobalFlags) executor.Runner {
 		httpClient = &http.Client{Timeout: time.Duration(flags.Timeout) * time.Second}
 	}
 	transportClient := transport.NewClient(httpClient)
+	transportClient.ExtraHeaders = resolveIdentityHeaders()
 	transportClient.FileLogger = FileLoggerInstance()
 	return &runtimeRunner{
 		transport:          transportClient,
@@ -155,14 +156,12 @@ type runtimeRunner struct {
 	enforceContentScan bool
 	includeScanReport  bool
 	auditSink          audit.Sink
-	agentMetadata      *agentMetadataSnapshot
 }

 var (
 	runnerResolveMultiProfileSelections = resolveMultiProfileSelections
 	runnerResolveProfile                = authpkg.ResolveProfile
 	runnerGetCachedRuntimeToken         = getCachedRuntimeToken
-	runnerResolveAuthToken              = (*runtimeRunner).resolveAuthToken
 	runnerPreflightDocDownload          = (*runtimeRunner).preflightDocDownload
 	runnerCallTool                      = (*transport.Client).CallTool
 	runnerStdioEnsureInitialized        = (*transport.StdioClient).EnsureInitialized
@@ -238,6 +237,7 @@ func (r *runtimeRunner) runSingle(ctx context.Context, invocation executor.Invoc
 	if r.transport == nil {
 		return r.fallback.Run(ctx, invocation)
 	}
+	r.transport.ExtraHeaders = resolveIdentityHeaders()

 	// Mock mode: skip endpoint resolution, use a placeholder endpoint.
 	if r.globalFlags != nil && r.globalFlags.Mock {
@@ -543,9 +543,9 @@ func (r *runtimeRunner) executeInvocation(ctx context.Context, endpoint string,
 		emitAudit(auditSink, execID, invokeStart, invocation, endpoint, retErr, version)
 	}()

-	// Check whether this product belongs to an HTTP plugin. Every accepted
-	// plugin has an ownership record; credentials within that record are
-	// optional. Plugin requests never fall back to the default DingTalk OAuth.
+	// Check if this product has plugin-level auth credentials registered.
+	// If so, use the plugin's token instead of the default DingTalk OAuth token.
+	// This allows third-party MCP servers (e.g. Bailian) to use their own API keys.
 	pluginAuth, hasPluginAuth := LookupPluginAuth(invocation.CanonicalProduct)

 	authToken := ""
@@ -553,7 +553,7 @@ func (r *runtimeRunner) executeInvocation(ctx context.Context, endpoint string,
 		authToken = pluginAuth.Token
 	} else if !invocation.DryRun && (r.globalFlags == nil || !r.globalFlags.Mock) {
 		var tokenErr error
-		authToken, tokenErr = runnerResolveAuthToken(r, ctx)
+		authToken, tokenErr = r.resolveAuthToken(ctx)
 		if tokenErr != nil {
 			return executor.Result{}, tokenResolutionError(tokenErr)
 		}
@@ -603,10 +603,9 @@ func (r *runtimeRunner) executeInvocation(ctx context.Context, endpoint string,
 		}, nil
 	}

-	// Preserve a final execution-boundary guard even though the built-in token
-	// resolver normally returns either a non-empty token or an error. HTTP
-	// plugins are ownership-scoped separately and may intentionally be anonymous.
-	if !hasPluginAuth && strings.TrimSpace(authToken) == "" {
+	// Fail-fast: reject unauthenticated requests before making network calls.
+	// This provides a clear error message instead of cryptic HTTP 400 from MCP.
+	if strings.TrimSpace(authToken) == "" {
 		return executor.Result{}, apperrors.NewAuth(
 			"未登录，请先执行 dws auth login",
 			apperrors.WithReason("not_authenticated"),
@@ -617,20 +616,12 @@ func (r *runtimeRunner) executeInvocation(ctx context.Context, endpoint string,

 	var tc *transport.Client
 	if hasPluginAuth {
-		// Plugin ownership is authoritative even when the plugin is anonymous.
-		// Copy and sanitize manifest headers so plugins cannot opt themselves into
-		// DWS-owned Agent metadata by declaring the reserved names directly.
-		tc = r.transport.WithAuth(authToken, pluginRequestHeaders(pluginAuth))
+		// Use plugin-level auth: inject the plugin's token and trust its domains.
+		tc = r.transport.WithAuth(authToken, pluginAuth.ExtraHeaders)
 		tc.TrustedDomains = pluginAuth.TrustedDomains
 	} else {
-		// Default path: use DingTalk OAuth token with identity headers. Agent
-		// metadata is resolved exactly once per invocation and is excluded from
-		// helper-only service-discovery requests.
-		if r.agentMetadata != nil {
-			tc = r.transport.WithAuth(authToken, resolveMCPRequestHeadersForInvocation(invocation, *r.agentMetadata))
-		} else {
-			tc = r.transport.WithAuth(authToken, resolveMCPRequestHeadersForInvocation(invocation))
-		}
+		// Default path: use DingTalk OAuth token with identity headers.
+		tc = r.transport.WithAuth(authToken, resolveIdentityHeaders())
 	}

 	callCtx := ctx
@@ -1078,10 +1069,6 @@ func resolveIdentityHeaders() map[string]string {
 	} else {
 		delete(headers, agentproduct.HeaderName)
 	}
-	// Agent version and extension are intentionally MCP-request-only. Remove
-	// every case variant potentially supplied by an edition or credential hook
-	// so shared consumers such as A2A cannot inherit them.
-	removeAgentMetadataHeaders(headers)
 	return headers
 }

@@ -1,80 +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 auth
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-)
-
-type agentMetadataHeaderRoundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f agentMetadataHeaderRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return f(req)
-}
-
-func TestCrossPlatformCoverageOAuthRequestsExcludeAgentMetadataHeaders(t *testing.T) {
-	t.Setenv("DWS_AGENT_VER", "1.2.3-test")
-	t.Setenv("DWS_AGENT_EXT", `{"umt":"test-umt","miniwua":"test-wua","ua":"test-agent"}`)
-
-	assertExcluded := func(t *testing.T, header http.Header) {
-		t.Helper()
-		for _, name := range []string{"x-dws-agent-ver", "x-dws-agent-ext"} {
-			if values := header.Values(name); len(values) != 0 {
-				t.Fatalf("OAuth request header %q = %q, want absent", name, values)
-			}
-		}
-	}
-
-	newCaptureClient := func(responseBody string) (*http.Client, <-chan http.Header) {
-		seen := make(chan http.Header, 1)
-		client := &http.Client{Transport: agentMetadataHeaderRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-			seen <- req.Header.Clone()
-			return &http.Response{
-				StatusCode: http.StatusOK,
-				Header:     http.Header{"Content-Type": {"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(responseBody)),
-				Request:    req,
-			}, nil
-		})}
-		return client, seen
-	}
-
-	t.Run("JSON token request", func(t *testing.T) {
-		client, seen := newCaptureClient(`{}`)
-		provider := &OAuthProvider{httpClient: client}
-		if _, err := provider.postJSON(context.Background(), "https://oauth.test/token", map[string]string{
-			"code":      "test-code",
-			"grantType": "authorization_code",
-		}); err != nil {
-			t.Fatalf("postJSON() error = %v", err)
-		}
-		assertExcluded(t, <-seen)
-	})
-
-	t.Run("device code request", func(t *testing.T) {
-		client, seen := newCaptureClient(`{"success":true,"result":{"deviceCode":"test-device-code","userCode":"TEST-CODE","verificationUri":"https://example.test/device","expiresIn":900,"interval":1}}`)
-		provider := NewDeviceFlowProvider(t.TempDir(), newDeviceFlowTestLogger())
-		provider.clientID = "test-client-id"
-		provider.httpClient = client
-		provider.SetBaseURL("https://oauth.test")
-		if _, err := provider.requestDeviceCode(context.Background()); err != nil {
-			t.Fatalf("requestDeviceCode() error = %v", err)
-		}
-		assertExcluded(t, <-seen)
-	})
-}
@@ -2799,8 +2799,6 @@ func newChatCommand() *cobra.Command {

 纯文本 / Markdown 消息（默认）：
  无需指定 --msg-type，直接传消息内容即可。推荐使用 --text flag 传递内容（尤其当内容含换行、引号等特殊字符时），也支持位置参数。可选 --title 作为消息标题。
-  图文混排时，公网图片 URL 需要写成 Markdown 图片语法：![图片标题](https://example.com/image.png)，才会以内联图片展示。
-  如果省略开头的 !，例如 [图片标题](https://example.com/image.png)，将按链接/URL 展示，不会渲染为图片。

 返回值与后续操作：
  发送后会返回 openTaskId。如需编辑或撤回刚发送的消息，使用
@@ -2818,8 +2816,6 @@ func newChatCommand() *cobra.Command {
  dws chat message send --user <userId> "请查收"
  dws chat message send --open-dingtalk-id <openDingTalkId> "请查收"
  dws chat message send --group <openconversation_id> --title "周报提醒" "请大家本周五前提交周报"
-  # 图文混排 Markdown：公网图片 URL 需要写成 ![图片标题](URL) 才会以内联图片展示
-  dws chat message send --group <openconversation_id> --text $'这是图文说明\n\n![这个是展示图片标题](https://down.dingtalk.com/media/lQLPM5jiBEiBNjswMLAKd_CTzm8eowpEWPT_7-cA_48_48.png)'
  # 发送本地图片或文件（图片会作为可下载的 file 附件发送）
  dws chat message send --group <openconversation_id> --msg-type file --file-path ./screenshot.png
  dws chat message send --group <openconversation_id> --msg-type file --file-path ./report.pdf
@@ -324,23 +324,11 @@ func (m FlagMigration) validate() error {
 	if m.Canonical.After.Hidden {
 		return fmt.Errorf("canonical flag must remain visible")
 	}
-	// Requiredness belongs to the one logical parameter. The hidden legacy
-	// spelling must not remain independently required, while the canonical
-	// spelling inherits the exact before-state contract. An already-visible
-	// canonical flag cannot change requiredness; an existing hidden canonical
-	// placeholder may inherit it when promoted to the public spelling.
-	if m.Legacy.After.Required {
-		return fmt.Errorf("legacy compatibility alias must not remain independently required after migration")
+	if !m.Canonical.After.Required {
+		return fmt.Errorf("canonical flag must be required after migration")
 	}
-	if m.Legacy.Before.Required != m.Canonical.After.Required {
-		return fmt.Errorf(
-			"flag requiredness must be preserved from legacy before to canonical after",
-		)
-	}
-	if m.Canonical.Before.Present &&
-		!m.Canonical.Before.Hidden &&
-		m.Canonical.Before.Required != m.Canonical.After.Required {
-		return fmt.Errorf("canonical flag requiredness must remain unchanged when already present")
+	if m.Canonical.Before.Present && m.Canonical.Before.Required {
+		return fmt.Errorf("canonical flag must be absent or optional before migration")
 	}
 	if m.Legacy.After.AliasOf != m.Canonical.Name {
 		return fmt.Errorf(
@@ -694,7 +682,6 @@ func flagMigrationAuthorizesChange(
 			return true
 		}
 		if migration.Canonical.Before.Present &&
-			migration.Canonical.Before.Hidden &&
 			!migration.Canonical.Before.Required &&
 			migration.Canonical.After.Required &&
 			change.Kind == "flag_became_required" {
@@ -188,7 +188,7 @@ func TestCrossPlatformCoverageFlagMigrationManifestParserEdges(t *testing.T) {

 func TestCrossPlatformCoverageFlagMigrationManifestRejectsEveryContractDrift(t *testing.T) {
 	optionalCanonical := func() FlagMigrationManifest {
-		manifest := coverageOptionalManifest(FlagMigrationPending)
+		manifest := coverageManifest(FlagMigrationPending)
 		manifest.Migrations[0].Canonical.Before = FlagMigrationState{
 			Present: true,
 			Type:    "string",
@@ -269,36 +269,6 @@ func TestCrossPlatformCoverageFlagMigrationManifestRejectsEveryContractDrift(t *
 			mutate:  func(m *FlagMigrationManifest) { m.Migrations[0].Canonical.After = FlagMigrationState{} },
 			wantErr: "canonical flag must be present after migration",
 		},
-		{
-			name:    "required legacy cannot become optional canonical",
-			make:    func() FlagMigrationManifest { return coverageManifest(FlagMigrationPending) },
-			mutate:  func(m *FlagMigrationManifest) { m.Migrations[0].Canonical.After.Required = false },
-			wantErr: "requiredness must be preserved from legacy before to canonical after",
-		},
-		{
-			name:    "optional legacy cannot become required canonical",
-			make:    func() FlagMigrationManifest { return coverageOptionalManifest(FlagMigrationPending) },
-			mutate:  func(m *FlagMigrationManifest) { m.Migrations[0].Canonical.After.Required = true },
-			wantErr: "requiredness must be preserved from legacy before to canonical after",
-		},
-		{
-			name: "existing canonical cannot change requiredness",
-			make: func() FlagMigrationManifest { return coverageManifest(FlagMigrationPending) },
-			mutate: func(manifest *FlagMigrationManifest) {
-				manifest.Migrations[0].Canonical.Before = FlagMigrationState{
-					Present: true,
-					Type:    "string",
-					Scope:   "local",
-				}
-			},
-			wantErr: "canonical flag requiredness must remain unchanged when already present",
-		},
-		{
-			name:    "hidden legacy alias is not independently required",
-			make:    func() FlagMigrationManifest { return coverageManifest(FlagMigrationPending) },
-			mutate:  func(m *FlagMigrationManifest) { m.Migrations[0].Legacy.After.Required = true },
-			wantErr: "legacy compatibility alias must not remain independently required",
-		},
 		{
 			name:    "legacy after declares alias target",
 			make:    func() FlagMigrationManifest { return coverageManifest(FlagMigrationPending) },
@@ -741,64 +711,11 @@ func TestCrossPlatformCoverageCompareAllWithFlagMigrationsInheritedAndOptionalCa
 		}
 	})

-	t.Run("optional canonical is introduced without becoming required", func(t *testing.T) {
-		pending := coverageOptionalManifest(FlagMigrationPending)
-		consumed := coverageOptionalManifest(FlagMigrationConsumed)
-		before := coverageMigrationSnapshot(pending.Migrations[0], false, false)
-		after := coverageMigrationSnapshot(pending.Migrations[0], true, false)
-
-		ordinary := Compare(after, before, "merge-base")
-		if !hasFlagChange(ordinary.Blocking, "flag_became_hidden", pending.Migrations[0].Command, pending.Migrations[0].Legacy.Name) {
-			t.Fatalf("fixture did not create flag_became_hidden: %#v", ordinary.Blocking)
-		}
-		if hasFlagChange(ordinary.Blocking, "required_flag_added", pending.Migrations[0].Command, pending.Migrations[0].Canonical.Name) {
-			t.Fatalf("optional canonical was treated as required: %#v", ordinary.Blocking)
-		}
-		report, err := CompareAllWithFlagMigrations(
-			after,
-			map[string]Snapshot{"merge-base": before, "stable": before},
-			pending,
-			consumed,
-		)
-		if err != nil || !report.Compatible {
-			t.Fatalf("optional rename = (%#v, %v), want compatible", report, err)
-		}
-	})
-
-	t.Run("existing optional canonical remains optional", func(t *testing.T) {
-		pending := coverageOptionalManifest(FlagMigrationPending)
-		pending.Migrations[0].Canonical.Before = FlagMigrationState{
-			Present: true,
-			Type:    "string",
-			Scope:   "local",
-		}
-		consumed := pending
-		consumed.Migrations = append([]FlagMigration(nil), pending.Migrations...)
-		consumed.Migrations[0].State = FlagMigrationConsumed
-		before := coverageMigrationSnapshot(pending.Migrations[0], false, false)
-		after := coverageMigrationSnapshot(pending.Migrations[0], true, false)
-
-		ordinary := Compare(after, before, "merge-base")
-		if hasFlagChange(ordinary.Blocking, "flag_became_required", pending.Migrations[0].Command, pending.Migrations[0].Canonical.Name) {
-			t.Fatalf("fixture changed canonical requiredness: %#v", ordinary.Blocking)
-		}
-		report, err := CompareAllWithFlagMigrations(
-			after,
-			map[string]Snapshot{"merge-base": before, "stable": before},
-			pending,
-			consumed,
-		)
-		if err != nil || !report.Compatible {
-			t.Fatalf("existing optional canonical migration = (%#v, %v), want compatible", report, err)
-		}
-	})
-
-	t.Run("hidden canonical inherits requiredness when promoted", func(t *testing.T) {
+	t.Run("existing optional canonical becomes required", func(t *testing.T) {
 		pending := coverageManifest(FlagMigrationPending)
 		pending.Migrations[0].Canonical.Before = FlagMigrationState{
 			Present: true,
 			Type:    "string",
-			Hidden:  true,
 			Scope:   "local",
 		}
 		consumed := pending
@@ -809,7 +726,7 @@ func TestCrossPlatformCoverageCompareAllWithFlagMigrationsInheritedAndOptionalCa

 		ordinary := Compare(after, before, "merge-base")
 		if !hasFlagChange(ordinary.Blocking, "flag_became_required", pending.Migrations[0].Command, pending.Migrations[0].Canonical.Name) {
-			t.Fatalf("fixture did not change canonical requiredness: %#v", ordinary.Blocking)
+			t.Fatalf("fixture did not create flag_became_required: %#v", ordinary.Blocking)
 		}
 		report, err := CompareAllWithFlagMigrations(
 			after,
@@ -818,54 +735,7 @@ func TestCrossPlatformCoverageCompareAllWithFlagMigrationsInheritedAndOptionalCa
 			consumed,
 		)
 		if err != nil || !report.Compatible {
-			t.Fatalf("hidden canonical promotion = (%#v, %v), want compatible", report, err)
-		}
-	})
-}
-
-func TestCrossPlatformCoverageOptionalFlagMigrationLifecycleRemainsHostile(t *testing.T) {
-	pending := coverageOptionalManifest(FlagMigrationPending)
-	consumed := coverageOptionalManifest(FlagMigrationConsumed)
-	empty := coverageEmptyManifest()
-	migration := pending.Migrations[0]
-	before := coverageMigrationSnapshot(migration, false, false)
-	after := coverageMigrationSnapshot(migration, true, false)
-
-	t.Run("candidate cannot self authorize", func(t *testing.T) {
-		_, err := CompareAllWithFlagMigrations(
-			after,
-			map[string]Snapshot{"merge-base": before, "stable": before},
-			empty,
-			pending,
-		)
-		if err == nil || !strings.Contains(err.Error(), "cannot authorize its own interface change") {
-			t.Fatalf("candidate self-authorization error = %v", err)
-		}
-	})
-
-	t.Run("partial application remains rejected", func(t *testing.T) {
-		partial := coverageMigrationSnapshot(migration, false, false)
-		partial.Commands[len(partial.Commands)-1].LocalFlags[0].Hidden = true
-		_, err := CompareAllWithFlagMigrations(
-			partial,
-			map[string]Snapshot{"merge-base": before, "stable": before},
-			pending,
-			consumed,
-		)
-		if err == nil || !strings.Contains(err.Error(), "partially applied flag migration") {
-			t.Fatalf("partial optional migration error = %v", err)
-		}
-	})
-
-	t.Run("consumed receipt remains stale after every reference converges", func(t *testing.T) {
-		_, err := CompareAllWithFlagMigrations(
-			after,
-			map[string]Snapshot{"merge-base": after, "stable": after},
-			consumed,
-			consumed,
-		)
-		if err == nil || !strings.Contains(err.Error(), "stale after all references reached the after state") {
-			t.Fatalf("stale optional migration error = %v", err)
+			t.Fatalf("optional-to-required migration = (%#v, %v), want compatible", report, err)
 		}
 	})
 }
@@ -1016,13 +886,6 @@ func coverageManifest(state string) FlagMigrationManifest {
 	}
 }

-func coverageOptionalManifest(state string) FlagMigrationManifest {
-	manifest := coverageManifest(state)
-	manifest.Migrations[0].Legacy.Before.Required = false
-	manifest.Migrations[0].Canonical.After.Required = false
-	return manifest
-}
-
 func coverageEmptyManifest() FlagMigrationManifest {
 	return FlagMigrationManifest{Version: FlagMigrationManifestVersion, Migrations: []FlagMigration{}}
 }
@@ -5,7 +5,6 @@ package interfacesnapshot

 import (
 	"errors"
-	"os"
 	"reflect"
 	"strings"
 	"testing"
@@ -38,42 +37,6 @@ const validFlagMigrationManifestJSON = `{
  ]
 }`

-func optionalFlagMigrationManifestJSON() string {
-	manifest := strings.Replace(
-		validFlagMigrationManifestJSON,
-		`"before": {"present": true, "type": "string", "required": true, "scope": "local"}`,
-		`"before": {"present": true, "type": "string", "scope": "local"}`,
-		1,
-	)
-	return strings.Replace(
-		manifest,
-		`"after": {"present": true, "type": "string", "required": true, "scope": "local"}`,
-		`"after": {"present": true, "type": "string", "scope": "local"}`,
-		1,
-	)
-}
-
-func hiddenCanonicalFlagMigrationManifestJSON() string {
-	return strings.Replace(
-		validFlagMigrationManifestJSON,
-		`"before": {"present": false}`,
-		`"before": {"present": true, "type": "string", "hidden": true, "scope": "local"}`,
-		1,
-	)
-}
-
-func TestApprovedFlagMigrationManifestRemainsValid(t *testing.T) {
-	manifest, err := os.Open("../../scripts/policy/interface-migrations/approved-flag-migrations-v1.json")
-	if err != nil {
-		t.Fatalf("open approved flag migration manifest: %v", err)
-	}
-	defer manifest.Close()
-
-	if _, err := ReadFlagMigrationManifest(manifest); err != nil {
-		t.Fatalf("approved flag migration manifest is invalid: %v", err)
-	}
-}
-
 func TestCrossPlatformCoverageReadFlagMigrationManifestRejectsUnknownFields(t *testing.T) {
 	_, err := ReadFlagMigrationManifest(strings.NewReader(`{
  "version": 1,
@@ -147,12 +110,6 @@ func TestCrossPlatformCoverageReadFlagMigrationManifestValidatesExactEntries(t *
 	if _, err := ReadFlagMigrationManifest(strings.NewReader(validFlagMigrationManifestJSON)); err != nil {
 		t.Fatalf("ReadFlagMigrationManifest(valid) error = %v", err)
 	}
-	if _, err := ReadFlagMigrationManifest(strings.NewReader(optionalFlagMigrationManifestJSON())); err != nil {
-		t.Fatalf("ReadFlagMigrationManifest(optional rename) error = %v", err)
-	}
-	if _, err := ReadFlagMigrationManifest(strings.NewReader(hiddenCanonicalFlagMigrationManifestJSON())); err != nil {
-		t.Fatalf("ReadFlagMigrationManifest(hidden canonical promotion) error = %v", err)
-	}

 	tests := []struct {
 		name    string
@@ -205,34 +162,24 @@ func TestCrossPlatformCoverageReadFlagMigrationManifestValidatesExactEntries(t *
 			wantErr: "canonical flag must remain visible",
 		},
 		{
-			name: "required legacy becomes optional canonical",
+			name: "canonical remains optional",
 			input: strings.Replace(
 				validFlagMigrationManifestJSON,
 				`"after": {"present": true, "type": "string", "required": true, "scope": "local"}`,
 				`"after": {"present": true, "type": "string", "scope": "local"}`,
 				1,
 			),
-			wantErr: "requiredness must be preserved from legacy before to canonical after",
+			wantErr: "canonical flag must be required after migration",
 		},
 		{
-			name: "optional legacy becomes required canonical",
-			input: strings.Replace(
-				optionalFlagMigrationManifestJSON(),
-				`"after": {"present": true, "type": "string", "scope": "local"}`,
-				`"after": {"present": true, "type": "string", "required": true, "scope": "local"}`,
-				1,
-			),
-			wantErr: "requiredness must be preserved from legacy before to canonical after",
-		},
-		{
-			name: "existing canonical changes requiredness",
+			name: "canonical was already required",
 			input: strings.Replace(
 				validFlagMigrationManifestJSON,
 				`"before": {"present": false}`,
-				`"before": {"present": true, "type": "string", "scope": "local"}`,
+				`"before": {"present": true, "type": "string", "required": true, "scope": "local"}`,
 				1,
 			),
-			wantErr: "canonical flag requiredness must remain unchanged when already present",
+			wantErr: "canonical flag must be absent or optional before migration",
 		},
 	}

@@ -268,10 +215,9 @@ func TestCrossPlatformCoverageFlagMigrationManifestRejectsDuplicateAndInexactCon
 	canonicalDrift := manifest
 	canonicalDrift.Migrations = append([]FlagMigration(nil), manifest.Migrations...)
 	canonicalDrift.Migrations[0].Canonical.Before = FlagMigrationState{
-		Present:  true,
-		Type:     "string",
-		Required: true,
-		Scope:    "local",
+		Present: true,
+		Type:    "string",
+		Scope:   "local",
 	}
 	canonicalDrift.Migrations[0].Canonical.After.Type = "stringSlice"
 	if err := canonicalDrift.Validate(); err == nil || !strings.Contains(err.Error(), "canonical flag type") {
@@ -26,8 +26,6 @@ import (
 var sensitiveKeys = map[string]bool{
 	"authorization":       true,
 	"x-user-access-token": true,
-	"dws_agent_ext":       true,
-	"x-dws-agent-ext":     true,
 	"client_secret":       true,
 	"client-secret":       true,
 	"token":               true,
@@ -30,12 +30,6 @@ func TestIsSensitiveKey(t *testing.T) {
 		{"authorization", true},
 		{"x-user-access-token", true},
 		{"X-User-Access-Token", true},
-		{"DWS_AGENT_EXT", true},
-		{"dws_agent_ext", true},
-		{"x-dws-agent-ext", true},
-		{"X-Dws-Agent-Ext", true},
-		{"DWS_AGENT_VER", false},
-		{"x-dws-agent-ver", false},
 		{"client_secret", true},
 		{"client-secret", true},
 		{"token", true},
@@ -134,24 +128,17 @@ func TestSanitizeArguments_Empty(t *testing.T) {

 func TestRedactHeaders(t *testing.T) {
 	t.Parallel()
-	headers := make(http.Header)
-	headers.Set("Authorization", "Bearer test-credential-value")
-	headers.Set("Content-Type", "application/json")
-	headers.Set("DWS_AGENT_EXT", `{"umt":"test-umt-value"}`)
-	headers.Set("x-dws-agent-ext", `{"ua":"test-agent-value"}`)
+	headers := http.Header{
+		"Authorization": {"Bearer token123456"},
+		"Content-Type":  {"application/json"},
+	}
 	attrs := RedactHeaders(headers)
-	if len(attrs) != 4 {
-		t.Fatalf("expected 4 attrs, got %d", len(attrs))
+	if len(attrs) != 2 {
+		t.Fatalf("expected 2 attrs, got %d", len(attrs))
 	}
 	for _, attr := range attrs {
-		switch attr.Key {
-		case "header.authorization", "header.dws_agent_ext", "header.x-dws-agent-ext":
-			if !strings.Contains(attr.Value.String(), "***") {
-				t.Fatalf("%s should be redacted: %s", attr.Key, attr.Value.String())
-			}
-			if strings.Contains(attr.Value.String(), "test-") {
-				t.Fatalf("%s leaked its original value: %s", attr.Key, attr.Value.String())
-			}
+		if attr.Key == "header.authorization" && !strings.Contains(attr.Value.String(), "***") {
+			t.Fatalf("authorization should be redacted: %s", attr.Value.String())
 		}
 		if attr.Key == "header.content-type" && attr.Value.String() != "application/json" {
 			t.Fatalf("content-type should not be redacted: %s", attr.Value.String())
@@ -104,35 +104,6 @@ func TestCrossPlatformCoverageFlagListMaxItemsPublishesStableTruncation(t *testi
 	}
 }

-func TestCrossPlatformCoverageFlagListLegacyFullRemainingPageFailsClosed(t *testing.T) {
-	fake := &larkAlignmentCaller{sequenceResponses: map[string][]string{
-		"im/list_message_favorites": {
-			`{"result":{"items":[{"openMessageId":"m1"},{"openMessageId":"m2"}],"hasMore":true,"nextCursor":7}}`,
-			`{"result":{"items":[{"openMessageId":"m3"}]}}`,
-		},
-	}}
-	helpers.InitDeps(fake)
-	root := newPlatformCoverageRoot()
-	var output bytes.Buffer
-	root.SetOut(&output)
-	root.SetArgs([]string{"chat", "+flag-list", "--page-size", "2", "--page-all", "--max-items", "3"})
-	if err := root.Execute(); err == nil {
-		t.Fatal("full remaining-budget legacy page unexpectedly declared a complete result")
-	}
-	if len(fake.calls) != 2 || fake.calls[0].args["size"] != "2" || fake.calls[1].args["size"] != "1" {
-		t.Fatalf("request sizes = %#v", fake.calls)
-	}
-	var payload map[string]any
-	if err := json.Unmarshal(output.Bytes(), &payload); err != nil {
-		t.Fatal(err)
-	}
-	if payload["count"] != float64(3) || payload["complete"] != false ||
-		payload["paginationKnown"] != false || payload["stopReason"] != "pagination_error" ||
-		payload["failedCount"] != float64(1) || payload["nextCursor"] != float64(0) {
-		t.Fatalf("payload = %#v", payload)
-	}
-}
-
 func TestCrossPlatformCoverageFlagListFailsClosedOnOversizeAndCanceledDelay(t *testing.T) {
 	t.Run("oversized lower page", func(t *testing.T) {
 		fake := &larkAlignmentCaller{responses: map[string]string{
@@ -651,7 +651,7 @@ func executeFlagList(rt *shortcut.RuntimeContext) error {
 			switch {
 			case nextCursor > 0:
 				pageHasMore = true
-			case len(pageItems) < requestPageSize:
+			case len(pageItems) < pageSize:
 				paginationKnown = false
 				complete = true
 				hasMore = false
@@ -486,23 +486,9 @@ var Upload = shortcut.Shortcut{
 		if err != nil {
 			return err
 		}
-		remoteID := firstString(verified, "fileId", "dentryUuid", "nodeId", "id")
-		if remoteID == "" {
-			return driveResponseError("drive/commit_upload", "readback_missing_id", "上传后读回缺少文件 ID；无法证明读回的是已提交文件")
-		}
-		if remoteID != nodeID {
-			return driveResponseError("drive/commit_upload", "readback_id_mismatch", fmt.Sprintf("上传后读回文件 ID %q 与提交 ID %q 不一致", remoteID, nodeID))
-		}
-		if remoteName := firstString(verified, "name", "fileName"); !driveReadbackNameMatches(verified, name) {
+		if remoteName := firstString(verified, "name", "fileName"); remoteName == "" || !strings.HasPrefix(remoteName, strings.TrimSuffix(name, filepath.Ext(name))) {
 			return driveResponseError("drive/commit_upload", "readback_mismatch", fmt.Sprintf("上传后读回名称 %q 与请求 %q 不一致", remoteName, name))
 		}
-		remoteSize, ok := firstInt64(verified, "fileSize", "size", "byteSize", "length")
-		if !ok {
-			return driveResponseError("drive/commit_upload", "readback_missing_size", "上传后读回缺少有效文件大小；无法证明远端文件完整")
-		}
-		if remoteSize != info.Size() {
-			return driveResponseError("drive/commit_upload", "readback_size_mismatch", fmt.Sprintf("上传后读回大小 %d 与本地文件大小 %d 不一致", remoteSize, info.Size()))
-		}
 		return rt.Output(map[string]any{"success": true, "nodeId": nodeID, "sizeBytes": info.Size(), "file": verified})
 	},
 }
@@ -6,8 +6,6 @@ package drive
 import (
 	"encoding/json"
 	"fmt"
-	"math"
-	"strconv"
 	"strings"

 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd"
@@ -218,47 +216,6 @@ func nestedString(data map[string]any, keys ...string) string {
 	return ""
 }

-func driveReadbackNameMatches(data map[string]any, requested string) bool {
-	remoteName := firstString(data, "name", "fileName")
-	if remoteName == requested {
-		return true
-	}
-	extension := strings.TrimLeft(firstString(data, "extension", "fileExtension", "ext"), ".")
-	return extension != "" && remoteName+"."+extension == requested
-}
-
-func firstInt64(data map[string]any, keys ...string) (int64, bool) {
-	for _, key := range keys {
-		value, present := data[key]
-		if !present {
-			continue
-		}
-		switch typed := value.(type) {
-		case int:
-			return int64(typed), true
-		case int32:
-			return int64(typed), true
-		case int64:
-			return typed, true
-		case float64:
-			if !math.IsNaN(typed) && !math.IsInf(typed, 0) && typed == math.Trunc(typed) && typed >= math.MinInt64 && typed < math.MaxInt64 {
-				return int64(typed), true
-			}
-		case json.Number:
-			parsed, err := strconv.ParseInt(typed.String(), 10, 64)
-			if err == nil {
-				return parsed, true
-			}
-		case string:
-			parsed, err := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
-			if err == nil {
-				return parsed, true
-			}
-		}
-	}
-	return 0, false
-}
-
 func driveResponseError(operation, reason, message string) error {
 	return apperrors.NewAPI(message,
 		apperrors.WithOperation(operation),
@@ -20,7 +20,6 @@
 package drive

 import (
-	"fmt"
 	"strings"

 	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/corecmd"
@@ -547,31 +546,6 @@ var Move = shortcut.Shortcut{
 		if err != nil {
 			return err
 		}
-		remoteID := firstString(verified, "nodeId", "fileId", "dentryUuid", "id")
-		if remoteID == "" {
-			return driveResponseError("doc/move_document", "readback_missing_id", "移动后读回缺少节点 ID；无法证明读回的是已移动节点")
-		}
-		if remoteID != rt.Str("node") {
-			return driveResponseError("doc/move_document", "readback_id_mismatch", fmt.Sprintf("移动后读回节点 %q 与请求节点 %q 不一致", remoteID, rt.Str("node")))
-		}
-		if rt.Changed("folder") {
-			remoteFolder := firstString(verified, "folderId", "targetFolderId", "parentId")
-			if remoteFolder == "" {
-				return driveResponseError("doc/move_document", "readback_missing_folder", "移动后读回缺少目标文件夹 ID；无法证明移动已到达请求位置")
-			}
-			if remoteFolder != rt.Str("folder") {
-				return driveResponseError("doc/move_document", "readback_folder_mismatch", fmt.Sprintf("移动后读回文件夹 %q 与请求 %q 不一致", remoteFolder, rt.Str("folder")))
-			}
-		}
-		if rt.Changed("workspace") {
-			remoteWorkspace := firstString(verified, "workspaceId", "spaceId")
-			if remoteWorkspace == "" {
-				return driveResponseError("doc/move_document", "readback_missing_workspace", "移动后读回缺少目标知识库 ID；无法证明移动已到达请求位置")
-			}
-			if remoteWorkspace != rt.Str("workspace") {
-				return driveResponseError("doc/move_document", "readback_workspace_mismatch", fmt.Sprintf("移动后读回知识库 %q 与请求 %q 不一致", remoteWorkspace, rt.Str("workspace")))
-			}
-		}
 		return rt.Output(map[string]any{"success": true, "nodeId": rt.Str("node"), "file": verified})
 	},
 }
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"os"
 	"path/filepath"
 	"strings"
@@ -177,40 +176,6 @@ func TestCrossPlatformCoverageDriveDownloadAndUploadRequireArtifactsAndReadback(
 	if _, _, err := resolveDriveUploadInput("../escape.bin"); err == nil {
 		t.Fatal("upload path escape was accepted")
 	}
-	for _, tc := range []struct {
-		name        string
-		committedID string
-		readback    string
-		want        string
-	}{
-		{"missing remote id", "uploaded-2", `{"success":true,"result":{"name":"input.bin","fileSize":18}}`, "缺少文件 ID"},
-		{"mismatched remote id", "uploaded-3", `{"success":true,"result":{"fileId":"other","name":"input.bin","fileSize":18}}`, "与提交 ID"},
-		{"prefix-only remote name", "uploaded-4", `{"success":true,"result":{"fileId":"uploaded-4","name":"input.bin-old","fileSize":18}}`, "读回名称"},
-		{"missing remote size", "uploaded-5", `{"success":true,"result":{"fileId":"uploaded-5","name":"input.bin"}}`, "缺少有效文件大小"},
-		{"mismatched remote size", "uploaded-6", `{"success":true,"result":{"fileId":"uploaded-6","name":"input.bin","fileSize":17}}`, "与本地文件大小 18 不一致"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			testseam.Swap(t, &uploadDriveFile, func(context.Context, helpers.DriveUploadRequest) (map[string]any, error) {
-				return map[string]any{"success": true, "result": map[string]any{"fileId": tc.committedID}}, nil
-			})
-			caller := &driveCoverageCaller{responses: map[string][]string{"get_file_info": {tc.readback}}}
-			err := runDriveCoverage(t, Upload, caller, "--file", "input.bin", "--yes")
-			if err == nil || !strings.Contains(err.Error(), tc.want) {
-				t.Fatalf("error = %v, want %q", err, tc.want)
-			}
-		})
-	}
-	t.Run("split remote extension", func(t *testing.T) {
-		testseam.Swap(t, &uploadDriveFile, func(context.Context, helpers.DriveUploadRequest) (map[string]any, error) {
-			return map[string]any{"success": true, "result": map[string]any{"fileId": "uploaded-7"}}, nil
-		})
-		caller := &driveCoverageCaller{responses: map[string][]string{
-			"get_file_info": {`{"success":true,"result":{"fileId":"uploaded-7","name":"input","extension":"bin","fileSize":18}}`},
-		}}
-		if err := runDriveCoverage(t, Upload, caller, "--file", "input.bin", "--yes"); err != nil {
-			t.Fatal(err)
-		}
-	})

 	testseam.Swap(t, &driveDownload, func(_ context.Context, _ string, options localio.DownloadOptions) (localio.DownloadResult, error) {
 		if options.Output != "downloads/file.bin" || options.Headers["x-token"] != "secret" {
@@ -253,42 +218,6 @@ func TestCrossPlatformCoverageDriveCopyPreservesSchemaProperties(t *testing.T) {
 	}
 }

-func TestCrossPlatformCoverageDriveFirstInt64(t *testing.T) {
-	for _, tc := range []struct {
-		name  string
-		value any
-		want  int64
-		ok    bool
-	}{
-		{"int", int(1), 1, true},
-		{"int32", int32(2), 2, true},
-		{"int64", int64(3), 3, true},
-		{"float", float64(4), 4, true},
-		{"json number", json.Number("5"), 5, true},
-		{"string", " 6 ", 6, true},
-		{"fraction", 1.5, 0, false},
-		{"nan", math.NaN(), 0, false},
-		{"infinity", math.Inf(1), 0, false},
-		{"overflow", float64(math.MaxInt64), 0, false},
-		{"bad json number", json.Number("bad"), 0, false},
-		{"bad string", "bad", 0, false},
-		{"unsupported", true, 0, false},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			got, ok := firstInt64(map[string]any{"size": tc.value}, "missing", "size")
-			if ok != tc.ok || got != tc.want {
-				t.Fatalf("firstInt64(%#v) = (%d, %t), want (%d, %t)", tc.value, got, ok, tc.want, tc.ok)
-			}
-		})
-	}
-	if got, ok := firstInt64(map[string]any{}, "size"); ok || got != 0 {
-		t.Fatalf("missing firstInt64 = (%d, %t), want (0, false)", got, ok)
-	}
-	if got, ok := firstInt64(map[string]any{"fileSize": nil, "size": "7"}, "fileSize", "size"); !ok || got != 7 {
-		t.Fatalf("fallback firstInt64 = (%d, %t), want (7, true)", got, ok)
-	}
-}
-
 func TestCrossPlatformCoverageDriveVersionAndPublishContracts(t *testing.T) {
 	versionPayload := `{"success":true,"versions":[{"version":1,"fileSize":3},{"versionNumber":"2","fileSize":4}],"hasMore":false}`
 	caller := &driveCoverageCaller{responses: map[string][]string{"list_file_versions": {versionPayload}}}
@@ -520,34 +449,11 @@ func TestCrossPlatformCoverageDriveCreateRestoreCopyMoveRename(t *testing.T) {

 	move := &driveCoverageCaller{responses: map[string][]string{
 		"move_document":     {`{"success":true}`},
-		"get_document_info": {`{"success":true,"result":{"nodeId":"n1","folderId":"target","workspaceId":"space"}}`},
+		"get_document_info": {`{"success":true,"result":{"nodeId":"n1"}}`},
 	}}
 	if err := runDriveCoverage(t, Move, move, "--node", "n1", "--folder", "target", "--workspace", "space", "--yes"); err != nil {
 		t.Fatal(err)
 	}
-	for _, tc := range []struct {
-		name     string
-		readback string
-		want     string
-	}{
-		{"missing node id", `{"success":true,"result":{"folderId":"target","workspaceId":"space"}}`, "缺少节点 ID"},
-		{"wrong node id", `{"success":true,"result":{"nodeId":"other","folderId":"target","workspaceId":"space"}}`, "与请求节点 \"n1\" 不一致"},
-		{"missing folder", `{"success":true,"result":{"nodeId":"n1","workspaceId":"space"}}`, "缺少目标文件夹 ID"},
-		{"wrong folder", `{"success":true,"result":{"nodeId":"n1","folderId":"other","workspaceId":"space"}}`, "与请求 \"target\" 不一致"},
-		{"missing workspace", `{"success":true,"result":{"nodeId":"n1","folderId":"target"}}`, "缺少目标知识库 ID"},
-		{"wrong workspace", `{"success":true,"result":{"nodeId":"n1","folderId":"target","workspaceId":"other"}}`, "与请求 \"space\" 不一致"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			caller := &driveCoverageCaller{responses: map[string][]string{
-				"move_document":     {`{"success":true}`},
-				"get_document_info": {tc.readback},
-			}}
-			err := runDriveCoverage(t, Move, caller, "--node", "n1", "--folder", "target", "--workspace", "space", "--yes")
-			if err == nil || !strings.Contains(err.Error(), tc.want) {
-				t.Fatalf("error = %v, want %q", err, tc.want)
-			}
-		})
-	}

 	rename := &driveCoverageCaller{responses: map[string][]string{
 		"get_file_info":   {`{"success":true,"result":{"fileId":"n1","type":"FILE","extension":"md","name":"old.md"}}`, `{"success":true,"result":{"fileId":"n1","name":"new.md"}}`},
@@ -1,93 +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 transport
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func TestCrossPlatformCoverageAgentMetadataReachesEveryMCPMethod(t *testing.T) {
-	t.Parallel()
-
-	const (
-		agentVersion = "1.2.3-test+7"
-		agentExt     = `{"umt":"test-umt","nested":{"enabled":true}}`
-		cliVersion   = "9.8.7-cli"
-		userAgent    = "dws-user-agent-test/1.0"
-	)
-
-	seen := make(map[string]int)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var request requestEnvelope
-		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		seen[request.Method]++
-		if got := r.Header.Get(HeaderAgentVersion); got != agentVersion {
-			t.Errorf("%s %s = %q, want %q", request.Method, HeaderAgentVersion, got, agentVersion)
-		}
-		if got := r.Header.Get(HeaderAgentExt); got != agentExt {
-			t.Errorf("%s %s = %q, want %q", request.Method, HeaderAgentExt, got, agentExt)
-		}
-		if got := r.Header.Get(HeaderVersion); got != cliVersion {
-			t.Errorf("%s %s = %q, want %q", request.Method, HeaderVersion, got, cliVersion)
-		}
-		if got := r.Header.Get("User-Agent"); got != userAgent {
-			t.Errorf("%s User-Agent = %q, want preset value %q", request.Method, got, userAgent)
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		switch request.Method {
-		case "initialize":
-			_, _ = fmt.Fprintf(w, `{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"%s","capabilities":{}}}`, supportedProtocolVersions[0])
-		case "tools/list":
-			_, _ = fmt.Fprint(w, `{"jsonrpc":"2.0","id":2,"result":{"tools":[]}}`)
-		case "tools/call":
-			_, _ = fmt.Fprint(w, `{"jsonrpc":"2.0","id":3,"result":{"content":{"success":true}}}`)
-		default:
-			http.Error(w, "unexpected method", http.StatusBadRequest)
-		}
-	}))
-	defer server.Close()
-
-	client := NewClient(server.Client())
-	client.ExtraHeaders = map[string]string{
-		HeaderAgentVersion: agentVersion,
-		HeaderAgentExt:     agentExt,
-		HeaderVersion:      cliVersion,
-		"User-Agent":       userAgent,
-	}
-	ctx := context.Background()
-	if _, err := client.Initialize(ctx, server.URL); err != nil {
-		t.Fatalf("Initialize() error = %v", err)
-	}
-	if _, err := client.ListTools(ctx, server.URL); err != nil {
-		t.Fatalf("ListTools() error = %v", err)
-	}
-	if _, err := client.CallTool(ctx, server.URL, "test_tool", map[string]any{"value": "safe"}); err != nil {
-		t.Fatalf("CallTool() error = %v", err)
-	}
-
-	for _, method := range []string{"initialize", "tools/list", "tools/call"} {
-		if got := seen[method]; got != 1 {
-			t.Errorf("%s request count = %d, want 1", method, got)
-		}
-	}
-}
@@ -68,12 +68,10 @@ const (
 	defaultRetryMaxDelay = 5 * time.Second

 	// Security headers
-	HeaderSource       = "X-Cli-Source"
-	HeaderVersion      = "X-Cli-Version"
-	HeaderExecutionId  = "X-Cli-Execution-Id"
-	HeaderAgentVersion = "x-dws-agent-ver"
-	HeaderAgentExt     = "x-dws-agent-ext"
-	SourceValue        = "dws-cli"
+	HeaderSource      = "X-Cli-Source"
+	HeaderVersion     = "X-Cli-Version"
+	HeaderExecutionId = "X-Cli-Execution-Id"
+	SourceValue       = "dws-cli"
 )

 // Supported MCP protocol versions, ordered from newest to oldest.
@@ -258,43 +256,20 @@ func NewClient(httpClient *http.Client) *Client {

 // safeRedirectPolicy prevents credential headers from being forwarded
 // when a response redirects to a different host (e.g. API 302 → CDN).
-// Credentials and Agent extension context are bound to the initial origin:
-// once a redirect chain leaves that origin they remain stripped for every
-// subsequent hop, including a redirect back to the initial origin.
-// Non-sensitive headers like X-Cli-* and x-dws-agent-ver pass through.
+// Strips Authorization, x-user-access-token on cross-host redirects;
+// other headers like X-Cli-* pass through.
 func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 	if len(via) >= 10 {
 		return fmt.Errorf("too many redirects")
 	}
-	if redirectChainLeftInitialOrigin(req, via) {
-		req.Header.Del(HeaderAgentExt)
+	if len(via) > 0 && req.URL.Host != via[0].URL.Host {
+		// Cross-host redirect: strip sensitive headers to prevent credential leakage
 		req.Header.Del("Authorization")
 		req.Header.Del("x-user-access-token")
 	}
 	return nil
 }

-func redirectChainLeftInitialOrigin(req *http.Request, via []*http.Request) bool {
-	if len(via) == 0 {
-		return false
-	}
-	initialURL := via[0].URL
-	if !sameOrigin(req.URL, initialURL) {
-		return true
-	}
-	for _, previous := range via[1:] {
-		if !sameOrigin(previous.URL, initialURL) {
-			return true
-		}
-	}
-	return false
-}
-
-func sameOrigin(left, right *url.URL) bool {
-	return strings.EqualFold(left.Scheme, right.Scheme) &&
-		strings.EqualFold(left.Host, right.Host)
-}
-
 // WithAuth returns a shallow copy of c with the given auth token and extra
 // headers. The returned client shares the underlying HTTP client but is safe
 // to use concurrently with the original.
@@ -1,140 +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 transport
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-)
-
-func TestCrossPlatformCoverageSafeRedirectPolicyAgentMetadataHeaders(t *testing.T) {
-	t.Parallel()
-
-	newRequest := func(t *testing.T, rawURL string) *http.Request {
-		t.Helper()
-		req, err := http.NewRequest(http.MethodGet, rawURL, nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		req.Header.Set(HeaderAgentVersion, "1.2.3-test")
-		req.Header.Set(HeaderAgentExt, `{"ua":"test-agent-value"}`)
-		req.Header.Set("Authorization", "Bearer test-token")
-		req.Header.Set("x-user-access-token", "test-token")
-		return req
-	}
-
-	assertHeaders := func(t *testing.T, request *http.Request, wantExt bool) {
-		t.Helper()
-		if got := request.Header.Get(HeaderAgentVersion); got != "1.2.3-test" {
-			t.Fatalf("agent version = %q, want retained", got)
-		}
-		gotExt := request.Header.Get(HeaderAgentExt)
-		if wantExt && gotExt == "" {
-			t.Fatal("agent extension was removed")
-		}
-		if !wantExt && gotExt != "" {
-			t.Fatalf("agent extension leaked across origins: %q", gotExt)
-		}
-		for _, key := range []string{"Authorization", "x-user-access-token"} {
-			got := request.Header.Get(key)
-			if wantExt && got == "" {
-				t.Fatalf("same-origin redirect removed %s", key)
-			}
-			if !wantExt && got != "" {
-				t.Fatalf("credential %s leaked across origins", key)
-			}
-		}
-	}
-
-	t.Run("same origin retains version and extension", func(t *testing.T) {
-		t.Parallel()
-		previous := newRequest(t, "https://api.example.test/start")
-		redirected := newRequest(t, "https://api.example.test/next")
-
-		if err := safeRedirectPolicy(redirected, []*http.Request{previous}); err != nil {
-			t.Fatal(err)
-		}
-		assertHeaders(t, redirected, true)
-	})
-
-	t.Run("cross host strips extension and retains version", func(t *testing.T) {
-		t.Parallel()
-		previous := newRequest(t, "https://api.example.test/start")
-		redirected := newRequest(t, "https://cdn.example.test/asset")
-
-		if err := safeRedirectPolicy(redirected, []*http.Request{previous}); err != nil {
-			t.Fatal(err)
-		}
-		assertHeaders(t, redirected, false)
-	})
-
-	t.Run("scheme downgrade on same host strips extension", func(t *testing.T) {
-		t.Parallel()
-		previous := newRequest(t, "https://api.example.test/start")
-		redirected := newRequest(t, "http://api.example.test/next")
-
-		if err := safeRedirectPolicy(redirected, []*http.Request{previous}); err != nil {
-			t.Fatal(err)
-		}
-		assertHeaders(t, redirected, false)
-	})
-
-	t.Run("extension remains stripped after returning to initial origin", func(t *testing.T) {
-		t.Parallel()
-		initial := newRequest(t, "https://api.example.test/start")
-		crossOrigin := newRequest(t, "https://cdn.example.test/asset")
-		redirectedBack := newRequest(t, "https://api.example.test/final")
-
-		if err := safeRedirectPolicy(redirectedBack, []*http.Request{initial, crossOrigin}); err != nil {
-			t.Fatal(err)
-		}
-		assertHeaders(t, redirectedBack, false)
-	})
-
-	t.Run("extension remains stripped on later cross-origin hop", func(t *testing.T) {
-		t.Parallel()
-		initial := newRequest(t, "https://api.example.test/start")
-		crossOrigin := newRequest(t, "https://cdn.example.test/asset")
-		redirected := newRequest(t, "https://cdn.example.test/final")
-
-		if err := safeRedirectPolicy(redirected, []*http.Request{initial, crossOrigin}); err != nil {
-			t.Fatal(err)
-		}
-		assertHeaders(t, redirected, false)
-	})
-
-	t.Run("initial request is unchanged", func(t *testing.T) {
-		t.Parallel()
-		request := newRequest(t, "https://api.example.test/start")
-
-		if err := safeRedirectPolicy(request, nil); err != nil {
-			t.Fatal(err)
-		}
-		assertHeaders(t, request, true)
-	})
-
-	t.Run("redirect limit is enforced", func(t *testing.T) {
-		t.Parallel()
-		request := newRequest(t, "https://api.example.test/final")
-		via := make([]*http.Request, 10)
-		for index := range via {
-			via[index] = newRequest(t, "https://api.example.test/"+strings.Repeat("x", index+1))
-		}
-
-		if err := safeRedirectPolicy(request, via); err == nil {
-			t.Fatal("safeRedirectPolicy() error = nil, want redirect limit error")
-		}
-	})
-}
@@ -15,9 +15,8 @@ package cli

 import "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/app"

-// MCPIdentityHeaders returns the shared identity and edition headers that
-// overlays may pass to auxiliary clients. MCP-request-only metadata such as
-// DWS_AGENT_VER and DWS_AGENT_EXT is intentionally excluded.
+// MCPIdentityHeaders returns HTTP headers aligned with MCP tool calls
+// (identity + edition merge). Overlays may pass this to auxiliary clients.
 func MCPIdentityHeaders() map[string]string {
 	return app.MCPIdentityHeaders()
 }
@@ -1,35 +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 cli
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCrossPlatformCoverageMCPIdentityHeadersExcludeMCPOnlyMetadata(t *testing.T) {
-	t.Setenv("DWS_CONFIG_DIR", t.TempDir())
-	t.Setenv("DWS_AGENT_VER", "1.2.3")
-	t.Setenv("DWS_AGENT_EXT", `{"ua":"test-agent/1.2.3"}`)
-
-	headers := MCPIdentityHeaders()
-	if headers == nil {
-		t.Fatal("MCPIdentityHeaders() returned nil")
-	}
-	for key := range headers {
-		if strings.EqualFold(key, "x-dws-agent-ver") || strings.EqualFold(key, "x-dws-agent-ext") {
-			t.Fatalf("shared identity export leaked MCP-only Header %q", key)
-		}
-	}
-}
@@ -14,7 +14,7 @@ runtime_contract="skills/multi/dingtalk-shared/references/runtime-contract.md"
 chat_target_bytes=10000
 chat_max_overage_percent=5
 chat_max_bytes=$((chat_target_bytes * (100 + chat_max_overage_percent) / 100))
-doc_max_bytes=10000
+doc_max_bytes=9000
 event_max_bytes=10000
 runtime_contract_max_bytes=3000

@@ -1313,8 +1313,6 @@ func validateRenamedSchemaParameter(
 	oldParameter parameterSchema,
 	newParameter parameterSchema,
 ) error {
-	// The migration authorizes only the CLI spelling change. Requiredness is
-	// part of the parameter contract in both projections and must remain exact.
 	if oldParameter.Type != newParameter.Type ||
 		oldParameter.Property != newParameter.Property ||
 		oldParameter.InterfaceType != newParameter.InterfaceType ||
@@ -1330,17 +1328,17 @@ func validateRenamedSchemaParameter(
 			migration.Canonical.Name,
 		)
 	}
-	if oldParameter.Required != newParameter.Required {
+	if oldParameter.Required && !newParameter.Required {
 		return fmt.Errorf(
-			"approved flag migration %q Schema parameter %q -> %q changed requiredness",
+			"approved flag migration %q Schema parameter %q -> %q became optional",
 			migration.Command,
 			migration.Legacy.Name,
 			migration.Canonical.Name,
 		)
 	}
-	if oldParameter.CLIRequired != newParameter.CLIRequired {
+	if oldParameter.CLIRequired && !newParameter.CLIRequired {
 		return fmt.Errorf(
-			"approved flag migration %q Schema parameter %q -> %q changed cli_required",
+			"approved flag migration %q Schema parameter %q -> %q stopped being cli_required",
 			migration.Command,
 			migration.Legacy.Name,
 			migration.Canonical.Name,
@@ -1218,11 +1218,8 @@ func TestCrossPlatformCoverageSchemaFlagMigrationNormalizesExactRename(t *testin
 			t.Fatalf("normalized baseline retained legacy parameter %q", legacy)
 		}
 	}
-	if canonical := tool.Parameters["conversation-id"]; canonical.Required || canonical.CLIRequired {
-		t.Fatalf("optional canonical rename changed requiredness: %#v", canonical)
-	}
-	if canonical := tool.Parameters["message-id"]; !canonical.Required || !canonical.CLIRequired {
-		t.Fatalf("required canonical rename changed requiredness: %#v", canonical)
+	if canonical := tool.Parameters["conversation-id"]; !canonical.Required || !canonical.CLIRequired {
+		t.Fatalf("canonical required transition was not normalized: %#v", canonical)
 	}
 	if tool.Constraints != current.Products["chat"].Tools["chat.edit_message"].Constraints {
 		t.Fatalf("constraints were not normalized: %s", tool.Constraints)
@@ -1272,39 +1269,6 @@ func TestCrossPlatformCoverageSchemaFlagMigrationRejectsSemanticDrift(t *testing
 			}
 		})
 	}
-
-	for _, test := range []struct {
-		name   string
-		want   string
-		mutate func(*parameterSchema)
-	}{
-		{name: "optional required promotion", want: "changed requiredness", mutate: func(parameter *parameterSchema) {
-			parameter.Required = true
-		}},
-		{name: "optional cli_required promotion", want: "changed cli_required", mutate: func(parameter *parameterSchema) {
-			parameter.CLIRequired = true
-		}},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			current := schemaFlagMigrationContract(true)
-			product := current.Products["chat"]
-			tool := product.Tools["chat.edit_message"]
-			canonical := tool.Parameters["conversation-id"]
-			test.mutate(&canonical)
-			tool.Parameters["conversation-id"] = canonical
-			product.Tools["chat.edit_message"] = tool
-			current.Products["chat"] = product
-
-			_, err := normalizeSchemaFlagMigrations(
-				schemaFlagMigrationContract(false),
-				current,
-				schemaFlagMigrationAuthorizations(),
-			)
-			if err == nil || !strings.Contains(err.Error(), test.want) {
-				t.Fatalf("normalizeSchemaFlagMigrations() error = %v, want %q", err, test.want)
-			}
-		})
-	}
 }

 func TestCrossPlatformCoverageSchemaFlagMigrationAdapterBranches(t *testing.T) {
@@ -1357,10 +1321,9 @@ func TestCrossPlatformCoverageSchemaFlagMigrationAdapterBranches(t *testing.T) {
 		t.Fatal("missing candidate product was normalized away")
 	}

-	canonicalOnlyMigration := schemaFlagMigrationAuthorizations()[0]
-	canonicalOnlyMigration.Legacy.Name = "legacy-not-published-in-schema"
-	canonicalOnlyBaseline := schemaFlagMigrationContract(true)
-	driftedCanonical := cloneContract(canonicalOnlyBaseline)
+	canonicalOnly := schemaFlagMigrationAuthorizations()[0]
+	canonicalOnly.Legacy.Name = "legacy-not-published-in-schema"
+	driftedCanonical := cloneContract(current)
 	product = driftedCanonical.Products["chat"]
 	tool = product.Tools["chat.edit_message"]
 	canonical := tool.Parameters["conversation-id"]
@@ -1368,7 +1331,7 @@ func TestCrossPlatformCoverageSchemaFlagMigrationAdapterBranches(t *testing.T) {
 	tool.Parameters["conversation-id"] = canonical
 	product.Tools["chat.edit_message"] = tool
 	driftedCanonical.Products["chat"] = product
-	normalized, err = normalizeSchemaFlagMigrations(canonicalOnlyBaseline, driftedCanonical, []interfacesnapshot.FlagMigration{canonicalOnlyMigration})
+	normalized, err = normalizeSchemaFlagMigrations(baseline, driftedCanonical, []interfacesnapshot.FlagMigration{canonicalOnly})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1376,24 +1339,24 @@ func TestCrossPlatformCoverageSchemaFlagMigrationAdapterBranches(t *testing.T) {
 		t.Fatalf("canonical-only Schema drift was hidden: %s", failures)
 	}

-	promotedCanonical := cloneContract(canonicalOnlyBaseline)
-	product = promotedCanonical.Products["chat"]
+	canonicalOptional := schemaFlagMigrationContract(true)
+	product = canonicalOptional.Products["chat"]
 	tool = product.Tools["chat.edit_message"]
 	canonical = tool.Parameters["conversation-id"]
-	canonical.Required = true
-	canonical.CLIRequired = true
+	canonical.Required = false
+	canonical.CLIRequired = false
 	tool.Parameters["conversation-id"] = canonical
 	product.Tools["chat.edit_message"] = tool
-	promotedCanonical.Products["chat"] = product
+	canonicalOptional.Products["chat"] = product
 	normalized, err = normalizeSchemaFlagMigrations(
-		canonicalOnlyBaseline,
-		promotedCanonical,
-		[]interfacesnapshot.FlagMigration{canonicalOnlyMigration},
+		canonicalOptional,
+		schemaFlagMigrationContract(true),
+		[]interfacesnapshot.FlagMigration{canonicalOnly},
 	)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if failures := strings.Join(checkCompatibility(normalized, promotedCanonical), "\n"); !strings.Contains(failures, "newly required") || !strings.Contains(failures, "newly cli_required") {
+	if failures := strings.Join(checkCompatibility(normalized, schemaFlagMigrationContract(true)), "\n"); !strings.Contains(failures, "newly required") || !strings.Contains(failures, "newly cli_required") {
 		t.Fatalf("canonical-only required promotion was hidden: %s", failures)
 	}

@@ -1429,19 +1392,12 @@ func TestCrossPlatformCoverageSchemaFlagMigrationAdapterBranches(t *testing.T) {
 	}

 	old := parameterSchema{Required: true, CLIRequired: true}
-	if err := validateRenamedSchemaParameter(schemaFlagMigrationAuthorizations()[0], old, parameterSchema{CLIRequired: true}); err == nil || !strings.Contains(err.Error(), "changed requiredness") {
+	if err := validateRenamedSchemaParameter(schemaFlagMigrationAuthorizations()[0], old, parameterSchema{CLIRequired: true}); err == nil || !strings.Contains(err.Error(), "became optional") {
 		t.Fatalf("direct required decline error = %v", err)
 	}
-	if err := validateRenamedSchemaParameter(schemaFlagMigrationAuthorizations()[0], old, parameterSchema{Required: true}); err == nil || !strings.Contains(err.Error(), "changed cli_required") {
+	if err := validateRenamedSchemaParameter(schemaFlagMigrationAuthorizations()[0], old, parameterSchema{Required: true}); err == nil || !strings.Contains(err.Error(), "stopped being cli_required") {
 		t.Fatalf("direct cli_required decline error = %v", err)
 	}
-	optional := parameterSchema{}
-	if err := validateRenamedSchemaParameter(schemaFlagMigrationAuthorizations()[0], optional, parameterSchema{Required: true}); err == nil || !strings.Contains(err.Error(), "changed requiredness") {
-		t.Fatalf("direct required promotion error = %v", err)
-	}
-	if err := validateRenamedSchemaParameter(schemaFlagMigrationAuthorizations()[0], optional, parameterSchema{CLIRequired: true}); err == nil || !strings.Contains(err.Error(), "changed cli_required") {
-		t.Fatalf("direct cli_required promotion error = %v", err)
-	}
 }

 func TestCrossPlatformCoverageSchemaFlagMigrationRejectsPartialAndUnrelatedChanges(t *testing.T) {
@@ -1515,8 +1471,9 @@ func TestCrossPlatformCoverageSchemaFlagMigrationRejectsPartialAndUnrelatedChang
 		t.Fatalf("constraint rewrite without Schema parameter evidence was hidden: %s", failures)
 	}

-	// A baseline that already contains only the canonical parameter is not
-	// evidence that a stray legacy name in constraints belongs to the migration.
+	// A baseline that already contains only the canonical parameter may receive
+	// a required promotion, but that is not evidence that a stray legacy name in
+	// constraints belongs to the migration.
 	canonicalOnly := schemaFlagMigrationContract(true)
 	product = canonicalOnly.Products["chat"]
 	tool = product.Tools["chat.edit_message"]
@@ -1792,10 +1749,13 @@ func schemaFlagMigrationContract(after bool) schemaContract {
 		InterfaceType: "string",
 	}
 	parameters := map[string]parameterSchema{
-		"unrelated": {Type: `"string"`, Property: "unrelated"},
+		"conversation-id": conversation,
+		"unrelated":       {Type: `"string"`, Property: "unrelated"},
 	}
-	constraints := `{"require_one_of":[["group","id"]]}`
+	constraints := `{"require_one_of":[["conversation-id","group","id"]]}`
 	if after {
+		conversation.Required = true
+		conversation.CLIRequired = true
 		parameters["conversation-id"] = conversation
 		parameters["message-id"] = legacyMessage
 		constraints = `{"require_one_of":[["conversation-id"]]}`
@@ -1828,6 +1788,7 @@ func schemaFlagMigrationAuthorizations() []interfacesnapshot.FlagMigration {
 		Scope:   "local",
 	}
 	conversationAfter := conversationBefore
+	conversationAfter.Required = true
 	messageBefore := interfacesnapshot.FlagMigrationState{
 		Present:  true,
 		Type:     "string",
@@ -1847,7 +1808,7 @@ func schemaFlagMigrationAuthorizations() []interfacesnapshot.FlagMigration {
 			},
 			Canonical: interfacesnapshot.FlagMigrationSide{
 				Name:   "conversation-id",
-				Before: interfacesnapshot.FlagMigrationState{},
+				Before: conversationBefore,
 				After:  conversationAfter,
 			},
 		},
@@ -1862,7 +1823,7 @@ func schemaFlagMigrationAuthorizations() []interfacesnapshot.FlagMigration {
 			},
 			Canonical: interfacesnapshot.FlagMigrationSide{
 				Name:   "conversation-id",
-				Before: interfacesnapshot.FlagMigrationState{},
+				Before: conversationBefore,
 				After:  conversationAfter,
 			},
 		},
@@ -54,7 +54,7 @@ while [ "$#" -gt 0 ]; do
 done

 TMP_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/dws-package-verify-XXXXXX")"
-HOME_SPECIFIC_AGENT_PARENTS="
+HOME_AGENT_PARENTS="
 .claude
 .cursor
 .qoder
@@ -72,7 +72,8 @@ HOME_SPECIFIC_AGENT_PARENTS="
 .openclaw
 .hermes
 "
-HOME_SPECIFIC_SKILL_BASES="
+HOME_SKILL_BASES="
+.agents/skills
 .claude/skills
 .cursor/skills
 .qoder/skills
@@ -101,55 +102,43 @@ cleanup() {
 }
 trap cleanup EXIT INT TERM

-seed_specific_agent_homes() {
+seed_agent_homes() {
  home_root="$1"
-  for parent in $HOME_SPECIFIC_AGENT_PARENTS; do
+  for parent in $HOME_AGENT_PARENTS; do
    mkdir -p "$home_root/$parent"
  done
 }

-verify_skill_base() {
-  home_root="$1"
-  base="$2"
-  need_file "$home_root/$base/dingtalk-shared/SKILL.md"
-  need_file "$home_root/$base/dingtalk-misc/SKILL.md"
-  [ ! -e "$home_root/$base/dws" ] || err "unexpected mono Skill layout found in $home_root/$base/dws"
-}
-
 verify_skill_targets() {
  home_root="$1"
-  found_specific=0
-  for base in $HOME_SPECIFIC_SKILL_BASES; do
-    parent="${base%/skills}"
-    if [ -d "$home_root/$parent" ]; then
-      verify_skill_base "$home_root" "$base"
-      found_specific=1
-    fi
-  done
-
-  if [ "$found_specific" -eq 0 ]; then
-    verify_skill_base "$home_root" ".agents/skills"
-    return
-  fi
-
-  for name in dingtalk-shared dingtalk-misc dws; do
-    [ ! -e "$home_root/.agents/skills/$name" ] || \
-      err "unexpected generic Skill copy found in $home_root/.agents/skills/$name"
+  for base in $HOME_SKILL_BASES; do
+    need_file "$home_root/$base/dingtalk-shared/SKILL.md"
+    need_file "$home_root/$base/dingtalk-misc/SKILL.md"
+    [ ! -e "$home_root/$base/dws" ] || err "unexpected mono Skill layout found in $home_root/$base/dws"
  done
 }

-verify_npm_install() {
-  tarball_path="$1"
-  scenario="$2"
-  npm_home="$TMP_ROOT/npm-home-$scenario"
-  npm_prefix="$TMP_ROOT/npm-prefix-$scenario"
-  npm_cache="$TMP_ROOT/npm-cache-$scenario"
+verify_npm() {
+  need_cmd npm
+  need_cmd node
+  need_cmd tar
+  need_cmd unzip
+  need_file "$NPM_STAGE_DIR/package.json"
+
+  npm_home="$TMP_ROOT/npm-home"
+  npm_prefix="$TMP_ROOT/npm-prefix"
+  npm_cache="$TMP_ROOT/npm-cache"
  mkdir -p "$npm_home" "$npm_prefix" "$npm_cache"
-  if [ "$scenario" = "specific-agent-roots" ]; then
-    seed_specific_agent_homes "$npm_home"
-  fi
+  seed_agent_homes "$npm_home"
+
+  say "==> verifying npm package install"
+  tarball_name="$(
+    cd "$NPM_STAGE_DIR"
+    HOME="$npm_home" npm_config_cache="$npm_cache" npm pack --silent
+  )"
+  tarball_path="$NPM_STAGE_DIR/$tarball_name"
+  need_file "$tarball_path"

-  say "==> verifying npm package install ($scenario)"
  HOME="$npm_home" npm_config_cache="$npm_cache" npm_config_prefix="$npm_prefix" \
    npm install -g "$tarball_path" >/dev/null

@@ -169,24 +158,6 @@ verify_npm_install() {

  HOME="$npm_home" npm_config_cache="$npm_cache" npm_config_prefix="$npm_prefix" \
    npm uninstall -g dingtalk-workspace-cli >/dev/null
-}
-
-verify_npm() {
-  need_cmd npm
-  need_cmd node
-  need_cmd tar
-  need_cmd unzip
-  need_file "$NPM_STAGE_DIR/package.json"
-
-  tarball_name="$(
-    cd "$NPM_STAGE_DIR"
-    HOME="$TMP_ROOT/npm-pack-home" npm_config_cache="$TMP_ROOT/npm-pack-cache" npm pack --silent
-  )"
-  tarball_path="$NPM_STAGE_DIR/$tarball_name"
-  need_file "$tarball_path"
-
-  verify_npm_install "$tarball_path" "specific-agent-roots"
-  verify_npm_install "$tarball_path" "generic-fallback"

  rm -f "$tarball_path"
 }
@@ -565,7 +565,6 @@ Flags:
 **重要：该接口会真实发送消息到目标会话，不可用于测试或试探性调用。调用前必须确认消息内容和接收对象无误。**

 --group 指定群聊 openConversationId 发群消息；--user 指定用户 userId 发单聊；--open-dingtalk-id 指定用户 openDingTalkId 发单聊。三者只能选其一，不能同时指定。纯文本/Markdown 单聊传 --user 时直接走 userId 发送能力，不需要先手动查询 openDingTalkId。推荐使用 --text flag 传递消息内容（也支持位置参数）。可选 --title 作为消息标题。
-图文混排 Markdown 中，公网图片 URL 需要写成 `![图片标题](https://example.com/image.png)` 才会以内联图片展示；省略开头的 `!` 时会按链接/URL 展示，不会渲染为图片。
 若用户只提供了数字群号而非 openConversationId，需先调用 `chat group get-by-group-id` 将群号转为 openConversationId，再传入 --group。
 --群聊时可选 --at-all @所有人，或 --at-open-dingtalk-ids 指定成员（仅群聊时生效）。
 --本地图片、文件、音频或视频统一用 --msg-type file --file-path；图片会作为可下载的文件附件发送。--msg-type image --media-id 仅用于上游已经提供有效 mediaId 的场景。
@@ -586,8 +585,6 @@ Example:
  dws chat message send --open-dingtalk-id <openDingTalkId> --text "请查收"
  dws chat message send --group <openconversation_id> "hello"
  dws chat message send --group <openconversation_id> --title "周报提醒" --text "请大家本周五前提交周报"
-  # 图文混排 Markdown：公网图片 URL 需要写成 ![图片标题](URL) 才会以内联图片展示
-  dws chat message send --group <openconversation_id> --text $'这是图文说明\n\n![这个是展示图片标题](https://down.dingtalk.com/media/lQLPM5jiBEiBNjswMLAKd_CTzm8eowpEWPT_7-cA_48_48.png)'
  # 幂等发送（24h 内相同 uuid 不重复投递）
  dws chat message send --group <openconversation_id> --text "hello" --uuid "unique-id-123"
  dws chat message send --group <openconversation_id> --at-all "<@all> 请大家注意"
@@ -627,7 +624,6 @@ Flags:
  - **换行符**：消息内容按 Markdown 渲染，换行有两层要求，缺一不可：
    1. 必须使用**真实换行符**（Unicode `U+000A`），而非字面量字符串 `\n`（反斜杠 + 字母 n）。程序或大模型构造参数时，须确保已正确反转义；否则全部内容会渲染在同一行
    2. Markdown 规范下**单个换行不产生换行效果**。需要换行时请使用：段落分隔（连续两个真实换行符 `\n\n`）、行尾两个空格 + 真实换行符（硬换行 `<br>`），或直接写 HTML 的 `<br>` 标签
-  - **图文混排**：公网图片 URL 需要写成 `![图片标题](https://example.com/image.png)` 才会以内联图片展示；如果省略开头的 `!`，例如 `[图片标题](https://example.com/image.png)`，将按链接/URL 展示，不会渲染为图片
  - 本地图片、文档、压缩包、音频和视频统一使用 `--msg-type file --file-path <本地路径>`；图片会成为可下载的 file 附件，不会内联渲染，也不会生成 mediaId
  - `--msg-type image --media-id` 仅接受上游已经提供的有效 mediaId；DWS CLI 不提供本地文件到 mediaId 的上传或转换能力
  - audio/video 仍是兼容的 file 语义别名，但本地文件的推荐路径保持为 `--msg-type file --file-path`
@@ -33,7 +33,6 @@
 - 发送位置消息前必须确认纬度、经度、地址名称；地图缩略图需先通过旧媒体上传链路拿到 mediaId。
 - 分享联系人名片前必须确认联系人 `openDingTalkId`，不要把 userId 直接当 `--contact-id`。
 - 消息内容按 Markdown 渲染，换行必须是真实换行符；需要换行效果时用空行、行尾两个空格或 `<br>`。
- 图文混排 Markdown 中，公网图片 URL 需要写成 `![图片标题](https://example.com/image.png)` 才会以内联图片展示；省略开头的 `!` 时会按链接/URL 展示，不会渲染为图片。
 - 建议发送时带 `--uuid`，失败重试复用同一个值。
 - Bot/Webhook 只支持文本/Markdown；Bot 多群使用 `+messages-send --groups/--groups-file` 的逐项
  ledger。不要把 user 文件/图片能力外推到 Bot。
@@ -55,7 +54,6 @@ dws chat message send --group <openConversationId> --text "hello"
 dws chat message send --user <userId> --text "请查收"
 dws chat message send --open-dingtalk-id <openDingTalkId> --text "请查收"
 dws chat message send --group <openConversationId> --title "周报提醒" --text "请大家本周五前提交周报" --uuid <uuid>
-dws chat message send --group <openConversationId> --text $'这是图文说明\n\n![这个是展示图片标题](https://down.dingtalk.com/media/lQLPM5jiBEiBNjswMLAKd_CTzm8eowpEWPT_7-cA_48_48.png)'

 # @ 群成员
 dws chat message send --group <openConversationId> --at-all "<@all> 请大家注意"
@@ -1,6 +1,6 @@
 ---
 name: dingtalk-doc
-description: 钉钉在线文字文档（adoc，「文档空间」里的在线文档）的查找、读取、创建、编辑、块、评论、附件、导入、导出(docx/markdown/pdf)、模板、版本、权限协作及 Markdown/JSONML 写入。文档空间与钉盘的文件管理走 dingtalk-drive（doc 同名原子命令已弃用），知识库空间与空间内节点走 dingtalk-wiki，原生 .md 文件读写走 dingtalk-misc。命令前缀：dws doc。
+description: 钉钉在线文字文档（adoc）的查找、读取、创建、编辑、块、评论、附件、导入导出、模板、版本和权限协作。普通文件走 dingtalk-drive，知识库空间走 dingtalk-wiki。命令前缀：dws doc。
 metadata:
  cli_version: ">=0.2.14"
  category: product
@@ -1,6 +1,6 @@
 ---
 name: dingtalk-drive
-description: 钉钉文件管理（存储层，覆盖钉盘与文档空间两个存储域）。Use when 用户说 钉盘/上传文件/下载文件/文件夹/查文件/找文件/全局搜索文件/复制/移动/重命名/删除/回收站/还原删除文件/权限管理/普通文件下载；也承接钉钉文档的这些管理动作（doc 侧同名原子命令已弃用）。文档正文编辑与导出 docx/markdown/pdf 走 dingtalk-doc，知识库空间与空间内节点组织走 dingtalk-wiki。命令前缀：dws drive。
+description: 钉钉文件管理（存储层）。Use when 用户说 钉盘/上传文件/下载文件/文件夹/查文件/找文件/全局搜索文件/复制/移动/重命名/删除/回收站/还原删除文件/权限管理/普通文件下载。任何文件类型都适用；文档内容编辑走 dingtalk-doc，知识库空间和空间内节点管理走 dingtalk-wiki。命令前缀：dws drive。
 metadata:
  cli_version: ">=0.2.14"
  category: product
@@ -1,6 +1,6 @@
 ---
 name: dingtalk-wiki
-description: 钉钉知识库与空间管理。Use when 用户说 知识库/wiki/创建知识库/搜索知识库空间/我的文档/团队空间/空间成员/在指定知识库内的节点创建/列出/搜索/复制/移动/删除/知识库动态。知识库空间与空间内节点管理走本 skill（节点操作需 workspace）；未指定空间的全局文件管理与搜索走 dingtalk-drive，空间内单文档内容读写先用本 skill 定位再切到 dingtalk-doc。命令前缀：dws wiki。
+description: 钉钉知识库与空间管理。Use when 用户说 知识库/wiki/创建知识库/搜索知识库空间/我的文档/团队空间/空间成员/空间内节点创建/列出/搜索/复制/移动/删除/知识库动态。知识库节点复制移动走本 skill，普通钉盘文件复制移动走 dingtalk-drive；空间内单文档内容读写先用本 skill 定位再切到 dingtalk-doc。命令前缀：dws wiki。
 metadata:
  cli_version: ">=0.2.14"
  category: product
@@ -1019,47 +1019,12 @@ func TestChangelogPRFastPathWorkflowContract(t *testing.T) {
 	}

 	admission := readWorkflow(".github/workflows/ci.yml")
-	policyStart := strings.Index(admission, "\n  policy:\n")
-	policyEnd := strings.Index(admission, "\n  interface-integrity:\n")
-	if policyStart < 0 || policyEnd <= policyStart {
-		t.Fatal("Code Admission workflow missing Policy job boundaries")
-	}
-	policyJob := admission[policyStart:policyEnd]
-	requirePolicyEnv := func(step, nextStep string) {
-		t.Helper()
-		start := strings.Index(policyJob, "      - name: "+step+"\n")
-		end := strings.Index(policyJob[start+1:], "      - name: "+nextStep+"\n")
-		if start < 0 || end < 0 {
-			t.Fatalf("Policy job missing %q step boundary", step)
-		}
-		block := policyJob[start : start+1+end]
-		if !strings.Contains(block, "RELEASE_SEAL_ONLY: ${{ needs.lint.outputs.release_seal_only }}") {
-			t.Errorf("Policy %q step must receive release-seal classification", step)
-		}
-	}
-	requirePolicyEnv("Validate changed CHANGELOG content", "Validate release fragment lifecycle")
-	requirePolicyEnv("Validate trusted main metadata-only push", "Record CHANGELOG-only fast path")
-	pushStart := strings.Index(admission, "} else if (context.eventName === 'push') {")
-	pushEnd := strings.Index(admission, "\n            core.setOutput('changelog_only'")
-	if pushStart < 0 || pushEnd <= pushStart {
-		t.Fatal("Code Admission workflow missing push classification boundaries")
-	}
-	pushClassification := admission[pushStart:pushEnd]
-	if strings.Contains(pushClassification, "const exactReleaseSealDiff = isExactReleaseSeal(files)") {
-		t.Error("push release-seal fast path must not trust an unguarded compare file list")
-	}
 	for _, want := range []string{
 		"name: CI",
 		"files.length === 1",
 		"files[0].filename === 'CHANGELOG.md'",
 		"files[0].status === 'modified'",
 		"!files[0].previous_filename",
-		"const isExactReleaseSeal",
-		"file.status !== 'renamed'",
-		"file.additions !== 0",
-		"file.deletions !== 0",
-		"releaseSealOnly = isExactReleaseSeal(files)",
-		"release_seal_only: ${{ steps.classify.outputs.release_seal_only }}",
 		"pre-classification",
 		"post-classification",
 		"before.changed_files !== files.length",
@@ -1083,8 +1048,7 @@ func TestChangelogPRFastPathWorkflowContract(t *testing.T) {
 		"mode=--fast-path",
 		`"$mode" "$PR_BASE_SHA" HEAD`,
 		`test "$(git rev-parse HEAD)" = "$PUSH_AFTER_SHA"`,
-		`"$mode" "$PUSH_BEFORE_SHA" "$PUSH_AFTER_SHA"`,
-		`./scripts/policy/check-release-fragments.sh \`,
+		`--fast-path "$PUSH_BEFORE_SHA" "$PUSH_AFTER_SHA"`,
 		"needs.lint.outputs.platform_sensitive == 'true'",
 		`COVERAGE_TARGET: "100"`,
 		`COVERAGE_ENFORCE_OVERALL: "false"`,
@@ -1096,9 +1060,7 @@ func TestChangelogPRFastPathWorkflowContract(t *testing.T) {
 		`package_output="$(./scripts/ci/test-packages.sh list`,
 		"docs_only: ${{ steps.classify.outputs.docs_only }}",
 		"full_suite: ${{ steps.classify.outputs.full_suite }}",
-		"const pushFilesComplete = files.length < 300",
-		"classifyFiles(pushFilesComplete)",
-		"pushFilesComplete && isExactReleaseSeal(files)",
+		"classifyFiles(files.length < 300)",
 		"platformSensitive =",
 		"files.some(isNativeGoChange)",
 		"paths.some(isEditionSensitive)",
@@ -70,12 +70,10 @@ func TestPackageManagerVersionVerificationReadsRawBinary(t *testing.T) {
 		t.Fatal("package-manager verifier still requires the version marker to occupy a strings(1) line")
 	}
 	for _, want := range []string{
-		"HOME_SPECIFIC_SKILL_BASES=",
+		"HOME_SKILL_BASES=",
 		`$base/dingtalk-shared/SKILL.md`,
 		`$base/dingtalk-misc/SKILL.md`,
 		"unexpected mono Skill layout",
-		`verify_npm_install "$tarball_path" "specific-agent-roots"`,
-		`verify_npm_install "$tarball_path" "generic-fallback"`,
 	} {
 		if !strings.Contains(script, want) {
 			t.Errorf("package-manager verifier is missing multi-layout contract %q", want)
@@ -86,60 +84,6 @@ func TestPackageManagerVersionVerificationReadsRawBinary(t *testing.T) {
 	}
 }

-func TestPackageManagerVerifierCoversSpecificAndFallbackSkillRoots(t *testing.T) {
-	t.Parallel()
-
-	postGoreleaserPath, err := filepath.Abs(filepath.Join("..", "..", "scripts", "release", "post-goreleaser.sh"))
-	if err != nil {
-		t.Fatalf("Abs(post-goreleaser.sh) error = %v", err)
-	}
-	verifierPath, err := filepath.Abs(filepath.Join("..", "..", "scripts", "release", "verify-package-managers.sh"))
-	if err != nil {
-		t.Fatalf("Abs(verify-package-managers.sh) error = %v", err)
-	}
-
-	distDir := filepath.Join(t.TempDir(), "dist")
-	targets := []string{
-		"dws-darwin-amd64.tar.gz",
-		"dws-darwin-arm64.tar.gz",
-		"dws-linux-amd64.tar.gz",
-		"dws-linux-arm64.tar.gz",
-	}
-	hostArchive := "dws-" + runtime.GOOS + "-" + runtime.GOARCH + ".tar.gz"
-	if runtime.GOOS == "windows" {
-		hostArchive = "dws-" + runtime.GOOS + "-" + runtime.GOARCH + ".zip"
-	}
-	foundHost := false
-	for _, target := range targets {
-		if target == hostArchive {
-			foundHost = true
-			break
-		}
-	}
-	if !foundHost {
-		targets = append(targets, hostArchive)
-	}
-	seedDistArtifacts(t, distDir, targets)
-
-	packageCmd := exec.Command("sh", postGoreleaserPath)
-	packageCmd.Env = postGoreleaserEnv(t, distDir, "v0.0.0-test", "https://downloads.example.com/dws/releases/v0.0.0-test")
-	if output, err := packageCmd.CombinedOutput(); err != nil {
-		t.Fatalf("post-goreleaser.sh error = %v\noutput:\n%s", err, output)
-	}
-
-	verifyCmd := exec.Command("sh", verifierPath, "--npm-only")
-	verifyCmd.Env = append(os.Environ(), "DWS_PACKAGE_DIST_DIR="+distDir)
-	output, err := verifyCmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("verify-package-managers.sh error = %v\noutput:\n%s", err, output)
-	}
-	for _, scenario := range []string{"specific-agent-roots", "generic-fallback"} {
-		if !strings.Contains(string(output), "verifying npm package install ("+scenario+")") {
-			t.Errorf("verifier output is missing %s scenario:\n%s", scenario, output)
-		}
-	}
-}
-
 func seedDistArchive(t *testing.T, path string) {
 	t.Helper()
 	file, err := os.Create(path)
Author	SHA1	Message	Date
Dennis	6ba5a0aece	docs(changelog): add IM pagination release note	2026-08-12 19:28:29 +08:00
Dennis	dc96ecc7a6	Merge remote-tracking branch 'origin/main' into codex/im-page-all	2026-08-12 19:17:29 +08:00
Dennis	4f77f4463d	fix(chat): bound automatic page delays	2026-08-12 16:43:55 +08:00
Dennis	60f591b447	Merge remote-tracking branch 'origin/main' into codex/im-page-all	2026-08-12 15:39:41 +08:00
Dennis	18511dad1d	fix(chat): preserve safe pagination continuations	2026-08-12 15:39:25 +08:00
Dennis	c9e5b68356	fix(chat): preserve max-results visibility	2026-08-12 14:59:18 +08:00
Dennis	30979a6cb1	feat(chat): unify shortcut auto-pagination controls	2026-08-12 14:46:34 +08:00