feat(auth): support managed external credentials

Add Extended-only direct, credential-proxy, and platform-proxy modes while keeping Standard behavior and external-credential product details isolated behind source-neutral runtime capabilities. Fail closed across helper execution, proxy routing, streams, managed file transfers, and unsupported event flows. Harden system configuration, edition updates, and release publication. Cover Standard compatibility and Extended integration with contract tests, repository-local three-mode E2E, native trust checks, and CI and release gates.
2026-08-03 08:32:46 +08:00 · 2026-07-30 18:33:25 +08:00
357 changed files with 15334 additions and 19940 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -82,6 +82,56 @@ jobs:
      - name: Run sidecar tag build + HMAC round-trip
        run: make sidecar-test

+  extended-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
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        with:
+          python-version: '3.x'
+      - name: Fetch meta data
+        run: python3 scripts/fetch_meta.py
+      - name: Build both editions and verify identity
+        run: |
+          set -euo pipefail
+          go build -o /tmp/lark-cli-standard .
+          go build -tags extended -o /tmp/lark-cli-extended .
+          test "$(/tmp/lark-cli-standard version --json | jq -r .edition)" = "standard"
+          test "$(/tmp/lark-cli-extended version --json | jq -r .edition)" = "extended"
+          test "$(/tmp/lark-cli-extended version --json | jq -r '.capabilities[]')" = "external-credential-platform"
+      - name: Cross-compile Extended platform-specific security code
+        run: |
+          set -euo pipefail
+          GOOS=darwin GOARCH=arm64 go build -tags extended -o /tmp/lark-cli-extended-darwin .
+          GOOS=windows GOARCH=amd64 go build -tags extended -o /tmp/lark-cli-extended-windows.exe .
+      - name: Verify edition source isolation
+        run: go test -count=1 ./internal/externalcredential -run '^TestEditionSourceIsolation$'
+      - name: Run Extended tests
+        run: make extended-test
+
+  extended-platform-security:
+    needs: fast-gate
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
+        with:
+          persist-credentials: false
+      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
+        with:
+          go-version-file: go.mod
+      - name: Run native helper isolation and path trust tests
+        run: go test -tags extended -count=1 ./internal/externalcredential -run '^(TestNativeAdminControlledPath|TestCredentialProcessEnvironmentUsesExplicitAllowlist|TestCredentialProcessCommandRunsWithIsolatedEnvironment)$'
+
  # ── Layer 2: Quality Gate ──────────────────────────────────────────
  unit-test:
    needs: fast-gate
@@ -142,6 +192,28 @@ jobs:
          node-version: '22'
      - name: Run script tests
        run: make script-test
+      - name: Install GoReleaser
+        uses: goreleaser/goreleaser-action@e435ccd777264be153ace6237001ef4d979d3a7a # v6
+        with:
+          version: '~> v2'
+          install-only: true
+      - name: Validate GoReleaser configuration
+        run: goreleaser check
+      - name: Check Extended installer syntax
+        shell: pwsh
+        run: |
+          sh -n scripts/install-extended.sh
+          $tokens = $null
+          $errors = $null
+          [System.Management.Automation.Language.Parser]::ParseFile(
+            (Resolve-Path scripts/install-extended.ps1),
+            [ref]$tokens,
+            [ref]$errors
+          ) | Out-Null
+          if ($errors.Count -ne 0) {
+            $errors | ForEach-Object { Write-Error $_ }
+            exit 1
+          }

  deterministic-gate:
    needs: fast-gate
@@ -216,16 +288,20 @@ jobs:
          # 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/')
-          go test -race -coverprofile=coverage.txt -covermode=atomic $packages
+          go test -race -coverprofile=coverage-standard.txt -covermode=atomic $packages
+          # Extended implementation files are selected by build tags and would
+          # otherwise be absent from the uploaded report. Their race-enabled
+          # suite runs in extended-integration; this pass contributes coverage.
+          go test -tags extended -coverprofile=coverage-extended.txt -covermode=atomic $packages
      - name: Upload coverage to Codecov
        if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
        uses: codecov/codecov-action@3f20e214133d0983f9a10f3d63b0faf9241a3daa # v6
        with:
-          files: coverage.txt
+          files: coverage-standard.txt,coverage-extended.txt
          token: ${{ secrets.CODECOV_TOKEN }}
      - name: Check coverage threshold
        run: |
-          total=$(go tool cover -func=coverage.txt | grep total | awk '{print $3}' | tr -d '%')
+          total=$(go tool cover -func=coverage-standard.txt | grep total | awk '{print $3}' | tr -d '%')
          threshold=40
          echo "Coverage: ${total}% (threshold: ${threshold}%)"
          if (( $(echo "$total < $threshold" | bc -l) )); then
@@ -235,21 +311,31 @@ jobs:
      - name: Coverage summary
        if: ${{ !cancelled() }}
        run: |
-          if [ ! -f coverage.txt ]; then
-            echo "No coverage data available" >> $GITHUB_STEP_SUMMARY
-            exit 0
-          fi
-          total=$(go tool cover -func=coverage.txt | grep total | awk '{print $3}')
          echo "## Coverage Report" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "**Total coverage: ${total}**" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "<details><summary>Details</summary>" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo '```' >> $GITHUB_STEP_SUMMARY
-          go tool cover -func=coverage.txt >> $GITHUB_STEP_SUMMARY
-          echo '```' >> $GITHUB_STEP_SUMMARY
-          echo "</details>" >> $GITHUB_STEP_SUMMARY
+          report_coverage() {
+            profile="$1"
+            label="$2"
+            echo "### ${label} edition" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            if [ ! -f "$profile" ]; then
+              echo "No ${label} coverage data available." >> $GITHUB_STEP_SUMMARY
+              echo "" >> $GITHUB_STEP_SUMMARY
+              return
+            fi
+            total=$(go tool cover -func="$profile" | grep total | awk '{print $3}')
+            echo "**Total coverage: ${total}**" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            echo "<details><summary>Details</summary>" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+            echo '```' >> $GITHUB_STEP_SUMMARY
+            go tool cover -func="$profile" >> $GITHUB_STEP_SUMMARY
+            echo '```' >> $GITHUB_STEP_SUMMARY
+            echo "</details>" >> $GITHUB_STEP_SUMMARY
+            echo "" >> $GITHUB_STEP_SUMMARY
+          }
+          report_coverage coverage-standard.txt Standard
+          report_coverage coverage-extended.txt Extended

  deadcode:
    needs: fast-gate
@@ -520,7 +606,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, plugin-integration, sidecar-integration, extended-integration, extended-platform-security]
    runs-on: ubuntu-latest
    steps:
      - name: Evaluate results
@@ -542,6 +628,8 @@ jobs:
          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
+          echo "| L4 | extended-integration | ${{ needs.extended-integration.result }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| L4 | extended-platform-security | ${{ needs.extended-platform-security.result }} |" >> $GITHUB_STEP_SUMMARY

          # Any failure or cancellation in any job blocks the merge.
          # Legitimately skipped jobs (deadcode on push, e2e-live when not
@@ -565,7 +653,9 @@ jobs:
            "${{ needs.e2e-dry-run.result }}" \
            "${{ needs.e2e-live.result }}" \
            "${{ needs.security.result }}" \
-            "${{ needs.license-header.result }}"; do
+            "${{ needs.license-header.result }}" \
+            "${{ needs.extended-integration.result }}" \
+            "${{ needs.extended-platform-security.result }}"; do
            if [ "$result" = "failure" ] || [ "$result" = "cancelled" ]; then
              FAILED=1
            fi
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -46,6 +46,8 @@ jobs:
    runs-on: ubuntu-22.04
    permissions:
      contents: write
+      id-token: write
+      attestations: write
    steps:
      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
        with:
@@ -68,7 +70,7 @@ jobs:
      - name: Install pinned npm
        run: npm install --global npm@11.16.0

-      - name: Run GoReleaser
+      - name: Build and upload draft release with GoReleaser
        uses: goreleaser/goreleaser-action@e435ccd777264be153ace6237001ef4d979d3a7a # v6
        with:
          version: '~> v2'
@@ -80,14 +82,41 @@ jobs:
        run: |
          set -euo pipefail
          test -s dist/checksums.txt
+          cp scripts/install-extended.sh scripts/install-extended.ps1 dist/
          (cd dist && sha256sum --check checksums.txt)
          cp dist/checksums.txt checksums.txt

+      - name: Verify release edition identities
+        run: |
+          set -euo pipefail
+          mkdir -p /tmp/lark-cli-standard /tmp/lark-cli-extended
+          tar -xzf "dist/lark-cli-${GITHUB_REF_NAME#v}-linux-amd64.tar.gz" -C /tmp/lark-cli-standard lark-cli
+          tar -xzf "dist/lark-cli-extended-${GITHUB_REF_NAME#v}-linux-amd64.tar.gz" -C /tmp/lark-cli-extended lark-cli
+          test "$(/tmp/lark-cli-standard/lark-cli version --json | jq -r .edition)" = "standard"
+          test "$(/tmp/lark-cli-extended/lark-cli version --json | jq -r .edition)" = "extended"
+          test "$(/tmp/lark-cli-standard/lark-cli version --json | jq -r .version)" = "${GITHUB_REF_NAME#v}"
+          test "$(/tmp/lark-cli-extended/lark-cli version --json | jq -r .version)" = "${GITHUB_REF_NAME#v}"
+
+      - name: Verify release platform asset matrix
+        run: bash scripts/verify-release-assets.sh dist "${GITHUB_REF_NAME#v}"
+
+      - name: Attest release archives
+        uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2
+        with:
+          subject-path: |
+            dist/*.tar.gz
+            dist/*.zip
+            dist/checksums.txt
+            dist/install-extended.sh
+            dist/install-extended.ps1
+
      - name: Collect release asset
        run: |
          set -euo pipefail
          mkdir npm-publish-asset
-          cp dist/*.tar.gz dist/*.zip dist/checksums.txt npm-publish-asset/
+          cp dist/*.tar.gz dist/*.zip dist/checksums.txt \
+            dist/install-extended.sh dist/install-extended.ps1 \
+            npm-publish-asset/

      - name: Upload release asset
        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
@@ -97,6 +126,76 @@ jobs:
          if-no-files-found: error
          overwrite: true

+      - name: Publish verified GitHub release
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        with:
+          github-token: ${{ github.token }}
+          script: |
+            const crypto = require("node:crypto");
+            const fs = require("node:fs");
+            const tag = process.env.RELEASE_TAG;
+            const { owner, repo } = context.repo;
+            const releases = await github.paginate(github.rest.repos.listReleases, {
+              owner,
+              repo,
+              per_page: 100,
+            });
+            const matches = releases.filter((release) => release.tag_name === tag);
+            if (matches.length !== 1) {
+              throw new Error(`expected exactly one draft release for ${tag}, found ${matches.length}`);
+            }
+            const release = matches[0];
+            if (!release.draft) {
+              throw new Error(`release ${tag} became public before verification completed`);
+            }
+
+            const checksumPath = "dist/checksums.txt";
+            const checksumBody = fs.readFileSync(checksumPath, "utf8");
+            const expectedDigests = new Map();
+            for (const line of checksumBody.split(/\r?\n/)) {
+              if (!line.trim()) continue;
+              const match = line.match(/^([0-9a-fA-F]{64})\s+\*?(.+)$/);
+              if (!match) throw new Error(`invalid checksums.txt line: ${line}`);
+              const name = match[2];
+              if (expectedDigests.has(name)) {
+                throw new Error(`duplicate checksums.txt entry: ${name}`);
+              }
+              expectedDigests.set(name, `sha256:${match[1].toLowerCase()}`);
+            }
+            expectedDigests.set(
+              "checksums.txt",
+              `sha256:${crypto.createHash("sha256").update(checksumBody).digest("hex")}`,
+            );
+
+            const actualNames = release.assets.map((asset) => asset.name).sort();
+            const expectedNames = [...expectedDigests.keys()].sort();
+            if (JSON.stringify(actualNames) !== JSON.stringify(expectedNames)) {
+              throw new Error(
+                `draft release asset set mismatch: expected ${expectedNames.join(", ")}, got ${actualNames.join(", ")}`,
+              );
+            }
+            for (const asset of release.assets) {
+              const expected = expectedDigests.get(asset.name);
+              if (!asset.digest) {
+                throw new Error(`GitHub did not report a digest for draft asset ${asset.name}`);
+              }
+              if (asset.digest.toLowerCase() !== expected) {
+                throw new Error(
+                  `draft asset digest mismatch for ${asset.name}: expected ${expected}, got ${asset.digest}`,
+                );
+              }
+            }
+
+            await github.rest.repos.updateRelease({
+              owner,
+              repo,
+              release_id: release.id,
+              draft: false,
+              make_latest: "true",
+            });
+
  publish-npm:
    needs: build-release
    runs-on: ubuntu-22.04
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -5,7 +5,8 @@ before:
    - python3 scripts/fetch_meta.py

 builds:
-  - binary: lark-cli
+  - id: standard
+    binary: lark-cli
    env:
      - CGO_ENABLED=0
    ldflags:
@@ -18,12 +19,54 @@ builds:
      - amd64
      - arm64
      - riscv64
+    ignore:
+      - goos: darwin
+        goarch: riscv64
+      - goos: windows
+        goarch: riscv64
+  - id: extended
+    binary: lark-cli
+    tags:
+      - extended
+    env:
+      - CGO_ENABLED=0
+    ldflags:
+      - -s -w -X github.com/larksuite/cli/internal/build.Version={{ .Version }} -X github.com/larksuite/cli/internal/build.Date={{ .Date }}
+    goos:
+      - darwin
+      - linux
+      - windows
+    goarch:
+      - amd64
+      - arm64
+      - riscv64
+    ignore:
+      - goos: darwin
+        goarch: riscv64
+      - goos: windows
+        goarch: riscv64

 archives:
-  - name_template: "lark-cli-{{ .Version }}-{{ .Os }}-{{ .Arch }}"
+  - id: standard
+    ids:
+      - standard
+    name_template: "lark-cli-{{ .Version }}-{{ .Os }}-{{ .Arch }}"
    format_overrides:
      - goos: windows
-        format: zip
+        formats:
+          - zip
+    files:
+      - README.md
+      - LICENSE
+      - CHANGELOG.md
+  - id: extended
+    ids:
+      - extended
+    name_template: "lark-cli-extended-{{ .Version }}-{{ .Os }}-{{ .Arch }}"
+    format_overrides:
+      - goos: windows
+        formats:
+          - zip
    files:
      - README.md
      - LICENSE
@@ -31,6 +74,18 @@ archives:

 checksum:
  name_template: checksums.txt
+  extra_files:
+    - glob: ./scripts/install-extended.sh
+    - glob: ./scripts/install-extended.ps1
+
+release:
+  # Keep assets undiscoverable by releases/latest until the workflow has
+  # independently verified checksums, edition identity, and platform coverage.
+  draft: true
+  replace_existing_draft: true
+  extra_files:
+    - glob: ./scripts/install-extended.sh
+    - glob: ./scripts/install-extended.ps1

 changelog:
  sort: asc
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,35 +2,6 @@

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

-## [v1.0.81] - 2026-07-31
-
-### Features
-
- support visible_rule for form questions (#1891)
- **contact**: add bot search shortcut (#2083)
- add SXSD schema validation to Slides lint (#2103)
- **drive**: add comment-operation shortcuts (#1898)
- **drive**: extend permission shortcuts for Miaoda (#2070)
- **apps**: add cache debug commands (+cache-get/-delete/-clear) (#1896)
- support source file preview artifacts (#2085)
-
-### Bug Fixes
-
- **contact**: stop bot match segments carrying tags or empty entries (#2115)
- **base**: resolve Base URL block types accurately (#2099)
- **drive**: use title for default download filename (#2089)
- drop stale target version from root upgrade prompt (#2100)
-
-### Documentation
-
- **calendar**: warn against container-default timezone in time conversion (#2104)
- **calendar**: confirm scope before editing recurring events (#2119)
- **base**: clarify form and file operation routing (#2110)
-
-### Misc
-
- add protected public domain allowlists (#2111)
-
 ## [v1.0.80] - 2026-07-29

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

-[v1.0.81]: https://github.com/larksuite/cli/releases/tag/v1.0.81
 [v1.0.80]: https://github.com/larksuite/cli/releases/tag/v1.0.80
 [v1.0.79]: https://github.com/larksuite/cli/releases/tag/v1.0.79
 [v1.0.78]: https://github.com/larksuite/cli/releases/tag/v1.0.78
--- a/9
+++ b/9
@@ -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 live-skills-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test extended-test

 all: test

@@ -50,6 +50,7 @@ fmt-check:
 script-test:
 	bash scripts/resolve-changed-from.test.sh
 	bash scripts/ci-workflow.test.sh
+	bash scripts/release-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

@@ -121,6 +122,12 @@ sidecar-test:
 	go test $(RACE_FLAG) -count=1 -tags authsidecar_demo ./sidecar/server-demo/
 	go test $(RACE_FLAG) -count=1 -tags authsidecar ./tests/sidecar_e2e/

+# extended-test compiles and exercises the separately distributed Extended
+# edition. The default build remains the Standard npm/npx binary.
+extended-test:
+	go build -tags extended -o /dev/null .
+	go test $(RACE_FLAG) -count=1 -tags extended ./cmd/... ./internal/... ./shortcuts/... ./extension/... ./tests/externalcredential_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
@@ -310,6 +310,10 @@ 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
+
+[![Star History Chart](https://api.star-history.com/svg?repos=larksuite/cli&type=Date)](https://star-history.com/#larksuite/cli&Date)
+
 ## Contributing

 Community contributions are welcome! If you find a bug or have feature suggestions, please submit an [Issue](https://github.com/larksuite/cli/issues) or [Pull Request](https://github.com/larksuite/cli/pulls).
--- a/README.zh.md
+++ b/README.zh.md
@@ -311,6 +311,10 @@ lark-cli config risk-control default

 请您充分知悉全部使用风险，使用本工具即视为您自愿承担相关所有责任。

+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=larksuite/cli&type=Date)](https://star-history.com/#larksuite/cli&Date)
+
 ## 贡献

 欢迎社区贡献！如果你发现 bug 或有功能建议，请提交 [Issue](https://github.com/larksuite/cli/issues) 或 [Pull Request](https://github.com/larksuite/cli/pulls)。
--- a/cmd/auth/auth.go
+++ b/cmd/auth/auth.go
@@ -18,6 +18,7 @@ import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/errclass"
+	"github.com/larksuite/cli/internal/runtimeplan"
 )

 // NewCmdAuth creates the auth command with subcommands.
@@ -30,21 +31,23 @@ func NewCmdAuth(f *cmdutil.Factory) *cobra.Command {
 			// PersistentPreRun[E] found walking up the chain, so the root-level
 			// SilenceUsage=true would be skipped without this line.
 			cmd.SilenceUsage = true
-			// cmd.Name() returns the subcommand name (e.g. "login"), not "auth".
-			// Pass "auth" as a literal so the error message reads
-			// `"auth" is not supported: ...`
-			return f.RequireBuiltinCredentialProvider(cmd.Context(), "auth")
+			return f.RequireCommandRuntimeCapabilities(cmd.Context(), cmd)
 		},
 	}
 	cmdutil.DisableAuthCheck(cmd)
+	cmdutil.SetRuntimeCapabilities(cmd, runtimeplan.CapabilityLocalCredentialManagement)

-	cmd.AddCommand(NewCmdAuthLogin(f, nil))
-	cmd.AddCommand(NewCmdAuthLogout(f, nil))
-	cmd.AddCommand(NewCmdAuthStatus(f, nil))
-	cmd.AddCommand(NewCmdAuthScopes(f, nil))
-	cmd.AddCommand(NewCmdAuthList(f, nil))
-	cmd.AddCommand(NewCmdAuthCheck(f, nil))
-	cmd.AddCommand(NewCmdAuthQRCode(f, nil))
+	login := NewCmdAuthLogin(f, nil)
+	logout := NewCmdAuthLogout(f, nil)
+	status := NewCmdAuthStatus(f, nil)
+	scopes := NewCmdAuthScopes(f, nil)
+	list := NewCmdAuthList(f, nil)
+	check := NewCmdAuthCheck(f, nil)
+	qrcode := NewCmdAuthQRCode(f, nil)
+	for _, diagnostic := range []*cobra.Command{status, scopes, check, qrcode} {
+		cmdutil.SetRuntimeCapabilities(diagnostic)
+	}
+	cmd.AddCommand(login, logout, status, scopes, list, check, qrcode)
 	return cmd
 }

--- a/cmd/auth/auth_test.go
+++ b/cmd/auth/auth_test.go
@@ -530,10 +530,7 @@ func TestAuthBlockedByExternalProvider(t *testing.T) {
 	}{
 		{"login", []string{"login"}},
 		{"logout", []string{"logout"}},
-		{"status", []string{"status"}},
-		{"check", []string{"check", "--scope", "calendar:read"}}, // --scope is required
 		{"list", []string{"list"}},
-		{"scopes", []string{"scopes"}},
 	}

 	for _, tt := range tests {
@@ -558,3 +555,19 @@ func TestAuthBlockedByExternalProvider(t *testing.T) {
 		})
 	}
 }
+
+func TestAuthReadOnlyCommandsAllowedByExternalProvider(t *testing.T) {
+	f := newFactoryWithExternalProvider(t)
+	for _, name := range []string{"status", "check", "scopes", "qrcode"} {
+		t.Run(name, func(t *testing.T) {
+			cmd := NewCmdAuth(f)
+			matched, _, err := cmd.Find([]string{name})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := cmd.PersistentPreRunE(matched, nil); err != nil {
+				t.Fatalf("read-only command blocked: %v", err)
+			}
+		})
+	}
+}
--- a/cmd/auth/check.go
+++ b/cmd/auth/check.go
@@ -4,6 +4,7 @@
 package auth

 import (
+	"context"
 	"fmt"
 	"strings"

@@ -12,6 +13,7 @@ import (
 	"github.com/larksuite/cli/errs"
 	larkauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/output"
 )

@@ -33,7 +35,7 @@ func NewCmdAuthCheck(f *cmdutil.Factory, runF func(*CheckOptions) error) *cobra.
 			if runF != nil {
 				return runF(opts)
 			}
-			return authCheckRun(opts)
+			return authCheckRunContext(cmd.Context(), opts)
 		},
 	}

@@ -46,6 +48,10 @@ func NewCmdAuthCheck(f *cmdutil.Factory, runF func(*CheckOptions) error) *cobra.
 }

 func authCheckRun(opts *CheckOptions) error {
+	return authCheckRunContext(context.Background(), opts)
+}
+
+func authCheckRunContext(ctx context.Context, opts *CheckOptions) error {
 	f := opts.Factory

 	required := strings.Fields(opts.Scope)
@@ -57,18 +63,74 @@ func authCheckRun(opts *CheckOptions) error {
 	if err != nil {
 		return err
 	}
-	if config.UserOpenId == "" {
+	if f.Credential == nil {
+		return errs.NewInternalError(errs.SubtypeUnknown, "credential inspection is unavailable")
+	}
+
+	inspection, err := f.Credential.InspectToken(ctx, credential.TokenInspectionRequest{
+		TokenSpec: credential.TokenSpec{
+			Type:  credential.TokenTypeUAT,
+			AppID: config.AppID,
+		},
+		IncludeScopes: true,
+	})
+	if err != nil {
+		if _, ok := errs.ProblemOf(err); ok {
+			return err
+		}
+		return errs.NewInternalError(errs.SubtypeUnknown,
+			"failed to inspect user authorization: %v", err).
+			WithCause(err)
+	}
+	if inspection == nil {
+		return errs.NewInternalError(errs.SubtypeInvalidResponse,
+			"credential source returned no authorization inspection")
+	}
+
+	if inspection.Status == credential.TokenInspectionNotLoggedIn && !inspection.Source.Managed {
 		output.PrintJson(f.IOStreams.Out, map[string]interface{}{"ok": false, "error": "not_logged_in", "missing": required})
 		return output.ErrBare(1)
 	}
-
-	stored := larkauth.GetStoredToken(config.AppID, config.UserOpenId)
-	if stored == nil {
+	if !inspection.Present {
+		if inspection.Source.Managed {
+			return errs.NewAuthenticationError(errs.SubtypeTokenMissing,
+				"credential source %q did not provide a user access token", inspection.Source.Name).
+				WithHint("authorize the user through the selected credential source")
+		}
 		output.PrintJson(f.IOStreams.Out, map[string]interface{}{"ok": false, "error": "no_token", "missing": required})
 		return output.ErrBare(1)
 	}

-	missing := larkauth.MissingScopes(stored.Scope, required)
+	switch inspection.ScopeState {
+	case credential.ScopeUnsupported:
+		return errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"auth check is unsupported by credential source %q because granted scopes are unavailable", inspection.Source.Name).
+			WithHint("the credential source must expose trusted scope metadata before `auth check` can evaluate --scope")
+	case credential.ScopeUnknown:
+		return errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"auth check result is unknown because credential source %q returned no scope metadata", inspection.Source.Name).
+			WithHint("configure the credential source to return trusted scopes for user access tokens")
+	case credential.ScopeKnown:
+		// Continue below.
+	default:
+		return errs.NewInternalError(errs.SubtypeInvalidResponse,
+			"credential source %q returned invalid scope inspection state %q", inspection.Source.Name, inspection.ScopeState)
+	}
+
+	suggestion := ""
+	missing := larkauth.MissingScopes(inspection.Scopes, required)
+	if inspection.Source.Managed {
+		if len(missing) > 0 {
+			suggestion = fmt.Sprintf("grant these scopes through credential source %s: %s", inspection.Source.Name, strings.Join(missing, " "))
+		}
+	} else {
+		suggestion = fmt.Sprintf(`lark-cli auth login --scope "%s"`, strings.Join(missing, " "))
+	}
+	return writeAuthCheckResult(f, required, inspection.Scopes, suggestion)
+}
+
+func writeAuthCheckResult(f *cmdutil.Factory, required []string, availableScopes, suggestion string) error {
+	missing := larkauth.MissingScopes(availableScopes, required)
 	missingSet := make(map[string]bool, len(missing))
 	for _, s := range missing {
 		missingSet[s] = true
@@ -82,8 +144,8 @@ func authCheckRun(opts *CheckOptions) error {

 	ok := len(missing) == 0
 	result := map[string]interface{}{"ok": ok, "granted": granted, "missing": missing}
-	if len(missing) > 0 {
-		result["suggestion"] = fmt.Sprintf(`lark-cli auth login --scope "%s"`, strings.Join(missing, " "))
+	if len(missing) > 0 && suggestion != "" {
+		result["suggestion"] = suggestion
 	}
 	output.PrintJson(f.IOStreams.Out, result)
 	if !ok {
--- a/cmd/auth/check_test.go
+++ b/cmd/auth/check_test.go
@@ -4,14 +4,20 @@
 package auth

 import (
+	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
+	"strings"
 	"testing"
 	"time"

+	"github.com/larksuite/cli/errs"
+	extcred "github.com/larksuite/cli/extension/credential"
 	larkauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/zalando/go-keyring"
 )
@@ -146,6 +152,128 @@ func TestAuthCheckRun_ScopedTokenPresent_ExitZero(t *testing.T) {
 	}
 }

+type authCheckExternalProvider struct {
+	token        *extcred.Token
+	capabilities credential.ProviderCapabilities
+	resolveCalls int
+}
+
+func (p *authCheckExternalProvider) Name() string { return "external-check-test" }
+
+func (p *authCheckExternalProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
+	return &extcred.Account{AppID: "test-app", Brand: extcred.BrandFeishu}, nil
+}
+
+func (p *authCheckExternalProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
+	p.resolveCalls++
+	return p.token, nil
+}
+
+func (p *authCheckExternalProvider) CredentialCapabilities() credential.ProviderCapabilities {
+	return p.capabilities
+}
+
+func externalAuthCheckFactory(t *testing.T, canInspectScopes bool, token *extcred.Token) (*cmdutil.Factory, *authCheckExternalProvider) {
+	t.Helper()
+	cfg := &core.CliConfig{
+		AppID: "test-app",
+		Brand: core.BrandFeishu,
+	}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	provider := &authCheckExternalProvider{
+		token: token,
+		capabilities: credential.ProviderCapabilities{
+			ProvidesOnDemandAuth: true,
+			CanInspectScopes:     canInspectScopes,
+		},
+	}
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{provider},
+		nil,
+		nil,
+		nil,
+	)
+	return f, provider
+}
+
+func TestAuthCheckRun_ExternalDirectUsesProviderScopes(t *testing.T) {
+	f, provider := externalAuthCheckFactory(t, true, &extcred.Token{
+		Value:  "external-uat",
+		Scopes: "im:message docx:document",
+	})
+	stdout := f.IOStreams.Out.(*bytes.Buffer)
+
+	err := authCheckRun(&CheckOptions{
+		Factory: f,
+		Scope:   "im:message",
+	})
+	if err != nil {
+		t.Fatalf("authCheckRun() error = %v", err)
+	}
+	if provider.resolveCalls != 1 {
+		t.Fatalf("ResolveToken calls = %d, want 1", provider.resolveCalls)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
+		t.Fatalf("stdout must be valid JSON: %v\nstdout=%s", err, stdout.String())
+	}
+	if payload["ok"] != true {
+		t.Fatalf("stdout.ok = %v, want true; payload=%v", payload["ok"], payload)
+	}
+	granted, ok := payload["granted"].([]any)
+	if !ok || len(granted) != 1 || granted[0] != "im:message" {
+		t.Fatalf("stdout.granted = %v, want [im:message]", payload["granted"])
+	}
+}
+
+func TestAuthCheckRun_ExternalProxyReturnsTypedUnknown(t *testing.T) {
+	f, provider := externalAuthCheckFactory(t, false, &extcred.Token{
+		Value: "proxy-placeholder",
+	})
+
+	err := authCheckRun(&CheckOptions{
+		Factory: f,
+		Scope:   "im:message",
+	})
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error = %T %v, want typed error", err, err)
+	}
+	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeFailedPrecondition {
+		t.Fatalf("problem = %#v, want validation/failed_precondition", problem)
+	}
+	var validation *errs.ValidationError
+	if !errors.As(err, &validation) || !strings.Contains(problem.Message, "unsupported") || validation.Param != "" || problem.Hint == "" {
+		t.Fatalf("problem = %#v, want explicit unsupported result with actionable hint and no param", problem)
+	}
+	if provider.resolveCalls != 0 {
+		t.Fatalf("ResolveToken calls = %d, want 0 for proxy scope check", provider.resolveCalls)
+	}
+}
+
+func TestAuthCheckRun_ExternalDirectWithoutScopeMetadataReturnsTypedUnknown(t *testing.T) {
+	f, _ := externalAuthCheckFactory(t, true, &extcred.Token{
+		Value: "external-uat",
+	})
+
+	err := authCheckRun(&CheckOptions{
+		Factory: f,
+		Scope:   "im:message",
+	})
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error = %T %v, want typed error", err, err)
+	}
+	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeFailedPrecondition {
+		t.Fatalf("problem = %#v, want validation/failed_precondition", problem)
+	}
+	var validation *errs.ValidationError
+	if !errors.As(err, &validation) || !strings.Contains(problem.Message, "unknown") || validation.Param != "" || problem.Hint == "" {
+		t.Fatalf("problem = %#v, want explicit unknown result with actionable hint and no param", problem)
+	}
+}
+
 func TestAuthCheckRun_EmptyScopeIsValidationError(t *testing.T) {
 	// Scope validation is a real input error, not a predicate negative
 	// answer — it must surface as a typed ValidationError with the normal
--- a/cmd/auth/qrcode.go
+++ b/cmd/auth/qrcode.go
@@ -56,6 +56,7 @@ For ASCII output, the result is printed to stdout with fixed size.`,
 	cmd.Flags().IntVar(&opts.Size, "size", 256, "Size of the QR code image in pixels (default: 256, for PNG mode only)")
 	cmd.Flags().BoolVar(&opts.ASCII, "ascii", false, "Output ASCII QR code to stdout")
 	cmd.Flags().StringVarP(&opts.Output, "output", "o", "", "Output file path for PNG image (relative path within current directory, required for non-ASCII mode)")
+	cmdutil.SetRisk(cmd, "read")

 	return cmd
 }
--- a/cmd/auth/status.go
+++ b/cmd/auth/status.go
@@ -44,6 +44,10 @@ func NewCmdAuthStatus(f *cmdutil.Factory, runF func(*StatusOptions) error) *cobr

 func authStatusRun(opts *StatusOptions) error {
 	f := opts.Factory
+	editionStatus, err := inspectEditionStatus(f)
+	if err != nil {
+		return err
+	}

 	config, err := f.Config()
 	if err != nil {
@@ -64,7 +68,9 @@ func authStatusRun(opts *StatusOptions) error {
 	result["identities"] = diagnostics
 	result["identity"] = effectiveIdentity(diagnostics)
 	addEffectiveVerification(result, diagnostics)
-	addStatusNote(result, diagnostics)
+	if !applyEditionStatus(result, diagnostics, editionStatus) {
+		addStatusNote(result, diagnostics)
+	}

 	output.PrintJson(f.IOStreams.Out, result)
 	return nil
--- a/cmd/auth/status_edition_extended.go
+++ b/cmd/auth/status_edition_extended.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package auth
+
+import (
+	"context"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/identitydiag"
+)
+
+type editionStatusState struct {
+	provider string
+	variant  string
+}
+
+func inspectEditionStatus(f *cmdutil.Factory) (editionStatusState, error) {
+	if f == nil || f.Credential == nil {
+		return editionStatusState{}, nil
+	}
+	source, err := f.Credential.InspectSource(context.Background())
+	if err != nil {
+		return editionStatusState{}, err
+	}
+	if source == nil || !source.Managed {
+		return editionStatusState{}, nil
+	}
+	state := editionStatusState{provider: source.Name}
+	description := f.RuntimeDescription()
+	if description.Managed {
+		state.variant = description.Variant
+	}
+	return state, nil
+}
+
+func applyEditionStatus(result map[string]interface{}, diagnostics identitydiag.Result, state editionStatusState) bool {
+	if state.provider == "" {
+		return false
+	}
+	result["source"] = "external"
+	result["credentialProvider"] = state.provider
+	if state.variant != "" {
+		result["externalCredentialMode"] = state.variant
+	}
+	switch {
+	case !diagnostics.User.Available && diagnostics.Bot.Available:
+		result["note"] = "User identity is " + identitydiag.StatusMessage(diagnostics.User.Status) +
+			"; bot identity is ready. Update authorization through external credential provider " + state.provider + "."
+	case diagnostics.User.Status == identitydiag.StatusNeedsRefresh:
+		result["note"] = "User identity needs refresh. Check external credential provider " + state.provider + "."
+	case !diagnostics.User.Available && !diagnostics.Bot.Available:
+		result["note"] = "No usable identity is available. Check external credential provider " + state.provider + "."
+	}
+	return true
+}
--- a/cmd/auth/status_edition_extended_test.go
+++ b/cmd/auth/status_edition_extended_test.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package auth
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/runtimeplan"
+)
+
+func TestExtendedAuthStatusReportsManagedSource(t *testing.T) {
+	cfg := &core.CliConfig{
+		AppID: "cli_env", Brand: core.BrandFeishu, DefaultAs: core.AsBot,
+		SupportedIdentities: uint8(extcred.SupportsBot),
+	}
+	f, stdout, _, _ := cmdutil.TestFactory(t, cfg)
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{&stubExternalProvider{name: "env"}},
+		nil, nil, f.HttpClient,
+	)
+	cmdutil.TestSetRuntimePlan(t, f, runtimeplan.New(runtimeplan.Options{
+		Description: runtimeplan.Description{
+			Managed: true,
+			Variant: "managed-test",
+		},
+	}))
+
+	if err := authStatusRun(&StatusOptions{Factory: f}); err != nil {
+		t.Fatal(err)
+	}
+	var got map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	if got["source"] != "external" ||
+		got["credentialProvider"] != "env" ||
+		got["externalCredentialMode"] != "managed-test" ||
+		got["identity"] != "bot" {
+		t.Fatalf("output = %#v", got)
+	}
+	if note, _ := got["note"].(string); strings.Contains(note, "auth login") ||
+		!strings.Contains(note, "external credential provider env") {
+		t.Fatalf("note = %q", note)
+	}
+}
--- a/cmd/auth/status_edition_standard.go
+++ b/cmd/auth/status_edition_standard.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package auth
+
+import (
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/identitydiag"
+)
+
+type editionStatusState struct{}
+
+func inspectEditionStatus(*cmdutil.Factory) (editionStatusState, error) {
+	return editionStatusState{}, nil
+}
+
+func applyEditionStatus(map[string]interface{}, identitydiag.Result, editionStatusState) bool {
+	return false
+}
--- a/cmd/auth/status_edition_standard_test.go
+++ b/cmd/auth/status_edition_standard_test.go
@@ -0,0 +1,49 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package auth
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
+)
+
+func TestStandardAuthStatusPreservesExistingProjection(t *testing.T) {
+	cfg := &core.CliConfig{
+		AppID: "cli_env", Brand: core.BrandFeishu, DefaultAs: core.AsBot,
+		SupportedIdentities: uint8(extcred.SupportsBot),
+	}
+	f, stdout, _, _ := cmdutil.TestFactory(t, cfg)
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{&stubExternalProvider{name: "env"}},
+		nil, nil, f.HttpClient,
+	)
+
+	if err := authStatusRun(&StatusOptions{Factory: f}); err != nil {
+		t.Fatal(err)
+	}
+	var got map[string]json.RawMessage
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	for _, field := range []string{"source", "credentialProvider", "externalCredentialMode"} {
+		if _, exists := got[field]; exists {
+			t.Fatalf("Standard auth status contains edition field %q: %s", field, stdout.String())
+		}
+	}
+	var note string
+	if err := json.Unmarshal(got["note"], &note); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(note, "lark-cli auth login") {
+		t.Fatalf("Standard note = %q, want established login guidance", note)
+	}
+}
--- a/cmd/auth/status_test.go
+++ b/cmd/auth/status_test.go
@@ -35,6 +35,15 @@ func TestAuthStatusRun_SplitsBotAndUserIdentity(t *testing.T) {
 	if got.Identities.User.Status != "missing" || got.Identities.User.Available {
 		t.Fatalf("user = %#v, want missing and unavailable", got.Identities.User)
 	}
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal(stdout.Bytes(), &raw); err != nil {
+		t.Fatalf("json.Unmarshal(raw) error = %v", err)
+	}
+	for _, field := range []string{"source", "credentialProvider", "externalCredentialMode"} {
+		if _, exists := raw[field]; exists {
+			t.Fatalf("local auth status unexpectedly contains edition field %q: %s", field, stdout.String())
+		}
+	}
 }

 func TestAuthStatusRun_VerifyReportsBotIdentity(t *testing.T) {
--- a/cmd/build.go
+++ b/cmd/build.go
@@ -29,6 +29,7 @@ import (
 	"github.com/larksuite/cli/internal/hook"
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/registry"
+	"github.com/larksuite/cli/internal/runtimebootstrap"
 	"github.com/larksuite/cli/shortcuts"
 	"github.com/spf13/cobra"
 )
@@ -45,6 +46,7 @@ type buildConfig struct {
 	skipService    bool
 	serviceCatalog *apicatalog.Catalog
 	startupBrand   core.LarkBrand
+	runtime        *runtimebootstrap.Result
 }

 // WithStartupBrand initializes the API registry with the given brand before
@@ -58,6 +60,14 @@ func WithStartupBrand(brand core.LarkBrand) BuildOption {
 	}
 }

+// withRuntimeBootstrap shares one invocation snapshot across registry,
+// credentials, transports, and command capabilities.
+func withRuntimeBootstrap(runtime *runtimebootstrap.Result) BuildOption {
+	return func(c *buildConfig) {
+		c.runtime = runtime
+	}
+}
+
 // WithIO sets the IO streams for the CLI by wrapping raw reader/writers.
 // Terminal detection is delegated to cmdutil.NewIOStreams.
 func WithIO(in io.Reader, out, errOut io.Writer) BuildOption {
@@ -143,9 +153,9 @@ func Build(ctx context.Context, inv cmdutil.InvocationContext, opts ...BuildOpti
 	return rootCmd
 }

-// buildInternal is a pure assembly function: it wires the command tree from
-// inv and BuildOptions alone. Any state-dependent decision (disk, network,
-// env) belongs in the caller and must be threaded in via BuildOption.
+// buildInternal assembles the command tree from one immutable startup
+// configuration snapshot. Profile selection happens before any registry
+// network decision and the same result is passed to the Factory.
 //
 // Returns (factory, rootCmd, registry). The registry is nil when plugin
 // install failed (FailClosed guard installed) or when no plugin produced
@@ -168,13 +178,29 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 		cfg.streams = cmdutil.SystemIO()
 	}

-	// Initialize the registry brand before anything touches the runtime
-	// catalog (its sync.Once would otherwise lock onto the Feishu default).
-	if cfg.startupBrand != "" {
-		registry.InitWithBrand(cfg.startupBrand)
+	startup := cfg.runtime
+	if startup == nil {
+		startup = runtimebootstrap.Resolve(inv.Profile)
 	}

-	f := cmdutil.NewDefault(cfg.streams, inv)
+	// Initialize the registry brand before anything touches the runtime
+	// catalog (its sync.Once would otherwise lock onto the Feishu default).
+	// Runtime policy can close direct metadata egress before any command is
+	// registered, without exposing a concrete credential mode here.
+	registryBrand := cfg.startupBrand
+	if registryBrand == "" {
+		registryBrand = resolveStartupBrandFromConfig(inv.Profile, startup.ProfileConfig)
+	}
+	if !startup.Plan.AllowsRemoteMetadata() {
+		if registryBrand == "" {
+			registryBrand = core.BrandFeishu
+		}
+		registry.InitEmbeddedWithBrand(registryBrand)
+	} else if registryBrand != "" {
+		registry.InitWithBrand(registryBrand)
+	}
+
+	f := cmdutil.NewDefaultWithRuntimePlan(cfg.streams, inv, startup.ProfileConfig, startup.Plan)
 	if cfg.keychain != nil {
 		f.Keychain = cfg.keychain
 	}
@@ -220,6 +246,7 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 	rootCmd.AddCommand(schema.NewCmdSchema(f, nil))
 	rootCmd.AddCommand(completion.NewCmdCompletion(f))
 	rootCmd.AddCommand(cmdupdate.NewCmdUpdate(f))
+	registerEditionCommands(rootCmd, f)
 	rootCmd.AddCommand(cmdevent.NewCmdEvents(f))
 	rootCmd.AddCommand(skill.NewCmdSkill(f))
 	if !cfg.skipService {
--- a/cmd/build_workspace_test.go
+++ b/cmd/build_workspace_test.go
@@ -0,0 +1,176 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"context"
+	"io"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/envvars"
+)
+
+func TestStartupProfileSnapshotUsesDetectedWorkspace(t *testing.T) {
+	previousWorkspace := core.CurrentWorkspace()
+	t.Cleanup(func() { core.SetCurrentWorkspace(previousWorkspace) })
+
+	tests := []struct {
+		name          string
+		workspace     core.Workspace
+		signalName    string
+		signalValue   string
+		expectedAppID string
+		expectedBrand core.LarkBrand
+	}{
+		{
+			name:          "local",
+			workspace:     core.WorkspaceLocal,
+			expectedAppID: "cli_local",
+			expectedBrand: core.BrandFeishu,
+		},
+		{
+			name:          "openclaw",
+			workspace:     core.WorkspaceOpenClaw,
+			signalName:    "OPENCLAW_CLI",
+			signalValue:   "1",
+			expectedAppID: "cli_openclaw",
+			expectedBrand: core.BrandLark,
+		},
+		{
+			name:          "hermes",
+			workspace:     core.WorkspaceHermes,
+			signalName:    "HERMES_HOME",
+			signalValue:   "/managed/hermes",
+			expectedAppID: "cli_hermes",
+			expectedBrand: core.BrandLark,
+		},
+		{
+			name:          "lark_channel",
+			workspace:     core.WorkspaceLarkChannel,
+			signalName:    "LARK_CHANNEL",
+			signalValue:   "1",
+			expectedAppID: "cli_lark_channel",
+			expectedBrand: core.BrandLark,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			clearWorkspaceSignals(t)
+			clearCredentialSignals(t)
+			configRoot := t.TempDir()
+			t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configRoot)
+			t.Setenv(envvars.CliExternalCredentialConfig,
+				filepath.Join(configRoot, "missing-external-credential.json"))
+			t.Setenv("LARKSUITE_CLI_REMOTE_META", "off")
+			if tt.signalName != "" {
+				t.Setenv(tt.signalName, tt.signalValue)
+			}
+
+			writeWorkspaceProfile(t, core.WorkspaceLocal, "local", "cli_local", core.BrandFeishu)
+			if !tt.workspace.IsLocal() {
+				writeWorkspaceProfile(t, tt.workspace, tt.name, tt.expectedAppID, tt.expectedBrand)
+			}
+
+			// Execute resolves the registry brand before entering
+			// buildInternal. Pin that ordering independently.
+			core.SetCurrentWorkspace(core.WorkspaceLocal)
+			if got := selectInvocationWorkspace(); got != tt.workspace {
+				t.Fatalf("selected workspace = %q, want %q", got, tt.workspace)
+			}
+			if got := ResolveStartupBrand(""); got != tt.expectedBrand {
+				t.Fatalf("startup brand = %q, want %q", got, tt.expectedBrand)
+			}
+
+			// Build/buildInternal is also a public construction path. Reset the
+			// process state to local so the test proves it establishes the
+			// workspace before SelectProfile captures the immutable snapshot.
+			core.SetCurrentWorkspace(core.WorkspaceLocal)
+			factory, _, _ := buildInternal(
+				context.Background(),
+				cmdutil.InvocationContext{},
+				WithIO(strings.NewReader(""), io.Discard, io.Discard),
+				WithoutPlugins(),
+				WithoutServiceCommands(),
+			)
+			if got := core.CurrentWorkspace(); got != tt.workspace {
+				t.Fatalf("workspace after build = %q, want %q", got, tt.workspace)
+			}
+			config, err := factory.Config()
+			if err != nil {
+				t.Fatalf("Factory.Config() error = %v", err)
+			}
+			if config.AppID != tt.expectedAppID || config.Brand != tt.expectedBrand {
+				t.Fatalf("resolved config = app %q (%s), want app %q (%s)",
+					config.AppID, config.Brand, tt.expectedAppID, tt.expectedBrand)
+			}
+		})
+	}
+}
+
+func clearWorkspaceSignals(t *testing.T) {
+	t.Helper()
+	for _, name := range []string{
+		"OPENCLAW_CLI",
+		"OPENCLAW_HOME",
+		"OPENCLAW_STATE_DIR",
+		"OPENCLAW_CONFIG_PATH",
+		"OPENCLAW_SERVICE_MARKER",
+		"OPENCLAW_SERVICE_VERSION",
+		"OPENCLAW_GATEWAY_PORT",
+		"OPENCLAW_SHELL",
+		"HERMES_HOME",
+		"HERMES_QUIET",
+		"HERMES_EXEC_ASK",
+		"HERMES_GATEWAY_TOKEN",
+		"HERMES_SESSION_KEY",
+		"LARK_CHANNEL",
+	} {
+		t.Setenv(name, "")
+	}
+}
+
+func clearCredentialSignals(t *testing.T) {
+	t.Helper()
+	for _, name := range []string{
+		envvars.CliAppID,
+		envvars.CliAppSecret,
+		envvars.CliBrand,
+		envvars.CliUserAccessToken,
+		envvars.CliTenantAccessToken,
+		envvars.CliDefaultAs,
+		envvars.CliStrictMode,
+	} {
+		t.Setenv(name, "")
+	}
+}
+
+func writeWorkspaceProfile(
+	t *testing.T,
+	workspace core.Workspace,
+	name string,
+	appID string,
+	brand core.LarkBrand,
+) {
+	t.Helper()
+	previous := core.CurrentWorkspace()
+	core.SetCurrentWorkspace(workspace)
+	defer core.SetCurrentWorkspace(previous)
+	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
+		CurrentApp: name,
+		Apps: []core.AppConfig{{
+			Name:      name,
+			AppId:     appID,
+			AppSecret: core.PlainSecret("test-secret-" + name),
+			Brand:     brand,
+			Users:     []core.AppUser{},
+		}},
+	}); err != nil {
+		t.Fatalf("save %s workspace profile: %v", workspace.Display(), err)
+	}
+}
--- a/cmd/config/config.go
+++ b/cmd/config/config.go
@@ -6,6 +6,7 @@ package config
 import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/runtimeplan"
 	"github.com/spf13/cobra"
 )

@@ -19,22 +20,38 @@ func NewCmdConfig(f *cmdutil.Factory) *cobra.Command {
 			// PersistentPreRun[E] found walking up the chain, so the root-level
 			// SilenceUsage=true would be skipped without this line.
 			cmd.SilenceUsage = true
-			// Pass "config" as a literal — cmd.Name() would return the subcommand name.
-			return f.RequireBuiltinCredentialProvider(cmd.Context(), "config")
+			return f.RequireCommandRuntimeCapabilities(cmd.Context(), cmd)
 		},
 	}
 	cmdutil.DisableAuthCheck(cmd)
+	cmdutil.SetRuntimeCapabilities(cmd, runtimeplan.CapabilityLocalCredentialManagement)

-	cmd.AddCommand(NewCmdConfigInit(f, nil))
-	cmd.AddCommand(NewCmdConfigBind(f, nil))
-	cmd.AddCommand(NewCmdConfigRemove(f, nil))
-	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))
+	initCmd := NewCmdConfigInit(f, nil)
+	bind := NewCmdConfigBind(f, nil)
+	remove := NewCmdConfigRemove(f, nil)
+	show := NewCmdConfigShow(f, nil)
+	defaultAs := NewCmdConfigDefaultAs(f)
+	strictMode := NewCmdConfigStrictMode(f)
+	riskControl := NewCmdConfigRiskControl(f)
+	policy := NewCmdConfigPolicy(f)
+	plugins := NewCmdConfigPlugins(f)
+	keychainDowngrade := NewCmdConfigKeychainDowngrade(f)
+	// Identity preferences live in the Profile, but external providers have
+	// historically treated these config commands as credential management.
+	// Check Profile ownership first so a managed runtime gives the actionable
+	// deployment-managed Profile error, then retain the credential capability
+	// so Standard external-provider behavior stays unchanged.
+	for _, identitySetting := range []*cobra.Command{defaultAs, strictMode} {
+		cmdutil.SetRuntimeCapabilities(
+			identitySetting,
+			runtimeplan.CapabilityLocalProfileMutation,
+			runtimeplan.CapabilityLocalCredentialManagement,
+		)
+	}
+	for _, sourceNeutral := range []*cobra.Command{show, riskControl, policy, plugins} {
+		cmdutil.SetRuntimeCapabilities(sourceNeutral)
+	}
+	cmd.AddCommand(initCmd, bind, remove, show, defaultAs, strictMode, riskControl, policy, plugins, keychainDowngrade)
 	return cmd
 }

--- a/cmd/config/config_test.go
+++ b/cmd/config/config_test.go
@@ -20,6 +20,7 @@ import (
 	"github.com/larksuite/cli/internal/i18n"
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/runtimeplan"
 )

 type noopConfigKeychain struct{}
@@ -452,10 +453,16 @@ func TestUpdateExistingProfileWithoutSecret_RejectsAppIDChange(t *testing.T) {
 }

 // stubConfigExtProvider simulates env/sidecar credential mode for config guard tests.
-type stubConfigExtProvider struct{ name string }
+type stubConfigExtProvider struct {
+	name string
+	err  error
+}

 func (s *stubConfigExtProvider) Name() string { return s.name }
 func (s *stubConfigExtProvider) ResolveAccount(_ context.Context) (*extcred.Account, error) {
+	if s.err != nil {
+		return nil, s.err
+	}
 	return &extcred.Account{AppID: "test-app"}, nil
 }
 func (s *stubConfigExtProvider) ResolveToken(_ context.Context, _ extcred.TokenSpec) (*extcred.Token, error) {
@@ -481,7 +488,6 @@ func TestConfigBlockedByExternalProvider(t *testing.T) {
 	}{
 		{"init", []string{"init", "--app-id", "x", "--app-secret-stdin"}},
 		{"remove", []string{"remove"}},
-		{"show", []string{"show"}},
 		{"default-as", []string{"default-as", "user"}},
 		{"strict-mode", []string{"strict-mode", "off"}},
 	}
@@ -509,6 +515,63 @@ func TestConfigBlockedByExternalProvider(t *testing.T) {
 	}
 }

+func TestConfigIdentityCommandsCheckProfileOwnershipBeforeCredentialOwnership(t *testing.T) {
+	profileDenied := errors.New("Profile identity settings are deployment-managed")
+	credentialChecks := 0
+	plan := runtimeplan.New(runtimeplan.Options{
+		Capabilities: func(capability runtimeplan.Capability) error {
+			switch capability {
+			case runtimeplan.CapabilityLocalProfileMutation:
+				return profileDenied
+			case runtimeplan.CapabilityLocalCredentialManagement:
+				credentialChecks++
+			}
+			return nil
+		},
+	})
+
+	for _, args := range [][]string{
+		{"default-as", "bot"},
+		{"strict-mode", "bot"},
+	} {
+		t.Run(args[0], func(t *testing.T) {
+			f, _, _, _ := cmdutil.TestFactoryWithRuntimePlan(t, nil, plan)
+			cmd := NewCmdConfig(f)
+			cmd.SetArgs(args)
+
+			err := cmd.Execute()
+			if !errors.Is(err, profileDenied) {
+				t.Fatalf("Execute(%v) error = %v, want Profile ownership denial", args, err)
+			}
+		})
+	}
+	if credentialChecks != 0 {
+		t.Fatalf("credential capability checked %d times after Profile denial, want 0", credentialChecks)
+	}
+}
+
+func TestConfigIdentityCommandsRetainCredentialOwnershipCapability(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	root := NewCmdConfig(f)
+
+	for _, name := range []string{"default-as", "strict-mode"} {
+		t.Run(name, func(t *testing.T) {
+			leaf, _, err := root.Find([]string{name})
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := cmdutil.GetRuntimeCapabilities(leaf)
+			want := []runtimeplan.Capability{
+				runtimeplan.CapabilityLocalProfileMutation,
+				runtimeplan.CapabilityLocalCredentialManagement,
+			}
+			if len(got) != len(want) || got[0] != want[0] || got[1] != want[1] {
+				t.Fatalf("%s capabilities = %v, want %v", name, got, want)
+			}
+		})
+	}
+}
+
 // TestValidateInitLang covers the --lang contract: empty (omitted or explicit)
 // is a no-op leaving Lang unset; a short code or Feishu locale canonicalizes to
 // the same locale; an unrecognized value errors.
--- a/cmd/config/init_interactive.go
+++ b/cmd/config/init_interactive.go
@@ -179,8 +179,8 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 	}

 	// Step 1: Request app registration (begin)
-	// Registration is platform traffic, so it must use the provider-aware
-	// transport as well as the shared proxy configuration.
+	// Use the shared proxy-plugin-aware transport so registration traffic is not
+	// a bypass of proxy plugin mode.
 	httpClient := transport.NewHTTPClient(0)
 	authResp, err := larkauth.RequestAppRegistration(ctx, httpClient, larkBrand, f.IOStreams.ErrOut)
 	if err != nil {
--- a/cmd/config/plugins.go
+++ b/cmd/config/plugins.go
@@ -27,13 +27,6 @@ func NewCmdConfigPlugins(f *cmdutil.Factory) *cobra.Command {
 		Use:    "plugins",
 		Hidden: true, // diagnostic-only; kept callable, omitted from --help so it stays out of AI-agent context
 		Short:  "Inspect installed plugins and their hook contributions",
-		// Same leaf-level no-op as config policy: the parent `config`
-		// group's PersistentPreRunE requires builtin credential, but
-		// this is a read-only diagnostic that must work everywhere.
-		PersistentPreRunE: func(c *cobra.Command, _ []string) error {
-			c.SilenceUsage = true
-			return nil
-		},
 	}
 	cmd.AddCommand(newCmdConfigPluginsShow(f))
 	return cmd
--- a/cmd/config/policy.go
+++ b/cmd/config/policy.go
@@ -16,12 +16,6 @@ func NewCmdConfigPolicy(f *cmdutil.Factory) *cobra.Command {
 		Use:    "policy",
 		Hidden: true,
 		Short:  "Inspect the user-layer command policy",
-		// Override parent's RequireBuiltinCredentialProvider check; this
-		// group is read-only diagnostic and must work under any provider.
-		PersistentPreRunE: func(c *cobra.Command, _ []string) error {
-			c.SilenceUsage = true
-			return nil
-		},
 	}
 	cmd.AddCommand(newCmdConfigPolicyShow(f))
 	return cmd
--- a/cmd/config/policy_test.go
+++ b/cmd/config/policy_test.go
@@ -132,19 +132,16 @@ func TestConfigPolicyShow_YamlSourceNameIsEmpty(t *testing.T) {
 	}
 }

-// Regression: the parent `config` command declares a PersistentPreRunE
-// that calls RequireBuiltinCredentialProvider; env credentials cause
-// it to return external_provider. `config policy` is a diagnostic
-// group that must not be blocked by that check. The group declares
-// its own no-op PersistentPreRunE so cobra's "first walking up from
-// leaf" picks ours over the config parent's.
-func TestConfigPolicy_BypassesConfigParentPersistentPreRunE(t *testing.T) {
+// The policy group explicitly overrides the config parent's local credential
+// management capability because it is source-neutral diagnostics.
+func TestConfigPolicyOverridesCredentialManagementCapability(t *testing.T) {
 	f, _, _ := newPolicyTestFactory()
-	group := NewCmdConfigPolicy(f)
-	if group.PersistentPreRunE == nil {
-		t.Fatal("config policy group must declare its own PersistentPreRunE to win over config parent")
+	root := NewCmdConfig(f)
+	leaf, _, err := root.Find([]string{"policy", "show"})
+	if err != nil {
+		t.Fatal(err)
 	}
-	if err := group.PersistentPreRunE(group, nil); err != nil {
-		t.Errorf("config policy PersistentPreRunE should be no-op, got %v", err)
+	if capabilities := cmdutil.GetRuntimeCapabilities(leaf); len(capabilities) != 0 {
+		t.Fatalf("policy capabilities = %v, want source-neutral", capabilities)
 	}
 }
--- a/cmd/config/risk_control.go
+++ b/cmd/config/risk_control.go
@@ -23,11 +23,6 @@ func NewCmdConfigRiskControl(f *cmdutil.Factory) *cobra.Command {
 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 {
--- a/cmd/config/show.go
+++ b/cmd/config/show.go
@@ -42,6 +42,16 @@ func NewCmdConfigShow(f *cmdutil.Factory, runF func(*ConfigShowOptions) error) *

 func configShowRun(opts *ConfigShowOptions) error {
 	f := opts.Factory
+	// config show describes the effective invocation configuration, not merely
+	// the bytes in config.json. Preserve the typed bootstrap failure so a
+	// Standard binary cannot present a local Profile as active when the system
+	// requires Extended runtime support.
+	if startupErr := f.RuntimeStartupError(); startupErr != nil {
+		return startupErr
+	}
+	if handled, editionErr := showEditionConfig(f); handled {
+		return editionErr
+	}

 	config, err := core.LoadMultiAppConfig()
 	if err != nil {
--- a/cmd/config/show_edition_extended.go
+++ b/cmd/config/show_edition_extended.go
@@ -0,0 +1,73 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package config
+
+import (
+	"context"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/output"
+)
+
+type editionConfigShowResult struct {
+	Source                 string  `json:"source"`
+	CredentialProvider     string  `json:"credentialProvider"`
+	Manageable             bool    `json:"manageable"`
+	Workspace              string  `json:"workspace"`
+	AppID                  string  `json:"appId"`
+	Brand                  string  `json:"brand"`
+	DefaultAs              string  `json:"defaultAs"`
+	Profile                *string `json:"profile,omitempty"`
+	ExternalCredentialMode *string `json:"externalCredentialMode,omitempty"`
+	RemoteEndpoint         *string `json:"remoteEndpoint,omitempty"`
+}
+
+func showEditionConfig(f *cmdutil.Factory) (bool, error) {
+	if f == nil || f.Credential == nil {
+		return false, nil
+	}
+	source, err := f.Credential.InspectSource(context.Background())
+	if err != nil {
+		return true, typedEditionProviderError("determine the active credential provider", err)
+	}
+	if source == nil || !source.Managed {
+		return false, nil
+	}
+	if source.AppID == "" {
+		return true, errs.NewInternalError(errs.SubtypeInvalidResponse,
+			"external credential provider %q returned no account", source.Name)
+	}
+	result := editionConfigShowResult{
+		Source:             "external",
+		CredentialProvider: source.Name,
+		Manageable:         false,
+		Workspace:          core.CurrentWorkspace().Display(),
+		AppID:              source.AppID,
+		Brand:              string(source.Brand),
+		DefaultAs:          string(source.DefaultAs),
+	}
+	description := f.RuntimeDescription()
+	if source.ProfileName != "" {
+		result.Profile = &source.ProfileName
+	}
+	if description.Managed && description.Variant != "" {
+		result.ExternalCredentialMode = &description.Variant
+		if description.ProxiesRequests {
+			result.RemoteEndpoint = &description.DataPlaneEndpoint
+		}
+	}
+	output.PrintJson(f.IOStreams.Out, result)
+	return true, nil
+}
+
+func typedEditionProviderError(action string, err error) error {
+	if _, ok := errs.ProblemOf(err); ok {
+		return err
+	}
+	return errs.NewInternalError(errs.SubtypeUnknown, "failed to %s: %v", action, err).WithCause(err)
+}
--- a/cmd/config/show_edition_extended_test.go
+++ b/cmd/config/show_edition_extended_test.go
@@ -0,0 +1,93 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package config
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/runtimeplan"
+)
+
+func TestExtendedConfigShowAllowedWithManagedSource(t *testing.T) {
+	f := newConfigFactoryWithExternalProvider(t)
+	cmd := NewCmdConfig(f)
+	matched, _, err := cmd.Find([]string{"show"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := cmd.PersistentPreRunE(matched, nil); err != nil {
+		t.Fatalf("config show blocked: %v", err)
+	}
+}
+
+func TestExtendedConfigShowProjectsManagedSource(t *testing.T) {
+	f := newConfigFactoryWithExternalProvider(t)
+	var stdout bytes.Buffer
+	f.IOStreams.Out = &stdout
+	cmdutil.TestSetRuntimePlan(t, f, runtimeplan.New(runtimeplan.Options{
+		Description: runtimeplan.Description{
+			Managed:           true,
+			Variant:           "managed-test",
+			ProxiesRequests:   true,
+			DataPlaneEndpoint: "https://managed.example.test",
+		},
+	}))
+
+	if err := configShowRun(&ConfigShowOptions{Factory: f}); err != nil {
+		t.Fatalf("configShowRun() error = %v", err)
+	}
+	var got editionConfigShowResult
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	if got.Source != "external" ||
+		got.CredentialProvider != "env" ||
+		got.Manageable ||
+		got.AppID != "test-app" ||
+		got.ExternalCredentialMode == nil ||
+		*got.ExternalCredentialMode != "managed-test" ||
+		got.RemoteEndpoint == nil ||
+		*got.RemoteEndpoint != "https://managed.example.test" {
+		t.Fatalf("output = %#v", got)
+	}
+	var fields map[string]json.RawMessage
+	if err := json.Unmarshal(stdout.Bytes(), &fields); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := fields["appSecret"]; ok {
+		t.Fatalf("managed output must not invent appSecret: %s", stdout.String())
+	}
+	if _, ok := fields["users"]; ok {
+		t.Fatalf("managed output must not invent users: %s", stdout.String())
+	}
+}
+
+func TestExtendedConfigShowTypesManagedSourceFailure(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	providerErr := errors.New("provider failed")
+	cred := credential.NewCredentialProvider(
+		[]extcred.Provider{&stubConfigExtProvider{name: "broken", err: providerErr}},
+		nil, nil, nil,
+	)
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	f.Credential = cred
+
+	err := configShowRun(&ConfigShowOptions{Factory: f})
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeUnknown {
+		t.Fatalf("error = %#v, want internal/unknown", err)
+	}
+	if !errors.Is(err, providerErr) {
+		t.Fatalf("error does not preserve provider failure: %v", err)
+	}
+}
--- a/cmd/config/show_edition_standard.go
+++ b/cmd/config/show_edition_standard.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package config
+
+import "github.com/larksuite/cli/internal/cmdutil"
+
+func showEditionConfig(*cmdutil.Factory) (bool, error) {
+	return false, nil
+}
--- a/cmd/config/show_edition_standard_test.go
+++ b/cmd/config/show_edition_standard_test.go
@@ -0,0 +1,54 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package config
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/runtimeplan"
+)
+
+func TestStandardConfigShowPreservesLocalConfigPath(t *testing.T) {
+	f := newConfigFactoryWithExternalProvider(t)
+
+	err := configShowRun(&ConfigShowOptions{Factory: f})
+	problem, ok := errs.ProblemOf(err)
+	if !ok ||
+		problem.Category != errs.CategoryConfig ||
+		problem.Subtype != errs.SubtypeNotConfigured {
+		t.Fatalf("error = %#v, want established config/not_configured result", err)
+	}
+}
+
+func TestStandardConfigShowReturnsTypedRuntimeStartupError(t *testing.T) {
+	startupErr := errs.NewValidationError(
+		errs.SubtypeFailedPrecondition,
+		"system external credential configuration requires the lark-cli Extended edition",
+	).WithHint("install lark-cli Extended or ask the administrator to remove external-credential.json")
+	f, stdout, _, _ := cmdutil.TestFactoryWithRuntimePlan(
+		t,
+		nil,
+		runtimeplan.Failed(startupErr, runtimeplan.MetadataEmbeddedOnly),
+	)
+
+	err := configShowRun(&ConfigShowOptions{Factory: f})
+	if !errors.Is(err, startupErr) {
+		t.Fatalf("config show error = %v, want original startup error", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok ||
+		problem.Category != errs.CategoryValidation ||
+		problem.Subtype != errs.SubtypeFailedPrecondition ||
+		problem.Message != "system external credential configuration requires the lark-cli Extended edition" {
+		t.Fatalf("config show problem = %#v, want typed Extended-required startup failure", problem)
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("config show wrote local Profile after bootstrap failure: %s", stdout.String())
+	}
+}
--- a/cmd/doctor/doctor.go
+++ b/cmd/doctor/doctor.go
@@ -84,6 +84,10 @@ func doctorRun(opts *DoctorOptions) error {
 		checks = append(checks, checkCLIUpdate()...)
 	}

+	if handled, editionErr := runEditionDoctor(opts, checks); handled {
+		return editionErr
+	}
+
 	// ── 1. Config file ──
 	_, err := core.LoadMultiAppConfig()
 	if err != nil {
@@ -130,8 +134,7 @@ func doctorRun(opts *DoctorOptions) error {
 		checks = append(checks, pass("identity_ready", "at least one identity is available"))
 	} else {
 		// No hint: this only summarizes the two checks above, which already carry
-		// the source-appropriate remediation. A command here would be redundant,
-		// or wrong (`auth status` is blocked under an external provider).
+		// the source-appropriate remediation. A command here would be redundant.
 		checks = append(checks, fail("identity_ready", "no usable bot or user identity is available", ""))
 	}

@@ -157,8 +160,8 @@ func networkChecks(ctx context.Context, opts *DoctorOptions, ep core.Endpoints)
 		}
 	}

-	// Connectivity checks are platform traffic and must exercise the same
-	// provider-aware route as real platform requests.
+	// Use the shared proxy-plugin-aware transport so connectivity checks reflect
+	// the real egress path (and are blocked when proxy plugin fails closed).
 	httpClient := transport.NewHTTPClient(0)
 	mcpURL := ep.MCP + "/mcp"

@@ -215,7 +218,7 @@ func probeEndpoint(ctx context.Context, client *http.Client, url string) error {
 // Unlike the root-level async check, this does a synchronous fetch with timeout
 // and works regardless of build version (dev builds included).
 func checkCLIUpdate() []checkResult {
-	latest, err := update.FetchLatest()
+	latest, err := fetchLatestForEdition()
 	if err != nil {
 		return []checkResult{warn("cli_update", "check failed: "+err.Error(), "")}
 	}
--- a/cmd/doctor/doctor_edition_extended.go
+++ b/cmd/doctor/doctor_edition_extended.go
@@ -0,0 +1,94 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package doctor
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/larksuite/cli/errs"
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/identitydiag"
+)
+
+func runEditionDoctor(opts *DoctorOptions, checks []checkResult) (bool, error) {
+	f := opts.Factory
+	if f == nil || f.Credential == nil {
+		return false, nil
+	}
+	source, err := f.Credential.InspectSource(opts.Ctx)
+	if err != nil {
+		checks = append(checks, fail("credential_source", err.Error(), editionDiagnosticErrorHint(err)))
+		return true, finishDoctor(f, checks)
+	}
+	if source == nil || !source.Managed {
+		return false, nil
+	}
+
+	provider := source.Name
+	cfg, err := f.Config()
+	if err != nil {
+		checks = append(checks,
+			fail("credential_source", err.Error(), editionDiagnosticErrorHint(err)),
+			skip("config_file", fmt.Sprintf("local credentials are not used; source is %s", provider)),
+		)
+		return true, finishDoctor(f, checks)
+	}
+	checks = append(checks, pass("credential_source",
+		fmt.Sprintf("credentials provided by %s (app %s; token not verified by this check)", provider, cfg.AppID)))
+
+	description := f.RuntimeDescription()
+	if description.Managed {
+		checks = append(checks, pass("config_file", "config.json found (system external credential mode)"))
+	} else {
+		checks = append(checks, skip("config_file",
+			fmt.Sprintf("local config not used; credentials provided by %s", provider)))
+	}
+	checks = append(checks, pass("app_resolved", fmt.Sprintf("app: %s (%s)", cfg.AppID, cfg.Brand)))
+
+	diagnostics := identitydiag.Diagnose(opts.Ctx, f, cfg, !opts.Offline)
+	checks = append(checks,
+		identityCheck("bot_identity", diagnostics.Bot),
+		identityCheck("user_identity", diagnostics.User),
+	)
+	if diagnostics.Bot.Available || diagnostics.User.Available {
+		checks = append(checks, pass("identity_ready", "at least one identity is available"))
+	} else {
+		checks = append(checks, fail("identity_ready", "no usable bot or user identity is available", ""))
+	}
+
+	if description.ProxiesRequests {
+		checks = append(checks, editionProxyNetworkCheck(opts, description.DataPlaneEndpoint, diagnostics))
+	} else {
+		checks = append(checks, networkChecks(opts.Ctx, opts, core.ResolveEndpoints(cfg.Brand))...)
+	}
+	return true, finishDoctor(f, checks)
+}
+
+func editionDiagnosticErrorHint(err error) string {
+	var blockErr *extcred.BlockError
+	if errors.As(err, &blockErr) {
+		return blockErr.Reason
+	}
+	var cfgErr *errs.ConfigError
+	if errors.As(err, &cfgErr) {
+		return cfgErr.Hint
+	}
+	return ""
+}
+
+func editionProxyNetworkCheck(opts *DoctorOptions, endpoint string, diagnostics identitydiag.Result) checkResult {
+	if opts.Offline {
+		return skip("endpoint_external_platform", "skipped (--offline)")
+	}
+	verified := func(id identitydiag.Identity) bool { return id.Verified != nil && *id.Verified }
+	if verified(diagnostics.User) || verified(diagnostics.Bot) {
+		return pass("endpoint_external_platform", endpoint+" reachable through an authenticated API request")
+	}
+	return fail("endpoint_external_platform", endpoint+" could not complete an authenticated API request",
+		"check the external credential program and platform logs")
+}
--- a/cmd/doctor/doctor_edition_extended_test.go
+++ b/cmd/doctor/doctor_edition_extended_test.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package doctor
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/identitydiag"
+)
+
+func TestExtendedProxyNetworkCheckUsesAuthenticatedDiagnostics(t *testing.T) {
+	verified := true
+	endpoint := "https://credentials.example.com"
+	got := editionProxyNetworkCheck(&DoctorOptions{}, endpoint, identitydiag.Result{
+		User: identitydiag.Identity{Verified: &verified},
+	})
+	if got.Status != "pass" || got.Name != "endpoint_external_platform" {
+		t.Fatalf("check = %#v", got)
+	}
+
+	got = editionProxyNetworkCheck(&DoctorOptions{}, endpoint, identitydiag.Result{})
+	if got.Status != "fail" {
+		t.Fatalf("unverified check = %#v, want fail", got)
+	}
+}
+
+func TestExtendedDoctorManagedSourceDoesNotRequireLocalConfig(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	cfg := &core.CliConfig{
+		AppID: "cli_env", Brand: core.BrandFeishu,
+		SupportedIdentities: uint8(extcred.SupportsBot), DefaultAs: core.AsBot,
+	}
+	f, out, _, _ := cmdutil.TestFactory(t, cfg)
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{&fakeExtProvider{
+			name: "env",
+			account: &extcred.Account{
+				AppID:               "cli_env",
+				SupportedIdentities: extcred.SupportsBot,
+			},
+		}},
+		nil, nil, nil,
+	)
+
+	if err := doctorRun(&DoctorOptions{Factory: f, Ctx: context.Background(), Offline: true}); err != nil {
+		t.Fatalf("doctorRun() error = %v", err)
+	}
+	var got struct {
+		OK     bool          `json:"ok"`
+		Checks []checkResult `json:"checks"`
+	}
+	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	if !got.OK {
+		t.Fatalf("checks = %#v", got.Checks)
+	}
+	assertCheck(t, got.Checks, "credential_source", "pass")
+	configCheck := findCheck(t, got.Checks, "config_file")
+	if configCheck.Status != "skip" ||
+		!strings.Contains(configCheck.Message, "local config") ||
+		strings.Contains(configCheck.Message, "config init") {
+		t.Fatalf("config_file = %#v", configCheck)
+	}
+}
--- a/cmd/doctor/doctor_edition_standard.go
+++ b/cmd/doctor/doctor_edition_standard.go
@@ -0,0 +1,24 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package doctor
+
+import "github.com/larksuite/cli/errs"
+
+func runEditionDoctor(opts *DoctorOptions, checks []checkResult) (bool, error) {
+	if opts == nil || opts.Factory == nil {
+		return false, nil
+	}
+	startupErr := opts.Factory.RuntimeStartupError()
+	if startupErr == nil {
+		return false, nil
+	}
+	hint := ""
+	if problem, ok := errs.ProblemOf(startupErr); ok {
+		hint = problem.Hint
+	}
+	checks = append(checks, fail("credential_source", startupErr.Error(), hint))
+	return true, finishDoctor(opts.Factory, checks)
+}
--- a/cmd/doctor/doctor_edition_standard_test.go
+++ b/cmd/doctor/doctor_edition_standard_test.go
@@ -0,0 +1,52 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package doctor
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
+)
+
+func TestStandardDoctorPreservesConfigFirstDiagnostics(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	cfg := &core.CliConfig{
+		AppID: "cli_env", Brand: core.BrandFeishu,
+		SupportedIdentities: uint8(extcred.SupportsBot), DefaultAs: core.AsBot,
+	}
+	f, out, _, _ := cmdutil.TestFactory(t, cfg)
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{&fakeExtProvider{
+			name: "env",
+			account: &extcred.Account{
+				AppID:               "cli_env",
+				SupportedIdentities: extcred.SupportsBot,
+			},
+		}},
+		nil, nil, nil,
+	)
+
+	if err := doctorRun(&DoctorOptions{Factory: f, Ctx: context.Background(), Offline: true}); err == nil {
+		t.Fatal("doctorRun() = nil, want established missing-config failure")
+	}
+	var got struct {
+		Checks []checkResult `json:"checks"`
+	}
+	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	assertCheck(t, got.Checks, "config_file", "fail")
+	for _, check := range got.Checks {
+		if check.Name == "credential_source" {
+			t.Fatalf("Standard doctor exposed edition diagnostic: %#v", got.Checks)
+		}
+	}
+}
--- a/cmd/doctor/doctor_test.go
+++ b/cmd/doctor/doctor_test.go
@@ -4,7 +4,6 @@
 package doctor

 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"net/http"
@@ -175,6 +174,44 @@ func (p *fakeExtProvider) ResolveToken(context.Context, extcred.TokenSpec) (*ext
 	return nil, nil
 }

+type failingDefaultAccountResolver struct {
+	err error
+}
+
+func (r *failingDefaultAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
+	return nil, r.err
+}
+
+func TestDoctor_DefaultResolutionFailurePreservesConfigFileCheck(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	f, out, _, _ := cmdutil.TestFactory(t, nil)
+	f.Credential = credential.NewCredentialProvider(
+		nil,
+		&failingDefaultAccountResolver{err: core.NotConfiguredError()},
+		nil,
+		nil,
+	)
+
+	if err := doctorRun(&DoctorOptions{Factory: f, Ctx: context.Background(), Offline: true}); err == nil {
+		t.Fatal("doctorRun() = nil, want not-configured failure")
+	}
+	var got struct {
+		Checks []checkResult `json:"checks"`
+	}
+	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
+		t.Fatalf("json.Unmarshal() error = %v\n%s", err, out.String())
+	}
+	configCheck := findCheck(t, got.Checks, "config_file")
+	if configCheck.Status != "fail" {
+		t.Fatalf("config_file = %#v, want fail", configCheck)
+	}
+	for _, check := range got.Checks {
+		if check.Name == "credential_source" {
+			t.Fatalf("default source resolution replaced the legacy config check: %#v", got.Checks)
+		}
+	}
+}
+
 // Under an external credential provider with no usable identity, the
 // identity_ready hint must not point at `auth status` (blocked there); the
 // per-identity checks already carry the source-appropriate escalation.
@@ -195,12 +232,8 @@ func TestDoctor_ExternalProvider_IdentityReadyHintNotBlockedCommand(t *testing.T
 		nil, nil,
 		func() (*http.Client, error) { return nil, nil },
 	)
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{
-		Config:     func() (*core.CliConfig, error) { return cfg, nil },
-		Credential: cred,
-		IOStreams:  &cmdutil.IOStreams{Out: out, ErrOut: &bytes.Buffer{}},
-	}
+	f, out, _, _ := cmdutil.TestFactory(t, cfg)
+	f.Credential = cred

 	if err := doctorRun(&DoctorOptions{Factory: f, Ctx: context.Background(), Offline: true}); err == nil {
 		t.Fatalf("doctorRun() = nil, want failure when no identity is available")
--- a/cmd/doctor/update_extended.go
+++ b/cmd/doctor/update_extended.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package doctor
+
+import "github.com/larksuite/cli/internal/extendedupdate"
+
+func fetchLatestForEdition() (string, error) {
+	return extendedupdate.FetchLatest()
+}
--- a/cmd/doctor/update_standard.go
+++ b/cmd/doctor/update_standard.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package doctor
+
+import "github.com/larksuite/cli/internal/update"
+
+func fetchLatestForEdition() (string, error) {
+	return update.FetchLatest()
+}
--- a/cmd/doctor_startup_standard_test.go
+++ b/cmd/doctor_startup_standard_test.go
@@ -0,0 +1,74 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/envvars"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+func TestStandardDoctorReportsEditionSentinelWithoutLocalProfile(t *testing.T) {
+	clearWorkspaceSignals(t)
+	clearCredentialSignals(t)
+	configDir := t.TempDir()
+	systemPath := filepath.Join(configDir, "external-credential.json")
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	t.Setenv(envvars.CliExternalCredentialConfig, systemPath)
+	t.Setenv("LARKSUITE_CLI_REMOTE_META", "off")
+	t.Setenv("LARKSUITE_CLI_NO_UPDATE_NOTIFIER", "1")
+	t.Setenv("LARKSUITE_CLI_NO_SKILLS_NOTIFIER", "1")
+	if err := vfs.WriteFile(systemPath, []byte("sentinel-only"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	var stdout, stderr bytes.Buffer
+	root := Build(
+		context.Background(),
+		cmdutil.InvocationContext{},
+		WithIO(strings.NewReader(""), &stdout, &stderr),
+		WithoutPlugins(),
+		WithoutServiceCommands(),
+	)
+	root.SetArgs([]string{"doctor", "--offline"})
+	if err := root.ExecuteContext(context.Background()); err == nil {
+		t.Fatal("doctor returned nil, want failed diagnostic result")
+	}
+
+	var report struct {
+		Checks []struct {
+			Name    string `json:"name"`
+			Status  string `json:"status"`
+			Message string `json:"message"`
+			Hint    string `json:"hint"`
+		} `json:"checks"`
+	}
+	if err := json.Unmarshal(stdout.Bytes(), &report); err != nil {
+		t.Fatalf("decode doctor output: %v\nstdout: %s\nstderr: %s", err, stdout.String(), stderr.String())
+	}
+	for _, check := range report.Checks {
+		if check.Name != "credential_source" {
+			continue
+		}
+		if check.Status != "fail" ||
+			check.Message != "system external credential configuration requires the lark-cli Extended edition" ||
+			!strings.Contains(check.Hint, "install lark-cli Extended") {
+			t.Fatalf("credential_source check = %#v", check)
+		}
+		if strings.Contains(stdout.String(), "config init") {
+			t.Fatalf("doctor suggested local credential bootstrap for an edition sentinel: %s", stdout.String())
+		}
+		return
+	}
+	t.Fatalf("doctor did not report the edition sentinel: %s", stdout.String())
+}
--- a/cmd/edition_commands_extended.go
+++ b/cmd/edition_commands_extended.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package cmd
+
+import (
+	cmdversion "github.com/larksuite/cli/cmd/version"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+// registerEditionCommands owns the Extended-only command surface.
+func registerEditionCommands(root *cobra.Command, f *cmdutil.Factory) {
+	root.AddCommand(cmdversion.NewCmdVersion(f))
+}
--- a/cmd/edition_commands_extended_test.go
+++ b/cmd/edition_commands_extended_test.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package cmd
+
+import (
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+func TestExtendedRegistersVersionCommand(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	root := &cobra.Command{Use: "lark-cli"}
+
+	registerEditionCommands(root, f)
+
+	commands := root.Commands()
+	if len(commands) != 1 || commands[0].Name() != "version" {
+		t.Fatalf("Extended edition commands = %v, want [version]", commands)
+	}
+	if commands[0].Hidden {
+		t.Fatal("Extended version command must be visible")
+	}
+}
--- a/cmd/edition_commands_standard.go
+++ b/cmd/edition_commands_standard.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package cmd
+
+import (
+	cmdversion "github.com/larksuite/cli/cmd/version"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+// registerEditionCommands keeps the release identity probe callable in
+// Standard while cmd/version hides it from help. This preserves the ordinary
+// command surface and gives installers/CI one edition-neutral verification
+// contract.
+func registerEditionCommands(root *cobra.Command, f *cmdutil.Factory) {
+	root.AddCommand(cmdversion.NewCmdVersion(f))
+}
--- a/cmd/edition_commands_standard_test.go
+++ b/cmd/edition_commands_standard_test.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package cmd
+
+import (
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+func TestStandardRegistersHiddenVersionCommand(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	root := &cobra.Command{Use: "lark-cli"}
+
+	registerEditionCommands(root, f)
+
+	commands := root.Commands()
+	if len(commands) != 1 || commands[0].Name() != "version" {
+		t.Fatalf("Standard edition commands = %v, want [version]", commands)
+	}
+	if !commands[0].Hidden {
+		t.Fatal("Standard version command must remain hidden")
+	}
+}
--- a/cmd/event/event.go
+++ b/cmd/event/event.go
@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/cobra"

 	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/runtimeplan"
 )

 func NewCmdEvents(f *cmdutil.Factory) *cobra.Command {
@@ -16,14 +17,31 @@ func NewCmdEvents(f *cmdutil.Factory) *cobra.Command {
 		Long:  `Unified event consumption system. Use 'event consume <EventKey>' to start consuming events.`,
 		// Without SilenceUsage, RunE errors print the full flag help banner.
 		SilenceUsage: true,
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			cmd.SilenceUsage = true
+			// This hook shadows root's PersistentPreRun, so preserve the matched
+			// command for structured error and declared-scope hints.
+			f.CurrentCommand = cmd
+			return f.RequireCommandRuntimeCapabilities(cmd.Context(), cmd)
+		},
 	}
+	cmdutil.SetRuntimeCapabilities(cmd, runtimeplan.CapabilityRealtimeEvents)

-	cmd.AddCommand(NewCmdConsume(f))
-	cmd.AddCommand(NewCmdList(f))
-	cmd.AddCommand(NewCmdSchema(f))
-	cmd.AddCommand(NewCmdStatus(f))
-	cmd.AddCommand(NewCmdStop(f))
-	cmd.AddCommand(NewCmdBus(f))
+	consume := NewCmdConsume(f)
+	bus := NewCmdBus(f)
+	list := NewCmdList(f)
+	schema := NewCmdSchema(f)
+	status := NewCmdStatus(f)
+	stop := NewCmdStop(f)
+	for _, local := range []*cobra.Command{list, schema, status, stop} {
+		cmdutil.SetRuntimeCapabilities(local)
+	}
+	cmd.AddCommand(consume)
+	cmd.AddCommand(list)
+	cmd.AddCommand(schema)
+	cmd.AddCommand(status)
+	cmd.AddCommand(stop)
+	cmd.AddCommand(bus)

 	return cmd
 }
--- a/cmd/event/external_credential_guard_test.go
+++ b/cmd/event/external_credential_guard_test.go
@@ -0,0 +1,146 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package event
+
+import (
+	"errors"
+	"io/fs"
+	"path/filepath"
+	"testing"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/runtimeplan"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+func TestEventCommandsRejectDeniedRuntimeCapability(t *testing.T) {
+	cfg := &core.CliConfig{
+		AppID:     "cli_runtime_event_test",
+		AppSecret: "must-not-be-used",
+		Brand:     core.BrandFeishu,
+	}
+	denied := errs.NewValidationError(errs.SubtypeFailedPrecondition,
+		"real-time events are unavailable in this runtime").
+		WithHint("use a runtime that supports real-time events")
+	plan := runtimeplan.New(runtimeplan.Options{
+		Capabilities: func(capability runtimeplan.Capability) error {
+			if capability == runtimeplan.CapabilityRealtimeEvents {
+				return denied
+			}
+			return nil
+		},
+	})
+
+	t.Run("consume", func(t *testing.T) {
+		f, _, _, _ := cmdutil.TestFactoryWithRuntimePlan(t, cfg, plan)
+		cmd := NewCmdEvents(f)
+		args := []string{"consume", "guarded-before-event-lookup"}
+		matched, _, err := cmd.Find(args)
+		if err != nil {
+			t.Fatalf("Find() error = %v", err)
+		}
+		cmd.SetArgs(args)
+		requireExternalEventGuard(t, cmd.Execute())
+		if f.CurrentCommand != matched {
+			t.Fatalf("CurrentCommand = %v, want matched command %v", f.CurrentCommand, matched)
+		}
+	})
+
+	t.Run("bus", func(t *testing.T) {
+		configDir := t.TempDir()
+		t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+		f, _, _, _ := cmdutil.TestFactoryWithRuntimePlan(t, cfg, plan)
+		cmd := NewCmdEvents(f)
+		args := []string{"_bus"}
+		matched, _, err := cmd.Find(args)
+		if err != nil {
+			t.Fatalf("Find() error = %v", err)
+		}
+		cmd.SetArgs(args)
+		requireExternalEventGuard(t, cmd.Execute())
+		if f.CurrentCommand != matched {
+			t.Fatalf("CurrentCommand = %v, want matched command %v", f.CurrentCommand, matched)
+		}
+		if _, err := vfs.Stat(filepath.Join(configDir, "events")); !errors.Is(err, fs.ErrNotExist) {
+			t.Fatalf("event bus created runtime files before guard: %v", err)
+		}
+	})
+}
+
+func TestEventCommandRuntimeCapabilityMatrix(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	cmd := NewCmdEvents(f)
+
+	parentCapabilities := cmdutil.GetRuntimeCapabilities(cmd)
+	if len(parentCapabilities) != 1 || parentCapabilities[0] != runtimeplan.CapabilityRealtimeEvents {
+		t.Fatalf("event capabilities = %v, want [%s]", parentCapabilities, runtimeplan.CapabilityRealtimeEvents)
+	}
+
+	wantRealtime := map[string]bool{
+		"_bus":    true,
+		"consume": true,
+		"list":    false,
+		"schema":  false,
+		"status":  false,
+		"stop":    false,
+	}
+	children := make(map[string]*cobra.Command, len(wantRealtime))
+	for _, child := range cmd.Commands() {
+		name := child.Name()
+		want, ok := wantRealtime[name]
+		if !ok {
+			t.Fatalf("event command %q is missing from the runtime capability matrix", name)
+		}
+		children[name] = child
+		got := cmdutil.GetRuntimeCapabilities(child)
+		if want {
+			if len(got) != 1 || got[0] != runtimeplan.CapabilityRealtimeEvents {
+				t.Errorf("event %s capabilities = %v, want [%s]", name, got, runtimeplan.CapabilityRealtimeEvents)
+			}
+			continue
+		}
+		if len(got) != 0 {
+			t.Errorf("event %s capabilities = %v, want source-neutral local command", name, got)
+		}
+	}
+	if len(children) != len(wantRealtime) {
+		t.Fatalf("event command matrix covered %d commands, want %d", len(children), len(wantRealtime))
+	}
+
+	// Clearing the parent declaration must also clear both consumers. This
+	// proves they inherit the fail-closed default instead of duplicating a
+	// leaf annotation that future event commands could forget.
+	cmdutil.SetRuntimeCapabilities(cmd)
+	for _, name := range []string{"consume", "_bus"} {
+		if got := cmdutil.GetRuntimeCapabilities(children[name]); len(got) != 0 {
+			t.Errorf("event %s capabilities after clearing parent = %v, want inherited empty declaration", name, got)
+		}
+	}
+}
+
+func requireExternalEventGuard(t *testing.T, err error) {
+	t.Helper()
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error = %T %v, want typed problem", err, err)
+	}
+	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeFailedPrecondition {
+		t.Fatalf("problem = %s/%s, want %s/%s",
+			problem.Category, problem.Subtype, errs.CategoryValidation, errs.SubtypeFailedPrecondition)
+	}
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("error = %T, want *errs.ValidationError", err)
+	}
+	if validationErr.Param != "" {
+		t.Fatalf("param = %q, want empty", validationErr.Param)
+	}
+	if problem.Hint == "" {
+		t.Fatal("hint is empty")
+	}
+}
--- a/cmd/profile/profile.go
+++ b/cmd/profile/profile.go
@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/cobra"

 	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/runtimeplan"
 )

 // NewCmdProfile creates the profile command with subcommands.
@@ -14,13 +15,26 @@ func NewCmdProfile(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "profile",
 		Short: "Manage configuration profiles",
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			// A child PersistentPreRunE shadows root's PersistentPreRun, so retain
+			// the invocation state used by structured error hints here.
+			cmd.SilenceUsage = true
+			f.CurrentCommand = cmd
+			return f.RequireCommandRuntimeCapabilities(cmd.Context(), cmd)
+		},
 	}
 	cmdutil.DisableAuthCheck(cmd)
+	cmdutil.SetRuntimeCapabilities(cmd, runtimeplan.CapabilityLocalProfileMutation)
 	cmdutil.SetTips(cmd, []string{
 		"AI agents: Do NOT switch or remove profiles unless the user explicitly asks.",
 	})

-	cmd.AddCommand(NewCmdProfileList(f))
+	list := NewCmdProfileList(f)
+	// Listing profiles is read-only and remains useful for diagnostics under a
+	// managed credential runtime. Every other profile subcommand mutates local
+	// profile selection, config, or keychain state and inherits the parent gate.
+	cmdutil.SetRuntimeCapabilities(list)
+	cmd.AddCommand(list)
 	cmd.AddCommand(NewCmdProfileUse(f))
 	cmd.AddCommand(NewCmdProfileAdd(f))
 	cmd.AddCommand(NewCmdProfileRemove(f))
--- a/cmd/profile/runtime_capabilities_test.go
+++ b/cmd/profile/runtime_capabilities_test.go
@@ -0,0 +1,222 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package profile
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/runtimeplan"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+type recordingProfileKeychain struct {
+	gets    int
+	sets    int
+	removes int
+}
+
+func (k *recordingProfileKeychain) Get(_, _ string) (string, error) {
+	k.gets++
+	return "", nil
+}
+
+func (k *recordingProfileKeychain) Set(_, _, _ string) error {
+	k.sets++
+	return nil
+}
+
+func (k *recordingProfileKeychain) Remove(_, _ string) error {
+	k.removes++
+	return nil
+}
+
+func TestProfileMutationCommandsAreDeniedBeforeLocalStateChanges(t *testing.T) {
+	denied := errs.NewValidationError(
+		errs.SubtypeFailedPrecondition,
+		"local credential management is unavailable in this runtime",
+	).WithHint("manage credentials through the active provider")
+	plan := runtimeplan.New(runtimeplan.Options{
+		Capabilities: func(capability runtimeplan.Capability) error {
+			if capability == runtimeplan.CapabilityLocalProfileMutation {
+				return denied
+			}
+			return nil
+		},
+	})
+
+	tests := []struct {
+		name string
+		args []string
+	}{
+		{
+			name: "add",
+			args: []string{"add", "--name", "new", "--app-id", "app-new", "--app-secret-stdin"},
+		},
+		{
+			name: "use",
+			args: []string{"use", "target"},
+		},
+		{
+			name: "rename",
+			args: []string{"rename", "target", "renamed"},
+		},
+		{
+			name: "remove",
+			args: []string{"remove", "target"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			configDir := setupProfileConfigDir(t)
+			saveManagedGateFixture(t)
+			configPath := filepath.Join(configDir, "config.json")
+			before, err := vfs.ReadFile(configPath)
+			if err != nil {
+				t.Fatalf("ReadFile(before) error = %v", err)
+			}
+
+			f, _, _, _ := cmdutil.TestFactoryWithRuntimePlan(t, nil, plan)
+			f.IOStreams.In = strings.NewReader("must-not-be-read\n")
+			keychain := &recordingProfileKeychain{}
+			f.Keychain = keychain
+
+			cmd := NewCmdProfile(f)
+			cmd.SetArgs(tt.args)
+			err = cmd.Execute()
+			if !errors.Is(err, denied) {
+				t.Fatalf("Execute() error = %v, want denied runtime error", err)
+			}
+
+			after, readErr := vfs.ReadFile(configPath)
+			if readErr != nil {
+				t.Fatalf("ReadFile(after) error = %v", readErr)
+			}
+			if !bytes.Equal(after, before) {
+				t.Fatalf("config changed despite runtime denial:\nbefore: %s\nafter:  %s", before, after)
+			}
+			if keychain.gets != 0 || keychain.sets != 0 || keychain.removes != 0 {
+				t.Fatalf("keychain calls = get:%d set:%d remove:%d, want none",
+					keychain.gets, keychain.sets, keychain.removes)
+			}
+		})
+	}
+}
+
+func TestProfileListRemainsAvailableWhenLocalMutationIsDenied(t *testing.T) {
+	setupProfileConfigDir(t)
+	saveManagedGateFixture(t)
+	plan := runtimeplan.New(runtimeplan.Options{
+		Capabilities: func(capability runtimeplan.Capability) error {
+			if capability == runtimeplan.CapabilityLocalProfileMutation {
+				return errs.NewValidationError(
+					errs.SubtypeFailedPrecondition,
+					"local credential management is unavailable in this runtime",
+				)
+			}
+			return nil
+		},
+	})
+	f, stdout, _, _ := cmdutil.TestFactoryWithRuntimePlan(t, nil, plan)
+
+	cmd := NewCmdProfile(f)
+	cmd.SetArgs([]string{"list"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("profile list was blocked by mutation capability: %v", err)
+	}
+	if !strings.Contains(stdout.String(), `"name": "default"`) {
+		t.Fatalf("profile list output = %s, want default profile", stdout.String())
+	}
+}
+
+func TestProfileMutationCommandsRemainAvailableByDefault(t *testing.T) {
+	setupProfileConfigDir(t)
+	saveManagedGateFixture(t)
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	// origin/main allows Profile preparation while an environment/extension
+	// provider is active. The managed runtime blocks this through its explicit
+	// plan policy; generic provider ownership must not change Standard.
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{profileEnvironmentProvider{}},
+		nil,
+		nil,
+		nil,
+	)
+
+	cmd := NewCmdProfile(f)
+	args := []string{"use", "target"}
+	matched, _, err := cmd.Find(args)
+	if err != nil {
+		t.Fatalf("Find() error = %v", err)
+	}
+	cmd.SetArgs(args)
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("profile use with default runtime plan error = %v", err)
+	}
+	if f.CurrentCommand != matched {
+		t.Fatalf("CurrentCommand = %v, want matched command %v", f.CurrentCommand, matched)
+	}
+
+	saved, err := core.LoadMultiAppConfig()
+	if err != nil {
+		t.Fatalf("LoadMultiAppConfig() error = %v", err)
+	}
+	if saved.CurrentApp != "target" || saved.PreviousApp != "default" {
+		t.Fatalf("selection = current:%q previous:%q, want target/default",
+			saved.CurrentApp, saved.PreviousApp)
+	}
+}
+
+type profileEnvironmentProvider struct{}
+
+func (profileEnvironmentProvider) Name() string { return "env" }
+
+func (profileEnvironmentProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
+	return &extcred.Account{
+		AppID:               "cli_environment",
+		Brand:               extcred.BrandFeishu,
+		SupportedIdentities: extcred.SupportsAll,
+	}, nil
+}
+
+func (profileEnvironmentProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
+	return &extcred.Token{Value: "environment-token"}, nil
+}
+
+func saveManagedGateFixture(t *testing.T) {
+	t.Helper()
+	multi := &core.MultiAppConfig{
+		CurrentApp: "default",
+		Apps: []core.AppConfig{
+			{
+				Name:      "default",
+				AppId:     "app-default",
+				AppSecret: core.PlainSecret("secret-default"),
+				Brand:     core.BrandFeishu,
+			},
+			{
+				Name:  "target",
+				AppId: "app-target",
+				AppSecret: core.SecretInput{Ref: &core.SecretRef{
+					Source: "keychain",
+					ID:     "appsecret:app-target",
+				}},
+				Brand: core.BrandLark,
+			},
+		},
+	}
+	if err := core.SaveMultiAppConfig(multi); err != nil {
+		t.Fatalf("SaveMultiAppConfig() error = %v", err)
+	}
+}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -21,6 +21,7 @@ import (
 	"github.com/larksuite/cli/internal/deprecation"
 	"github.com/larksuite/cli/internal/hook"
 	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/runtimebootstrap"
 	"github.com/larksuite/cli/internal/skillscheck"
 	"github.com/larksuite/cli/internal/suggest"
 	"github.com/larksuite/cli/internal/update"
@@ -100,6 +101,12 @@ func Execute() int {
 		fmt.Fprintln(os.Stderr, "Error:", err)
 		return 1
 	}
+	// Resolve all startup state from the detected workspace. This must happen
+	// before ResolveStartupBrand, isSingleAppMode, or buildInternal reads
+	// workspace-scoped configuration.
+	selectInvocationWorkspace()
+	startup := runtimebootstrap.Resolve(inv.Profile)
+	startupBrand := resolveStartupBrandFromConfig(inv.Profile, startup.ProfileConfig)
 	configureFlagCompletions(os.Args)

 	ctx := context.Background()
@@ -107,7 +114,8 @@ func Execute() int {
 		ctx, inv,
 		WithIO(os.Stdin, os.Stdout, os.Stderr),
 		HideProfile(isSingleAppMode()),
-		WithStartupBrand(ResolveStartupBrand(inv.Profile)),
+		WithStartupBrand(startupBrand),
+		withRuntimeBootstrap(startup),
 	)

 	// --- Notices (non-blocking) ---
@@ -137,7 +145,7 @@ func Execute() int {
 // or both may be present in any given envelope.
 func setupNotices() {
 	// Binary update — synchronous cache check + async refresh
-	if info := update.CheckCached(build.Version); info != nil {
+	if info := checkCachedEditionUpdate(build.Version); info != nil {
 		update.SetPending(info)
 	}
 	ver := build.Version
@@ -147,9 +155,9 @@ func setupNotices() {
 				fmt.Fprintf(os.Stderr, "update check panic: %v\n", r)
 			}
 		}()
-		update.RefreshCache(ver)
+		refreshEditionUpdateCache(ver)
 		if update.GetPending() == nil {
-			if info := update.CheckCached(ver); info != nil {
+			if info := checkCachedEditionUpdate(ver); info != nil {
 				update.SetPending(info)
 			}
 		}
--- a/cmd/root_test.go
+++ b/cmd/root_test.go
@@ -18,6 +18,7 @@ import (
 	cmdconfig "github.com/larksuite/cli/cmd/config"
 	"github.com/larksuite/cli/cmd/schema"
 	"github.com/larksuite/cli/errs"
+	extcred "github.com/larksuite/cli/extension/credential"
 	internalauth "github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
@@ -435,6 +436,25 @@ func TestHandleRootError_LeakedUntypedErrorBecomesInternal(t *testing.T) {
 	}
 }

+func TestHandleRootError_BlockErrorPreservesUntypedFallback(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	errOut := &bytes.Buffer{}
+	f.IOStreams.ErrOut = errOut
+	blockErr := &extcred.BlockError{Provider: "env", Reason: "LARKSUITE_CLI_APP_ID is missing"}
+
+	exit := handleRootError(f, blockErr)
+	errObj := decodeErrorEnvelope(t, errOut.Bytes())
+	if errObj["type"] != "internal" || errObj["subtype"] != "unknown" {
+		t.Fatalf("error = %#v", errObj)
+	}
+	if errObj["message"] != "blocked by env: LARKSUITE_CLI_APP_ID is missing" {
+		t.Fatalf("error.message = %v", errObj["message"])
+	}
+	if exit != int(output.ExitInternal) {
+		t.Fatalf("exit = %d, want %d", exit, output.ExitInternal)
+	}
+}
+
 // TestHandleRootError_PartialWritePreservesExitCode pins that when the
 // stderr write fails mid-envelope, handleRootError still returns the typed
 // exit code (ExitAuth=3 for AuthenticationError), not fall through to the
--- a/cmd/root_upgrade.go
+++ b/cmd/root_upgrade.go
@@ -11,7 +11,6 @@ import (

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

@@ -58,24 +57,14 @@ func offerRootUpgrade(f *cmdutil.Factory, cmd *cobra.Command) {
 	if !ios.IsTerminal || !ios.OutIsTerminal || !ios.StderrIsTerminal {
 		return
 	}
-	// Gate 4: cached newer version. CheckCached applies opt-out (shouldSkip)
-	// and the IsNewer/semver validation chain; it reads the on-disk cache that
-	// the 24h-throttled RefreshCache maintains (CheckCached itself has no TTL).
-	info := update.CheckCached(build.Version)
+	// Gate 4: cached newer version from this binary's release channel.
+	// Standard reads the npm-backed cache; Extended reads its separate
+	// GitHub-release cache.
+	info := checkCachedEditionUpdate(build.Version)
 	if info == nil {
 		return
 	}
-	// Deliberately no target version here: info.Latest comes from the on-disk
-	// cache, which has no expiry (the 24h TTL only throttles refreshes, and a
-	// failed refresh leaves the old value in place), so it can name a version
-	// that is no longer the one npm would install. The version actually
-	// installed is resolved live by the update subcommand, which prints
-	// "Updating lark-cli <cur> -> <latest> via <pm> ..." before installing —
-	// that is where the user sees the real target. Keep going through the
-	// update subcommand rather than calling RunNpmInstall directly, otherwise
-	// that line disappears and the user approves a global install without ever
-	// being told what gets installed.
-	fmt.Fprintf(ios.ErrOut, "A newer lark-cli is available (current %s). Upgrade now? [y/N]: ", info.Current)
+	fmt.Fprintf(ios.ErrOut, "lark-cli %s available (current %s). Upgrade now? [y/N]: ", info.Latest, info.Current)
 	if !readYes(ios.In) {
 		return
 	}
--- a/cmd/root_upgrade_test.go
+++ b/cmd/root_upgrade_test.go
@@ -6,7 +6,6 @@ package cmd
 import (
 	"bytes"
 	"fmt"
-	"os"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -15,13 +14,21 @@ import (
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/vfs"
 	"github.com/spf13/cobra"
 )

-func writeUpdateState(t *testing.T, dir, latest string) {
+func updateStateFileForEdition(edition string) string {
+	if edition == "extended" {
+		return "update-state-extended.json"
+	}
+	return "update-state.json"
+}
+
+func writeUpdateState(t *testing.T, dir, edition, latest string) {
 	t.Helper()
 	data := fmt.Sprintf(`{"latest_version":%q,"checked_at":%d}`, latest, time.Now().Unix())
-	if err := os.WriteFile(filepath.Join(dir, "update-state.json"), []byte(data), 0o644); err != nil {
+	if err := vfs.WriteFile(filepath.Join(dir, updateStateFileForEdition(edition)), []byte(data), 0o600); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -105,7 +112,7 @@ func TestOfferRootUpgrade(t *testing.T) {
 			t.Setenv("RUN_ID", "")
 			t.Setenv("LARKSUITE_CLI_NO_UPDATE_NOTIFIER", "")
 			if tc.latest != "" {
-				writeUpdateState(t, dir, tc.latest)
+				writeUpdateState(t, dir, build.Edition, tc.latest)
 			}
 			if tc.optOut {
 				t.Setenv("LARKSUITE_CLI_NO_UPDATE_NOTIFIER", "1")
@@ -128,17 +135,6 @@ func TestOfferRootUpgrade(t *testing.T) {
 			if gotPrompt != tc.wantPrompt {
 				t.Errorf("prompt: got %v want %v (stderr=%q)", gotPrompt, tc.wantPrompt, errBuf.String())
 			}
-			// The prompt must not name a target version: info.Latest comes from
-			// the on-disk cache and can be stale, while the version actually
-			// installed is resolved live by the update subcommand.
-			if tc.wantPrompt {
-				if strings.Contains(errBuf.String(), tc.latest) {
-					t.Errorf("prompt must not name the cached target version %q (stderr=%q)", tc.latest, errBuf.String())
-				}
-				if !strings.Contains(errBuf.String(), build.Version) {
-					t.Errorf("prompt must name the current version %q (stderr=%q)", build.Version, errBuf.String())
-				}
-			}
 			if called != tc.wantRun {
 				t.Errorf("runRootUpgrade called: got %v want %v", called, tc.wantRun)
 			}
@@ -146,6 +142,53 @@ func TestOfferRootUpgrade(t *testing.T) {
 	}
 }

+func TestOfferRootUpgradeIgnoresOtherEditionCache(t *testing.T) {
+	origV := build.Version
+	build.Version = "1.0.0"
+	t.Cleanup(func() { build.Version = origV })
+
+	origRun := runRootUpgrade
+	t.Cleanup(func() { runRootUpgrade = origRun })
+
+	origWS := core.CurrentWorkspace()
+	t.Cleanup(func() { core.SetCurrentWorkspace(origWS) })
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+
+	dir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", dir)
+	t.Setenv("CI", "")
+	t.Setenv("BUILD_NUMBER", "")
+	t.Setenv("RUN_ID", "")
+	t.Setenv("LARKSUITE_CLI_NO_UPDATE_NOTIFIER", "")
+
+	otherEdition := "extended"
+	if build.Edition == "extended" {
+		otherEdition = "standard"
+	}
+	writeUpdateState(t, dir, otherEdition, "9.0.0")
+
+	called := false
+	runRootUpgrade = func(*cobra.Command) { called = true }
+	var errBuf bytes.Buffer
+	f := &cmdutil.Factory{IOStreams: &cmdutil.IOStreams{
+		In:               strings.NewReader("y\n"),
+		Out:              &bytes.Buffer{},
+		ErrOut:           &errBuf,
+		IsTerminal:       true,
+		OutIsTerminal:    true,
+		StderrIsTerminal: true,
+	}}
+
+	offerRootUpgrade(f, &cobra.Command{})
+
+	if strings.Contains(errBuf.String(), "available") {
+		t.Fatalf("%s prompt consumed %s cache: %q", build.Edition, otherEdition, errBuf.String())
+	}
+	if called {
+		t.Fatalf("%s upgrade ran from %s cache", build.Edition, otherEdition)
+	}
+}
+
 func TestInstallRootUpgradePromptPreservesInner(t *testing.T) {
 	orig := rawInvocationArgs
 	t.Cleanup(func() { rawInvocationArgs = orig })
--- a/cmd/startup_brand.go
+++ b/cmd/startup_brand.go
@@ -10,17 +10,34 @@ import (
 	"github.com/larksuite/cli/internal/envvars"
 )

+// selectInvocationWorkspace establishes the workspace before any startup
+// consumer reads workspace-scoped configuration. Execute needs this before
+// resolving the registry brand, while Build/buildInternal needs it before
+// capturing the immutable Profile snapshot passed to the Factory.
+func selectInvocationWorkspace() core.Workspace {
+	workspace := core.DetectWorkspaceFromEnv(os.Getenv)
+	core.SetCurrentWorkspace(workspace)
+	return workspace
+}
+
 // ResolveStartupBrand resolves the brand before the command tree is built, so
 // the registry's remote metadata overlay uses the configured brand from the
 // first catalog access. It mirrors the credential chain's brand precedence —
 // environment, then the active profile's raw config entry — without touching
 // the keychain (no secrets are needed to know the brand).
 func ResolveStartupBrand(profile string) core.LarkBrand {
+	config, _ := core.LoadMultiAppConfig()
+	return resolveStartupBrandFromConfig(profile, config)
+}
+
+// resolveStartupBrandFromConfig keeps registry routing on the same immutable
+// Profile snapshot used by credentials and runtime policy.
+func resolveStartupBrandFromConfig(profile string, config *core.MultiAppConfig) core.LarkBrand {
 	if raw := os.Getenv(envvars.CliBrand); raw != "" {
 		return core.ParseBrand(raw)
 	}
-	if cfg, err := core.LoadMultiAppConfig(); err == nil {
-		if app := cfg.CurrentAppConfig(profile); app != nil {
+	if config != nil {
+		if app := config.CurrentAppConfig(profile); app != nil {
 			return core.ParseBrand(string(app.Brand))
 		}
 	}
--- a/cmd/update/edition_extended.go
+++ b/cmd/update/edition_extended.go
@@ -0,0 +1,100 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package cmdupdate
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/build"
+	"github.com/larksuite/cli/internal/extendedupdate"
+	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/skillscheck"
+	"github.com/larksuite/cli/internal/update"
+)
+
+var (
+	fetchExtendedLatest = extendedupdate.FetchLatest
+	installExtended     = extendedupdate.Install
+)
+
+func updateLongDescription() string {
+	return `Update lark-cli Extended from the matching GitHub Release.
+
+The command downloads the lark-cli-extended asset for the current platform,
+verifies its SHA-256 checksum and compiled edition identity, then replaces the
+current binary. It never installs the Standard npm/npx edition.
+
+Use --json for structured output (for AI agents and scripts).
+Use --check to only check for updates without installing.`
+}
+
+func runEditionUpdate(opts *UpdateOptions) (bool, error) {
+	io := opts.Factory.IOStreams
+	cur := currentVersion()
+	updater := newUpdater()
+	if !opts.Check {
+		updater.Brand = resolveSkillsBrand(opts.Factory, io.ErrOut)
+		updater.CleanupStaleFiles()
+	}
+	output.PendingNotice = nil
+
+	latest, err := fetchExtendedLatest()
+	if err != nil {
+		var typed errs.TypedError
+		if errors.As(err, &typed) {
+			return true, reportError(opts, io, "network", typed)
+		}
+		return true, reportError(opts, io, "network",
+			errs.NewNetworkError(errs.SubtypeNetworkTransport,
+				"failed to check the latest Extended version: %v", err).WithCause(err))
+	}
+	if update.ParseVersion(latest) == nil {
+		return true, reportError(opts, io, "update_error",
+			errs.NewInternalError(errs.SubtypeInvalidResponse,
+				"invalid Extended version from GitHub Releases: %s", latest))
+	}
+	if !opts.Force && !update.IsNewer(latest, cur) {
+		var skillsResult *skillscheck.SyncResult
+		if !opts.Check {
+			skillsResult = runSkillsAndState(updater, io, cur, opts.Force)
+		}
+		return true, reportAlreadyUpToDate(opts, io, cur, latest, skillsResult, opts.Check)
+	}
+	if opts.Check {
+		return true, reportCheckResult(opts, io, cur, latest, true)
+	}
+	if !opts.JSON {
+		fmt.Fprintf(io.ErrOut, "Updating lark-cli Extended %s %s %s from GitHub Releases ...\n", cur, symArrow(), latest)
+	}
+	if err := installExtended(latest); err != nil {
+		var typed errs.TypedError
+		if errors.As(err, &typed) {
+			return true, reportError(opts, io, "update_error", typed)
+		}
+		return true, reportError(opts, io, "update_error",
+			errs.NewInternalError(errs.SubtypeUnknown,
+				"failed to install lark-cli Extended: %v", err).WithCause(err))
+	}
+
+	skillsResult := runSkillsAndState(updater, io, latest, opts.Force)
+	if opts.JSON {
+		result := map[string]interface{}{
+			"ok": true, "previous_version": cur, "current_version": latest,
+			"latest_version": latest, "edition": build.Edition, "action": "updated",
+			"message": fmt.Sprintf("lark-cli Extended updated from %s to %s", cur, latest),
+			"url":     releaseURL(latest), "changelog": changelogURL(),
+		}
+		applySkillsResult(result, skillsResult)
+		output.PrintJson(io.Out, result)
+		return true, nil
+	}
+	fmt.Fprintf(io.ErrOut, "\n%s Successfully updated lark-cli Extended from %s to %s\n", symOK(), cur, latest)
+	fmt.Fprintf(io.ErrOut, "  Changelog: %s\n", changelogURL())
+	emitSkillsTextHints(io, skillsResult)
+	return true, nil
+}
--- a/cmd/update/edition_extended_test.go
+++ b/cmd/update/edition_extended_test.go
@@ -0,0 +1,80 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package cmdupdate
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"testing"
+
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/selfupdate"
+	"github.com/larksuite/cli/internal/skillscheck"
+)
+
+func TestExtendedUpdateUsesExtendedReleaseInstaller(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	oldFetch, oldInstall := fetchExtendedLatest, installExtended
+	oldVersion, oldUpdater, oldSync := currentVersion, newUpdater, syncSkills
+	t.Cleanup(func() {
+		fetchExtendedLatest, installExtended = oldFetch, oldInstall
+		currentVersion, newUpdater, syncSkills = oldVersion, oldUpdater, oldSync
+	})
+	fetchExtendedLatest = func() (string, error) { return "1.2.4", nil }
+	currentVersion = func() string { return "1.2.3" }
+	installed := ""
+	installExtended = func(version string) error {
+		installed = version
+		return nil
+	}
+	newUpdater = func() *selfupdate.Updater {
+		return &selfupdate.Updater{DetectOverride: func() selfupdate.DetectResult {
+			return selfupdate.DetectResult{Method: selfupdate.InstallManual}
+		}}
+	}
+	syncSkills = func(skillscheck.SyncOptions) *skillscheck.SyncResult { return &skillscheck.SyncResult{} }
+
+	var out, errOut bytes.Buffer
+	f := cmdutil.NewDefault(cmdutil.NewIOStreams(nil, &out, &errOut), cmdutil.InvocationContext{})
+	cmd := NewCmdUpdate(f)
+	cmd.SetArgs([]string{"--json"})
+	if err := cmd.ExecuteContext(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	if installed != "1.2.4" {
+		t.Fatalf("installed version = %q, want 1.2.4", installed)
+	}
+	var result map[string]interface{}
+	if err := json.Unmarshal(out.Bytes(), &result); err != nil {
+		t.Fatal(err)
+	}
+	if result["edition"] != "extended" || result["action"] != "updated" {
+		t.Fatalf("result = %#v", result)
+	}
+}
+
+func TestExtendedUpdateCheckDoesNotInstall(t *testing.T) {
+	oldFetch, oldInstall := fetchExtendedLatest, installExtended
+	oldVersion := currentVersion
+	t.Cleanup(func() {
+		fetchExtendedLatest, installExtended = oldFetch, oldInstall
+		currentVersion = oldVersion
+	})
+	fetchExtendedLatest = func() (string, error) { return "1.2.4", nil }
+	currentVersion = func() string { return "1.2.3" }
+	installExtended = func(string) error {
+		t.Fatal("installer called during --check")
+		return nil
+	}
+	var out bytes.Buffer
+	f := cmdutil.NewDefault(cmdutil.NewIOStreams(nil, &out, &bytes.Buffer{}), cmdutil.InvocationContext{})
+	cmd := NewCmdUpdate(f)
+	cmd.SetArgs([]string{"--json", "--check"})
+	if err := cmd.ExecuteContext(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+}
--- a/cmd/update/edition_standard.go
+++ b/cmd/update/edition_standard.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package cmdupdate
+
+func runEditionUpdate(*UpdateOptions) (bool, error) { return false, nil }
+
+func updateLongDescription() string {
+	return `Update lark-cli to the latest version.
+
+Detects the installation method automatically:
+  - npm install:  runs npm install -g @larksuite/cli@<version>
+  - pnpm install: runs pnpm add -g @larksuite/cli@<version>
+  - manual/other: shows GitHub Releases download URL
+
+Use --json for structured output (for AI agents and scripts).
+Use --check to only check for updates without installing.`
+}
--- a/cmd/update/update.go
+++ b/cmd/update/update.go
@@ -101,15 +101,7 @@ func NewCmdUpdate(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "update",
 		Short: "Update lark-cli to the latest version",
-		Long: `Update lark-cli to the latest version.
-
-Detects the installation method automatically:
-  - npm install:  runs npm install -g @larksuite/cli@<version>
-  - pnpm install: runs pnpm add -g @larksuite/cli@<version>
-  - manual/other: shows GitHub Releases download URL
-
-Use --json for structured output (for AI agents and scripts).
-Use --check to only check for updates without installing.`,
+		Long:  updateLongDescription(),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return updateRun(opts)
 		},
@@ -124,6 +116,9 @@ Use --check to only check for updates without installing.`,
 }

 func updateRun(opts *UpdateOptions) error {
+	if handled, err := runEditionUpdate(opts); handled {
+		return err
+	}
 	io := opts.Factory.IOStreams
 	cur := currentVersion()
 	updater := newUpdater()
--- a/cmd/update/update_test.go
+++ b/cmd/update/update_test.go
@@ -1,6 +1,8 @@
 // Copyright (c) 2026 Lark Technologies Pte. Ltd.
 // SPDX-License-Identifier: MIT

+//go:build !extended
+
 package cmdupdate

 import (
--- a/cmd/update_notice_extended.go
+++ b/cmd/update_notice_extended.go
@@ -0,0 +1,19 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package cmd
+
+import (
+	"github.com/larksuite/cli/internal/extendedupdate"
+	"github.com/larksuite/cli/internal/update"
+)
+
+func checkCachedEditionUpdate(currentVersion string) *update.UpdateInfo {
+	return extendedupdate.CheckCached(currentVersion)
+}
+
+func refreshEditionUpdateCache(currentVersion string) {
+	extendedupdate.RefreshCache(currentVersion)
+}
--- a/cmd/update_notice_standard.go
+++ b/cmd/update_notice_standard.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package cmd
+
+import "github.com/larksuite/cli/internal/update"
+
+func checkCachedEditionUpdate(currentVersion string) *update.UpdateInfo {
+	return update.CheckCached(currentVersion)
+}
+
+func refreshEditionUpdateCache(currentVersion string) {
+	update.RefreshCache(currentVersion)
+}
--- a/cmd/version/version.go
+++ b/cmd/version/version.go
@@ -0,0 +1,56 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package version
+
+import (
+	"fmt"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/build"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
+	"github.com/spf13/cobra"
+)
+
+type options struct {
+	factory *cmdutil.Factory
+	json    bool
+}
+
+type versionReport struct {
+	Version      string   `json:"version"`
+	Edition      string   `json:"edition"`
+	Capabilities []string `json:"capabilities"`
+}
+
+// NewCmdVersion reports the immutable edition identity compiled into the
+// binary. Root --version remains unchanged for compatibility.
+func NewCmdVersion(f *cmdutil.Factory) *cobra.Command {
+	opts := &options{factory: f}
+	cmd := &cobra.Command{
+		Use:    "version",
+		Short:  "Show version and edition information",
+		Hidden: hideVersionCommand(),
+		Args:   cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if opts.json {
+				output.PrintJson(opts.factory.IOStreams.Out, versionReport{
+					Version:      build.Version,
+					Edition:      build.Edition,
+					Capabilities: build.Capabilities(),
+				})
+				return nil
+			}
+			_, err := fmt.Fprintf(opts.factory.IOStreams.Out, "lark-cli version %s (%s)\n", build.Version, build.Edition)
+			if err != nil {
+				return errs.NewInternalError(errs.SubtypeSDKError, "failed to write version output: %v", err).WithCause(err)
+			}
+			return nil
+		},
+	}
+	cmd.Flags().BoolVar(&opts.json, "json", false, "structured JSON output")
+	cmdutil.DisableAuthCheck(cmd)
+	cmdutil.SetRisk(cmd, "read")
+	return cmd
+}
--- a/cmd/version/version_test.go
+++ b/cmd/version/version_test.go
@@ -0,0 +1,67 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package version
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/build"
+	"github.com/larksuite/cli/internal/cmdutil"
+)
+
+func TestVersionJSONReportsCompiledEdition(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	f, out, _, _ := cmdutil.TestFactory(t, nil)
+	cmd := NewCmdVersion(f)
+	cmd.SetArgs([]string{"--json"})
+	if err := cmd.ExecuteContext(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	var got struct {
+		Version      string   `json:"version"`
+		Edition      string   `json:"edition"`
+		Capabilities []string `json:"capabilities"`
+	}
+	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	if got.Version != build.Version || got.Edition != build.Edition || !reflect.DeepEqual(got.Capabilities, build.Capabilities()) {
+		t.Fatalf("version output = %#v, want version=%q edition=%q", got, build.Version, build.Edition)
+	}
+}
+
+func TestVersionVisibilityPreservesStandardHelpSurface(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	cmd := NewCmdVersion(f)
+	wantHidden := build.Edition == "standard"
+	if cmd.Hidden != wantHidden {
+		t.Fatalf("version command hidden = %v, want %v for %s", cmd.Hidden, wantHidden, build.Edition)
+	}
+}
+
+type failingWriter struct{ err error }
+
+func (w failingWriter) Write([]byte) (int, error) { return 0, w.err }
+
+func TestVersionTextWriteFailureIsTyped(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	writeErr := errors.New("write failed")
+	f.IOStreams.Out = failingWriter{err: writeErr}
+
+	cmd := NewCmdVersion(f)
+	err := cmd.ExecuteContext(context.Background())
+	problem, ok := errs.ProblemOf(err)
+	if !ok || problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeSDKError {
+		t.Fatalf("error = %#v, want internal/sdk_error", err)
+	}
+	if !errors.Is(err, writeErr) {
+		t.Fatalf("error does not preserve write failure: %v", err)
+	}
+}
--- a/cmd/version/visibility_extended.go
+++ b/cmd/version/visibility_extended.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package version
+
+func hideVersionCommand() bool { return false }
--- a/cmd/version/visibility_standard.go
+++ b/cmd/version/visibility_standard.go
@@ -0,0 +1,10 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package version
+
+// Standard keeps its historical help surface unchanged. The command remains
+// directly callable for release identity verification.
+func hideVersionCommand() bool { return true }
--- a/errs/ERROR_CONTRACT.md
+++ b/errs/ERROR_CONTRACT.md
@@ -62,6 +62,8 @@ Typed errors render to **stderr** as one JSON object per process exit:
 | `error.message` | informational | not safe to branch on |
 | `error.hint` | informational | actionable recovery guidance |
 | `error.log_id` | informational | upstream request id (server-side trace) |
+| `error.origin` | informational | Extended producer: `cli`, `credential_process`, `proxy`, or `lark`; omitted by Standard to preserve its existing envelope; consumers must tolerate absence and unknown future values |
+| `error.proxy_request_id` | informational | external credential platform trace id; never stored in `log_id` |
 | `error.retryable` | wire-stable | `true` when present; omitted when `false` |
 | `error.param` | per-Subtype-stable | single offending parameter (`ValidationError`); see **Validation parameters** |
 | `error.params` | per-Subtype-stable | per-parameter validation detail array (`ValidationError`); see **Validation parameters** |
@@ -104,7 +106,7 @@ already succeeded).
 | `config` | local config missing / unbound | 3 | `ConfigError` |
 | `network` | DNS, refused, timeout, transport | 4 | `NetworkError` |
 | `api` | server-side Lark error w/o specific bucket | 1 | `APIError` |
-| `policy` | content safety / security challenge | 6 | `SecurityPolicyError`, `ContentSafetyError` |
+| `policy` | security policy denial/challenge, including content safety | 6 | `SecurityPolicyError`, `ContentSafetyError` |
 | `internal` | SDK contract violation / decode failure | 5 | `InternalError` |
 | `confirmation` | high-risk action needs `--yes` | 10 | `ConfirmationRequiredError` |

@@ -272,7 +274,7 @@ legal for framework dynamic paths (e.g. classifier fanout) but the lint
 | Login required | `errs.NewAuthenticationError(errs.SubtypeTokenMissing, msg)` |
 | Token lacks scope | `errclass.BuildAPIError(resp, ctx)` |
 | Local config missing | `errs.NewConfigError(errs.SubtypeNotConfigured, msg)` |
-| Transport failure | `errs.NewNetworkError(errs.SubtypeNetworkTimeout, msg).WithCause(err)` (subtype: `timeout` / `tls` / `dns` / `server_error` / `transport`) |
+| Transport or external dependency failure | `errs.NewNetworkError(subtype, msg).WithCause(err)` (subtype: `timeout` / `tls` / `dns` / `server_error` / `transport` / `credential_source_unavailable` / `upstream_unavailable`) |
 | Lark API error | `errclass.BuildAPIError(resp, ctx)` |
 | SDK / decode bug | `errs.NewInternalError(errs.SubtypeSDKError, msg).WithCause(err)` |
 | Policy block | `errs.NewSecurityPolicyError(subtype, msg).WithChallengeURL(url)` or `errs.NewContentSafetyError(subtype, msg).WithRules(...)` |
@@ -513,7 +515,11 @@ Rare; the existing structs cover the 9 Categories with room. If you must:
 `CheckProblemEmbed` enforces the `Problem` embed at lint time. New
 top-level wire fields are forbidden — per-Subtype data goes into the
 typed struct as a documented extension field, not into the envelope's
-top level.
+top level. The external credential platform contract is the single explicit
+exception: `origin` and `proxy_request_id` are shared across several error
+categories and therefore live in `Problem`. Both fields are optional, and
+consumers must ignore them when absent or unknown. Any further shared field
+still requires an explicit contract revision and wire-format pin.

 ## CI guards

--- a/errs/diagnostic_metadata.go
+++ b/errs/diagnostic_metadata.go
@@ -0,0 +1,134 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package errs
+
+import (
+	"encoding/json"
+)
+
+// DiagnosticMetadata carries optional producer diagnostics without changing
+// the field layout of Problem or any concrete typed error. Keeping this
+// metadata in a wrapper preserves source compatibility for callers that use
+// positional literals of the existing exported error structs.
+type DiagnosticMetadata struct {
+	Origin         string
+	ProxyRequestID string
+}
+
+type diagnosticMetadataWrapper struct {
+	err      error
+	typed    error
+	metadata DiagnosticMetadata
+}
+
+func (e *diagnosticMetadataWrapper) Error() string {
+	if e == nil || e.err == nil {
+		return ""
+	}
+	return e.err.Error()
+}
+
+func (e *diagnosticMetadataWrapper) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.err
+}
+
+func (e *diagnosticMetadataWrapper) ProblemDetail() *Problem {
+	if e == nil {
+		return nil
+	}
+	problem, _ := ProblemOf(e.typed)
+	return problem
+}
+
+func (e *diagnosticMetadataWrapper) DiagnosticMetadata() DiagnosticMetadata {
+	if e == nil {
+		return DiagnosticMetadata{}
+	}
+	return e.metadata
+}
+
+// MarshalJSON preserves the concrete typed error's extension fields and adds
+// the optional diagnostics as sibling fields in the existing error object.
+func (e *diagnosticMetadataWrapper) MarshalJSON() ([]byte, error) {
+	raw, err := json.Marshal(e.typed)
+	if err != nil {
+		return nil, err
+	}
+
+	var object map[string]json.RawMessage
+	if err := json.Unmarshal(raw, &object); err != nil {
+		return nil, err
+	}
+	if e.metadata.Origin != "" {
+		origin, err := json.Marshal(e.metadata.Origin)
+		if err != nil {
+			return nil, err
+		}
+		object["origin"] = origin
+	}
+	if e.metadata.ProxyRequestID != "" {
+		requestID, err := json.Marshal(e.metadata.ProxyRequestID)
+		if err != nil {
+			return nil, err
+		}
+		object["proxy_request_id"] = requestID
+	}
+	return json.Marshal(object)
+}
+
+// WithDiagnosticMetadata attaches optional wire diagnostics to a typed error.
+// Empty metadata is a no-op. The returned wrapper still participates in
+// errors.Is/errors.As and TypedError routing through Unwrap and ProblemDetail.
+func WithDiagnosticMetadata(err error, metadata DiagnosticMetadata) error {
+	if err == nil || (metadata.Origin == "" && metadata.ProxyRequestID == "") {
+		return err
+	}
+
+	typed, ok := UnwrapTypedError(err)
+	if !ok {
+		return err
+	}
+	if existing, ok := diagnosticMetadataWrapperForProducer(typed); ok {
+		merged := existing.metadata
+		if metadata.Origin != "" {
+			merged.Origin = metadata.Origin
+		}
+		if metadata.ProxyRequestID != "" {
+			merged.ProxyRequestID = metadata.ProxyRequestID
+		}
+		return &diagnosticMetadataWrapper{err: err, typed: existing.typed, metadata: merged}
+	}
+	return &diagnosticMetadataWrapper{err: err, typed: typed, metadata: metadata}
+}
+
+// DiagnosticMetadataOf returns optional diagnostics attached to the first
+// typed producer in err's wrap chain. Metadata on a typed cause belongs to
+// that inner producer and must not be projected onto an outer typed error.
+func DiagnosticMetadataOf(err error) (DiagnosticMetadata, bool) {
+	typed, ok := UnwrapTypedError(err)
+	if !ok {
+		return DiagnosticMetadata{}, false
+	}
+	carrier, ok := diagnosticMetadataWrapperForProducer(typed)
+	if !ok {
+		return DiagnosticMetadata{}, false
+	}
+	metadata := carrier.DiagnosticMetadata()
+	if metadata.Origin == "" && metadata.ProxyRequestID == "" {
+		return DiagnosticMetadata{}, false
+	}
+	return metadata, true
+}
+
+// diagnosticMetadataWrapperForProducer deliberately checks only the selected
+// typed producer. errors.As must not be used here because it would traverse
+// into an inner typed cause and associate that cause's metadata with the outer
+// producer.
+func diagnosticMetadataWrapperForProducer(typed error) (*diagnosticMetadataWrapper, bool) {
+	wrapper, ok := typed.(*diagnosticMetadataWrapper) //nolint:errorlint // Exact producer identity is the invariant being enforced.
+	return wrapper, ok
+}
--- a/errs/diagnostic_metadata_test.go
+++ b/errs/diagnostic_metadata_test.go
@@ -0,0 +1,118 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package errs
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestDiagnosticMetadataPreservesTypedErrorContract(t *testing.T) {
+	permission := NewPermissionError(SubtypeMissingScope, "missing scope").
+		WithMissingScopes("im:message")
+	wrapped := WithDiagnosticMetadata(permission, DiagnosticMetadata{
+		Origin:         "proxy",
+		ProxyRequestID: "proxy_req_1",
+	})
+
+	var gotPermission *PermissionError
+	if !errors.As(wrapped, &gotPermission) || gotPermission != permission {
+		t.Fatalf("errors.As() = %p, want original permission error %p", gotPermission, permission)
+	}
+	problem, ok := ProblemOf(wrapped)
+	if !ok || problem != &permission.Problem {
+		t.Fatalf("ProblemOf() = (%p, %v), want original Problem %p", problem, ok, &permission.Problem)
+	}
+	metadata, ok := DiagnosticMetadataOf(wrapped)
+	if !ok || metadata.Origin != "proxy" || metadata.ProxyRequestID != "proxy_req_1" {
+		t.Fatalf("DiagnosticMetadataOf() = (%#v, %v)", metadata, ok)
+	}
+
+	raw, err := json.Marshal(wrapped)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var object map[string]any
+	if err := json.Unmarshal(raw, &object); err != nil {
+		t.Fatal(err)
+	}
+	if object["origin"] != "proxy" || object["proxy_request_id"] != "proxy_req_1" {
+		t.Fatalf("metadata missing from JSON: %s", raw)
+	}
+	missingScopes, ok := object["missing_scopes"].([]any)
+	if !ok || len(missingScopes) != 1 || missingScopes[0] != "im:message" {
+		t.Fatalf("typed extension fields missing from JSON: %s", raw)
+	}
+}
+
+func TestDiagnosticMetadataMergesWithoutMutatingExistingWrapper(t *testing.T) {
+	typed := NewNetworkError(SubtypeUpstreamUnavailable, "unavailable")
+	withOrigin := WithDiagnosticMetadata(typed, DiagnosticMetadata{Origin: "proxy"})
+	withRequestID := WithDiagnosticMetadata(withOrigin, DiagnosticMetadata{ProxyRequestID: "proxy_req_2"})
+
+	original, _ := DiagnosticMetadataOf(withOrigin)
+	if original.ProxyRequestID != "" {
+		t.Fatalf("existing wrapper was mutated: %#v", original)
+	}
+	merged, ok := DiagnosticMetadataOf(withRequestID)
+	if !ok || merged.Origin != "proxy" || merged.ProxyRequestID != "proxy_req_2" {
+		t.Fatalf("merged metadata = (%#v, %v)", merged, ok)
+	}
+}
+
+func TestDiagnosticMetadataPreservesOuterErrorContext(t *testing.T) {
+	cause := errors.New("transport failed")
+	typed := NewNetworkError(SubtypeNetworkTransport, "request failed").WithCause(cause)
+	outer := fmt.Errorf("fetch document: %w", typed)
+
+	wrapped := WithDiagnosticMetadata(outer, DiagnosticMetadata{Origin: "proxy"})
+	if got, want := wrapped.Error(), outer.Error(); got != want {
+		t.Fatalf("Error() = %q, want %q", got, want)
+	}
+	if !errors.Is(wrapped, cause) {
+		t.Fatal("metadata wrapper lost the original cause chain")
+	}
+	var gotTyped *NetworkError
+	if !errors.As(wrapped, &gotTyped) || gotTyped != typed {
+		t.Fatalf("errors.As() = %p, want original typed error %p", gotTyped, typed)
+	}
+}
+
+func TestDiagnosticMetadataDoesNotCrossTypedProducerBoundary(t *testing.T) {
+	inner := NewNetworkError(SubtypeUpstreamUnavailable, "proxy unavailable")
+	annotatedInner := WithDiagnosticMetadata(inner, DiagnosticMetadata{
+		Origin:         "proxy",
+		ProxyRequestID: "proxy_req_inner",
+	})
+	outer := NewInternalError(SubtypeUnknown, "business reclassified failure").
+		WithCause(annotatedInner)
+
+	if metadata, ok := DiagnosticMetadataOf(outer); ok {
+		t.Fatalf("outer typed producer inherited inner metadata: %#v", metadata)
+	}
+
+	wrapped := WithDiagnosticMetadata(outer, DiagnosticMetadata{Origin: "cli"})
+	problem, ok := ProblemOf(wrapped)
+	if !ok || problem != &outer.Problem {
+		t.Fatalf("ProblemOf() = (%p, %v), want outer Problem %p", problem, ok, &outer.Problem)
+	}
+	if problem.Category != CategoryInternal ||
+		problem.Subtype != SubtypeUnknown ||
+		problem.Message != "business reclassified failure" {
+		t.Fatalf("outer typed identity changed: %#v", problem)
+	}
+	metadata, ok := DiagnosticMetadataOf(wrapped)
+	if !ok || metadata.Origin != "cli" || metadata.ProxyRequestID != "" {
+		t.Fatalf("outer metadata = (%#v, %v), want cli without inner request id", metadata, ok)
+	}
+
+	innerMetadata, ok := DiagnosticMetadataOf(annotatedInner)
+	if !ok ||
+		innerMetadata.Origin != "proxy" ||
+		innerMetadata.ProxyRequestID != "proxy_req_inner" {
+		t.Fatalf("inner metadata was mutated: (%#v, %v)", innerMetadata, ok)
+	}
+}
--- a/errs/marshal_test.go
+++ b/errs/marshal_test.go
@@ -27,7 +27,11 @@ func TestPermissionError_MarshalJSON_HasAllWireFields(t *testing.T) {
 		Identity:      "user",
 		ConsoleURL:    "https://example",
 	}
-	b, err := json.Marshal(pe)
+	withMetadata := WithDiagnosticMetadata(pe, DiagnosticMetadata{
+		Origin:         "proxy",
+		ProxyRequestID: "proxy_req_123",
+	})
+	b, err := json.Marshal(withMetadata)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -39,6 +43,8 @@ func TestPermissionError_MarshalJSON_HasAllWireFields(t *testing.T) {
 		`"message":"x"`,
 		`"hint":"y"`,
 		`"log_id":"lg"`,
+		`"origin":"proxy"`,
+		`"proxy_request_id":"proxy_req_123"`,
 		`"missing_scopes":["docx:document"]`,
 		`"identity":"user"`,
 		`"console_url":"https://example"`,
--- a/errs/subtypes.go
+++ b/errs/subtypes.go
@@ -48,11 +48,13 @@ const (

 // CategoryNetwork subtypes
 const (
-	SubtypeNetworkTransport Subtype = "transport"    // fallback when no more-specific network subtype matches
-	SubtypeNetworkTimeout   Subtype = "timeout"      // dial / read timeout
-	SubtypeNetworkTLS       Subtype = "tls"          // TLS handshake / cert failure
-	SubtypeNetworkDNS       Subtype = "dns"          // DNS resolution failure
-	SubtypeNetworkServer    Subtype = "server_error" // upstream HTTP 5xx
+	SubtypeNetworkTransport            Subtype = "transport"                     // fallback when no more-specific network subtype matches
+	SubtypeNetworkTimeout              Subtype = "timeout"                       // dial / read timeout
+	SubtypeNetworkTLS                  Subtype = "tls"                           // TLS handshake / cert failure
+	SubtypeNetworkDNS                  Subtype = "dns"                           // DNS resolution failure
+	SubtypeNetworkServer               Subtype = "server_error"                  // upstream HTTP 5xx
+	SubtypeCredentialSourceUnavailable Subtype = "credential_source_unavailable" // external credential program or identity service is temporarily unavailable
+	SubtypeUpstreamUnavailable         Subtype = "upstream_unavailable"          // external proxy cannot reach the requested upstream service
 )

 // CategoryAPI subtypes
--- a/extension/transport/sidecar/interceptor_test.go
+++ b/extension/transport/sidecar/interceptor_test.go
@@ -12,18 +12,9 @@ import (
 	"net/http"
 	"testing"

-	exttransport "github.com/larksuite/cli/extension/transport"
-	"github.com/larksuite/cli/internal/envvars"
-	internaltransport "github.com/larksuite/cli/internal/transport"
 	"github.com/larksuite/cli/sidecar"
 )

-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return f(req)
-}
-
 // failingBody is a ReadCloser that errors on Read and tracks Close calls.
 type failingBody struct {
 	err      error
@@ -272,55 +263,3 @@ func TestInterceptor_EmptyBody(t *testing.T) {
 		t.Errorf("body SHA256 = %q, want empty-string SHA256 %q", sha, expectedEmpty)
 	}
 }
-
-func TestLegacySidecarProviderStillHandlesForcedExternalRequests(t *testing.T) {
-	t.Setenv(envvars.CliAuthProxy, "http://127.0.0.1:16384")
-	t.Setenv(envvars.CliProxyKey, "test-key")
-	previousProvider := exttransport.GetProvider()
-	exttransport.Register(&Provider{})
-	t.Cleanup(func() { exttransport.Register(previousProvider) })
-
-	seen := make(chan *http.Request, 2)
-	base := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		seen <- req.Clone(req.Context())
-		return &http.Response{StatusCode: http.StatusNoContent, Body: http.NoBody, Request: req}, nil
-	})
-	client := internaltransport.ClientForRequestClass(
-		&http.Client{Transport: internaltransport.NewHTTPPolicyRouter(base, base)},
-		exttransport.RequestClassExternal,
-	)
-
-	withSentinel, err := http.NewRequest(http.MethodGet, "https://external.example/protected", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	withSentinel.Header.Set("Authorization", "Bearer "+sidecar.SentinelUAT)
-	resp, err := client.Do(withSentinel)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-
-	withoutSentinel, err := http.NewRequest(http.MethodGet, "https://external.example/public", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp, err = client.Do(withoutSentinel)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-
-	proxied := <-seen
-	if proxied.URL.Scheme != "http" || proxied.URL.Host != "127.0.0.1:16384" {
-		t.Fatalf("sentinel request URL = %s, want sidecar route", proxied.URL)
-	}
-	if got := proxied.Header.Get(sidecar.HeaderProxyTarget); got != "https://external.example" {
-		t.Fatalf("sentinel request proxy target = %q", got)
-	}
-
-	passthrough := <-seen
-	if got := passthrough.URL.String(); got != "https://external.example/public" {
-		t.Fatalf("non-sentinel request URL = %q, want unchanged", got)
-	}
-}
--- a/extension/transport/types.go
+++ b/extension/transport/types.go
@@ -15,27 +15,6 @@ type Provider interface {
 	ResolveInterceptor(ctx context.Context) Interceptor
 }

-// RequestClass describes the trust boundary of an outbound HTTP request.
-// Platform requests target endpoints owned by the CLI's endpoint resolver;
-// external requests target user-provided, pre-signed, CDN, registry, or other
-// non-platform URLs. Redirect targets are classified again from each hop's
-// logical URL; rewriting a host in an interceptor does not add that host to
-// the platform endpoint catalog.
-type RequestClass string
-
-const (
-	RequestClassPlatform RequestClass = "platform"
-	RequestClassExternal RequestClass = "external"
-)
-
-// ScopedProvider optionally limits a Provider to selected request classes.
-// Providers that do not implement this interface retain the original
-// behavior and apply to every request class.
-type ScopedProvider interface {
-	Provider
-	SupportsRequestClass(RequestClass) bool
-}
-
 // Interceptor defines network-layer customization via a pre/post hook pair.
 // The built-in transport chain always executes between PreRoundTrip and the
 // returned post function, and cannot be skipped or overridden by the extension.
--- a/internal/auth/transport.go
+++ b/internal/auth/transport.go
@@ -17,8 +17,6 @@ import (
 	"github.com/larksuite/cli/internal/transport"
 )

-var _ transport.RoundTripperDecorator = (*SecurityPolicyTransport)(nil)
-
 // SecurityPolicyTransport is an http.RoundTripper that intercepts all responses
 // and checks for security policy errors.
 type SecurityPolicyTransport struct {
@@ -33,16 +31,6 @@ func (t *SecurityPolicyTransport) base() http.RoundTripper {
 	return transport.Fallback()
 }

-func (t *SecurityPolicyTransport) BaseRoundTripper() http.RoundTripper {
-	return t.base()
-}
-
-func (t *SecurityPolicyTransport) WithBaseRoundTripper(base http.RoundTripper) http.RoundTripper {
-	cloned := *t
-	cloned.Base = base
-	return &cloned
-}
-
 // RoundTrip implements http.RoundTripper.
 func (t *SecurityPolicyTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	resp, err := t.base().RoundTrip(req)
--- a/internal/build/edition_extended.go
+++ b/internal/build/edition_extended.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package build
+
+const Edition = "extended"
+
+func Capabilities() []string {
+	return []string{"external-credential-platform"}
+}
--- a/internal/build/edition_standard.go
+++ b/internal/build/edition_standard.go
@@ -0,0 +1,10 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build !extended
+
+package build
+
+const Edition = "standard"
+
+func Capabilities() []string { return []string{} }
--- a/internal/client/client.go
+++ b/internal/client/client.go
@@ -23,6 +23,7 @@ import (
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/errclass"
 	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/requestcontext"
 	"github.com/larksuite/cli/internal/util"
 )

@@ -119,6 +120,7 @@ func (c *APIClient) buildApiReq(request RawApiRequest) (*larkcore.ApiReq, []lark
 // (a typed *errs.* from resolveAccessToken's missing-credential paths or
 // elsewhere) flow through unchanged.
 func (c *APIClient) DoSDKRequest(ctx context.Context, req *larkcore.ApiReq, as core.Identity, extraOpts ...larkcore.RequestOptionFunc) (*larkcore.ApiResp, error) {
+	ctx = requestcontext.WithIdentity(ctx, as)
 	var opts []larkcore.RequestOptionFunc

 	token, err := c.resolveAccessToken(ctx, as)
@@ -155,6 +157,7 @@ func (c *APIClient) DoSDKRequest(ctx context.Context, req *larkcore.ApiReq, as c
 // HTTP errors (status >= 400) are handled internally: the body is read (up to 4 KB),
 // closed, and returned as a typed *errs.NetworkError — callers only receive successful responses.
 func (c *APIClient) DoStream(ctx context.Context, req *larkcore.ApiReq, as core.Identity, opts ...Option) (*http.Response, error) {
+	ctx = requestcontext.WithIdentity(ctx, as)
 	cfg := buildConfig(opts)

 	// Resolve auth
--- a/internal/client/client_test.go
+++ b/internal/client/client_test.go
@@ -518,29 +518,6 @@ func TestDoStream_TransportFailureSplitsSubtype(t *testing.T) {
 	}
 }

-func TestDoStream_PreservesTypedTransportError(t *testing.T) {
-	policyErr := errs.NewSecurityPolicyError(errs.SubtypeAccessDenied, "blocked redirect")
-	ac := &APIClient{
-		HTTP: &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
-			return nil, policyErr
-		})},
-		Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
-		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
-	}
-
-	_, err := ac.DoStream(context.Background(), &larkcore.ApiReq{
-		HttpMethod: http.MethodGet,
-		ApiPath:    "/open-apis/drive/v1/files/file_token/download",
-	}, core.AsBot)
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryPolicy || problem.Subtype != errs.SubtypeAccessDenied {
-		t.Fatalf("DoStream() problem = %#v, %v; want policy/access_denied", problem, ok)
-	}
-	if !errors.Is(err, policyErr) {
-		t.Fatal("DoStream() did not preserve the typed transport error")
-	}
-}
-
 // failingTokenResolver always returns TokenUnavailableError, exercising the
 // auth/credential failure path through resolveAccessToken.
 type failingTokenResolver struct{}
--- a/internal/client/remote_files.go
+++ b/internal/client/remote_files.go
@@ -0,0 +1,169 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package client
+
+import (
+	"context"
+	"io"
+	"net/http"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/requestcontext"
+)
+
+// RemoteFile is a service-returned file reference that has passed the active
+// runtime's data-plane policy. Its URL is intentionally private so callers
+// cannot construct a trusted reference without Validate.
+type RemoteFile struct {
+	rawURL string
+}
+
+// URL returns the original service-provided URL verbatim.
+func (f RemoteFile) URL() string { return f.rawURL }
+
+// NewRequest constructs a request that remains bound to this validated file
+// reference. Business shortcuts do not construct raw URL requests themselves.
+func (f RemoteFile) NewRequest(ctx context.Context, method string, body io.Reader) (*http.Request, error) {
+	if f.rawURL == "" {
+		return nil, errs.NewInternalError(errs.SubtypeUnknown,
+			"cannot build a request for an empty remote file reference")
+	}
+	req, err := http.NewRequestWithContext(ctx, method, f.rawURL, body)
+	if err != nil {
+		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport,
+			"build remote file request: %v", err).WithCause(err)
+	}
+	return req, nil
+}
+
+// DirectRemoteFileValidator applies a caller-specific policy to direct-mode
+// URLs. Proxy handles are validated by the managed data-plane policy instead.
+type DirectRemoteFileValidator func(context.Context, string) error
+
+// HTTPClientProvider resolves the runtime's configured HTTP client without
+// exposing raw client construction to business shortcuts.
+type HTTPClientProvider func() (*http.Client, error)
+
+// RemoteFilePolicy is the source-neutral runtime contract for validating and
+// routing service-returned file references.
+type RemoteFilePolicy interface {
+	ValidateRemoteFile(rawURL string) error
+	UsesManagedFilePlane() bool
+}
+
+// RemoteFiles is the runtime boundary for service-returned file references.
+// It keeps credential mode and edition routing out of business shortcuts.
+// Every service-returned file byte transfer must pass through Validate,
+// RemoteFile.NewRequest, and Do so the active data-plane policy is enforced.
+type RemoteFiles struct {
+	policy        RemoteFilePolicy
+	managedClient HTTPClientProvider
+	identity      core.Identity
+}
+
+// NewRemoteFiles creates a file boundary for one resolved runtime identity.
+func NewRemoteFiles(
+	policy RemoteFilePolicy,
+	managedClient HTTPClientProvider,
+	identity core.Identity,
+) *RemoteFiles {
+	return &RemoteFiles{
+		policy:        policy,
+		managedClient: managedClient,
+		identity:      identity,
+	}
+}
+
+// Validate checks a known service-returned file URL and returns an opaque,
+// typed reference. A directValidator, when supplied, is applied only to the
+// ordinary/direct data plane; proxy handles use the configured proxy policy.
+func (r *RemoteFiles) Validate(
+	ctx context.Context,
+	rawURL string,
+	directValidator ...DirectRemoteFileValidator,
+) (RemoteFile, error) {
+	if r == nil {
+		return RemoteFile{}, errs.NewInternalError(errs.SubtypeUnknown, "remote file runtime is unavailable")
+	}
+	if r.policy != nil {
+		if err := r.policy.ValidateRemoteFile(rawURL); err != nil {
+			return RemoteFile{}, err
+		}
+	}
+	if !usesManagedFilePlane(r.policy) && len(directValidator) > 0 && directValidator[0] != nil {
+		if err := directValidator[0](ctx, rawURL); err != nil {
+			return RemoteFile{}, err
+		}
+	}
+	return RemoteFile{rawURL: rawURL}, nil
+}
+
+// RequirePortableURL rejects commands that would return a managed file handle
+// for use outside this CLI. The check is capability-based, so callers do not
+// branch on a credential mode.
+func (r *RemoteFiles) RequirePortableURL(param string) error {
+	if r == nil || !usesManagedFilePlane(r.policy) {
+		return nil
+	}
+	return errs.NewValidationError(errs.SubtypeFailedPrecondition,
+		"%s is unavailable because this credential source requires CLI-managed file routing", param).
+		WithParam(param).
+		WithHint("omit %s and let lark-cli transfer the file", param)
+}
+
+// Do executes a request for a validated remote file. Ordinary/direct runtimes
+// use directClient unchanged; a nil directClient gets the same isolated
+// DefaultTransport client historically used by presigned Apps transfers.
+// Managed runtimes select the proxy-aware client and copy the caller's
+// timeout/redirect policy so existing transfer semantics remain intact.
+func (r *RemoteFiles) Do(req *http.Request, file RemoteFile, directClient *http.Client) (*http.Response, error) {
+	if r == nil {
+		return nil, errs.NewInternalError(errs.SubtypeUnknown, "remote file runtime is unavailable")
+	}
+	if req == nil || req.URL == nil || file.rawURL == "" || req.URL.String() != file.rawURL {
+		return nil, errs.NewInternalError(errs.SubtypeUnknown,
+			"remote file request does not match its validated reference")
+	}
+
+	if directClient == nil {
+		directClient = &http.Client{Transport: http.DefaultTransport}
+	}
+	selected := directClient
+	managedPlane := usesManagedFilePlane(r.policy)
+	if managedPlane {
+		if r.managedClient == nil {
+			return nil, errs.NewInternalError(errs.SubtypeUnknown,
+				"managed remote file runtime has no HTTP client")
+		}
+		managed, err := r.managedClient()
+		if err != nil {
+			return nil, err
+		}
+		if managed == nil {
+			return nil, errs.NewInternalError(errs.SubtypeUnknown,
+				"managed remote file runtime returned no HTTP client")
+		}
+		if directClient != nil && managed != directClient {
+			cloned := *managed
+			cloned.Timeout = directClient.Timeout
+			if directClient.CheckRedirect != nil {
+				cloned.CheckRedirect = directClient.CheckRedirect
+			}
+			selected = &cloned
+		} else {
+			selected = managed
+		}
+	}
+	if !managedPlane {
+		return selected.Do(req)
+	}
+
+	requestCtx := requestcontext.WithIdentity(req.Context(), r.identity)
+	return selected.Do(req.Clone(requestCtx))
+}
+
+func usesManagedFilePlane(policy RemoteFilePolicy) bool {
+	return policy != nil && policy.UsesManagedFilePlane()
+}
--- a/internal/client/remote_files_architecture_test.go
+++ b/internal/client/remote_files_architecture_test.go
@@ -0,0 +1,317 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package client
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+const externalCredentialImplementation = "github.com/larksuite/cli/internal/externalcredential"
+
+// These functions own protocols that are explicitly outside the
+// service-returned file plane: user-supplied external downloads and MCP.
+// Adding a boundary is an architectural decision; //nolint alone must never
+// make a new raw HTTP path possible.
+var shortcutRawHTTPBoundaries = map[string]string{
+	"common/mcp_client.go:DoMCPCall":                   "MCP protocol client",
+	"doc/doc_resource_cover.go:downloadDocCoverURL":    "validated user-supplied cover URL",
+	"doc/doc_resource_cover.go:newDocCoverHTTPClient":  "guarded external-download client",
+	"doc/doc_resource_cover.go:cloneDocCoverTransport": "guarded external-download transport",
+	"im/helpers.go:startURLDownload":                   "validated user-supplied media URL",
+}
+
+func TestCoreDoesNotOwnExternalCredentialProductModel(t *testing.T) {
+	checkCoreDirectoryIsProductNeutral(t, filepath.Join("..", "core"))
+}
+
+func TestRuntimeFrameworkDoesNotImportExternalCredentialImplementation(t *testing.T) {
+	for _, dir := range []string{
+		".",
+		filepath.Join("..", "cmdutil"),
+		filepath.Join("..", "credential"),
+	} {
+		checkDirectoryDoesNotImportExternalCredential(t, dir)
+	}
+}
+
+func checkCoreDirectoryIsProductNeutral(t *testing.T, dir string) {
+	t.Helper()
+	entries, err := vfs.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	forbidden := []string{
+		"externalcredential",
+		"external-credential",
+		"credential_proxy",
+		"platform_proxy",
+	}
+	for _, entry := range entries {
+		path := filepath.Join(dir, entry.Name())
+		if entry.IsDir() {
+			checkCoreDirectoryIsProductNeutral(t, path)
+			continue
+		}
+		if !strings.HasSuffix(entry.Name(), ".go") {
+			continue
+		}
+		src, err := vfs.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalizedSource := strings.ToLower(string(src))
+		for _, productSymbol := range forbidden {
+			if strings.Contains(normalizedSource, strings.ToLower(productSymbol)) {
+				t.Errorf("%s contains external credential product symbol %q; keep the core profile model product-neutral", path, productSymbol)
+			}
+		}
+	}
+}
+
+func TestBusinessShortcutsUseRuntimeCredentialBoundaries(t *testing.T) {
+	checkBusinessShortcutDirectory(t, filepath.Join("..", "..", "shortcuts"))
+}
+
+func TestShortcutRawHTTPConstructionIsConfinedToExplicitBoundaries(t *testing.T) {
+	root := filepath.Join("..", "..", "shortcuts")
+	checkShortcutRawHTTPDirectory(t, root, root)
+}
+
+func TestRawHTTPConstructionGuardRecognizesAliasedBypasses(t *testing.T) {
+	const source = `package fixture
+import nethttp "net/http"
+func bypass() {
+	_ = &nethttp.Client{}
+	_, _ = nethttp.NewRequest(nethttp.MethodGet, "https://files.example", nil)
+	_ = nethttp.DefaultClient
+}`
+	file, err := parser.ParseFile(token.NewFileSet(), "fixture.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	uses := rawHTTPConstructions(file, map[string]struct{}{"nethttp": {}})
+	joined := strings.Join(uses, ",")
+	for _, want := range []string{"Client literal", "NewRequest", "DefaultClient"} {
+		if !strings.Contains(joined, want) {
+			t.Fatalf("raw HTTP uses = %q, want %q", joined, want)
+		}
+	}
+}
+
+func checkDirectoryDoesNotImportExternalCredential(t *testing.T, dir string) {
+	t.Helper()
+	entries, err := vfs.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range entries {
+		path := filepath.Join(dir, entry.Name())
+		if entry.IsDir() {
+			checkDirectoryDoesNotImportExternalCredential(t, path)
+			continue
+		}
+		if !strings.HasSuffix(entry.Name(), ".go") || strings.HasSuffix(entry.Name(), "_test.go") {
+			continue
+		}
+		src, err := vfs.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), path, src, parser.ImportsOnly)
+		if err != nil {
+			t.Fatalf("parse %s: %v", path, err)
+		}
+		for _, spec := range file.Imports {
+			importPath, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				t.Fatalf("parse import in %s: %v", path, err)
+			}
+			if importPath == externalCredentialImplementation ||
+				strings.HasPrefix(importPath, externalCredentialImplementation+"/") {
+				t.Errorf("%s imports external credential implementation; inject a source-neutral runtime boundary", path)
+			}
+		}
+	}
+}
+
+func checkBusinessShortcutDirectory(t *testing.T, dir string) {
+	t.Helper()
+	entries, err := vfs.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range entries {
+		path := filepath.Join(dir, entry.Name())
+		if entry.IsDir() {
+			if entry.Name() != "common" {
+				checkBusinessShortcutDirectory(t, path)
+			}
+			continue
+		}
+		if !strings.HasSuffix(entry.Name(), ".go") || strings.HasSuffix(entry.Name(), "_test.go") {
+			continue
+		}
+		src, err := vfs.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), path, src, 0)
+		if err != nil {
+			t.Fatalf("parse %s: %v", path, err)
+		}
+		for _, spec := range file.Imports {
+			importPath, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				t.Fatalf("parse import in %s: %v", path, err)
+			}
+			if importPath == externalCredentialImplementation ||
+				strings.HasPrefix(importPath, externalCredentialImplementation+"/") {
+				t.Errorf("%s imports external credential implementation; use a source-neutral runtime capability boundary", path)
+			}
+		}
+		ast.Inspect(file, func(node ast.Node) bool {
+			selector, ok := node.(*ast.SelectorExpr)
+			if ok && selector.Sel.Name == "ExternalCredential" {
+				t.Errorf("%s selects ExternalCredential directly; use a runtime capability boundary", path)
+			}
+			return true
+		})
+	}
+}
+
+func checkShortcutRawHTTPDirectory(t *testing.T, root, dir string) {
+	t.Helper()
+	entries, err := vfs.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range entries {
+		path := filepath.Join(dir, entry.Name())
+		if entry.IsDir() {
+			checkShortcutRawHTTPDirectory(t, root, path)
+			continue
+		}
+		if !strings.HasSuffix(entry.Name(), ".go") || strings.HasSuffix(entry.Name(), "_test.go") {
+			continue
+		}
+		src, err := vfs.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), path, src, 0)
+		if err != nil {
+			t.Fatalf("parse %s: %v", path, err)
+		}
+		httpAliases := make(map[string]struct{})
+		for _, spec := range file.Imports {
+			importPath, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				t.Fatalf("parse import in %s: %v", path, err)
+			}
+			if importPath != "net/http" {
+				continue
+			}
+			alias := "http"
+			if spec.Name != nil {
+				alias = spec.Name.Name
+			}
+			if alias == "." {
+				t.Errorf("%s dot-imports net/http; raw HTTP boundaries must remain statically auditable", path)
+				continue
+			}
+			if alias != "_" {
+				httpAliases[alias] = struct{}{}
+			}
+		}
+		if len(httpAliases) == 0 {
+			continue
+		}
+
+		relativePath, err := filepath.Rel(root, path)
+		if err != nil {
+			t.Fatalf("relative shortcut path for %s: %v", path, err)
+		}
+		relativePath = filepath.ToSlash(relativePath)
+		for _, decl := range file.Decls {
+			fn, isFunc := decl.(*ast.FuncDecl)
+			uses := rawHTTPConstructions(decl, httpAliases)
+			if len(uses) == 0 {
+				continue
+			}
+			if !isFunc {
+				t.Errorf("%s constructs raw net/http at package scope (%s); route service-returned file bytes through RuntimeContext.RemoteFiles",
+					path, strings.Join(uses, ", "))
+				continue
+			}
+			boundary := relativePath + ":" + fn.Name.Name
+			if _, allowed := shortcutRawHTTPBoundaries[boundary]; allowed {
+				continue
+			}
+			t.Errorf("%s function %s constructs raw net/http (%s); route service-returned file bytes through RuntimeContext.RemoteFiles or declare a reviewed non-file-plane boundary",
+				path, fn.Name.Name, strings.Join(uses, ", "))
+		}
+	}
+}
+
+func rawHTTPConstructions(node ast.Node, aliases map[string]struct{}) []string {
+	seen := make(map[string]struct{})
+	var uses []string
+	add := func(name string) {
+		if _, ok := seen[name]; ok {
+			return
+		}
+		seen[name] = struct{}{}
+		uses = append(uses, name)
+	}
+	isHTTPSelector := func(selector *ast.SelectorExpr) bool {
+		ident, ok := selector.X.(*ast.Ident)
+		if !ok {
+			return false
+		}
+		_, ok = aliases[ident.Name]
+		return ok
+	}
+
+	ast.Inspect(node, func(current ast.Node) bool {
+		switch typed := current.(type) {
+		case *ast.CallExpr:
+			selector, ok := typed.Fun.(*ast.SelectorExpr)
+			if !ok || !isHTTPSelector(selector) {
+				break
+			}
+			switch selector.Sel.Name {
+			case "NewRequest", "NewRequestWithContext", "Get", "Post", "PostForm", "Head", "Serve", "ListenAndServe":
+				add(selector.Sel.Name)
+			}
+		case *ast.CompositeLit:
+			selector, ok := typed.Type.(*ast.SelectorExpr)
+			if !ok || !isHTTPSelector(selector) {
+				break
+			}
+			switch selector.Sel.Name {
+			case "Client", "Request", "Transport":
+				add(selector.Sel.Name + " literal")
+			}
+		case *ast.SelectorExpr:
+			if !isHTTPSelector(typed) {
+				break
+			}
+			switch typed.Sel.Name {
+			case "DefaultClient", "DefaultTransport":
+				add(typed.Sel.Name)
+			}
+		}
+		return true
+	})
+	return uses
+}
--- a/internal/client/remote_files_test.go
+++ b/internal/client/remote_files_test.go
@@ -0,0 +1,177 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package client
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/requestcontext"
+)
+
+type testRemoteFilePolicy struct {
+	allowed string
+	managed bool
+}
+
+func (p testRemoteFilePolicy) ValidateRemoteFile(rawURL string) error {
+	if p.allowed != "" && rawURL != p.allowed {
+		return errors.New("remote file rejected")
+	}
+	return nil
+}
+
+func (p testRemoteFilePolicy) UsesManagedFilePlane() bool { return p.managed }
+
+func TestRemoteFilesDirectPreservesCallerClientAndPolicy(t *testing.T) {
+	var managedCalls, directCalls, validationCalls int
+	direct := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		directCalls++
+		if got := requestcontext.Identity(req.Context()); got != "" {
+			t.Fatalf("direct request context was changed: identity = %q", got)
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Header:     make(http.Header),
+			Body:       io.NopCloser(strings.NewReader("ok")),
+			Request:    req,
+		}, nil
+	})}
+	files := NewRemoteFiles(nil, func() (*http.Client, error) {
+		managedCalls++
+		return nil, errors.New("must not be called")
+	}, core.AsUser)
+
+	file, err := files.Validate(context.Background(), "https://files.example/object?signature=x",
+		func(_ context.Context, rawURL string) error {
+			validationCalls++
+			if rawURL != "https://files.example/object?signature=x" {
+				t.Fatalf("validator URL = %q", rawURL)
+			}
+			return nil
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	req, err := file.NewRequest(context.Background(), http.MethodGet, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := files.Do(req, file, direct)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if directCalls != 1 || managedCalls != 0 || validationCalls != 1 {
+		t.Fatalf("calls direct=%d managed=%d validation=%d", directCalls, managedCalls, validationCalls)
+	}
+}
+
+func TestRemoteFilesManagedValidatesAndRoutesOpaqueHandle(t *testing.T) {
+	const opaqueURL = "https://proxy.example/lark-cli/v1/files/opaque_1"
+	policy := testRemoteFilePolicy{allowed: opaqueURL, managed: true}
+	var managedCalls, directCalls, directValidationCalls int
+	managed := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		managedCalls++
+		if got := requestcontext.Identity(req.Context()); got != core.AsBot {
+			t.Fatalf("request identity = %q, want bot", got)
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Header:     make(http.Header),
+			Body:       io.NopCloser(strings.NewReader("ok")),
+			Request:    req,
+		}, nil
+	})}
+	direct := &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
+		directCalls++
+		return nil, errors.New("must not be called")
+	})}
+	files := NewRemoteFiles(policy, func() (*http.Client, error) { return managed, nil }, core.AsBot)
+
+	if _, err := files.Validate(context.Background(), "https://objects.example/raw?signature=secret"); err == nil {
+		t.Fatal("raw object URL accepted in managed mode")
+	}
+	file, err := files.Validate(context.Background(), opaqueURL,
+		func(context.Context, string) error {
+			directValidationCalls++
+			return errors.New("must not be called")
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	req, err := file.NewRequest(context.Background(), http.MethodGet, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := files.Do(req, file, direct)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if managedCalls != 1 || directCalls != 0 || directValidationCalls != 0 {
+		t.Fatalf("calls managed=%d direct=%d validation=%d", managedCalls, directCalls, directValidationCalls)
+	}
+}
+
+func TestRemoteFilesDoRejectsReferenceMismatch(t *testing.T) {
+	files := NewRemoteFiles(nil, nil, core.AsUser)
+	file, err := files.Validate(context.Background(), "https://files.example/one")
+	if err != nil {
+		t.Fatal(err)
+	}
+	req, _ := http.NewRequest(http.MethodGet, "https://files.example/two", nil)
+	if _, err := files.Do(req, file, http.DefaultClient); err == nil {
+		t.Fatal("mismatched request and validated file accepted")
+	}
+}
+
+func TestRemoteFilesRequirePortableURL(t *testing.T) {
+	files := NewRemoteFiles(testRemoteFilePolicy{managed: true}, nil, core.AsBot)
+	err := files.RequirePortableURL("--url-only")
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("error = %T %v, want ValidationError", err, err)
+	}
+	if validationErr.Subtype != errs.SubtypeFailedPrecondition || validationErr.Param != "--url-only" {
+		t.Fatalf("error = subtype %q param %q", validationErr.Subtype, validationErr.Param)
+	}
+}
+
+func TestCallAPIPreservesURLsInArbitraryJSON(t *testing.T) {
+	const rawURL = "https://objects.example/raw?signature=opaque"
+	apiClient, _ := newTestAPIClient(t, roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		resp := jsonResponse(map[string]any{
+			"code": 0,
+			"data": map[string]any{
+				"download_url": rawURL,
+				"nested":       []any{map[string]any{"url": rawURL}},
+			},
+		})
+		resp.Request = req
+		return resp, nil
+	}))
+	result, err := apiClient.CallAPI(context.Background(), RawApiRequest{
+		Method: http.MethodGet,
+		URL:    "/open-apis/example/v1/raw",
+		As:     core.AsBot,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := result.(map[string]any)["data"].(map[string]any)
+	if got := data["download_url"]; got != rawURL {
+		t.Fatalf("download_url = %v, want exact arbitrary JSON value %q", got, rawURL)
+	}
+	nested := data["nested"].([]any)[0].(map[string]any)
+	if got := nested["url"]; got != rawURL {
+		t.Fatalf("nested url = %v, want exact arbitrary JSON value %q", got, rawURL)
+	}
+}
--- a/internal/cmdutil/factory.go
+++ b/internal/cmdutil/factory.go
@@ -16,12 +16,11 @@ import (
 	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/extension/fileio"
-	exttransport "github.com/larksuite/cli/extension/transport"
 	"github.com/larksuite/cli/internal/client"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/keychain"
-	"github.com/larksuite/cli/internal/transport"
+	"github.com/larksuite/cli/internal/runtimeplan"
 )

 // Factory holds shared dependencies injected into every command.
@@ -33,7 +32,7 @@ type InvocationContext struct {

 type Factory struct {
 	Config     func() (*core.CliConfig, error) // lazily loads app config from Credential
-	HttpClient func() (*http.Client, error)    // policy-routed HTTP client for direct requests
+	HttpClient func() (*http.Client, error)    // HTTP client for non-Lark API calls (with retry and security headers)
 	LarkClient func() (*lark.Client, error)    // Lark SDK client for all Open API calls
 	IOStreams  *IOStreams                      // stdin/stdout/stderr streams

@@ -45,23 +44,13 @@ type Factory struct {

 	Credential *credential.CredentialProvider

+	runtimePlan *runtimeplan.Plan
+
 	FileIOProvider fileio.Provider // file transfer provider (default: local filesystem)

 	SkillContent fs.FS // embedded skill tree (rooted at the skill list); nil when the build embeds no skills
 }

-// ExternalHTTPClient returns a clone of the existing Factory client whose
-// requests are explicitly classified as external. The underlying client,
-// redirect policy, timeout, proxy configuration, and legacy transport provider
-// behavior are preserved.
-func (f *Factory) ExternalHTTPClient() (*http.Client, error) {
-	client, err := f.HttpClient()
-	if err != nil {
-		return nil, err
-	}
-	return transport.ClientForRequestClass(client, exttransport.RequestClassExternal), nil
-}
-
 // ResolveFileIO resolves a FileIO instance using the current execution context.
 // The provider controls whether the returned instance is fresh or cached.
 func (f *Factory) ResolveFileIO(ctx context.Context) fileio.FileIO {
@@ -71,6 +60,34 @@ func (f *Factory) ResolveFileIO(ctx context.Context) fileio.FileIO {
 	return f.FileIOProvider.ResolveFileIO(ctx)
 }

+// NewRemoteFiles returns the invocation's file-transfer boundary without
+// exposing credential source, mode, or edition to business shortcuts.
+func (f *Factory) NewRemoteFiles(identity core.Identity) *client.RemoteFiles {
+	if f == nil {
+		return client.NewRemoteFiles(nil, nil, identity)
+	}
+	return client.NewRemoteFiles(runtimeplan.Ensure(f.runtimePlan), f.HttpClient, identity)
+}
+
+// RuntimeDescription returns sanitized diagnostics for the active plan.
+func (f *Factory) RuntimeDescription() runtimeplan.Description {
+	if f == nil {
+		return runtimeplan.Description{}
+	}
+	return runtimeplan.Ensure(f.runtimePlan).Describe()
+}
+
+// RuntimeStartupError reports whether invocation bootstrap failed before an
+// effective credential/runtime configuration could be selected. It exposes
+// only the source-neutral plan contract so diagnostic commands do not need to
+// know which edition or credential product produced the failure.
+func (f *Factory) RuntimeStartupError() error {
+	if f == nil {
+		return nil
+	}
+	return runtimeplan.Ensure(f.runtimePlan).StartupError()
+}
+
 // ResolveAs returns the effective identity type.
 // If the user explicitly passed --as, use that value; otherwise use the configured default.
 // When the value is "auto" (or unset), auto-detect based on credential hints.
@@ -224,26 +241,3 @@ func (f *Factory) NewAPIClientWithConfig(cfg *core.CliConfig) (*client.APIClient
 		Credential: f.Credential,
 	}, nil
 }
-
-// RequireBuiltinCredentialProvider returns a typed validation error when an
-// extension provider is actively managing credentials. Intended for use as
-// PersistentPreRunE on the auth and config parent commands.
-//
-// Returns nil when:
-//   - f.Credential is nil (test environments without credential setup)
-//   - No extension provider is active (built-in keychain/config path is used)
-func (f *Factory) RequireBuiltinCredentialProvider(ctx context.Context, command string) error {
-	if f.Credential == nil {
-		return nil
-	}
-	provName, err := f.Credential.ActiveExtensionProviderName(ctx)
-	if err != nil {
-		return err
-	}
-	if provName == "" {
-		return nil
-	}
-	return errs.NewValidationError(errs.SubtypeInvalidArgument,
-		"%q is not supported: credentials are provided externally and do not support interactive management", command).
-		WithHint("If another tool or method for authorization is available in this environment, try that. Otherwise, ask the user to set up credentials through the appropriate channel.")
-}
--- a/internal/cmdutil/factory_default.go
+++ b/internal/cmdutil/factory_default.go
@@ -5,18 +5,16 @@ package cmdutil

 import (
 	"context"
+	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"os"
-	"strings"
 	"sync"
 	"time"

 	lark "github.com/larksuite/oapi-sdk-go/v3"
 	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"

-	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/extension/fileio"
 	"github.com/larksuite/cli/internal/auth"
@@ -25,11 +23,17 @@ import (
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/registry"
 	"github.com/larksuite/cli/internal/riskcontrol"
+	"github.com/larksuite/cli/internal/runtimeplan"
 	_ "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
 )

+var (
+	initRegistryWithBrand         = registry.InitWithBrand
+	initEmbeddedRegistryWithBrand = registry.InitEmbeddedWithBrand
+)
+
 // NewDefault creates a production Factory with cached closures.
 // Initialization follows a credential-first order:
 //
@@ -38,38 +42,49 @@ import (
 //	Phase 3: Config derived from Credential
 //	Phase 4: LarkClient derived from Credential and workspace policy
 func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
+	// Preserve the established standalone Factory behavior. Product-specific
+	// runtime selection belongs to the CLI composition root, which calls
+	// NewDefaultWithRuntimePlan with one immutable startup snapshot.
+	core.SetCurrentWorkspace(core.DetectWorkspaceFromEnv(os.Getenv))
+	return newDefaultWithRuntimePlan(streams, inv, nil, runtimeplan.Default(), false)
+}
+
+// NewDefaultWithRuntimePlan creates a production Factory from the same
+// immutable Profile snapshot and source-neutral plan used by startup routing.
+func NewDefaultWithRuntimePlan(
+	streams *IOStreams,
+	inv InvocationContext,
+	profileConfig *core.MultiAppConfig,
+	plan *runtimeplan.Plan,
+) *Factory {
+	return newDefaultWithRuntimePlan(streams, inv, profileConfig, plan, true)
+}
+
+func newDefaultWithRuntimePlan(
+	streams *IOStreams,
+	inv InvocationContext,
+	profileConfig *core.MultiAppConfig,
+	plan *runtimeplan.Plan,
+	useProfileSnapshot bool,
+) *Factory {
 	streams = normalizeStreams(streams)
 	f := &Factory{
-		Keychain:   keychain.Default(),
-		Invocation: inv,
-		IOStreams:  streams,
+		Keychain:    keychain.Default(),
+		Invocation:  inv,
+		IOStreams:   streams,
+		runtimePlan: runtimeplan.Ensure(plan),
 	}

-	// Workspace detection: determines which config subtree to use.
-	// Must run before any config or credential load, since those paths are
-	// workspace-scoped. Default is WorkspaceLocal — existing behavior unchanged.
-	ws := core.DetectWorkspaceFromEnv(os.Getenv)
-	core.SetCurrentWorkspace(ws)
-	workspaceConfig := core.NewConfigSnapshot()
-	bootstrapHostSignalSource := sync.OnceValue(func() riskcontrol.Source {
-		return resolveSDKHostSignalSource(workspaceConfig)
-	})
-	// Install after workspace selection so the dependency bootstrap bridge uses
-	// the correct shared proxy configuration. NewDefault is also used by cmd.Build
-	// consumers, so this keeps their request routing identical to cmd.Execute.
-	transport.InstallSDKTransportBridge(func(base http.RoundTripper) http.RoundTripper {
-		return buildSDKPlatformTransportWithBase(
-			base,
-			bootstrapHostSignalSource(),
-		)
-	})
-
 	// Inject workspace-aware dir into keychain's log system.
 	// This breaks the core↔keychain import cycle by using a function variable.
 	keychain.RuntimeDirFunc = core.GetRuntimeDir

 	// Phase 0: FileIO provider (no dependency)
 	f.FileIOProvider = fileio.GetProvider()
+	workspaceConfig := core.NewConfigSnapshot()
+	if profileConfig != nil {
+		workspaceConfig = core.NewConfigSnapshotFrom(profileConfig)
+	}

 	// Phase 1: HttpClient (no credential dependency)
 	f.HttpClient = cachedHttpClientFunc(f, workspaceConfig)
@@ -77,10 +92,13 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 	// 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,
-		HttpClient: f.HttpClient,
-		ErrOut:     f.IOStreams.ErrOut,
+		Keychain:              func() keychain.KeychainAccess { return f.Keychain },
+		Profile:               inv.Profile,
+		HttpClient:            f.HttpClient,
+		ErrOut:                f.IOStreams.ErrOut,
+		RuntimePlan:           f.runtimePlan,
+		ProfileConfigSnapshot: profileConfig,
+		UseProfileSnapshot:    useProfileSnapshot,
 	})

 	// Phase 3: Runtime config contains resolved account data only.
@@ -90,7 +108,13 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 			return nil, err
 		}
 		cfg := acct.ToCliConfig()
-		registry.InitWithBrand(cfg.Brand)
+		if f.runtimePlan.AllowsRemoteMetadata() {
+			initRegistryWithBrand(cfg.Brand)
+		} else {
+			// Defense in depth for callers that construct a Factory directly
+			// instead of going through cmd/build's composition root.
+			initEmbeddedRegistryWithBrand(cfg.Brand)
+		}
 		return cfg, nil
 	})

@@ -101,45 +125,15 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 	return f
 }

-// safeRedirectPolicy permits cross-origin redirects only for bodyless GET and
-// HEAD requests. This allows API download redirects while preventing OAuth or
-// other credential-bearing request bodies from being replayed to another
-// origin. HTTPS requests can never be downgraded to HTTP.
+// safeRedirectPolicy prevents credential headers from being forwarded
+// when a response redirects to a different host (e.g. Lark API 302 → CDN).
+// Strips Authorization, X-Lark-MCP-UAT, and X-Lark-MCP-TAT on cross-host
+// redirects; other headers like X-Cli-* pass through.
 func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 	if len(via) >= 10 {
-		return errs.NewNetworkError(errs.SubtypeNetworkTransport, "too many redirects")
+		return fmt.Errorf("too many redirects")
 	}
-	if len(via) == 0 {
-		return nil
-	}
-	original := via[0]
-	previous := via[len(via)-1]
-	if previous.URL != nil && req.URL != nil && strings.EqualFold(previous.URL.Scheme, "https") && !strings.EqualFold(req.URL.Scheme, "https") {
-		return errs.NewSecurityPolicyError(
-			errs.SubtypeAccessDenied,
-			"redirect from HTTPS to %s is not allowed",
-			req.URL.Scheme,
-		)
-	}
-	if !sameRedirectOrigin(previous.URL, req.URL) {
-		if req.Method != http.MethodGet && req.Method != http.MethodHead {
-			return errs.NewSecurityPolicyError(
-				errs.SubtypeAccessDenied,
-				"cross-origin redirect for HTTP method %s is not allowed",
-				req.Method,
-			)
-		}
-		if req.Body != nil || req.GetBody != nil {
-			return errs.NewSecurityPolicyError(
-				errs.SubtypeAccessDenied,
-				"cross-origin redirect with a request body is not allowed",
-			)
-		}
-	}
-	// net/http copies initial headers onto every redirect request. Continue
-	// stripping credentials for every hop outside the initial origin, even when
-	// two consecutive redirect targets share an origin.
-	if !sameRedirectOrigin(original.URL, req.URL) {
+	if len(via) > 0 && req.URL.Host != via[0].URL.Host {
 		req.Header.Del("Authorization")
 		req.Header.Del("X-Lark-MCP-UAT")
 		req.Header.Del("X-Lark-MCP-TAT")
@@ -147,29 +141,6 @@ func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 	return nil
 }

-func sameRedirectOrigin(left, right *url.URL) bool {
-	if left == nil || right == nil {
-		return false
-	}
-	return strings.EqualFold(left.Scheme, right.Scheme) &&
-		strings.EqualFold(left.Hostname(), right.Hostname()) &&
-		effectivePort(left) == effectivePort(right)
-}
-
-func effectivePort(candidate *url.URL) string {
-	if port := candidate.Port(); port != "" {
-		return port
-	}
-	switch strings.ToLower(candidate.Scheme) {
-	case "http":
-		return "80"
-	case "https":
-		return "443"
-	default:
-		return ""
-	}
-}
-
 // warnIfProxied is a test seam for the proxy-warning gate. Production wires it
 // to transport.WarnIfProxied; tests swap in a spy to count invocations. It is
 // needed because the real function is guarded by an internal sync.Once, so
@@ -185,12 +156,22 @@ func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 		}

 		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-		shared := transport.Shared()
-		outbound := riskcontrol.NewTransport(shared, hostSignalSource)
-		platform := buildDirectHTTPTransport(outbound, true)
-		external := buildDirectHTTPTransport(outbound, false)
+
+		var rt http.RoundTripper = transport.Shared()
+		var err error
+		rt, err = applyRuntimePlan(f, rt)
+		if err != nil {
+			return nil, err
+		}
+		// Risk control remains the final trusted header boundary before either
+		// the ordinary network transport or the managed proxy data plane.
+		rt = riskcontrol.NewTransport(rt, hostSignalSource)
+		rt = &RetryTransport{Base: rt}
+		rt = &SecurityHeaderTransport{Base: rt}
+		rt = &auth.SecurityPolicyTransport{Base: rt} // Add our global response interceptor
+		rt = wrapWithExtension(rt)
 		client := &http.Client{
-			Transport:     transport.NewHTTPPolicyRouter(platform, external),
+			Transport:     rt,
 			Timeout:       30 * time.Second,
 			CheckRedirect: safeRedirectPolicy,
 		}
@@ -198,15 +179,6 @@ func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }

-func buildDirectHTTPTransport(base http.RoundTripper, platform bool) http.RoundTripper {
-	var builtIn http.RoundTripper = &RetryTransport{Base: base}
-	builtIn = &SecurityHeaderTransport{Base: builtIn}
-	if platform {
-		builtIn = &auth.SecurityPolicyTransport{Base: builtIn}
-	}
-	return builtIn
-}
-
 func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*lark.Client, error) {
 	return sync.OnceValues(func() (*lark.Client, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
@@ -222,8 +194,19 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 			warnIfProxied(f.IOStreams.ErrOut)
 		}
 		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
+		var sdkBase http.RoundTripper = transport.Shared()
+		sdkBase, err = applyRuntimePlan(f, sdkBase)
+		if err != nil {
+			return nil, err
+		}
+		// The innermost SDK boundary always strips reserved host-signal headers;
+		// a nil source makes it strip-only when workspace policy disables signal
+		// collection. A managed runtime applies its data-plane policy after this
+		// boundary so trusted signals remain associated with the original request.
+		sdkBase = riskcontrol.NewTransport(sdkBase, hostSignalSource)
+		sdkTransport := wrapSDKTransport(sdkBase)
 		opts = append(opts, lark.WithHttpClient(&http.Client{
-			Transport:     buildSDKTransport(hostSignalSource),
+			Transport:     sdkTransport,
 			CheckRedirect: safeRedirectPolicy,
 		}))
 		ep := core.ResolveEndpoints(acct.Brand)
@@ -232,54 +215,56 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }

-func buildSDKTransport(hostSignalSource riskcontrol.Source) http.RoundTripper {
-	return buildSDKTransportWithBase(transport.Shared(), hostSignalSource)
+func wrapSDKTransport(next http.RoundTripper) http.RoundTripper {
+	var sdkTransport http.RoundTripper = &RetryTransport{Base: next}
+	sdkTransport = &UserAgentTransport{Base: sdkTransport}
+	sdkTransport = &BuildHeaderTransport{Base: sdkTransport}
+	sdkTransport = &auth.SecurityPolicyTransport{Base: sdkTransport}
+	sdkTransport = wrapWithExtension(sdkTransport)
+	return sdkTransport
 }

-func buildSDKPlatformTransportWithBase(
-	base http.RoundTripper,
-	hostSignalSource riskcontrol.Source,
-) http.RoundTripper {
-	outbound := riskcontrol.NewTransport(base, hostSignalSource)
-	return buildSDKHTTPTransport(outbound, true)
-}
-
-func buildSDKTransportWithBase(
-	base http.RoundTripper,
-	hostSignalSource riskcontrol.Source,
-) http.RoundTripper {
-	// Risk control is the innermost trusted boundary for both request classes.
-	// It therefore observes the final URL and strips extension-supplied reserved
-	// headers immediately before the network transport.
-	outbound := riskcontrol.NewTransport(base, hostSignalSource)
-	return transport.NewHTTPPolicyRouter(
-		buildSDKHTTPTransport(outbound, true),
-		buildSDKHTTPTransport(outbound, false),
-	)
-}
-
-func buildSDKHTTPTransport(base http.RoundTripper, platform bool) http.RoundTripper {
-	var builtIn http.RoundTripper = &RetryTransport{Base: base}
-	builtIn = &UserAgentTransport{Base: builtIn}
-	builtIn = &BuildHeaderTransport{Base: builtIn}
-	builtIn = &SecurityHeaderTransport{Base: builtIn}
-	if platform {
-		builtIn = &auth.SecurityPolicyTransport{Base: builtIn}
+func applyRuntimePlan(f *Factory, base http.RoundTripper) (http.RoundTripper, error) {
+	if f == nil {
+		return base, nil
 	}
-	return builtIn
+	return runtimeplan.Ensure(f.runtimePlan).Wrap(base)
 }

 type credentialDeps struct {
-	Keychain   func() keychain.KeychainAccess
-	Profile    string
-	HttpClient func() (*http.Client, error)
-	ErrOut     io.Writer
+	Keychain              func() keychain.KeychainAccess
+	Profile               string
+	HttpClient            func() (*http.Client, error)
+	ErrOut                io.Writer
+	RuntimePlan           *runtimeplan.Plan
+	ProfileConfigSnapshot *core.MultiAppConfig
+	UseProfileSnapshot    bool
 }

 func buildCredentialProvider(deps credentialDeps) *credential.CredentialProvider {
+	plan := runtimeplan.Ensure(deps.RuntimePlan)
 	providers := extcred.Providers()
-	defaultAcct := credential.NewDefaultAccountProvider(deps.Keychain, deps.Profile)
-	defaultToken := credential.NewDefaultTokenProvider(defaultAcct, deps.HttpClient, deps.ErrOut)
+	localAcct := credential.NewDefaultAccountProvider(deps.Keychain, deps.Profile)
+	if deps.UseProfileSnapshot {
+		localAcct = credential.NewDefaultAccountProviderFromSnapshot(deps.Keychain, deps.Profile, deps.ProfileConfigSnapshot)
+	}
+	localToken := credential.NewDefaultTokenProvider(localAcct, deps.HttpClient, deps.ErrOut)
+	var defaultAcct credential.DefaultAccountResolver = localAcct
+	var defaultToken credential.DefaultTokenResolver = localToken
+
+	if startupErr := plan.StartupError(); startupErr != nil {
+		providers = []extcred.Provider{&runtimePlanErrorProvider{err: startupErr}}
+		defaultAcct = nil
+		defaultToken = nil
+	} else if provider, replace := plan.CredentialProvider(); provider != nil {
+		if replace {
+			providers = []extcred.Provider{provider}
+			defaultAcct = nil
+			defaultToken = nil
+		} else {
+			providers = append([]extcred.Provider{provider}, providers...)
+		}
+	}
 	// NOTE: Do not pass deps.ErrOut as warnOut. Credential resolution
 	// happens before the command runs, so any plain-text warning written
 	// to stderr would break the JSON envelope contract that AI agents
@@ -288,3 +273,15 @@ func buildCredentialProvider(deps credentialDeps) *credential.CredentialProvider
 	// warning is safe.
 	return credential.NewCredentialProvider(providers, defaultAcct, defaultToken, deps.HttpClient)
 }
+
+type runtimePlanErrorProvider struct{ err error }
+
+func (p *runtimePlanErrorProvider) Name() string { return "runtime-policy" }
+
+func (p *runtimePlanErrorProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
+	return nil, p.err
+}
+
+func (p *runtimePlanErrorProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
+	return nil, p.err
+}
--- a/internal/cmdutil/factory_default_test.go
+++ b/internal/cmdutil/factory_default_test.go
@@ -6,6 +6,7 @@ package cmdutil
 import (
 	"context"
 	"errors"
+	"path/filepath"
 	"testing"

 	"github.com/larksuite/cli/errs"
@@ -14,6 +15,9 @@ import (
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/envvars"
+	"github.com/larksuite/cli/internal/runtimebootstrap"
+	"github.com/larksuite/cli/internal/runtimeplan"
+	"github.com/larksuite/cli/internal/vfs"
 	"github.com/larksuite/cli/internal/vfs/localfileio"
 )

@@ -213,3 +217,63 @@ func TestNewDefault_FileIOProviderDoesNotResolveDuringInitialization(t *testing.
 		t.Fatalf("ResolveFileIO() calls after explicit resolve = %d, want 1", provider.resolveCalls)
 	}
 }
+
+func TestRuntimePlanMetadataPolicyIsEnforcedByFactory(t *testing.T) {
+	t.Setenv(envvars.CliAppID, "")
+	t.Setenv(envvars.CliAppSecret, "")
+	t.Setenv(envvars.CliUserAccessToken, "")
+	t.Setenv(envvars.CliTenantAccessToken, "")
+
+	originalRemote := initRegistryWithBrand
+	originalEmbedded := initEmbeddedRegistryWithBrand
+	t.Cleanup(func() {
+		initRegistryWithBrand = originalRemote
+		initEmbeddedRegistryWithBrand = originalEmbedded
+	})
+
+	var remoteCalls, embeddedCalls int
+	initRegistryWithBrand = func(core.LarkBrand) { remoteCalls++ }
+	initEmbeddedRegistryWithBrand = func(core.LarkBrand) { embeddedCalls++ }
+
+	profile := &core.MultiAppConfig{Apps: []core.AppConfig{{
+		AppId:     "cli_test",
+		AppSecret: core.PlainSecret("secret"),
+		Brand:     core.BrandFeishu,
+	}}}
+	plan := runtimeplan.New(runtimeplan.Options{Metadata: runtimeplan.MetadataEmbeddedOnly})
+	f := NewDefaultWithRuntimePlan(nil, InvocationContext{}, profile, plan)
+	if _, err := f.Config(); err != nil {
+		t.Fatalf("Config() error = %v", err)
+	}
+	if remoteCalls != 0 || embeddedCalls != 1 {
+		t.Fatalf("registry init calls = remote:%d embedded:%d, want remote:0 embedded:1", remoteCalls, embeddedCalls)
+	}
+}
+
+func TestCLICompositionPreservesEnvironmentCredentialsWhenProfileIsUnreadable(t *testing.T) {
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	t.Setenv(envvars.CliExternalCredentialConfig,
+		filepath.Join(configDir, "missing-external-credential.json"))
+	t.Setenv(envvars.CliAppID, "cli_env")
+	t.Setenv(envvars.CliAppSecret, "env-secret")
+	t.Setenv(envvars.CliUserAccessToken, "")
+	t.Setenv(envvars.CliTenantAccessToken, "")
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	if err := vfs.MkdirAll(core.GetConfigPath(), 0o700); err != nil {
+		t.Fatal(err)
+	}
+
+	startup := runtimebootstrap.Resolve("")
+	if err := startup.Plan.StartupError(); err != nil {
+		t.Fatalf("runtime bootstrap changed legacy environment fallback: %v", err)
+	}
+	f := NewDefaultWithRuntimePlan(nil, InvocationContext{}, startup.ProfileConfig, startup.Plan)
+	account, err := f.Credential.ResolveAccount(context.Background())
+	if err != nil {
+		t.Fatalf("ResolveAccount() error = %v", err)
+	}
+	if account.AppID != "cli_env" {
+		t.Fatalf("account AppID = %q, want environment account", account.AppID)
+	}
+}
--- a/internal/cmdutil/factory_external_credential_test.go
+++ b/internal/cmdutil/factory_external_credential_test.go
@@ -0,0 +1,261 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+//go:build extended
+
+package cmdutil
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"os"
+	"testing"
+
+	_ "github.com/larksuite/cli/extension/credential/env"
+	exttransport "github.com/larksuite/cli/extension/transport"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/envvars"
+	"github.com/larksuite/cli/internal/externalcredential"
+	"github.com/larksuite/cli/internal/i18n"
+	"github.com/larksuite/cli/internal/requestcontext"
+	"github.com/larksuite/cli/internal/riskcontrol"
+	"github.com/larksuite/cli/internal/runtimebootstrap"
+	internaltransport "github.com/larksuite/cli/internal/transport"
+)
+
+func newFactoryFromRuntimeBootstrap(streams *IOStreams, inv InvocationContext) *Factory {
+	startup := runtimebootstrap.Resolve(inv.Profile)
+	return NewDefaultWithRuntimePlan(streams, inv, startup.ProfileConfig, startup.Plan)
+}
+
+func writePlatformProxyConfiguration(t *testing.T, config *core.MultiAppConfig, appID string) {
+	t.Helper()
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	systemPath := configDir + "/external-credential.json"
+	t.Setenv(envvars.CliExternalCredentialConfig, systemPath)
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	if err := core.SaveMultiAppConfig(config); err != nil {
+		t.Fatal(err)
+	}
+	system := externalcredential.Config{
+		Version: 1, Mode: externalcredential.ModePlatformProxy,
+		RemoteEndpoint: "https://credentials.example.com",
+		Applications:   []externalcredential.Application{{Brand: core.BrandFeishu, AppID: appID}},
+	}
+	data, err := json.Marshal(system)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(systemPath, data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestFactoryInstallsExternalProxyTransport(t *testing.T) {
+	t.Setenv(internaltransport.EnvNoProxy, "")
+	previousTransport := http.DefaultTransport
+	var observed *http.Request
+	http.DefaultTransport = roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		observed = req.Clone(req.Context())
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Header:     make(http.Header),
+			Body:       http.NoBody,
+			Request:    req,
+		}, nil
+	})
+	t.Cleanup(func() { http.DefaultTransport = previousTransport })
+
+	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
+		Name: "sandbox", AppId: "cli_test", Brand: core.BrandFeishu, Lang: i18n.LangJaJP, Users: []core.AppUser{},
+	}}}
+	writePlatformProxyConfiguration(t, config, "cli_test")
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	resolved, err := factory.Config()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if resolved.Lang != i18n.LangJaJP {
+		t.Fatalf("resolved Lang = %q, want Profile Lang %q", resolved.Lang, i18n.LangJaJP)
+	}
+	client, err := factory.HttpClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := requestcontext.WithIdentity(context.Background(), core.AsUser)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
+		"https://open.feishu.cn/open-apis/test/v1/ping", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if observed == nil ||
+		observed.URL.String() != "https://credentials.example.com/lark-cli/v1/openapi/open-apis/test/v1/ping" ||
+		observed.Header.Get(externalcredential.HeaderAppID) != "cli_test" ||
+		observed.Header.Get(externalcredential.HeaderIdentity) != "user" ||
+		observed.Header.Get(riskcontrol.HeaderOSType) == "" {
+		t.Fatalf("managed data-plane request = %#v", observed)
+	}
+}
+
+func TestFactoryKeepsEnvironmentProviderWhenLegacyConfigIsMalformed(t *testing.T) {
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	t.Setenv(envvars.CliAppID, "cli_env")
+	t.Setenv(envvars.CliTenantAccessToken, "tenant-token")
+	t.Setenv(envvars.CliAppSecret, "")
+	t.Setenv(envvars.CliUserAccessToken, "")
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	if err := os.WriteFile(core.GetConfigPath(), []byte(`{"apps":[`), 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	account, err := factory.Credential.ResolveAccount(context.Background())
+	if err != nil {
+		t.Fatalf("ResolveAccount() error = %v", err)
+	}
+	if account.AppID != "cli_env" {
+		t.Fatalf("account AppID = %q, want environment account", account.AppID)
+	}
+}
+
+func TestFactoryKeepsEnvironmentProviderWhenLegacyConfigIsUnreadable(t *testing.T) {
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	t.Setenv(envvars.CliAppID, "cli_env")
+	t.Setenv(envvars.CliTenantAccessToken, "tenant-token")
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	if err := os.Mkdir(core.GetConfigPath(), 0700); err != nil {
+		t.Fatal(err)
+	}
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	account, err := factory.Credential.ResolveAccount(context.Background())
+	if err != nil {
+		t.Fatalf("ResolveAccount() error = %v", err)
+	}
+	if account.AppID != "cli_env" {
+		t.Fatalf("account AppID = %q, want environment account", account.AppID)
+	}
+}
+
+func TestFactoryRejectsMisspelledExternalCredentialInsteadOfFallingBack(t *testing.T) {
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	t.Setenv(envvars.CliAppID, "cli_env")
+	t.Setenv(envvars.CliTenantAccessToken, "tenant-token")
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	config := `{"apps":[{"appId":"cli_external","brand":"feishu","users":[],"externalCredentials":{"mode":"proxy"}}]}`
+	if err := os.WriteFile(core.GetConfigPath(), []byte(config), 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	if _, err := factory.Credential.ResolveAccount(context.Background()); err == nil {
+		t.Fatal("expected misspelled external credential profile to fail closed")
+	}
+}
+
+func TestFactoryRejectsNullExternalCredentialInsteadOfFallingBack(t *testing.T) {
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	t.Setenv(envvars.CliAppID, "cli_env")
+	t.Setenv(envvars.CliTenantAccessToken, "tenant-token")
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	config := `{"apps":[{"appId":"cli_external","brand":"feishu","users":[],"externalCredential":null}]}`
+	if err := os.WriteFile(core.GetConfigPath(), []byte(config), 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	if _, err := factory.Credential.ResolveAccount(context.Background()); err == nil {
+		t.Fatal("expected null external credential profile to fail closed")
+	}
+}
+
+func TestFactoryRejectsMissingSelectedExternalCredentialProfile(t *testing.T) {
+	t.Setenv(envvars.CliAppID, "cli_env")
+	t.Setenv(envvars.CliTenantAccessToken, "tenant-token")
+	config := &core.MultiAppConfig{
+		CurrentApp: "missing",
+		Apps: []core.AppConfig{{
+			Name: "sandbox", AppId: "cli_external", Brand: core.BrandFeishu, Users: []core.AppUser{},
+		}},
+	}
+	writePlatformProxyConfiguration(t, config, "cli_external")
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	if _, err := factory.Credential.ResolveAccount(context.Background()); err == nil {
+		t.Fatal("expected missing selected external credential profile to fail closed")
+	}
+}
+
+func TestFactoryUsesOneProfileSnapshotForCredentialAndTransport(t *testing.T) {
+	configDir := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", configDir)
+	systemPath := configDir + "/external-credential.json"
+	t.Setenv(envvars.CliExternalCredentialConfig, systemPath)
+	for _, name := range []string{
+		envvars.CliAppID, envvars.CliAppSecret, envvars.CliUserAccessToken,
+		envvars.CliTenantAccessToken, envvars.CliAuthProxy, envvars.CliProxyKey,
+		envvars.CliProxyEnable, envvars.CliProxyAddress, envvars.CliCAPath,
+	} {
+		t.Setenv(name, "")
+	}
+	core.SetCurrentWorkspace(core.WorkspaceLocal)
+	initial := &core.MultiAppConfig{Apps: []core.AppConfig{{
+		Name: "initial", AppId: "cli_initial", AppSecret: core.PlainSecret("initial-secret"),
+		Brand: core.BrandFeishu, Users: []core.AppUser{},
+	}}}
+	if err := core.SaveMultiAppConfig(initial); err != nil {
+		t.Fatal(err)
+	}
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{In: nil, Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	replacement := &core.MultiAppConfig{Apps: []core.AppConfig{{
+		Name: "replacement", AppId: "cli_proxy", Brand: core.BrandFeishu, Users: []core.AppUser{},
+	}}}
+	if err := core.SaveMultiAppConfig(replacement); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(systemPath, []byte(`{"version":1,"mode":"platform_proxy","remoteEndpoint":"https://credentials.example.com","applications":[{"brand":"feishu","appId":"cli_proxy"}]}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	account, err := factory.Credential.ResolveAccount(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if account.AppID != "cli_initial" {
+		t.Fatalf("account AppID = %q, want immutable snapshot cli_initial", account.AppID)
+	}
+	client, err := factory.HttpClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := client.Transport.(*externalcredential.Transport); ok {
+		t.Fatalf("transport = %T, should match initial non-proxy profile", client.Transport)
+	}
+}
+
+func TestFactoryRejectsProxyModeWithTransportExtension(t *testing.T) {
+	exttransport.Register(&stubTransportProvider{})
+	t.Cleanup(func() { exttransport.Register(nil) })
+	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
+		AppId: "cli_test", Brand: core.BrandFeishu, Users: []core.AppUser{},
+	}}}
+	writePlatformProxyConfiguration(t, config, "cli_test")
+
+	factory := newFactoryFromRuntimeBootstrap(&IOStreams{Out: io.Discard, ErrOut: io.Discard}, InvocationContext{})
+	if _, err := factory.HttpClient(); err == nil {
+		t.Fatal("expected proxy mode and transport extension to be rejected")
+	}
+}
--- a/internal/cmdutil/factory_http_test.go
+++ b/internal/cmdutil/factory_http_test.go
@@ -4,20 +4,13 @@
 package cmdutil

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

-	"github.com/larksuite/cli/errs"
-	exttransport "github.com/larksuite/cli/extension/transport"
 	"github.com/larksuite/cli/internal/core"
-	internaltransport "github.com/larksuite/cli/internal/transport"
 )

-func TestCachedHTTPClientFunc_ReturnsSameInstance(t *testing.T) {
+func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
 	isEnabled := false
 	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
 	f.IOStreams.ErrOut = io.Discard
@@ -40,7 +33,7 @@ func TestCachedHTTPClientFunc_ReturnsSameInstance(t *testing.T) {
 	}
 }

-func TestCachedHTTPClientFunc_HasTimeout(t *testing.T) {
+func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
 	isEnabled := false
 	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
 	f.IOStreams.ErrOut = io.Discard
@@ -51,7 +44,7 @@ func TestCachedHTTPClientFunc_HasTimeout(t *testing.T) {
 	}
 }

-func TestCachedHTTPClientFunc_HasRedirectPolicy(t *testing.T) {
+func TestCachedHttpClientFunc_HasRedirectPolicy(t *testing.T) {
 	isEnabled := false
 	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
 	f.IOStreams.ErrOut = io.Discard
@@ -61,283 +54,3 @@ func TestCachedHTTPClientFunc_HasRedirectPolicy(t *testing.T) {
 		t.Error("expected CheckRedirect to be set (safeRedirectPolicy)")
 	}
 }
-
-func TestFactoryExternalHTTPClientClonesExistingClient(t *testing.T) {
-	base := &http.Client{Timeout: 17, CheckRedirect: safeRedirectPolicy}
-	factory := &Factory{HttpClient: func() (*http.Client, error) { return base, nil }}
-
-	external, err := factory.ExternalHTTPClient()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if external == base {
-		t.Fatal("ExternalHTTPClient returned the cached client instead of a clone")
-	}
-	if external.Timeout != base.Timeout || external.CheckRedirect == nil {
-		t.Fatal("ExternalHTTPClient did not preserve client policy")
-	}
-	if base.Transport != nil {
-		t.Fatal("ExternalHTTPClient mutated the cached client's transport")
-	}
-}
-
-type platformOnlyStubProvider struct {
-	*stubTransportProvider
-}
-
-func (*platformOnlyStubProvider) SupportsRequestClass(class exttransport.RequestClass) bool {
-	return class == exttransport.RequestClassPlatform
-}
-
-func TestFactoryHTTPClientRoutesPoliciesByRequestClass(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_NO_PROXY", "1")
-
-	interceptor := &headerCapturingInterceptor{}
-	exttransport.Register(&platformOnlyStubProvider{stubTransportProvider: &stubTransportProvider{interceptor: interceptor}})
-	t.Cleanup(func() { exttransport.Register(nil) })
-
-	received := make(chan http.Header, 2)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		received <- req.Header.Clone()
-		w.WriteHeader(http.StatusNoContent)
-	}))
-	t.Cleanup(server.Close)
-
-	factory := &Factory{IOStreams: &IOStreams{ErrOut: io.Discard}}
-	client, err := cachedHttpClientFunc(factory, nil)()
-	if err != nil {
-		t.Fatal(err)
-	}
-	factory.HttpClient = func() (*http.Client, error) { return client, nil }
-	platformClient := internaltransport.ClientForRequestClass(client, exttransport.RequestClassPlatform)
-	externalClient, err := factory.ExternalHTTPClient()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, client := range []*http.Client{platformClient, externalClient} {
-		resp, err := client.Get(server.URL)
-		if err != nil {
-			t.Fatal(err)
-		}
-		resp.Body.Close()
-	}
-
-	platformHeaders := <-received
-	if got := platformHeaders.Get("X-Custom-Trace"); got != "ext-trace-123" {
-		t.Fatalf("platform extension header = %q, want ext-trace-123", got)
-	}
-	if got := platformHeaders.Get(HeaderSource); got != SourceValue {
-		t.Fatalf("platform security header = %q, want %q", got, SourceValue)
-	}
-
-	externalHeaders := <-received
-	if got := externalHeaders.Get("X-Custom-Trace"); got != "" {
-		t.Fatalf("external request leaked extension header %q", got)
-	}
-	for header, values := range BaseSecurityHeaders() {
-		if len(values) == 0 {
-			continue
-		}
-		want := values[len(values)-1]
-		if got := externalHeaders.Get(header); got != want {
-			t.Fatalf("external security header %s = %q, want preserved value %q", header, got, want)
-		}
-	}
-}
-
-func TestFactoryExternalHTTPClientDoesNotParsePlatformErrorProtocol(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_NO_PROXY", "1")
-	exttransport.Register(nil)
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = io.WriteString(w, `{"code":21000,"msg":"application-defined external response","data":{"cli_hint":"external-defined"}}`)
-	}))
-	t.Cleanup(server.Close)
-
-	factory := &Factory{IOStreams: &IOStreams{ErrOut: io.Discard}}
-	client, err := cachedHttpClientFunc(factory, nil)()
-	if err != nil {
-		t.Fatal(err)
-	}
-	factory.HttpClient = func() (*http.Client, error) { return client, nil }
-
-	platform := internaltransport.ClientForRequestClass(client, exttransport.RequestClassPlatform)
-	if _, err := platform.Get(server.URL); err == nil {
-		t.Fatal("platform request error = nil, want security policy classification")
-	} else {
-		var policyErr *errs.SecurityPolicyError
-		if !errors.As(err, &policyErr) {
-			t.Fatalf("platform request error type = %T, want *errs.SecurityPolicyError", err)
-		}
-	}
-
-	external, err := factory.ExternalHTTPClient()
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp, err := external.Get(server.URL)
-	if err != nil {
-		t.Fatalf("external request parsed platform error protocol: %v", err)
-	}
-	resp.Body.Close()
-}
-
-func TestSafeRedirectPolicyAllowsBodylessCrossOriginGetAndStripsCredentials(t *testing.T) {
-	original, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/start", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodGet, "https://cdn.example.com/file", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, header := range []string{"Authorization", "X-Lark-MCP-UAT", "X-Lark-MCP-TAT"} {
-		redirect.Header.Set(header, "secret")
-	}
-
-	if err := safeRedirectPolicy(redirect, []*http.Request{original}); err != nil {
-		t.Fatalf("safeRedirectPolicy() error = %v, want allowed GET redirect", err)
-	}
-	for _, header := range []string{"Authorization", "X-Lark-MCP-UAT", "X-Lark-MCP-TAT"} {
-		if got := redirect.Header.Get(header); got != "" {
-			t.Fatalf("redirect retained %s=%q", header, got)
-		}
-	}
-}
-
-func TestSafeRedirectPolicyRejectsHTTPSDowngrade(t *testing.T) {
-	original, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/start", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodGet, "http://open.feishu.cn/next", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = safeRedirectPolicy(redirect, []*http.Request{original})
-	if err == nil || !strings.Contains(err.Error(), "HTTPS") {
-		t.Fatalf("safeRedirectPolicy() error = %v, want HTTPS downgrade rejection", err)
-	}
-	requireRedirectProblem(t, err, errs.CategoryPolicy, errs.SubtypeAccessDenied)
-}
-
-func TestSafeRedirectPolicyRejectsCrossOriginMethod(t *testing.T) {
-	original, err := http.NewRequest(http.MethodPost, "https://accounts.feishu.cn/token", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodPost, "https://external.example/token", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = safeRedirectPolicy(redirect, []*http.Request{original})
-	if err == nil || !strings.Contains(err.Error(), "HTTP method POST") {
-		t.Fatalf("safeRedirectPolicy() error = %v, want cross-origin method rejection", err)
-	}
-	requireRedirectProblem(t, err, errs.CategoryPolicy, errs.SubtypeAccessDenied)
-}
-
-func TestSafeRedirectPolicyRejectsCrossOriginRequestBody(t *testing.T) {
-	original, err := http.NewRequest(http.MethodGet, "https://accounts.feishu.cn/token", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodGet, "https://external.example/token", strings.NewReader("client_secret=secret"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = safeRedirectPolicy(redirect, []*http.Request{original})
-	if err == nil || !strings.Contains(err.Error(), "request body") {
-		t.Fatalf("safeRedirectPolicy() error = %v, want cross-origin body rejection", err)
-	}
-	requireRedirectProblem(t, err, errs.CategoryPolicy, errs.SubtypeAccessDenied)
-}
-
-func TestSafeRedirectPolicyRejectsTooManyRedirects(t *testing.T) {
-	err := safeRedirectPolicy(&http.Request{}, make([]*http.Request, 10))
-	if err == nil || err.Error() != "too many redirects" {
-		t.Fatalf("safeRedirectPolicy() error = %v, want redirect limit rejection", err)
-	}
-	requireRedirectProblem(t, err, errs.CategoryNetwork, errs.SubtypeNetworkTransport)
-}
-
-func TestSafeRedirectPolicyTreatsDefaultHTTPSPortAsSameOrigin(t *testing.T) {
-	original, err := http.NewRequest(http.MethodPost, "https://accounts.feishu.cn/token", strings.NewReader("secret"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodPost, "https://accounts.feishu.cn:443/token-next", strings.NewReader("secret"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := safeRedirectPolicy(redirect, []*http.Request{original}); err != nil {
-		t.Fatalf("safeRedirectPolicy() error = %v, want same-origin redirect", err)
-	}
-}
-
-func TestSafeRedirectPolicyKeepsCredentialsStrippedAcrossExternalHops(t *testing.T) {
-	original, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/start", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	previous, err := http.NewRequest(http.MethodGet, "https://cdn.example.com/first", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodGet, "https://cdn.example.com/second", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect.Header.Set("Authorization", "Bearer copied-from-initial-request")
-
-	if err := safeRedirectPolicy(redirect, []*http.Request{original, previous}); err != nil {
-		t.Fatalf("safeRedirectPolicy() error = %v, want same-CDN redirect", err)
-	}
-	if got := redirect.Header.Get("Authorization"); got != "" {
-		t.Fatalf("redirect retained Authorization=%q outside the initial origin", got)
-	}
-}
-
-func TestSafeRedirectPolicyRejectsDowngradeOnLaterHop(t *testing.T) {
-	original, err := http.NewRequest(http.MethodGet, "http://source.example/start", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	previous, err := http.NewRequest(http.MethodGet, "https://cdn.example.com/secure", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	redirect, err := http.NewRequest(http.MethodGet, "http://cdn.example.com/plain", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = safeRedirectPolicy(redirect, []*http.Request{original, previous})
-	if err == nil || !strings.Contains(err.Error(), "HTTPS") {
-		t.Fatalf("safeRedirectPolicy() error = %v, want later-hop HTTPS downgrade rejection", err)
-	}
-	requireRedirectProblem(t, err, errs.CategoryPolicy, errs.SubtypeAccessDenied)
-}
-
-func requireRedirectProblem(t *testing.T, err error, category errs.Category, subtype errs.Subtype) {
-	t.Helper()
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error type = %T, want typed error", err)
-	}
-	if problem.Category != category || problem.Subtype != subtype {
-		t.Fatalf(
-			"error category/subtype = %s/%s, want %s/%s",
-			problem.Category,
-			problem.Subtype,
-			category,
-			subtype,
-		)
-	}
-}
--- a/internal/cmdutil/factory_proxy_warn_test.go
+++ b/internal/cmdutil/factory_proxy_warn_test.go
@@ -34,9 +34,9 @@ var proxyWarnGateCases = []struct {
 	{"non-terminal stderr stays silent", false, 0},
 }

-// TestCachedHTTPClientFunc_ProxyWarnGate verifies the HTTP client init path
+// TestCachedHttpClientFunc_ProxyWarnGate verifies the http-client init path
 // invokes WarnIfProxied only when stderr is an interactive terminal.
-func TestCachedHTTPClientFunc_ProxyWarnGate(t *testing.T) {
+func TestCachedHttpClientFunc_ProxyWarnGate(t *testing.T) {
 	isEnabled := false
 	for _, tc := range proxyWarnGateCases {
 		t.Run(tc.name, func(t *testing.T) {
--- a/internal/cmdutil/factory_test.go
+++ b/internal/cmdutil/factory_test.go
@@ -17,6 +17,7 @@ import (
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/runtimeplan"
 )

 // newCmdWithAsFlag creates a cobra.Command with a --as string flag for testing.
@@ -413,13 +414,13 @@ func (s *stubExtProvider) ResolveToken(_ context.Context, _ extcred.TokenSpec) (
 	return nil, nil
 }

-func TestRequireBuiltinCredentialProvider_BlocksExternalProvider(t *testing.T) {
+func TestRequireRuntimeCapabilities_BlocksProviderOwnedCredentials(t *testing.T) {
 	stub := &stubExtProvider{name: "env", acct: &extcred.Account{AppID: "app"}}
 	cred := credential.NewCredentialProvider([]extcred.Provider{stub}, nil, nil, nil)
 	f, _, _, _ := TestFactory(t, nil)
 	f.Credential = cred

-	err := f.RequireBuiltinCredentialProvider(context.Background(), "auth")
+	err := f.RequireRuntimeCapabilities(context.Background(), "auth", runtimeplan.CapabilityLocalCredentialManagement)
 	if err == nil {
 		t.Fatal("expected error, got nil")
 	}
@@ -439,25 +440,44 @@ func TestRequireBuiltinCredentialProvider_BlocksExternalProvider(t *testing.T) {
 	}
 }

-func TestRequireBuiltinCredentialProvider_AllowsBuiltinProvider(t *testing.T) {
+func TestRequireRuntimeCapabilities_DefaultCommandLabel(t *testing.T) {
+	stub := &stubExtProvider{name: "env", acct: &extcred.Account{AppID: "app"}}
+	cred := credential.NewCredentialProvider([]extcred.Provider{stub}, nil, nil, nil)
+	f, _, _, _ := TestFactory(t, nil)
+	f.Credential = cred
+
+	err := f.RequireRuntimeCapabilities(context.Background(), "", runtimeplan.CapabilityLocalCredentialManagement)
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error type = %T, want typed error", err)
+	}
+	if problem.Subtype != errs.SubtypeFailedPrecondition {
+		t.Errorf("subtype = %q, want %q", problem.Subtype, errs.SubtypeFailedPrecondition)
+	}
+}
+
+func TestRequireRuntimeCapabilities_AllowsLocalCredentialProvider(t *testing.T) {
 	// No extension providers → built-in path → no error
 	f, _, _, _ := TestFactory(t, nil)
-	err := f.RequireBuiltinCredentialProvider(context.Background(), "auth")
+	err := f.RequireRuntimeCapabilities(context.Background(), "auth", runtimeplan.CapabilityLocalCredentialManagement)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }

-func TestRequireBuiltinCredentialProvider_NilCredential(t *testing.T) {
+func TestRequireRuntimeCapabilities_AllowsNilCredential(t *testing.T) {
 	f, _, _, _ := TestFactory(t, nil)
 	f.Credential = nil
-	err := f.RequireBuiltinCredentialProvider(context.Background(), "auth")
+	err := f.RequireRuntimeCapabilities(context.Background(), "auth", runtimeplan.CapabilityLocalCredentialManagement)
 	if err != nil {
 		t.Fatalf("unexpected error with nil Credential: %v", err)
 	}
 }

-func TestRequireBuiltinCredentialProvider_PropagatesProviderError(t *testing.T) {
+func TestRequireRuntimeCapabilities_PropagatesProviderError(t *testing.T) {
 	sentinel := errors.New("provider unavailable")
 	stub := &stubExtProvider{name: "env", err: sentinel}
 	cred := credential.NewCredentialProvider([]extcred.Provider{stub}, nil, nil, nil)
@@ -465,7 +485,7 @@ func TestRequireBuiltinCredentialProvider_PropagatesProviderError(t *testing.T)
 	f, _, _, _ := TestFactory(t, nil)
 	f.Credential = cred

-	err := f.RequireBuiltinCredentialProvider(context.Background(), "auth")
+	err := f.RequireRuntimeCapabilities(context.Background(), "auth", runtimeplan.CapabilityLocalCredentialManagement)
 	if !errors.Is(err, sentinel) {
 		t.Fatalf("error = %v, want sentinel", err)
 	}
--- a/internal/cmdutil/runtime_capabilities.go
+++ b/internal/cmdutil/runtime_capabilities.go
@@ -0,0 +1,112 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"context"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/runtimeplan"
+)
+
+const (
+	runtimeCapabilitiesAnnotation = "lark:runtimeCapabilities"
+	noRuntimeCapabilities         = "-"
+)
+
+// SetRuntimeCapabilities declares the runtime surfaces required by a command.
+// A zero-capability declaration explicitly overrides a parent default.
+func SetRuntimeCapabilities(cmd *cobra.Command, capabilities ...runtimeplan.Capability) {
+	if cmd == nil {
+		return
+	}
+	if cmd.Annotations == nil {
+		cmd.Annotations = make(map[string]string)
+	}
+	if len(capabilities) == 0 {
+		cmd.Annotations[runtimeCapabilitiesAnnotation] = noRuntimeCapabilities
+		return
+	}
+	values := make([]string, 0, len(capabilities))
+	for _, capability := range capabilities {
+		if capability != "" {
+			values = append(values, string(capability))
+		}
+	}
+	if len(values) == 0 {
+		cmd.Annotations[runtimeCapabilitiesAnnotation] = noRuntimeCapabilities
+		return
+	}
+	cmd.Annotations[runtimeCapabilitiesAnnotation] = strings.Join(values, ",")
+}
+
+// GetRuntimeCapabilities resolves the nearest explicit declaration from the
+// leaf command toward its parents.
+func GetRuntimeCapabilities(cmd *cobra.Command) []runtimeplan.Capability {
+	for current := cmd; current != nil; current = current.Parent() {
+		raw, ok := current.Annotations[runtimeCapabilitiesAnnotation]
+		if !ok {
+			continue
+		}
+		if raw == "" || raw == noRuntimeCapabilities {
+			return nil
+		}
+		parts := strings.Split(raw, ",")
+		out := make([]runtimeplan.Capability, 0, len(parts))
+		for _, part := range parts {
+			if capability := strings.TrimSpace(part); capability != "" {
+				out = append(out, runtimeplan.Capability(capability))
+			}
+		}
+		return out
+	}
+	return nil
+}
+
+// RequireRuntimeCapabilities applies the invocation plan and the selected
+// credential source to a command's source-neutral capability declaration.
+func (f *Factory) RequireRuntimeCapabilities(
+	ctx context.Context,
+	command string,
+	capabilities ...runtimeplan.Capability,
+) error {
+	if f == nil {
+		return nil
+	}
+	plan := runtimeplan.Ensure(f.runtimePlan)
+	for _, capability := range capabilities {
+		if err := plan.Require(capability); err != nil {
+			return err
+		}
+		if capability != runtimeplan.CapabilityLocalCredentialManagement || f.Credential == nil {
+			continue
+		}
+		providerName, err := f.Credential.ActiveExtensionProviderName(ctx)
+		if err != nil {
+			return err
+		}
+		if providerName == "" {
+			continue
+		}
+		if command == "" {
+			command = "credential management"
+		}
+		return errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"%q cannot manage credentials owned by provider %q", command, providerName).
+			WithHint("manage authorization through the active credential provider, or use a local Profile credential source")
+	}
+	return nil
+}
+
+// RequireCommandRuntimeCapabilities checks the declaration resolved for cmd.
+func (f *Factory) RequireCommandRuntimeCapabilities(ctx context.Context, cmd *cobra.Command) error {
+	command := "credential management"
+	if cmd != nil {
+		command = cmd.CommandPath()
+	}
+	return f.RequireRuntimeCapabilities(ctx, command, GetRuntimeCapabilities(cmd)...)
+}
--- a/internal/cmdutil/runtime_capabilities_test.go
+++ b/internal/cmdutil/runtime_capabilities_test.go
@@ -0,0 +1,96 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package cmdutil
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/runtimeplan"
+	"github.com/spf13/cobra"
+)
+
+func TestRuntimeCapabilitiesUseNearestDeclaration(t *testing.T) {
+	parent := &cobra.Command{Use: "auth"}
+	SetRuntimeCapabilities(parent, runtimeplan.CapabilityLocalCredentialManagement)
+
+	inherited := &cobra.Command{Use: "login"}
+	parent.AddCommand(inherited)
+	got := GetRuntimeCapabilities(inherited)
+	if len(got) != 1 || got[0] != runtimeplan.CapabilityLocalCredentialManagement {
+		t.Fatalf("inherited capabilities = %v", got)
+	}
+
+	diagnostic := &cobra.Command{Use: "status"}
+	SetRuntimeCapabilities(diagnostic)
+	parent.AddCommand(diagnostic)
+	if got := GetRuntimeCapabilities(diagnostic); len(got) != 0 {
+		t.Fatalf("explicit empty capabilities = %v", got)
+	}
+}
+
+func TestRequireRuntimeCapabilitiesUsesPlan(t *testing.T) {
+	denied := errors.New("events denied")
+	plan := runtimeplan.New(runtimeplan.Options{
+		Capabilities: func(capability runtimeplan.Capability) error {
+			if capability == runtimeplan.CapabilityRealtimeEvents {
+				return denied
+			}
+			return nil
+		},
+	})
+	f, _, _, _ := TestFactoryWithRuntimePlan(t, nil, plan)
+
+	err := f.RequireRuntimeCapabilities(context.Background(), "event consume", runtimeplan.CapabilityRealtimeEvents)
+	if !errors.Is(err, denied) {
+		t.Fatalf("error = %v, want plan denial", err)
+	}
+}
+
+func TestRequireRuntimeCapabilitiesKeepsPurelyLocalCommandsAvailable(t *testing.T) {
+	startupErr := errors.New("managed runtime bootstrap failed")
+	f, _, _, _ := TestFactoryWithRuntimePlan(t, nil,
+		runtimeplan.Failed(startupErr, runtimeplan.MetadataEmbeddedOnly))
+
+	if err := f.RequireRuntimeCapabilities(context.Background(), "local recovery"); err != nil {
+		t.Fatalf("capability-free local command = %v, want available", err)
+	}
+}
+
+func TestRequireRuntimeCapabilitiesBlocksProviderOwnedCredentials(t *testing.T) {
+	provider := &runtimeCapabilityProvider{}
+	f, _, _, _ := TestFactory(t, nil)
+	f.Credential = credential.NewCredentialProvider(
+		[]extcred.Provider{provider}, nil, nil, nil,
+	)
+
+	err := f.RequireRuntimeCapabilities(
+		context.Background(),
+		"auth login",
+		runtimeplan.CapabilityLocalCredentialManagement,
+	)
+	if err == nil {
+		t.Fatal("expected provider-owned credentials to reject local management")
+	}
+	if err := f.RequireRuntimeCapabilities(
+		context.Background(),
+		"profile use",
+		runtimeplan.CapabilityLocalProfileMutation,
+	); err != nil {
+		t.Fatalf("generic provider unexpectedly blocked Standard Profile mutation: %v", err)
+	}
+}
+
+type runtimeCapabilityProvider struct{}
+
+func (*runtimeCapabilityProvider) Name() string { return "test-provider" }
+func (*runtimeCapabilityProvider) ResolveAccount(context.Context) (*extcred.Account, error) {
+	return &extcred.Account{AppID: "cli_test"}, nil
+}
+func (*runtimeCapabilityProvider) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
+	return nil, nil
+}
--- a/internal/cmdutil/testing.go
+++ b/internal/cmdutil/testing.go
@@ -17,6 +17,7 @@ import (
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/runtimeplan"
 	"github.com/larksuite/cli/internal/vfs"
 )

@@ -76,6 +77,29 @@ func TestFactory(t *testing.T, config *core.CliConfig) (*Factory, *bytes.Buffer,
 	return f, stdoutBuf, stderrBuf, reg
 }

+// TestFactoryWithRuntimePlan creates a TestFactory with an explicit
+// source-neutral runtime policy.
+func TestFactoryWithRuntimePlan(
+	t *testing.T,
+	config *core.CliConfig,
+	plan *runtimeplan.Plan,
+) (*Factory, *bytes.Buffer, *bytes.Buffer, *httpmock.Registry) {
+	t.Helper()
+	f, out, errOut, registry := TestFactory(t, config)
+	f.runtimePlan = runtimeplan.Ensure(plan)
+	return f, out, errOut, registry
+}
+
+// TestSetRuntimePlan replaces a Factory's runtime policy in tests that need to
+// preserve an existing HTTP mock registry or other custom wiring.
+func TestSetRuntimePlan(t *testing.T, f *Factory, plan *runtimeplan.Plan) {
+	t.Helper()
+	if f == nil {
+		t.Fatal("cannot install a runtime plan on a nil Factory")
+	}
+	f.runtimePlan = runtimeplan.Ensure(plan)
+}
+
 type testDefaultAcct struct {
 	config *core.CliConfig
 }
--- a/internal/cmdutil/testing_test.go
+++ b/internal/cmdutil/testing_test.go
@@ -46,7 +46,7 @@ func TestTestFactory_ReplacesGlobals(t *testing.T) {
 		URL:  "/test",
 		Body: "ok",
 	})
-	// Use the stub via Factory HttpClient.
+	// Use the stub via Factory HttpClient
 	httpClient, err := f.HttpClient()
 	if err != nil {
 		t.Fatalf("HttpClient() error: %v", err)
--- a/internal/cmdutil/transport.go
+++ b/internal/cmdutil/transport.go
@@ -4,19 +4,14 @@
 package cmdutil

 import (
+	"context"
 	"net/http"
 	"time"

+	exttransport "github.com/larksuite/cli/extension/transport"
 	"github.com/larksuite/cli/internal/transport"
 )

-var (
-	_ transport.RoundTripperDecorator = (*RetryTransport)(nil)
-	_ transport.RoundTripperDecorator = (*UserAgentTransport)(nil)
-	_ transport.RoundTripperDecorator = (*BuildHeaderTransport)(nil)
-	_ transport.RoundTripperDecorator = (*SecurityHeaderTransport)(nil)
-)
-
 // RetryTransport is an http.RoundTripper that retries on 5xx responses
 // and network errors. MaxRetries defaults to 0 (no retries).
 type RetryTransport struct {
@@ -32,16 +27,6 @@ func (t *RetryTransport) base() http.RoundTripper {
 	return transport.Fallback()
 }

-func (t *RetryTransport) BaseRoundTripper() http.RoundTripper {
-	return t.base()
-}
-
-func (t *RetryTransport) WithBaseRoundTripper(base http.RoundTripper) http.RoundTripper {
-	cloned := *t
-	cloned.Base = base
-	return &cloned
-}
-
 func (t *RetryTransport) delay() time.Duration {
 	if t.Delay > 0 {
 		return t.Delay
@@ -78,19 +63,6 @@ type UserAgentTransport struct {
 	Base http.RoundTripper
 }

-func (t *UserAgentTransport) BaseRoundTripper() http.RoundTripper {
-	if t.Base != nil {
-		return t.Base
-	}
-	return transport.Fallback()
-}
-
-func (t *UserAgentTransport) WithBaseRoundTripper(base http.RoundTripper) http.RoundTripper {
-	cloned := *t
-	cloned.Base = base
-	return &cloned
-}
-
 func (t *UserAgentTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	req = req.Clone(req.Context())
 	req.Header.Set(HeaderUserAgent, UserAgentValue())
@@ -101,25 +73,14 @@ func (t *UserAgentTransport) RoundTrip(req *http.Request) (*http.Response, error
 }

 // BuildHeaderTransport is an http.RoundTripper that force-writes the
-// X-Cli-Build header before every request. It remains in the SDK transport
-// chain as a narrow defense-in-depth layer alongside SecurityHeaderTransport.
+// X-Cli-Build header before every request. Used in the SDK transport chain,
+// where SecurityHeaderTransport is not installed, to prevent extensions from
+// tampering with the build classification. The direct HTTP chain is already
+// covered by SecurityHeaderTransport iterating BaseSecurityHeaders.
 type BuildHeaderTransport struct {
 	Base http.RoundTripper
 }

-func (t *BuildHeaderTransport) BaseRoundTripper() http.RoundTripper {
-	if t.Base != nil {
-		return t.Base
-	}
-	return transport.Fallback()
-}
-
-func (t *BuildHeaderTransport) WithBaseRoundTripper(base http.RoundTripper) http.RoundTripper {
-	cloned := *t
-	cloned.Base = base
-	return &cloned
-}
-
 func (t *BuildHeaderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	req = req.Clone(req.Context())
 	req.Header.Set(HeaderBuild, DetectBuildKind())
@@ -142,16 +103,6 @@ func (t *SecurityHeaderTransport) base() http.RoundTripper {
 	return transport.Fallback()
 }

-func (t *SecurityHeaderTransport) BaseRoundTripper() http.RoundTripper {
-	return t.base()
-}
-
-func (t *SecurityHeaderTransport) WithBaseRoundTripper(base http.RoundTripper) http.RoundTripper {
-	cloned := *t
-	cloned.Base = base
-	return &cloned
-}
-
 // RoundTrip implements http.RoundTripper.
 func (t *SecurityHeaderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	req = req.Clone(req.Context())
@@ -169,3 +120,67 @@ func (t *SecurityHeaderTransport) RoundTrip(req *http.Request) (*http.Response,
 	}
 	return t.base().RoundTrip(req)
 }
+
+// extensionMiddleware wraps the built-in transport chain with pre/post hooks.
+// The built-in chain always executes unless the extension is an
+// exttransport.AbortableInterceptor and its PreRoundTripE returns a non-nil
+// error; it cannot otherwise be skipped or overridden.
+//
+// The original request context is restored after the pre hook to prevent
+// extensions from tampering with cancellation, deadlines, or built-in values.
+// Cloning the request isolates header/URL/etc. mutations from the caller's
+// request object; req.Body is intentionally shared — extensions that consume
+// it are responsible for rewinding (see Interceptor doc).
+type extensionMiddleware struct {
+	Base    http.RoundTripper
+	Ext     exttransport.Interceptor
+	ExtName string // Provider.Name(), captured at wrap time for *AbortError.Extension
+}
+
+// RoundTrip invokes the interceptor pre hook, restores the original context,
+// executes the built-in chain (unless aborted), then calls the post hook if
+// non-nil. When the extension implements AbortableInterceptor and returns a
+// non-nil error from PreRoundTripE, the built-in chain is skipped and an
+// *exttransport.AbortError is returned; the post hook is still invoked with
+// (nil, reason) so extensions can unwind resources.
+func (m *extensionMiddleware) RoundTrip(req *http.Request) (*http.Response, error) {
+	origCtx := req.Context()
+	req = req.Clone(origCtx)
+
+	var (
+		post    func(*http.Response, error)
+		abortEr error
+	)
+	if a, ok := m.Ext.(exttransport.AbortableInterceptor); ok {
+		post, abortEr = a.PreRoundTripE(req)
+	} else {
+		post = m.Ext.PreRoundTrip(req)
+	}
+	if abortEr != nil {
+		if post != nil {
+			post(nil, abortEr)
+		}
+		return nil, &exttransport.AbortError{Extension: m.ExtName, Reason: abortEr}
+	}
+
+	req = req.WithContext(origCtx) // restore original context
+	resp, err := m.Base.RoundTrip(req)
+	if post != nil {
+		post(resp, err)
+	}
+	return resp, err
+}
+
+// wrapWithExtension wraps transport with the registered extension middleware.
+// If no extension is registered, returns transport unchanged.
+func wrapWithExtension(transport http.RoundTripper) http.RoundTripper {
+	p := exttransport.GetProvider()
+	if p == nil {
+		return transport
+	}
+	tr := p.ResolveInterceptor(context.Background())
+	if tr == nil {
+		return transport
+	}
+	return &extensionMiddleware{Base: transport, Ext: tr, ExtName: p.Name()}
+}
--- a/internal/cmdutil/transport_test.go
+++ b/internal/cmdutil/transport_test.go
@@ -14,8 +14,8 @@ import (
 	"time"

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

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

-// buildSDKTransport policy behavior
+// ---------------------------------------------------------------------------
+// wrapSDKTransport chain composition
 // ---------------------------------------------------------------------------

-func TestBuildSDKTransportAppliesSecurityHeadersToEveryRequestClass(t *testing.T) {
-	exttransport.Register(nil)
-	received := make(chan http.Header, 2)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		received <- req.Header.Clone()
-		w.WriteHeader(http.StatusNoContent)
-	}))
-	t.Cleanup(server.Close)
+func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
+	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))

-	for _, class := range []exttransport.RequestClass{
-		exttransport.RequestClassPlatform,
-		exttransport.RequestClassExternal,
-	} {
-		client := internaltransport.ClientForRequestClass(
-			&http.Client{Transport: buildSDKTransport(nil)},
-			class,
-		)
-		resp, err := client.Get(server.URL)
-		if err != nil {
-			t.Fatal(err)
-		}
-		resp.Body.Close()
-
-		headers := <-received
-		for header, values := range BaseSecurityHeaders() {
-			if len(values) == 0 {
-				continue
-			}
-			want := values[len(values)-1]
-			if got := headers.Get(header); got != want {
-				t.Fatalf("SDK %s header %s = %q, want %q", class, header, got, want)
-			}
-		}
-	}
-}
-
-func TestBuildSDKTransport_WithExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
-	interceptor := &headerCapturingInterceptor{}
-	exttransport.Register(&platformOnlyStubProvider{
-		stubTransportProvider: &stubTransportProvider{interceptor: interceptor},
-	})
-	t.Cleanup(func() { exttransport.Register(previous) })
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		w.WriteHeader(http.StatusNoContent)
-	}))
-	t.Cleanup(server.Close)
-
-	client := internaltransport.ClientForRequestClass(
-		&http.Client{Transport: buildSDKTransport(nil)},
-		exttransport.RequestClassPlatform,
-	)
-	resp, err := client.Get(server.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-	if !interceptor.preCalled || !interceptor.postCalled {
-		t.Fatal("SDK platform request did not execute extension pre/post hooks")
-	}
-}
-
-func TestBuildSDKTransport_WithoutExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
-	exttransport.Register(nil)
-	t.Cleanup(func() { exttransport.Register(previous) })
-
-	if _, ok := buildSDKTransport(nil).(*internaltransport.HTTPPolicyRouter); !ok {
-		t.Fatalf(
-			"buildSDKTransport() type = %T, want *transport.HTTPPolicyRouter",
-			buildSDKTransport(nil),
-		)
-	}
-}
-
-func TestBuildSDKTransportSupportsPolicyLeafCloning(t *testing.T) {
-	previous := exttransport.GetProvider()
-	exttransport.Register(nil)
-	t.Cleanup(func() { exttransport.Register(previous) })
-
-	base := &http.Transport{}
-	client := internaltransport.ClientForRequestClass(
-		&http.Client{Transport: buildSDKTransportWithBase(base, nil)},
-		exttransport.RequestClassExternal,
-	)
-	source, ok := client.Transport.(interface {
-		CloneHTTPTransport() (http.RoundTripper, *http.Transport, bool)
-	})
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
-		t.Fatalf("SDK request-class transport type = %T, want clone capability", client.Transport)
+		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
 	}
-	rebuilt, concrete, ok := source.CloneHTTPTransport()
-	if !ok || rebuilt == nil || concrete == nil {
-		t.Fatal("SDK policy graph could not clone its HTTP transport leaf")
+	bh, ok := sec.Base.(*BuildHeaderTransport)
+	if !ok {
+		t.Fatalf("layer after SecurityPolicy = %T, want *BuildHeaderTransport", sec.Base)
 	}
-	if concrete == base {
-		t.Fatal("SDK policy graph reused the original HTTP transport")
+	ua, ok := bh.Base.(*UserAgentTransport)
+	if !ok {
+		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
+	}
+	retry, ok := ua.Base.(*RetryTransport)
+	if !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()
+	exttransport.Register(&stubTransportProvider{})
+	t.Cleanup(func() { exttransport.Register(previous) })
+
+	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+
+	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	mid, ok := transport.(*extensionMiddleware)
+	if !ok {
+		t.Fatalf("outer transport type = %T, want *extensionMiddleware", transport)
+	}
+	sec, ok := mid.Base.(*internalauth.SecurityPolicyTransport)
+	if !ok {
+		t.Fatalf("transport type = %T, want *auth.SecurityPolicyTransport", mid.Base)
+	}
+	bh, ok := sec.Base.(*BuildHeaderTransport)
+	if !ok {
+		t.Fatalf("layer after SecurityPolicy = %T, want *BuildHeaderTransport", sec.Base)
+	}
+	ua, ok := bh.Base.(*UserAgentTransport)
+	if !ok {
+		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
+	}
+	retry, ok := ua.Base.(*RetryTransport)
+	if !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()
+	exttransport.Register(nil)
+	t.Cleanup(func() { exttransport.Register(previous) })
+
+	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
+	if !ok {
+		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
+	}
+	bh, ok := sec.Base.(*BuildHeaderTransport)
+	if !ok {
+		t.Fatalf("layer after SecurityPolicy = %T, want *BuildHeaderTransport", sec.Base)
+	}
+	ua, ok := bh.Base.(*UserAgentTransport)
+	if !ok {
+		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
+	}
+	retry, ok := ua.Base.(*RetryTransport)
+	if !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)
 	}
 }

@@ -251,7 +238,7 @@ func TestExtensionInterceptor_ExecutionOrder(t *testing.T) {
 	var base http.RoundTripper = http.DefaultTransport
 	base = &RetryTransport{Base: base}
 	base = &SecurityHeaderTransport{Base: base}
-	transport := internaltransport.WrapWithExtension(base)
+	transport := wrapWithExtension(base)
 	client := &http.Client{Transport: transport}

 	req, _ := http.NewRequest("GET", srv.URL, nil)
@@ -279,16 +266,14 @@ func TestExtensionInterceptor_ExecutionOrder(t *testing.T) {
 	}
 }

-// buildTamperingInterceptor tries to delete and spoof security headers via
-// PreRoundTrip. The SDK built-in chain must restore the real values before the
-// request leaves the process.
+// buildTamperingInterceptor tries to delete and spoof X-Cli-Build via
+// PreRoundTrip. The SDK chain's BuildHeaderTransport must restore the real
+// value before the request leaves the process.
 type buildTamperingInterceptor struct{}

 func (buildTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
 	req.Header.Del(HeaderBuild)
 	req.Header.Set(HeaderBuild, "ext-tampered-build")
-	req.Header.Del(HeaderSource)
-	req.Header.Set(HeaderSource, "ext-tampered-source")
 	return nil
 }

@@ -300,74 +285,7 @@ func (riskHeaderTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http
 	return nil
 }

-type bootstrapPolicyTamperingInterceptor struct{}
-
-func (bootstrapPolicyTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
-	req.Header.Set(HeaderSource, "extension-value")
-	req.Header.Set(riskcontrol.HeaderOSType, "extension-value")
-	return nil
-}
-
-func TestNewDefaultInstallsSDKBootstrapSecurityPolicy(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	oldTransport := http.DefaultClient.Transport
-	oldCheckRedirect := http.DefaultClient.CheckRedirect
-	t.Cleanup(func() {
-		http.DefaultClient.Transport = oldTransport
-		http.DefaultClient.CheckRedirect = oldCheckRedirect
-	})
-
-	previous := exttransport.GetProvider()
-	exttransport.Register(&platformOnlyStubProvider{
-		stubTransportProvider: &stubTransportProvider{
-			interceptor: bootstrapPolicyTamperingInterceptor{},
-		},
-	})
-	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.StatusNoContent,
-			Body:       http.NoBody,
-			Request:    req,
-		}, nil
-	})
-	http.DefaultClient.Transport = network
-	http.DefaultClient.CheckRedirect = nil
-	_ = NewDefault(nil, InvocationContext{})
-
-	req, err := http.NewRequest(
-		http.MethodPost,
-		"https://open.feishu.cn/callback/ws/endpoint",
-		strings.NewReader(`{"app_secret":"secret"}`),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-
-	if got := received.Get(HeaderSource); got != SourceValue {
-		t.Fatalf("%s = %q, want trusted value %q", HeaderSource, got, SourceValue)
-	}
-	if got := received.Get(riskcontrol.HeaderOSType); got != "" {
-		t.Fatalf("%s = %q, want extension value stripped", riskcontrol.HeaderOSType, got)
-	}
-	if got := received.Get(HeaderBuild); got != DetectBuildKind() {
-		t.Fatalf("%s = %q, want %q", HeaderBuild, got, DetectBuildKind())
-	}
-	if got := received.Get(HeaderUserAgent); got != UserAgentValue() {
-		t.Fatalf("%s = %q, want %q", HeaderUserAgent, got, UserAgentValue())
-	}
-}
-
-func TestBuildSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
+func TestWrapSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
 	previous := exttransport.GetProvider()
 	exttransport.Register(&stubTransportProvider{interceptor: riskHeaderTamperingInterceptor{}})
 	t.Cleanup(func() { exttransport.Register(previous) })
@@ -383,11 +301,7 @@ func TestBuildSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
 	}
 	req.Header.Set("Authorization", "Bearer token")

-	client := internaltransport.ClientForRequestClass(
-		&http.Client{Transport: buildSDKTransportWithBase(network, nil)},
-		exttransport.RequestClassPlatform,
-	)
-	resp, err := client.Do(req)
+	resp, err := wrapSDKTransport(riskcontrol.NewTransport(network, nil)).RoundTrip(req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -398,13 +312,14 @@ func TestBuildSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
 }

 // TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader verifies that the
-// SDK chain restores both the build classification and the full security
-// header set after an extension runs.
+// 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
+// closes the gap where the SDK chain had no equivalent of
+// SecurityHeaderTransport (see design doc §3.3.3).
 func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
-	var receivedBuild, receivedSource string
+	var receivedBuild string
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		receivedBuild = r.Header.Get(HeaderBuild)
-		receivedSource = r.Header.Get(HeaderSource)
 		w.WriteHeader(http.StatusOK)
 	}))
 	defer srv.Close()
@@ -412,13 +327,12 @@ func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{interceptor: buildTamperingInterceptor{}})
 	t.Cleanup(func() { exttransport.Register(nil) })

-	// Replicate the SDK built-in chain inside buildSDKTransport.
+	// Replicate the SDK chain layering used by wrapSDKTransport.
 	var base http.RoundTripper = http.DefaultTransport
 	base = &RetryTransport{Base: base}
 	base = &UserAgentTransport{Base: base}
 	base = &BuildHeaderTransport{Base: base}
-	base = &SecurityHeaderTransport{Base: base}
-	transport := internaltransport.WrapWithExtension(base)
+	transport := wrapWithExtension(base)
 	client := &http.Client{Transport: transport}

 	req, _ := http.NewRequest("GET", srv.URL, nil)
@@ -435,9 +349,6 @@ func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
 	if receivedBuild != want {
 		t.Fatalf("%s = %q, want %q", HeaderBuild, receivedBuild, want)
 	}
-	if receivedSource != SourceValue {
-		t.Fatalf("%s = %q, want %q", HeaderSource, receivedSource, SourceValue)
-	}
 }

 // TestBuildHeaderTransport_OverridesEvenWithoutTamper verifies that even if
@@ -527,7 +438,7 @@ func TestExtensionInterceptor_ContextTamperPrevented(t *testing.T) {
 		return nil
 	})

-	mid := &internaltransport.ExtensionMiddleware{Base: capturer, Ext: tamperIC}
+	mid := &extensionMiddleware{Base: capturer, Ext: tamperIC}

 	origCtx := context.WithValue(context.Background(), testKey, "original")
 	req, _ := http.NewRequestWithContext(origCtx, "GET", srv.URL, nil)
@@ -589,7 +500,7 @@ func TestExtensionMiddleware_PreRoundTripEAbort(t *testing.T) {
 			return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
 		})

-		mid := &internaltransport.ExtensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
+		mid := &extensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
 		req, _ := http.NewRequest("GET", "http://example.invalid/", nil)
 		resp, err := mid.RoundTrip(req)

@@ -630,7 +541,7 @@ func TestExtensionMiddleware_PreRoundTripEAbort(t *testing.T) {
 			return nil, nil
 		})

-		mid := &internaltransport.ExtensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
+		mid := &extensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
 		req, _ := http.NewRequest("GET", "http://example.invalid/", nil)
 		_, err := mid.RoundTrip(req)

@@ -649,7 +560,7 @@ func TestExtensionMiddleware_PreRoundTripEHappyPath(t *testing.T) {
 		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
 	})

-	mid := &internaltransport.ExtensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
+	mid := &extensionMiddleware{Base: base, Ext: ic, ExtName: "stub"}
 	req, _ := http.NewRequest("GET", "http://example.invalid/", nil)
 	resp, err := mid.RoundTrip(req)
 	if err != nil {
--- a/internal/core/config_snapshot.go
+++ b/internal/core/config_snapshot.go
@@ -21,6 +21,14 @@ func NewConfigSnapshot() *ConfigSnapshot {
 	return newConfigSnapshot(LoadMultiAppConfig)
 }

+// NewConfigSnapshotFrom creates a snapshot from configuration that was
+// already captured by another invocation-start boundary.
+func NewConfigSnapshotFrom(config *MultiAppConfig) *ConfigSnapshot {
+	return newConfigSnapshot(func() (*MultiAppConfig, error) {
+		return config, nil
+	})
+}
+
 func newConfigSnapshot(load func() (*MultiAppConfig, error)) *ConfigSnapshot {
 	if load == nil {
 		return &ConfigSnapshot{}
--- a/internal/core/config_snapshot_test.go
+++ b/internal/core/config_snapshot_test.go
@@ -38,6 +38,19 @@ func TestConfigSnapshotZeroValueIsMissing(t *testing.T) {
 	}
 }

+func TestNewConfigSnapshotFromPreservesCapturedConfig(t *testing.T) {
+	want := &MultiAppConfig{CurrentApp: "captured"}
+	snapshot := NewConfigSnapshotFrom(want)
+
+	got, err := snapshot.MultiAppConfig()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != want || got.CurrentApp != "captured" {
+		t.Fatalf("MultiAppConfig() = %#v, want captured pointer %#v", got, want)
+	}
+}
+
 func TestConfigSnapshotCachesError(t *testing.T) {
 	calls := 0
 	want := errors.New("load failed")
--- a/internal/core/types.go
+++ b/internal/core/types.go
@@ -3,10 +3,7 @@

 package core

-import (
-	"net/url"
-	"strings"
-)
+import "strings"

 // LarkBrand represents the Lark platform brand.
 // "feishu" targets China-mainland, "lark" targets international.
@@ -66,39 +63,3 @@ func ResolveEndpoints(brand LarkBrand) Endpoints {
 func ResolveOpenBaseURL(brand LarkBrand) string {
 	return ResolveEndpoints(brand).Open
 }
-
-var platformEndpointHosts = func() map[string]struct{} {
-	hosts := make(map[string]struct{})
-	for _, brand := range []LarkBrand{BrandFeishu, BrandLark} {
-		endpoints := ResolveEndpoints(brand)
-		for _, rawURL := range []string{endpoints.Open, endpoints.Accounts, endpoints.MCP, endpoints.AppLink} {
-			parsed, err := url.Parse(rawURL)
-			if err == nil && parsed.Hostname() != "" {
-				hosts[strings.ToLower(parsed.Hostname())] = struct{}{}
-			}
-		}
-	}
-	return hosts
-}()
-
-// IsPlatformEndpointHost reports whether hostname exactly matches one of the
-// endpoint hosts produced by ResolveEndpoints. It intentionally does not use a
-// suffix match: lookalike external domains must never enter the platform
-// transport extension.
-func IsPlatformEndpointHost(hostname string) bool {
-	_, ok := platformEndpointHosts[strings.ToLower(hostname)]
-	return ok
-}
-
-// IsPlatformEndpointURL reports whether candidate uses a secure origin for a
-// configured platform endpoint. Non-TLS and non-standard-port lookalikes are
-// excluded even when their hostname matches.
-func IsPlatformEndpointURL(candidate *url.URL) bool {
-	if candidate == nil || !strings.EqualFold(candidate.Scheme, "https") {
-		return false
-	}
-	if port := candidate.Port(); port != "" && port != "443" {
-		return false
-	}
-	return IsPlatformEndpointHost(candidate.Hostname())
-}
--- a/internal/core/types_test.go
+++ b/internal/core/types_test.go
@@ -3,11 +3,7 @@

 package core

-import (
-	"net/url"
-	"reflect"
-	"testing"
-)
+import "testing"

 func TestResolveEndpoints_Feishu(t *testing.T) {
 	ep := ResolveEndpoints(BrandFeishu)
@@ -95,85 +91,3 @@ func TestResolveEndpoints_NormalizesBrand(t *testing.T) {
 		t.Errorf("ResolveEndpoints(unexpected).Open = %q, want the feishu default", got)
 	}
 }
-
-func TestIsPlatformEndpointHost_ExactMatchOnly(t *testing.T) {
-	for _, host := range []string{
-		"open.feishu.cn",
-		"accounts.feishu.cn",
-		"mcp.feishu.cn",
-		"applink.feishu.cn",
-		"open.larksuite.com",
-		"accounts.larksuite.com",
-		"mcp.larksuite.com",
-		"applink.larksuite.com",
-	} {
-		if !IsPlatformEndpointHost(host) {
-			t.Errorf("IsPlatformEndpointHost(%q) = false, want true", host)
-		}
-	}
-
-	for _, host := range []string{
-		"example.com",
-		"open.feishu.cn.example.com",
-		"notopen.feishu.cn",
-		"",
-	} {
-		if IsPlatformEndpointHost(host) {
-			t.Errorf("IsPlatformEndpointHost(%q) = true, want false", host)
-		}
-	}
-}
-
-func TestIsPlatformEndpointHost_CoversEveryResolvedEndpoint(t *testing.T) {
-	for _, brand := range []LarkBrand{BrandFeishu, BrandLark} {
-		endpoints := reflect.ValueOf(ResolveEndpoints(brand))
-		for i := 0; i < endpoints.NumField(); i++ {
-			rawURL := endpoints.Field(i).String()
-			parsed, err := url.Parse(rawURL)
-			if err != nil {
-				t.Fatalf("ResolveEndpoints(%q) field %d URL %q: %v", brand, i, rawURL, err)
-			}
-			if !IsPlatformEndpointHost(parsed.Hostname()) {
-				t.Errorf("ResolveEndpoints(%q) field %d host %q is missing from the platform transport boundary", brand, i, parsed.Hostname())
-			}
-		}
-	}
-}
-
-func TestIsPlatformEndpointURL_RequiresSecureStandardOrigin(t *testing.T) {
-	if IsPlatformEndpointURL(nil) {
-		t.Error("IsPlatformEndpointURL(nil) = true, want false")
-	}
-	uppercaseScheme := &url.URL{Scheme: "HTTPS", Host: "open.feishu.cn", Path: "/path"}
-	if !IsPlatformEndpointURL(uppercaseScheme) {
-		t.Error("IsPlatformEndpointURL() rejected uppercase HTTPS scheme")
-	}
-
-	for _, rawURL := range []string{
-		"http://open.feishu.cn/path",
-		"https://open.feishu.cn:8443/path",
-		"https://open.feishu.cn.example.com/path",
-	} {
-		candidate, err := url.Parse(rawURL)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if IsPlatformEndpointURL(candidate) {
-			t.Errorf("IsPlatformEndpointURL(%q) = true, want false", rawURL)
-		}
-	}
-
-	for _, rawURL := range []string{
-		"https://open.feishu.cn/path",
-		"https://open.feishu.cn:443/path",
-		"https://OPEN.FEISHU.CN/path",
-	} {
-		candidate, err := url.Parse(rawURL)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !IsPlatformEndpointURL(candidate) {
-			t.Errorf("IsPlatformEndpointURL(%q) = false, want true", rawURL)
-		}
-	}
-}
--- a/internal/credential/credential_provider.go
+++ b/internal/credential/credential_provider.go
@@ -14,6 +14,7 @@ import (
 	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/i18n"
 )

 // DefaultAccountResolver is implemented by the default account provider.
@@ -26,6 +27,34 @@ type DefaultTokenResolver interface {
 	ResolveToken(ctx context.Context, req TokenSpec) (*TokenResult, error)
 }

+type userInfoEnrichmentSkipper interface {
+	SkipUserInfoEnrichment() bool
+}
+
+// ProviderCapabilities describes source-neutral credential behavior used by
+// inspection and account resolution. It carries no provider configuration.
+type ProviderCapabilities struct {
+	SkipUserInfoEnrichment bool
+	ProvidesOnDemandAuth   bool
+	CanInspectScopes       bool
+}
+
+type providerCapabilitiesSource interface {
+	CredentialCapabilities() ProviderCapabilities
+}
+
+// ProviderAccountMetadata carries source-neutral Profile preferences that are
+// not part of the public credential extension account contract. Internal
+// runtime providers can expose them without coupling core configuration to a
+// concrete credential product.
+type ProviderAccountMetadata struct {
+	Lang i18n.Lang
+}
+
+type providerAccountMetadataSource interface {
+	CredentialAccountMetadata() ProviderAccountMetadata
+}
+
 var (
 	getStoredToken       = auth.GetStoredToken
 	getStoredTokenStatus = auth.TokenStatus
@@ -136,10 +165,12 @@ type CredentialProvider struct {
 	httpClient   func() (*http.Client, error)
 	warnOut      io.Writer

-	accountOnce    sync.Once
-	account        *Account
-	accountErr     error
-	selectedSource credentialSource
+	accountOnce      sync.Once
+	account          *Account
+	accountErr       error
+	selectedSource   credentialSource
+	selectedProvider extcred.Provider
+	selectedCaps     ProviderCapabilities

 	hintOnce sync.Once
 	hint     *IdentityHint
@@ -176,36 +207,61 @@ func (p *CredentialProvider) doResolveAccount(ctx context.Context) (*Account, er
 	for _, prov := range p.providers {
 		acct, err := prov.ResolveAccount(ctx)
 		if err != nil {
+			// A provider error stops the chain, so remember that source as the
+			// immutable selection even though account resolution failed.
+			p.selectedSource = extensionTokenSource{provider: prov}
+			p.selectedProvider = prov
+			p.selectedCaps = credentialProviderCapabilities(prov)
 			return nil, err
 		}
 		if acct != nil {
 			internal := convertAccount(acct)
+			if source, ok := prov.(providerAccountMetadataSource); ok {
+				metadata := source.CredentialAccountMetadata()
+				internal.Lang = metadata.Lang
+			}
 			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)
+			capabilities := credentialProviderCapabilities(prov)
+			skipEnrichment := capabilities.SkipUserInfoEnrichment
+			if skipper, ok := prov.(userInfoEnrichmentSkipper); ok {
+				skipEnrichment = skipper.SkipUserInfoEnrichment()
+			}
+			if !skipEnrichment {
+				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)
+					}
+					// 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 = ""
 				}
-				// 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 = ""
 			}
 			p.selectedSource = source
+			p.selectedProvider = prov
+			p.selectedCaps = capabilities
 			return internal, nil
 		}
 	}
 	if p.defaultAcct != nil {
+		p.selectedSource = defaultTokenSource{resolver: p.defaultToken}
 		acct, err := p.defaultAcct.ResolveAccount(ctx)
 		if err != nil {
 			return nil, err
 		}
-		p.selectedSource = defaultTokenSource{resolver: p.defaultToken}
 		return acct, nil
 	}
 	return nil, core.NotConfiguredError()
 }

+func credentialProviderCapabilities(provider extcred.Provider) ProviderCapabilities {
+	if source, ok := provider.(providerCapabilitiesSource); ok {
+		return source.CredentialCapabilities()
+	}
+	return ProviderCapabilities{CanInspectScopes: true}
+}
+
 // enrichUserInfo resolves user identity when extension provides a UAT.
 // If UAT is available, user_info API call is mandatory (security: verify token validity).
 // If no UAT from extension, falls back to provider-supplied OpenID.
--- a/internal/credential/credential_provider_test.go
+++ b/internal/credential/credential_provider_test.go
@@ -120,7 +120,7 @@ func TestCredentialProvider_TokenFromExtension(t *testing.T) {
 		[]extcred.Provider{&mockExtProvider{
 			name:    "env",
 			account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-			token:   &extcred.Token{Value: "ext_tok", Source: "env"},
+			token:   &extcred.Token{Value: "ext_tok", Scopes: "im:message", Source: "env"},
 		}},
 		&mockDefaultAcct{}, &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
 	)
@@ -128,8 +128,28 @@ func TestCredentialProvider_TokenFromExtension(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if result.Token != "ext_tok" {
-		t.Errorf("expected ext_tok, got %s", result.Token)
+	if result.Token != "ext_tok" || result.Scopes != "im:message" {
+		t.Errorf("extension token = %#v, want token and scopes preserved", result)
+	}
+}
+
+func TestCredentialProvider_ResolveTokenTreatsEmptyExtensionTokenAsMalformed(t *testing.T) {
+	cp := NewCredentialProvider(
+		[]extcred.Provider{&mockExtProvider{
+			name:    "env",
+			account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
+			token:   &extcred.Token{},
+		}},
+		nil, nil, nil,
+	)
+
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
+	var malformedErr *MalformedTokenResultError
+	if !errors.As(err, &malformedErr) {
+		t.Fatalf("ResolveToken() error = %T %v, want *MalformedTokenResultError", err, err)
+	}
+	if malformedErr.Source != "env" || malformedErr.Type != TokenTypeUAT || malformedErr.Reason != "empty token" {
+		t.Fatalf("malformed token error = %+v, want env/uat/empty token", malformedErr)
 	}
 }

--- a/internal/credential/default_provider.go
+++ b/internal/credential/default_provider.go
@@ -61,8 +61,21 @@ func classifyTATResponseCode(code int, oauthErr, errDesc, brand, appID string) e

 // DefaultAccountProvider resolves account from config.json via keychain.
 type DefaultAccountProvider struct {
-	keychain func() keychain.KeychainAccess
-	profile  string
+	keychain    func() keychain.KeychainAccess
+	profile     string
+	snapshot    *core.MultiAppConfig
+	useSnapshot bool
+}
+
+// NewDefaultAccountProviderFromSnapshot creates the production provider for a
+// Factory. A nil snapshot means no usable config existed when the Factory was
+// created; the provider does not re-read a file that may have changed since
+// transport wiring was selected.
+func NewDefaultAccountProviderFromSnapshot(kc func() keychain.KeychainAccess, profile string, snapshot *core.MultiAppConfig) *DefaultAccountProvider {
+	provider := NewDefaultAccountProvider(kc, profile)
+	provider.snapshot = snapshot
+	provider.useSnapshot = true
+	return provider
 }

 func NewDefaultAccountProvider(kc func() keychain.KeychainAccess, profile string) *DefaultAccountProvider {
@@ -73,9 +86,16 @@ 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.
-	multi, err := core.LoadMultiAppConfig()
-	if err != nil {
+	// Use one config for both credentials and strict mode.
+	multi := p.snapshot
+	if !p.useSnapshot {
+		var err error
+		multi, err = core.LoadMultiAppConfig()
+		if err != nil {
+			return nil, core.NotConfiguredError()
+		}
+	}
+	if multi == nil {
 		return nil, core.NotConfiguredError()
 	}

--- a/Show More
+++ b/Show More