chore: add PPE headers and pin miaoda-cli alpha for testing

2026-08-03 08:32:46 +08:00 · 2026-07-13 17:00:39 +08:00
783 changed files with 6899 additions and 70015 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,5 +1,4 @@
 name: CI
-run-name: ${{ github.event_name == 'pull_request' && format('CI / {0}', github.event.pull_request.number) || '' }}

 on:
  push:
@@ -9,12 +8,6 @@ on:
    types: [opened, synchronize, reopened, edited]
  workflow_dispatch:

-# PR metadata edits can retrigger full CI for the same head. Keep only the
-# newest run for a pull request; push and manual runs use a unique run ID.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
 permissions:
  contents: read
  actions: read
@@ -54,34 +47,6 @@ jobs:
            exit 1
          fi

-  plugin-integration:
-    needs: fast-gate
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          persist-credentials: false
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-      # No fetch_meta: the git-archive clean tree must embed only the
-      # committed meta_data stub (reproduces the bare-module customer state).
-      - name: Run plugin-integration L4 tests
-        run: go test -count=1 -timeout=15m ./tests/plugin_e2e/...
-
-  sidecar-integration:
-    needs: fast-gate
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          persist-credentials: false
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-      - name: Run sidecar tag build + HMAC round-trip
-        run: make sidecar-test
-
  # ── Layer 2: Quality Gate ──────────────────────────────────────────
  unit-test:
    needs: fast-gate
@@ -211,11 +176,7 @@ jobs:
        run: python3 scripts/fetch_meta.py
      - name: Run tests with coverage
        run: |
-          # tests/ holds only L3/L4 suites (cli_e2e, plugin_e2e, sidecar_e2e) that
-          # have dedicated jobs; exclude the whole subtree so none of them runs a
-          # second time here — and, crucially, so an observe-only suite's failure
-          # can never block merges through coverage's spot in the results loop.
-          packages=$(go list ./... | grep -v '^github.com/larksuite/cli/tests/')
+          packages=$(go list ./... | grep -v '^github.com/larksuite/cli/tests/cli_e2e$' | grep -v '^github.com/larksuite/cli/tests/cli_e2e/')
          go test -race -coverprofile=coverage.txt -covermode=atomic $packages
      - name: Upload coverage to Codecov
        if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
@@ -302,11 +263,6 @@ jobs:
  e2e-dry-run:
    needs: [unit-test, lint, script-test, deterministic-gate]
    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    outputs:
-      mode: ${{ steps.e2e_domains.outputs.mode }}
-      reason: ${{ steps.e2e_domains.outputs.reason }}
-      live_packages: ${{ steps.e2e_domains.outputs.live_packages }}
    steps:
      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
        with:
@@ -320,23 +276,6 @@ jobs:
      - name: Resolve CLI E2E domains
        id: e2e_domains
        run: node scripts/e2e_domains.js
-      - name: Validate CLI E2E domain outputs
-        env:
-          E2E_MODE: ${{ steps.e2e_domains.outputs.mode }}
-          E2E_LIVE_PACKAGES: ${{ steps.e2e_domains.outputs.live_packages }}
-        run: |
-          case "$E2E_MODE" in
-            skip)
-              [ -z "$E2E_LIVE_PACKAGES" ] || { echo "::error::Skip mode must not resolve live packages"; exit 1; }
-              ;;
-            full|subset)
-              [ -n "$E2E_LIVE_PACKAGES" ] || { echo "::error::No live packages resolved for mode $E2E_MODE"; exit 1; }
-              ;;
-            *)
-              echo "::error::Invalid CLI E2E mode: $E2E_MODE"
-              exit 1
-              ;;
-          esac
      - name: Build lark-cli
        if: ${{ steps.e2e_domains.outputs.mode != 'skip' }}
        run: make build
@@ -370,22 +309,16 @@ jobs:
          fi

  e2e-live:
-    needs: [unit-test, lint, script-test, deterministic-gate, e2e-dry-run]
-    if: ${{ always() && (github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork) && needs.unit-test.result == 'success' && needs.lint.result == 'success' && needs.script-test.result == 'success' && needs.deterministic-gate.result == 'success' && needs.e2e-dry-run.result == 'success' && (needs.e2e-dry-run.outputs.mode == 'full' || needs.e2e-dry-run.outputs.mode == 'subset') && needs.e2e-dry-run.outputs.live_packages != '' }}
+    needs: [unit-test, lint, script-test, deterministic-gate]
+    if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    # Live E2E uses one repository-wide execution slot.
-    concurrency:
-      group: lark-cli-e2e-live
-      cancel-in-progress: false
-      queue: max
    permissions:
-      actions: read
      contents: read
      checks: write
    env:
      TEST_BOT1_APP_ID: ${{ secrets.TEST_BOT1_APP_ID }}
-      LARKSUITE_CLI_BRAND: feishu
+      TEST_BOT1_APP_SECRET: ${{ secrets.TEST_BOT1_APP_SECRET }}
+      TEST_USER_ACCESS_TOKEN: ${{ secrets.TEST_USER_ACCESS_TOKEN }}
    steps:
      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
        with:
@@ -396,68 +329,31 @@ jobs:
      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
        with:
          python-version: '3.x'
+      - name: Resolve CLI E2E domains
+        id: e2e_domains
+        run: node scripts/e2e_domains.js
      - name: Build lark-cli
-        id: build_cli
+        if: ${{ steps.e2e_domains.outputs.mode != 'skip' }}
        run: make build
-      - name: Prepare shared live E2E tenant token
-        id: live_e2e_tat
-        env:
-          LARKSUITE_CLI_APP_ID: ${{ secrets.TEST_BOT1_APP_ID }}
-          TEST_BOT1_APP_SECRET: ${{ secrets.TEST_BOT1_APP_SECRET }}
-        run: node scripts/fetch_e2e_tat.js
-      - name: Run CLI E2E tests
-        # Keep an active Go test alive so t.Cleanup can finish. A queued stale
-        # run is rejected below before it can start live E2E.
-        if: ${{ always() && steps.build_cli.outcome == 'success' && steps.live_e2e_tat.outcome == 'success' }}
-        shell: bash
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPOSITORY: ${{ github.repository }}
-          EVENT_NAME: ${{ github.event_name }}
-          RUN_ID: ${{ github.run_id }}
-          RUN_NUMBER: ${{ github.run_number }}
-          RUN_GENERATION: ${{ github.event_name == 'pull_request' && format('CI / {0}', github.event.pull_request.number) || '' }}
-          LARK_CLI_BIN: ${{ github.workspace }}/lark-cli
-          E2E_MODE: ${{ needs.e2e-dry-run.outputs.mode }}
-          E2E_REASON: ${{ needs.e2e-dry-run.outputs.reason }}
-          E2E_LIVE_PACKAGES: ${{ needs.e2e-dry-run.outputs.live_packages }}
-          E2E_TENANT_AUTH_FILE: ${{ steps.live_e2e_tat.outputs.path }}
-          TEST_USER_ACCESS_TOKEN: ${{ secrets.TEST_USER_ACCESS_TOKEN }}
+      - name: Configure bot credentials
+        if: ${{ steps.e2e_domains.outputs.mode != 'skip' }}
        run: |
-          if [ "$EVENT_NAME" = "pull_request" ]; then
-            workflow_id="$(gh api "repos/$REPOSITORY/actions/runs/$RUN_ID" --jq '.workflow_id')"
-            newer_runs="$(
-              gh api --paginate -X GET "repos/$REPOSITORY/actions/workflows/$workflow_id/runs" \
-                -f event=pull_request -f branch="$GITHUB_HEAD_REF" -f per_page=100 |
-                jq -r --arg repository "$REPOSITORY" --arg generation "$RUN_GENERATION" --argjson run_number "$RUN_NUMBER" \
-                  '.workflow_runs[] | select(.head_repository.full_name == $repository and .display_title == $generation and .run_number > $run_number) | .id'
-            )"
-            if [ -n "$newer_runs" ]; then
-              echo "::error::Superseded before live E2E started by newer workflow run(s): $newer_runs"
-              exit 1
-            fi
-          fi
-          if [ -z "${E2E_TENANT_AUTH_FILE:-}" ] || [ ! -f "$E2E_TENANT_AUTH_FILE" ]; then
-            echo "::error::Missing shared live E2E tenant token file"
+          if [ -z "$TEST_BOT1_APP_ID" ] || [ -z "$TEST_BOT1_APP_SECRET" ]; then
+            echo "::error::Missing required secrets: TEST_BOT1_APP_ID / TEST_BOT1_APP_SECRET"
            exit 1
          fi
-          export TEST_TENANT_ACCESS_TOKEN="$(cat "$E2E_TENANT_AUTH_FILE")"
-          rm -f "$E2E_TENANT_AUTH_FILE"
-          if ! LARKSUITE_CLI_APP_ID="$TEST_BOT1_APP_ID" \
-            LARKSUITE_CLI_TENANT_ACCESS_TOKEN="$TEST_TENANT_ACCESS_TOKEN" \
-            ./lark-cli whoami --as bot | node -e '
-            let input = "";
-            process.stdin.setEncoding("utf8");
-            process.stdin.on("data", (chunk) => { input += chunk; });
-            process.stdin.on("end", () => {
-              const result = JSON.parse(input);
-              if (result.identity !== "bot" || result.available !== true || result.tokenStatus !== "ready") process.exit(1);
-            });
-          '; then
-            echo "::error::Tenant credential preflight failed"
-            exit 1
+          printf '%s\n' "$TEST_BOT1_APP_SECRET" | ./lark-cli config init --app-id "$TEST_BOT1_APP_ID" --app-secret-stdin
+      - name: Run CLI E2E tests
+        env:
+          LARK_CLI_BIN: ${{ github.workspace }}/lark-cli
+          E2E_MODE: ${{ steps.e2e_domains.outputs.mode }}
+          E2E_REASON: ${{ steps.e2e_domains.outputs.reason }}
+          E2E_LIVE_PACKAGES: ${{ steps.e2e_domains.outputs.live_packages }}
+        run: |
+          if [ "$E2E_MODE" = "skip" ]; then
+            echo "No live CLI E2E needed: $E2E_REASON"
+            exit 0
          fi
-          echo "Tenant credential preflight succeeded"
          packages="$E2E_LIVE_PACKAGES"
          if [ -z "$packages" ]; then
            echo "::error::No live CLI E2E packages resolved for mode $E2E_MODE"
@@ -467,7 +363,7 @@ jobs:
          echo "Live CLI E2E packages: $packages"
          go run gotest.tools/gotestsum@v1.12.3 --rerun-fails=2 --rerun-fails-max-failures=20 --packages="$packages" --format testname --junitfile cli-e2e-report.xml -- -count=1 -v
      - name: Publish CLI E2E test report
-        if: ${{ !cancelled() }}
+        if: ${{ !cancelled() && steps.e2e_domains.outputs.mode != 'skip' }}
        uses: dorny/test-reporter@a43b3a5f7366b97d083190328d2c652e1a8b6aa2 # v3.0.0
        with:
          name: CLI E2E Tests
@@ -520,7 +416,7 @@ jobs:
  # ── Results Gate (single required check for branch protection) ─────
  results:
    if: ${{ always() }}
-    needs: [fast-gate, unit-test, lint, script-test, deterministic-gate, coverage, deadcode, e2e-dry-run, e2e-live, security, license-header, plugin-integration, sidecar-integration]
+    needs: [fast-gate, unit-test, lint, script-test, deterministic-gate, coverage, deadcode, e2e-dry-run, e2e-live, security, license-header]
    runs-on: ubuntu-latest
    steps:
      - name: Evaluate results
@@ -540,19 +436,10 @@ jobs:
          echo "| L3 | e2e-live | ${{ needs.e2e-live.result }} |" >> $GITHUB_STEP_SUMMARY
          echo "| L4 | security | ${{ needs.security.result }} |" >> $GITHUB_STEP_SUMMARY
          echo "| L4 | license-header | ${{ needs.license-header.result }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| L4 | plugin-integration (observe-only) | ${{ needs.plugin-integration.result }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| L4 | sidecar-integration (observe-only) | ${{ needs.sidecar-integration.result }} |" >> $GITHUB_STEP_SUMMARY

          # Any failure or cancellation in any job blocks the merge.
-          # Legitimately skipped jobs (deadcode on push, e2e-live when not
-          # needed or on a fork, license-header on push) are OK.
-          #
-          # plugin-integration and sidecar-integration are intentionally NOT
-          # in this loop yet: they run on every PR and their status is shown
-          # in the table above, but a failure is observe-only (non-blocking)
-          # during the initial soak. Graduation to required is tracked in
-          # https://github.com/larksuite/cli/issues/1894 (criteria: 4
-          # consecutive weeks with zero false positives).
+          # Legitimately skipped jobs (deadcode on push, e2e-live on fork,
+          # license-header on push) are OK.
          FAILED=0
          for result in \
            "${{ needs.fast-gate.result }}" \
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -9,40 +9,7 @@ permissions:
  contents: read

 jobs:
-  preflight:
-    runs-on: ubuntu-22.04
-    permissions:
-      contents: read
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
-        with:
-          node-version: '22.14.0'
-
-      - name: Validate tag and commit
-        env:
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          node scripts/release-preflight.js --tag "$TAG"
-          git fetch origin main
-          HEAD_SHA="$(git rev-parse --verify 'HEAD^{commit}')"
-          MAIN_SHA="$(git rev-parse --verify 'FETCH_HEAD^{commit}')"
-          TAG_SHA="$(git rev-parse --verify "refs/tags/${TAG}^{commit}")"
-          if [[ "$TAG_SHA" != "$HEAD_SHA" ]]; then
-            echo "Tag ${TAG} does not resolve to the checked-out HEAD commit." >&2
-            exit 1
-          fi
-          if ! git merge-base --is-ancestor "$HEAD_SHA" "$MAIN_SHA"; then
-            echo "Tag ${TAG} does not point to a commit contained in origin/main." >&2
-            exit 1
-          fi
-
-  build-release:
-    needs: preflight
+  goreleaser:
    runs-on: ubuntu-22.04
    permissions:
      contents: write
@@ -59,79 +26,35 @@ jobs:
        with:
          python-version: '3.x'

-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
-        with:
-          node-version: '22.14.0'
-          registry-url: 'https://registry.npmjs.org'
-          package-manager-cache: false
-
-      - name: Install pinned npm
-        run: npm install --global npm@11.16.0
-
      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@e435ccd777264be153ace6237001ef4d979d3a7a # v6
        with:
          version: '~> v2'
          args: release --clean
        env:
-          GITHUB_TOKEN: ${{ github.token }}
-
-      - name: Include release checksums
-        run: |
-          set -euo pipefail
-          test -s dist/checksums.txt
-          (cd dist && sha256sum --check checksums.txt)
-          cp dist/checksums.txt checksums.txt
-
-      - name: Collect release asset
-        run: |
-          set -euo pipefail
-          mkdir npm-publish-asset
-          cp dist/*.tar.gz dist/*.zip dist/checksums.txt npm-publish-asset/
-
-      - name: Upload release asset
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        with:
-          name: npm-publish-asset-${{ github.run_id }}
-          path: npm-publish-asset/
-          if-no-files-found: error
-          overwrite: true
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  publish-npm:
-    needs: build-release
+    needs: goreleaser
    runs-on: ubuntu-22.04
-    environment: npm-production
-    permissions:
-      contents: read
-      id-token: write
    steps:
      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4

-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
        with:
-          node-version: '22.14.0'
+          node-version: '20'
          registry-url: 'https://registry.npmjs.org'
-          package-manager-cache: false

-      - name: Install pinned npm
-        run: npm install --global npm@11.16.0
-
-      - name: Download release asset
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
-        with:
-          name: npm-publish-asset-${{ github.run_id }}
-          path: npm-publish-asset
-
-      - name: Verify npm publish asset
+      - name: Download checksums from release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          set -euo pipefail
-          (cd npm-publish-asset && sha256sum --check checksums.txt)
-          cp npm-publish-asset/checksums.txt checksums.txt
-          PACK_JSON="$(npm pack --ignore-scripts --json)"
-          PACK_FILE="$(node -e 'const p=JSON.parse(process.argv[1]); if(p.length!==1 || !p[0].filename) process.exit(1); process.stdout.write(p[0].filename)' "$PACK_JSON")"
-          test -s "$PACK_FILE"
-          tar -tzf "$PACK_FILE" | grep -qx 'package/checksums.txt'
-          rm "$PACK_FILE"
+          TAG="${GITHUB_REF_NAME}"
+          gh release download "${TAG}" --pattern checksums.txt --dir .
+          test -s checksums.txt || { echo "checksums.txt missing or empty for ${TAG}"; exit 1; }

      - name: Publish to npm
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
        run: npm publish --access public
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,10 +10,9 @@
 ## Build & Test

 ```bash
-make build             # Build (runs fetch_meta first)
-make unit-test         # Required before PR (runs with -race where supported, e.g. amd64/arm64)
-make live-skills-test  # Opt-in real Skills CLI tests; runs with isolated user directories
-make test              # Full: vet + unit + integration
+make build          # Build (runs fetch_meta first)
+make unit-test      # Required before PR (runs with -race where supported, e.g. amd64/arm64)
+make test           # Full: vet + unit + integration
 ```

 ## Notification Opt-Outs
@@ -106,20 +105,6 @@ Signatures that are easy to guess wrong:

 Program output (JSON envelopes) goes to stdout. Progress, warnings, hints go to stderr. Mixing them corrupts pipe chains.

-### Typed data over loose maps
-
-Parse `map[string]interface{}` into a typed struct at the boundary — one projection function per shape — and let everything downstream consume struct fields, not string keys. A typo'd map key compiles fine and fails at runtime, which an agent then debugs blind.
-
-Use distinct types when two values could be swapped silently: see `internal/meta.Token` — a bare string compiles on either side of a string/string signature, a distinct type does not.
-
-Legacy loose-map code exists in older paths. Match its call sites when touching it, but do not copy the pattern into new code.
-
-### Transcribe faithfully — no silent fallbacks
-
-When code echoes input onward (request previews, transformations, proxies), transcribe verbatim. A `default:` branch that coerces unrecognized input into a plausible value ("unknown HTTP verb → GET") makes the output lie, and an agent reasons from the lie.
-
-The same rule applies to flag combinations and internal wiring: if a requested option cannot be honored, return a typed validation error — never silently substitute another behavior and exit 0. Silent guesses (defaulting a missing identity, discarding writes on a nil writer) are bugs even when every current caller happens to avoid them.
-
 ### Use `vfs.*` instead of `os.*`

 All filesystem access goes through `internal/vfs`. This enables test mocking.
@@ -131,7 +116,6 @@ CLI arguments are untrusted (they come from AI agents). Call `validate.SafeInput
 ### Tests

 - Every behavior change needs a test alongside the change.
- A contract test must fail if the implementation is reverted. If you can undo the code change and the suite stays green, the contract is not pinned — assert the new field/behavior directly, not a happy-path substring.
 - `cmdutil.TestFactory(t, config)` for test factories.
 - `t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())` to isolate config state.

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,235 +2,6 @@

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

-## [v1.0.77] - 2026-07-24
-
-### Features
-
- introducing official card icon (#1973)
- **apps**: validate +file-list --page-size against server (0, 200] range (#2007)
- **apps**: support absolute and relative upload paths (#2005)
- **slides**: fill xml-schema-quick-ref gaps that forced XSD fallback (#2026)
- **slides**: add layout density lint for sparse/empty containers (#2022)
- add risk-control protection (#1910)
-
-### Bug Fixes
-
- **slides**: normalize presentation flag aliases (#2032)
- **base**: classify +form-submit as high-risk-write (#1969)
- **slides**: declare screenshot scope
- **slides**: support CSV multi-value for --slide-id in screenshot (#2047)
-
-### Documentation
-
- **skill**: clarify scope handling for query expansion (#2030)
- **base**: clarify complete and partial updates (#1993)
- **skills**: clarify callout child rules (#2048)
-
-### Misc
-
- fix/task id handling (#2023)
- fix/task search pagination (#2041)
-
-## [v1.0.75] - 2026-07-22
-
-### Features
-
- add okr single create shortcut & skill text opti (#1941)
- **calendar**: auto-add bot self as attendee and note user-only search (#1991)
-
-### Bug Fixes
-
- **base**: improve table shortcut behavior & guidance (#1803)
- issue#1935 & whiteboard shortcut reformat (#1980)
- remove legacy shortcut (#1997)
- **e2e**: inject shared credentials by identity (#1995)
-
-### Documentation
-
- **skill**: describe html5 block xml usage (#1380)
- clarify fetch metadata and user cites (#1981)
- add topic move collector workflow (#1473)
- update lark doc HTML size limit (#2001)
- **base**: align record write schema guidance (#2000)
-
-### Tests
-
- **e2e**: declare request identities explicitly (#2004)
-
-### Misc
-
- harden npm release publishing (#1918)
-
-## [v1.0.74] - 2026-07-21
-
-### Features
-
- **slides**: add history rollback shortcuts (#1714)
- **base**: support per-record batch updates (#1889)
-
-### Bug Fixes
-
- preserve slides schema issues
- allow jq examples in quality gate dry-runs
- **im**: warn when flag pagination is truncated (#1906)
- **slides**: warn on text shape overflow
- **slides**: exempt chart roundtrip attributes from lint
- **slides**: detect image text occlusion
- **slides**: clarify xml-text-overlap-lint error for positional argument (#1986)
-
-### Documentation
-
- clarify drive upload overwrite guidance (#1982)
-
-### Tests
-
- isolate unit tests from user state (#1883)
-
-### Refactoring
-
- converge success output through a single Emitter that owns the write (#1899)
-
-## [v1.0.73] - 2026-07-20
-
-### Features
-
- **apps**: design_html support, creative-design skill, unified TOS publish (#1901)
-
-### Bug Fixes
-
- **slides**: detect visual elements outside canvas
- reduce public content credential fixture false positives
- standardize CLI shortcut text in English (#1942)
-
-### Documentation
-
- **base**: reduce filter and update retry loops (#1879)
- **vc**: default transcript routing to smart notes over minutes (#1961)
- clarify local trigger automation (#1958)
-
-### Tests
-
- synchronize temporary Git maintenance (#1946)
-
-### Misc
-
- **slides**: update lark-slides skill to 0715 snapshot (#1933)
- [codex] support bot menu events (#1765)
-
-## [v1.0.72] - 2026-07-17
-
-### Features
-
- **slides**: lint table out of canvas
- **slides**: report resolved table size mismatches
- **approval**: support approval event consumption (#1924)
-
-### Bug Fixes
-
- **vc**: don't fail +detail for in-progress meetings (#1930)
- stabilize drive delete E2E terminal-state checks (#1939)
-
-### Documentation
-
- **slides**: document table dimensions
- document base field default values (#1500)
- **sheets**: use English placeholder in table-get guidance (#1936)
-
-### Tests
-
- stabilize live e2e auth retries (#1904)
- use tri-state wiki node identity in delete verification (#1931)
- fix drive cover download retries (#1934)
-
-## [v1.0.71] - 2026-07-16
-
-### Features
-
- add wiki move-to-drive shortcut (#1869)
- **apps**: add role management shortcuts (#1881)
- **drive**: add secure label support and clarify comment location API (#1913)
-
-### Bug Fixes
-
- **base**: improve dashboard shortcut guidance (#1787)
-
-### Documentation
-
- **apps**: add platform SQL authoring guide to the db-execute skill (#1912)
-
-### Misc
-
- add L4 plugin-integration and sidecar-integration CI jobs (#1840)
- **drive**: optimize drive +delete workflow (#1909)
-
-## [v1.0.70] - 2026-07-15
-
-### Features
-
- add minutes permission application shortcut (#1876)
- **drive**: support apps in list comments (#1877)
- slide style
- edit ppt template
- **slides**: add sxsd validation to slides lint
- **slides**: validate iconpark icon types in slides lint
- **slides**: lint before create
- **apps**: add automation trigger commands for Miaoda (#1886)
-
-### Bug Fixes
-
- unify dry-run output contract (#1870)
- **skills**: align skill guidance with the typed error contract (#1786)
- **slides**: limit slides screenshot page requests
- **slides**: detect lark slides text overflow overlap
- **vc**: align meeting query scopes by identity (#1850)
-
-### Documentation
-
- clarify task search relevance filters (#1884)
- surface minutes permission application in skill description (#1890)
- clarify okr progress children (#1861)
- **slides**: prefer slides xml-get shortcut
- **calendar**: document setting meeting owner via full API (#1903)
-
-### Refactoring
-
- **slides**: streamline create workflow and validate SML namespaces
-
-### Misc
-
- **slides**: address PR review feedback
-
-## [v1.0.69] - 2026-07-13
-
-### Features
-
- support docs fetch selection anchors (#1815)
- **apps**: support modern_html app type with TOS publish path and app type querying
- **im**: show bot sender display names when reading messages (#1829)
- add drive list comments shortcut (#1845)
- support wiki sources in drive export (#1802)
- add application domain with slash command management shortcuts (#1806)
- validate IM idempotency key length (#1797)
- surface reply context and mentions in im.message.receive_v1 (#1798)
-
-### Bug Fixes
-
- route brand-sensitive endpoints through the resolver (#1836)
-
-### Documentation
-
- document OKR block XML guidance (#1648)
- refine doubao whiteboard workflow routing (#1841)
- clarify Mindnote token handling (#1827)
-
-### Tests
-
- isolate semantic waiver fixtures from wall clock
-
-### Misc
-
- Merge lark sheets development branch (#1833)
-
 ## [v1.0.68] - 2026-07-09

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

-[v1.0.77]: https://github.com/larksuite/cli/releases/tag/v1.0.77
-[v1.0.75]: https://github.com/larksuite/cli/releases/tag/v1.0.75
-[v1.0.74]: https://github.com/larksuite/cli/releases/tag/v1.0.74
-[v1.0.73]: https://github.com/larksuite/cli/releases/tag/v1.0.73
-[v1.0.72]: https://github.com/larksuite/cli/releases/tag/v1.0.72
-[v1.0.71]: https://github.com/larksuite/cli/releases/tag/v1.0.71
-[v1.0.70]: https://github.com/larksuite/cli/releases/tag/v1.0.70
-[v1.0.69]: https://github.com/larksuite/cli/releases/tag/v1.0.69
 [v1.0.68]: https://github.com/larksuite/cli/releases/tag/v1.0.68
 [v1.0.67]: https://github.com/larksuite/cli/releases/tag/v1.0.67
 [v1.0.66]: https://github.com/larksuite/cli/releases/tag/v1.0.66
--- a/20
+++ b/20
@@ -23,7 +23,7 @@ PREFIX   ?= /usr/local
 TEST_GOARCH := $(or $(GOARCH),$(shell go env GOARCH))
 RACE_FLAG := $(if $(filter riscv64,$(TEST_GOARCH)),,-race)

-.PHONY: all build vet fmt-check script-test test unit-test live-skills-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test
+.PHONY: all build vet fmt-check script-test test unit-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks

 all: test

@@ -51,27 +51,19 @@ script-test:
 	bash scripts/resolve-changed-from.test.sh
 	bash scripts/ci-workflow.test.sh
 	bash scripts/semantic-review-workflow.test.sh
-	$(NODE) --test scripts/e2e_domains.test.js scripts/fetch_e2e_tat.test.js scripts/install.test.js scripts/release-preflight.test.js scripts/semantic-review-verify-artifact.test.js scripts/pr-quality-summary.test.js scripts/semantic-review-publish.test.js scripts/ci-quality-summary-publish.test.js
+	$(NODE) --test scripts/e2e_domains.test.js scripts/semantic-review-verify-artifact.test.js scripts/pr-quality-summary.test.js scripts/semantic-review-publish.test.js scripts/ci-quality-summary-publish.test.js

 # ./extension/... keeps the public plugin SDK in the default test matrix.
 unit-test: fetch_meta
 	go test $(RACE_FLAG) -gcflags="all=-N -l" -count=1 \
 		./cmd/... ./internal/... ./shortcuts/... ./extension/...

-live-skills-test: fetch_meta
-	LARKSUITE_CLI_RUN_LIVE_SKILLS_TESTS=1 \
-	go test -v -count=1 ./cmd/update \
-		-run '^TestUpdateCommand_(RealSkillsSyncRewritesState|SkillsSyncColdStart)$$'
-
 # examples-build keeps the shipped plugin-SDK examples compilable. If this
 # breaks, the plugin author guide's "go build ./..." path is broken.
 examples-build:
 	go build ./extension/platform/examples/audit-observer
 	go build ./extension/platform/examples/readonly-policy

-# ./tests/... includes tests/plugin_e2e, which builds ~20 customer-fork
-# binaries (~1 min warm; a cold module cache also downloads via GOPROXY).
-# Deliberate: local `make test` exercises the L4 plugin contract by default.
 integration-test: build
 	go test -v -count=1 ./tests/...

@@ -113,14 +105,6 @@ uninstall:
 clean:
 	rm -f $(BINARY)

-# sidecar-test compiles and runs the authsidecar* build-tagged code that the
-# default CI matrix never sees (they carry //go:build tags).
-sidecar-test:
-	go build -tags authsidecar -o /dev/null .
-	go test $(RACE_FLAG) -count=1 -tags authsidecar ./extension/credential/sidecar/ ./extension/transport/sidecar/ ./internal/cmdutil/
-	go test $(RACE_FLAG) -count=1 -tags authsidecar_demo ./sidecar/server-demo/
-	go test $(RACE_FLAG) -count=1 -tags authsidecar ./tests/sidecar_e2e/
-
 # Run secret-leak checks locally before pushing.
 # Step 1: check-doc-tokens catches realistic-looking example tokens in reference
 #         docs and asks you to use _EXAMPLE_TOKEN placeholders instead.
--- a/README.md
+++ b/README.md
@@ -285,29 +285,6 @@ To reduce these risks, the tool enables default security protections at multiple

 We recommend using the Lark/Feishu bot integrated with this tool as a private conversational assistant. Do not add it to group chats or allow other users to interact with it, to avoid abuse of permissions or data leakage.

-To reduce the security risks associated with access token theft, the CLI sends a minimal set of risk-control signals with OpenAPI requests made to exact official Feishu/Lark HTTPS domains. These signals are used to help identify anomalous API activity. This protection is enabled by default. The information sent is limited to:
-
- Operating system type: macOS, Windows, or Linux
- Device hardware model: for example, Mac17,9
-
-To disable this protection for the current workspace, run:
-
-```bash
-lark-cli config risk-control off
-```
-
-To enable this protection for the current workspace, run:
-
-```bash
-lark-cli config risk-control on
-```
-
-To restore the default policy for the current workspace, run:
-
-```bash
-lark-cli config risk-control default
-```
-
 Please fully understand all usage risks. By using this tool, you are deemed to voluntarily assume all related responsibilities.

 ## Star History
--- a/README.zh.md
+++ b/README.zh.md
@@ -286,29 +286,6 @@ lark-cli schema im.messages.delete

 我们建议您将对接本工具的飞书机器人作为私人对话助手使用，请勿将其拉入群聊或允许其他用户与其交互，以避免权限被滥用或数据泄露。

-为降低访问令牌被盗用后的安全风险，CLI 在向飞书/Lark 官方 HTTPS 精确域名发起 OpenAPI 请求时，会随请求发送一组最小化的风控信号，用于辅助识别异常调用行为。该保护默认开启，发送的信息仅包括：
-
- 操作系统类型：macOS、Windows 或 Linux
- 设备的硬件产品型号：例如 Mac17,9
-
-如需让当前 workspace 退出该保护，可执行以下命令：
-
-```bash
-lark-cli config risk-control off
-```
-
-如需开启当前 workspace 的保护，可执行以下命令：
-
-```bash
-lark-cli config risk-control on
-```
-
-恢复当前 workspace 默认策略可执行：
-
-```bash
-lark-cli config risk-control default
-```
-
 请您充分知悉全部使用风险，使用本工具即视为您自愿承担相关所有责任。

 ## Star History
--- a/cmd/api/api.go
+++ b/cmd/api/api.go
@@ -130,13 +130,6 @@ func buildAPIRequest(opts *APIOptions) (client.RawApiRequest, *cmdutil.FileUploa
 	stdin := opts.Factory.IOStreams.In
 	fileIO := opts.Factory.ResolveFileIO(opts.Ctx)

-	if opts.Method == "" {
-		return client.RawApiRequest{}, nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"HTTP method must not be empty").
-			WithHint("pass the verb as the first argument, e.g. lark-cli api GET /open-apis/...").
-			WithParam("<method>")
-	}
-
 	// Validate --file mutual exclusions first.
 	if err := cmdutil.ValidateFileFlag(opts.File, opts.Params, opts.Data, opts.Output, opts.PageAll, opts.Method); err != nil {
 		return client.RawApiRequest{}, nil, err
@@ -250,9 +243,9 @@ func apiRun(opts *APIOptions) error {

 	if opts.DryRun {
 		if fileMeta != nil {
-			return cmdutil.PrintDryRunWithFile(request, config, dryRunOutputOptions(f, opts), *fileMeta)
+			return cmdutil.PrintDryRunWithFile(f.IOStreams.Out, request, config, opts.Format, fileMeta.FieldName, fileMeta.FilePath, fileMeta.FormFields)
 		}
-		return apiDryRun(f, request, config, opts)
+		return apiDryRun(f, request, config, opts.Format)
 	}
 	// Identity info is now included in the JSON envelope; skip stderr printing.
 	// cmdutil.PrintIdentity(f.IOStreams.ErrOut, opts.As, config, f.IdentityAutoDetected)
@@ -304,19 +297,8 @@ func apiRun(opts *APIOptions) error {
 	return nil
 }

-func apiDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, opts *APIOptions) error {
-	return cmdutil.PrintDryRun(request, config, dryRunOutputOptions(f, opts))
-}
-
-func dryRunOutputOptions(f *cmdutil.Factory, opts *APIOptions) cmdutil.DryRunOutputOptions {
-	return cmdutil.DryRunOutputOptions{
-		Format:      opts.Format,
-		JqExpr:      opts.JqExpr,
-		CommandPath: opts.Cmd.CommandPath(),
-		Identity:    opts.As,
-		Out:         f.IOStreams.Out,
-		ErrOut:      f.IOStreams.ErrOut,
-	}
+func apiDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, format string) error {
+	return cmdutil.PrintDryRun(f.IOStreams.Out, request, config, format)
 }

 func apiPaginate(ctx context.Context, ac *client.APIClient, request client.RawApiRequest, format output.Format, jqExpr string, out, errOut io.Writer, commandPath string, pagOpts client.PaginationOptions) error {
@@ -344,18 +326,20 @@ func apiPaginate(ctx context.Context, ac *client.APIClient, request client.RawAp

 	switch format {
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
-		emitter := output.NewEmitter(output.EmitterConfig{
-			Out:            out,
-			ErrOut:         errOut,
-			CommandPath:    commandPath,
-			Identity:       string(pagOpts.Identity),
-			NoticeProvider: output.GetNotice,
-		})
+		pf := output.NewPaginatedFormatter(out, format)
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {
 			// Streaming formats intentionally emit each page after that page has
 			// passed safety scanning. A later page may still fail, so callers
 			// must use the exit code to distinguish complete vs partial output.
-			return emitter.StreamPage(items, output.StreamOptions{Format: format.String()})
+			scanResult := output.ScanForSafety(commandPath, items, errOut)
+			if scanResult.Blocked {
+				return scanResult.BlockErr
+			}
+			if scanResult.Alert != nil {
+				output.WriteAlertWarning(errOut, scanResult.Alert)
+			}
+			pf.FormatPage(items)
+			return nil
 		}, pagOpts)
 		if err != nil {
 			return errs.MarkRaw(err)
--- a/cmd/api/api_paginate_test.go
+++ b/cmd/api/api_paginate_test.go
@@ -1,396 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package api
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/client"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-)
-
-type apiFailOnWriteWriter struct {
-	buf    bytes.Buffer
-	writes int
-	failAt int
-	err    error
-}
-
-func (w *apiFailOnWriteWriter) Write(p []byte) (int, error) {
-	w.writes++
-	if w.writes == w.failAt {
-		return 0, w.err
-	}
-	return w.buf.Write(p)
-}
-
-func newAPIPaginateTestHarness(t *testing.T) (*client.APIClient, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
-	t.Helper()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	previousNotice := output.PendingNotice
-	output.PendingNotice = nil
-	t.Cleanup(func() { output.PendingNotice = previousNotice })
-
-	config := &core.CliConfig{
-		AppID:     "test-app",
-		AppSecret: "test-secret",
-		Brand:     core.BrandFeishu,
-	}
-	f, out, errOut, reg := cmdutil.TestFactory(t, config)
-	ac, err := f.NewAPIClientWithConfig(config)
-	if err != nil {
-		t.Fatalf("NewAPIClientWithConfig() error = %v", err)
-	}
-	ac.ErrOut = io.Discard
-	return ac, out, errOut, reg
-}
-
-func apiPaginateRequest() client.RawApiRequest {
-	return client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test/v1/items",
-		As:     core.AsBot,
-	}
-}
-
-func assertAPIPaginateJSONBytes(t *testing.T, got []byte, want interface{}) {
-	t.Helper()
-	wantBytes, err := json.MarshalIndent(want, "", "  ")
-	if err != nil {
-		t.Fatalf("marshal expected JSON: %v", err)
-	}
-	wantBytes = append(wantBytes, '\n')
-	if !bytes.Equal(got, wantBytes) {
-		t.Fatalf("stdout bytes mismatch\ngot:\n%s\nwant:\n%s", got, wantBytes)
-	}
-}
-
-func TestAPIPaginate_DefaultAggregatesAllPages(t *testing.T) {
-	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-	calls := 0
-	wantTokens := []string{"", "next-1", "next-2"}
-	for i, wantToken := range wantTokens {
-		page := i + 1
-		hasMore := page < len(wantTokens)
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": string(rune('0' + page))}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = wantTokens[page]
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(req *http.Request) {
-				calls++
-				if got := req.URL.Query().Get("page_token"); got != wantToken {
-					t.Errorf("request %d page_token = %q, want %q", page, got, wantToken)
-				}
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{
-			PageLimit: 10,
-			PageDelay: -1,
-		})
-
-	if err != nil {
-		t.Fatalf("apiPaginate() error = %v, want nil", err)
-	}
-	if calls != 3 {
-		t.Fatalf("pagination requests = %d, want 3", calls)
-	}
-	assertAPIPaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"items": []interface{}{
-				map[string]interface{}{"id": "1"},
-				map[string]interface{}{"id": "2"},
-				map[string]interface{}{"id": "3"},
-			},
-			"has_more": false,
-		},
-	})
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}
-
-func TestAPIPaginate_StreamingFormatsEmitExactMultiPageBytes(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		want   string
-	}{
-		{
-			name:   "ndjson",
-			format: output.FormatNDJSON,
-			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Carol\",\"page_only\":\"ignored\"}\n",
-		},
-		{
-			name:   "table",
-			format: output.FormatTable,
-			want:   "id  name \n──  ─────\n1   Alice\n2   Carol\n",
-		},
-		{
-			name:   "csv",
-			format: output.FormatCSV,
-			want:   "id,name\n1,Alice\n2,Carol\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "1", "name": "Alice"},
-						},
-						"has_more":   true,
-						"page_token": "next-1",
-					},
-				},
-			})
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "2", "name": "Carol", "page_only": "ignored"},
-						},
-						"has_more": false,
-					},
-				},
-			})
-
-			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-				tt.format, "", out, errOut, "lark-cli api GET", client.PaginationOptions{
-					PageLimit: 10,
-					PageDelay: -1,
-				})
-
-			if err != nil {
-				t.Fatalf("apiPaginate() error = %v, want nil", err)
-			}
-			if got := out.String(); got != tt.want {
-				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestAPIPaginate_StreamingWriteFailureStopsFurtherPages(t *testing.T) {
-	ac, _, errOut, reg := newAPIPaginateTestHarness(t)
-	sentinel := errors.New("page write failed")
-	out := &apiFailOnWriteWriter{failAt: 2, err: sentinel}
-	calls := 0
-	for page := 1; page <= 2; page++ {
-		hasMore := true
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": page}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = fmt.Sprintf("next-%d", page)
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(*http.Request) {
-				calls++
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli api GET",
-		client.PaginationOptions{PageLimit: 10, PageDelay: -1})
-
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("apiPaginate() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("apiPaginate() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	if calls != 2 {
-		t.Fatalf("pagination requests = %d, want 2", calls)
-	}
-	if got, want := out.buf.String(), "{\"id\":1}\n"; got != want {
-		t.Fatalf("stdout bytes = %q, want %q", got, want)
-	}
-}
-
-func TestAPIPaginate_StreamingFormatFallsBackToJSONWithoutList(t *testing.T) {
-	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"name":    "Test User",
-				"user_id": "u123",
-			},
-		},
-	})
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-	if err != nil {
-		t.Fatalf("apiPaginate() error = %v, want nil", err)
-	}
-	assertAPIPaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"name":    "Test User",
-			"user_id": "u123",
-		},
-	})
-	wantWarning := "warning: this API does not return a list, format \"ndjson\" is not supported, falling back to json\n"
-	if got := errOut.String(); got != wantWarning {
-		t.Fatalf("stderr bytes = %q, want %q", got, wantWarning)
-	}
-}
-
-func TestAPIPaginate_BusinessErrorsWriteRawAndAreMarkedRaw(t *testing.T) {
-	businessResponse := map[string]interface{}{
-		"code": 123456,
-		"msg":  "fixture business error",
-		"data": map[string]interface{}{"detail": "business failed"},
-	}
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "default_json", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL:  "/open-apis/test/v1/items",
-				Body: businessResponse,
-			})
-
-			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-			if err == nil {
-				t.Fatal("apiPaginate() error = nil, want business error")
-			}
-			if !errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
-			}
-			assertAPIPaginateJSONBytes(t, out.Bytes(), businessResponse)
-			if bytes.Contains(out.Bytes(), []byte(`"ok": true`)) {
-				t.Fatalf("business-error stdout contains a success envelope:\n%s", out.Bytes())
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestAPIPaginate_TransportErrorsAreMarkedRaw(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq_paginate_all", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "stream_pages", format: output.FormatNDJSON},
-		{name: "default_paginate_all", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, _ := newAPIPaginateTestHarness(t)
-
-			err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-			if err == nil {
-				t.Fatal("apiPaginate() error = nil, want transport error")
-			}
-			if !errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
-			}
-			if got := out.String(); got != "" {
-				t.Fatalf("stdout bytes = %q, want empty", got)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestAPIPaginate_StreamBusinessErrorIsMarkedRaw(t *testing.T) {
-	ac, out, errOut, reg := newAPIPaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 123456,
-			"msg":  "fixture business error",
-			"data": map[string]interface{}{},
-		},
-	})
-
-	err := apiPaginate(context.Background(), ac, apiPaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli api GET", client.PaginationOptions{PageDelay: -1})
-
-	if err == nil {
-		t.Fatal("apiPaginate() error = nil, want business error")
-	}
-	if !errs.IsRaw(err) {
-		t.Fatalf("errs.IsRaw(error) = false, want true; error = %T: %v", err, err)
-	}
-	if got := out.String(); got != "" {
-		t.Fatalf("stdout bytes = %q, want empty", got)
-	}
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}
--- a/cmd/api/api_test.go
+++ b/cmd/api/api_test.go
@@ -69,7 +69,7 @@ func TestApiCmd_FlagParsing(t *testing.T) {
 }

 func TestApiCmd_DryRun(t *testing.T) {
-	f, stdout, stderr, _ := cmdutil.TestFactory(t, &core.CliConfig{
+	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})

@@ -79,42 +79,12 @@ func TestApiCmd_DryRun(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
+	output := stdout.String()
+	if !strings.Contains(output, "Dry Run") {
+		t.Error("expected dry run output")
 	}
-	if got["ok"] != true || got["identity"] != "bot" || got["dry_run"] != true {
-		t.Fatalf("unexpected dry-run envelope: %#v", got)
-	}
-	data, ok := got["data"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("data = %#v, want object", got["data"])
-	}
-	api, ok := data["api"].([]interface{})
-	if !ok || len(api) != 1 {
-		t.Fatalf("api = %#v, want one call", data["api"])
-	}
-	call, ok := api[0].(map[string]interface{})
-	if !ok || call["url"] != "/open-apis/test" {
-		t.Fatalf("api[0] = %#v", api[0])
-	}
-	if strings.Contains(stdout.String(), "=== Dry Run ===") {
-		t.Fatalf("stdout should not contain dry-run banner: %s", stdout.String())
-	}
-}
-
-func TestApiCmd_DryRunWithJq(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	cmd := newTestApiCmd(f, nil)
-	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--dry-run", "--jq", ".data.api[0].url"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got := strings.TrimSpace(stdout.String()); got != "/open-apis/test" {
-		t.Fatalf("jq output = %q, want /open-apis/test", got)
+	if !strings.Contains(output, "/open-apis/test") {
+		t.Error("expected path in dry run output")
 	}
 }

@@ -182,22 +152,6 @@ func TestApiCmd_MissingArgs(t *testing.T) {
 	}
 }

-func TestApiCmd_EmptyMethodRejected(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	cmd := newTestApiCmd(f, nil)
-	cmd.SetArgs([]string{"", "/open-apis/test", "--as", "bot", "--dry-run"})
-	err := cmd.Execute()
-	if err == nil {
-		t.Fatal("expected validation error for empty HTTP method")
-	}
-	if !strings.Contains(err.Error(), "method") {
-		t.Fatalf("error should name the method argument, got: %v", err)
-	}
-}
-
 func TestApiCmd_InvalidParamsJSON(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
@@ -352,9 +306,6 @@ func TestApiCmd_OutputAndPageAllConflict(t *testing.T) {
 }

 func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
-	dir := t.TempDir()
-	cmdutil.TestChdir(t, dir)
-
 	f, stdout, stderr, reg := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app-bin", AppSecret: "test-secret-bin", Brand: core.BrandFeishu,
 	})
@@ -374,33 +325,8 @@ func TestApiCmd_BinaryResponse_AutoSave(t *testing.T) {
 	if !strings.Contains(stderr.String(), "binary response detected") {
 		t.Error("expected binary response hint in stderr")
 	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("stdout is not JSON: %v\nstdout:\n%s", err, stdout.String())
-	}
-	savedPath, _ := got["saved_path"].(string)
-	if savedPath == "" {
-		t.Fatalf("saved_path missing from output: %#v", got)
-	}
-	// The file must land inside the temporary cwd — this pins the isolation
-	// contract: rolling back TestChdir would leave download.bin in the repo.
-	wantDir, err := filepath.EvalSymlinks(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	gotDir, err := filepath.EvalSymlinks(filepath.Dir(savedPath))
-	if err != nil {
-		t.Fatalf("saved_path %q dir not resolvable: %v", savedPath, err)
-	}
-	if gotDir != wantDir {
-		t.Errorf("saved_path %q is outside temp cwd %q", savedPath, wantDir)
-	}
-	content, err := os.ReadFile(savedPath)
-	if err != nil {
-		t.Fatalf("read saved file: %v", err)
-	}
-	if string(content) != "fake-binary-content" {
-		t.Errorf("saved file content = %q, want %q", content, "fake-binary-content")
+	if !strings.Contains(stdout.String(), "saved_path") {
+		t.Error("expected saved_path in output")
 	}
 }

@@ -1074,23 +1000,11 @@ func TestApiCmd_DryRunWithFile(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	out := stdout.String()
-	var env map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, out)
+	if !strings.Contains(out, "image") {
+		t.Errorf("expected dry-run output to mention file field, got: %s", out)
 	}
-	if env["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", env["dry_run"])
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	body := call["body"].(map[string]interface{})
-	file := body["file"].(map[string]interface{})
-	if file["field"] != "image" || file["path"] != tmpFile {
-		t.Fatalf("unexpected file dry-run body: %#v", body)
-	}
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("stdout should not contain dry-run banner: %s", out)
+	if !strings.Contains(out, "Dry Run") {
+		t.Errorf("expected dry-run header, got: %s", out)
 	}
 }

--- a/cmd/auth/auth_test.go
+++ b/cmd/auth/auth_test.go
@@ -386,7 +386,7 @@ func TestAuthScopesRun_UsesTenantAccessTokenFromCredentialProvider(t *testing.T)
 		AppID: "test-app", AppSecret: "", Brand: core.BrandFeishu,
 	})
 	tokenResolver := &authScopesTokenResolver{}
-	f.Credential = newAuthTestCredentialProvider("test-app", tokenResolver)
+	f.Credential = credential.NewCredentialProvider(nil, nil, tokenResolver, nil)

 	appInfoStub := &httpmock.Stub{
 		Method: http.MethodGet,
@@ -442,7 +442,7 @@ func TestAuthScopesRun_LarkPermissionError_TypedAsPermissionError(t *testing.T)
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 	tokenResolver := &authScopesTokenResolver{}
-	f.Credential = newAuthTestCredentialProvider("test-app", tokenResolver)
+	f.Credential = credential.NewCredentialProvider(nil, nil, tokenResolver, nil)

 	reg.Register(&httpmock.Stub{
 		Method: http.MethodGet,
@@ -485,18 +485,6 @@ type authScopesTokenResolver struct {
 	requests []credential.TokenSpec
 }

-type authTestAccountResolver struct {
-	appID string
-}
-
-func (r authTestAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return &credential.Account{AppID: r.appID, Brand: core.BrandFeishu}, nil
-}
-
-func newAuthTestCredentialProvider(appID string, tokenResolver credential.DefaultTokenResolver) *credential.CredentialProvider {
-	return credential.NewCredentialProvider(nil, authTestAccountResolver{appID: appID}, tokenResolver, nil)
-}
-
 func (r *authScopesTokenResolver) ResolveToken(ctx context.Context, req credential.TokenSpec) (*credential.TokenResult, error) {
 	r.requests = append(r.requests, req)
 	switch req.Type {
--- a/cmd/auth/login_messages.go
+++ b/cmd/auth/login_messages.go
@@ -128,5 +128,5 @@ func getLoginMsg(lang i18n.Lang) *loginMsg {
 // (not backed by from_meta service specs). Descriptions are now centralized in
 // service_descriptions.json.
 func getShortcutOnlyDomainNames() []string {
-	return []string{"application", "base", "contact", "docs", "markdown", "apps", "note"}
+	return []string{"base", "contact", "docs", "markdown", "apps", "note"}
 }
--- a/cmd/auth/status.go
+++ b/cmd/auth/status.go
@@ -27,9 +27,6 @@ func NewCmdAuthStatus(f *cmdutil.Factory, runF func(*StatusOptions) error) *cobr
 	cmd := &cobra.Command{
 		Use:   "status",
 		Short: "View current auth status",
-		Long: `Show OAuth user login, token validity, and granted scopes.
-For token-validity checks, run lark-cli auth status --json --verify.
-This is not profile/app selection diagnostics; use lark-cli whoami for the effective app/profile identity used by an invocation.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if runF != nil {
 				return runF(opts)
--- a/cmd/auth/status_test.go
+++ b/cmd/auth/status_test.go
@@ -4,35 +4,15 @@
 package auth

 import (
-	"context"
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"

-	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/internal/httpmock"
 )

-func TestAuthStatusHelpDistinguishesFromWhoami(t *testing.T) {
-	cmd := NewCmdAuthStatus(nil, nil)
-	for _, want := range []string{
-		"OAuth user login",
-		"auth status --json --verify",
-		"not profile/app selection diagnostics",
-		"lark-cli whoami",
-	} {
-		if !strings.Contains(cmd.Long, want) {
-			t.Errorf("auth status --help Long missing %q; got:\n%s", want, cmd.Long)
-		}
-	}
-}
-
 func TestAuthStatusRun_SplitsBotAndUserIdentity(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "secret", Brand: core.BrandFeishu,
@@ -99,51 +79,6 @@ func TestAuthStatusRun_VerifyReportsBotIdentity(t *testing.T) {
 	}
 }

-type fixedStatusAccountResolver struct {
-	account *credential.Account
-}
-
-func (r *fixedStatusAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return r.account, nil
-}
-
-func TestAuthStatus_AllowsMatchingAppIDOnlySelectedProfile(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv(envvars.CliAppID, "cli_a")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv(envvars.CliUserAccessToken, "")
-	t.Setenv(envvars.CliTenantAccessToken, "")
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name:      "tenant_a",
-			AppId:     "cli_a",
-			AppSecret: core.PlainSecret("test-secret"),
-			Brand:     core.BrandFeishu,
-		}},
-	}); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	config := &core.CliConfig{ProfileName: "tenant_a", AppID: "cli_a", AppSecret: "test-secret", Brand: core.BrandFeishu}
-	f, stdout, _, _ := cmdutil.TestFactory(t, config)
-	f.Credential = credential.NewCredentialProvider(
-		[]extcred.Provider{&envprovider.Provider{}},
-		&fixedStatusAccountResolver{account: credential.AccountFromCliConfig(config)},
-		nil,
-		nil,
-	).WithProfileFromFlag("tenant_a")
-
-	cmd := NewCmdAuth(f)
-	cmd.SetArgs([]string{"status", "--json"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("auth status should use the selected built-in profile: %v", err)
-	}
-	if strings.Contains(stdout.String(), "credentials are provided externally") {
-		t.Fatalf("matching APP_ID-only env was misclassified as external:\n%s", stdout.String())
-	}
-}
-
 type statusOutput struct {
 	Identity   string `json:"identity"`
 	Verified   *bool  `json:"verified"`
--- a/cmd/auth/testmain_test.go
+++ b/cmd/auth/testmain_test.go
@@ -1,46 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package auth
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/larksuite/cli/internal/registry/registrytest"
-)
-
-// TestMain isolates auth command tests from the host machine: config, logs
-// and the registry cache are redirected to a temp dir, then the registry is
-// seeded from the tracked fixture and initialized eagerly. Domain-completion
-// tests read the registry, so without seeding a clean checkout would either
-// fail or trigger a remote metadata fetch.
-//
-// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
-// m.Run before exiting.
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-cmd-auth-test-*")
-	if err != nil {
-		println("cmd/auth test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		println("cmd/auth test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_LOG_DIR", filepath.Join(root, "logs")); err != nil {
-		println("cmd/auth test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := registrytest.Seed(root); err != nil {
-		println("cmd/auth test setup: registrytest.Seed failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/cmd/bootstrap.go
+++ b/cmd/bootstrap.go
@@ -6,10 +6,8 @@ package cmd
 import (
 	"errors"
 	"io"
-	"os"

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

@@ -28,13 +26,5 @@ func BootstrapInvocationContext(args []string) (cmdutil.InvocationContext, error
 	if err := fs.Parse(args); err != nil && !errors.Is(err, pflag.ErrHelp) {
 		return cmdutil.InvocationContext{}, err
 	}
-
-	profileFromFlag := fs.Changed("profile")
-	if !profileFromFlag {
-		globals.Profile = os.Getenv(envvars.CliProfile)
-	}
-	return cmdutil.InvocationContext{
-		Profile:         globals.Profile,
-		ProfileFromFlag: profileFromFlag,
-	}, nil
+	return cmdutil.InvocationContext{Profile: globals.Profile}, nil
 }
--- a/cmd/bootstrap_test.go
+++ b/cmd/bootstrap_test.go
@@ -3,11 +3,7 @@

 package cmd

-import (
-	"testing"
-
-	"github.com/larksuite/cli/internal/envvars"
-)
+import "testing"

 func TestBootstrapInvocationContext_ProfileFlag(t *testing.T) {
 	inv, err := BootstrapInvocationContext([]string{"--profile", "target", "auth", "status"})
@@ -74,58 +70,3 @@ func TestBootstrapInvocationContext_HelpWithProfile(t *testing.T) {
 		t.Fatalf("profile = %q, want %q", inv.Profile, "target")
 	}
 }
-
-func TestBootstrapProfileEnvFallback(t *testing.T) {
-	t.Run("flag wins over env", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "tenant_env")
-		inv, err := BootstrapInvocationContext([]string{"--profile", "tenant_flag", "whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "tenant_flag" {
-			t.Errorf("got %q, want tenant_flag", inv.Profile)
-		}
-		if !inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = false, want true")
-		}
-	})
-	t.Run("explicit empty flag clears env selection", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "tenant_env")
-		inv, err := BootstrapInvocationContext([]string{"--profile=", "whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "" {
-			t.Errorf("got %q, want empty", inv.Profile)
-		}
-		if !inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = false, want true")
-		}
-	})
-	t.Run("env used when flag absent", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "tenant_env")
-		inv, err := BootstrapInvocationContext([]string{"whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "tenant_env" {
-			t.Errorf("got %q, want tenant_env", inv.Profile)
-		}
-		if inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = true, want false")
-		}
-	})
-	t.Run("empty when neither set", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "")
-		inv, err := BootstrapInvocationContext([]string{"whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "" {
-			t.Errorf("got %q, want empty", inv.Profile)
-		}
-		if inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = true, want false")
-		}
-	})
-}
--- a/cmd/config/config.go
+++ b/cmd/config/config.go
@@ -31,7 +31,6 @@ func NewCmdConfig(f *cmdutil.Factory) *cobra.Command {
 	cmd.AddCommand(NewCmdConfigShow(f, nil))
 	cmd.AddCommand(NewCmdConfigDefaultAs(f))
 	cmd.AddCommand(NewCmdConfigStrictMode(f))
-	cmd.AddCommand(NewCmdConfigRiskControl(f))
 	cmd.AddCommand(NewCmdConfigPolicy(f))
 	cmd.AddCommand(NewCmdConfigPlugins(f))
 	cmd.AddCommand(NewCmdConfigKeychainDowngrade(f))
--- a/cmd/config/config_test.go
+++ b/cmd/config/config_test.go
@@ -84,16 +84,6 @@ func TestConfigShowCmd_FlagParsing(t *testing.T) {
 	}
 }

-func TestConfigShowHelpClarifiesSavedConfig(t *testing.T) {
-	cmd := NewCmdConfigShow(nil, nil)
-	if !strings.Contains(cmd.Short, "saved config") {
-		t.Errorf("config show short = %q, want saved config", cmd.Short)
-	}
-	if !strings.Contains(cmd.Long, "lark-cli whoami --json") {
-		t.Errorf("config show help missing whoami route")
-	}
-}
-
 func TestConfigShowRun_NotConfiguredReturnsStructuredError(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())

@@ -116,77 +106,6 @@ func TestConfigShowRun_NotConfiguredReturnsStructuredError(t *testing.T) {
 	}
 }

-// config show promises "saved config, not current usage" (help + skill
-// routing): the session profile (--profile / LARKSUITE_CLI_PROFILE) must not
-// change what it shows.
-func TestConfigShowRun_IgnoresSessionProfile(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{
-			{Name: "tenant_a", AppId: "cli_a", AppSecret: core.PlainSecret("your-secret-a"), Brand: core.BrandFeishu},
-			{Name: "tenant_b", AppId: "cli_b", AppSecret: core.PlainSecret("your-secret-b"), Brand: core.BrandFeishu},
-		},
-	}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-	f.Invocation.Profile = "tenant_b" // session selection must not leak in
-
-	if err := configShowRun(&ConfigShowOptions{Factory: f}); err != nil {
-		t.Fatalf("configShowRun: %v", err)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, `"cli_a"`) || !strings.Contains(out, `"tenant_a"`) {
-		t.Fatalf("output = %s, want the saved default tenant_a/cli_a", out)
-	}
-	if strings.Contains(out, `"cli_b"`) {
-		t.Fatalf("output = %s, session profile tenant_b must not change saved-config view", out)
-	}
-}
-
-// engagedEnvStub simulates a fully engaged external credential provider.
-type engagedEnvStub struct{}
-
-func (engagedEnvStub) Name() string  { return "env" }
-func (engagedEnvStub) Priority() int { return 10 }
-func (engagedEnvStub) ResolveAccount(context.Context) (*extcred.Account, error) {
-	return &extcred.Account{AppID: "cli_env", AppSecret: "your-password"}, nil // managed takeover
-}
-func (engagedEnvStub) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
-	return nil, nil
-}
-
-// config show inspects the SAVED config only, so the parent command's
-// external-credential gate must not apply: even with a fully engaged direct
-// env credential, `config show` still answers from the saved config.
-func TestConfigShow_BypassesExternalCredentialGate(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name: "tenant_a", AppId: "cli_a", AppSecret: core.PlainSecret("your-secret-a"), Brand: core.BrandFeishu,
-		}},
-	}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-	f.Credential = credential.NewCredentialProvider([]extcred.Provider{engagedEnvStub{}}, nil, nil, nil)
-
-	cmd := NewCmdConfig(f)
-	cmd.SetArgs([]string{"show"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("config show must bypass the external-credential gate: %v", err)
-	}
-	if out := stdout.String(); !strings.Contains(out, `"cli_a"`) {
-		t.Fatalf("output = %s, want the saved config shown", out)
-	}
-}
-
 func TestConfigShowRun_NoActiveProfileReturnsStructuredError(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	multi := &core.MultiAppConfig{
@@ -562,8 +481,7 @@ func TestConfigBlockedByExternalProvider(t *testing.T) {
 	}{
 		{"init", []string{"init", "--app-id", "x", "--app-secret-stdin"}},
 		{"remove", []string{"remove"}},
-		// "show" is deliberately absent: it inspects the SAVED config only
-		// and bypasses this gate (TestConfigShow_BypassesExternalCredentialGate).
+		{"show", []string{"show"}},
 		{"default-as", []string{"default-as", "user"}},
 		{"strict-mode", []string{"strict-mode", "off"}},
 	}
--- a/cmd/config/risk_control.go
+++ b/cmd/config/risk_control.go
@@ -1,80 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-// NewCmdConfigRiskControl creates the workspace risk-control policy command.
-func NewCmdConfigRiskControl(f *cmdutil.Factory) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "risk-control [on|off|default]",
-		Short: "Manage workspace account-protection policy",
-		Long: `View or set the account-protection risk-control policy for this workspace.
-
-Account protection is on by default. Use off to opt this workspace out, on to
-opt it back in explicitly, or default to remove the explicit preference.`,
-		Args: cobra.MaximumNArgs(1),
-		// This is persistent workspace policy, not credential management.
-		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
-			cmd.SilenceUsage = true
-			return nil
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			config, err := core.LoadOrNotConfigured()
-			if err != nil {
-				return err
-			}
-			if len(args) == 0 {
-				printRiskControl(f, config)
-				return nil
-			}
-
-			switch args[0] {
-			case "on":
-				enabled := true
-				config.RiskControl = &enabled
-			case "off":
-				enabled := false
-				config.RiskControl = &enabled
-			case "default":
-				config.RiskControl = nil
-			default:
-				return errs.NewValidationError(errs.SubtypeInvalidArgument,
-					"invalid risk-control value %q, valid values: on | off | default", args[0])
-			}
-
-			if err := core.SaveMultiAppConfig(config); err != nil {
-				return errs.NewInternalError(errs.SubtypeStorage,
-					"failed to save risk-control policy: %v", err).WithCause(err)
-			}
-			fmt.Fprintf(f.IOStreams.ErrOut, "Risk control set to %s (workspace)\n", args[0])
-			return nil
-		},
-	}
-	cmdutil.SetRisk(cmd, cmdutil.RiskWrite)
-	return cmd
-}
-
-func printRiskControl(f *cmdutil.Factory, config *core.MultiAppConfig) {
-	source := "default"
-	if config.RiskControl != nil {
-		source = "workspace"
-	}
-	fmt.Fprintf(f.IOStreams.Out, "risk-control: %s (source: %s)\n", riskControlState(config.RiskControlEnabled()), source)
-}
-
-func riskControlState(enabled bool) string {
-	if enabled {
-		return "on"
-	}
-	return "off"
-}
--- a/cmd/config/risk_control_test.go
+++ b/cmd/config/risk_control_test.go
@@ -1,130 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-func TestRiskControlWorkspacePolicy(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(config); err != nil {
-		t.Fatal(err)
-	}
-
-	f, stdout, stderr, _ := cmdutil.TestFactory(t, nil)
-	cmd := NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"off"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set off: %v", err)
-	}
-	loaded, err := core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || *loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit false", loaded.RiskControl)
-	}
-	if !strings.Contains(stderr.String(), "set to off") {
-		t.Fatalf("stderr = %q", stderr.String())
-	}
-
-	stdout.Reset()
-	cmd = NewCmdConfigRiskControl(f)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("show: %v", err)
-	}
-	if got := stdout.String(); got != "risk-control: off (source: workspace)\n" {
-		t.Fatalf("stdout = %q", got)
-	}
-
-	cmd = NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"on"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set on: %v", err)
-	}
-	loaded, err = core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || !*loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit true", loaded.RiskControl)
-	}
-
-	cmd = NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"default"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("reset default: %v", err)
-	}
-	loaded, err = core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl != nil {
-		t.Fatalf("RiskControl = %v, want nil", loaded.RiskControl)
-	}
-
-	stdout.Reset()
-	cmd = NewCmdConfigRiskControl(f)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("show default: %v", err)
-	}
-	if got := stdout.String(); got != "risk-control: on (source: default)\n" {
-		t.Fatalf("stdout = %q", got)
-	}
-}
-
-func TestRiskControlWorkspacePolicyRejectsInvalidValue(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}); err != nil {
-		t.Fatal(err)
-	}
-
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	cmd := NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"invalid"})
-	err := cmd.Execute()
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("error = %T %v, want *errs.ValidationError", err, err)
-	}
-	if validationErr.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype = %q, want %q", validationErr.Subtype, errs.SubtypeInvalidArgument)
-	}
-}
-
-func TestRiskControlWorkspacePolicyAllowedWithExternalCredentials(t *testing.T) {
-	f := newConfigFactoryWithExternalProvider(t)
-	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(config); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := NewCmdConfig(f)
-	cmd.SetArgs([]string{"risk-control", "off"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set off with external credentials: %v", err)
-	}
-
-	loaded, err := core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || *loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit false", loaded.RiskControl)
-	}
-}
--- a/cmd/config/show.go
+++ b/cmd/config/show.go
@@ -27,16 +27,7 @@ func NewCmdConfigShow(f *cmdutil.Factory, runF func(*ConfigShowOptions) error) *

 	cmd := &cobra.Command{
 		Use:   "show",
-		Short: "Show saved config",
-		Long:  "Shows saved config. To see the app/profile lark-cli is using now, run `lark-cli whoami --json`.",
-		// Override parent's RequireBuiltinCredentialProvider check: this
-		// command reads the SAVED config only (its own help promises "saved
-		// config, not current usage"), so the currently effective credential
-		// source — external or otherwise — must not gate it.
-		PersistentPreRunE: func(c *cobra.Command, _ []string) error {
-			c.SilenceUsage = true
-			return nil
-		},
+		Short: "Show current configuration",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if runF != nil {
 				return runF(opts)
@@ -62,10 +53,7 @@ func configShowRun(opts *ConfigShowOptions) error {
 	if config == nil || len(config.Apps) == 0 {
 		return core.NotConfiguredError()
 	}
-	// Saved config only: the session profile (--profile / LARKSUITE_CLI_PROFILE)
-	// must not change what this command shows — the help and skill routing
-	// promise "saved config, not current usage" (use whoami for that).
-	app := config.CurrentAppConfig("")
+	app := config.CurrentAppConfig(f.Invocation.Profile)
 	if app == nil {
 		return errs.NewConfigError(errs.SubtypeNotConfigured, "no active profile").WithHint("run: lark-cli profile list")
 	}
--- a/cmd/event/consume_test.go
+++ b/cmd/event/consume_test.go
@@ -110,20 +110,8 @@ func (failingTokenResolver) ResolveToken(_ context.Context, _ credential.TokenSp
 	return nil, errors.New("backend unavailable")
 }

-type eventTestAccountResolver struct {
-	appID string
-}
-
-func (r eventTestAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return &credential.Account{AppID: r.appID}, nil
-}
-
-func newEventTestCredentialProvider(appID string, tokenResolver credential.DefaultTokenResolver) *credential.CredentialProvider {
-	return credential.NewCredentialProvider(nil, eventTestAccountResolver{appID: appID}, tokenResolver, nil)
-}
-
 func factoryWithResolver(r credential.DefaultTokenResolver) *cmdutil.Factory {
-	return &cmdutil.Factory{Credential: newEventTestCredentialProvider("cli_x", r)}
+	return &cmdutil.Factory{Credential: credential.NewCredentialProvider(nil, nil, r, nil)}
 }

 func TestResolveTenantToken_EmptyTokenResult(t *testing.T) {
--- a/cmd/event/list_test.go
+++ b/cmd/event/list_test.go
@@ -17,8 +17,6 @@ import (

 func TestEventLookup_VCMeetingLifecycleKeys(t *testing.T) {
 	for _, key := range []string{
-		"approval.instance.status_changed_v4",
-		"approval.task.status_changed_v4",
 		"vc.meeting.participant_meeting_started_v1",
 		"vc.meeting.participant_meeting_joined_v1",
 	} {
@@ -38,8 +36,6 @@ func TestRunList_TextOutput(t *testing.T) {
 	out := stdout.String()
 	for _, want := range []string{
 		"KEY", "AUTH", "PARAMS", "DESCRIPTION",
-		"approval.instance.status_changed_v4",
-		"approval.task.status_changed_v4",
 		"im.message.receive_v1",
 		"im.message.message_read_v1",
 		"task.task.update_user_access_v2",
@@ -94,8 +90,6 @@ func TestRunList_JSONOutput(t *testing.T) {
 		t.Fatal("event list JSON missing task.task.update_user_access_v2")
 	}
 	for _, want := range []string{
-		"approval.instance.status_changed_v4",
-		"approval.task.status_changed_v4",
 		"vc.meeting.participant_meeting_started_v1",
 		"vc.meeting.participant_meeting_joined_v1",
 	} {
--- a/cmd/event/runtime_test.go
+++ b/cmd/event/runtime_test.go
@@ -44,7 +44,7 @@ func newTestConsumeRuntime(rt http.RoundTripper) *consumeRuntime {
 		client: &client.APIClient{
 			SDK:        sdk,
 			ErrOut:     io.Discard,
-			Credential: newEventTestCredentialProvider("test-app", &staticTokenResolver{}),
+			Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
 			Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 		},
 		accessIdentity: core.AsBot,
--- a/cmd/event/schema_test.go
+++ b/cmd/event/schema_test.go
@@ -19,29 +19,6 @@ import (
 	_ "github.com/larksuite/cli/events"
 )

-type approvalSchemaJSONPayload struct {
-	JQRootPath           string                           `json:"jq_root_path"`
-	AuthTypes            []string                         `json:"auth_types"`
-	Scopes               []string                         `json:"scopes"`
-	Params               []approvalSchemaJSONParam        `json:"params"`
-	ResolvedOutputSchema approvalSchemaJSONResolvedSchema `json:"resolved_output_schema"`
-}
-
-type approvalSchemaJSONParam struct {
-	Name            string `json:"name"`
-	Type            string `json:"type"`
-	Required        bool   `json:"required"`
-	SubscriptionKey bool   `json:"subscription_key"`
-}
-
-type approvalSchemaJSONResolvedSchema struct {
-	Properties map[string]approvalSchemaJSONProperty `json:"properties"`
-}
-
-type approvalSchemaJSONProperty struct {
-	Format string `json:"format"`
-}
-
 func TestRunSchema_ProcessedKey_Text(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})

@@ -119,40 +96,6 @@ func TestRunSchema_JSONOutput(t *testing.T) {
 	}
 }

-func TestRunSchema_ReceiveMessageAgentFieldsJSON(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})
-
-	if err := runSchema(f, "im.message.receive_v1", true); err != nil {
-		t.Fatalf("runSchema json: %v", err)
-	}
-
-	var payload map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
-		t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
-	}
-	resolved := payload["resolved_output_schema"].(map[string]interface{})
-	props := resolved["properties"].(map[string]interface{})
-	for _, field := range []string{
-		"root_id",
-		"thread_id",
-		"reply_to",
-		"sender_type",
-		"mentions",
-	} {
-		if _, ok := props[field]; !ok {
-			t.Errorf("receive schema missing field %q", field)
-		}
-	}
-	msgDesc := props["message_id"].(map[string]interface{})["description"].(string)
-	if !strings.Contains(msgDesc, "Recommended idempotency key") {
-		t.Errorf("message_id description should guide deduplication, got %q", msgDesc)
-	}
-	eventDesc := props["event_id"].(map[string]interface{})["description"].(string)
-	if strings.Contains(eventDesc, "safe for deduplication") {
-		t.Errorf("event_id description should not recommend deduplication, got %q", eventDesc)
-	}
-}
-
 func TestRunSchema_TaskUpdateUserAccessJSON(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})

@@ -181,60 +124,6 @@ func TestRunSchema_TaskUpdateUserAccessJSON(t *testing.T) {
 	}
 }

-func TestRunSchema_ApprovalStatusChangedJSON(t *testing.T) {
-	tests := []struct {
-		key   string
-		scope string
-	}{
-		{"approval.instance.status_changed_v4", "approval:instance:read"},
-		{"approval.task.status_changed_v4", "approval:task:read"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.key, func(t *testing.T) {
-			t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-			f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})
-
-			if err := runSchema(f, tc.key, true); err != nil {
-				t.Fatalf("runSchema json: %v", err)
-			}
-
-			var payload approvalSchemaJSONPayload
-			if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
-				t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
-			}
-			if payload.JQRootPath != "." {
-				t.Errorf("jq_root_path = %v, want .", payload.JQRootPath)
-			}
-			if got := payload.AuthTypes; !reflect.DeepEqual(got, []string{"user"}) {
-				t.Errorf("auth_types = %#v, want user", got)
-			}
-			if got := payload.Scopes; !reflect.DeepEqual(got, []string{tc.scope}) {
-				t.Errorf("scopes = %#v, want %s", got, tc.scope)
-			}
-			if len(payload.Params) != 1 {
-				t.Fatalf("params = %#v, want one subscription_type param", payload.Params)
-			}
-			param := payload.Params[0]
-			if param.Name != "subscription_type" || param.Type != "multi" || param.Required || param.SubscriptionKey {
-				t.Fatalf("subscription_type param = %#v, want optional multi non-subscription-key param", param)
-			}
-			props := payload.ResolvedOutputSchema.Properties
-			for _, field := range []string{"type", "event_id", "timestamp", "approval_code", "instance_code", "status", "operate_time"} {
-				if _, ok := props[field]; !ok {
-					t.Errorf("approval schema missing flat field %q: %+v", field, props)
-				}
-			}
-			if _, ok := props["event"]; ok {
-				t.Errorf("approval Custom schema should be flat, got envelope field event: %+v", props)
-			}
-			if got := props["operate_time"].Format; got != "timestamp_ms" {
-				t.Errorf("operate_time format = %v, want timestamp_ms", got)
-			}
-		})
-	}
-}
-
 func TestRunSchema_JSONOutput_VCMeetingLifecycleKeys(t *testing.T) {
 	for _, key := range []string{
 		"vc.meeting.participant_meeting_started_v1",
--- a/cmd/profile/list.go
+++ b/cmd/profile/list.go
@@ -17,14 +17,11 @@ import (
 )

 // profileListItem is the JSON output for a single profile entry.
-// `default` (formerly `active`, renamed in this feature as a declared
-// breaking change) marks the saved default profile — never the identity
-// effective for the current invocation; that is whoami's job.
 type profileListItem struct {
 	Name        string         `json:"name"`
 	AppID       string         `json:"appId"`
 	Brand       core.LarkBrand `json:"brand"`
-	Default     bool           `json:"default"`
+	Active      bool           `json:"active"`
 	User        string         `json:"user,omitempty"`
 	TokenStatus string         `json:"tokenStatus,omitempty"`
 }
@@ -33,8 +30,7 @@ type profileListItem struct {
 func NewCmdProfileList(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "list",
-		Short: "List saved profiles",
-		Long:  "Lists saved profiles. To see the app/profile lark-cli is using now, run `lark-cli whoami --json`.",
+		Short: "List all profiles",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return profileListRun(f)
 		},
@@ -57,7 +53,7 @@ func profileListRun(f *cmdutil.Factory) error {
 		return nil
 	}

-	// Intentionally uses "" to show the saved default profile, not the ephemeral --profile override.
+	// Intentionally uses "" to show the persistent active profile, not the ephemeral --profile override.
 	currentApp := multi.CurrentAppConfig("")
 	currentName := ""
 	if currentApp != nil {
@@ -70,10 +66,10 @@ func profileListRun(f *cmdutil.Factory) error {
 		name := app.ProfileName()

 		item := profileListItem{
-			Name:    name,
-			AppID:   app.AppId,
-			Brand:   app.Brand,
-			Default: name == currentName,
+			Name:   name,
+			AppID:  app.AppId,
+			Brand:  app.Brand,
+			Active: name == currentName,
 		}

 		if len(app.Users) > 0 {
--- a/cmd/profile/profile.go
+++ b/cmd/profile/profile.go
@@ -14,17 +14,6 @@ func NewCmdProfile(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "profile",
 		Short: "Manage configuration profiles",
-		Long: `Profiles are named app identities managed by lark-cli.
-
-Identity diagnostics and profile selection:
-  lark-cli whoami --json       Show the app/profile lark-cli is using now.
-  lark-cli auth status --json --verify  Verify OAuth login and token state.
-  --profile <name>             Use a profile for this command only.
-  LARKSUITE_CLI_PROFILE        Use a profile for the current shell / agent session.
-  config show / profile list   Inspect saved config, not current usage.
-  unset LARKSUITE_CLI_PROFILE  Clear the session profile and fall back to direct app env or configured default.
-
-A selected profile takes precedence over matching direct env credentials and tokens.`,
 	}
 	cmdutil.DisableAuthCheck(cmd)
 	cmdutil.SetTips(cmd, []string{
--- a/cmd/profile/profile_test.go
+++ b/cmd/profile/profile_test.go
@@ -306,24 +306,14 @@ func TestProfileListRun_OutputsProfiles(t *testing.T) {
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("Unmarshal() error = %v; output=%s", err, stdout.String())
 	}
-	raw := stdout.String()
-	// `active` is renamed to `default` as a declared breaking change: keeping
-	// a permanently mirrored alias would keep misleading agents into reading
-	// it as the currently effective identity (whoami's job).
-	if strings.Contains(raw, `"active"`) {
-		t.Fatalf("profile list output contains renamed active field: %s", raw)
-	}
-	if !strings.Contains(raw, `"default"`) {
-		t.Fatalf("profile list output missing default field: %s", raw)
-	}
 	if len(got) != 2 {
 		t.Fatalf("len(got) = %d, want 2", len(got))
 	}
-	if got[0].Name != "default" || !got[0].Default {
-		t.Fatalf("got[0] = %#v, want configured default profile", got[0])
+	if got[0].Name != "default" || !got[0].Active {
+		t.Fatalf("got[0] = %#v, want active default profile", got[0])
 	}
-	if got[1].Name != "target" || got[1].Default {
-		t.Fatalf("got[1] = %#v, want non-default target profile", got[1])
+	if got[1].Name != "target" || got[1].Active {
+		t.Fatalf("got[1] = %#v, want inactive target profile", got[1])
 	}
 }

@@ -637,39 +627,6 @@ func TestProfileRemoveRun_ValidationErrors(t *testing.T) {
 	})
 }

-// TestProfileHelpHasSelectionSection asserts `profile --help` documents the
-// per-invocation flag and session-scoped env var for selecting a profile, so
-// users and AI agents can find LARKSUITE_CLI_PROFILE without reading source.
-func TestProfileHelpHasSelectionSection(t *testing.T) {
-	cmd := NewCmdProfile(nil)
-	if !strings.Contains(cmd.Long, "Identity diagnostics and profile selection:") {
-		t.Errorf("profile --help missing identity diagnostics and profile selection section")
-	}
-	if !strings.Contains(cmd.Long, "LARKSUITE_CLI_PROFILE") {
-		t.Errorf("profile --help missing LARKSUITE_CLI_PROFILE")
-	}
-	if !strings.Contains(cmd.Long, "lark-cli whoami --json") {
-		t.Errorf("profile --help missing whoami identity route")
-	}
-	if !strings.Contains(cmd.Long, "config show / profile list") {
-		t.Errorf("profile --help missing saved-config boundary")
-	}
-	const precedence = "A selected profile takes precedence over matching direct env credentials and tokens."
-	if !strings.Contains(cmd.Long, precedence) {
-		t.Errorf("profile --help missing precedence statement %q", precedence)
-	}
-}
-
-func TestProfileListHelpClarifiesSavedProfiles(t *testing.T) {
-	cmd := NewCmdProfileList(nil)
-	if !strings.Contains(cmd.Short, "saved profiles") {
-		t.Errorf("profile list short = %q, want saved profiles", cmd.Short)
-	}
-	if !strings.Contains(cmd.Long, "lark-cli whoami --json") {
-		t.Errorf("profile list help missing whoami route")
-	}
-}
-
 func TestProfileListRun_InvalidConfigReturnsValidationError(t *testing.T) {
 	dir := setupProfileConfigDir(t)
 	if err := os.WriteFile(filepath.Join(dir, "config.json"), []byte("{invalid json"), 0600); err != nil {
--- a/cmd/root_integration_test.go
+++ b/cmd/root_integration_test.go
@@ -371,11 +371,10 @@ func TestIntegration_StrictModeUser_ProfileOverride_ShortcutExplicitBotReturnsEn

 func TestIntegration_StrictModeBot_ProfileOverride_ServiceExplicitUserReturnsEnvelope(t *testing.T) {
 	f, stdout, stderr := newStrictModeDefaultFactory(t, "target", core.StrictModeBot)
-	catalog := strictModeFixtureCatalog()
-	rootCmd := buildStrictModeIntegrationRootCmdWithCatalog(t, f, &catalog)
+	rootCmd := buildStrictModeIntegrationRootCmd(t, f)

 	code := executeRootIntegration(t, f, rootCmd, []string{
-		"fixture", "things", "create", "--data", `{"name":"probe"}`, "--as", "user", "--dry-run",
+		"im", "chats", "get", "--params", `{"chat_id":"oc_test"}`, "--as", "user", "--dry-run",
 	})

 	if code != output.ExitValidation {
--- a/cmd/service/service.go
+++ b/cmd/service/service.go
@@ -403,9 +403,9 @@ func serviceMethodRun(opts *ServiceMethodOptions) error {

 	if opts.DryRun {
 		if fileMeta != nil {
-			return cmdutil.PrintDryRunWithFile(request, config, serviceDryRunOutputOptions(f, opts), *fileMeta)
+			return cmdutil.PrintDryRunWithFile(f.IOStreams.Out, request, config, opts.Format, fileMeta.FieldName, fileMeta.FilePath, fileMeta.FormFields)
 		}
-		return serviceDryRun(f, request, config, opts)
+		return serviceDryRun(f, request, config, opts.Format)
 	}

 	if opts.Method.Risk == cmdutil.RiskHighRiskWrite {
@@ -667,19 +667,8 @@ func buildServiceRequest(opts *ServiceMethodOptions) (client.RawApiRequest, *cmd
 	return request, nil, nil
 }

-func serviceDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, opts *ServiceMethodOptions) error {
-	return cmdutil.PrintDryRun(request, config, serviceDryRunOutputOptions(f, opts))
-}
-
-func serviceDryRunOutputOptions(f *cmdutil.Factory, opts *ServiceMethodOptions) cmdutil.DryRunOutputOptions {
-	return cmdutil.DryRunOutputOptions{
-		Format:      opts.Format,
-		JqExpr:      opts.JqExpr,
-		CommandPath: opts.Cmd.CommandPath(),
-		Identity:    opts.As,
-		Out:         f.IOStreams.Out,
-		ErrOut:      f.IOStreams.ErrOut,
-	}
+func serviceDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, format string) error {
+	return cmdutil.PrintDryRun(f.IOStreams.Out, request, config, format)
 }

 func servicePaginate(ctx context.Context, ac *client.APIClient, request client.RawApiRequest, format output.Format, jqExpr string, out, errOut io.Writer, commandPath string, pagOpts client.PaginationOptions, checkErr func(interface{}, core.Identity) error) error {
@@ -707,18 +696,20 @@ func servicePaginate(ctx context.Context, ac *client.APIClient, request client.R

 	switch format {
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
-		emitter := output.NewEmitter(output.EmitterConfig{
-			Out:            out,
-			ErrOut:         errOut,
-			CommandPath:    commandPath,
-			Identity:       string(pagOpts.Identity),
-			NoticeProvider: output.GetNotice,
-		})
+		pf := output.NewPaginatedFormatter(out, format)
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {
 			// Streaming formats intentionally emit each page after that page has
 			// passed safety scanning. A later page may still fail, so callers
 			// must use the exit code to distinguish complete vs partial output.
-			return emitter.StreamPage(items, output.StreamOptions{Format: format.String()})
+			scanResult := output.ScanForSafety(commandPath, items, errOut)
+			if scanResult.Blocked {
+				return scanResult.BlockErr
+			}
+			if scanResult.Alert != nil {
+				output.WriteAlertWarning(errOut, scanResult.Alert)
+			}
+			pf.FormatPage(items)
+			return nil
 		}, pagOpts)
 		if err != nil {
 			return err
--- a/cmd/service/service_paginate_test.go
+++ b/cmd/service/service_paginate_test.go
@@ -1,400 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package service
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/client"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/internal/output"
-)
-
-type serviceFailOnWriteWriter struct {
-	buf    bytes.Buffer
-	writes int
-	failAt int
-	err    error
-}
-
-func (w *serviceFailOnWriteWriter) Write(p []byte) (int, error) {
-	w.writes++
-	if w.writes == w.failAt {
-		return 0, w.err
-	}
-	return w.buf.Write(p)
-}
-
-func newServicePaginateTestHarness(t *testing.T) (*client.APIClient, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
-	t.Helper()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-	previousNotice := output.PendingNotice
-	output.PendingNotice = nil
-	t.Cleanup(func() { output.PendingNotice = previousNotice })
-
-	config := &core.CliConfig{
-		AppID:     "test-app",
-		AppSecret: "test-secret",
-		Brand:     core.BrandFeishu,
-	}
-	f, out, errOut, reg := cmdutil.TestFactory(t, config)
-	ac, err := f.NewAPIClientWithConfig(config)
-	if err != nil {
-		t.Fatalf("NewAPIClientWithConfig() error = %v", err)
-	}
-	ac.ErrOut = io.Discard
-	return ac, out, errOut, reg
-}
-
-func servicePaginateRequest() client.RawApiRequest {
-	return client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test/v1/items",
-		As:     core.AsBot,
-	}
-}
-
-func assertServicePaginateJSONBytes(t *testing.T, got []byte, want interface{}) {
-	t.Helper()
-	wantBytes, err := json.MarshalIndent(want, "", "  ")
-	if err != nil {
-		t.Fatalf("marshal expected JSON: %v", err)
-	}
-	wantBytes = append(wantBytes, '\n')
-	if !bytes.Equal(got, wantBytes) {
-		t.Fatalf("stdout bytes mismatch\ngot:\n%s\nwant:\n%s", got, wantBytes)
-	}
-}
-
-func TestServicePaginate_DefaultAggregatesAllPages(t *testing.T) {
-	ac, out, errOut, reg := newServicePaginateTestHarness(t)
-	calls := 0
-	wantTokens := []string{"", "next-1", "next-2"}
-	for i, wantToken := range wantTokens {
-		page := i + 1
-		hasMore := page < len(wantTokens)
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": string(rune('0' + page))}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = wantTokens[page]
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(req *http.Request) {
-				calls++
-				if got := req.URL.Query().Get("page_token"); got != wantToken {
-					t.Errorf("request %d page_token = %q, want %q", page, got, wantToken)
-				}
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatJSON, "", out, errOut, "lark-cli test items list", client.PaginationOptions{
-			PageLimit: 10,
-			PageDelay: -1,
-		}, ac.CheckResponse)
-
-	if err != nil {
-		t.Fatalf("servicePaginate() error = %v, want nil", err)
-	}
-	if calls != 3 {
-		t.Fatalf("pagination requests = %d, want 3", calls)
-	}
-	assertServicePaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"items": []interface{}{
-				map[string]interface{}{"id": "1"},
-				map[string]interface{}{"id": "2"},
-				map[string]interface{}{"id": "3"},
-			},
-			"has_more": false,
-		},
-	})
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}
-
-func TestServicePaginate_StreamingFormatsEmitExactMultiPageBytes(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		want   string
-	}{
-		{
-			name:   "ndjson",
-			format: output.FormatNDJSON,
-			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Carol\",\"page_only\":\"ignored\"}\n",
-		},
-		{
-			name:   "table",
-			format: output.FormatTable,
-			want:   "id  name \n──  ─────\n1   Alice\n2   Carol\n",
-		},
-		{
-			name:   "csv",
-			format: output.FormatCSV,
-			want:   "id,name\n1,Alice\n2,Carol\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newServicePaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "1", "name": "Alice"},
-						},
-						"has_more":   true,
-						"page_token": "next-1",
-					},
-				},
-			})
-			reg.Register(&httpmock.Stub{
-				URL: "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "2", "name": "Carol", "page_only": "ignored"},
-						},
-						"has_more": false,
-					},
-				},
-			})
-
-			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-				tt.format, "", out, errOut, "lark-cli test items list", client.PaginationOptions{
-					PageLimit: 10,
-					PageDelay: -1,
-				}, ac.CheckResponse)
-
-			if err != nil {
-				t.Fatalf("servicePaginate() error = %v, want nil", err)
-			}
-			if got := out.String(); got != tt.want {
-				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestServicePaginate_StreamingWriteFailureStopsFurtherPages(t *testing.T) {
-	ac, _, errOut, reg := newServicePaginateTestHarness(t)
-	sentinel := errors.New("page write failed")
-	out := &serviceFailOnWriteWriter{failAt: 2, err: sentinel}
-	calls := 0
-	for page := 1; page <= 2; page++ {
-		hasMore := true
-		data := map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"id": page}},
-			"has_more": hasMore,
-		}
-		if hasMore {
-			data["page_token"] = fmt.Sprintf("next-%d", page)
-		}
-		reg.Register(&httpmock.Stub{
-			URL: "/open-apis/test/v1/items",
-			OnMatch: func(*http.Request) {
-				calls++
-			},
-			Body: map[string]interface{}{
-				"code": 0,
-				"msg":  "ok",
-				"data": data,
-			},
-		})
-	}
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli test items list",
-		client.PaginationOptions{PageLimit: 10, PageDelay: -1}, ac.CheckResponse)
-
-	if !errors.Is(err, sentinel) {
-		t.Fatalf("servicePaginate() error = %v, want preserved writer cause", err)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal {
-		t.Fatalf("servicePaginate() problem = %#v, %v; want internal typed error", problem, ok)
-	}
-	if calls != 2 {
-		t.Fatalf("pagination requests = %d, want 2", calls)
-	}
-	if got, want := out.buf.String(), "{\"id\":1}\n"; got != want {
-		t.Fatalf("stdout bytes = %q, want %q", got, want)
-	}
-}
-
-func TestServicePaginate_StreamingFormatFallsBackToJSONWithoutList(t *testing.T) {
-	ac, out, errOut, reg := newServicePaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{
-				"name":    "Test User",
-				"user_id": "u123",
-			},
-		},
-	})
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli test items get",
-		client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-	if err != nil {
-		t.Fatalf("servicePaginate() error = %v, want nil", err)
-	}
-	assertServicePaginateJSONBytes(t, out.Bytes(), output.Envelope{
-		OK:       true,
-		Identity: "bot",
-		Data: map[string]interface{}{
-			"name":    "Test User",
-			"user_id": "u123",
-		},
-	})
-	wantWarning := "warning: this API does not return a list, format \"ndjson\" is not supported, falling back to json\n"
-	if got := errOut.String(); got != wantWarning {
-		t.Fatalf("stderr bytes = %q, want %q", got, wantWarning)
-	}
-}
-
-func TestServicePaginate_BusinessErrorsWriteRawAndRemainUnmarked(t *testing.T) {
-	businessResponse := map[string]interface{}{
-		"code": 123456,
-		"msg":  "fixture business error",
-		"data": map[string]interface{}{"detail": "business failed"},
-	}
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "default_json", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, reg := newServicePaginateTestHarness(t)
-			reg.Register(&httpmock.Stub{
-				URL:  "/open-apis/test/v1/items",
-				Body: businessResponse,
-			})
-
-			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli test items list",
-				client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-			if err == nil {
-				t.Fatal("servicePaginate() error = nil, want business error")
-			}
-			if errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
-			}
-			assertServicePaginateJSONBytes(t, out.Bytes(), businessResponse)
-			if bytes.Contains(out.Bytes(), []byte(`"ok": true`)) {
-				t.Fatalf("business-error stdout contains a success envelope:\n%s", out.Bytes())
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestServicePaginate_TransportErrorsRemainUnmarked(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		jqExpr string
-	}{
-		{name: "jq_paginate_all", format: output.FormatJSON, jqExpr: ".data.items"},
-		{name: "stream_pages", format: output.FormatNDJSON},
-		{name: "default_paginate_all", format: output.FormatJSON},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ac, out, errOut, _ := newServicePaginateTestHarness(t)
-
-			err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-				tt.format, tt.jqExpr, out, errOut, "lark-cli test items list",
-				client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-			if err == nil {
-				t.Fatal("servicePaginate() error = nil, want transport error")
-			}
-			if errs.IsRaw(err) {
-				t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
-			}
-			if got := out.String(); got != "" {
-				t.Fatalf("stdout bytes = %q, want empty", got)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-		})
-	}
-}
-
-func TestServicePaginate_StreamBusinessErrorRemainsUnmarked(t *testing.T) {
-	ac, out, errOut, reg := newServicePaginateTestHarness(t)
-	reg.Register(&httpmock.Stub{
-		URL: "/open-apis/test/v1/items",
-		Body: map[string]interface{}{
-			"code": 123456,
-			"msg":  "fixture business error",
-			"data": map[string]interface{}{},
-		},
-	})
-
-	err := servicePaginate(context.Background(), ac, servicePaginateRequest(),
-		output.FormatNDJSON, "", out, errOut, "lark-cli test items list",
-		client.PaginationOptions{PageDelay: -1}, ac.CheckResponse)
-
-	if err == nil {
-		t.Fatal("servicePaginate() error = nil, want business error")
-	}
-	if errs.IsRaw(err) {
-		t.Fatalf("errs.IsRaw(error) = true, want current servicePaginate pass-through behavior")
-	}
-	if got := out.String(); got != "" {
-		t.Fatalf("stdout bytes = %q, want empty", got)
-	}
-	if got := errOut.String(); got != "" {
-		t.Fatalf("stderr bytes = %q, want empty", got)
-	}
-}
--- a/cmd/service/service_test.go
+++ b/cmd/service/service_test.go
@@ -224,39 +224,13 @@ func TestServiceMethod_DryRun_PathParam(t *testing.T) {
 			if err := cmd.Execute(); err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
-			var got map[string]interface{}
-			if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-				t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, stdout.String())
-			}
-			if got["ok"] != true || got["dry_run"] != true {
-				t.Fatalf("unexpected dry-run envelope: %#v", got)
-			}
-			data := got["data"].(map[string]interface{})
-			api := data["api"].([]interface{})
-			call := api[0].(map[string]interface{})
-			if call["url"] != tt.wantInURL {
-				t.Errorf("url = %q, want %q\nstdout:\n%s", call["url"], tt.wantInURL, stdout.String())
+			if !strings.Contains(stdout.String(), tt.wantInURL) {
+				t.Errorf("expected URL containing %q, got:\n%s", tt.wantInURL, stdout.String())
 			}
 		})
 	}
 }

-func TestServiceMethod_DryRunWithJq(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, testConfig)
-	cmd := NewCmdServiceMethod(f, driveSpec(), driveMethod("GET", nil), "get", "files", nil)
-	cmd.SetArgs([]string{
-		"--params", `{"file_token":"boxcn123abc"}`,
-		"--dry-run",
-		"--jq", ".data.api[0].url",
-	})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got, want := strings.TrimSpace(stdout.String()), "/open-apis/drive/v1/files/boxcn123abc/copy"; got != want {
-		t.Fatalf("jq output = %q, want %q", got, want)
-	}
-}
-
 func TestServiceMethod_PathParamRejectsTraversal(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -344,12 +318,8 @@ func TestServiceMethod_PaginationParamSkippedWithPageAll(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected no error with --page-all skipping page_size, got: %v", err)
 	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, stdout.String())
-	}
-	if got["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", got["dry_run"])
+	if !strings.Contains(stdout.String(), "Dry Run") {
+		t.Error("expected dry-run output")
 	}
 }

@@ -1111,23 +1081,11 @@ func TestServiceMethod_FileUpload_DryRun(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	out := stdout.String()
-	var env map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, out)
+	if !strings.Contains(out, "image") {
+		t.Errorf("expected dry-run output to mention file field, got: %s", out)
 	}
-	if env["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", env["dry_run"])
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	body := call["body"].(map[string]interface{})
-	file := body["file"].(map[string]interface{})
-	if file["field"] != "image" || file["path"] != tmpFile {
-		t.Fatalf("unexpected file dry-run body: %#v", body)
-	}
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("stdout should not contain dry-run banner: %s", out)
+	if !strings.Contains(out, "Dry Run") {
+		t.Errorf("expected dry-run header, got: %s", out)
 	}
 }

--- a/cmd/service/testmain_test.go
+++ b/cmd/service/testmain_test.go
@@ -1,39 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package service
-
-import (
-	"os"
-	"testing"
-
-	"github.com/larksuite/cli/internal/registry/registrytest"
-)
-
-// TestMain isolates service command tests from the host machine: config (and
-// the registry cache under it) is redirected to a temp dir, then the registry
-// is seeded from the tracked fixture and initialized eagerly. Tests pass on a
-// clean checkout with no network, no `make fetch_meta`, and no user cache.
-//
-// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
-// m.Run before exiting.
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-cmd-service-test-*")
-	if err != nil {
-		println("cmd/service test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", root); err != nil {
-		println("cmd/service test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := registrytest.Seed(root); err != nil {
-		println("cmd/service test setup: registrytest.Seed failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	code := m.Run()
-	os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/cmd/startup_brand_test.go
+++ b/cmd/startup_brand_test.go
@@ -5,7 +5,6 @@ package cmd

 import (
 	"context"
-	"flag"
 	"fmt"
 	"os"
 	"os/exec"
@@ -13,34 +12,11 @@ import (
 	"strings"
 	"testing"

-	"github.com/google/uuid"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/registry"
 )

-const startupBrandHelperEnv = "GO_TEST_STARTUP_BRAND_HELPER"
-
-var _ = flag.String("startup-brand-helper", "", "internal startup brand test helper nonce")
-
-func isStartupBrandHelper() bool {
-	return startupBrandHelperEnabled(os.Getenv(startupBrandHelperEnv), startupBrandHelperNonce(os.Args))
-}
-
-func startupBrandHelperEnabled(envNonce, argNonce string) bool {
-	return envNonce != "" && envNonce == argNonce
-}
-
-func startupBrandHelperNonce(args []string) string {
-	const prefix = "-startup-brand-helper="
-	for _, arg := range args {
-		if strings.HasPrefix(arg, prefix) {
-			return strings.TrimPrefix(arg, prefix)
-		}
-	}
-	return ""
-}
-
 func TestResolveStartupBrand_Precedence(t *testing.T) {
 	tmp := t.TempDir()
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
@@ -78,7 +54,7 @@ func TestResolveStartupBrand_Precedence(t *testing.T) {
 // sync.Once, so the brand must be injected before the first catalog access.
 // It runs in a subprocess because the registry is process-global.
 func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
-	if isStartupBrandHelper() {
+	if os.Getenv("GO_TEST_STARTUP_BRAND_HELPER") == "1" {
 		// Helper: replicate Execute()'s build wiring with a lark config.
 		buildInternal(
 			context.Background(), cmdutil.InvocationContext{},
@@ -95,11 +71,9 @@ func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
 		t.Fatal(err)
 	}

-	nonce := uuid.NewString()
-	t.Setenv(startupBrandHelperEnv, nonce)
 	cmd := exec.Command(os.Args[0], "-test.run", "TestStartupBrandReachesRegistry_RealStartupOrder")
-	cmd.Args = append(cmd.Args, "-startup-brand-helper="+nonce)
 	cmd.Env = append(os.Environ(),
+		"GO_TEST_STARTUP_BRAND_HELPER=1",
 		"LARKSUITE_CLI_CONFIG_DIR="+tmp,
 		"LARKSUITE_CLI_REMOTE_META=off", // no network during the subprocess build
 	)
@@ -111,33 +85,3 @@ func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
 		t.Errorf("registry brand after real startup order = %s, want lark", out)
 	}
 }
-
-func TestStartupBrandHelperRequiresMatchingCommandNonce(t *testing.T) {
-	for _, tt := range []struct {
-		name     string
-		envNonce string
-		argNonce string
-		want     bool
-	}{
-		{name: "neither set"},
-		{name: "ambient environment only", envNonce: "ambient"},
-		{name: "command argument only", argNonce: "command"},
-		{name: "mismatch", envNonce: "ambient", argNonce: "command"},
-		{name: "matching", envNonce: "nonce", argNonce: "nonce", want: true},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := startupBrandHelperEnabled(tt.envNonce, tt.argNonce); got != tt.want {
-				t.Fatalf("startupBrandHelperEnabled() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestStartupBrandHelperNonce(t *testing.T) {
-	if got := startupBrandHelperNonce([]string{"test", "-test.run", "brand"}); got != "" {
-		t.Fatalf("startupBrandHelperNonce() = %q, want empty", got)
-	}
-	if got := startupBrandHelperNonce([]string{"test", "-startup-brand-helper=nonce"}); got != "nonce" {
-		t.Fatalf("startupBrandHelperNonce() = %q, want nonce", got)
-	}
-}
--- a/cmd/testmain_test.go
+++ b/cmd/testmain_test.go
@@ -1,46 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"os"
-	"testing"
-
-	"github.com/larksuite/cli/internal/registry/registrytest"
-)
-
-// TestMain isolates command-tree tests from the host machine: config (and the
-// registry cache under it) is redirected to a temp dir, then the registry is
-// seeded from the tracked fixture and initialized eagerly. Tests pass on a
-// clean checkout with no network, no `make fetch_meta`, and no user cache.
-//
-// Note: os.Exit skips deferred functions, so cleanup runs explicitly after
-// m.Run before exiting.
-func TestMain(m *testing.M) {
-	if isStartupBrandHelper() {
-		// Re-exec helper subprocess (startup_brand_test.go): the parent test
-		// already provides an isolated config dir and disables remote metadata,
-		// and the helper must own the first registry Init to prove the startup
-		// order — do not seed or eagerly initialize here.
-		os.Exit(m.Run())
-	}
-	root, err := os.MkdirTemp("", "lark-cli-cmd-test-*")
-	if err != nil {
-		println("cmd test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", root); err != nil {
-		println("cmd test setup: Setenv failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	if err := registrytest.Seed(root); err != nil {
-		println("cmd test setup: registrytest.Seed failed:", err.Error())
-		os.RemoveAll(root)
-		os.Exit(2)
-	}
-	code := m.Run()
-	os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/cmd/update/testmain_test.go
+++ b/cmd/update/testmain_test.go
@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdupdate
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-update-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/cmd/update/update_test.go
+++ b/cmd/update/update_test.go
@@ -24,8 +24,6 @@ import (
 	"github.com/larksuite/cli/internal/skillscheck"
 )

-const runLiveSkillsTestsEnv = "LARKSUITE_CLI_RUN_LIVE_SKILLS_TESTS"
-
 // newTestFactory creates a test factory with minimal config.
 func newTestFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffer) {
 	t.Helper()
@@ -33,17 +31,13 @@ func newTestFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer, *bytes.Buffe
 	return f, stdout, stderr
 }

-// mockDetect sets up newUpdater to return an Updater with the given DetectResult
-// and fully mocked skills operations. Tests that only care about install-method
-// detection must never fall through to the real npx skills CLI.
+// mockDetect sets up newUpdater to return an Updater with the given DetectResult.
 func mockDetect(t *testing.T, result selfupdate.DetectResult) {
 	t.Helper()
 	origNew := newUpdater
 	newUpdater = func() *selfupdate.Updater {
 		u := selfupdate.New()
 		u.DetectOverride = func() selfupdate.DetectResult { return result }
-		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
-		u.SkillsCommandOverride = successfulSkillsCommand()
 		return u
 	}
 	t.Cleanup(func() { newUpdater = origNew })
@@ -110,18 +104,6 @@ func successfulSkillsCommand() func(args ...string) *selfupdate.NpmResult {
 	}
 }

-func mockSkillsSync(t *testing.T) {
-	t.Helper()
-	origNew := newUpdater
-	newUpdater = func() *selfupdate.Updater {
-		u := selfupdate.New()
-		u.SkillsIndexFetchOverride = successfulSkillsIndexFetch()
-		u.SkillsCommandOverride = successfulSkillsCommand()
-		return u
-	}
-	t.Cleanup(func() { newUpdater = origNew })
-}
-
 func TestUpdatePnpm_JSON(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _ := newTestFactory(t)
@@ -246,9 +228,6 @@ func TestNormalizeVersion(t *testing.T) {
 }

 func TestUpdateAlreadyUpToDate_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	mockSkillsSync(t)
-
 	f, stdout, _ := newTestFactory(t)

 	cmd := NewCmdUpdate(f)
@@ -277,9 +256,6 @@ func TestUpdateAlreadyUpToDate_JSON(t *testing.T) {
 }

 func TestUpdateAlreadyUpToDate_Human(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	mockSkillsSync(t)
-
 	f, _, stderr := newTestFactory(t)

 	cmd := NewCmdUpdate(f)
@@ -305,7 +281,6 @@ func TestUpdateAlreadyUpToDate_Human(t *testing.T) {
 }

 func TestUpdateManual_JSON(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, stdout, _ := newTestFactory(t)
 	cmd := NewCmdUpdate(f)
 	cmd.SetArgs([]string{"--json"})
@@ -337,7 +312,6 @@ func TestUpdateManual_JSON(t *testing.T) {
 }

 func TestUpdateManual_Human(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, _, stderr := newTestFactory(t)
 	cmd := NewCmdUpdate(f)
 	cmd.SetArgs([]string{})
@@ -1187,7 +1161,6 @@ func TestRunSkillsAndState_DedupForceBypass(t *testing.T) {
 	}
 	called := false
 	updater := &selfupdate.Updater{
-		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
 		SkillsCommandOverride: func(args ...string) *selfupdate.NpmResult {
 			called = true
 			return successfulSkillsCommand()(args...)
@@ -1204,10 +1177,7 @@ func TestRunSkillsAndState_DedupForceBypass(t *testing.T) {

 func TestRunSkillsAndState_SuccessWritesState(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	updater := &selfupdate.Updater{
-		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
-		SkillsCommandOverride:    successfulSkillsCommand(),
-	}
+	updater := &selfupdate.Updater{SkillsCommandOverride: successfulSkillsCommand()}
 	got := runSkillsAndState(updater, newTestIO(), "1.0.21", false)
 	if got == nil || got.Err != nil {
 		t.Fatalf("runSkillsAndState() = %+v, want non-nil with nil Err", got)
@@ -1227,7 +1197,6 @@ func TestRunSkillsAndState_FailureKeepsOldState(t *testing.T) {
 		t.Fatal(err)
 	}
 	updater := &selfupdate.Updater{
-		SkillsIndexFetchOverride: successfulSkillsIndexFetch(),
 		SkillsCommandOverride: func(args ...string) *selfupdate.NpmResult {
 			r := &selfupdate.NpmResult{}
 			r.Err = fmt.Errorf("npx failed")
@@ -1544,133 +1513,28 @@ func TestEmitSkillsTextHints_Success(t *testing.T) {
 	}
 }

-// liveSkillsIsolationEnv is the single source of truth for the user-state
-// directories a live skills test must redirect under the temporary home. It
-// covers the CLI's own config, the agent homes the skills CLI installs into,
-// the XDG dirs it derives paths from (XDG_STATE_HOME holds its global
-// .skill-lock.json), and the npm/npx overrides that take precedence over
-// HOME-derived defaults (both cases: npm reads npm_config_* case-insensitively).
-func liveSkillsIsolationEnv(home string) map[string]string {
-	return map[string]string{
-		"HOME":                     home,
-		"USERPROFILE":              home,
-		"APPDATA":                  filepath.Join(home, "AppData", "Roaming"),
-		"LOCALAPPDATA":             filepath.Join(home, "AppData", "Local"),
-		"XDG_CONFIG_HOME":          filepath.Join(home, ".config"),
-		"XDG_DATA_HOME":            filepath.Join(home, ".local", "share"),
-		"XDG_STATE_HOME":           filepath.Join(home, ".local", "state"),
-		"CODEX_HOME":               filepath.Join(home, ".codex"),
-		"CLAUDE_CONFIG_DIR":        filepath.Join(home, ".claude"),
-		"LARKSUITE_CLI_CONFIG_DIR": filepath.Join(home, ".lark-cli"),
-		"npm_config_cache":         filepath.Join(home, ".npm-cache"),
-		"NPM_CONFIG_CACHE":         filepath.Join(home, ".npm-cache"),
-		"npm_config_prefix":        filepath.Join(home, ".npm-global"),
-		"NPM_CONFIG_PREFIX":        filepath.Join(home, ".npm-global"),
-		"npm_config_userconfig":    filepath.Join(home, ".npmrc"),
-		"NPM_CONFIG_USERCONFIG":    filepath.Join(home, ".npmrc"),
-	}
-}
-
-func prepareLiveSkillsIntegration(t *testing.T) string {
-	t.Helper()
-	if os.Getenv(runLiveSkillsTestsEnv) != "1" {
-		t.Skipf("live skills integration test disabled; set %s=1 to run", runLiveSkillsTestsEnv)
-	}
-
-	home := t.TempDir()
-	for key, value := range liveSkillsIsolationEnv(home) {
-		t.Setenv(key, value)
-	}
-	return home
-}
-
-func TestPrepareLiveSkillsIntegration(t *testing.T) {
-	reachedAfterGate := false
-	t.Run("requires explicit opt-in", func(t *testing.T) {
-		t.Setenv(runLiveSkillsTestsEnv, "")
-		prepareLiveSkillsIntegration(t)
-		reachedAfterGate = true
-	})
-	if reachedAfterGate {
-		t.Fatal("prepareLiveSkillsIntegration continued without explicit opt-in")
-	}
-
-	t.Run("isolates user directories", func(t *testing.T) {
-		t.Setenv(runLiveSkillsTestsEnv, "1")
-		home := prepareLiveSkillsIntegration(t)
-		// Pin the isolation contract by key: removing a variable from
-		// liveSkillsIsolationEnv must fail this list, and every redirected
-		// value must live under the temporary home.
-		required := []string{
-			"HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA",
-			"XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME",
-			"CODEX_HOME", "CLAUDE_CONFIG_DIR", "LARKSUITE_CLI_CONFIG_DIR",
-			"npm_config_cache", "NPM_CONFIG_CACHE",
-			"npm_config_prefix", "NPM_CONFIG_PREFIX",
-			"npm_config_userconfig", "NPM_CONFIG_USERCONFIG",
-		}
-		env := liveSkillsIsolationEnv(home)
-		for _, key := range required {
-			expected, ok := env[key]
-			if !ok {
-				t.Errorf("liveSkillsIsolationEnv dropped required key %s", key)
-				continue
-			}
-			if !strings.HasPrefix(expected, home) {
-				t.Errorf("%s = %q escapes temporary home %q", key, expected, home)
-			}
-			if got := os.Getenv(key); got != expected {
-				t.Errorf("%s = %q, want %q", key, got, expected)
-			}
-		}
-	})
-}
-
-// seedLiveSkillsGlobal verifies the real npx skills CLI is reachable, installs
-// lark-calendar into the isolated global skills dir, and returns the parsed
-// global skills list. The caller opted in explicitly, so every missing
-// precondition is a hard failure — skipping would report "nothing verified"
-// as a green run.
-func seedLiveSkillsGlobal(t *testing.T) []string {
-	t.Helper()
+// TestUpdateCommand_RealSkillsSyncRewritesState is a live integration test that
+// verifies "lark-cli update" correctly triggers skills sync and rewrites the
+// state file. It calls the real npx skills CLI, so the test is skipped when
+// npx or the skills registry is unavailable (e.g. no network or fork PRs).
+func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
+	// Phase 1: Verify the real npx skills CLI is available; skip otherwise.
 	if _, err := exec.LookPath("npx"); err != nil {
-		t.Fatalf("live skills tests opted in but npx not found in PATH: %v", err)
+		t.Skipf("npx not found in PATH: %v", err)
 	}
-	// Three sequential npx runs against a cold cache (the isolated home starts
-	// empty) can be slow; with Fatal-on-timeout semantics the budget errs on
-	// the generous side.
-	ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
 	defer cancel()
 	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "--list").Run(); err != nil {
-		t.Fatalf("live skills tests opted in but real skills CLI unavailable: %v", err)
-	}
-	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "-s", "lark-calendar", "-g", "-y").Run(); err != nil {
-		t.Fatalf("failed to seed isolated global skills: %v", err)
+		t.Skipf("real skills CLI unavailable: %v", err)
 	}
 	globalOut, err := exec.CommandContext(ctx, "npx", "-y", "skills", "ls", "-g").Output()
 	if err != nil {
-		t.Fatalf("real global skills CLI unavailable: %v", err)
+		t.Skipf("real global skills CLI unavailable: %v", err)
 	}
 	localSkills := skillscheck.ParseSkillsList(string(globalOut))
-	if len(localSkills) == 0 {
-		t.Fatal("seeded lark-calendar but global skills list is empty")
-	}
 	if err := ctx.Err(); err != nil {
-		t.Fatalf("real skills CLI availability check timed out: %v", err)
+		t.Skipf("real skills CLI availability check timed out: %v", err)
 	}
-	return localSkills
-}
-
-// TestUpdateCommand_RealSkillsSyncRewritesState is a live integration test that
-// verifies "lark-cli update" correctly triggers skills sync and rewrites the
-// state file. It calls the real npx skills CLI and only runs with explicit
-// opt-in. All user directories are redirected to a temporary home.
-func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
-	prepareLiveSkillsIntegration(t)
-
-	// Phase 1: Verify the real npx skills CLI is available and seed the
-	// isolated global skills install.
-	localSkills := seedLiveSkillsGlobal(t)

 	// Phase 2: Seed a previous sync state simulating an upgrade from v1.0.19.
 	// lark-doc and lark-mail are recorded as skipped/deleted, meaning the user
@@ -1766,17 +1630,26 @@ func TestUpdateCommand_RealSkillsSyncRewritesState(t *testing.T) {
 // not exist (cold start), the update command installs all official skills and
 // writes a fresh state file. No skill should appear in SkippedDeletedSkills
 // because there is no previous state to preserve user deletions from.
-// This is a live integration test that calls the real npx skills CLI and only
-// runs with explicit opt-in. All user directories are redirected to a temporary
-// home.
+// This is a live integration test that calls the real npx skills CLI; it is
+// skipped when npx or the skills registry is unavailable.
 func TestUpdateCommand_SkillsSyncColdStart(t *testing.T) {
-	prepareLiveSkillsIntegration(t)
-
-	// Phase 1: Verify the real npx skills CLI is available and seed one known
-	// official skill into the isolated global install. Cold start means no
-	// skills-state.json — locally installed skills may still exist, and seeding
-	// one keeps the Phase 4 per-skill assertions from running zero times.
-	localSkills := seedLiveSkillsGlobal(t)
+	// Phase 1: Verify the real npx skills CLI is available; skip otherwise.
+	if _, err := exec.LookPath("npx"); err != nil {
+		t.Skipf("npx not found in PATH: %v", err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
+	defer cancel()
+	if err := exec.CommandContext(ctx, "npx", "-y", "skills", "add", "https://open.feishu.cn", "--list").Run(); err != nil {
+		t.Skipf("real skills CLI unavailable: %v", err)
+	}
+	globalOut, err := exec.CommandContext(ctx, "npx", "-y", "skills", "ls", "-g").Output()
+	if err != nil {
+		t.Skipf("real global skills CLI unavailable: %v", err)
+	}
+	localSkills := skillscheck.ParseSkillsList(string(globalOut))
+	if err := ctx.Err(); err != nil {
+		t.Skipf("real skills CLI availability check timed out: %v", err)
+	}

 	// Phase 2: Use an isolated config dir with no pre-existing skills-state.json.
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
--- a/cmd/whoami/whoami.go
+++ b/cmd/whoami/whoami.go
@@ -10,7 +10,6 @@ import (

 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/identitydiag"
 	"github.com/larksuite/cli/internal/output"
 )
@@ -34,15 +33,6 @@ type whoamiResult struct {
 	TokenStatus    string         `json:"tokenStatus"`
 	OnBehalfOf     *delegatedUser `json:"onBehalfOf,omitempty"`
 	Hint           string         `json:"hint,omitempty"`
-
-	// CredentialSource, Explicit, and DirectCredentialEnv surface the cached
-	// credential.IdentitySelection computed during resolution (not re-inferred
-	// here). On the non-env extension-provider path CredentialSource is
-	// "extension:<provider>" (e.g. "extension:sidecar"); an empty value only
-	// means the selection was never resolved.
-	CredentialSource    string                         `json:"credentialSource"`
-	Explicit            bool                           `json:"explicit"`
-	DirectCredentialEnv credential.DirectCredentialEnv `json:"directCredentialEnv"`
 }

 // delegatedUser is the user a user-identity acts on behalf of.
@@ -68,10 +58,6 @@ func NewCmdWhoami(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "whoami",
 		Short: "Show the current effective identity, app, profile, and token status (JSON)",
-		Long: `Show the effective app identity used by this invocation. This is not OAuth login status;
-use ` + "`lark-cli auth status --json`" + ` for OAuth user/token state.
-The JSON output includes credentialSource, appId, brand, and whether direct app credential
-env is present and matches the selected profile.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return whoamiRun(cmd, opts)
 		},
@@ -111,17 +97,7 @@ func whoamiRun(cmd *cobra.Command, opts *Options) error {
 		f.ResolveStrictMode(ctx).ForcedIdentity(),
 	)
 	diag := identitydiag.Diagnose(ctx, f, cfg, false)
-	// Read the cached selection computed during resolution; never re-infer it
-	// here. A resolution failure (e.g. under a non-env extension provider that
-	// doesn't populate a selection) degrades to the zero value rather than
-	// regressing whoami's own error/diagnostic path above.
-	var selection credential.IdentitySelection
-	if f.Credential != nil {
-		if sel, err := f.Credential.Selection(ctx); err == nil {
-			selection = sel
-		}
-	}
-	res := buildResult(cfg, as, source, diag, selection)
+	res := buildResult(cfg, as, source, diag)
 	output.PrintJson(f.IOStreams.Out, res)
 	return nil
 }
@@ -146,23 +122,18 @@ func resolveSource(changedAs bool, flagAs core.Identity, autoDetected bool, stri

 // buildResult maps the resolved identity and local diagnostics into the output.
 // ResolveAs only ever returns user or bot, so the default branch handles user.
-// selection is the cached credential.IdentitySelection from resolution; it is
-// read as-is, never recomputed.
-func buildResult(cfg *core.CliConfig, as core.Identity, source string, diag identitydiag.Result, selection credential.IdentitySelection) *whoamiResult {
+func buildResult(cfg *core.CliConfig, as core.Identity, source string, diag identitydiag.Result) *whoamiResult {
 	defaultAs := cfg.DefaultAs
 	if defaultAs == "" {
 		defaultAs = core.AsAuto
 	}
 	res := &whoamiResult{
-		Profile:             cfg.ProfileName,
-		AppID:               cfg.AppID,
-		Brand:               cfg.Brand,
-		DefaultAs:           string(defaultAs),
-		Identity:            string(as),
-		IdentitySource:      source,
-		CredentialSource:    string(selection.Source),
-		Explicit:            selection.Explicit(),
-		DirectCredentialEnv: selection.DirectCredentialEnv,
+		Profile:        cfg.ProfileName,
+		AppID:          cfg.AppID,
+		Brand:          cfg.Brand,
+		DefaultAs:      string(defaultAs),
+		Identity:       string(as),
+		IdentitySource: source,
 	}
 	// Use the diagnosed hint as-is: it is tailored to the credential source, so
 	// it never says "auth login" when that is blocked under an external provider.
--- a/cmd/whoami/whoami_test.go
+++ b/cmd/whoami/whoami_test.go
@@ -15,13 +15,10 @@ import (

 	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/internal/identitydiag"
-	"github.com/larksuite/cli/internal/keychain"
 )

 func TestResolveSource(t *testing.T) {
@@ -55,7 +52,7 @@ func TestBuildResult_UserValid(t *testing.T) {
 	diag := identitydiag.Result{
 		User: identitydiag.Identity{Available: true, Status: "ready", TokenStatus: "valid", OpenID: "ou_x", UserName: "Alice"},
 	}
-	r := buildResult(cfg, core.AsUser, "auto_detect", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsUser, "auto_detect", diag)

 	if r.Identity != "user" || r.IdentitySource != "auto_detect" {
 		t.Fatalf("identity/source = %q/%q", r.Identity, r.IdentitySource)
@@ -80,7 +77,7 @@ func TestBuildResult_UserMissingToken(t *testing.T) {
 	diag := identitydiag.Result{
 		User: identitydiag.Identity{Available: false, Status: "missing", Hint: "run: lark-cli auth login --help"}, // never logged in
 	}
-	r := buildResult(cfg, core.AsUser, "auto_detect", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsUser, "auto_detect", diag)

 	if r.Available {
 		t.Fatalf("available = true, want false")
@@ -103,7 +100,7 @@ func TestBuildResult_BotReady(t *testing.T) {
 	diag := identitydiag.Result{
 		Bot: identitydiag.Identity{Available: true, Status: "ready"},
 	}
-	r := buildResult(cfg, core.AsBot, "default_as", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsBot, "default_as", diag)

 	if r.Identity != "bot" || r.IdentitySource != "default_as" {
 		t.Fatalf("identity/source = %q/%q", r.Identity, r.IdentitySource)
@@ -124,7 +121,7 @@ func TestBuildResult_BotNotConfigured(t *testing.T) {
 	diag := identitydiag.Result{
 		Bot: identitydiag.Identity{Available: false, Status: "not_configured", Hint: "run: lark-cli config --help"},
 	}
-	r := buildResult(cfg, core.AsBot, "auto_detect", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsBot, "auto_detect", diag)

 	if r.Available {
 		t.Fatalf("available = true, want false")
@@ -321,94 +318,3 @@ func TestWhoami_ExternalProvider_UserHintNotKeychain(t *testing.T) {
 		t.Fatalf("hint should explain external management: %q", got.Hint)
 	}
 }
-
-// noopWhoamiKeychain is a no-op KeychainAccess; the profile below uses a
-// plaintext secret, so no keychain lookup is actually required.
-type noopWhoamiKeychain struct{}
-
-func (noopWhoamiKeychain) Get(service, account string) (string, error) { return "", nil }
-func (noopWhoamiKeychain) Set(service, account, value string) error    { return nil }
-func (noopWhoamiKeychain) Remove(service, account string) error        { return nil }
-
-// credentialSourceSecret is the profile secret written to config for
-// TestWhoamiIncludesCredentialSource. It must never leak into whoami's output
-// (security: never leak a secret).
-const credentialSourceSecret = "test-secret"
-
-// profileSelectionFactory builds a Factory whose CredentialProvider resolves
-// an explicit profile ("tenant_a") supplied via the LARKSUITE_CLI_PROFILE env
-// fallback (not --profile), so Selection().Source resolves to
-// env:LARKSUITE_CLI_PROFILE and Explicit() is true, with no direct
-// app-credential env vars present.
-func profileSelectionFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer) {
-	t.Helper()
-	t.Setenv(envvars.CliAppID, "")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	multi := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name:      "tenant_a",
-			AppId:     "cli_a",
-			AppSecret: core.PlainSecret(credentialSourceSecret),
-			Brand:     core.BrandFeishu,
-		}},
-	}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	defaultAcct := credential.NewDefaultAccountProvider(func() keychain.KeychainAccess { return noopWhoamiKeychain{} }, "tenant_a")
-	cred := credential.NewCredentialProvider([]extcred.Provider{&envprovider.Provider{}}, defaultAcct, nil, nil)
-	cred.WithProfileFromEnv("tenant_a")
-
-	cfg := &core.CliConfig{ProfileName: "tenant_a", AppID: "cli_a", AppSecret: credentialSourceSecret, Brand: core.BrandFeishu}
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{
-		Config:     func() (*core.CliConfig, error) { return cfg, nil },
-		Credential: cred,
-		IOStreams:  &cmdutil.IOStreams{Out: out, ErrOut: &bytes.Buffer{}},
-	}
-	return f, out
-}
-
-// TestWhoamiIncludesCredentialSource locks in the diagnostic fields surfaced
-// from the cached credential.IdentitySelection: credentialSource,
-// explicit, and directCredentialEnv. whoami must read the cached selection
-// as-is, not re-infer it.
-func TestWhoamiIncludesCredentialSource(t *testing.T) {
-	f, out := profileSelectionFactory(t)
-
-	cmd := NewCmdWhoami(f)
-	cmd.SetArgs([]string{})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("Execute() error = %v", err)
-	}
-
-	raw := out.String()
-	if strings.Contains(raw, credentialSourceSecret) {
-		t.Fatalf("whoami output leaked the profile secret: %s", raw)
-	}
-
-	var got whoamiResult
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("json.Unmarshal() error = %v\n%s", err, raw)
-	}
-	if got.CredentialSource != string(credential.SourceEnvProfile) {
-		t.Fatalf("credentialSource = %q, want %q", got.CredentialSource, credential.SourceEnvProfile)
-	}
-	if !got.Explicit {
-		t.Fatalf("explicit = false, want true")
-	}
-	if got.DirectCredentialEnv.Present {
-		t.Fatalf("directCredentialEnv.present = true, want false: %#v", got.DirectCredentialEnv)
-	}
-	if !strings.Contains(raw, `"credentialSource": "env:LARKSUITE_CLI_PROFILE"`) {
-		t.Fatalf("raw JSON missing credentialSource literal: %s", raw)
-	}
-	if got.DirectCredentialEnv.Present || len(got.DirectCredentialEnv.Keys) != 0 ||
-		got.DirectCredentialEnv.AppID != "" || got.DirectCredentialEnv.Matched || got.DirectCredentialEnv.ConflictsWithProfile {
-		t.Fatalf("directCredentialEnv = %#v, want only present:false set", got.DirectCredentialEnv)
-	}
-}
--- a/errs/ERROR_CONTRACT.md
+++ b/errs/ERROR_CONTRACT.md
@@ -67,17 +67,6 @@ Typed errors render to **stderr** as one JSON object per process exit:
 | `error.params` | per-Subtype-stable | per-parameter validation detail array (`ValidationError`); see **Validation parameters** |
 | per-Subtype extension fields | per-Subtype-stable | e.g. `missing_scopes`, `console_url`, `challenge_url` |

-Credential/identity-selection extension fields (per-Subtype-stable):
-
-| Field | Carrier | Subtypes | Notes |
-|-------|---------|----------|-------|
-| `missing_keys` | `ConfigError` | `app_credential_incomplete` | env var NAMES that must all be set; never values |
-| `required_any_of` | `ConfigError` | `app_credential_incomplete` | env var NAMES where any one completes the credential; mutually exclusive with `missing_keys` |
-| `profile` | `ConfigError` | `profile_not_found`, `profile_secret_invalid` | requested profile name |
-| `app_id` | `ConfigError` | `profile_secret_invalid` | plaintext app id; never a secret |
-| `credential_source` | `ConfigError` | `profile_not_found`, `no_active_profile` | how the identity was (not) chosen: `flag:--profile` \| `env:LARKSUITE_CLI_PROFILE` \| `config` |
-| `profile_app_id`, `env_app_id` | `ValidationError` | `profile_app_credential_conflict` | the two conflicting plaintext app ids |
-
 `SecurityPolicyError` renders through the same typed envelope as every
 other category. `error.type` is `"policy"`, `error.subtype` is one of
 `challenge_required` / `access_denied`, and process exit is `6` via
--- a/errs/marshal_test.go
+++ b/errs/marshal_test.go
@@ -136,79 +136,6 @@ func TestConfigError_MarshalJSON(t *testing.T) {
 	}
 }

-func TestConfigError_ProfileFieldsMarshalJSON(t *testing.T) {
-	ce := NewConfigError(SubtypeAppCredentialIncomplete, "incomplete").
-		WithMissingKeys("LARKSUITE_CLI_APP_ID", "LARKSUITE_CLI_APP_SECRET").
-		WithRequiredAnyOf("LARKSUITE_CLI_APP_SECRET", "LARKSUITE_CLI_USER_ACCESS_TOKEN").
-		WithProfile("work").
-		WithAppID("cli_abc").
-		WithCredentialSource("flag:--profile")
-	b, err := json.Marshal(ce)
-	if err != nil {
-		t.Fatal(err)
-	}
-	s := string(b)
-	for _, want := range []string{
-		`"type":"config"`,
-		`"subtype":"app_credential_incomplete"`,
-		`"missing_keys":["LARKSUITE_CLI_APP_ID","LARKSUITE_CLI_APP_SECRET"]`,
-		`"required_any_of":["LARKSUITE_CLI_APP_SECRET","LARKSUITE_CLI_USER_ACCESS_TOKEN"]`,
-		`"profile":"work"`,
-		`"app_id":"cli_abc"`,
-		`"credential_source":"flag:--profile"`,
-	} {
-		if !strings.Contains(s, want) {
-			t.Errorf("missing %q in %s", want, s)
-		}
-	}
-
-	// omitempty: unset fields must not appear on the wire.
-	empty := NewConfigError(SubtypeProfileNotFound, "x")
-	b2, err := json.Marshal(empty)
-	if err != nil {
-		t.Fatal(err)
-	}
-	s2 := string(b2)
-	for _, notWant := range []string{`"missing_keys"`, `"required_any_of"`, `"profile"`, `"app_id"`, `"credential_source"`} {
-		if strings.Contains(s2, notWant) {
-			t.Errorf("%q should be omitted when empty; got %s", notWant, s2)
-		}
-	}
-}
-
-func TestValidationError_ProfileConflictMarshalJSON(t *testing.T) {
-	ve := NewValidationError(SubtypeProfileAppCredentialConflict, "conflict").
-		WithProfileAppConflict("cli_profile", "cli_env")
-	b, err := json.Marshal(ve)
-	if err != nil {
-		t.Fatal(err)
-	}
-	s := string(b)
-	for _, want := range []string{
-		`"type":"validation"`,
-		`"subtype":"profile_app_credential_conflict"`,
-		`"profile_app_id":"cli_profile"`,
-		`"env_app_id":"cli_env"`,
-	} {
-		if !strings.Contains(s, want) {
-			t.Errorf("missing %q in %s", want, s)
-		}
-	}
-
-	// omitempty: unset conflict fields must not appear on the wire.
-	empty := NewValidationError(SubtypeInvalidArgument, "x")
-	b2, err := json.Marshal(empty)
-	if err != nil {
-		t.Fatal(err)
-	}
-	s2 := string(b2)
-	for _, notWant := range []string{`"profile_app_id"`, `"env_app_id"`} {
-		if strings.Contains(s2, notWant) {
-			t.Errorf("%q should be omitted when empty; got %s", notWant, s2)
-		}
-	}
-}
-
 func TestNetworkError_MarshalJSON(t *testing.T) {
 	ne := &NetworkError{
 		Problem: Problem{Category: CategoryNetwork, Subtype: SubtypeNetworkTimeout, Message: "dial timeout"},
--- a/errs/subtypes.go
+++ b/errs/subtypes.go
@@ -12,9 +12,8 @@ const (

 // CategoryValidation subtypes
 const (
-	SubtypeInvalidArgument              Subtype = "invalid_argument"                // user-supplied flag / arg failed validation (gRPC INVALID_ARGUMENT alignment)
-	SubtypeFailedPrecondition           Subtype = "failed_precondition"             // request is valid but the system/resource state is not in the state required to execute; caller must change state (not retry) — e.g. ambiguous remote mapping (gRPC FAILED_PRECONDITION alignment)
-	SubtypeProfileAppCredentialConflict Subtype = "profile_app_credential_conflict" // profile and direct app env both set but app_id differs
+	SubtypeInvalidArgument    Subtype = "invalid_argument"    // user-supplied flag / arg failed validation (gRPC INVALID_ARGUMENT alignment)
+	SubtypeFailedPrecondition Subtype = "failed_precondition" // request is valid but the system/resource state is not in the state required to execute; caller must change state (not retry) — e.g. ambiguous remote mapping (gRPC FAILED_PRECONDITION alignment)
 )

 // CategoryAuthentication subtypes
@@ -42,13 +41,9 @@ const (

 // CategoryConfig subtypes
 const (
-	SubtypeInvalidClient           Subtype = "invalid_client"            // app_id / app_secret incorrect (RFC 6749 §5.2 alignment)
-	SubtypeNotConfigured           Subtype = "not_configured"            // local config file absent (user has not run `config init`)
-	SubtypeInvalidConfig           Subtype = "invalid_config"            // local config file present but malformed
-	SubtypeProfileNotFound         Subtype = "profile_not_found"         // --profile / LARKSUITE_CLI_PROFILE points to a nonexistent profile
-	SubtypeNoActiveProfile         Subtype = "no_active_profile"         // no active identity input and no usable default profile
-	SubtypeAppCredentialIncomplete Subtype = "app_credential_incomplete" // direct app env missing app_id or app_secret
-	SubtypeProfileSecretInvalid    Subtype = "profile_secret_invalid"    // profile exists but its secret cannot be resolved locally
+	SubtypeInvalidClient Subtype = "invalid_client" // app_id / app_secret incorrect (RFC 6749 §5.2 alignment)
+	SubtypeNotConfigured Subtype = "not_configured" // local config file absent (user has not run `config init`)
+	SubtypeInvalidConfig Subtype = "invalid_config" // local config file present but malformed
 )

 // CategoryNetwork subtypes
--- a/errs/types.go
+++ b/errs/types.go
@@ -61,11 +61,9 @@ type TypedError interface {
 // it is intentionally not serialized.
 type ValidationError struct {
 	Problem
-	Param        string         `json:"param,omitempty"`
-	Params       []InvalidParam `json:"params,omitempty"`
-	ProfileAppID string         `json:"profile_app_id,omitempty"`
-	EnvAppID     string         `json:"env_app_id,omitempty"`
-	Cause        error          `json:"-"`
+	Param  string         `json:"param,omitempty"`
+	Params []InvalidParam `json:"params,omitempty"`
+	Cause  error          `json:"-"`
 }

 // InvalidParam is one structured validation diagnostic: the parameter that
@@ -152,12 +150,6 @@ func (e *ValidationError) WithCause(cause error) *ValidationError {
 	return e
 }

-func (e *ValidationError) WithProfileAppConflict(profileAppID, envAppID string) *ValidationError {
-	e.ProfileAppID = profileAppID
-	e.EnvAppID = envAppID
-	return e
-}
-
 // =========================== AuthenticationError =============================

 // AuthenticationError is the typed error for CategoryAuthentication.
@@ -323,18 +315,8 @@ func (e *PermissionError) WithCause(cause error) *PermissionError {
 // intentionally not serialized.
 type ConfigError struct {
 	Problem
-	Field         string   `json:"field,omitempty"`
-	MissingKeys   []string `json:"missing_keys,omitempty"`
-	RequiredAnyOf []string `json:"required_any_of,omitempty"`
-	Profile       string   `json:"profile,omitempty"`
-	AppID         string   `json:"app_id,omitempty"`
-	// CredentialSource is the machine-readable App/credential selection source
-	// that produced this config error (e.g. "flag:--profile",
-	// "env:LARKSUITE_CLI_PROFILE", "config"). It is required on
-	// profile_not_found and no_active_profile so an agent can branch
-	// on how the identity was (or was not) chosen. It is never a secret.
-	CredentialSource string `json:"credential_source,omitempty"`
-	Cause            error  `json:"-"`
+	Field string `json:"field,omitempty"`
+	Cause error  `json:"-"`
 }

 // Unwrap is nil-receiver safe; see ValidationError.Unwrap.
@@ -388,34 +370,6 @@ func (e *ConfigError) WithField(field string) *ConfigError {
 	return e
 }

-func (e *ConfigError) WithMissingKeys(keys ...string) *ConfigError {
-	e.MissingKeys = slices.Clone(keys)
-	return e
-}
-
-func (e *ConfigError) WithRequiredAnyOf(keys ...string) *ConfigError {
-	e.RequiredAnyOf = slices.Clone(keys)
-	return e
-}
-
-func (e *ConfigError) WithProfile(name string) *ConfigError {
-	e.Profile = name
-	return e
-}
-
-func (e *ConfigError) WithAppID(appID string) *ConfigError {
-	e.AppID = appID
-	return e
-}
-
-// WithCredentialSource records the machine-readable credential-selection source
-// on the wire (snake_case credential_source). The value is an enum string
-// (e.g. "flag:--profile", "config"), never a secret.
-func (e *ConfigError) WithCredentialSource(source string) *ConfigError {
-	e.CredentialSource = source
-	return e
-}
-
 func (e *ConfigError) WithCause(cause error) *ConfigError {
 	e.Cause = cause
 	return e
--- a/errs/types_test.go
+++ b/errs/types_test.go
@@ -643,29 +643,3 @@ func TestBuilderSetter_DefensiveCopy(t *testing.T) {
 		}
 	})
 }
-
-// ======================= Profile selection error subtypes =======================
-
-func TestConfigErrorProfileFields(t *testing.T) {
-	e := errs.NewConfigError(errs.SubtypeAppCredentialIncomplete, "incomplete").
-		WithMissingKeys("LARKSUITE_CLI_APP_ID").
-		WithCredentialSource("env:LARKSUITE_CLI_PROFILE")
-	p, ok := errs.ProblemOf(e)
-	if !ok || p.Subtype != errs.SubtypeAppCredentialIncomplete {
-		t.Fatalf("subtype mismatch: %+v", p)
-	}
-	if len(e.MissingKeys) != 1 || e.MissingKeys[0] != "LARKSUITE_CLI_APP_ID" {
-		t.Errorf("missing_keys not set: %v", e.MissingKeys)
-	}
-	if e.CredentialSource != "env:LARKSUITE_CLI_PROFILE" {
-		t.Errorf("credential_source not set: %q", e.CredentialSource)
-	}
-}
-
-func TestValidationErrorProfileConflict(t *testing.T) {
-	e := errs.NewValidationError(errs.SubtypeProfileAppCredentialConflict, "conflict").
-		WithProfileAppConflict("cli_profile", "cli_env")
-	if e.ProfileAppID != "cli_profile" || e.EnvAppID != "cli_env" {
-		t.Errorf("conflict fields not set: %q %q", e.ProfileAppID, e.EnvAppID)
-	}
-}
--- a/events/application/menu.go
+++ b/events/application/menu.go
@@ -1,107 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-// BotMenuOutput is the flattened shape for application.bot.menu_v6.
-type BotMenuOutput struct {
-	Type            string `json:"type"                         desc:"Event type; always application.bot.menu_v6"`
-	EventID         string `json:"event_id,omitempty"           desc:"Globally unique event ID; safe for deduplication"`
-	Timestamp       string `json:"timestamp,omitempty"          desc:"Event delivery time (ms timestamp string); prefers header.create_time" kind:"timestamp_ms"`
-	AppID           string `json:"app_id,omitempty"             desc:"Application ID from the event header"`
-	TenantKey       string `json:"tenant_key,omitempty"         desc:"Tenant key from the event header"`
-	EventKey        string `json:"event_key,omitempty"          desc:"Developer-defined bot menu event key"`
-	MenuTimestamp   string `json:"menu_timestamp,omitempty"     desc:"Menu click timestamp from the event body"                           kind:"timestamp_ms"`
-	OperatorID      string `json:"operator_id,omitempty"        desc:"Operator open_id; kept as a short alias of operator_open_id"        kind:"open_id"`
-	OperatorOpenID  string `json:"operator_open_id,omitempty"   desc:"Operator open_id"                                                   kind:"open_id"`
-	OperatorUnionID string `json:"operator_union_id,omitempty"  desc:"Operator union_id"                                                  kind:"union_id"`
-	OperatorUserID  string `json:"operator_user_id,omitempty"   desc:"Operator user_id"                                                   kind:"user_id"`
-	OperatorName    string `json:"operator_name,omitempty"      desc:"Operator display name"`
-}
-
-func processBotMenu(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
-	var envelope struct {
-		Header struct {
-			EventID    string `json:"event_id"`
-			EventType  string `json:"event_type"`
-			CreateTime string `json:"create_time"`
-			AppID      string `json:"app_id"`
-			TenantKey  string `json:"tenant_key"`
-		} `json:"header"`
-		Event struct {
-			EventKey  string          `json:"event_key"`
-			Timestamp json.RawMessage `json:"timestamp"`
-			Operator  struct {
-				OperatorID struct {
-					OpenID  string `json:"open_id"`
-					UnionID string `json:"union_id"`
-					UserID  string `json:"user_id"`
-				} `json:"operator_id"`
-				OperatorName string `json:"operator_name"`
-			} `json:"operator"`
-		} `json:"event"`
-	}
-	if err := json.Unmarshal(raw.Payload, &envelope); err != nil {
-		return raw.Payload, nil //nolint:nilerr // passthrough on malformed payload so consumers still see the event
-	}
-
-	menuTimestamp := timestampMillisString(envelope.Event.Timestamp)
-	timestamp := envelope.Header.CreateTime
-	if timestamp == "" {
-		timestamp = menuTimestamp
-	}
-	operatorID := envelope.Event.Operator.OperatorID.OpenID
-
-	out := &BotMenuOutput{
-		Type:            eventTypeBotMenuV6,
-		EventID:         envelope.Header.EventID,
-		Timestamp:       timestamp,
-		AppID:           envelope.Header.AppID,
-		TenantKey:       envelope.Header.TenantKey,
-		EventKey:        envelope.Event.EventKey,
-		MenuTimestamp:   menuTimestamp,
-		OperatorID:      operatorID,
-		OperatorOpenID:  operatorID,
-		OperatorUnionID: envelope.Event.Operator.OperatorID.UnionID,
-		OperatorUserID:  envelope.Event.Operator.OperatorID.UserID,
-		OperatorName:    envelope.Event.Operator.OperatorName,
-	}
-	return json.Marshal(out)
-}
-
-func rawScalarString(raw json.RawMessage) string {
-	s := strings.TrimSpace(string(raw))
-	if s == "" || s == "null" {
-		return ""
-	}
-	var text string
-	if err := json.Unmarshal(raw, &text); err == nil {
-		return text
-	}
-	return s
-}
-
-func timestampMillisString(raw json.RawMessage) string {
-	s := rawScalarString(raw)
-	if len(s) == 10 && allDigits(s) {
-		return s + "000"
-	}
-	return s
-}
-
-func allDigits(s string) bool {
-	for _, r := range s {
-		if r < '0' || r > '9' {
-			return false
-		}
-	}
-	return s != ""
-}
--- a/events/application/menu_test.go
+++ b/events/application/menu_test.go
@@ -1,227 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"encoding/json"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-func TestKeysBotMenuMetadata(t *testing.T) {
-	keys := Keys()
-	if len(keys) != 1 {
-		t.Fatalf("len(Keys()) = %d, want 1", len(keys))
-	}
-
-	def := keys[0]
-	if def.Key != eventTypeBotMenuV6 {
-		t.Errorf("Key = %q, want %q", def.Key, eventTypeBotMenuV6)
-	}
-	if def.EventType != eventTypeBotMenuV6 {
-		t.Errorf("EventType = %q, want %q", def.EventType, eventTypeBotMenuV6)
-	}
-	if def.SubscriptionType != "" {
-		t.Errorf("SubscriptionType = %q, want default event subscription", def.SubscriptionType)
-	}
-	if def.Schema.Custom == nil {
-		t.Fatal("Schema.Custom is nil")
-	}
-	if def.Schema.Custom.Type != reflect.TypeOf(BotMenuOutput{}) {
-		t.Errorf("custom type = %v, want BotMenuOutput", def.Schema.Custom.Type)
-	}
-	if def.Schema.Native != nil {
-		t.Fatal("Schema.Native must be nil for processed output")
-	}
-	if def.Process == nil {
-		t.Fatal("Process is nil")
-	}
-	if !reflect.DeepEqual(def.AuthTypes, []string{"bot"}) {
-		t.Errorf("AuthTypes = %#v", def.AuthTypes)
-	}
-	if !reflect.DeepEqual(def.RequiredConsoleEvents, []string{eventTypeBotMenuV6}) {
-		t.Errorf("RequiredConsoleEvents = %#v", def.RequiredConsoleEvents)
-	}
-}
-
-func TestBotMenuRegistersCleanly(t *testing.T) {
-	const key = eventTypeBotMenuV6
-	event.UnregisterKeyForTest(key)
-	t.Cleanup(func() { event.UnregisterKeyForTest(key) })
-
-	for _, def := range Keys() {
-		event.RegisterKey(def)
-	}
-	if _, ok := event.Lookup(key); !ok {
-		t.Fatalf("event.Lookup(%q) not registered", key)
-	}
-}
-
-func TestProcessBotMenu(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_001",
-			"event_type": "application.bot.menu_v6",
-			"create_time": "1776409469273",
-			"app_id": "cli_test",
-			"tenant_key": "tenant_test"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"timestamp": 1776409469000,
-			"operator": {
-				"operator_id": {
-					"open_id": "ou_operator",
-					"union_id": "on_operator",
-					"user_id": "user_operator"
-				},
-				"operator_name": "Test User"
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Type != eventTypeBotMenuV6 {
-		t.Errorf("Type = %q, want %q", out.Type, eventTypeBotMenuV6)
-	}
-	if out.EventID != "ev_menu_001" {
-		t.Errorf("EventID = %q", out.EventID)
-	}
-	if out.Timestamp != "1776409469273" {
-		t.Errorf("Timestamp = %q", out.Timestamp)
-	}
-	if out.EventKey != "start_eval" {
-		t.Errorf("EventKey = %q", out.EventKey)
-	}
-	if out.MenuTimestamp != "1776409469000" {
-		t.Errorf("MenuTimestamp = %q", out.MenuTimestamp)
-	}
-	if out.OperatorID != "ou_operator" || out.OperatorOpenID != "ou_operator" {
-		t.Errorf("OperatorID/OperatorOpenID = %q/%q", out.OperatorID, out.OperatorOpenID)
-	}
-	if out.OperatorUnionID != "on_operator" {
-		t.Errorf("OperatorUnionID = %q", out.OperatorUnionID)
-	}
-	if out.OperatorUserID != "user_operator" {
-		t.Errorf("OperatorUserID = %q", out.OperatorUserID)
-	}
-	if out.OperatorName != "Test User" {
-		t.Errorf("OperatorName = %q", out.OperatorName)
-	}
-	if out.AppID != "cli_test" || out.TenantKey != "tenant_test" {
-		t.Errorf("AppID/TenantKey = %q/%q", out.AppID, out.TenantKey)
-	}
-}
-
-func TestProcessBotMenuStringTimestampFallback(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_002",
-			"event_type": "application.bot.menu_v6"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"timestamp": "1776409469001",
-			"operator": {
-				"operator_id": {"open_id": "ou_operator"}
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Timestamp != "1776409469001" {
-		t.Errorf("Timestamp fallback = %q", out.Timestamp)
-	}
-	if out.MenuTimestamp != "1776409469001" {
-		t.Errorf("MenuTimestamp = %q", out.MenuTimestamp)
-	}
-}
-
-func TestProcessBotMenuSecondsTimestampFallback(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_seconds",
-			"event_type": "application.bot.menu_v6"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"timestamp": 1694592375,
-			"operator": {
-				"operator_id": {"open_id": "ou_operator"}
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Timestamp != "1694592375000" {
-		t.Errorf("Timestamp fallback = %q, want seconds normalized to milliseconds", out.Timestamp)
-	}
-	if out.MenuTimestamp != "1694592375000" {
-		t.Errorf("MenuTimestamp = %q, want seconds normalized to milliseconds", out.MenuTimestamp)
-	}
-}
-
-func TestProcessBotMenuTypeUsesLocalConstant(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_menu_003",
-			"event_type": "unexpected.event_type",
-			"create_time": "1776409469275"
-		},
-		"event": {
-			"event_key": "start_eval",
-			"operator": {
-				"operator_id": {"open_id": "ou_operator"}
-			}
-		}
-	}`
-	out := runBotMenu(t, payload)
-
-	if out.Type != eventTypeBotMenuV6 {
-		t.Errorf("Type = %q, want %q", out.Type, eventTypeBotMenuV6)
-	}
-}
-
-func TestProcessBotMenuMalformedPayload(t *testing.T) {
-	raw := &event.RawEvent{
-		EventID:   "ev_bad",
-		EventType: eventTypeBotMenuV6,
-		Payload:   json.RawMessage(`not json`),
-		Timestamp: time.Now(),
-	}
-	got, err := processBotMenu(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("Process should swallow parse errors, got %v", err)
-	}
-	if string(got) != "not json" {
-		t.Errorf("malformed fallback output = %q, want original bytes", string(got))
-	}
-}
-
-func runBotMenu(t *testing.T, payload string) BotMenuOutput {
-	t.Helper()
-	raw := &event.RawEvent{
-		EventID:   "ev_test",
-		EventType: eventTypeBotMenuV6,
-		Payload:   json.RawMessage(payload),
-		Timestamp: time.Now(),
-	}
-	got, err := processBotMenu(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("processBotMenu: %v", err)
-	}
-	var out BotMenuOutput
-	if err := json.Unmarshal(got, &out); err != nil {
-		t.Fatalf("unmarshal output: %v\n%s", err, got)
-	}
-	return out
-}
--- a/events/application/register.go
+++ b/events/application/register.go
@@ -1,31 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package application registers Application-domain EventKeys.
-package application
-
-import (
-	"reflect"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-const eventTypeBotMenuV6 = "application.bot.menu_v6"
-
-// Keys returns all Application-domain EventKey definitions.
-func Keys() []event.KeyDefinition {
-	return []event.KeyDefinition{
-		{
-			Key:         eventTypeBotMenuV6,
-			DisplayName: "Bot menu",
-			Description: "Triggered when a user clicks a custom bot menu item whose action is configured as a push event.",
-			EventType:   eventTypeBotMenuV6,
-			Schema: event.SchemaDef{
-				Custom: &event.SchemaSpec{Type: reflect.TypeOf(BotMenuOutput{})},
-			},
-			Process:               processBotMenu,
-			AuthTypes:             []string{"bot"},
-			RequiredConsoleEvents: []string{eventTypeBotMenuV6},
-		},
-	}
-}
--- a/events/approval/preconsume.go
+++ b/events/approval/preconsume.go
@@ -1,155 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package approval
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/event"
-)
-
-type approvalEventType string
-type approvalSubscriptionPath string
-
-type approvalSubscriptionConfig struct {
-	eventType     approvalEventType
-	subscribePath approvalSubscriptionPath
-}
-
-func approvalSubscriptionPreConsume(cfg approvalSubscriptionConfig) func(context.Context, event.APIClient, map[string]string) (func() error, error) {
-	return func(ctx context.Context, rt event.APIClient, params map[string]string) (func() error, error) {
-		if rt == nil {
-			return nil, errs.NewInternalError(errs.SubtypeUnknown,
-				"runtime API client is required for pre-consume subscription")
-		}
-
-		eventType := string(cfg.eventType)
-		subscribePath := string(cfg.subscribePath)
-		subscriptionTypes, err := approvalSubscriptionTypes(eventType, params)
-		if err != nil {
-			return nil, err
-		}
-
-		registered := make([]string, 0, len(subscriptionTypes))
-		for _, subscriptionType := range subscriptionTypes {
-			body := map[string]string{"subscription_type": subscriptionType}
-			if _, err := rt.CallAPI(ctx, "POST", subscribePath, body); err != nil {
-				return nil, approvalSubscriptionRegistrationError(eventType, registered, subscriptionType, err)
-			}
-			registered = append(registered, subscriptionType)
-		}
-
-		// Approval subscriptions are durable user-auth relations. Consuming events
-		// should not cancel that relation when this local process exits.
-		return nil, nil
-	}
-}
-
-func approvalSubscriptionTypes(eventType string, params map[string]string) ([]string, error) {
-	raw := strings.TrimSpace(params["subscription_type"])
-	if raw == "" {
-		return append([]string(nil), approvalAllSubscriptionTypes...), nil
-	}
-
-	values, err := parseApprovalSubscriptionTypeValues(raw)
-	if err != nil {
-		return nil, invalidApprovalSubscriptionTypeError(eventType, raw)
-	}
-
-	selected := make(map[string]bool, len(values))
-	for _, value := range values {
-		value = strings.TrimSpace(value)
-		switch value {
-		case approvalSubscriptionTypeInvolved, approvalSubscriptionTypeManaged:
-			selected[value] = true
-		default:
-			return nil, invalidApprovalSubscriptionTypeError(eventType, value)
-		}
-	}
-
-	result := make([]string, 0, len(selected))
-	for _, value := range approvalAllSubscriptionTypes {
-		if selected[value] {
-			result = append(result, value)
-		}
-	}
-	if len(result) == 0 {
-		return nil, invalidApprovalSubscriptionTypeError(eventType, raw)
-	}
-	return result, nil
-}
-
-func parseApprovalSubscriptionTypeValues(raw string) ([]string, error) {
-	if strings.HasPrefix(raw, "[") {
-		var values []string
-		if err := json.Unmarshal([]byte(raw), &values); err != nil {
-			return nil, err
-		}
-		return values, nil
-	}
-	return strings.Split(raw, ","), nil
-}
-
-func approvalSubscriptionRegistrationError(eventType string, registered []string, failed string, err error) error {
-	if err == nil {
-		return nil
-	}
-
-	msg := fmt.Sprintf(
-		"approval subscription pre-consume failed for EventKey %s: failed subscription_type %s",
-		eventType,
-		failed,
-	)
-	hint := fmt.Sprintf(
-		"no approval subscription relation was registered for EventKey %s; fix the cause and retry",
-		eventType,
-	)
-	if len(registered) > 0 {
-		msg = fmt.Sprintf(
-			"approval subscription pre-consume partially completed for EventKey %s: registered subscription_type(s) [%s], failed subscription_type %s",
-			eventType,
-			strings.Join(registered, ", "),
-			failed,
-		)
-		hint = fmt.Sprintf(
-			"server-side approval subscription relation(s) already registered for EventKey %s: %s; after fixing the cause, retry with --param subscription_type=%s to register the failed relation",
-			eventType,
-			strings.Join(registered, ", "),
-			failed,
-		)
-	}
-
-	if p, ok := errs.ProblemOf(err); ok {
-		if upstream := strings.TrimSpace(p.Message); upstream != "" {
-			p.Message = msg + ": " + upstream
-		} else {
-			p.Message = msg
-		}
-		if upstreamHint := strings.TrimSpace(p.Hint); upstreamHint != "" {
-			p.Hint = upstreamHint + "\n" + hint
-		} else {
-			p.Hint = hint
-		}
-		return err
-	}
-	return errs.NewInternalError(errs.SubtypeSDKError, "%s: %v", msg, err).
-		WithHint("%s", hint).
-		WithCause(err)
-}
-
-func invalidApprovalSubscriptionTypeError(eventType, value string) error {
-	return errs.NewValidationError(errs.SubtypeInvalidArgument,
-		"invalid subscription_type for EventKey %s: %q", eventType, value).
-		WithParam("--param").
-		WithHint("omit subscription_type to register both approval subscription relations, or pass --param subscription_type=%s, --param subscription_type=%s, or --param subscription_type=%s,%s; run `lark-cli event schema %s` for details",
-			approvalSubscriptionTypeInvolved,
-			approvalSubscriptionTypeManaged,
-			approvalSubscriptionTypeInvolved,
-			approvalSubscriptionTypeManaged,
-			eventType)
-}
--- a/events/approval/register.go
+++ b/events/approval/register.go
@@ -1,179 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package approval registers Approval-domain EventKeys.
-package approval
-
-import (
-	"context"
-	"encoding/json"
-	"reflect"
-
-	"github.com/larksuite/cli/internal/event"
-)
-
-const (
-	eventTypeApprovalInstanceStatusChangedV4 = "approval.instance.status_changed_v4"
-	eventTypeApprovalTaskStatusChangedV4     = "approval.task.status_changed_v4"
-
-	pathApprovalInstancesSubscription = "/open-apis/approval/v4/instances/subscription"
-	pathApprovalTasksSubscription     = "/open-apis/approval/v4/tasks/subscription"
-
-	approvalSubscriptionTypeInvolved = "INVOLVED_APPROVAL"
-	approvalSubscriptionTypeManaged  = "MANAGED_APPROVAL"
-)
-
-var approvalAllSubscriptionTypes = []string{
-	approvalSubscriptionTypeInvolved,
-	approvalSubscriptionTypeManaged,
-}
-
-// Keys returns all Approval-domain EventKey definitions.
-func Keys() []event.KeyDefinition {
-	return []event.KeyDefinition{
-		{
-			Key:         eventTypeApprovalInstanceStatusChangedV4,
-			DisplayName: "Approval instance status changed",
-			Description: "Triggered after an approval instance status becomes visible to the requester or approval participants",
-			EventType:   eventTypeApprovalInstanceStatusChangedV4,
-			Params:      approvalSubscriptionParams(),
-			Schema: event.SchemaDef{
-				Custom: &event.SchemaSpec{Type: reflect.TypeOf(ApprovalInstanceStatusChangedV4Output{})},
-			},
-			Process: processApprovalInstanceStatusChanged,
-			PreConsume: approvalSubscriptionPreConsume(approvalSubscriptionConfig{
-				eventType:     eventTypeApprovalInstanceStatusChangedV4,
-				subscribePath: pathApprovalInstancesSubscription,
-			}),
-			Scopes: []string{"approval:instance:read"},
-			AuthTypes: []string{
-				"user",
-			},
-			RequiredConsoleEvents: []string{eventTypeApprovalInstanceStatusChangedV4},
-		},
-		{
-			Key:         eventTypeApprovalTaskStatusChangedV4,
-			DisplayName: "Approval task status changed",
-			Description: "Triggered after an approval task status becomes visible to the requester or task approver",
-			EventType:   eventTypeApprovalTaskStatusChangedV4,
-			Params:      approvalSubscriptionParams(),
-			Schema: event.SchemaDef{
-				Custom: &event.SchemaSpec{Type: reflect.TypeOf(ApprovalTaskStatusChangedV4Output{})},
-			},
-			Process: processApprovalTaskStatusChanged,
-			PreConsume: approvalSubscriptionPreConsume(approvalSubscriptionConfig{
-				eventType:     eventTypeApprovalTaskStatusChangedV4,
-				subscribePath: pathApprovalTasksSubscription,
-			}),
-			Scopes: []string{"approval:task:read"},
-			AuthTypes: []string{
-				"user",
-			},
-			RequiredConsoleEvents: []string{eventTypeApprovalTaskStatusChangedV4},
-		},
-	}
-}
-
-func approvalSubscriptionParams() []event.ParamDef {
-	return []event.ParamDef{
-		{
-			Name:        "subscription_type",
-			Type:        event.ParamMulti,
-			Description: "Approval subscription relation type(s) to register for the current authorized user. Omit to register both involved and managed approval relations.",
-			Values: []event.ParamValue{
-				{
-					Value: approvalSubscriptionTypeInvolved,
-					Desc:  "Receive events where the current user is the approval requester or approver.",
-				},
-				{
-					Value: approvalSubscriptionTypeManaged,
-					Desc:  "Receive events under approval definitions managed by the current user.",
-				},
-			},
-		},
-	}
-}
-
-func processApprovalInstanceStatusChanged(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
-	if raw == nil {
-		return nil, nil
-	}
-	var envelope struct {
-		Header struct {
-			EventID    string `json:"event_id"`
-			EventType  string `json:"event_type"`
-			CreateTime string `json:"create_time"`
-		} `json:"header"`
-		Event struct {
-			ApprovalCode string          `json:"approval_code"`
-			InstanceCode string          `json:"instance_code"`
-			ExternalID   string          `json:"external_id"`
-			Status       string          `json:"status"`
-			OperateTime  string          `json:"operate_time"`
-			StartUser    *ApprovalUserID `json:"start_user"`
-		} `json:"event"`
-	}
-	if err := json.Unmarshal(raw.Payload, &envelope); err != nil {
-		return raw.Payload, nil //nolint:nilerr // passthrough on malformed payload so consumers still see the event
-	}
-
-	out := &ApprovalInstanceStatusChangedV4Output{
-		Type:         envelope.Header.EventType,
-		EventID:      envelope.Header.EventID,
-		Timestamp:    envelope.Header.CreateTime,
-		ApprovalCode: envelope.Event.ApprovalCode,
-		InstanceCode: envelope.Event.InstanceCode,
-		ExternalID:   envelope.Event.ExternalID,
-		Status:       envelope.Event.Status,
-		OperateTime:  envelope.Event.OperateTime,
-		StartUser:    envelope.Event.StartUser,
-	}
-	if out.Type == "" {
-		out.Type = raw.EventType
-	}
-	return json.Marshal(out)
-}
-
-func processApprovalTaskStatusChanged(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
-	if raw == nil {
-		return nil, nil
-	}
-	var envelope struct {
-		Header struct {
-			EventID    string `json:"event_id"`
-			EventType  string `json:"event_type"`
-			CreateTime string `json:"create_time"`
-		} `json:"header"`
-		Event struct {
-			ApprovalCode   string          `json:"approval_code"`
-			InstanceCode   string          `json:"instance_code"`
-			TaskID         string          `json:"task_id"`
-			ExternalID     string          `json:"external_id"`
-			TaskExternalID string          `json:"task_external_id"`
-			AssignedUser   *ApprovalUserID `json:"assigned_user"`
-			Status         string          `json:"status"`
-			OperateTime    string          `json:"operate_time"`
-		} `json:"event"`
-	}
-	if err := json.Unmarshal(raw.Payload, &envelope); err != nil {
-		return raw.Payload, nil //nolint:nilerr // passthrough on malformed payload so consumers still see the event
-	}
-
-	out := &ApprovalTaskStatusChangedV4Output{
-		Type:           envelope.Header.EventType,
-		EventID:        envelope.Header.EventID,
-		Timestamp:      envelope.Header.CreateTime,
-		ApprovalCode:   envelope.Event.ApprovalCode,
-		InstanceCode:   envelope.Event.InstanceCode,
-		TaskID:         envelope.Event.TaskID,
-		ExternalID:     envelope.Event.ExternalID,
-		TaskExternalID: envelope.Event.TaskExternalID,
-		AssignedUser:   envelope.Event.AssignedUser,
-		Status:         envelope.Event.Status,
-		OperateTime:    envelope.Event.OperateTime,
-	}
-	if out.Type == "" {
-		out.Type = raw.EventType
-	}
-	return json.Marshal(out)
-}
--- a/events/approval/register_test.go
+++ b/events/approval/register_test.go
@@ -1,654 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package approval
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/event"
-	"github.com/larksuite/cli/internal/event/schemas"
-)
-
-type recordedCall struct {
-	method string
-	path   string
-	body   interface{}
-}
-
-type fakeAPIClient struct {
-	calls     []recordedCall
-	err       error
-	errOnCall int
-}
-
-func (f *fakeAPIClient) CallAPI(_ context.Context, method, path string, body interface{}) (json.RawMessage, error) {
-	f.calls = append(f.calls, recordedCall{method: method, path: path, body: body})
-	if f.err != nil && (f.errOnCall == 0 || f.errOnCall == len(f.calls)) {
-		return nil, f.err
-	}
-	return json.RawMessage(`{}`), nil
-}
-
-func TestKeysApprovalMetadata(t *testing.T) {
-	keys := Keys()
-	if len(keys) != 2 {
-		t.Fatalf("len(Keys()) = %d, want 2", len(keys))
-	}
-
-	tests := []struct {
-		key        string
-		scope      string
-		schemaType reflect.Type
-		subscribe  string
-	}{
-		{
-			key:        eventTypeApprovalInstanceStatusChangedV4,
-			scope:      "approval:instance:read",
-			schemaType: reflect.TypeOf(ApprovalInstanceStatusChangedV4Output{}),
-			subscribe:  pathApprovalInstancesSubscription,
-		},
-		{
-			key:        eventTypeApprovalTaskStatusChangedV4,
-			scope:      "approval:task:read",
-			schemaType: reflect.TypeOf(ApprovalTaskStatusChangedV4Output{}),
-			subscribe:  pathApprovalTasksSubscription,
-		},
-	}
-
-	byKey := make(map[string]event.KeyDefinition, len(keys))
-	for _, def := range keys {
-		byKey[def.Key] = def
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.key, func(t *testing.T) {
-			def, ok := byKey[tc.key]
-			if !ok {
-				t.Fatalf("missing key %s", tc.key)
-			}
-			if def.EventType != tc.key {
-				t.Errorf("EventType = %q, want %q", def.EventType, tc.key)
-			}
-			if def.Schema.Custom == nil || def.Schema.Custom.Type != tc.schemaType {
-				t.Fatalf("Custom schema Type = %v, want %v", def.Schema.Custom, tc.schemaType)
-			}
-			if def.Schema.Native != nil {
-				t.Fatal("approval events must use Custom schema while SDK event types are not exported")
-			}
-			if def.Process == nil {
-				t.Fatal("Process must flatten raw V2 envelopes")
-			}
-			if def.PreConsume == nil {
-				t.Fatal("PreConsume must subscribe approval user-auth events")
-			}
-			if !reflect.DeepEqual(def.Scopes, []string{tc.scope}) {
-				t.Errorf("Scopes = %#v, want %q", def.Scopes, tc.scope)
-			}
-			if !reflect.DeepEqual(def.AuthTypes, []string{"user"}) {
-				t.Errorf("AuthTypes = %#v, want user", def.AuthTypes)
-			}
-			if !reflect.DeepEqual(def.RequiredConsoleEvents, []string{tc.key}) {
-				t.Errorf("RequiredConsoleEvents = %#v, want %q", def.RequiredConsoleEvents, tc.key)
-			}
-			assertSubscriptionParam(t, def.Params)
-		})
-	}
-}
-
-func assertSubscriptionParam(t *testing.T, params []event.ParamDef) {
-	t.Helper()
-	if len(params) != 1 {
-		t.Fatalf("len(params) = %d, want 1", len(params))
-	}
-	p := params[0]
-	if p.Name != "subscription_type" || p.Type != event.ParamMulti || p.Required || p.SubscriptionKey {
-		t.Fatalf("subscription_type param = %+v, want optional multi non-subscription-key param", p)
-	}
-	got := map[string]string{}
-	for _, v := range p.Values {
-		got[v.Value] = v.Desc
-	}
-	for _, want := range []string{approvalSubscriptionTypeInvolved, approvalSubscriptionTypeManaged} {
-		if got[want] == "" {
-			t.Errorf("subscription_type value %q missing or empty desc; values=%+v", want, p.Values)
-		}
-	}
-}
-
-type reflectedApprovalSchema struct {
-	Properties map[string]reflectedApprovalSchemaProperty `json:"properties"`
-}
-
-type reflectedApprovalSchemaProperty struct {
-	Format     string                                     `json:"format"`
-	Enum       []string                                   `json:"enum"`
-	Properties map[string]reflectedApprovalSchemaProperty `json:"properties"`
-}
-
-func TestApprovalSchemasAnnotations(t *testing.T) {
-	tests := []struct {
-		name         string
-		schemaType   reflect.Type
-		eventType    string
-		statusValues []string
-		userField    string
-	}{
-		{
-			name:         "instance",
-			schemaType:   reflect.TypeOf(ApprovalInstanceStatusChangedV4Output{}),
-			eventType:    eventTypeApprovalInstanceStatusChangedV4,
-			statusValues: []string{"PENDING", "APPROVED", "REJECTED", "CANCELED", "DELETED", "REVERTED", "OVERTIME_CLOSE", "OVERTIME_RECOVER"},
-			userField:    "start_user",
-		},
-		{
-			name:         "task",
-			schemaType:   reflect.TypeOf(ApprovalTaskStatusChangedV4Output{}),
-			eventType:    eventTypeApprovalTaskStatusChangedV4,
-			statusValues: []string{"REVERTED", "PENDING", "APPROVED", "REJECTED", "TRANSFERRED", "ROLLBACK", "DONE", "OVERTIME_CLOSE", "OVERTIME_RECOVER"},
-			userField:    "assigned_user",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			var schema reflectedApprovalSchema
-			if err := json.Unmarshal(schemas.FromType(tc.schemaType), &schema); err != nil {
-				t.Fatalf("unmarshal schema: %v", err)
-			}
-			props := schema.Properties
-			eventTypeEnum := props["type"].Enum
-			if len(eventTypeEnum) != 1 || eventTypeEnum[0] != tc.eventType {
-				t.Fatalf("type enum = %v, want %s", eventTypeEnum, tc.eventType)
-			}
-			if got := props["timestamp"].Format; got != "timestamp_ms" {
-				t.Errorf("timestamp format = %v, want timestamp_ms", got)
-			}
-			assertEnumContains(t, props["status"].Enum, tc.statusValues)
-			if got := props["operate_time"].Format; got != "timestamp_ms" {
-				t.Errorf("event.operate_time format = %v, want timestamp_ms", got)
-			}
-
-			userProps := props[tc.userField].Properties
-			if got := userProps["open_id"].Format; got != "open_id" {
-				t.Errorf("%s.open_id format = %v, want open_id", tc.userField, got)
-			}
-			if got := userProps["union_id"].Format; got != "union_id" {
-				t.Errorf("%s.union_id format = %v, want union_id", tc.userField, got)
-			}
-			if got := userProps["user_id"].Format; got != "user_id" {
-				t.Errorf("%s.user_id format = %v, want user_id", tc.userField, got)
-			}
-		})
-	}
-}
-
-func assertEnumContains(t *testing.T, raw []string, wants []string) {
-	t.Helper()
-	got := make(map[string]bool, len(raw))
-	for _, v := range raw {
-		got[v] = true
-	}
-	for _, want := range wants {
-		if !got[want] {
-			t.Errorf("enum missing %q; enum=%v", want, raw)
-		}
-	}
-}
-
-func TestApprovalPreConsumeRegistersSubscriptionTypesWithoutCleanup(t *testing.T) {
-	tests := []struct {
-		name          string
-		eventType     string
-		subscribePath string
-		params        map[string]string
-		wantTypes     []string
-	}{
-		{
-			name:          "instance omitted subscription_type registers both",
-			eventType:     eventTypeApprovalInstanceStatusChangedV4,
-			subscribePath: pathApprovalInstancesSubscription,
-			wantTypes: []string{
-				approvalSubscriptionTypeInvolved,
-				approvalSubscriptionTypeManaged,
-			},
-		},
-		{
-			name:          "task explicit single managed",
-			eventType:     eventTypeApprovalTaskStatusChangedV4,
-			subscribePath: pathApprovalTasksSubscription,
-			params:        map[string]string{"subscription_type": approvalSubscriptionTypeManaged},
-			wantTypes:     []string{approvalSubscriptionTypeManaged},
-		},
-		{
-			name:          "task comma separated multi canonicalizes and deduplicates",
-			eventType:     eventTypeApprovalTaskStatusChangedV4,
-			subscribePath: pathApprovalTasksSubscription,
-			params: map[string]string{
-				"subscription_type": approvalSubscriptionTypeManaged + "," + approvalSubscriptionTypeInvolved + "," + approvalSubscriptionTypeManaged,
-			},
-			wantTypes: []string{
-				approvalSubscriptionTypeInvolved,
-				approvalSubscriptionTypeManaged,
-			},
-		},
-		{
-			name:          "instance json array multi",
-			eventType:     eventTypeApprovalInstanceStatusChangedV4,
-			subscribePath: pathApprovalInstancesSubscription,
-			params: map[string]string{
-				"subscription_type": `["MANAGED_APPROVAL","INVOLVED_APPROVAL"]`,
-			},
-			wantTypes: []string{
-				approvalSubscriptionTypeInvolved,
-				approvalSubscriptionTypeManaged,
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			pc := approvalSubscriptionPreConsume(approvalSubscriptionConfig{
-				eventType:     approvalEventType(tc.eventType),
-				subscribePath: approvalSubscriptionPath(tc.subscribePath),
-			})
-			rt := &fakeAPIClient{}
-			cleanup, err := pc(context.Background(), rt, tc.params)
-			if err != nil {
-				t.Fatalf("PreConsume returned error: %v", err)
-			}
-			if cleanup != nil {
-				t.Fatal("cleanup must be nil; approval consume must not unsubscribe on exit")
-			}
-			assertSubscriptionCalls(t, rt.calls, tc.subscribePath, tc.wantTypes)
-		})
-	}
-}
-
-func assertSubscriptionCalls(t *testing.T, got []recordedCall, wantPath string, wantTypes []string) {
-	t.Helper()
-	if len(got) != len(wantTypes) {
-		t.Fatalf("calls after pre-consume = %d, want %d; calls=%+v", len(got), len(wantTypes), got)
-	}
-	for i, wantType := range wantTypes {
-		assertCall(t, got[i], "POST", wantPath, map[string]string{"subscription_type": wantType})
-	}
-}
-
-func assertCall(t *testing.T, got recordedCall, wantMethod, wantPath string, wantBody interface{}) {
-	t.Helper()
-	if got.method != wantMethod {
-		t.Errorf("method = %q, want %q", got.method, wantMethod)
-	}
-	if got.path != wantPath {
-		t.Errorf("path = %q, want %q", got.path, wantPath)
-	}
-	if !reflect.DeepEqual(got.body, wantBody) {
-		t.Errorf("body = %#v, want %#v", got.body, wantBody)
-	}
-}
-
-func TestApprovalPreConsumeValidationErrors(t *testing.T) {
-	t.Run("nil runtime", func(t *testing.T) {
-		pc := approvalSubscriptionPreConsume(approvalSubscriptionConfig{
-			eventType: eventTypeApprovalInstanceStatusChangedV4,
-		})
-		_, err := pc(context.Background(), nil, map[string]string{"subscription_type": approvalSubscriptionTypeInvolved})
-		if err == nil {
-			t.Fatal("expected nil runtime error")
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok || p.Category != errs.CategoryInternal {
-			t.Fatalf("err = %T/%v, want typed internal error", err, err)
-		}
-	})
-
-	for _, raw := range []string{"BAD", "[]", `["INVOLVED_APPROVAL",3]`} {
-		t.Run("invalid subscription type "+raw, func(t *testing.T) {
-			pc := approvalSubscriptionPreConsume(approvalSubscriptionConfig{
-				eventType: eventTypeApprovalInstanceStatusChangedV4,
-			})
-			cleanup, err := pc(context.Background(), &fakeAPIClient{}, map[string]string{"subscription_type": raw})
-			if err == nil {
-				t.Fatal("expected invalid subscription_type error")
-			}
-			if cleanup != nil {
-				t.Fatal("cleanup must be nil on validation error")
-			}
-			var ve *errs.ValidationError
-			if !errors.As(err, &ve) {
-				t.Fatalf("err = %T/%v, want *errs.ValidationError", err, err)
-			}
-			if ve.Subtype != errs.SubtypeInvalidArgument || ve.Param != "--param" {
-				t.Errorf("subtype/param = %s/%q, want invalid_argument/--param", ve.Subtype, ve.Param)
-			}
-			if ve.Hint == "" {
-				t.Error("invalid subscription_type should carry a hint")
-			}
-		})
-	}
-
-	t.Run("partial registration failure reports registered and failed relation types", func(t *testing.T) {
-		upstream := errs.NewAPIError(errs.SubtypeServerError, "approval subscription API failed")
-		rt := &fakeAPIClient{err: upstream, errOnCall: 2}
-		pc := approvalSubscriptionPreConsume(approvalSubscriptionConfig{
-			eventType:     eventTypeApprovalTaskStatusChangedV4,
-			subscribePath: pathApprovalTasksSubscription,
-		})
-
-		cleanup, err := pc(context.Background(), rt, map[string]string{})
-		if err == nil {
-			t.Fatal("expected partial registration error")
-		}
-		if cleanup != nil {
-			t.Fatal("cleanup must be nil on registration error")
-		}
-		assertSubscriptionCalls(t, rt.calls, pathApprovalTasksSubscription, []string{
-			approvalSubscriptionTypeInvolved,
-			approvalSubscriptionTypeManaged,
-		})
-		p, ok := errs.ProblemOf(err)
-		if !ok {
-			t.Fatalf("err = %T/%v, want typed error", err, err)
-		}
-		if p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeServerError {
-			t.Fatalf("category/subtype = %s/%s, want api/server_error", p.Category, p.Subtype)
-		}
-		for _, want := range []string{
-			"registered subscription_type(s) [INVOLVED_APPROVAL]",
-			"failed subscription_type MANAGED_APPROVAL",
-		} {
-			if !strings.Contains(p.Message, want) {
-				t.Errorf("partial error message missing %q: %q", want, p.Message)
-			}
-		}
-		for _, want := range []string{
-			"already registered",
-			"--param subscription_type=MANAGED_APPROVAL",
-		} {
-			if !strings.Contains(p.Hint, want) {
-				t.Errorf("partial error hint missing %q: %q", want, p.Hint)
-			}
-		}
-	})
-}
-
-func TestApprovalSubscriptionRegistrationErrorVariants(t *testing.T) {
-	t.Run("nil error", func(t *testing.T) {
-		if err := approvalSubscriptionRegistrationError(eventTypeApprovalTaskStatusChangedV4, nil, approvalSubscriptionTypeInvolved, nil); err != nil {
-			t.Fatalf("nil cause returned error: %v", err)
-		}
-	})
-
-	t.Run("typed error with existing hint and empty message", func(t *testing.T) {
-		upstream := errs.NewAPIError(errs.SubtypeServerError, "").WithHint("retry later")
-		err := approvalSubscriptionRegistrationError(
-			eventTypeApprovalTaskStatusChangedV4,
-			nil,
-			approvalSubscriptionTypeInvolved,
-			upstream,
-		)
-		if err != upstream {
-			t.Fatalf("typed error should be annotated in place; got %T/%v", err, err)
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok {
-			t.Fatalf("err = %T/%v, want typed error", err, err)
-		}
-		if !strings.Contains(p.Message, "failed subscription_type INVOLVED_APPROVAL") {
-			t.Errorf("message missing failed relation: %q", p.Message)
-		}
-		for _, want := range []string{"retry later", "no approval subscription relation was registered"} {
-			if !strings.Contains(p.Hint, want) {
-				t.Errorf("hint missing %q: %q", want, p.Hint)
-			}
-		}
-	})
-
-	t.Run("untyped error is wrapped with retry context", func(t *testing.T) {
-		cause := errors.New("transport closed")
-		err := approvalSubscriptionRegistrationError(
-			eventTypeApprovalTaskStatusChangedV4,
-			nil,
-			approvalSubscriptionTypeInvolved,
-			cause,
-		)
-		if !errors.Is(err, cause) {
-			t.Fatalf("wrapped error should preserve cause; got %T/%v", err, err)
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok {
-			t.Fatalf("err = %T/%v, want typed error", err, err)
-		}
-		if p.Category != errs.CategoryInternal || p.Subtype != errs.SubtypeSDKError {
-			t.Fatalf("category/subtype = %s/%s, want internal/sdk_error", p.Category, p.Subtype)
-		}
-		if !strings.Contains(p.Hint, "no approval subscription relation was registered") {
-			t.Errorf("hint missing no-registration context: %q", p.Hint)
-		}
-	})
-}
-
-func TestProcessApprovalInstanceStatusChanged(t *testing.T) {
-	out := runApprovalInstanceStatusChanged(t, `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "evt_approval_instance_001",
-			"event_type": "approval.instance.status_changed_v4",
-			"create_time": "1710000000000"
-		},
-		"event": {
-			"approval_code": "approval_code_001",
-			"instance_code": "instance_code_001",
-			"external_id": "external_001",
-			"status": "PENDING",
-			"operate_time": "1666079207003",
-			"start_user": {
-				"open_id": "ou_start",
-				"union_id": "on_start",
-				"user_id": "user_start"
-			}
-		}
-	}`)
-
-	if out.Type != eventTypeApprovalInstanceStatusChangedV4 {
-		t.Errorf("Type = %q, want %q", out.Type, eventTypeApprovalInstanceStatusChangedV4)
-	}
-	if out.EventID != "evt_approval_instance_001" || out.Timestamp != "1710000000000" {
-		t.Errorf("EventID/Timestamp = %q/%q", out.EventID, out.Timestamp)
-	}
-	if out.ApprovalCode != "approval_code_001" || out.InstanceCode != "instance_code_001" {
-		t.Errorf("approval/instance code = %q/%q", out.ApprovalCode, out.InstanceCode)
-	}
-	if out.ExternalID != "external_001" || out.Status != "PENDING" || out.OperateTime != "1666079207003" {
-		t.Errorf("external/status/operate_time = %q/%q/%q", out.ExternalID, out.Status, out.OperateTime)
-	}
-	if out.StartUser == nil || out.StartUser.OpenID != "ou_start" || out.StartUser.UnionID != "on_start" || out.StartUser.UserID != "user_start" {
-		t.Fatalf("StartUser = %+v, want full user ids", out.StartUser)
-	}
-}
-
-func TestProcessApprovalTaskStatusChanged(t *testing.T) {
-	out := runApprovalTaskStatusChanged(t, `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "evt_approval_task_001",
-			"event_type": "approval.task.status_changed_v4",
-			"create_time": "1710000000001"
-		},
-		"event": {
-			"approval_code": "approval_code_002",
-			"instance_code": "instance_code_002",
-			"task_id": "task_001",
-			"external_id": "external_002",
-			"task_external_id": "task_external_001",
-			"status": "APPROVED",
-			"operate_time": "1666079207004",
-			"assigned_user": {
-				"open_id": "ou_assignee",
-				"union_id": "on_assignee",
-				"user_id": "user_assignee"
-			}
-		}
-	}`)
-
-	if out.Type != eventTypeApprovalTaskStatusChangedV4 {
-		t.Errorf("Type = %q, want %q", out.Type, eventTypeApprovalTaskStatusChangedV4)
-	}
-	if out.EventID != "evt_approval_task_001" || out.Timestamp != "1710000000001" {
-		t.Errorf("EventID/Timestamp = %q/%q", out.EventID, out.Timestamp)
-	}
-	if out.ApprovalCode != "approval_code_002" || out.InstanceCode != "instance_code_002" || out.TaskID != "task_001" {
-		t.Errorf("approval/instance/task = %q/%q/%q", out.ApprovalCode, out.InstanceCode, out.TaskID)
-	}
-	if out.ExternalID != "external_002" || out.TaskExternalID != "task_external_001" || out.Status != "APPROVED" || out.OperateTime != "1666079207004" {
-		t.Errorf("external/task_external/status/operate_time = %q/%q/%q/%q", out.ExternalID, out.TaskExternalID, out.Status, out.OperateTime)
-	}
-	if out.AssignedUser == nil || out.AssignedUser.OpenID != "ou_assignee" || out.AssignedUser.UnionID != "on_assignee" || out.AssignedUser.UserID != "user_assignee" {
-		t.Fatalf("AssignedUser = %+v, want full user ids", out.AssignedUser)
-	}
-}
-
-func TestProcessApprovalStatusChangedUsesRawEventTypeFallback(t *testing.T) {
-	instance := runApprovalInstanceStatusChanged(t, `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "evt_approval_instance_fallback",
-			"create_time": "1710000000002"
-		},
-		"event": {
-			"approval_code": "approval_code_fallback",
-			"instance_code": "instance_code_fallback",
-			"status": "APPROVED",
-			"operate_time": "1666079207005"
-		}
-	}`)
-	if instance.Type != eventTypeApprovalInstanceStatusChangedV4 {
-		t.Errorf("instance Type fallback = %q, want %q", instance.Type, eventTypeApprovalInstanceStatusChangedV4)
-	}
-
-	task := runApprovalTaskStatusChanged(t, `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "evt_approval_task_fallback",
-			"create_time": "1710000000003"
-		},
-		"event": {
-			"approval_code": "approval_code_fallback",
-			"instance_code": "instance_code_fallback",
-			"task_id": "task_fallback",
-			"status": "DONE",
-			"operate_time": "1666079207006"
-		}
-	}`)
-	if task.Type != eventTypeApprovalTaskStatusChangedV4 {
-		t.Errorf("task Type fallback = %q, want %q", task.Type, eventTypeApprovalTaskStatusChangedV4)
-	}
-}
-
-func TestProcessApprovalStatusChangedMalformedPayloadPassthrough(t *testing.T) {
-	for _, tc := range []struct {
-		name      string
-		eventType string
-		process   event.ProcessFunc
-	}{
-		{"instance", eventTypeApprovalInstanceStatusChangedV4, processApprovalInstanceStatusChanged},
-		{"task", eventTypeApprovalTaskStatusChangedV4, processApprovalTaskStatusChanged},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			raw := &event.RawEvent{
-				EventType: tc.eventType,
-				Payload:   json.RawMessage(`not json`),
-				Timestamp: time.Now(),
-			}
-			got, err := tc.process(context.Background(), nil, raw, nil)
-			if err != nil {
-				t.Fatalf("Process should swallow parse errors, got %v", err)
-			}
-			if string(got) != "not json" {
-				t.Errorf("malformed fallback output = %q, want original bytes", string(got))
-			}
-		})
-	}
-}
-
-func TestProcessApprovalStatusChangedNilRaw(t *testing.T) {
-	for _, tc := range []struct {
-		name    string
-		process event.ProcessFunc
-	}{
-		{"instance", processApprovalInstanceStatusChanged},
-		{"task", processApprovalTaskStatusChanged},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := tc.process(context.Background(), nil, nil, nil)
-			if err != nil {
-				t.Fatalf("Process nil raw returned error: %v", err)
-			}
-			if got != nil {
-				t.Fatalf("Process nil raw output = %s, want nil", string(got))
-			}
-		})
-	}
-}
-
-func runApprovalInstanceStatusChanged(t *testing.T, payload string) ApprovalInstanceStatusChangedV4Output {
-	t.Helper()
-	raw := &event.RawEvent{
-		EventType: eventTypeApprovalInstanceStatusChangedV4,
-		Payload:   json.RawMessage(payload),
-		Timestamp: time.Now(),
-	}
-	got, err := processApprovalInstanceStatusChanged(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("Process returned error: %v", err)
-	}
-	var out ApprovalInstanceStatusChangedV4Output
-	if err := json.Unmarshal(got, &out); err != nil {
-		t.Fatalf("Process output is not valid instance JSON: %v\nraw=%s", err, string(got))
-	}
-	return out
-}
-
-func runApprovalTaskStatusChanged(t *testing.T, payload string) ApprovalTaskStatusChangedV4Output {
-	t.Helper()
-	raw := &event.RawEvent{
-		EventType: eventTypeApprovalTaskStatusChangedV4,
-		Payload:   json.RawMessage(payload),
-		Timestamp: time.Now(),
-	}
-	got, err := processApprovalTaskStatusChanged(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("Process returned error: %v", err)
-	}
-	var out ApprovalTaskStatusChangedV4Output
-	if err := json.Unmarshal(got, &out); err != nil {
-		t.Fatalf("Process output is not valid task JSON: %v\nraw=%s", err, string(got))
-	}
-	return out
-}
-
-func TestApprovalKeysRegisterCleanly(t *testing.T) {
-	for _, key := range []string{eventTypeApprovalInstanceStatusChangedV4, eventTypeApprovalTaskStatusChangedV4} {
-		event.UnregisterKeyForTest(key)
-		t.Cleanup(func() { event.UnregisterKeyForTest(key) })
-	}
-
-	for _, def := range Keys() {
-		event.RegisterKey(def)
-	}
-	for _, key := range []string{eventTypeApprovalInstanceStatusChangedV4, eventTypeApprovalTaskStatusChangedV4} {
-		if _, ok := event.Lookup(key); !ok {
-			t.Fatalf("event.Lookup(%q) not registered", key)
-		}
-	}
-}
-
-var _ event.APIClient = (*fakeAPIClient)(nil)
--- a/events/approval/types.go
+++ b/events/approval/types.go
@@ -1,42 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package approval
-
-// ApprovalUserID identifies a user in the three Lark ID formats included by
-// approval status-change events.
-type ApprovalUserID struct {
-	OpenID  string `json:"open_id,omitempty"  desc:"User open_id; prefixed with ou_" kind:"open_id"`
-	UnionID string `json:"union_id,omitempty" desc:"User union_id"                  kind:"union_id"`
-	UserID  string `json:"user_id,omitempty"  desc:"User id within the tenant"       kind:"user_id"`
-}
-
-// ApprovalInstanceStatusChangedV4Output is the flattened shape for
-// approval.instance.status_changed_v4.
-type ApprovalInstanceStatusChangedV4Output struct {
-	Type         string          `json:"type"                    desc:"Event type; always approval.instance.status_changed_v4" enum:"approval.instance.status_changed_v4"`
-	EventID      string          `json:"event_id,omitempty"      desc:"Globally unique event ID; safe for deduplication"`
-	Timestamp    string          `json:"timestamp,omitempty"     desc:"Event delivery time (ms timestamp string); taken from header.create_time when present" kind:"timestamp_ms"`
-	ApprovalCode string          `json:"approval_code,omitempty" desc:"Approval definition code; not a subscription dimension"`
-	InstanceCode string          `json:"instance_code,omitempty" desc:"Approval instance code"`
-	ExternalID   string          `json:"external_id,omitempty"   desc:"Third-party approval instance id; present only for third-party approvals"`
-	Status       string          `json:"status,omitempty"        desc:"Approval instance status" enum:"PENDING,APPROVED,REJECTED,CANCELED,DELETED,REVERTED,OVERTIME_CLOSE,OVERTIME_RECOVER"`
-	OperateTime  string          `json:"operate_time,omitempty"  desc:"Status change time in milliseconds" kind:"timestamp_ms"`
-	StartUser    *ApprovalUserID `json:"start_user,omitempty"    desc:"Approval instance starter; omitted when unavailable"`
-}
-
-// ApprovalTaskStatusChangedV4Output is the flattened shape for
-// approval.task.status_changed_v4.
-type ApprovalTaskStatusChangedV4Output struct {
-	Type           string          `json:"type"                      desc:"Event type; always approval.task.status_changed_v4" enum:"approval.task.status_changed_v4"`
-	EventID        string          `json:"event_id,omitempty"        desc:"Globally unique event ID; safe for deduplication"`
-	Timestamp      string          `json:"timestamp,omitempty"       desc:"Event delivery time (ms timestamp string); taken from header.create_time when present" kind:"timestamp_ms"`
-	ApprovalCode   string          `json:"approval_code,omitempty"     desc:"Approval definition code; not a subscription dimension"`
-	InstanceCode   string          `json:"instance_code,omitempty"     desc:"Approval instance code"`
-	TaskID         string          `json:"task_id,omitempty"           desc:"Approval task id"`
-	ExternalID     string          `json:"external_id,omitempty"       desc:"Third-party approval external id; present only for third-party approvals"`
-	TaskExternalID string          `json:"task_external_id,omitempty"  desc:"Third-party approval task external id; present only when emitted by the upstream service"`
-	AssignedUser   *ApprovalUserID `json:"assigned_user,omitempty"     desc:"Task assignee or operator user ids; omitted for automatic flows without an operator"`
-	Status         string          `json:"status,omitempty"            desc:"Approval task status" enum:"REVERTED,PENDING,APPROVED,REJECTED,TRANSFERRED,ROLLBACK,DONE,OVERTIME_CLOSE,OVERTIME_RECOVER"`
-	OperateTime    string          `json:"operate_time,omitempty"      desc:"Status change time in milliseconds" kind:"timestamp_ms"`
-}
--- a/events/im/message_receive.go
+++ b/events/im/message_receive.go
@@ -13,29 +13,17 @@ import (

 // ImMessageReceiveOutput is the flattened shape for im.message.receive_v1; `desc` tags drive the reflected schema.
 type ImMessageReceiveOutput struct {
-	Type        string          `json:"type"                   desc:"Event type; always im.message.receive_v1"`
-	EventID     string          `json:"event_id,omitempty"     desc:"Event delivery ID. Do not use as the message deduplication key; use message_id instead."`
-	Timestamp   string          `json:"timestamp,omitempty"    desc:"Event delivery time (ms timestamp string); prefers header.create_time"                                                                                                              kind:"timestamp_ms"`
-	ID          string          `json:"id,omitempty"           desc:"Message ID (legacy alias of message_id, kept for compatibility)"                                                                                                                     kind:"message_id"`
-	MessageID   string          `json:"message_id,omitempty"   desc:"Message ID; prefixed with om_. Recommended idempotency key for im.message.receive_v1 consumers."                                                                                     kind:"message_id"`
-	CreateTime  string          `json:"create_time,omitempty"  desc:"Message creation time (ms timestamp string)"                                                                                                                                         kind:"timestamp_ms"`
-	UpdateTime  string          `json:"update_time,omitempty"  desc:"Message update time (ms timestamp string); emitted only when different from create_time"                                                                                              kind:"timestamp_ms"`
-	ChatID      string          `json:"chat_id,omitempty"      desc:"Chat/conversation ID; prefixed with oc_"                                                                                                                                             kind:"chat_id"`
-	ChatType    string          `json:"chat_type,omitempty"    desc:"Conversation type"                                                                                                                                                                   enum:"p2p,group"`
-	MessageType string          `json:"message_type,omitempty" desc:"Message type"`
-	SenderID    string          `json:"sender_id,omitempty"    desc:"Sender open_id; prefixed with ou_"                                                                                                                                                   kind:"open_id"`
-	SenderType  string          `json:"sender_type,omitempty"  desc:"Sender type"                                                                                                                                                                         enum:"user,bot"`
-	RootID      string          `json:"root_id,omitempty"      desc:"Root message ID of the reply/thread context, when present"                                                                                                                           kind:"message_id"`
-	ThreadID    string          `json:"thread_id,omitempty"    desc:"Thread ID, when present"`
-	ReplyTo     string          `json:"reply_to,omitempty"     desc:"Parent message ID of the direct reply context, when present"                                                                                                                         kind:"message_id"`
-	Content     string          `json:"content,omitempty"      desc:"Message content. For most types (text/post/image/file/audio, etc.) this is pre-rendered human-readable text."`
-	Mentions    []MentionOutput `json:"mentions,omitempty" desc:"Compact mentions aligned with im +messages-mget"`
-}
-
-type MentionOutput struct {
-	Key  string `json:"key,omitempty"  desc:"Mention placeholder key, for example @_user_1"`
-	ID   string `json:"id,omitempty"   desc:"Mentioned user open_id; prefixed with ou_"        kind:"open_id"`
-	Name string `json:"name,omitempty" desc:"Mentioned display name"`
+	Type        string `json:"type"                   desc:"Event type; always im.message.receive_v1"`
+	EventID     string `json:"event_id,omitempty"     desc:"Globally unique event ID; safe for deduplication"`
+	Timestamp   string `json:"timestamp,omitempty"    desc:"Event delivery time (ms timestamp string); prefers header.create_time"                                                                                                              kind:"timestamp_ms"`
+	ID          string `json:"id,omitempty"           desc:"Message ID (legacy alias of message_id, kept for compatibility)"                                                                                                                     kind:"message_id"`
+	MessageID   string `json:"message_id,omitempty"   desc:"Message ID; prefixed with om_"                                                                                                                                                       kind:"message_id"`
+	CreateTime  string `json:"create_time,omitempty"  desc:"Message creation time (ms timestamp string)"                                                                                                                                         kind:"timestamp_ms"`
+	ChatID      string `json:"chat_id,omitempty"      desc:"Chat/conversation ID; prefixed with oc_"                                                                                                                                             kind:"chat_id"`
+	ChatType    string `json:"chat_type,omitempty"    desc:"Conversation type"                                                                                                                                                                   enum:"p2p,group"`
+	MessageType string `json:"message_type,omitempty" desc:"Message type"`
+	SenderID    string `json:"sender_id,omitempty"    desc:"Sender open_id; prefixed with ou_"                                                                                                                                                   kind:"open_id"`
+	Content     string `json:"content,omitempty"      desc:"Message content. For most types (text/post/image/file/audio, etc.) this is pre-rendered human-readable text."`
 }

 func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
@@ -48,20 +36,15 @@ func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.Ra
 		Event struct {
 			Message struct {
 				MessageID   string        `json:"message_id"`
-				RootID      string        `json:"root_id"`
-				ParentID    string        `json:"parent_id"`
-				ThreadID    string        `json:"thread_id"`
 				ChatID      string        `json:"chat_id"`
 				ChatType    string        `json:"chat_type"`
 				MessageType string        `json:"message_type"`
 				Content     string        `json:"content"`
 				CreateTime  string        `json:"create_time"`
-				UpdateTime  string        `json:"update_time"`
 				Mentions    []interface{} `json:"mentions"`
 			} `json:"message"`
 			Sender struct {
-				SenderType string `json:"sender_type"`
-				SenderID   struct {
+				SenderID struct {
 					OpenID string `json:"open_id"`
 				} `json:"sender_id"`
 			} `json:"sender"`
@@ -98,54 +81,7 @@ func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.Ra
 		ChatType:    msg.ChatType,
 		MessageType: msg.MessageType,
 		SenderID:    envelope.Event.Sender.SenderID.OpenID,
-		SenderType:  envelope.Event.Sender.SenderType,
-		RootID:      msg.RootID,
-		ThreadID:    msg.ThreadID,
-		ReplyTo:     msg.ParentID,
 		Content:     content,
-		Mentions:    compactMentions(msg.Mentions),
-	}
-	if msg.UpdateTime != "" && msg.UpdateTime != msg.CreateTime {
-		out.UpdateTime = msg.UpdateTime
 	}
 	return json.Marshal(out)
 }
-
-func compactMentions(mentions []interface{}) []MentionOutput {
-	if len(mentions) == 0 {
-		return nil
-	}
-	out := make([]MentionOutput, 0, len(mentions))
-	for _, raw := range mentions {
-		item, _ := raw.(map[string]interface{})
-		mention := MentionOutput{
-			Key:  stringField(item, "key"),
-			ID:   mentionOpenID(item["id"]),
-			Name: stringField(item, "name"),
-		}
-		if mention.Key != "" || mention.ID != "" || mention.Name != "" {
-			out = append(out, mention)
-		}
-	}
-	if len(out) == 0 {
-		return nil
-	}
-	return out
-}
-
-func stringField(m map[string]interface{}, key string) string {
-	v, _ := m[key].(string)
-	return v
-}
-
-func mentionOpenID(raw interface{}) string {
-	switch v := raw.(type) {
-	case map[string]interface{}:
-		openID, _ := v["open_id"].(string)
-		return openID
-	case string:
-		return v
-	default:
-		return ""
-	}
-}
--- a/events/im/message_receive_test.go
+++ b/events/im/message_receive_test.go
@@ -84,32 +84,19 @@ func TestProcessImMessageReceive_Text(t *testing.T) {
 		},
 		"event": {
 			"sender": {
-				"sender_type": "user",
 				"sender_id": {"open_id": "ou_sender"}
 			},
 			"message": {
 				"message_id":   "om_text_001",
-				"root_id":      "om_root_001",
-				"parent_id":    "om_parent_001",
-				"thread_id":    "omt_thread_001",
 				"chat_id":      "oc_chat",
 				"chat_type":    "p2p",
 				"message_type": "text",
 				"create_time":  "1776409468987",
-				"update_time":  "1776409469999",
-				"content":      "{\"text\":\"hello @_user_1\"}",
-				"mentions": [
-					{
-						"key": "@_user_1",
-						"id": {"open_id": "ou_mentioned"},
-						"name": "Alice"
-					}
-				]
+				"content":      "{\"text\":\"hello there\"}"
 			}
 		}
 	}`
 	out := runReceive(t, payload)
-	outMap := runReceiveMap(t, payload)

 	if out.Type != "im.message.receive_v1" {
 		t.Errorf("Type = %q", out.Type)
@@ -123,69 +110,12 @@ func TestProcessImMessageReceive_Text(t *testing.T) {
 	if out.SenderID != "ou_sender" {
 		t.Errorf("SenderID = %q", out.SenderID)
 	}
-	if out.Content != "hello @Alice" {
-		t.Errorf("Content = %q, want \"hello @Alice\"", out.Content)
+	if out.Content != "hello there" {
+		t.Errorf("Content = %q, want \"hello there\"", out.Content)
 	}
 	if out.Timestamp != "1776409469273" {
 		t.Errorf("Timestamp = %q", out.Timestamp)
 	}
-	for field, want := range map[string]string{
-		"sender_type": "user",
-		"root_id":     "om_root_001",
-		"thread_id":   "omt_thread_001",
-		"reply_to":    "om_parent_001",
-		"update_time": "1776409469999",
-	} {
-		if got, _ := outMap[field].(string); got != want {
-			t.Errorf("%s = %q, want %q", field, got, want)
-		}
-	}
-	mentions, _ := outMap["mentions"].([]interface{})
-	if len(mentions) != 1 {
-		t.Fatalf("mentions length = %d, want 1: %#v", len(mentions), outMap["mentions"])
-	}
-	mention, _ := mentions[0].(map[string]interface{})
-	for field, want := range map[string]string{
-		"key":  "@_user_1",
-		"id":   "ou_mentioned",
-		"name": "Alice",
-	} {
-		if got, _ := mention[field].(string); got != want {
-			t.Errorf("mentions[0].%s = %q, want %q", field, got, want)
-		}
-	}
-}
-
-func TestProcessImMessageReceive_OmitsUnchangedUpdateTime(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_test_text",
-			"event_type": "im.message.receive_v1",
-			"create_time": "1776409469273",
-			"app_id": "cli_test"
-		},
-		"event": {
-			"sender": {
-				"sender_type": "user",
-				"sender_id": {"open_id": "ou_sender"}
-			},
-			"message": {
-				"message_id":   "om_text_001",
-				"chat_id":      "oc_chat",
-				"chat_type":    "p2p",
-				"message_type": "text",
-				"create_time":  "1776409468987",
-				"update_time":  "1776409468987",
-				"content":      "{\"text\":\"hello there\"}"
-			}
-		}
-	}`
-	outMap := runReceiveMap(t, payload)
-
-	if _, ok := outMap["update_time"]; ok {
-		t.Errorf("update_time should be omitted when it equals create_time: %#v", outMap)
-	}
 }

 func TestProcessImMessageReceive_Interactive(t *testing.T) {
@@ -258,22 +188,3 @@ func runReceive(t *testing.T, payload string) ImMessageReceiveOutput {
 	}
 	return out
 }
-
-func runReceiveMap(t *testing.T, payload string) map[string]interface{} {
-	t.Helper()
-	raw := &event.RawEvent{
-		EventID:   "ev_test",
-		EventType: "im.message.receive_v1",
-		Payload:   json.RawMessage(payload),
-		Timestamp: time.Now(),
-	}
-	got, err := processImMessageReceive(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("Process error: %v", err)
-	}
-	var out map[string]interface{}
-	if err := json.Unmarshal(got, &out); err != nil {
-		t.Fatalf("Process output is not valid JSON: %v\nraw=%s", err, string(got))
-	}
-	return out
-}
--- a/events/register.go
+++ b/events/register.go
@@ -5,8 +5,6 @@
 package events

 import (
-	"github.com/larksuite/cli/events/application"
-	"github.com/larksuite/cli/events/approval"
 	"github.com/larksuite/cli/events/im"
 	"github.com/larksuite/cli/events/minutes"
 	"github.com/larksuite/cli/events/task"
@@ -18,8 +16,6 @@ import (
 // Mail is intentionally omitted in this phase.
 func init() {
 	all := [][]event.KeyDefinition{
-		application.Keys(),
-		approval.Keys(),
 		im.Keys(),
 		minutes.Keys(),
 		task.Keys(),
--- a/extension/credential/env/env.go
+++ b/extension/credential/env/env.go
@@ -23,89 +23,63 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 	appSecret := os.Getenv(envvars.CliAppSecret)
 	hasUAT := os.Getenv(envvars.CliUserAccessToken) != ""
 	hasTAT := os.Getenv(envvars.CliTenantAccessToken) != ""
-	presentKeys := presentCredentialEnvKeys(appID, appSecret, hasUAT, hasTAT)
-	if len(presentKeys) == 0 {
-		return nil, nil
+	if appID == "" && appSecret == "" {
+		switch {
+		case hasUAT:
+			return nil, &credential.BlockError{Provider: "env", Reason: envvars.CliUserAccessToken + " is set but " + envvars.CliAppID + " is missing"}
+		case hasTAT:
+			return nil, &credential.BlockError{Provider: "env", Reason: envvars.CliTenantAccessToken + " is set but " + envvars.CliAppID + " is missing"}
+		default:
+			return nil, nil
+		}
 	}
+	if appID == "" {
+		return nil, &credential.BlockError{Provider: "env", Reason: envvars.CliAppSecret + " is set but " + envvars.CliAppID + " is missing"}
+	}
+	if appSecret == "" && !hasUAT && !hasTAT {
+		return nil, &credential.BlockError{
+			Provider: "env",
+			Reason:   envvars.CliAppID + " is set but no app secret or access token is available",
+		}
+	}
+	brand := credential.Brand(core.ParseBrand(os.Getenv(envvars.CliBrand)))
+	acct := &credential.Account{AppID: appID, AppSecret: appSecret, Brand: brand}

-	// Identity policy variables are validated whenever a direct credential
-	// input is present. Their errors must not be hidden by a later credential
-	// completeness check or profile arbitration.
-	defaultAs := credential.Identity(os.Getenv(envvars.CliDefaultAs))
-	switch defaultAs {
-	case "", credential.IdentityAuto, credential.IdentityUser, credential.IdentityBot:
+	switch id := credential.Identity(os.Getenv(envvars.CliDefaultAs)); id {
+	case "", credential.IdentityAuto:
+		acct.DefaultAs = id
+	case credential.IdentityUser, credential.IdentityBot:
+		acct.DefaultAs = id
 	default:
 		return nil, &credential.BlockError{
 			Provider: "env",
-			Reason:   fmt.Sprintf("invalid %s %q (want user, bot, or auto)", envvars.CliDefaultAs, defaultAs),
-			Code:     credential.BlockReasonInvalidPolicy,
-			Param:    envvars.CliDefaultAs,
+			Reason:   fmt.Sprintf("invalid %s %q (want user, bot, or auto)", envvars.CliDefaultAs, id),
 		}
 	}

-	strictMode := os.Getenv(envvars.CliStrictMode)
-	var supported credential.IdentitySupport
-	switch strictMode {
+	// Explicit strict mode policy takes priority
+	switch strictMode := os.Getenv(envvars.CliStrictMode); strictMode {
 	case "bot":
-		supported = credential.SupportsBot
+		acct.SupportedIdentities = credential.SupportsBot
 	case "user":
-		supported = credential.SupportsUser
+		acct.SupportedIdentities = credential.SupportsUser
 	case "off":
-		supported = credential.SupportsAll
+		acct.SupportedIdentities = credential.SupportsAll
 	case "":
+		// Infer from available tokens
 		if hasUAT {
-			supported |= credential.SupportsUser
+			acct.SupportedIdentities |= credential.SupportsUser
 		}
 		if hasTAT {
-			supported |= credential.SupportsBot
+			acct.SupportedIdentities |= credential.SupportsBot
 		}
 	default:
 		return nil, &credential.BlockError{
 			Provider: "env",
 			Reason:   fmt.Sprintf("invalid %s %q (want bot, user, or off)", envvars.CliStrictMode, strictMode),
-			Code:     credential.BlockReasonInvalidPolicy,
-			Param:    envvars.CliStrictMode,
 		}
 	}

-	if appID == "" && appSecret == "" {
-		switch {
-		case hasUAT:
-			return nil, incompleteCredentialError(
-				appID,
-				envvars.CliUserAccessToken+" is set but "+envvars.CliAppID+" is missing",
-				[]string{envvars.CliAppID}, nil, presentKeys)
-		case hasTAT:
-			return nil, incompleteCredentialError(
-				appID,
-				envvars.CliTenantAccessToken+" is set but "+envvars.CliAppID+" is missing",
-				[]string{envvars.CliAppID}, nil, presentKeys)
-		}
-	}
-	if appID == "" {
-		return nil, incompleteCredentialError(
-			appID,
-			envvars.CliAppSecret+" is set but "+envvars.CliAppID+" is missing",
-			[]string{envvars.CliAppID}, nil, presentKeys)
-	}
-	if appSecret == "" && !hasUAT && !hasTAT {
-		return nil, incompleteCredentialError(
-			appID,
-			envvars.CliAppID+" is set but no app secret or access token is available",
-			nil,
-			[]string{envvars.CliAppSecret, envvars.CliUserAccessToken, envvars.CliTenantAccessToken},
-			presentKeys)
-	}
-	brand := credential.Brand(core.ParseBrand(os.Getenv(envvars.CliBrand)))
-	acct := &credential.Account{
-		AppID:               appID,
-		AppSecret:           appSecret,
-		Brand:               brand,
-		DefaultAs:           defaultAs,
-		SupportedIdentities: supported,
-		Kind:                credential.AccountDirect,
-	}
-
 	if acct.DefaultAs == "" {
 		switch {
 		case hasUAT:
@@ -118,35 +92,6 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 	return acct, nil
 }

-func incompleteCredentialError(appID, reason string, missingKeys, requiredAnyOf, presentKeys []string) *credential.BlockError {
-	return &credential.BlockError{
-		Provider:      "env",
-		Reason:        reason,
-		Code:          credential.BlockReasonCredentialIncomplete,
-		MissingKeys:   missingKeys,
-		RequiredAnyOf: requiredAnyOf,
-		PresentKeys:   presentKeys,
-		AppID:         appID,
-	}
-}
-
-func presentCredentialEnvKeys(appID, appSecret string, hasUAT, hasTAT bool) []string {
-	var keys []string
-	if appID != "" {
-		keys = append(keys, envvars.CliAppID)
-	}
-	if appSecret != "" {
-		keys = append(keys, envvars.CliAppSecret)
-	}
-	if hasUAT {
-		keys = append(keys, envvars.CliUserAccessToken)
-	}
-	if hasTAT {
-		keys = append(keys, envvars.CliTenantAccessToken)
-	}
-	return keys
-}
-
 func (p *Provider) ResolveToken(ctx context.Context, req credential.TokenSpec) (*credential.Token, error) {
 	var envKey string
 	switch req.Type {
--- a/extension/credential/env/env_test.go
+++ b/extension/credential/env/env_test.go
@@ -6,7 +6,6 @@ package env
 import (
 	"context"
 	"errors"
-	"slices"
 	"strings"
 	"testing"

@@ -48,22 +47,6 @@ func TestResolveAccount_OnlyIDSet(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %v", err)
 	}
-	if blockErr.Code != credential.BlockReasonCredentialIncomplete {
-		t.Fatalf("Code = %q, want %q", blockErr.Code, credential.BlockReasonCredentialIncomplete)
-	}
-	want := []string{envvars.CliAppSecret, envvars.CliUserAccessToken, envvars.CliTenantAccessToken}
-	if !slices.Equal(blockErr.RequiredAnyOf, want) {
-		t.Fatalf("RequiredAnyOf = %v, want %v", blockErr.RequiredAnyOf, want)
-	}
-	if len(blockErr.MissingKeys) != 0 {
-		t.Fatalf("MissingKeys = %v, want empty", blockErr.MissingKeys)
-	}
-	if !slices.Equal(blockErr.PresentKeys, []string{envvars.CliAppID}) {
-		t.Fatalf("PresentKeys = %v, want [%s]", blockErr.PresentKeys, envvars.CliAppID)
-	}
-	if blockErr.AppID != "cli_test" {
-		t.Fatalf("AppID = %q, want cli_test", blockErr.AppID)
-	}
 }

 func TestResolveAccount_AppIDAndUserTokenWithoutSecret(t *testing.T) {
@@ -92,81 +75,18 @@ func TestResolveAccount_OnlySecretSet(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %v", err)
 	}
-	if blockErr.Code != credential.BlockReasonCredentialIncomplete ||
-		!slices.Equal(blockErr.MissingKeys, []string{envvars.CliAppID}) ||
-		!slices.Equal(blockErr.PresentKeys, []string{envvars.CliAppSecret}) {
-		t.Fatalf("BlockError = %+v, want incomplete with missing APP_ID and present APP_SECRET", blockErr)
-	}
-	if len(blockErr.RequiredAnyOf) != 0 {
-		t.Fatalf("RequiredAnyOf = %v, want empty for APP_SECRET-only", blockErr.RequiredAnyOf)
-	}
 }

 func TestResolveAccount_OnlyTokenSetWithoutAppID(t *testing.T) {
-	for _, tt := range []struct {
-		name string
-		key  string
-	}{
-		{name: "UAT", key: envvars.CliUserAccessToken},
-		{name: "TAT", key: envvars.CliTenantAccessToken},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv(envvars.CliAppID, "")
-			t.Setenv(envvars.CliAppSecret, "")
-			t.Setenv(envvars.CliUserAccessToken, "")
-			t.Setenv(envvars.CliTenantAccessToken, "")
-			t.Setenv(tt.key, "token_test")
+	t.Setenv(envvars.CliUserAccessToken, "uat_test")

-			_, err := (&Provider{}).ResolveAccount(context.Background())
-			var blockErr *credential.BlockError
-			if !errors.As(err, &blockErr) {
-				t.Fatalf("expected BlockError, got %v", err)
-			}
-			if !strings.Contains(err.Error(), envvars.CliAppID) {
-				t.Fatalf("error = %v, want mention of %s", err, envvars.CliAppID)
-			}
-			if blockErr.Code != credential.BlockReasonCredentialIncomplete ||
-				!slices.Equal(blockErr.MissingKeys, []string{envvars.CliAppID}) ||
-				!slices.Equal(blockErr.PresentKeys, []string{tt.key}) {
-				t.Fatalf("BlockError = %+v, want incomplete for %s", blockErr, tt.key)
-			}
-			if len(blockErr.RequiredAnyOf) != 0 {
-				t.Fatalf("RequiredAnyOf = %v, want empty for %s-only", blockErr.RequiredAnyOf, tt.name)
-			}
-		})
+	_, err := (&Provider{}).ResolveAccount(context.Background())
+	var blockErr *credential.BlockError
+	if !errors.As(err, &blockErr) {
+		t.Fatalf("expected BlockError, got %v", err)
 	}
-}
-
-func TestResolveAccount_InvalidPolicyRejectedBeforeIncomplete(t *testing.T) {
-	for _, tt := range []struct {
-		name string
-		key  string
-	}{
-		{name: "DEFAULT_AS", key: envvars.CliDefaultAs},
-		{name: "STRICT_MODE", key: envvars.CliStrictMode},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv(envvars.CliAppID, "cli_test")
-			t.Setenv(envvars.CliAppSecret, "")
-			t.Setenv(envvars.CliUserAccessToken, "")
-			t.Setenv(envvars.CliTenantAccessToken, "")
-			t.Setenv(tt.key, "banana")
-
-			_, err := (&Provider{}).ResolveAccount(context.Background())
-			var blockErr *credential.BlockError
-			if !errors.As(err, &blockErr) {
-				t.Fatalf("error = %T %v, want BlockError", err, err)
-			}
-			if blockErr.Code != credential.BlockReasonInvalidPolicy {
-				t.Fatalf("Code = %q, want %q", blockErr.Code, credential.BlockReasonInvalidPolicy)
-			}
-			if blockErr.Param != tt.key {
-				t.Fatalf("Param = %q, want %q", blockErr.Param, tt.key)
-			}
-			if !strings.Contains(blockErr.Reason, tt.key) {
-				t.Fatalf("reason = %q, want %s", blockErr.Reason, tt.key)
-			}
-		})
+	if !strings.Contains(err.Error(), envvars.CliAppID) {
+		t.Fatalf("error = %v, want mention of %s", err, envvars.CliAppID)
 	}
 }

@@ -338,9 +258,6 @@ func TestResolveAccount_InvalidStrictModeRejected(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %T", err)
 	}
-	if blockErr.Code != credential.BlockReasonInvalidPolicy || blockErr.Param != envvars.CliStrictMode {
-		t.Fatalf("BlockError = %+v, want invalid_policy with Param %s", blockErr, envvars.CliStrictMode)
-	}
 	if !strings.Contains(err.Error(), envvars.CliStrictMode) {
 		t.Fatalf("error = %v, want mention of %s", err, envvars.CliStrictMode)
 	}
@@ -359,9 +276,6 @@ func TestResolveAccount_InvalidDefaultAsRejected(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %T", err)
 	}
-	if blockErr.Code != credential.BlockReasonInvalidPolicy || blockErr.Param != envvars.CliDefaultAs {
-		t.Fatalf("BlockError = %+v, want invalid_policy with Param %s", blockErr, envvars.CliDefaultAs)
-	}
 	if !strings.Contains(err.Error(), envvars.CliDefaultAs) {
 		t.Fatalf("error = %v, want mention of %s", err, envvars.CliDefaultAs)
 	}
--- a/extension/credential/sidecar/provider.go
+++ b/extension/credential/sidecar/provider.go
@@ -77,8 +77,6 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 		return nil, &credential.BlockError{
 			Provider: "sidecar",
 			Reason:   fmt.Sprintf("invalid %s %q (want user, bot, or auto)", envvars.CliDefaultAs, id),
-			Code:     credential.BlockReasonInvalidPolicy,
-			Param:    envvars.CliDefaultAs,
 		}
 	}

@@ -94,8 +92,6 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 		return nil, &credential.BlockError{
 			Provider: "sidecar",
 			Reason:   fmt.Sprintf("invalid %s %q (want bot, user, or off)", envvars.CliStrictMode, strictMode),
-			Code:     credential.BlockReasonInvalidPolicy,
-			Param:    envvars.CliStrictMode,
 		}
 	}

--- a/extension/credential/sidecar/provider_test.go
+++ b/extension/credential/sidecar/provider_test.go
@@ -7,9 +7,7 @@ package sidecar

 import (
 	"context"
-	"errors"
 	"os"
-	"strings"
 	"testing"

 	"github.com/larksuite/cli/extension/credential"
@@ -148,57 +146,6 @@ func TestResolveAccount_StrictMode(t *testing.T) {
 	}
 }

-func TestResolveAccount_InvalidPolicyClassified(t *testing.T) {
-	setEnv(t, envvars.CliAuthProxy, "http://127.0.0.1:16384")
-	setEnv(t, envvars.CliProxyKey, "test-key")
-	setEnv(t, envvars.CliAppID, "cli_test")
-
-	tests := []struct {
-		name          string
-		key           string
-		value         string
-		supportedText string
-	}{
-		{
-			name:          "default as",
-			key:           envvars.CliDefaultAs,
-			value:         "banana",
-			supportedText: "want user, bot, or auto",
-		},
-		{
-			name:          "strict mode",
-			key:           envvars.CliStrictMode,
-			value:         "banana",
-			supportedText: "want bot, user, or off",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			unsetEnv(t, envvars.CliDefaultAs)
-			unsetEnv(t, envvars.CliStrictMode)
-			setEnv(t, tt.key, tt.value)
-
-			_, err := (&Provider{}).ResolveAccount(context.Background())
-			var blockErr *credential.BlockError
-			if !errors.As(err, &blockErr) {
-				t.Fatalf("error = %T %v, want BlockError", err, err)
-			}
-			if blockErr.Code != credential.BlockReasonInvalidPolicy {
-				t.Fatalf("Code = %q, want %q", blockErr.Code, credential.BlockReasonInvalidPolicy)
-			}
-			if blockErr.Param != tt.key {
-				t.Fatalf("Param = %q, want %q", blockErr.Param, tt.key)
-			}
-			if !strings.Contains(blockErr.Reason, tt.key) ||
-				!strings.Contains(blockErr.Reason, tt.value) ||
-				!strings.Contains(blockErr.Reason, tt.supportedText) {
-				t.Fatalf("Reason = %q, want variable, invalid value, and supported values", blockErr.Reason)
-			}
-		})
-	}
-}
-
 func TestResolveToken_NotActive(t *testing.T) {
 	unsetEnv(t, envvars.CliAuthProxy)

--- a/extension/credential/types.go
+++ b/extension/credential/types.go
@@ -44,27 +44,6 @@ func (s IdentitySupport) UserOnly() bool { return s == SupportsUser }
 // BotOnly returns true if only bot identity is supported.
 func (s IdentitySupport) BotOnly() bool { return s == SupportsBot }

-// AccountKind declares how an account participates in credential arbitration.
-type AccountKind int
-
-const (
-	// AccountManaged means the provider owns the whole identity; winning it
-	// ends arbitration outright. The zero value, so existing providers are
-	// unchanged.
-	AccountManaged AccountKind = iota
-	// AccountDirect marks an actively supplied raw credential (the env
-	// provider's LARKSUITE_CLI_* variables). It participates in profile
-	// arbitration and conflict detection instead of winning outright.
-	//
-	// RESERVED: only the builtin env provider may declare AccountDirect
-	// today — the arbitration's direct-credential diagnostics are defined in
-	// terms of the process environment, and the caller rejects AccountDirect
-	// from any other provider. Third-party providers must return
-	// AccountManaged until the SPI carries provider-reported input
-	// descriptors.
-	AccountDirect
-)
-
 // Account holds resolved app credentials and configuration.
 type Account struct {
 	AppID               string
@@ -74,7 +53,6 @@ type Account struct {
 	ProfileName         string
 	OpenID              string          // optional; if UAT is available, API result takes precedence
 	SupportedIdentities IdentitySupport // zero = provider did not declare; treat as no restriction
-	Kind                AccountKind     // AccountManaged (default) or AccountDirect
 }

 // Token holds a resolved access token and optional metadata.
@@ -98,38 +76,11 @@ type TokenSpec struct {
 	AppID string
 }

-// BlockReason classifies provider-originated block conditions that callers may
-// safely map to a more specific public error contract.
-type BlockReason string
-
-const (
-	// BlockReasonCredentialIncomplete marks incomplete inputs from the builtin
-	// process-env credential provider. It is reserved for that provider because
-	// direct-credential arbitration and diagnostics currently name the fixed
-	// LARKSUITE_CLI_* env surface. Third-party providers must return an
-	// unclassified BlockError until the SPI carries provider-owned input
-	// descriptors. Blocks without a Code propagate unchanged.
-	BlockReasonCredentialIncomplete BlockReason = "credential_incomplete"
-
-	// BlockReasonInvalidPolicy marks a user-supplied policy input (e.g.
-	// LARKSUITE_CLI_DEFAULT_AS / LARKSUITE_CLI_STRICT_MODE) that failed
-	// validation. The caller maps it to a typed validation error carrying
-	// Param and a repair hint, so user input mistakes never surface as
-	// internal errors.
-	BlockReasonInvalidPolicy BlockReason = "invalid_policy"
-)
-
 // BlockError is returned by a Provider to actively reject a request
 // and prevent subsequent providers in the chain from being consulted.
 type BlockError struct {
-	Provider      string
-	Reason        string
-	Code          BlockReason
-	MissingKeys   []string // environment variable names only; never values
-	RequiredAnyOf []string // environment variable names only; never values
-	PresentKeys   []string // environment variable names only; never values
-	AppID         string   // plaintext app identifier used only for source comparison; never a secret
-	Param         string   // name of the invalid input variable on invalid_policy blocks; never a value
+	Provider string
+	Reason   string
 }

 func (e *BlockError) Error() string {
--- a/internal/auth/testmain_test.go
+++ b/internal/auth/testmain_test.go
@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package auth
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-internal-auth-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_LOG_DIR", filepath.Join(root, "logs")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/internal/client/client_test.go
+++ b/internal/client/client_test.go
@@ -48,18 +48,6 @@ func (s *staticTokenResolver) ResolveToken(_ context.Context, _ credential.Token
 	return &credential.TokenResult{Token: "test-token"}, nil
 }

-type clientTestAccountResolver struct {
-	appID string
-}
-
-func (r clientTestAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return &credential.Account{AppID: r.appID, Brand: core.BrandFeishu}, nil
-}
-
-func newClientTestCredentialProvider(appID string, tokenResolver credential.DefaultTokenResolver) *credential.CredentialProvider {
-	return credential.NewCredentialProvider(nil, clientTestAccountResolver{appID: appID}, tokenResolver, nil)
-}
-
 // newTestAPIClient creates an APIClient with a mock HTTP transport.
 func newTestAPIClient(t *testing.T, rt http.RoundTripper) (*APIClient, *bytes.Buffer) {
 	t.Helper()
@@ -70,7 +58,7 @@ func newTestAPIClient(t *testing.T, rt http.RoundTripper) (*APIClient, *bytes.Bu
 		lark.WithLogLevel(larkcore.LogLevelError),
 		lark.WithHttpClient(httpClient),
 	)
-	testCred := newClientTestCredentialProvider("test-app", &staticTokenResolver{})
+	testCred := credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil)
 	cfg := &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu}
 	return &APIClient{
 		SDK:        sdk,
@@ -475,7 +463,7 @@ func TestDoStream_IgnoresBaseHTTPClientTimeout(t *testing.T) {

 	ac := &APIClient{
 		HTTP:       &http.Client{Timeout: 5 * time.Millisecond},
-		Credential: newClientTestCredentialProvider("test-app", &staticTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}

@@ -510,7 +498,7 @@ func TestDoStream_TransportFailureSplitsSubtype(t *testing.T) {
 	})
 	ac := &APIClient{
 		HTTP:       &http.Client{Transport: rt},
-		Credential: newClientTestCredentialProvider("test-app", &staticTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}

@@ -544,7 +532,7 @@ func (f *failingTokenResolver) ResolveToken(_ context.Context, spec credential.T
 func TestResolveAccessToken_NoToken_ReturnsTypedAuthenticationError(t *testing.T) {
 	ac := &APIClient{
 		HTTP:       &http.Client{},
-		Credential: newClientTestCredentialProvider("test-app", &failingTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &failingTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}

@@ -584,7 +572,7 @@ func (f *needAuthTokenResolver) ResolveToken(_ context.Context, _ credential.Tok
 func TestResolveAccessToken_NeedAuthorization_SurfacesAsTypedAuthentication(t *testing.T) {
 	ac := &APIClient{
 		HTTP:       &http.Client{},
-		Credential: newClientTestCredentialProvider("test-app", &needAuthTokenResolver{userOpenID: "ou_test_user"}),
+		Credential: credential.NewCredentialProvider(nil, nil, &needAuthTokenResolver{userOpenID: "ou_test_user"}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}

@@ -624,7 +612,7 @@ func TestResolveAccessToken_NeedAuthorization_SurfacesAsTypedAuthentication(t *t
 func TestDoSDKRequest_AuthFailureSurfacesTypedAuthenticationError(t *testing.T) {
 	ac := &APIClient{
 		HTTP:       &http.Client{},
-		Credential: newClientTestCredentialProvider("test-app", &failingTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &failingTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}

--- a/internal/client/response.go
+++ b/internal/client/response.go
@@ -132,14 +132,16 @@ func HandleResponse(resp *larkcore.ApiResp, opts ResponseOptions) error {
 			})
 		}

-		emitter := output.NewEmitter(output.EmitterConfig{
-			Out:            opts.Out,
-			ErrOut:         opts.ErrOut,
-			CommandPath:    opts.CommandPath,
-			Identity:       string(identity),
-			NoticeProvider: output.GetNotice,
-		})
-		return emitter.Success(result, output.EmitOptions{Format: opts.Format.String()})
+		// Content safety scanning for non-JSON presentation formats.
+		scanResult := output.ScanForSafety(opts.CommandPath, result, opts.ErrOut)
+		if scanResult.Blocked {
+			return scanResult.BlockErr
+		}
+		if scanResult.Alert != nil {
+			output.WriteAlertWarning(opts.ErrOut, scanResult.Alert)
+		}
+		output.FormatValue(opts.Out, result, opts.Format)
+		return nil
 	}

 	// Non-JSON (binary) responses.
--- a/internal/client/response_test.go
+++ b/internal/client/response_test.go
@@ -18,7 +18,6 @@ import (

 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/vfs/localfileio"
 )
@@ -240,87 +239,6 @@ func TestHandleResponse_JSON(t *testing.T) {
 	}
 }

-func TestHandleResponse_NonJSONFormatsEmitExactStructuredResponseBytes(t *testing.T) {
-	tests := []struct {
-		name   string
-		format output.Format
-		want   string
-	}{
-		{
-			name:   "ndjson",
-			format: output.FormatNDJSON,
-			want:   "{\"id\":\"1\",\"name\":\"Alice\"}\n{\"id\":\"2\",\"name\":\"Bob\"}\n",
-		},
-		{
-			name:   "table",
-			format: output.FormatTable,
-			want:   "id  name \n──  ─────\n1   Alice\n2   Bob  \n",
-		},
-		{
-			name:   "csv",
-			format: output.FormatCSV,
-			want:   "id,name\n1,Alice\n2,Bob\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "off")
-			reg := &httpmock.Registry{}
-			reg.Register(&httpmock.Stub{
-				Method: http.MethodGet,
-				URL:    "/open-apis/test/v1/items",
-				Body: map[string]interface{}{
-					"code": 0,
-					"msg":  "ok",
-					"data": map[string]interface{}{
-						"items": []interface{}{
-							map[string]interface{}{"id": "1", "name": "Alice"},
-							map[string]interface{}{"id": "2", "name": "Bob"},
-						},
-						"has_more": false,
-					},
-				},
-			})
-
-			httpResp, err := httpmock.NewClient(reg).Get("https://open.feishu.cn/open-apis/test/v1/items")
-			if err != nil {
-				t.Fatalf("fixture request failed: %v", err)
-			}
-			body, err := io.ReadAll(httpResp.Body)
-			_ = httpResp.Body.Close()
-			if err != nil {
-				t.Fatalf("read fixture response: %v", err)
-			}
-			resp := &larkcore.ApiResp{
-				StatusCode: httpResp.StatusCode,
-				Header:     httpResp.Header.Clone(),
-				RawBody:    body,
-			}
-
-			var out bytes.Buffer
-			var errOut bytes.Buffer
-			err = HandleResponse(resp, ResponseOptions{
-				Format:      tt.format,
-				Identity:    core.AsBot,
-				Out:         &out,
-				ErrOut:      &errOut,
-				CommandPath: "lark-cli api GET",
-			})
-			if err != nil {
-				t.Fatalf("HandleResponse() error = %v, want nil", err)
-			}
-			if got := out.String(); got != tt.want {
-				t.Fatalf("stdout byte mismatch\ngot (%d bytes):\n%q\nwant (%d bytes):\n%q", len(got), got, len(tt.want), tt.want)
-			}
-			if got := errOut.String(); got != "" {
-				t.Fatalf("stderr bytes = %q, want empty", got)
-			}
-			reg.Verify(t)
-		})
-	}
-}
-
 func TestHandleResponse_JSONWithJqUsesSuccessEnvelope(t *testing.T) {
 	body := []byte(`{"code":0,"msg":"ok","data":{"id":"1"}}`)
 	resp := newApiResp(body, map[string]string{"Content-Type": "application/json"})
--- a/internal/cmdutil/dryrun.go
+++ b/internal/cmdutil/dryrun.go
@@ -8,29 +8,15 @@ import (
 	"fmt"
 	"io"
 	"net/url"
-	"regexp"
 	"sort"
 	"strings"

-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/client"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/util"
 )

-var dryRunURLPlaceholderRE = regexp.MustCompile(`:([A-Za-z_][A-Za-z0-9_]*)`)
-
-// DryRunOutputOptions controls dry-run stdout/stderr rendering.
-type DryRunOutputOptions struct {
-	Format      string
-	JqExpr      string
-	CommandPath string
-	Identity    core.Identity
-	Out         io.Writer
-	ErrOut      io.Writer
-}
-
 // DryRunAPICall describes a single API call in dry-run output.
 type DryRunAPICall struct {
 	Desc   string                 `json:"desc,omitempty"`
@@ -40,21 +26,12 @@ type DryRunAPICall struct {
 	Body   interface{}            `json:"body,omitempty"`
 }

-// DryRunContext is the execution context shared by every dry-run preview:
-// which app would make the call and, when known, as which user. The identity
-// itself lives at the envelope top level, not here.
-type DryRunContext struct {
-	AppID      string `json:"app_id,omitempty"`
-	UserOpenID string `json:"user_open_id,omitempty"`
-}
-
 // DryRunAPI is the builder and result type for dry-run output.
 // URL templates use :param placeholders; Set stores actual values; MarshalJSON and Format resolve them.
 type DryRunAPI struct {
-	desc    string
-	calls   []DryRunAPICall
-	context *DryRunContext
-	extra   map[string]interface{}
+	desc  string
+	calls []DryRunAPICall
+	extra map[string]interface{}
 }

 func NewDryRunAPI() *DryRunAPI {
@@ -63,22 +40,30 @@ func NewDryRunAPI() *DryRunAPI {

 // --- HTTP method builders (add a call, return self for chaining) ---

-// call appends a request with the method transcribed verbatim, so previews
-// never misreport what the real client would send.
-func (d *DryRunAPI) call(method, url string) *DryRunAPI {
-	d.calls = append(d.calls, DryRunAPICall{Method: method, URL: url})
+func (d *DryRunAPI) GET(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "GET", URL: url})
 	return d
 }

-func (d *DryRunAPI) GET(url string) *DryRunAPI { return d.call("GET", url) }
+func (d *DryRunAPI) POST(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "POST", URL: url})
+	return d
+}

-func (d *DryRunAPI) POST(url string) *DryRunAPI { return d.call("POST", url) }
+func (d *DryRunAPI) PUT(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "PUT", URL: url})
+	return d
+}

-func (d *DryRunAPI) PUT(url string) *DryRunAPI { return d.call("PUT", url) }
+func (d *DryRunAPI) DELETE(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "DELETE", URL: url})
+	return d
+}

-func (d *DryRunAPI) DELETE(url string) *DryRunAPI { return d.call("DELETE", url) }
-
-func (d *DryRunAPI) PATCH(url string) *DryRunAPI { return d.call("PATCH", url) }
+func (d *DryRunAPI) PATCH(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "PATCH", URL: url})
+	return d
+}

 // Body sets the request body on the last added call.
 func (d *DryRunAPI) Body(body interface{}) *DryRunAPI {
@@ -113,26 +98,12 @@ func (d *DryRunAPI) Set(key string, value interface{}) *DryRunAPI {
 	return d
 }

-// Context records the calling app/user under data.context; empty values are
-// omitted, and a fully empty context is not emitted at all.
-func (d *DryRunAPI) Context(appID, userOpenID string) *DryRunAPI {
-	if appID == "" && userOpenID == "" {
-		return d
-	}
-	d.context = &DryRunContext{AppID: appID, UserOpenID: userOpenID}
-	return d
-}
-
 // resolveURL replaces :key placeholders in url with path-escaped values from extra.
 func (d *DryRunAPI) resolveURL(rawURL string) string {
-	return dryRunURLPlaceholderRE.ReplaceAllStringFunc(rawURL, func(token string) string {
-		name := token[1:]
-		value, ok := d.extra[name]
-		if !ok {
-			return token
-		}
-		return url.PathEscape(fmt.Sprintf("%v", value))
-	})
+	for k, v := range d.extra {
+		rawURL = strings.ReplaceAll(rawURL, ":"+k, url.PathEscape(fmt.Sprintf("%v", v)))
+	}
+	return rawURL
 }

 // MarshalJSON serializes as {"description": "...", "api": [...calls with resolved URLs], ...extra}.
@@ -147,17 +118,13 @@ func (d *DryRunAPI) MarshalJSON() ([]byte, error) {
 			Body:   c.Body,
 		}
 	}
-	m := make(map[string]interface{}, len(d.extra)+3)
-	for k, v := range d.extra {
-		m[k] = v
-	}
-	// Typed fields win over same-named extra keys.
+	m := make(map[string]interface{}, len(d.extra)+2)
 	if d.desc != "" {
 		m["description"] = d.desc
 	}
 	m["api"] = resolved
-	if d.context != nil {
-		m["context"] = d.context
+	for k, v := range d.extra {
+		m[k] = v
 	}
 	return json.Marshal(m)
 }
@@ -187,7 +154,11 @@ func (d *DryRunAPI) Format() string {
 			u += "?" + encodeParams(c.Params)
 		}

-		b.WriteString(c.Method)
+		method := c.Method
+		if method == "" {
+			method = "GET"
+		}
+		b.WriteString(method)
 		b.WriteByte(' ')
 		b.WriteString(u)
 		b.WriteByte('\n')
@@ -244,74 +215,83 @@ func encodeParams(params map[string]interface{}) string {
 	return vals.Encode()
 }

-// buildDryRunPreview assembles the shared preview skeleton: HTTP method, URL,
-// query params, and the app/user context common to every dry-run.
-func buildDryRunPreview(request client.RawApiRequest, config *core.CliConfig) *DryRunAPI {
-	dr := NewDryRunAPI().call(request.Method, request.URL)
+// PrintDryRunWithFile outputs a dry-run summary for file upload requests.
+// Instead of serializing the Formdata body, it shows file metadata.
+func PrintDryRunWithFile(w io.Writer, request client.RawApiRequest, config *core.CliConfig, format, fileField, filePath string, formFields any) error {
+	dr := NewDryRunAPI()
+	switch request.Method {
+	case "POST":
+		dr.POST(request.URL)
+	case "PUT":
+		dr.PUT(request.URL)
+	case "PATCH":
+		dr.PATCH(request.URL)
+	case "DELETE":
+		dr.DELETE(request.URL)
+	default:
+		dr.GET(request.URL)
+	}
 	if len(request.Params) > 0 {
 		dr.Params(request.Params)
 	}
-	// Identity is reported at the envelope top level, not duplicated here.
-	dr.Context(config.AppID, config.UserOpenId)
-	return dr
-}
-
-// PrintDryRunWithFile outputs a dry-run summary for file upload requests.
-// Instead of serializing the Formdata body, it shows file metadata.
-func PrintDryRunWithFile(request client.RawApiRequest, config *core.CliConfig, opts DryRunOutputOptions, file FileUploadMeta) error {
-	dr := buildDryRunPreview(request, config)
-	filePathDisplay := file.FilePath
+	filePathDisplay := filePath
 	if filePathDisplay == "" {
 		filePathDisplay = "<stdin>"
 	}
 	fileInfo := map[string]any{
-		"file": map[string]string{"field": file.FieldName, "path": filePathDisplay},
+		"file": map[string]string{"field": fileField, "path": filePathDisplay},
 	}
-	if file.FormFields != nil {
-		fileInfo["form_fields"] = file.FormFields
+	if formFields != nil {
+		fileInfo["form_fields"] = formFields
 	}
 	fileInfo["options"] = []string{"WithFileUpload"}
 	dr.Body(fileInfo)
-	return WriteDryRun(dr, opts)
+	dr.Set("as", string(request.As))
+	dr.Set("appId", config.AppID)
+	if config.UserOpenId != "" {
+		dr.Set("userOpenId", config.UserOpenId)
+	}
+	fmt.Fprintln(w, "=== Dry Run ===")
+	if format == "pretty" {
+		fmt.Fprint(w, dr.Format())
+	} else {
+		output.PrintJson(w, dr)
+	}
+	return nil
 }

 // PrintDryRun outputs a standardised dry-run summary using DryRunAPI.
 // When format is "pretty", outputs human-readable text; otherwise JSON.
-func PrintDryRun(request client.RawApiRequest, config *core.CliConfig, opts DryRunOutputOptions) error {
-	dr := buildDryRunPreview(request, config)
+func PrintDryRun(w io.Writer, request client.RawApiRequest, config *core.CliConfig, format string) error {
+	dr := NewDryRunAPI()
+	switch request.Method {
+	case "POST":
+		dr.POST(request.URL)
+	case "PUT":
+		dr.PUT(request.URL)
+	case "PATCH":
+		dr.PATCH(request.URL)
+	case "DELETE":
+		dr.DELETE(request.URL)
+	default:
+		dr.GET(request.URL)
+	}
+	if len(request.Params) > 0 {
+		dr.Params(request.Params)
+	}
 	if !util.IsNil(request.Data) {
 		dr.Body(request.Data)
 	}
-	return WriteDryRun(dr, opts)
-}
-
-// WriteDryRun emits a DryRunAPI using the shared dry-run output contract.
-// Identity may be empty; the envelope omits it rather than guessing.
-func WriteDryRun(dr *DryRunAPI, opts DryRunOutputOptions) error {
-	if dr == nil {
-		return errs.NewInternalError(errs.SubtypeUnknown, "dry-run produced no request preview")
+	dr.Set("as", string(request.As))
+	dr.Set("appId", config.AppID)
+	if config.UserOpenId != "" {
+		dr.Set("userOpenId", config.UserOpenId)
 	}
-	// The JqExpr guard is defensive: every entry point already rejects --jq
-	// combined with --format pretty via output.ValidateJqFlags.
-	if opts.Format == "pretty" && opts.JqExpr == "" {
-		// A nil ErrOut only skips the banner decoration (mirroring
-		// WriteSuccessEnvelope's warning path); the payload write to Out
-		// must fail loudly rather than be silently discarded.
-		if opts.ErrOut != nil {
-			fmt.Fprintln(opts.ErrOut, "=== Dry Run ===")
-		}
-		// stdout carries its own marker so logs that drop stderr still show
-		// this was a preview, not an executed request.
-		fmt.Fprintln(opts.Out, "# dry-run: request not sent")
-		fmt.Fprint(opts.Out, dr.Format())
-		return nil
+	fmt.Fprintln(w, "=== Dry Run ===")
+	if format == "pretty" {
+		fmt.Fprint(w, dr.Format())
+	} else {
+		output.PrintJson(w, dr)
 	}
-	return output.WriteSuccessEnvelope(dr, output.SuccessEnvelopeOptions{
-		CommandPath: opts.CommandPath,
-		Identity:    string(opts.Identity),
-		DryRun:      true,
-		JqExpr:      opts.JqExpr,
-		Out:         opts.Out,
-		ErrOut:      opts.ErrOut,
-	})
+	return nil
 }
--- a/internal/cmdutil/dryrun_test.go
+++ b/internal/cmdutil/dryrun_test.go
@@ -6,12 +6,9 @@ package cmdutil
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
-	"io"
 	"strings"
 	"testing"

-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/client"
 	"github.com/larksuite/cli/internal/core"
 )
@@ -69,31 +66,11 @@ func TestDryRunAPI_ResolveURL(t *testing.T) {
 	}
 }

-func TestDryRunAPI_ResolveURLMatchesFullPlaceholderOnly(t *testing.T) {
-	dr := NewDryRunAPI().
-		GET("/open-apis/task/v2/tasks/:assignee_id").
-		Set("assignee", "ou_bot")
-
-	text := dr.Format()
-	if strings.Contains(text, "ou_bot_id") {
-		t.Fatalf("prefix placeholder key corrupted longer token: %s", text)
-	}
-	if !strings.Contains(text, ":assignee_id") {
-		t.Fatalf("missing unresolved placeholder, got: %s", text)
-	}
-
-	dr.Set("assignee_id", "ou_abc/123")
-	text = dr.Format()
-	if !strings.Contains(text, "/open-apis/task/v2/tasks/ou_abc%2F123") {
-		t.Fatalf("expected full placeholder replacement with path escaping, got: %s", text)
-	}
-}
-
 func TestDryRunAPI_MarshalJSON(t *testing.T) {
 	dr := NewDryRunAPI().
 		Desc("test api").
 		GET("/open-apis/test").
-		Set("note", "audit")
+		Set("as", "user")

 	data, err := json.Marshal(dr)
 	if err != nil {
@@ -106,8 +83,8 @@ func TestDryRunAPI_MarshalJSON(t *testing.T) {
 	if m["description"] != "test api" {
 		t.Errorf("expected description, got: %v", m["description"])
 	}
-	if m["note"] != "audit" {
-		t.Errorf("expected note=audit, got: %v", m["note"])
+	if m["as"] != "user" {
+		t.Errorf("expected as=user, got: %v", m["as"])
 	}
 	api, ok := m["api"].([]interface{})
 	if !ok || len(api) != 1 {
@@ -146,67 +123,31 @@ func TestDryRunAPI_ExtraFieldsOnly(t *testing.T) {

 func TestPrintDryRun_JSON(t *testing.T) {
 	var buf bytes.Buffer
-	var errBuf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
+	err := PrintDryRun(&buf, client.RawApiRequest{
 		Method: "GET",
 		URL:    "/open-apis/test",
 		As:     "user",
-	}, &core.CliConfig{AppID: "app123"}, DryRunOutputOptions{
-		Format:      "json",
-		CommandPath: "lark-cli api",
-		Identity:    core.AsUser,
-		Out:         &buf,
-		ErrOut:      &errBuf,
-	})
+	}, &core.CliConfig{AppID: "app123"}, "json")
 	if err != nil {
 		t.Fatalf("PrintDryRun failed: %v", err)
 	}
 	out := buf.String()
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("JSON stdout must not contain banner, got: %s", out)
+	if !strings.Contains(out, "=== Dry Run ===") {
+		t.Errorf("expected header, got: %s", out)
 	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, out)
-	}
-	if env["ok"] != true || env["identity"] != "user" || env["dry_run"] != true {
-		t.Fatalf("unexpected envelope: %#v", env)
-	}
-	data, ok := env["data"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("unexpected data: %#v", env["data"])
-	}
-	dctx, ok := data["context"].(map[string]interface{})
-	if !ok || dctx["app_id"] != "app123" {
-		t.Fatalf("unexpected data.context: %#v", data["context"])
-	}
-	if _, exists := data["as"]; exists {
-		t.Fatalf("data.as must not appear; identity lives at the envelope top level: %#v", data)
-	}
-	api, ok := data["api"].([]interface{})
-	if !ok || len(api) != 1 {
-		t.Fatalf("api = %#v, want one call", data["api"])
-	}
-	call, ok := api[0].(map[string]interface{})
-	if !ok || call["url"] != "/open-apis/test" {
-		t.Fatalf("api[0] = %#v", api[0])
+	if !strings.Contains(out, "app123") {
+		t.Errorf("expected appId in output, got: %s", out)
 	}
 }

 func TestPrintDryRun_Pretty(t *testing.T) {
 	var buf bytes.Buffer
-	var errBuf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
+	err := PrintDryRun(&buf, client.RawApiRequest{
 		Method: "POST",
 		URL:    "/open-apis/test",
 		Data:   map[string]interface{}{"key": "val"},
 		As:     "bot",
-	}, &core.CliConfig{AppID: "app456"}, DryRunOutputOptions{
-		Format:   "pretty",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   &errBuf,
-	})
+	}, &core.CliConfig{AppID: "app456"}, "pretty")
 	if err != nil {
 		t.Fatalf("PrintDryRun failed: %v", err)
 	}
@@ -214,136 +155,6 @@ func TestPrintDryRun_Pretty(t *testing.T) {
 	if !strings.Contains(out, "POST /open-apis/test") {
 		t.Errorf("expected POST line in pretty output, got: %s", out)
 	}
-	if !strings.HasPrefix(out, "# dry-run: request not sent\n") {
-		t.Fatalf("pretty stdout should start with the dry-run marker, got: %s", out)
-	}
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("pretty stdout must not contain banner, got: %s", out)
-	}
-	if !strings.Contains(errBuf.String(), "=== Dry Run ===") {
-		t.Fatalf("pretty stderr should contain banner, got: %s", errBuf.String())
-	}
-}
-
-func TestPrintDryRun_WithJqUsesEnvelope(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test",
-		As:     "bot",
-	}, &core.CliConfig{AppID: "app123"}, DryRunOutputOptions{
-		Format:   "json",
-		JqExpr:   ".data.api[0].url",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   io.Discard,
-	})
-	if err != nil {
-		t.Fatalf("PrintDryRun failed: %v", err)
-	}
-	if got := strings.TrimSpace(buf.String()); got != "/open-apis/test" {
-		t.Fatalf("jq output = %q, want /open-apis/test", got)
-	}
-}
-
-func TestPrintDryRunWithFile_JSONEnvelope(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRunWithFile(client.RawApiRequest{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/files/upload_all",
-		As:     "bot",
-	}, &core.CliConfig{AppID: "app123", UserOpenId: "ou_tester"}, DryRunOutputOptions{
-		Format:   "json",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   io.Discard,
-	}, FileUploadMeta{FieldName: "file", FilePath: "report.txt", FormFields: map[string]any{"parent": "fld"}})
-	if err != nil {
-		t.Fatalf("PrintDryRunWithFile failed: %v", err)
-	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, buf.String())
-	}
-	if env["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", env["dry_run"])
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	body := call["body"].(map[string]interface{})
-	file := body["file"].(map[string]interface{})
-	if file["path"] != "report.txt" {
-		t.Fatalf("file body = %#v", body)
-	}
-	dctx, ok := data["context"].(map[string]interface{})
-	if !ok || dctx["app_id"] != "app123" || dctx["user_open_id"] != "ou_tester" {
-		t.Fatalf("unexpected data.context: %#v", data["context"])
-	}
-	for _, legacy := range []string{"as", "appId", "userOpenId"} {
-		if _, exists := data[legacy]; exists {
-			t.Fatalf("legacy key %q must not appear in data: %#v", legacy, data)
-		}
-	}
-}
-
-func TestPrintDryRun_MethodTranscribedVerbatim(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
-		Method: "OPTIONS",
-		URL:    "/open-apis/test",
-		As:     "bot",
-	}, &core.CliConfig{AppID: "app123"}, DryRunOutputOptions{
-		Format:   "json",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   io.Discard,
-	})
-	if err != nil {
-		t.Fatalf("PrintDryRun failed: %v", err)
-	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, buf.String())
-	}
-	call := env["data"].(map[string]interface{})["api"].([]interface{})[0].(map[string]interface{})
-	if call["method"] != "OPTIONS" {
-		t.Fatalf("method = %#v, want OPTIONS transcribed verbatim (not coerced to GET)", call["method"])
-	}
-}
-
-func TestPrintDryRun_EmptyConfigOmitsContext(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test",
-	}, &core.CliConfig{}, DryRunOutputOptions{
-		Format: "json",
-		Out:    &buf,
-		ErrOut: io.Discard,
-	})
-	if err != nil {
-		t.Fatalf("PrintDryRun failed: %v", err)
-	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, buf.String())
-	}
-	data := env["data"].(map[string]interface{})
-	if _, exists := data["context"]; exists {
-		t.Fatalf("empty app/user context must be omitted entirely, got: %#v", data["context"])
-	}
-}
-
-func TestWriteDryRun_NilPreviewIsInternalError(t *testing.T) {
-	err := WriteDryRun(nil, DryRunOutputOptions{Format: "json", Out: io.Discard})
-	if err == nil {
-		t.Fatal("WriteDryRun(nil) should fail instead of emitting an empty preview")
-	}
-	var internal *errs.InternalError
-	if !errors.As(err, &internal) {
-		t.Fatalf("expected *errs.InternalError, got %T: %v", err, err)
-	}
 }

 func TestDryRunFormatValue(t *testing.T) {
--- a/internal/cmdutil/factory.go
+++ b/internal/cmdutil/factory.go
@@ -27,11 +27,6 @@ import (
 // In tests, replace any field to stub out external dependencies.
 type InvocationContext struct {
 	Profile string
-	// ProfileFromFlag is true when Profile was set via the --profile flag,
-	// and false when it came from the LARKSUITE_CLI_PROFILE env fallback
-	// (or neither was set). Downstream credential resolution uses this to
-	// report the correct profile source.
-	ProfileFromFlag bool
 }

 type Factory struct {
--- a/internal/cmdutil/factory_default.go
+++ b/internal/cmdutil/factory_default.go
@@ -22,7 +22,6 @@ import (
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/registry"
-	"github.com/larksuite/cli/internal/riskcontrol"
 	_ "github.com/larksuite/cli/internal/security/contentsafety" // register content safety provider
 	"github.com/larksuite/cli/internal/transport"
 	_ "github.com/larksuite/cli/internal/vfs/localfileio" // register default FileIO provider
@@ -34,7 +33,7 @@ import (
 //	Phase 1: HttpClient (no credential dependency)
 //	Phase 2: Credential (sole data source for account info)
 //	Phase 3: Config derived from Credential
-//	Phase 4: LarkClient derived from Credential and workspace policy
+//	Phase 4: LarkClient derived from Credential
 func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 	streams = normalizeStreams(streams)
 	f := &Factory{
@@ -55,22 +54,20 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {

 	// Phase 0: FileIO provider (no dependency)
 	f.FileIOProvider = fileio.GetProvider()
-	workspaceConfig := core.NewConfigSnapshot()

 	// Phase 1: HttpClient (no credential dependency)
-	f.HttpClient = cachedHttpClientFunc(f, workspaceConfig)
+	f.HttpClient = cachedHttpClientFunc(f)

 	// Phase 2: Credential (sole data source)
 	// Keychain is read via closure so callers can replace f.Keychain after construction.
 	f.Credential = buildCredentialProvider(credentialDeps{
-		Keychain:        func() keychain.KeychainAccess { return f.Keychain },
-		Profile:         inv.Profile,
-		ProfileFromFlag: inv.ProfileFromFlag,
-		HttpClient:      f.HttpClient,
-		ErrOut:          f.IOStreams.ErrOut,
+		Keychain:   func() keychain.KeychainAccess { return f.Keychain },
+		Profile:    inv.Profile,
+		HttpClient: f.HttpClient,
+		ErrOut:     f.IOStreams.ErrOut,
 	})

-	// Phase 3: Runtime config contains resolved account data only.
+	// Phase 3: Config derived from Credential via an explicit conversion boundary.
 	f.Config = sync.OnceValues(func() (*core.CliConfig, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
 		if err != nil {
@@ -81,9 +78,8 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 		return cfg, nil
 	})

-	// Phase 4: LarkClient composes account data and workspace policy at the SDK
-	// transport boundary.
-	f.LarkClient = cachedLarkClientFunc(f, workspaceConfig)
+	// Phase 4: LarkClient from Credential (placeholder AppSecret)
+	f.LarkClient = cachedLarkClientFunc(f)

 	return f
 }
@@ -112,16 +108,13 @@ func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 // .StderrIsTerminal field, which tests set directly.
 var warnIfProxied = transport.WarnIfProxied

-func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*http.Client, error) {
+func cachedHttpClientFunc(f *Factory) func() (*http.Client, error) {
 	return sync.OnceValues(func() (*http.Client, error) {
 		if f.IOStreams.StderrIsTerminal {
 			warnIfProxied(f.IOStreams.ErrOut)
 		}

-		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-
 		var rt http.RoundTripper = transport.Shared()
-		rt = riskcontrol.NewTransport(rt, hostSignalSource)
 		rt = &RetryTransport{Base: rt}
 		rt = &SecurityHeaderTransport{Base: rt}
 		rt = &auth.SecurityPolicyTransport{Base: rt} // Add our global response interceptor
@@ -135,7 +128,7 @@ func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }

-func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*lark.Client, error) {
+func cachedLarkClientFunc(f *Factory) func() (*lark.Client, error) {
 	return sync.OnceValues(func() (*lark.Client, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
 		if err != nil {
@@ -149,15 +142,8 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 		if f.IOStreams.StderrIsTerminal {
 			warnIfProxied(f.IOStreams.ErrOut)
 		}
-		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-		var sdkBase http.RoundTripper = transport.Shared()
-		// The innermost SDK boundary always strips reserved host-signal headers;
-		// a nil source makes it strip-only when workspace policy disables signal
-		// collection.
-		sdkBase = riskcontrol.NewTransport(sdkBase, hostSignalSource)
-		sdkTransport := wrapSDKTransport(sdkBase)
 		opts = append(opts, lark.WithHttpClient(&http.Client{
-			Transport:     sdkTransport,
+			Transport:     buildSDKTransport(),
 			CheckRedirect: safeRedirectPolicy,
 		}))
 		ep := core.ResolveEndpoints(acct.Brand)
@@ -166,8 +152,9 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }

-func wrapSDKTransport(next http.RoundTripper) http.RoundTripper {
-	var sdkTransport http.RoundTripper = &RetryTransport{Base: next}
+func buildSDKTransport() http.RoundTripper {
+	var sdkTransport http.RoundTripper = transport.Shared()
+	sdkTransport = &RetryTransport{Base: sdkTransport}
 	sdkTransport = &UserAgentTransport{Base: sdkTransport}
 	sdkTransport = &BuildHeaderTransport{Base: sdkTransport}
 	sdkTransport = &auth.SecurityPolicyTransport{Base: sdkTransport}
@@ -175,11 +162,10 @@ func wrapSDKTransport(next http.RoundTripper) http.RoundTripper {
 }

 type credentialDeps struct {
-	Keychain        func() keychain.KeychainAccess
-	Profile         string
-	ProfileFromFlag bool
-	HttpClient      func() (*http.Client, error)
-	ErrOut          io.Writer
+	Keychain   func() keychain.KeychainAccess
+	Profile    string
+	HttpClient func() (*http.Client, error)
+	ErrOut     io.Writer
 }

 func buildCredentialProvider(deps credentialDeps) *credential.CredentialProvider {
@@ -192,13 +178,5 @@ func buildCredentialProvider(deps credentialDeps) *credential.CredentialProvider
 	// depend on. enrichUserInfo failures are already non-fatal (the
 	// provider clears unverified identity fields), so silencing the
 	// warning is safe.
-	cred := credential.NewCredentialProvider(providers, defaultAcct, defaultToken, deps.HttpClient)
-	if deps.Profile == "" {
-		// No profile selected — don't record a phantom env source.
-		return cred
-	}
-	if deps.ProfileFromFlag {
-		return cred.WithProfileFromFlag(deps.Profile)
-	}
-	return cred.WithProfileFromEnv(deps.Profile)
+	return credential.NewCredentialProvider(providers, defaultAcct, defaultToken, deps.HttpClient)
 }
--- a/internal/cmdutil/factory_http_test.go
+++ b/internal/cmdutil/factory_http_test.go
@@ -6,15 +6,10 @@ package cmdutil
 import (
 	"io"
 	"testing"
-
-	"github.com/larksuite/cli/internal/core"
 )

 func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})

 	c1, err := fn()
 	if err != nil {
@@ -34,10 +29,7 @@ func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
 }

 func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.Timeout == 0 {
 		t.Error("expected non-zero timeout")
@@ -45,10 +37,7 @@ func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
 }

 func TestCachedHttpClientFunc_HasRedirectPolicy(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.CheckRedirect == nil {
 		t.Error("expected CheckRedirect to be set (safeRedirectPolicy)")
--- a/internal/cmdutil/factory_proxy_warn_test.go
+++ b/internal/cmdutil/factory_proxy_warn_test.go
@@ -8,7 +8,6 @@ import (
 	"testing"

 	_ "github.com/larksuite/cli/extension/credential/env" // registers the env-backed account provider
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/envvars"
 )

@@ -37,15 +36,13 @@ var proxyWarnGateCases = []struct {
 // TestCachedHttpClientFunc_ProxyWarnGate verifies the http-client init path
 // invokes WarnIfProxied only when stderr is an interactive terminal.
 func TestCachedHttpClientFunc_ProxyWarnGate(t *testing.T) {
-	isEnabled := false
 	for _, tc := range proxyWarnGateCases {
 		t.Run(tc.name, func(t *testing.T) {
 			calls := installProxyWarnSpy(t)

-			f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-			f.IOStreams.ErrOut = io.Discard
-			f.IOStreams.StderrIsTerminal = tc.terminal
-			fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+			fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{
+				ErrOut: io.Discard, StderrIsTerminal: tc.terminal,
+			}})
 			if _, err := fn(); err != nil {
 				t.Fatalf("http client init: %v", err)
 			}
@@ -76,7 +73,7 @@ func TestCachedLarkClientFunc_ProxyWarnGate(t *testing.T) {
 			// normalizeStreams copies the struct (out := *s), so the
 			// StderrIsTerminal field survives into f.IOStreams.
 			f := NewDefault(&IOStreams{ErrOut: io.Discard, StderrIsTerminal: tc.terminal}, InvocationContext{})
-			if _, err := cachedLarkClientFunc(f, nil)(); err != nil {
+			if _, err := cachedLarkClientFunc(f)(); err != nil {
 				t.Fatalf("lark client init: %v", err)
 			}

--- a/internal/cmdutil/factory_test.go
+++ b/internal/cmdutil/factory_test.go
@@ -13,7 +13,6 @@ import (

 	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/envvars"
@@ -406,14 +405,6 @@ type stubExtProvider struct {
 	err  error
 }

-type stubDefaultAccountResolver struct {
-	acct *credential.Account
-}
-
-func (s *stubDefaultAccountResolver) ResolveAccount(_ context.Context) (*credential.Account, error) {
-	return s.acct, nil
-}
-
 func (s *stubExtProvider) Name() string { return s.name }
 func (s *stubExtProvider) ResolveAccount(_ context.Context) (*extcred.Account, error) {
 	return s.acct, s.err
@@ -457,86 +448,6 @@ func TestRequireBuiltinCredentialProvider_AllowsBuiltinProvider(t *testing.T) {
 	}
 }

-func TestRequireBuiltinCredentialProvider_AllowsMatchingAppIDOnlyProfile(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv(envvars.CliAppID, "cli_a")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv(envvars.CliUserAccessToken, "")
-	t.Setenv(envvars.CliTenantAccessToken, "")
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name:      "tenant_a",
-			AppId:     "cli_a",
-			AppSecret: core.PlainSecret("test-secret"),
-			Brand:     core.BrandFeishu,
-		}},
-	}); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{&envprovider.Provider{}},
-		&stubDefaultAccountResolver{acct: &credential.Account{AppID: "cli_a", AppSecret: "test-secret"}},
-		nil,
-		nil,
-	).WithProfileFromFlag("tenant_a")
-	f, _, _, _ := TestFactory(t, nil)
-	f.Credential = cred
-
-	if err := f.RequireBuiltinCredentialProvider(context.Background(), "auth"); err != nil {
-		t.Fatalf("matching APP_ID-only profile should use builtin credentials: %v", err)
-	}
-}
-
-// A stale LARKSUITE_CLI_PROFILE (profile that cannot resolve) must not lock
-// the user out of the builtin setup/repair commands this gate guards: the
-// probe falls back to provider engagement and lets the command run.
-func TestRequireBuiltinCredentialProvider_StaleProfileDoesNotLockOut(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir()) // no config -> "ghost" cannot resolve
-
-	stub := &stubExtProvider{name: "env"} // not engaged: returns nil, nil
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{stub},
-		&stubDefaultAccountResolver{},
-		nil,
-		nil,
-	).WithProfileFromEnv("ghost")
-	f, _, _, _ := TestFactory(t, nil)
-	f.Credential = cred
-
-	if err := f.RequireBuiltinCredentialProvider(context.Background(), "config"); err != nil {
-		t.Fatalf("stale profile must not lock out builtin auth/config commands: %v", err)
-	}
-}
-
-// An invalid policy variable (e.g. LARKSUITE_CLI_DEFAULT_AS=banana) is a user
-// input error, not an external credential takeover: the gate surfaces the
-// same typed validation error as formal arbitration instead of a misleading
-// "provided externally" refusal.
-func TestRequireBuiltinCredentialProvider_InvalidPolicySurfacesTypedError(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	stub := &stubExtProvider{name: "env", err: &extcred.BlockError{
-		Provider: "env",
-		Reason:   "invalid LARKSUITE_CLI_DEFAULT_AS \"banana\" (want user, bot, or auto)",
-		Code:     extcred.BlockReasonInvalidPolicy,
-		Param:    envvars.CliDefaultAs,
-	}}
-	cred := credential.NewCredentialProvider([]extcred.Provider{stub}, &stubDefaultAccountResolver{}, nil, nil)
-	f, _, _, _ := TestFactory(t, nil)
-	f.Credential = cred
-
-	err := f.RequireBuiltinCredentialProvider(context.Background(), "auth")
-	prob, ok := errs.ProblemOf(err)
-	if !ok || prob.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("err = %v, want typed invalid_argument (same as formal arbitration)", err)
-	}
-	if strings.Contains(err.Error(), "provided externally") {
-		t.Fatalf("err = %v, must not read as external takeover", err)
-	}
-}
-
 func TestRequireBuiltinCredentialProvider_NilCredential(t *testing.T) {
 	f, _, _, _ := TestFactory(t, nil)
 	f.Credential = nil
--- a/internal/cmdutil/localfile.go
+++ b/internal/cmdutil/localfile.go
@@ -1,36 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"io/fs"
-
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-// StatLocalFile returns metadata for a path in the process filesystem namespace.
-// It is intended for advisory validation; callers must validate the opened file
-// again before using its contents.
-func StatLocalFile(path string) (fs.FileInfo, error) {
-	localPath, err := validate.LocalInputPath(path)
-	if err != nil {
-		return nil, &fileio.PathValidationError{Err: err}
-	}
-	return vfs.Stat(localPath)
-}
-
-// OpenLocalFile opens a path in the process filesystem namespace.
-// Absolute and relative paths are accepted. It is the shared replacement for
-// direct os.Open/os.ReadFile use in commands that intentionally read local
-// paths outside the workspace sandbox. Callers inspect the returned descriptor
-// before reading so validation and use apply to the same opened file.
-func OpenLocalFile(path string) (fs.File, error) {
-	localPath, err := validate.LocalInputPath(path)
-	if err != nil {
-		return nil, &fileio.PathValidationError{Err: err}
-	}
-	return vfs.Open(localPath)
-}
--- a/internal/cmdutil/localfile_test.go
+++ b/internal/cmdutil/localfile_test.go
@@ -1,96 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"errors"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-func TestOpenLocalFile_AcceptsAbsoluteAndParentRelativePaths(t *testing.T) {
-	root := t.TempDir()
-	workDir := filepath.Join(root, "work")
-	if err := os.Mkdir(workDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	path := filepath.Join(root, "input.txt")
-	if err := os.WriteFile(path, []byte("content"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	TestChdir(t, workDir)
-
-	for _, input := range []string{path, filepath.Join("..", "input.txt")} {
-		f, err := OpenLocalFile(input)
-		if err != nil {
-			t.Fatalf("OpenLocalFile(%q) error = %v", input, err)
-		}
-		got, readErr := io.ReadAll(f)
-		closeErr := f.Close()
-		if readErr != nil || closeErr != nil || string(got) != "content" {
-			t.Fatalf("OpenLocalFile(%q) content=%q read=%v close=%v", input, got, readErr, closeErr)
-		}
-	}
-}
-
-func TestOpenLocalFile_RejectsInvalidInput(t *testing.T) {
-	if _, err := OpenLocalFile("input\n.txt"); !errors.Is(err, fileio.ErrPathValidation) {
-		t.Fatalf("OpenLocalFile() error = %v, want ErrPathValidation", err)
-	}
-}
-
-func TestStatLocalFile_ReturnsMetadata(t *testing.T) {
-	info, err := StatLocalFile(t.TempDir())
-	if err != nil {
-		t.Fatalf("StatLocalFile() error = %v", err)
-	}
-	if !info.IsDir() {
-		t.Fatalf("StatLocalFile() mode = %v, want directory", info.Mode())
-	}
-}
-
-func TestOpenLocalFile_DoesNotStatBeforeOpen(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "input.txt")
-	if err := os.WriteFile(path, []byte("content"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	previous := vfs.DefaultFS
-	counting := &countingLocalFileFS{FS: previous}
-	vfs.DefaultFS = counting
-	t.Cleanup(func() { vfs.DefaultFS = previous })
-
-	f, err := OpenLocalFile(path)
-	if err != nil {
-		t.Fatalf("OpenLocalFile() error = %v", err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if counting.openCalls != 1 || counting.statCalls != 0 {
-		t.Fatalf("OpenLocalFile() calls: Open=%d Stat=%d, want Open=1 Stat=0", counting.openCalls, counting.statCalls)
-	}
-}
-
-type countingLocalFileFS struct {
-	vfs.FS
-	openCalls int
-	statCalls int
-}
-
-func (f *countingLocalFileFS) Open(name string) (*os.File, error) {
-	f.openCalls++
-	return f.FS.Open(name)
-}
-
-func (f *countingLocalFileFS) Stat(name string) (fs.FileInfo, error) {
-	f.statCalls++
-	return f.FS.Stat(name)
-}
--- a/internal/cmdutil/risk_control.go
+++ b/internal/cmdutil/risk_control.go
@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/riskcontrol"
-)
-
-type workspaceConfigSource interface {
-	MultiAppConfig() (*core.MultiAppConfig, error)
-}
-
-// resolveSDKHostSignalSource applies workspace policy at the SDK transport
-// boundary.
-func resolveSDKHostSignalSource(config workspaceConfigSource) riskcontrol.Source {
-	if config == nil {
-		return nil
-	}
-	workspace, configErr := config.MultiAppConfig()
-	// Default-on means an existing config with no explicit preference. Absent
-	// or unreadable config cannot authorize host-signal collection.
-	if configErr != nil || !workspace.RiskControlEnabled() {
-		return nil
-	}
-	return riskcontrol.NewHostSource()
-}
--- a/internal/cmdutil/risk_control_test.go
+++ b/internal/cmdutil/risk_control_test.go
@@ -1,45 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/internal/core"
-)
-
-type staticWorkspaceConfig struct {
-	config *core.MultiAppConfig
-	err    error
-}
-
-func (s staticWorkspaceConfig) MultiAppConfig() (*core.MultiAppConfig, error) {
-	return s.config, s.err
-}
-
-func TestResolveSDKHostSignalSource(t *testing.T) {
-	disabled := false
-	tests := []struct {
-		name       string
-		config     workspaceConfigSource
-		wantSource bool
-	}{
-		{name: "workspace default on", config: staticWorkspaceConfig{config: &core.MultiAppConfig{}}, wantSource: true},
-		{name: "workspace opt-out", config: staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &disabled}}},
-		{name: "missing config", config: staticWorkspaceConfig{err: errors.New("file does not exist")}},
-		{name: "unreadable config", config: staticWorkspaceConfig{err: errors.New("permission denied")}},
-		{name: "nil config value", config: staticWorkspaceConfig{}},
-		{name: "nil config source"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			got := resolveSDKHostSignalSource(test.config)
-			if (got != nil) != test.wantSource {
-				t.Fatalf("resolveSDKHostSignalSource() = %T, wantSource %t", got, test.wantSource)
-			}
-		})
-	}
-}
--- a/internal/cmdutil/testmain_test.go
+++ b/internal/cmdutil/testmain_test.go
@@ -1,30 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	// Default-factory tests initialize the registry and resolve config. Keep
-	// them deterministic: never read the developer's real ~/.lark-cli and
-	// prevent background remote-metadata refreshes from touching user state.
-	root, err := os.MkdirTemp("", "lark-cli-cmdutil-test-*")
-	if err != nil {
-		println("internal/cmdutil test setup: MkdirTemp failed:", err.Error())
-		os.Exit(2)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_REMOTE_META", "off"); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/internal/cmdutil/transport_test.go
+++ b/internal/cmdutil/transport_test.go
@@ -15,7 +15,6 @@ import (

 	exttransport "github.com/larksuite/cli/extension/transport"
 	internalauth "github.com/larksuite/cli/internal/auth"
-	"github.com/larksuite/cli/internal/riskcontrol"
 )

 type roundTripFunc func(*http.Request) (*http.Response, error)
@@ -92,13 +91,13 @@ func TestRetryTransport_DefaultNoRetry(t *testing.T) {
 }

 // ---------------------------------------------------------------------------
-// wrapSDKTransport chain composition
+// buildSDKTransport chain composition
 // ---------------------------------------------------------------------------

-func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+func TestBuildSDKTransport_IncludesRetryTransport(t *testing.T) {
+	transport := buildSDKTransport()

-	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
@@ -111,23 +110,18 @@ func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }

-func TestWrapSDKTransport_WithExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
+func TestBuildSDKTransport_WithExtension(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{})
-	t.Cleanup(func() { exttransport.Register(previous) })
+	t.Cleanup(func() { exttransport.Register(nil) })

-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+	transport := buildSDKTransport()

-	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	mid, ok := transport.(*extensionMiddleware)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *extensionMiddleware", transport)
@@ -144,23 +138,17 @@ func TestWrapSDKTransport_WithExtension(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("innermost transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }

-func TestWrapSDKTransport_WithoutExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
+func TestBuildSDKTransport_WithoutExtension(t *testing.T) {
 	exttransport.Register(nil)
-	t.Cleanup(func() { exttransport.Register(previous) })

-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+	transport := buildSDKTransport()

-	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
@@ -173,13 +161,9 @@ func TestWrapSDKTransport_WithoutExtension(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }

 // ---------------------------------------------------------------------------
@@ -277,40 +261,6 @@ func (buildTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Resp
 	return nil
 }

-type riskHeaderTamperingInterceptor struct{}
-
-func (riskHeaderTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
-	req.Header.Set(riskcontrol.HeaderOSType, "extension-value")
-	req.Header.Set(riskcontrol.HeaderProductModel, "extension-value")
-	return nil
-}
-
-func TestWrapSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
-	previous := exttransport.GetProvider()
-	exttransport.Register(&stubTransportProvider{interceptor: riskHeaderTamperingInterceptor{}})
-	t.Cleanup(func() { exttransport.Register(previous) })
-
-	var received http.Header
-	network := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		received = req.Header.Clone()
-		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
-	})
-	req, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/open-apis/test", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req.Header.Set("Authorization", "Bearer token")
-
-	resp, err := wrapSDKTransport(riskcontrol.NewTransport(network, nil)).RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-	if received.Get(riskcontrol.HeaderOSType) != "" || received.Get(riskcontrol.HeaderProductModel) != "" {
-		t.Fatalf("extension risk headers reached network: %v", received)
-	}
-}
-
 // TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader verifies that the
 // X-Cli-Build header is force-written by BuildHeaderTransport in the SDK
 // transport chain, even when an extension tries to delete or spoof it. This
@@ -327,7 +277,7 @@ func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{interceptor: buildTamperingInterceptor{}})
 	t.Cleanup(func() { exttransport.Register(nil) })

-	// Replicate the SDK chain layering used by wrapSDKTransport.
+	// Replicate the SDK chain layering used by buildSDKTransport.
 	var base http.RoundTripper = http.DefaultTransport
 	base = &RetryTransport{Base: base}
 	base = &UserAgentTransport{Base: base}
--- a/internal/core/config.go
+++ b/internal/core/config.go
@@ -60,18 +60,11 @@ func (a *AppConfig) ProfileName() string {
 // MultiAppConfig is the multi-app config file format.
 type MultiAppConfig struct {
 	StrictMode  StrictMode  `json:"strictMode,omitempty"`
-	RiskControl *bool       `json:"riskControl,omitempty"`
 	CurrentApp  string      `json:"currentApp,omitempty"`
 	PreviousApp string      `json:"previousApp,omitempty"`
 	Apps        []AppConfig `json:"apps"`
 }

-// RiskControlEnabled resolves the workspace policy. An omitted preference
-// keeps the default-on account-protection behavior.
-func (m *MultiAppConfig) RiskControlEnabled() bool {
-	return m != nil && (m.RiskControl == nil || *m.RiskControl)
-}
-
 // CurrentAppConfig returns the currently active app config.
 // Resolution priority: profileOverride > CurrentApp field > Apps[0].
 func (m *MultiAppConfig) CurrentAppConfig(profileOverride string) *AppConfig {
@@ -255,11 +248,7 @@ func ResolveConfigFromMulti(raw *MultiAppConfig, kc keychain.KeychainAccess, pro
 	}

 	if err := ValidateSecretKeyMatch(app.AppId, app.AppSecret); err != nil {
-		// invalid_config, not not_configured: the config exists but is
-		// internally inconsistent. not_configured would let callers degrade
-		// this into a generic "secret invalid" answer and destroy the precise
-		// repair hint (which names the expected keychain key — never a value).
-		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "appId and appSecret keychain key are out of sync").
+		return nil, errs.NewConfigError(errs.SubtypeNotConfigured, "appId and appSecret keychain key are out of sync").
 			WithHint("%s", err.Error()).
 			WithCause(err)
 	}
--- a/internal/core/config_snapshot.go
+++ b/internal/core/config_snapshot.go
@@ -1,37 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package core
-
-import (
-	"io/fs"
-	"sync"
-)
-
-// ConfigSnapshot lazily captures one stable view of config.json for a CLI
-// invocation. All runtime consumers share the same load result so account and
-// workspace policy resolution cannot observe different file revisions. Callers
-// must treat the returned config as read-only.
-type ConfigSnapshot struct {
-	load func() (*MultiAppConfig, error)
-}
-
-// NewConfigSnapshot creates a lazily loaded invocation-scoped config snapshot.
-func NewConfigSnapshot() *ConfigSnapshot {
-	return newConfigSnapshot(LoadMultiAppConfig)
-}
-
-func newConfigSnapshot(load func() (*MultiAppConfig, error)) *ConfigSnapshot {
-	if load == nil {
-		return &ConfigSnapshot{}
-	}
-	return &ConfigSnapshot{load: sync.OnceValues(load)}
-}
-
-// MultiAppConfig returns the captured persistent config and load error.
-func (s *ConfigSnapshot) MultiAppConfig() (*MultiAppConfig, error) {
-	if s == nil || s.load == nil {
-		return nil, fs.ErrNotExist
-	}
-	return s.load()
-}
--- a/internal/core/config_snapshot_test.go
+++ b/internal/core/config_snapshot_test.go
@@ -1,58 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package core
-
-import (
-	"errors"
-	"io/fs"
-	"testing"
-)
-
-func TestConfigSnapshotLoadsOnce(t *testing.T) {
-	calls := 0
-	want := &MultiAppConfig{}
-	snapshot := newConfigSnapshot(func() (*MultiAppConfig, error) {
-		calls++
-		return want, nil
-	})
-
-	for range 2 {
-		config, err := snapshot.MultiAppConfig()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if config != want {
-			t.Fatal("snapshot returned a different config instance")
-		}
-	}
-	if calls != 1 {
-		t.Fatalf("config loads = %d, want 1", calls)
-	}
-}
-
-func TestConfigSnapshotZeroValueIsMissing(t *testing.T) {
-	config, err := (&ConfigSnapshot{}).MultiAppConfig()
-	if config != nil || !errors.Is(err, fs.ErrNotExist) {
-		t.Fatalf("MultiAppConfig() = (%v, %v), want (nil, fs.ErrNotExist)", config, err)
-	}
-}
-
-func TestConfigSnapshotCachesError(t *testing.T) {
-	calls := 0
-	want := errors.New("load failed")
-	snapshot := newConfigSnapshot(func() (*MultiAppConfig, error) {
-		calls++
-		return nil, want
-	})
-
-	for range 2 {
-		config, err := snapshot.MultiAppConfig()
-		if config != nil || !errors.Is(err, want) {
-			t.Fatalf("MultiAppConfig() = (%v, %v), want (nil, %v)", config, err, want)
-		}
-	}
-	if calls != 1 {
-		t.Fatalf("config loads = %d, want 1", calls)
-	}
-}
--- a/internal/core/config_test.go
+++ b/internal/core/config_test.go
@@ -60,9 +60,7 @@ func TestAppConfig_LangOmitEmpty(t *testing.T) {
 }

 func TestMultiAppConfig_RoundTrip(t *testing.T) {
-	disabled := false
 	config := &MultiAppConfig{
-		RiskControl: &disabled,
 		Apps: []AppConfig{{
 			AppId: "cli_test", AppSecret: PlainSecret("s"),
 			Brand: BrandLark, Lang: "zh", Users: []AppUser{},
@@ -86,9 +84,6 @@ func TestMultiAppConfig_RoundTrip(t *testing.T) {
 	if got.Apps[0].Brand != BrandLark {
 		t.Errorf("Brand = %q, want %q", got.Apps[0].Brand, BrandLark)
 	}
-	if got.RiskControl == nil || *got.RiskControl {
-		t.Errorf("RiskControl = %v, want explicit false", got.RiskControl)
-	}
 }

 func TestResolveConfigFromMulti_RejectsSecretKeyMismatch(t *testing.T) {
--- a/internal/core/notconfigured.go
+++ b/internal/core/notconfigured.go
@@ -36,13 +36,16 @@ func LoadOrNotConfigured() (*MultiAppConfig, error) {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil, NotConfiguredError()
 		}
-		// Surface the real cause so the user can fix the broken file. Every
-		// non-ENOENT load failure — malformed JSON, permission denied, I/O
-		// error — means a config EXISTS but cannot be used: invalid_config.
-		// Only a genuinely absent config is not_configured; anything else
-		// classified as not_configured would let callers degrade it into
-		// profile_not_found / no_active_profile and hide the real cause.
-		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "failed to load config: %v", err).WithCause(err)
+		// Surface the real cause (parse error, permission denied, etc.)
+		// so the user can fix the broken file. A malformed file is
+		// invalid_config; anything else (permission denied, etc.) is
+		// not_configured. Both stay on the typed structured-envelope path
+		// at the root command's error sink.
+		subtype := errs.SubtypeNotConfigured
+		if isMalformedConfigError(err) {
+			subtype = errs.SubtypeInvalidConfig
+		}
+		return nil, errs.NewConfigError(subtype, "failed to load config: %v", err).WithCause(err)
 	}
 	if multi == nil || len(multi.Apps) == 0 {
 		return nil, NotConfiguredError()
--- a/internal/credential/authsidecar_contract_test.go
+++ b/internal/credential/authsidecar_contract_test.go
@@ -1,154 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-//go:build authsidecar
-
-package credential_test
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	extcred "github.com/larksuite/cli/extension/credential"
-	sidecarprovider "github.com/larksuite/cli/extension/credential/sidecar"
-	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/envvars"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/sidecar"
-)
-
-func newRealSidecarCredentialProvider(t *testing.T) *credential.CredentialProvider {
-	t.Helper()
-	t.Setenv(envvars.CliAuthProxy, "http://127.0.0.1:16384")
-	t.Setenv(envvars.CliProxyKey, "test-key")
-	t.Setenv(envvars.CliAppID, "cli_sidecar")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv(envvars.CliUserAccessToken, "")
-	t.Setenv(envvars.CliTenantAccessToken, "")
-	t.Setenv(envvars.CliDefaultAs, "")
-	t.Setenv(envvars.CliStrictMode, "")
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	return credential.NewCredentialProvider(
-		[]extcred.Provider{&sidecarprovider.Provider{}},
-		nil,
-		nil,
-		nil,
-	)
-}
-
-func TestAuthSidecarInvalidPolicyUsesValidationContract(t *testing.T) {
-	for _, tt := range []struct {
-		name string
-		key  string
-	}{
-		{name: "default as", key: envvars.CliDefaultAs},
-		{name: "strict mode", key: envvars.CliStrictMode},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			cp := newRealSidecarCredentialProvider(t)
-			t.Setenv(tt.key, "banana")
-
-			_, err := cp.ResolveAccount(context.Background())
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("error = %T %v, want typed validation error", err, err)
-			}
-			if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
-				t.Fatalf("problem = %s/%s, want %s/%s", problem.Category, problem.Subtype, errs.CategoryValidation, errs.SubtypeInvalidArgument)
-			}
-			var validationErr *errs.ValidationError
-			if !errors.As(err, &validationErr) {
-				t.Fatalf("error = %T %v, want ValidationError", err, err)
-			}
-			if validationErr.Param != tt.key {
-				t.Fatalf("param = %q, want %q", validationErr.Param, tt.key)
-			}
-			if got := output.ExitCodeOf(err); got != output.ExitValidation {
-				t.Fatalf("exit code = %d, want %d", got, output.ExitValidation)
-			}
-			if !strings.Contains(problem.Hint, tt.key) {
-				t.Fatalf("hint = %q, want variable name %s", problem.Hint, tt.key)
-			}
-			var blockErr *extcred.BlockError
-			if !errors.As(err, &blockErr) ||
-				blockErr.Code != extcred.BlockReasonInvalidPolicy ||
-				blockErr.Param != tt.key {
-				t.Fatalf("cause = %T %v, want classified BlockError for %s", err, err, tt.key)
-			}
-		})
-	}
-}
-
-func TestAuthSidecarGateProbeUsesValidationContract(t *testing.T) {
-	cp := newRealSidecarCredentialProvider(t)
-	t.Setenv(envvars.CliStrictMode, "banana")
-
-	name, err := cp.ActiveExtensionProviderName(context.Background())
-	if name != "" {
-		t.Fatalf("provider name = %q, want empty on invalid policy", name)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error = %T %v, want typed validation error", err, err)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("error = %T %v, want ValidationError", err, err)
-	}
-	if problem.Category != errs.CategoryValidation ||
-		problem.Subtype != errs.SubtypeInvalidArgument ||
-		validationErr.Param != envvars.CliStrictMode {
-		t.Fatalf("problem = %+v param = %q, want validation/invalid_argument param %s", problem, validationErr.Param, envvars.CliStrictMode)
-	}
-}
-
-func TestAuthSidecarTokenHonorsSelectedAppID(t *testing.T) {
-	t.Run("matching app returns sentinel", func(t *testing.T) {
-		cp := newRealSidecarCredentialProvider(t)
-
-		result, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
-			Type:  credential.TokenTypeUAT,
-			AppID: "cli_sidecar",
-		})
-		if err != nil {
-			t.Fatalf("ResolveToken: %v", err)
-		}
-		if result == nil || result.Token != sidecar.SentinelUAT {
-			t.Fatalf("result = %+v, want sidecar UAT sentinel", result)
-		}
-	})
-
-	for _, tt := range []struct {
-		name  string
-		appID string
-	}{
-		{name: "empty app id", appID: ""},
-		{name: "conflicting app id", appID: "cli_other"},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			cp := newRealSidecarCredentialProvider(t)
-
-			result, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
-				Type:  credential.TokenTypeUAT,
-				AppID: tt.appID,
-			})
-			if result != nil {
-				t.Fatalf("result = %+v, want no sidecar sentinel", result)
-			}
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("error = %T %v, want typed internal error", err, err)
-			}
-			if problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeUnknown {
-				t.Fatalf("problem = %s/%s, want %s/%s", problem.Category, problem.Subtype, errs.CategoryInternal, errs.SubtypeUnknown)
-			}
-			if strings.Contains(err.Error(), sidecar.SentinelUAT) {
-				t.Fatalf("error leaked sidecar sentinel: %v", err)
-			}
-		})
-	}
-}
--- a/internal/credential/credential_provider.go
+++ b/internal/credential/credential_provider.go
@@ -9,17 +9,11 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"
-	"slices"
-	"strings"
 	"sync"

-	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/envvars"
 )

 // DefaultAccountResolver is implemented by the default account provider.
@@ -142,21 +136,10 @@ type CredentialProvider struct {
 	httpClient   func() (*http.Client, error)
 	warnOut      io.Writer

-	// profile is the active profile (from --profile or LARKSUITE_CLI_PROFILE);
-	// profileSrc records which of the two supplied it, for the reported
-	// selection and error attribution.
-	profile    string
-	profileSrc CredentialSourceKind
-
 	accountOnce    sync.Once
 	account        *Account
 	accountErr     error
 	selectedSource credentialSource
-	// selection is the explainable credential-selection result, populated by
-	// doResolveAccount under accountOnce. It never carries a secret.
-	selection IdentitySelection
-
-	enrichOnce sync.Once

 	hintOnce sync.Once
 	hint     *IdentityHint
@@ -178,521 +161,49 @@ func (p *CredentialProvider) SetWarnOut(warnOut io.Writer) *CredentialProvider {
 	return p
 }

-// WithProfileFromFlag records the --profile flag value as the active profile.
-// It governs credential arbitration and the reported selection source.
-func (p *CredentialProvider) WithProfileFromFlag(profile string) *CredentialProvider {
-	p.profile = profile
-	p.profileSrc = SourceFlagProfile
-	return p
-}
-
-// WithProfileFromEnv records the LARKSUITE_CLI_PROFILE env fallback as the
-// active profile. It governs credential arbitration and the reported
-// selection source.
-func (p *CredentialProvider) WithProfileFromEnv(profile string) *CredentialProvider {
-	p.profile = profile
-	p.profileSrc = SourceEnvProfile
-	return p
-}
-
 // ResolveAccount resolves app credentials. Result is cached after first call.
 // NOTE: Uses sync.Once — only the context from the first call is used for resolution.
 // Subsequent calls return the cached result regardless of their context.
 // This is acceptable for CLI (single invocation per process) but not for long-running servers.
 func (p *CredentialProvider) ResolveAccount(ctx context.Context) (*Account, error) {
-	acct, err := p.resolveAccountSelection(ctx)
-	if err != nil || acct == nil {
-		return acct, err
-	}
-	if _, ok := p.selectedSource.(extensionTokenSource); ok {
-		p.enrichOnce.Do(func() {
-			p.enrichOrClearIdentity(ctx, acct, p.selectedSource)
-		})
-	}
-	return acct, nil
-}
-
-// resolveAccountSelection performs and caches only credential selection. It
-// deliberately does not resolve tokens or user_info, so callers can validate
-// the selected app before any token work begins.
-func (p *CredentialProvider) resolveAccountSelection(ctx context.Context) (*Account, error) {
 	p.accountOnce.Do(func() {
 		p.account, p.accountErr = p.doResolveAccount(ctx)
 	})
 	return p.account, p.accountErr
 }

-// doResolveAccount arbitrates the credential/App selection in three phases:
-// gather all arbitration inputs in a single I/O pass, decide the route with a
-// pure function, then execute the remaining I/O for the chosen route.
-//
-// Resolution order (encoded in decideIdentity): a managed extension provider
-// (e.g. sidecar) wins outright; then an explicit profile (--profile /
-// LARKSUITE_CLI_PROFILE) arbitrates against the direct env credential
-// (matching app_id → profile supplies credential and tokens; mismatch → hard
-// conflict; incomplete env without a usable app_id → repair error); then a
-// complete direct env credential; then the config default (currentApp →
-// firstApp).
-//
-// It populates p.selection (never carries a secret) and p.selectedSource on
-// every success path.
 func (p *CredentialProvider) doResolveAccount(ctx context.Context) (*Account, error) {
-	in, err := p.gatherIdentityInputs(ctx)
-	if err != nil {
-		return nil, err
-	}
-	d, err := decideIdentity(in)
-	if err != nil {
-		return nil, err
-	}
-	acct, source, err := p.execute(ctx, d, in)
-	if err != nil {
-		return nil, err
-	}
-	p.selectedSource = source
-	// Assigned only after full success: error paths can never leave a
-	// partial selection behind.
-	p.selection = d.selection
-	return acct, nil
-}
-
-// providerAccount pairs an extension-provider account with its token source.
-type providerAccount struct {
-	acct   *Account
-	source extensionTokenSource
-}
-
-// identityInputs is one invocation's complete arbitration input, gathered in
-// a single pass by gatherIdentityInputs. It is read-only after gathering;
-// decideIdentity consumes it without further I/O.
-type identityInputs struct {
-	profile    string
-	profileSrc CredentialSourceKind
-
-	managed *providerAccount // managed extension account; wins arbitration outright
-	direct  *providerAccount // complete direct env credential
-	// directBlock is a provider's explicit incomplete-direct-credential
-	// classification (BlockError.Code == credential_incomplete). It
-	// participates in profile arbitration instead of failing outright.
-	directBlock *extcred.BlockError
-
-	// directKeys / conflictKeys describe the BUILTIN process-env direct
-	// credential surface (LARKSUITE_CLI_* variable NAMES, never values).
-	// They annotate DirectCredentialEnv and conflict hints; a third-party
-	// AccountDirect provider reports its own inputs via BlockError metadata
-	// (PresentKeys/AppID), not through these.
-	directKeys   []string
-	conflictKeys []string
-
-	config    *core.MultiAppConfig
-	configErr error
-}
-
-// gatherIdentityInputs performs the arbitration's read phase: it consults the
-// extension providers and snapshots the config. Providers classify their own
-// failures at the source (BlockError.Code); this layer must not infer them by
-// re-reading environment variables or parsing Reason.
-func (p *CredentialProvider) gatherIdentityInputs(ctx context.Context) (identityInputs, error) {
-	in := identityInputs{
-		profile:      p.profile,
-		profileSrc:   p.profileSrc,
-		directKeys:   presentDirectCredentialKeys(),
-		conflictKeys: presentDirectCredentialInputKeys(),
-	}
 	for _, prov := range p.providers {
 		acct, err := prov.ResolveAccount(ctx)
 		if err != nil {
-			var blockErr *extcred.BlockError
-			if errors.As(err, &blockErr) {
-				switch blockErr.Code {
-				case extcred.BlockReasonCredentialIncomplete:
-					// app_credential_incomplete, profile matching, and
-					// DirectCredentialEnv diagnostics are defined in terms of
-					// the builtin LARKSUITE_CLI_* env surface. Until the SPI
-					// carries provider-owned input descriptors, accepting this
-					// classification from another provider would produce
-					// contradictory arbitration and repair hints.
-					if _, builtin := prov.(*envprovider.Provider); !builtin {
-						return in, newCredentialIncompleteProviderContractError(prov)
-					}
-					in.directBlock = blockErr
-				case extcred.BlockReasonInvalidPolicy:
-					// A user-supplied policy value failed validation; that is
-					// a validation error, never an internal one.
-					return in, newInvalidPolicyError(blockErr)
-				default:
-					// Blocks without a recognized Code preserve their
-					// original attribution.
-					return in, err
+			return nil, err
+		}
+		if acct != nil {
+			internal := convertAccount(acct)
+			source := extensionTokenSource{provider: prov}
+			if err := p.enrichUserInfo(ctx, internal, source); err != nil {
+				if p.warnOut != nil {
+					_, _ = fmt.Fprintf(p.warnOut, "warning: unable to verify user identity from credential source %q: %v\n", source.Name(), err)
 				}
-				break
+				// enrichUserInfo failure is non-fatal: SupportedIdentities
+				// (used for strict mode) is already set by the provider.
+				// Clear unverified user identity for safety.
+				internal.UserOpenId = ""
+				internal.UserName = ""
 			}
-			// Any other provider error preserves its original attribution.
-			return in, err
-		}
-		if acct == nil {
-			continue
-		}
-		pa := &providerAccount{acct: convertAccount(acct), source: extensionTokenSource{provider: prov}}
-		switch acct.Kind {
-		case extcred.AccountDirect:
-			// The arbitration's direct-credential surface — DirectCredentialEnv,
-			// the env:LARKSUITE_CLI_APP_ID selection source, conflict-hint
-			// keys — is defined in terms of the builtin process-env variables.
-			// Until the SPI carries provider-reported input descriptors, only
-			// the builtin env provider may declare AccountDirect; accepting it
-			// from anyone else would produce self-contradictory diagnostics
-			// (e.g. credentialSource "env:LARKSUITE_CLI_APP_ID" with
-			// directCredentialEnv.present=false). The check is by concrete
-			// type: the registry reserves neither names nor uniqueness, so a
-			// Name() comparison would be forgeable.
-			if _, builtin := prov.(*envprovider.Provider); !builtin {
-				return in, errs.NewInternalError(errs.SubtypeUnknown,
-					"credential provider %q declared AccountDirect, which is reserved for the builtin env provider", prov.Name())
-			}
-			in.direct = pa
-		case extcred.AccountManaged:
-			in.managed = pa
-		default:
-			return in, errs.NewInternalError(errs.SubtypeUnknown,
-				"credential provider %q returned unknown AccountKind %d", prov.Name(), acct.Kind)
-		}
-		break // the first engaged provider ends the scan (registry priority order)
-	}
-	// The config snapshot backs profile lookup, the config-default route, and
-	// config-default failure attribution. A winning managed or direct-env
-	// identity without a profile never needs it — and managed identities must
-	// keep working when the config is absent or malformed.
-	if in.managed == nil && (in.profile != "" || in.direct == nil) {
-		in.config, in.configErr = core.LoadOrNotConfigured()
-	}
-	return in, nil
-}
-
-// credentialRoute names which source serves the selected account and tokens.
-type credentialRoute int
-
-const (
-	routeManaged credentialRoute = iota
-	routeProfile
-	routeDirectEnv
-	routeConfigDefault
-)
-
-// decision is decideIdentity's complete verdict. Nothing in it touched I/O.
-type decision struct {
-	route     credentialRoute
-	selection IdentitySelection
-	// profileAppID is set on routeProfile; app_id is plaintext and safe to
-	// echo in the secret-invalid error.
-	profileAppID string
-}
-
-// decideIdentity holds every selection rule in one place: precedence
-// (managed > profile > direct env > config default), profile/direct-env
-// conflict detection, and error attribution. It is pure — same inputs, same
-// verdict — so the full selection matrix is table-testable without env vars
-// or config fixtures.
-func decideIdentity(in identityInputs) (decision, error) {
-	// DirectCredentialEnv reports the direct env vars truthfully on every
-	// route: Present always means "direct credential env vars are set".
-	directEnv := DirectCredentialEnv{Present: len(in.directKeys) > 0, Keys: in.directKeys}
-	if in.direct != nil {
-		directEnv.AppID = in.direct.acct.AppID
-	}
-	switch {
-	case in.managed != nil:
-		return decision{route: routeManaged, selection: IdentitySelection{
-			Source:              SourceExtension(in.managed.source.Name()),
-			DirectCredentialEnv: directEnv,
-		}}, nil
-	case in.profile != "":
-		return decideProfile(in, directEnv)
-	case in.directBlock != nil:
-		return decision{}, newAppCredentialIncompleteError(in.directBlock, false)
-	case in.direct != nil:
-		return decision{route: routeDirectEnv, selection: IdentitySelection{
-			Source:              SourceEnvAppID,
-			DirectCredentialEnv: directEnv,
-		}}, nil
-	default:
-		return decision{route: routeConfigDefault, selection: IdentitySelection{
-			Source:              selectionSourceForDefault(in.config),
-			DirectCredentialEnv: directEnv,
-		}}, nil
-	}
-}
-
-// decideProfile arbitrates an explicit profile against the direct env
-// credential state.
-func decideProfile(in identityInputs, directEnv DirectCredentialEnv) (decision, error) {
-	app, err := findProfile(in)
-	if err != nil {
-		return decision{}, err
-	}
-	if in.directBlock != nil {
-		// APP_ID-only is sufficient to compare sources: a matching selected
-		// profile supplies the credential and tokens; a mismatch is the same
-		// hard conflict as a complete direct env. Anything less than a usable
-		// app_id keeps the provider's repair error, extended with the
-		// unset-to-use-the-profile path.
-		if in.directBlock.AppID == "" || !slices.Contains(in.directBlock.PresentKeys, envvars.CliAppID) {
-			return decision{}, newAppCredentialIncompleteError(in.directBlock, true)
-		}
-		if app.AppId != in.directBlock.AppID {
-			return decision{}, newProfileAppCredentialConflict(
-				in.profile, app.AppId, in.directBlock.AppID, in.directBlock.PresentKeys)
-		}
-		directEnv.AppID = in.directBlock.AppID
-		directEnv.Matched = true
-	}
-	if in.direct != nil {
-		// E == complete: the direct env app_id must match the profile.
-		if app.AppId != in.direct.acct.AppID {
-			return decision{}, newProfileAppCredentialConflict(
-				in.profile, app.AppId, in.direct.acct.AppID, in.conflictKeys)
-		}
-		directEnv.Matched = true
-	}
-	return decision{
-		route:        routeProfile,
-		selection:    IdentitySelection{Source: in.profileSrc, DirectCredentialEnv: directEnv},
-		profileAppID: app.AppId,
-	}, nil
-}
-
-// findProfile resolves the requested profile against the config snapshot.
-// A malformed config must surface its real typed cause (invalid_config):
-// reporting it as profile_not_found would send the user to `profile list`
-// and hide the broken file. Only a genuinely absent config degrades to
-// profile_not_found, because the profile then cannot exist anywhere. Both
-// deliberately outrank an incomplete direct env: fixing the profile side is
-// what makes the selected profile usable.
-func findProfile(in identityInputs) (*core.AppConfig, error) {
-	if in.configErr != nil {
-		if prob, ok := errs.ProblemOf(in.configErr); !ok || prob.Subtype != errs.SubtypeNotConfigured {
-			return nil, in.configErr
+			p.selectedSource = source
+			return internal, nil
 		}
 	}
-	if in.config != nil {
-		if app := in.config.FindApp(in.profile); app != nil {
-			return app, nil
-		}
-	}
-	return nil, errs.NewConfigError(errs.SubtypeProfileNotFound,
-		"profile %q not found", in.profile).
-		WithProfile(in.profile).
-		WithCredentialSource(string(in.profileSrc)).
-		WithHint("run `lark-cli profile list` to see available profiles.")
-}
-
-// execute performs the remaining I/O for the decided route and returns the
-// account together with its token source.
-func (p *CredentialProvider) execute(ctx context.Context, d decision, in identityInputs) (*Account, credentialSource, error) {
-	switch d.route {
-	case routeManaged:
-		return in.managed.acct, in.managed.source, nil
-	case routeDirectEnv:
-		return in.direct.acct, in.direct.source, nil
-	case routeProfile:
-		// Resolve the profile's own (keychain-backed) credential locally.
+	if p.defaultAcct != nil {
 		acct, err := p.defaultAcct.ResolveAccount(ctx)
 		if err != nil {
-			// A typed failure other than not_configured carries its own
-			// precise, secret-free diagnosis (typed errors never embed secret
-			// material per the error contract) — pass it through instead of
-			// flattening it into the generic secret error. Untyped failures
-			// and a config that vanished mid-resolution stay masked: their
-			// content is not guaranteed secret-free.
-			if prob, ok := errs.ProblemOf(err); ok && prob.Subtype != errs.SubtypeNotConfigured {
-				return nil, nil, err
-			}
-			return nil, nil, newProfileSecretInvalidError(in.profile, d.profileAppID)
+			return nil, err
 		}
-		// The resolver re-reads the config; a concurrent profile edit between
-		// gather and here could hand back a different app. Refuse the mismatch
-		// instead of silently using credentials the arbitration never checked.
-		if acct.AppID != d.profileAppID {
-			return nil, nil, errs.NewInternalError(errs.SubtypeUnknown,
-				"config changed during resolution: profile %q resolved to a different app", in.profile).
-				WithHint("retry the command.")
-		}
-		return acct, defaultTokenSource{resolver: p.defaultToken}, nil
-	default: // routeConfigDefault
-		if p.defaultAcct == nil {
-			return nil, nil, core.NotConfiguredError()
-		}
-		acct, err := p.defaultAcct.ResolveAccount(ctx)
-		if err != nil {
-			return nil, nil, translateConfigDefaultFailure(err, in.config)
-		}
-		return acct, defaultTokenSource{resolver: p.defaultToken}, nil
+		p.selectedSource = defaultTokenSource{resolver: p.defaultToken}
+		return acct, nil
 	}
-}
-
-// translateConfigDefaultFailure attributes a config-default failure from the
-// snapshot: a default profile that EXISTS (has an app_id) but whose secret
-// cannot be resolved locally is profile_secret_invalid — "identity is
-// configured, its secret is broken" is more actionable than "no active
-// profile". Only when there is genuinely no usable default profile do we
-// report no_active_profile. Other typed failures pass through unchanged.
-func translateConfigDefaultFailure(err error, multi *core.MultiAppConfig) error {
-	if prob, ok := errs.ProblemOf(err); !ok || prob.Subtype != errs.SubtypeNotConfigured {
-		return err
-	}
-	if multi != nil {
-		if app := multi.CurrentAppConfig(""); app != nil && app.AppId != "" {
-			return newProfileSecretInvalidError(app.ProfileName(), app.AppId)
-		}
-	}
-	return errs.NewConfigError(errs.SubtypeNoActiveProfile, "no active profile").
-		WithCredentialSource(noActiveProfileCredentialSource).
-		WithHint("run `lark-cli config init` / `lark-cli profile add`, or set %s.", envvars.CliProfile)
-}
-
-func newProfileAppCredentialConflict(profile, profileAppID, envAppID string, presentKeys []string) error {
-	err := errs.NewValidationError(errs.SubtypeProfileAppCredentialConflict,
-		"profile %q app_id does not match %s", profile, envvars.CliAppID).
-		WithProfileAppConflict(profileAppID, envAppID)
-	if len(presentKeys) > 0 {
-		return err.WithHint("unset %s, or select a profile whose app_id matches the environment.",
-			humanList(presentKeys, "and"))
-	}
-	return err.WithHint("unset the direct credential environment variables, or select a profile whose app_id matches the environment.")
-}
-
-func newAppCredentialIncompleteError(blockErr *extcred.BlockError, selectedProfileAvailable bool) *errs.ConfigError {
-	err := errs.NewConfigError(errs.SubtypeAppCredentialIncomplete, "%s", blockErr.Reason).
-		WithCause(blockErr)
-	if len(blockErr.MissingKeys) > 0 {
-		err.WithMissingKeys(blockErr.MissingKeys...)
-	}
-	if len(blockErr.RequiredAnyOf) > 0 {
-		err.WithRequiredAnyOf(blockErr.RequiredAnyOf...)
-	}
-
-	hint := credentialRepairHint(blockErr)
-	if selectedProfileAvailable && len(blockErr.PresentKeys) > 0 {
-		hint += fmt.Sprintf(", or unset %s to use the selected profile", humanList(blockErr.PresentKeys, "and"))
-	}
-	return err.WithHint("%s.", hint)
-}
-
-func credentialRepairHint(blockErr *extcred.BlockError) string {
-	if len(blockErr.RequiredAnyOf) > 0 {
-		return "set " + humanList(blockErr.RequiredAnyOf, "or")
-	}
-	return "set " + humanList(blockErr.MissingKeys, "and")
-}
-
-func humanList(items []string, conjunction string) string {
-	switch len(items) {
-	case 0:
-		return "the missing direct credential variables"
-	case 1:
-		return items[0]
-	case 2:
-		return items[0] + " " + conjunction + " " + items[1]
-	default:
-		return strings.Join(items[:len(items)-1], ", ") + ", " + conjunction + " " + items[len(items)-1]
-	}
-}
-
-// newInvalidPolicyError translates a provider's invalid-policy block into the
-// typed validation contract: the failed variable name travels in param, the
-// repair path in the hint, and the original block stays on the cause chain.
-// Reason carries only the variable name and its non-secret value.
-func newInvalidPolicyError(blockErr *extcred.BlockError) error {
-	return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", blockErr.Reason).
-		WithParam(blockErr.Param).
-		WithCause(blockErr).
-		WithHint("set %s to a supported value or unset it.", blockErr.Param)
-}
-
-func newCredentialIncompleteProviderContractError(prov extcred.Provider) error {
-	return errs.NewInternalError(errs.SubtypeUnknown,
-		"credential provider %q returned credential_incomplete, which is reserved for the builtin env provider", prov.Name())
-}
-
-// newProfileSecretInvalidError is deliberately generic (SECURITY): the
-// underlying cause may carry secret material, so neither it nor its message
-// may reach the envelope. app_id is plaintext and safe to echo.
-func newProfileSecretInvalidError(profile, appID string) error {
-	return errs.NewConfigError(errs.SubtypeProfileSecretInvalid,
-		"profile %q credential could not be resolved locally", profile).
-		WithProfile(profile).
-		WithAppID(appID).
-		WithHint("verify the profile's app secret or re-add the profile with `lark-cli config`.")
-}
-
-// enrichOrClearIdentity verifies a provider-supplied user identity via
-// enrichUserInfo. Verification failure is non-fatal — SupportedIdentities
-// (used for strict mode) is already set by the provider — but an unverified
-// identity must not survive it: a stale OpenID would attribute calls to a
-// user the token can no longer act for.
-func (p *CredentialProvider) enrichOrClearIdentity(ctx context.Context, acct *Account, source credentialSource) {
-	err := p.enrichUserInfo(ctx, acct, source)
-	if err == nil {
-		return
-	}
-	if p.warnOut != nil {
-		_, _ = fmt.Fprintf(p.warnOut, "warning: unable to verify user identity from credential source %q: %v\n", source.Name(), err)
-	}
-	acct.UserOpenId = ""
-	acct.UserName = ""
-}
-
-// noActiveProfileCredentialSource is the credential_source reported on the
-// no_active_profile error. The error contract fixes this to the literal "config": there is
-// no resolved default profile at all, so the more specific config:currentApp /
-// config:firstApp source values (used on successful config-default selections)
-// would be misleading. It is an enum string, never a secret.
-const noActiveProfileCredentialSource = "config"
-
-// selectionSourceForDefault reports whether the config default resolved to the
-// explicit currentApp or fell back to the first app.
-func selectionSourceForDefault(multi *core.MultiAppConfig) CredentialSourceKind {
-	if multi != nil && multi.CurrentApp != "" {
-		return SourceConfigCurrentApp
-	}
-	return SourceConfigFirstApp
-}
-
-// presentDirectCredentialKeys returns the NAMES (never values) of the direct
-// app credential env vars that are set. Used to annotate DirectCredentialEnv.
-func presentDirectCredentialKeys() []string {
-	var keys []string
-	if os.Getenv(envvars.CliAppID) != "" {
-		keys = append(keys, envvars.CliAppID)
-	}
-	if os.Getenv(envvars.CliAppSecret) != "" {
-		keys = append(keys, envvars.CliAppSecret)
-	}
-	return keys
-}
-
-// presentDirectCredentialInputKeys returns all direct env input names that
-// must be cleared together to remove a profile/app_id conflict. Values are
-// never returned.
-func presentDirectCredentialInputKeys() []string {
-	keys := presentDirectCredentialKeys()
-	if os.Getenv(envvars.CliUserAccessToken) != "" {
-		keys = append(keys, envvars.CliUserAccessToken)
-	}
-	if os.Getenv(envvars.CliTenantAccessToken) != "" {
-		keys = append(keys, envvars.CliTenantAccessToken)
-	}
-	return keys
-}
-
-// Selection resolves the account (once) and returns the cached, secret-free
-// explanation of how the credential/App was selected. It mirrors
-// selectedCredentialSource: resolve-then-return.
-func (p *CredentialProvider) Selection(ctx context.Context) (IdentitySelection, error) {
-	if _, err := p.ResolveAccount(ctx); err != nil {
-		return IdentitySelection{}, err
-	}
-	return p.selection, nil
+	return nil, core.NotConfiguredError()
 }

 // enrichUserInfo resolves user identity when extension provides a UAT.
@@ -728,13 +239,17 @@ func (p *CredentialProvider) enrichUserInfo(ctx context.Context, acct *Account,
 }

 func (p *CredentialProvider) selectedCredentialSource(ctx context.Context) (credentialSource, error) {
-	if _, err := p.resolveAccountSelection(ctx); err != nil {
+	if p.selectedSource != nil {
+		return p.selectedSource, nil
+	}
+	if p.defaultAcct == nil {
+		return nil, nil
+	}
+	if _, err := p.ResolveAccount(ctx); err != nil {
 		return nil, err
 	}
 	if p.selectedSource == nil {
-		return nil, errs.NewInternalError(errs.SubtypeUnknown,
-			"credential provider resolved an account without selecting a token source").
-			WithHint("retry the command.")
+		return nil, fmt.Errorf("credential provider resolved an account without selecting a token source")
 	}
 	return p.selectedSource, nil
 }
@@ -787,88 +302,51 @@ func (p *CredentialProvider) doResolveIdentityHint(ctx context.Context) (*Identi

 // ResolveToken resolves an access token.
 func (p *CredentialProvider) ResolveToken(ctx context.Context, req TokenSpec) (*TokenResult, error) {
-	acct, err := p.resolveAccountSelection(ctx)
+	source, err := p.selectedCredentialSource(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if acct == nil {
-		return nil, errs.NewInternalError(errs.SubtypeUnknown,
-			"credential provider resolved no account before %s token resolution", req.Type).
-			WithHint("retry the command.")
+	if source != nil {
+		return resolveTokenFromSource(ctx, source, req)
 	}
-	source := p.selectedSource
-	if source == nil {
-		return nil, errs.NewInternalError(errs.SubtypeUnknown,
-			"credential provider resolved app %q without selecting a token source", acct.AppID).
-			WithHint("retry the command.")
+
+	for _, prov := range p.providers {
+		source := extensionTokenSource{provider: prov}
+		result, found, err := source.TryResolveToken(ctx, req)
+		if err != nil {
+			return nil, err
+		}
+		if found {
+			return result, nil
+		}
 	}
-	if req.AppID == "" {
-		return nil, errs.NewInternalError(errs.SubtypeUnknown,
-			"TokenSpec.AppID is required for %s token resolution", req.Type).
-			WithHint("retry the command.")
+	source = defaultTokenSource{resolver: p.defaultToken}
+	result, found, err := source.TryResolveToken(ctx, req)
+	if err != nil {
+		return nil, err
 	}
-	if req.AppID != acct.AppID {
-		return nil, errs.NewInternalError(errs.SubtypeUnknown,
-			"token requested for app %q but the selected account belongs to app %q", req.AppID, acct.AppID).
-			WithHint("retry the command.")
+	if found {
+		return result, nil
 	}
-	return resolveTokenFromSource(ctx, source, req)
+	return nil, &TokenUnavailableError{Type: req.Type}
 }

 // ActiveExtensionProviderName reports whether an extension provider is managing
-// the credentials that actually win selection. With an explicit profile that
-// resolves successfully it reuses ResolveAccount's cached arbitration result;
-// otherwise it probes extension providers directly and returns the first
-// engaged provider.
+// credentials. It probes p.providers (extension providers only, not defaultAcct)
+// and returns the name of the first engaged provider.
 //
 // "Engaged" means: ResolveAccount returns a non-nil account, OR returns a
 // *extcred.BlockError (provider configured but misconfigured — still counts as
-// external). Any other probe error is propagated to the caller.
-//
-// A failed profile resolution (profile not found, broken secret, malformed
-// config, incomplete direct env, ...) deliberately does NOT propagate: this
-// probe guards the builtin setup/repair commands (auth, config), and an
-// unresolvable credential must never lock the user out of the commands that
-// fix it. It falls back to the engagement probe, which answers the only
-// question this function owns: is an extension provider holding credentials?
+// external). Any other error is propagated to the caller.
 //
 // Returns ("", nil) when no extension provider is active (built-in keychain path).
-// Safe to call multiple times: explicit-profile resolution uses sync.Once, while
-// the probe path only consults providers.
+// Safe to call multiple times — probes providers directly without the sync.Once cache.
 func (p *CredentialProvider) ActiveExtensionProviderName(ctx context.Context) (string, error) {
-	// With an explicit profile, report the source that actually won the same
-	// arbitration used by commands. A matching APP_ID-only env block is not an
-	// external takeover once the selected profile supplies credentials/tokens.
-	if p.profile != "" {
-		if _, err := p.ResolveAccount(ctx); err == nil {
-			if p.selectedSource == nil {
-				return "", nil
-			}
-			if _, builtin := p.selectedSource.(defaultTokenSource); builtin {
-				return "", nil
-			}
-			return p.selectedSource.Name(), nil
-		}
-		// Resolution failed — fall through to the engagement probe.
-	}
 	for _, prov := range p.providers {
 		acct, err := prov.ResolveAccount(ctx)
 		if err != nil {
 			var blockErr *extcred.BlockError
 			if errors.As(err, &blockErr) {
-				// Align with formal arbitration: a misconfigured policy
-				// variable is the same typed validation error everywhere —
-				// not an external takeover of the provider that reported it,
-				// and not license to keep scanning and blame a later
-				// provider instead.
-				if blockErr.Code == extcred.BlockReasonInvalidPolicy {
-					return "", newInvalidPolicyError(blockErr)
-				}
-				if blockErr.Code == extcred.BlockReasonCredentialIncomplete {
-					if _, builtin := prov.(*envprovider.Provider); !builtin {
-						return "", newCredentialIncompleteProviderContractError(prov)
-					}
-				}
 				name := blockErr.Provider
 				if name == "" {
 					name = prov.Name()
--- a/internal/credential/credential_provider_selection_test.go
+++ b/internal/credential/credential_provider_selection_test.go
--- a/internal/credential/credential_provider_test.go
+++ b/internal/credential/credential_provider_test.go
@@ -11,7 +11,6 @@ import (
 	"strings"
 	"testing"

-	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/core"
@@ -24,7 +23,6 @@ type mockExtProvider struct {
 	err        error
 	accountErr error
 	tokenErr   error
-	tokenCalls int
 }

 func (m *mockExtProvider) Name() string { return m.name }
@@ -35,7 +33,6 @@ func (m *mockExtProvider) ResolveAccount(ctx context.Context) (*extcred.Account,
 	return m.account, m.err
 }
 func (m *mockExtProvider) ResolveToken(ctx context.Context, req extcred.TokenSpec) (*extcred.Token, error) {
-	m.tokenCalls++
 	if m.tokenErr != nil {
 		return nil, m.tokenErr
 	}
@@ -52,13 +49,11 @@ func (m *mockDefaultAcct) ResolveAccount(ctx context.Context) (*Account, error)
 }

 type mockDefaultToken struct {
-	result     *TokenResult
-	err        error
-	tokenCalls int
+	result *TokenResult
+	err    error
 }

 func (m *mockDefaultToken) ResolveToken(ctx context.Context, req TokenSpec) (*TokenResult, error) {
-	m.tokenCalls++
 	return m.result, m.err
 }

@@ -121,45 +116,35 @@ func TestCredentialProvider_AccountCached(t *testing.T) {
 }

 func TestCredentialProvider_TokenFromExtension(t *testing.T) {
-	for _, sourceName := range []string{"env", "authsidecar"} {
-		t.Run(sourceName, func(t *testing.T) {
-			cp := NewCredentialProvider(
-				[]extcred.Provider{&mockExtProvider{
-					name:    sourceName,
-					account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-					token:   &extcred.Token{Value: "ext_tok", Source: sourceName},
-				}},
-				&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-				&mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
-			)
-			result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
-			if err != nil {
-				t.Fatal(err)
-			}
-			if result.Token != "ext_tok" {
-				t.Errorf("expected ext_tok, got %s", result.Token)
-			}
-		})
+	cp := NewCredentialProvider(
+		[]extcred.Provider{&mockExtProvider{
+			name:    "env",
+			account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
+			token:   &extcred.Token{Value: "ext_tok", Source: "env"},
+		}},
+		&mockDefaultAcct{}, &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
+	)
+	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Token != "ext_tok" {
+		t.Errorf("expected ext_tok, got %s", result.Token)
 	}
 }

 func TestCredentialProvider_TokenFallsToDefault(t *testing.T) {
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
 	cp := NewCredentialProvider(
 		[]extcred.Provider{&mockExtProvider{name: "skip"}},
-		&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-		defaultToken, nil,
+		&mockDefaultAcct{}, &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
 	)
-	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err != nil {
 		t.Fatal(err)
 	}
 	if result.Token != "default_tok" {
 		t.Errorf("expected default_tok, got %s", result.Token)
 	}
-	if defaultToken.tokenCalls != 1 {
-		t.Fatalf("default ResolveToken() calls = %d, want 1", defaultToken.tokenCalls)
-	}
 }

 func TestCredentialProvider_TokenDoesNotMixSourcesAfterDefaultAccountSelection(t *testing.T) {
@@ -174,7 +159,7 @@ func TestCredentialProvider_TokenDoesNotMixSourcesAfterDefaultAccountSelection(t
 		t.Fatalf("ResolveAccount() error = %v", err)
 	}

-	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err != nil {
 		t.Fatalf("ResolveToken() error = %v", err)
 	}
@@ -196,7 +181,7 @@ func TestCredentialProvider_SelectedSourceWithoutTokenReturnsUnavailableError(t
 		t.Fatalf("ResolveAccount() error = %v", err)
 	}

-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil {
 		t.Fatal("ResolveToken() error = nil, want unavailable error")
 	}
@@ -217,7 +202,7 @@ func TestCredentialProvider_ResolveTokenPropagatesNonBlockExtensionError(t *test
 		nil,
 	)

-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil || err.Error() != "provider exploded" {
 		t.Fatalf("ResolveToken() error = %v, want provider exploded", err)
 	}
@@ -327,12 +312,12 @@ func TestCredentialProvider_ResolveIdentityHint_CachesResult(t *testing.T) {
 func TestCredentialProvider_ResolveTokenTreatsEmptyDefaultTokenAsMalformed(t *testing.T) {
 	cp := NewCredentialProvider(
 		nil,
-		&mockDefaultAcct{account: &Account{AppID: "default_app"}},
+		nil,
 		&mockDefaultToken{result: &TokenResult{Token: ""}},
 		nil,
 	)

-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil || !strings.Contains(err.Error(), "empty token") {
 		t.Fatalf("ResolveToken() error = %v, want malformed empty token error", err)
 	}
@@ -425,189 +410,17 @@ func TestCredentialProvider_ResolveAccountWarnsWhenExtensionIdentityVerification
 }

 func TestCredentialProvider_ResolveTokenDoesNotBypassFailedDefaultAccountResolution(t *testing.T) {
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
 	cp := NewCredentialProvider(
 		nil,
 		&mockDefaultAcct{err: errors.New("config unavailable")},
-		defaultToken,
+		&mockDefaultToken{result: &TokenResult{Token: "default_tok"}},
 		nil,
 	)

-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil || err.Error() != "config unavailable" {
 		t.Fatalf("ResolveToken() error = %v, want config unavailable", err)
 	}
-	if defaultToken.tokenCalls != 0 {
-		t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsUnboundAppBeforeExtensionIO(t *testing.T) {
-	tests := []struct {
-		name  string
-		appID string
-	}{
-		{name: "empty app id"},
-		{name: "different app id", appID: "other_app"},
-	}
-
-	for _, tt := range tests {
-		for _, sourceName := range []string{"env", "authsidecar"} {
-			t.Run(tt.name+"/"+sourceName, func(t *testing.T) {
-				provider := &mockExtProvider{
-					name:    sourceName,
-					account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-					token:   &extcred.Token{Value: "ext_tok", Source: sourceName},
-				}
-				httpClientCalls := 0
-				cp := NewCredentialProvider(
-					[]extcred.Provider{provider},
-					&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-					&mockDefaultToken{result: &TokenResult{Token: "default_tok"}},
-					func() (*http.Client, error) {
-						httpClientCalls++
-						return nil, errors.New("unexpected user_info call")
-					},
-				)
-
-				_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: tt.appID})
-				if err == nil {
-					t.Fatal("ResolveToken() error = nil, want app binding error")
-				}
-				assertInternalUnknownWithRetryHint(t, err)
-				if provider.tokenCalls != 0 {
-					t.Fatalf("extension ResolveToken() calls = %d, want 0", provider.tokenCalls)
-				}
-				if httpClientCalls != 0 {
-					t.Fatalf("httpClient() calls = %d, want 0", httpClientCalls)
-				}
-			})
-		}
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsUnboundAppBeforeDefaultIO(t *testing.T) {
-	tests := []struct {
-		name  string
-		appID string
-	}{
-		{name: "empty app id"},
-		{name: "different app id", appID: "other_app"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
-			cp := NewCredentialProvider(
-				nil,
-				&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-				defaultToken,
-				nil,
-			)
-
-			_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: tt.appID})
-			if err == nil {
-				t.Fatal("ResolveToken() error = nil, want app binding error")
-			}
-			assertInternalUnknownWithRetryHint(t, err)
-			if defaultToken.tokenCalls != 0 {
-				t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-			}
-		})
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsNilAccountBeforeTokenIO(t *testing.T) {
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
-	cp := NewCredentialProvider(
-		nil,
-		&mockDefaultAcct{},
-		defaultToken,
-		nil,
-	)
-
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "requested_app"})
-	if err == nil {
-		t.Fatal("ResolveToken() error = nil, want nil account error")
-	}
-	assertInternalUnknownWithRetryHint(t, err)
-	if defaultToken.tokenCalls != 0 {
-		t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsMissingSelectedSourceWithoutFallback(t *testing.T) {
-	extension := &mockExtProvider{
-		name:  "env",
-		token: &extcred.Token{Value: "ext_tok", Source: "env"},
-	}
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
-	cp := NewCredentialProvider(
-		[]extcred.Provider{extension},
-		&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-		defaultToken,
-		nil,
-	)
-	cp.account = &Account{AppID: "selected_app"}
-	cp.accountOnce.Do(func() {})
-
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "selected_app"})
-	if err == nil {
-		t.Fatal("ResolveToken() error = nil, want missing selected source error")
-	}
-	assertInternalUnknownWithRetryHint(t, err)
-	if extension.tokenCalls != 0 {
-		t.Fatalf("extension ResolveToken() calls = %d, want 0", extension.tokenCalls)
-	}
-	if defaultToken.tokenCalls != 0 {
-		t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-	}
-}
-
-func TestCredentialProvider_ResolveTokenMatchingExtensionDoesNotEnrichIdentity(t *testing.T) {
-	provider := &mockExtProvider{
-		name:    "env",
-		account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-		token:   &extcred.Token{Value: "ext_tok", Source: "env"},
-	}
-	httpClientCalls := 0
-	cp := NewCredentialProvider(
-		[]extcred.Provider{provider},
-		nil,
-		nil,
-		func() (*http.Client, error) {
-			httpClientCalls++
-			return nil, errors.New("unexpected user_info call")
-		},
-	)
-
-	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
-	if err != nil {
-		t.Fatalf("ResolveToken() error = %v", err)
-	}
-	if result.Token != "ext_tok" {
-		t.Fatalf("ResolveToken() token = %q, want %q", result.Token, "ext_tok")
-	}
-	if provider.tokenCalls != 1 {
-		t.Fatalf("extension ResolveToken() calls = %d, want 1", provider.tokenCalls)
-	}
-	if httpClientCalls != 0 {
-		t.Fatalf("httpClient() calls = %d, want 0", httpClientCalls)
-	}
-}
-
-func assertInternalUnknownWithRetryHint(t *testing.T, err error) {
-	t.Helper()
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error type = %T, want typed internal error", err)
-	}
-	if problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeUnknown {
-		t.Fatalf("error problem = %+v, want internal/unknown", problem)
-	}
-	if problem.Hint != "retry the command." {
-		t.Fatalf("error hint = %q, want retry hint", problem.Hint)
-	}
 }

 func TestActiveExtensionProviderName_ExtActive(t *testing.T) {
--- a/internal/credential/decide_test.go
+++ b/internal/credential/decide_test.go
@@ -1,181 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package credential
-
-import (
-	"context"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	extcred "github.com/larksuite/cli/extension/credential"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/envvars"
-)
-
-// stubDecideProvider satisfies extcred.Provider for building providerAccount
-// literals; decideIdentity only ever calls Name() on it.
-type stubDecideProvider struct{ name string }
-
-func (s stubDecideProvider) Name() string  { return s.name }
-func (s stubDecideProvider) Priority() int { return 0 }
-func (s stubDecideProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
-	return nil, nil
-}
-func (s stubDecideProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
-	return nil, nil
-}
-
-func pa(providerName, appID string) *providerAccount {
-	return &providerAccount{
-		acct:   &Account{AppID: appID},
-		source: extensionTokenSource{provider: stubDecideProvider{name: providerName}},
-	}
-}
-
-func appIDOnlyBlock(appID string) *extcred.BlockError {
-	return &extcred.BlockError{
-		Provider:      "env",
-		Reason:        envvars.CliAppID + " is set but no app secret or access token is available",
-		Code:          extcred.BlockReasonCredentialIncomplete,
-		RequiredAnyOf: []string{envvars.CliAppSecret, envvars.CliUserAccessToken, envvars.CliTenantAccessToken},
-		PresentKeys:   []string{envvars.CliAppID},
-		AppID:         appID,
-	}
-}
-
-func uatOnlyBlock() *extcred.BlockError {
-	return &extcred.BlockError{
-		Provider:    "env",
-		Reason:      envvars.CliUserAccessToken + " is set but " + envvars.CliAppID + " is missing",
-		Code:        extcred.BlockReasonCredentialIncomplete,
-		MissingKeys: []string{envvars.CliAppID},
-		PresentKeys: []string{envvars.CliUserAccessToken},
-	}
-}
-
-// TestDecideIdentity exercises the selection matrix as data: decideIdentity is
-// pure, so every rule (precedence, conflict detection, error attribution) is
-// table-testable without env vars or config fixtures.
-func TestDecideIdentity(t *testing.T) {
-	tenantA := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps:       []core.AppConfig{{Name: "tenant_a", AppId: "cli_a"}},
-	}
-	noCurrent := &core.MultiAppConfig{
-		Apps: []core.AppConfig{{Name: "tenant_a", AppId: "cli_a"}},
-	}
-	invalidConfigErr := errs.NewConfigError(errs.SubtypeInvalidConfig, "invalid config format")
-	notConfiguredErr := core.NotConfiguredError()
-
-	cases := []struct {
-		name    string
-		in      identityInputs
-		route   credentialRoute
-		source  CredentialSourceKind
-		matched bool
-		subtype errs.Subtype // "" = success expected
-	}{
-		{
-			name:   "managed provider wins over explicit profile",
-			in:     identityInputs{profile: "tenant_a", profileSrc: SourceFlagProfile, managed: pa("sidecar", "sidecar_app"), config: tenantA},
-			route:  routeManaged,
-			source: SourceExtension("sidecar"),
-		},
-		{
-			name:    "profile conflicts with complete direct env app_id",
-			in:      identityInputs{profile: "tenant_a", profileSrc: SourceFlagProfile, direct: pa("env", "cli_x"), directKeys: []string{envvars.CliAppID, envvars.CliAppSecret}, config: tenantA},
-			subtype: errs.SubtypeProfileAppCredentialConflict,
-		},
-		{
-			name:    "matched complete direct env yields profile route",
-			in:      identityInputs{profile: "tenant_a", profileSrc: SourceEnvProfile, direct: pa("env", "cli_a"), directKeys: []string{envvars.CliAppID, envvars.CliAppSecret}, config: tenantA},
-			route:   routeProfile,
-			source:  SourceEnvProfile,
-			matched: true,
-		},
-		{
-			name:    "APP_ID-only block matching the profile yields profile route",
-			in:      identityInputs{profile: "tenant_a", profileSrc: SourceFlagProfile, directBlock: appIDOnlyBlock("cli_a"), directKeys: []string{envvars.CliAppID}, config: tenantA},
-			route:   routeProfile,
-			source:  SourceFlagProfile,
-			matched: true,
-		},
-		{
-			name:    "APP_ID-only block mismatching the profile is a hard conflict",
-			in:      identityInputs{profile: "tenant_a", profileSrc: SourceFlagProfile, directBlock: appIDOnlyBlock("cli_x"), directKeys: []string{envvars.CliAppID}, config: tenantA},
-			subtype: errs.SubtypeProfileAppCredentialConflict,
-		},
-		{
-			name:    "UAT-only block with a valid profile keeps the repair error",
-			in:      identityInputs{profile: "tenant_a", profileSrc: SourceFlagProfile, directBlock: uatOnlyBlock(), config: tenantA},
-			subtype: errs.SubtypeAppCredentialIncomplete,
-		},
-		{
-			name:    "block without profile is app_credential_incomplete",
-			in:      identityInputs{directBlock: appIDOnlyBlock("cli_a"), directKeys: []string{envvars.CliAppID}},
-			subtype: errs.SubtypeAppCredentialIncomplete,
-		},
-		{
-			name:   "complete direct env without profile wins",
-			in:     identityInputs{direct: pa("env", "cli_env"), directKeys: []string{envvars.CliAppID, envvars.CliAppSecret}},
-			route:  routeDirectEnv,
-			source: SourceEnvAppID,
-		},
-		{
-			name:    "malformed config is not masked as profile_not_found",
-			in:      identityInputs{profile: "tenant_a", profileSrc: SourceFlagProfile, configErr: invalidConfigErr},
-			subtype: errs.SubtypeInvalidConfig,
-		},
-		{
-			name:    "absent config degrades to profile_not_found",
-			in:      identityInputs{profile: "ghost", profileSrc: SourceEnvProfile, configErr: notConfiguredErr},
-			subtype: errs.SubtypeProfileNotFound,
-		},
-		{
-			name:    "profile missing from a valid config is profile_not_found even with incomplete env",
-			in:      identityInputs{profile: "ghost", profileSrc: SourceEnvProfile, directBlock: appIDOnlyBlock("cli_a"), directKeys: []string{envvars.CliAppID}, config: tenantA},
-			subtype: errs.SubtypeProfileNotFound,
-		},
-		{
-			name:   "config default reports currentApp",
-			in:     identityInputs{config: tenantA},
-			route:  routeConfigDefault,
-			source: SourceConfigCurrentApp,
-		},
-		{
-			name:   "config default without currentApp reports firstApp",
-			in:     identityInputs{config: noCurrent},
-			route:  routeConfigDefault,
-			source: SourceConfigFirstApp,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			d, err := decideIdentity(tc.in)
-			if tc.subtype != "" {
-				if err == nil {
-					t.Fatalf("decideIdentity = %+v, want error subtype %q", d, tc.subtype)
-				}
-				prob, ok := errs.ProblemOf(err)
-				if !ok || prob.Subtype != tc.subtype {
-					t.Fatalf("error = %v, want subtype %q", err, tc.subtype)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("decideIdentity: %v", err)
-			}
-			if d.route != tc.route {
-				t.Errorf("route = %d, want %d", d.route, tc.route)
-			}
-			if d.selection.Source != tc.source {
-				t.Errorf("source = %q, want %q", d.selection.Source, tc.source)
-			}
-			if d.selection.DirectCredentialEnv.Matched != tc.matched {
-				t.Errorf("matched = %v, want %v", d.selection.DirectCredentialEnv.Matched, tc.matched)
-			}
-		})
-	}
-}
--- a/internal/credential/default_provider.go
+++ b/internal/credential/default_provider.go
@@ -74,13 +74,9 @@ func NewDefaultAccountProvider(kc func() keychain.KeychainAccess, profile string

 func (p *DefaultAccountProvider) ResolveAccount(ctx context.Context) (*Account, error) {
 	// Load config once — used for both credentials and strict mode.
-	// LoadOrNotConfigured distinguishes an absent config (→ not_configured)
-	// from a malformed/unreadable one (→ invalid_config with cause), so a
-	// broken config is never masked as "run config init" — matching the
-	// explicit-profile path in doResolveAccount.
-	multi, err := core.LoadOrNotConfigured()
+	multi, err := core.LoadMultiAppConfig()
 	if err != nil {
-		return nil, err
+		return nil, core.NotConfiguredError()
 	}

 	cfg, err := core.ResolveConfigFromMulti(multi, p.keychain(), p.profile)
@@ -120,7 +116,6 @@ type DefaultTokenProvider struct {

 	tatOnce   sync.Once
 	tatResult *TokenResult
-	tatAppID  string
 	tatErr    error
 }

@@ -131,42 +126,21 @@ func NewDefaultTokenProvider(defaultAcct *DefaultAccountProvider, httpClient fun
 func (p *DefaultTokenProvider) ResolveToken(ctx context.Context, req TokenSpec) (*TokenResult, error) {
 	switch req.Type {
 	case TokenTypeUAT:
-		return p.resolveUAT(ctx, req)
+		return p.resolveUAT(ctx)
 	case TokenTypeTAT:
-		return p.resolveTAT(ctx, req)
+		return p.resolveTAT(ctx)
 	default:
 		return nil, fmt.Errorf("unsupported token type: %s", req.Type)
 	}
 }

-// checkTokenAppID refuses to hand out a token for a different app than the
-// caller resolved. The token provider re-reads the config, so a concurrent
-// profile edit between account resolution and token resolution could otherwise
-// cross tokens between apps. TokenSpec.AppID is REQUIRED here: an empty value
-// would silently disable the guarantee, so it is rejected rather than skipped.
-func checkTokenAppID(req TokenSpec, resolvedAppID string) error {
-	if req.AppID == "" {
-		return errs.NewInternalError(errs.SubtypeUnknown,
-			"TokenSpec.AppID is required for %s token resolution", req.Type)
-	}
-	if req.AppID == resolvedAppID {
-		return nil
-	}
-	return errs.NewInternalError(errs.SubtypeUnknown,
-		"config changed during resolution: token requested for app %q but the saved profile now resolves to a different app", req.AppID).
-		WithHint("retry the command.")
-}
-
 // resolveUAT resolves a user access token. Not cached (unlike TAT) because UAT
 // may be refreshed between calls and GetValidAccessToken handles its own caching.
-func (p *DefaultTokenProvider) resolveUAT(ctx context.Context, req TokenSpec) (*TokenResult, error) {
+func (p *DefaultTokenProvider) resolveUAT(ctx context.Context) (*TokenResult, error) {
 	acct, err := p.defaultAcct.ResolveAccount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if err := checkTokenAppID(req, acct.AppID); err != nil {
-		return nil, err
-	}
 	httpClient, err := p.httpClient()
 	if err != nil {
 		return nil, err
@@ -183,36 +157,20 @@ func (p *DefaultTokenProvider) resolveUAT(ctx context.Context, req TokenSpec) (*
 	return &TokenResult{Token: token, Scopes: scopes}, nil
 }

-// resolveTAT resolves a tenant access token. The result is cached after the
-// first mint via sync.Once — only the context from that call is used.
-//
-// The account is resolved and checked against the request BEFORE any token
-// work: a mismatched request must not trigger a token mint (network call,
-// quota, audit trail) for the wrong app. The cached result is additionally
-// re-checked on every hit, so a token minted for one app is never served to
-// a request that resolved another.
-func (p *DefaultTokenProvider) resolveTAT(ctx context.Context, req TokenSpec) (*TokenResult, error) {
+// resolveTAT resolves a tenant access token. The result is cached after the first
+// call via sync.Once — only the context from the first call is used.
+func (p *DefaultTokenProvider) resolveTAT(ctx context.Context) (*TokenResult, error) {
+	p.tatOnce.Do(func() {
+		p.tatResult, p.tatErr = p.doResolveTAT(ctx)
+	})
+	return p.tatResult, p.tatErr
+}
+
+func (p *DefaultTokenProvider) doResolveTAT(ctx context.Context) (*TokenResult, error) {
 	acct, err := p.defaultAcct.ResolveAccount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if err := checkTokenAppID(req, acct.AppID); err != nil {
-		return nil, err
-	}
-	p.tatOnce.Do(func() {
-		p.tatResult, p.tatErr = p.doResolveTAT(ctx, acct)
-		p.tatAppID = acct.AppID
-	})
-	if p.tatErr != nil {
-		return nil, p.tatErr
-	}
-	if err := checkTokenAppID(req, p.tatAppID); err != nil {
-		return nil, err
-	}
-	return p.tatResult, nil
-}
-
-func (p *DefaultTokenProvider) doResolveTAT(ctx context.Context, acct *Account) (*TokenResult, error) {
 	httpClient, err := p.httpClient()
 	if err != nil {
 		return nil, err
--- a/internal/credential/default_provider_test.go
+++ b/internal/credential/default_provider_test.go
@@ -4,15 +4,10 @@
 package credential

 import (
-	"context"
 	"errors"
-	"io"
-	"net/http"
-	"strings"
 	"testing"

 	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/core"
 )

 func TestDefaultTokenProvider_Dispatches(t *testing.T) {
@@ -97,136 +92,3 @@ func TestClassifyTATResponseCode_CodeZeroOtherError_StillTyped(t *testing.T) {
 		t.Fatalf("code-0 invalid_scope must not be a ConfigError, got %T", err)
 	}
 }
-
-func TestCheckTokenAppID(t *testing.T) {
-	if err := checkTokenAppID(TokenSpec{Type: TokenTypeUAT}, "cli_a"); err == nil {
-		t.Fatal("empty requested app must be rejected: it would silently disable the guarantee")
-	}
-	if err := checkTokenAppID(TokenSpec{AppID: "cli_a"}, "cli_a"); err != nil {
-		t.Fatalf("matching app must pass: %v", err)
-	}
-	err := checkTokenAppID(TokenSpec{AppID: "cli_a"}, "cli_b")
-	if err == nil {
-		t.Fatal("mismatched app must be refused")
-	}
-	var ie *errs.InternalError
-	if !errors.As(err, &ie) {
-		t.Fatalf("error type = %T, want *errs.InternalError", err)
-	}
-}
-
-// REAL-path regression for review F2: the token provider re-reads the config,
-// so a profile edit between account resolution and token resolution must not
-// hand a token minted for the new app to a caller that resolved the old one.
-// Uses the real DefaultAccountProvider + DefaultTokenProvider; the HTTP stub
-// makes the network step unreachable, so reaching it proves the app check ran
-// and passed first.
-func TestDefaultTokenProvider_RefusesTokenAfterConfigSwap(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	writeCfg := func(appID string) {
-		t.Helper()
-		multi := &core.MultiAppConfig{CurrentApp: "tenant_a", Apps: []core.AppConfig{{
-			Name: "tenant_a", AppId: appID, AppSecret: core.PlainSecret("your-secret"), Brand: core.BrandFeishu,
-		}}}
-		if err := core.SaveMultiAppConfig(multi); err != nil {
-			t.Fatalf("SaveMultiAppConfig: %v", err)
-		}
-	}
-	writeCfg("cli_a")
-
-	httpSentinel := errors.New("http client sentinel: unreachable in test")
-	tp := NewDefaultTokenProvider(
-		NewDefaultAccountProvider(nil, "tenant_a"),
-		func() (*http.Client, error) { return nil, httpSentinel },
-		nil,
-	)
-
-	// Matching app: the consistency check passes and resolution proceeds to
-	// the (stubbed) HTTP step.
-	_, err := tp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "cli_a"})
-	if !errors.Is(err, httpSentinel) {
-		t.Fatalf("err = %v, want the HTTP sentinel (check must pass for a matching app)", err)
-	}
-
-	// The profile now resolves to a different app: the token request that was
-	// arbitrated for cli_a must be refused before any token work happens.
-	writeCfg("cli_b")
-	_, err = tp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "cli_a"})
-	if err == nil || !strings.Contains(err.Error(), "config changed during resolution") {
-		t.Fatalf("err = %v, want config-changed refusal", err)
-	}
-}
-
-// F1 regression: a TAT request for a mismatched app must be refused BEFORE
-// any token work starts — no HTTP client construction, no mint, no cache —
-// otherwise the CLI mints (and caches) a token for the wrong app and only
-// then refuses to return it, leaving auth audit/quota side effects behind.
-func TestDefaultTokenProvider_TATChecksAppBeforeAnyTokenWork(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{CurrentApp: "tenant_a", Apps: []core.AppConfig{{
-		Name: "tenant_a", AppId: "cli_b", AppSecret: core.PlainSecret("your-secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	httpCalled := false
-	tp := NewDefaultTokenProvider(
-		NewDefaultAccountProvider(nil, "tenant_a"),
-		func() (*http.Client, error) { httpCalled = true; return nil, errors.New("http sentinel") },
-		nil,
-	)
-
-	// The profile resolves to cli_b, but the caller arbitrated cli_a.
-	_, err := tp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeTAT, AppID: "cli_a"})
-	if err == nil || !strings.Contains(err.Error(), "config changed during resolution") {
-		t.Fatalf("err = %v, want config-changed refusal", err)
-	}
-	if httpCalled {
-		t.Fatal("token work started for a mismatched app: the check must run before any HTTP client is built")
-	}
-}
-
-// countingTATTripper serves a canned successful TAT response and counts calls.
-type countingTATTripper struct{ calls int }
-
-func (c *countingTATTripper) RoundTrip(*http.Request) (*http.Response, error) {
-	c.calls++
-	return &http.Response{
-		StatusCode: http.StatusOK,
-		Body:       io.NopCloser(strings.NewReader(`{"code":0,"access_token":"your-access-token"}`)),
-		Header:     http.Header{"Content-Type": []string{"application/json"}},
-	}, nil
-}
-
-// TAT happy path: the first request mints the token over HTTP, the second is
-// served from the sync.Once cache without another HTTP call.
-func TestDefaultTokenProvider_TATSuccessAndCacheHit(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{CurrentApp: "tenant_a", Apps: []core.AppConfig{{
-		Name: "tenant_a", AppId: "cli_a", AppSecret: core.PlainSecret("your-secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	tripper := &countingTATTripper{}
-	tp := NewDefaultTokenProvider(
-		NewDefaultAccountProvider(nil, "tenant_a"),
-		func() (*http.Client, error) { return &http.Client{Transport: tripper}, nil },
-		nil,
-	)
-
-	req := TokenSpec{Type: TokenTypeTAT, AppID: "cli_a"}
-	first, err := tp.ResolveToken(context.Background(), req)
-	if err != nil || first.Token != "your-access-token" {
-		t.Fatalf("first resolve = %+v, %v; want minted token", first, err)
-	}
-	second, err := tp.ResolveToken(context.Background(), req)
-	if err != nil || second.Token != "your-access-token" {
-		t.Fatalf("second resolve = %+v, %v; want cached token", second, err)
-	}
-	if tripper.calls != 1 {
-		t.Fatalf("HTTP calls = %d, want exactly 1 (second resolve must hit the cache)", tripper.calls)
-	}
-}
--- a/internal/credential/identity_selection.go
+++ b/internal/credential/identity_selection.go
@@ -1,54 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package credential
-
-// CredentialSourceKind is the wire-stable App/credential selection source.
-type CredentialSourceKind string
-
-const (
-	SourceFlagProfile      CredentialSourceKind = "flag:--profile"
-	SourceEnvProfile       CredentialSourceKind = "env:LARKSUITE_CLI_PROFILE"
-	SourceEnvAppID         CredentialSourceKind = "env:LARKSUITE_CLI_APP_ID"
-	SourceConfigCurrentApp CredentialSourceKind = "config:currentApp"
-	SourceConfigFirstApp   CredentialSourceKind = "config:firstApp"
-
-	// SourceExtensionPrefix prefixes the name of a managed extension provider
-	// that won selection outright (e.g. "extension:sidecar"). With it, an
-	// empty Source is left with exactly one meaning: not resolved.
-	SourceExtensionPrefix CredentialSourceKind = "extension:"
-)
-
-// SourceExtension reports the selection source for a managed extension
-// provider by name.
-func SourceExtension(name string) CredentialSourceKind {
-	return SourceExtensionPrefix + CredentialSourceKind(name)
-}
-
-// DirectCredentialEnv describes the state of direct app credential env vars.
-// It never carries a secret value — only names and the non-sensitive app_id.
-type DirectCredentialEnv struct {
-	Present              bool     `json:"present"`
-	Keys                 []string `json:"keys,omitempty"`
-	AppID                string   `json:"appId,omitempty"`
-	Matched              bool     `json:"matched,omitempty"`
-	ConflictsWithProfile bool     `json:"conflictsWithProfile,omitempty"`
-}
-
-// IdentitySelection is the explainable result of credential selection.
-// It carries NO secret value.
-type IdentitySelection struct {
-	Source              CredentialSourceKind
-	DirectCredentialEnv DirectCredentialEnv
-}
-
-// Explicit reports whether the identity was actively specified by the
-// user/agent (flag or env), which governs no-fallback behavior.
-func (s IdentitySelection) Explicit() bool {
-	switch s.Source {
-	case SourceFlagProfile, SourceEnvProfile, SourceEnvAppID:
-		return true
-	default:
-		return false
-	}
-}
--- a/internal/credential/identity_selection_test.go
+++ b/internal/credential/identity_selection_test.go
@@ -1,25 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package credential
-
-import "testing"
-
-func TestIdentitySelectionExplicit(t *testing.T) {
-	cases := []struct {
-		src      CredentialSourceKind
-		explicit bool
-	}{
-		{SourceFlagProfile, true},
-		{SourceEnvProfile, true},
-		{SourceEnvAppID, true},
-		{SourceConfigCurrentApp, false},
-		{SourceConfigFirstApp, false},
-	}
-	for _, c := range cases {
-		sel := IdentitySelection{Source: c.src}
-		if sel.Explicit() != c.explicit {
-			t.Errorf("source %q: Explicit()=%v want %v", c.src, sel.Explicit(), c.explicit)
-		}
-	}
-}
--- a/internal/credential/integration_test.go
+++ b/internal/credential/integration_test.go
@@ -52,24 +52,6 @@ func TestFullChain_EnvWins(t *testing.T) {
 	}
 }

-func TestFullChain_EnvRejectsDifferentApp(t *testing.T) {
-	t.Setenv(envvars.CliAppID, "env_app")
-	t.Setenv(envvars.CliAppSecret, "env_secret")
-	t.Setenv(envvars.CliUserAccessToken, "env_uat")
-
-	cp := credential.NewCredentialProvider(
-		[]extcred.Provider{&envprovider.Provider{}},
-		nil, nil, nil,
-	)
-
-	_, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
-		Type: credential.TokenTypeUAT, AppID: "other_app",
-	})
-	if err == nil {
-		t.Fatal("ResolveToken() error = nil, want app binding error")
-	}
-}
-
 func TestFullChain_Fallthrough(t *testing.T) {
 	// env provider returns nil (no env vars set), falls through to default token
 	ep := &envprovider.Provider{}
@@ -77,8 +59,7 @@ func TestFullChain_Fallthrough(t *testing.T) {

 	cp := credential.NewCredentialProvider(
 		[]extcred.Provider{ep},
-		&mockDefaultAccountProvider{account: &credential.Account{AppID: "app1"}},
-		mock, nil,
+		nil, mock, nil,
 	)
 	result, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
 		Type: credential.TokenTypeUAT, AppID: "app1",
@@ -91,14 +72,6 @@ func TestFullChain_Fallthrough(t *testing.T) {
 	}
 }

-type mockDefaultAccountProvider struct {
-	account *credential.Account
-}
-
-func (m *mockDefaultAccountProvider) ResolveAccount(context.Context) (*credential.Account, error) {
-	return m.account, nil
-}
-
 type mockDefaultTokenProvider struct {
 	token  string
 	scopes string
--- a/internal/envvars/envvars.go
+++ b/internal/envvars/envvars.go
@@ -21,7 +21,6 @@ const (

 	CliAgentName  = "LARKSUITE_CLI_AGENT_NAME"
 	CliAgentTrace = "LARKSUITE_CLI_AGENT_TRACE"
-	CliProfile    = "LARKSUITE_CLI_PROFILE"

 	CliProxyEnable  = "LARKSUITE_CLI_PROXY_ENABLE"
 	CliProxyAddress = "LARKSUITE_CLI_PROXY_ADDRESS"
--- a/internal/errclass/codemeta_spark.go
+++ b/internal/errclass/codemeta_spark.go
@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package errclass
-
-import "github.com/larksuite/cli/errs"
-
-// sparkCodeMeta holds stable Spark app-role business-code classifications.
-// Command-specific recovery guidance belongs in the Apps shortcut layer; the
-// numeric code remains the source-specific discriminator on the error envelope.
-var sparkCodeMeta = map[int]CodeMeta{
-	3340001: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // request parameters are invalid
-	3344027: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // role user count exceeds the service limit
-	3344028: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // role department count exceeds the service limit
-	3344029: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // role chat count exceeds the service limit
-	3344030: {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied}, // app administrator required
-	3344031: {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied}, // app administrator or developer required
-	3344034: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid role ID
-	3344035: {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},                   // role does not exist
-	3344036: {Category: errs.CategoryAPI, Subtype: errs.SubtypeAlreadyExists},              // role ID already exists
-	3344037: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // app role count exceeds the service limit
-	3344038: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid role name
-	3344039: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid role description
-	3344040: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // unsupported member type
-	3344041: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid member ID
-}
-
-func init() { mergeCodeMeta(sparkCodeMeta, "spark") }
--- a/internal/errclass/codemeta_spark_test.go
+++ b/internal/errclass/codemeta_spark_test.go
@@ -1,59 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package errclass
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-func TestLookupCodeMetaSparkRoleCodes(t *testing.T) {
-	tests := []struct {
-		code     int
-		category errs.Category
-		subtype  errs.Subtype
-	}{
-		{3340001, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344027, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344028, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344029, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344030, errs.CategoryAuthorization, errs.SubtypePermissionDenied},
-		{3344031, errs.CategoryAuthorization, errs.SubtypePermissionDenied},
-		{3344034, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344035, errs.CategoryAPI, errs.SubtypeNotFound},
-		{3344036, errs.CategoryAPI, errs.SubtypeAlreadyExists},
-		{3344037, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344038, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344039, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344040, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344041, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-	}
-
-	for _, tt := range tests {
-		t.Run(fmt.Sprintf("%d", tt.code), func(t *testing.T) {
-			meta, ok := LookupCodeMeta(tt.code)
-			if !ok {
-				t.Fatalf("code %d is not registered", tt.code)
-			}
-			if meta.Category != tt.category || meta.Subtype != tt.subtype || meta.Retryable {
-				t.Fatalf("code %d metadata = %+v, want category=%s subtype=%s retryable=false", tt.code, meta, tt.category, tt.subtype)
-			}
-
-			err := BuildAPIError(map[string]any{
-				"code":   tt.code,
-				"msg":    "spark role error",
-				"log_id": "log-spark-role",
-			}, ClassifyContext{Identity: "user"})
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("BuildAPIError(%d) = %#v, want typed problem", tt.code, err)
-			}
-			if problem.Category != tt.category || problem.Subtype != tt.subtype || problem.Code != tt.code || problem.LogID != "log-spark-role" || problem.Retryable {
-				t.Fatalf("BuildAPIError(%d) problem = %+v", tt.code, problem)
-			}
-		})
-	}
-}
--- a/internal/event/testmain_test.go
+++ b/internal/event/testmain_test.go
@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package event
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-event-test-*")
-	if err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("LARKSUITE_CLI_CONFIG_DIR", filepath.Join(root, "config")); err != nil {
-		panic(err)
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/internal/keychain/testmain_test.go
+++ b/internal/keychain/testmain_test.go
@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package keychain
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	root, err := os.MkdirTemp("", "lark-cli-keychain-test-*")
-	if err != nil {
-		panic(err)
-	}
-	for key, value := range map[string]string{
-		"LARKSUITE_CLI_DATA_DIR": filepath.Join(root, "data"),
-		"LARKSUITE_CLI_LOG_DIR":  filepath.Join(root, "logs"),
-	} {
-		if err := os.Setenv(key, value); err != nil {
-			panic(err)
-		}
-	}
-	code := m.Run()
-	_ = os.RemoveAll(root)
-	os.Exit(code)
-}
--- a/internal/output/csv.go
+++ b/internal/output/csv.go
@@ -7,91 +7,70 @@ import (
 	"encoding/csv"
 	"fmt"
 	"io"
+	"os"
 )

 // FormatAsCSV formats data as CSV (with header) and writes it to w.
 func FormatAsCSV(w io.Writer, data interface{}) {
-	// Match the other legacy wrappers: surface only a marshal failure (as the
-	// JSON fallback historically did); plain write failures stay swallowed.
-	if err := WriteCSV(w, data); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteCSV formats data as CSV and returns marshal or write errors.
-func WriteCSV(w io.Writer, data interface{}) error {
-	return WriteCSVPaginated(w, data, true)
+	FormatAsCSVPaginated(w, data, true)
 }

 // FormatAsCSVPaginated formats data as CSV with pagination awareness.
 // When isFirstPage is true, outputs the header row; otherwise only data rows.
 func FormatAsCSVPaginated(w io.Writer, data interface{}, isFirstPage bool) {
-	if err := WriteCSVPaginated(w, data, isFirstPage); isOutputMarshalError(err) {
-		legacyStderrf("json marshal error: %v\n", err)
-	}
-}
-
-// WriteCSVPaginated formats data as CSV and returns marshal or write errors.
-func WriteCSVPaginated(w io.Writer, data interface{}, isFirstPage bool) error {
 	rows, cols, isList := prepareRows(data)
 	if cols == nil {
 		if isList {
-			_, err := fmt.Fprintln(w, "(empty)")
-			return err
+			fmt.Fprintln(w, "(empty)")
 		} else {
-			return WriteJSON(w, data)
+			PrintJson(w, data)
 		}
+		return
 	}

 	if len(rows) == 0 {
 		if isFirstPage {
-			_, err := fmt.Fprintln(w, "(empty)")
-			return err
+			fmt.Fprintln(w, "(empty)")
 		}
-		return nil
+		return
 	}

 	if !isList {
 		// Single object: key,value rows
 		cw := csv.NewWriter(w)
 		if isFirstPage {
-			if err := cw.Write([]string{"key", "value"}); err != nil {
-				return err
-			}
+			cw.Write([]string{"key", "value"})
 		}
 		for _, col := range cols {
-			if err := cw.Write([]string{col, rows[0][col]}); err != nil {
-				return err
-			}
+			cw.Write([]string{col, rows[0][col]})
 		}
-		return flushCSV(cw)
+		flushCSV(cw)
+		return
 	}

-	return writeCSVRows(w, rows, cols, isFirstPage)
+	writeCSVRows(w, rows, cols, isFirstPage)
 }

 // writeCSVRows writes CSV data rows (and optionally header) using the given columns.
-func writeCSVRows(w io.Writer, rows []map[string]string, cols []string, writeHeader bool) error {
+func writeCSVRows(w io.Writer, rows []map[string]string, cols []string, writeHeader bool) {
 	cw := csv.NewWriter(w)
 	if writeHeader {
-		if err := cw.Write(cols); err != nil {
-			return err
-		}
+		cw.Write(cols)
 	}
 	for _, row := range rows {
 		record := make([]string, len(cols))
 		for i, col := range cols {
 			record[i] = row[col]
 		}
-		if err := cw.Write(record); err != nil {
-			return err
-		}
+		cw.Write(record)
 	}
-	return flushCSV(cw)
+	flushCSV(cw)
 }

-// flushCSV flushes the csv.Writer and returns any write error.
-func flushCSV(cw *csv.Writer) error {
+// flushCSV flushes the csv.Writer and reports any write error to stderr.
+func flushCSV(cw *csv.Writer) {
 	cw.Flush()
-	return cw.Error()
+	if err := cw.Error(); err != nil {
+		fmt.Fprintf(os.Stderr, "csv write error: %v\n", err)
+	}
 }
--- a/internal/output/emit.go
+++ b/internal/output/emit.go
@@ -50,11 +50,10 @@ func wrapBlockError(alert *extcs.Alert) error {

 // WriteAlertWarning writes a human-readable content-safety warning to w.
 // Used by non-JSON output paths (pretty, table, csv) in warn mode.
-func WriteAlertWarning(w io.Writer, alert *extcs.Alert) error {
+func WriteAlertWarning(w io.Writer, alert *extcs.Alert) {
 	if alert == nil {
-		return nil
+		return
 	}
-	_, err := fmt.Fprintf(w, "warning: content safety alert from %s (rules: %s)\n",
+	fmt.Fprintf(w, "warning: content safety alert from %s (rules: %s)\n",
 		alert.Provider, strings.Join(alert.MatchedRules, ", "))
-	return err
 }
--- a/internal/output/emitter.go
+++ b/internal/output/emitter.go
@@ -1,336 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package output
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"maps"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// NoticeProvider supplies the notice attached to a structured envelope.
-// The provider is captured by an Emitter so emission never reads the global
-// PendingNotice hook implicitly.
-type NoticeProvider func() map[string]interface{}
-
-// PrettyRenderer writes the human-readable representation of one result.
-// colorEnabled is the terminal capability captured when the Emitter is built.
-type PrettyRenderer func(w io.Writer, colorEnabled bool) error
-
-// EmitterConfig contains command-scoped dependencies. A command constructs one
-// Emitter and reuses it for its success result or streamed pages.
-type EmitterConfig struct {
-	Out            io.Writer
-	ErrOut         io.Writer
-	CommandPath    string
-	Identity       string
-	ColorEnabled   bool
-	NoticeProvider NoticeProvider
-}
-
-// EmitOptions describes one result's wire representation.
-//
-// The format contract is explicit: JSON (including the empty default) uses an
-// Envelope; pretty, table, csv, and ndjson render naked business data. JQ takes
-// precedence over Format and filters the JSON Envelope. Raw affects only JSON
-// envelope encoding and jq's complex-value encoding.
-//
-// JQSafetyWarning preserves the legacy difference between RuntimeContext.emit
-// (false) and WriteSuccessEnvelope (true) until their callers are migrated.
-type EmitOptions struct {
-	Raw             bool
-	Meta            *Meta
-	Format          string
-	JQ              string
-	DryRun          bool
-	Pretty          PrettyRenderer
-	JQSafetyWarning bool
-}
-
-// StreamOptions describes one streamed page's wire representation. Streaming
-// carries page items directly, so it deliberately exposes only the fields that
-// affect a single page: the format and, for pretty, its renderer. It has no
-// OK/Meta/DryRun/JQ — an ok:false envelope, metadata, dry-run, and jq all need
-// the aggregated result, which the caller's pagination layer owns before it
-// streams pages.
-type StreamOptions struct {
-	Format string
-	Pretty PrettyRenderer
-}
-
-// Emitter owns all command-scoped output dependencies and pagination state.
-// It deliberately has no dependency on client or cmdutil.
-type Emitter struct {
-	out            io.Writer
-	errOut         io.Writer
-	commandPath    string
-	identity       string
-	colorEnabled   bool
-	noticeProvider NoticeProvider
-
-	streamFormat    string
-	streamFormatter *PaginatedFormatter
-}
-
-// NewEmitter constructs a command-scoped output emitter.
-func NewEmitter(config EmitterConfig) *Emitter {
-	errOut := config.ErrOut
-	if errOut == nil {
-		errOut = io.Discard
-	}
-	return &Emitter{
-		out:            config.Out,
-		errOut:         errOut,
-		commandPath:    config.CommandPath,
-		identity:       config.Identity,
-		colorEnabled:   config.ColorEnabled,
-		noticeProvider: config.NoticeProvider,
-	}
-}
-
-// Success scans and emits one command result by composing the package's leaf
-// primitives. JSON and jq use the standard envelope; pretty, table, csv, and
-// ndjson render the business value directly.
-func (e *Emitter) Success(data interface{}, opts EmitOptions) error {
-	if err := e.requireOutput(); err != nil {
-		return err
-	}
-
-	if opts.JQ != "" {
-		return e.emitEnvelope(data, true, opts)
-	}
-
-	switch opts.Format {
-	case "", "json":
-		return e.emitEnvelope(data, true, opts)
-	case "pretty":
-		return e.emitPretty(data, opts)
-	default:
-		return e.emitFormatted(data, opts.Format)
-	}
-}
-
-// PartialFailure emits a multi-status result whose envelope honestly reports
-// ok:false. It is the typed counterpart to Success for batch operations where
-// some items failed but the per-item outcomes are the primary stdout output.
-// Like the legacy OutPartialFailure it produces only the JSON/jq envelope; the
-// caller owns the non-zero exit signal, keeping the Emitter free of exit
-// semantics.
-func (e *Emitter) PartialFailure(data interface{}, opts EmitOptions) error {
-	if err := e.requireOutput(); err != nil {
-		return err
-	}
-	return e.emitEnvelope(data, false, opts)
-}
-
-// StreamPage scans and emits one page while retaining table/csv columns from
-// the first page. Streamed output carries page items directly, so it takes a
-// StreamOptions (format + optional pretty renderer) rather than the full
-// EmitOptions: ok/meta/dry-run/jq all need the aggregated result and are the
-// caller's pagination-layer responsibility, not a per-page concern. Excluding
-// jq from the type makes "jq requires aggregated output" a compile-time fact
-// instead of a runtime rejection.
-func (e *Emitter) StreamPage(data interface{}, opts StreamOptions) error {
-	if err := e.requireOutput(); err != nil {
-		return err
-	}
-
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-	if scanResult.Alert != nil {
-		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-			return wrapOutputError("write", err)
-		}
-	}
-
-	if opts.Format == "pretty" {
-		if opts.Pretty == nil {
-			return errs.NewInternalError(errs.SubtypeUnknown,
-				"pretty output requires a renderer")
-		}
-		return e.emit(func(w io.Writer) error {
-			return opts.Pretty(w, e.colorEnabled)
-		})
-	}
-
-	format, known := ParseFormat(opts.Format)
-	if !known && e.streamFormatter == nil && e.errOut != nil {
-		fmt.Fprintf(e.errOut, "warning: unknown format %q, falling back to json\n", opts.Format)
-	}
-	if e.streamFormatter == nil {
-		e.streamFormat = opts.Format
-		e.streamFormatter = NewPaginatedFormatter(nil, format)
-	} else if opts.Format != e.streamFormat {
-		return errs.NewInternalError(errs.SubtypeUnknown,
-			"stream output format changed from %q to %q", e.streamFormat, opts.Format)
-	}
-
-	return e.emit(func(w io.Writer) error {
-		e.streamFormatter.W = w
-		return e.streamFormatter.WritePage(data)
-	})
-}
-
-func (e *Emitter) emitEnvelope(data interface{}, ok bool, opts EmitOptions) error {
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-
-	env := Envelope{
-		OK:       ok,
-		Identity: e.identity,
-		DryRun:   opts.DryRun,
-		Data:     data,
-		Meta:     opts.Meta,
-		Notice:   e.notice(),
-	}
-	if scanResult.Alert != nil {
-		env.ContentSafetyAlert = scanResult.Alert
-	}
-
-	if opts.JQ != "" {
-		if scanResult.Alert != nil && opts.JQSafetyWarning {
-			if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-				return wrapOutputError("write", err)
-			}
-		}
-		// Buffer the jq output manually so jq's own typed error (a validation
-		// error for a bad expression, an api error for a runtime failure) is
-		// returned unchanged; only a genuine stdout write failure is wrapped as
-		// an internal output error.
-		var buf bytes.Buffer
-		var jqErr error
-		if opts.Raw {
-			jqErr = JqFilterRaw(&buf, env, opts.JQ)
-		} else {
-			jqErr = JqFilter(&buf, env, opts.JQ)
-		}
-		if jqErr != nil {
-			return jqErr
-		}
-		if _, err := io.Copy(e.out, &buf); err != nil {
-			return wrapOutputError("write", err)
-		}
-		return nil
-	}
-
-	return e.emit(func(w io.Writer) error {
-		if opts.Raw {
-			enc := json.NewEncoder(w)
-			enc.SetEscapeHTML(false)
-			enc.SetIndent("", "  ")
-			return enc.Encode(env)
-		}
-		return WriteJSON(w, env)
-	})
-}
-
-func (e *Emitter) emitPretty(data interface{}, opts EmitOptions) error {
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-	if scanResult.Alert != nil {
-		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-			return wrapOutputError("write", err)
-		}
-	}
-	if opts.Pretty != nil {
-		return e.emit(func(w io.Writer) error {
-			return opts.Pretty(w, e.colorEnabled)
-		})
-	}
-
-	// RuntimeContext.outFormat falls back through Out/OutRaw when no pretty
-	// renderer is supplied. Keep that second scan visible in the leaf contract
-	// until production callers are migrated and the legacy behavior is removed.
-	return e.emitEnvelope(data, true, opts)
-}
-
-func (e *Emitter) emitFormatted(data interface{}, rawFormat string) error {
-	scanResult := ScanForSafety(e.commandPath, data, e.errOut)
-	if scanResult.Blocked {
-		return scanResult.BlockErr
-	}
-	if scanResult.Alert != nil {
-		if err := WriteAlertWarning(e.errOut, scanResult.Alert); err != nil {
-			return wrapOutputError("write", err)
-		}
-	}
-
-	format, known := ParseFormat(rawFormat)
-	if !known && e.errOut != nil {
-		fmt.Fprintf(e.errOut, "warning: unknown format %q, falling back to json\n", rawFormat)
-	}
-	if format == FormatJSON {
-		return e.printLegacyDataJSON(data)
-	}
-	return e.emit(func(w io.Writer) error {
-		return WriteFormatted(w, data, format)
-	})
-}
-
-type emitterDataMap map[string]interface{}
-
-// printLegacyDataJSON matches FormatValue's JSON branch while sourcing notice
-// data from this Emitter instead of PrintJson's global PendingNotice hook.
-func (e *Emitter) printLegacyDataJSON(data interface{}) error {
-	// Normalise structs / named maps to plain generic types first, exactly as
-	// FormatValue does, so a struct or named-map payload still matches the map
-	// case below and keeps its injected _notice on the unknown-format fallback.
-	data = toGeneric(data)
-	if m, ok := data.(map[string]interface{}); ok {
-		if _, isEnvelope := m["ok"]; isEnvelope {
-			if notice := e.notice(); notice != nil {
-				m = maps.Clone(m)
-				m["_notice"] = notice
-			}
-		}
-		// The named map retains identical JSON bytes while preventing PrintJson
-		// from consulting its legacy global notice hook a second time.
-		return e.emit(func(w io.Writer) error {
-			return WriteJSON(w, emitterDataMap(m))
-		})
-	}
-	return e.emit(func(w io.Writer) error {
-		return WriteJSON(w, data)
-	})
-}
-
-func (e *Emitter) emit(render func(io.Writer) error) error {
-	var buf bytes.Buffer
-	if err := render(&buf); err != nil {
-		return wrapOutputError("render", err)
-	}
-	if _, err := io.Copy(e.out, &buf); err != nil {
-		return wrapOutputError("write", err)
-	}
-	return nil
-}
-
-func wrapOutputError(op string, err error) error {
-	return errs.NewInternalError(errs.SubtypeUnknown, "failed to %s command output", op).WithCause(err)
-}
-
-func (e *Emitter) notice() map[string]interface{} {
-	if e.noticeProvider == nil {
-		return nil
-	}
-	return e.noticeProvider()
-}
-
-func (e *Emitter) requireOutput() error {
-	if e == nil || e.out == nil {
-		return errs.NewInternalError(errs.SubtypeUnknown,
-			"success output writer is not configured")
-	}
-	return nil
-}
--- a/Show More
+++ b/Show More