feat(config): bind OpenClaw keyless credentials

.github/workflows/release.yml

@@ -9,40 +9,11 @@ permissions:
   contents: read
 
 jobs:
-  preflight:
-    runs-on: ubuntu-22.04
-    permissions:
-      contents: read
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
-        with:
-          node-version: '22.14.0'
-
-      - name: Validate tag and commit
-        env:
-          TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          node scripts/release-preflight.js --tag "$TAG"
-          git fetch origin main
-          HEAD_SHA="$(git rev-parse --verify 'HEAD^{commit}')"
-          MAIN_SHA="$(git rev-parse --verify 'FETCH_HEAD^{commit}')"
-          TAG_SHA="$(git rev-parse --verify "refs/tags/${TAG}^{commit}")"
-          if [[ "$TAG_SHA" != "$HEAD_SHA" ]]; then
-            echo "Tag ${TAG} does not resolve to the checked-out HEAD commit." >&2
-            exit 1
-          fi
-          if ! git merge-base --is-ancestor "$HEAD_SHA" "$MAIN_SHA"; then
-            echo "Tag ${TAG} does not point to a commit contained in origin/main." >&2
-            exit 1
-          fi
-
-  build-release:
-    needs: preflight
+  # All platforms (incl. darwin keychain_signer) are CGO-free and cross-compiled
+  # on a single ubuntu runner in one goreleaser run (one checksums.txt). The
+  # darwin signer's runtime FFI is validated separately by the signer-test job.
+  goreleaser:
+    needs: signer-test-macos
     runs-on: ubuntu-22.04
     permissions:
       contents: write
@@ -59,79 +30,50 @@ jobs:
         with:
           python-version: '3.x'
 
-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
-        with:
-          node-version: '22.14.0'
-          registry-url: 'https://registry.npmjs.org'
-          package-manager-cache: false
-
-      - name: Install pinned npm
-        run: npm install --global npm@11.16.0
-
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@e435ccd777264be153ace6237001ef4d979d3a7a # v6
         with:
           version: '~> v2'
           args: release --clean
         env:
-          GITHUB_TOKEN: ${{ github.token }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Include release checksums
-        run: |
-          set -euo pipefail
-          test -s dist/checksums.txt
-          (cd dist && sha256sum --check checksums.txt)
-          cp dist/checksums.txt checksums.txt
-
-      - name: Collect release asset
-        run: |
-          set -euo pipefail
-          mkdir npm-publish-asset
-          cp dist/*.tar.gz dist/*.zip dist/checksums.txt npm-publish-asset/
-
-      - name: Upload release asset
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        with:
-          name: npm-publish-asset-${{ github.run_id }}
-          path: npm-publish-asset/
-          if-no-files-found: error
-          overwrite: true
-
-  publish-npm:
-    needs: build-release
-    runs-on: ubuntu-22.04
-    environment: npm-production
+  # Validate the macOS keychain signer on real hardware. The release binaries are
+  # cross-compiled on ubuntu (CGO-free purego FFI), so this is the only step that
+  # needs a Mac — and it gates the release rather than producing it.
+  signer-test-macos:
+    runs-on: macos-latest
     permissions:
       contents: read
-      id-token: write
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5
+        with:
+          go-version: '1.23'
+      - name: Keychain signer round-trip (CGO-free purego FFI)
+        run: LARK_KEYCHAIN_IT=1 CGO_ENABLED=0 go test -tags keychain_signer -run Keychain -v ./internal/keysigner/
+
+  publish-npm:
+    needs: goreleaser
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
 
-      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
-          node-version: '22.14.0'
+          node-version: '20'
           registry-url: 'https://registry.npmjs.org'
-          package-manager-cache: false
 
-      - name: Install pinned npm
-        run: npm install --global npm@11.16.0
-
-      - name: Download release asset
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
-        with:
-          name: npm-publish-asset-${{ github.run_id }}
-          path: npm-publish-asset
-
-      - name: Verify npm publish asset
+      - name: Download checksums from release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           set -euo pipefail
-          (cd npm-publish-asset && sha256sum --check checksums.txt)
-          cp npm-publish-asset/checksums.txt checksums.txt
-          PACK_JSON="$(npm pack --ignore-scripts --json)"
-          PACK_FILE="$(node -e 'const p=JSON.parse(process.argv[1]); if(p.length!==1 || !p[0].filename) process.exit(1); process.stdout.write(p[0].filename)' "$PACK_JSON")"
-          test -s "$PACK_FILE"
-          tar -tzf "$PACK_FILE" | grep -qx 'package/checksums.txt'
-          rm "$PACK_FILE"
+          TAG="${GITHUB_REF_NAME}"
+          gh release download "${TAG}" --pattern checksums.txt --dir .
+          test -s checksums.txt || { echo "checksums.txt missing or empty for ${TAG}"; exit 1; }
 
       - name: Publish to npm
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: npm publish --access public

.goreleaser.yml

@@ -5,25 +5,63 @@ before:
     - python3 scripts/fetch_meta.py
 
 builds:
-  - binary: lark-cli
+  # Linux & Windows: pure-Go TPM 2.0 signer is compiled in by default (no build
+  # tag), cross-compiled with CGO disabled — the binaries ship the platform key
+  # signer for private_key_jwt. windows/arm64 is the one exception: the sks
+  # Windows dependency stack (go-ole) has no arm64 support, so the signer file is
+  # arch-excluded there and that binary falls back to client_secret only.
+  - id: linux
+    binary: lark-cli
+    main: .
     env:
       - CGO_ENABLED=0
+    flags:
+      - -trimpath
     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
+  - id: windows
+    binary: lark-cli
+    main: .
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+    ldflags:
+      - -s -w -X github.com/larksuite/cli/internal/build.Version={{ .Version }} -X github.com/larksuite/cli/internal/build.Date={{ .Date }}
+    goos:
+      - windows
+    goarch:
+      - amd64
+      - arm64
+  # macOS: the keychain signer calls Security.framework via runtime FFI (purego),
+  # so it is CGO-free, compiled into every darwin build (no build tag), and
+  # cross-compiles from the same ubuntu runner as linux/windows.
+  - id: darwin
+    binary: lark-cli
+    main: .
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -trimpath
+    ldflags:
+      - -s -w -X github.com/larksuite/cli/internal/build.Version={{ .Version }} -X github.com/larksuite/cli/internal/build.Date={{ .Date }}
+    goos:
+      - darwin
+    goarch:
+      - amd64
+      - arm64
 
 archives:
   - name_template: "lark-cli-{{ .Version }}-{{ .Os }}-{{ .Arch }}"
     format_overrides:
       - goos: windows
-        format: zip
+        formats: [zip]
     files:
       - README.md
       - LICENSE

CHANGELOG.md

@@ -2,65 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.77] - 2026-07-24
-
-### Features
-
-- introducing official card icon (#1973)
-- **apps**: validate +file-list --page-size against server (0, 200] range (#2007)
-- **apps**: support absolute and relative upload paths (#2005)
-- **slides**: fill xml-schema-quick-ref gaps that forced XSD fallback (#2026)
-- **slides**: add layout density lint for sparse/empty containers (#2022)
-- add risk-control protection (#1910)
-
-### Bug Fixes
-
-- **slides**: normalize presentation flag aliases (#2032)
-- **base**: classify +form-submit as high-risk-write (#1969)
-- **slides**: declare screenshot scope
-- **slides**: support CSV multi-value for --slide-id in screenshot (#2047)
-
-### Documentation
-
-- **skill**: clarify scope handling for query expansion (#2030)
-- **base**: clarify complete and partial updates (#1993)
-- **skills**: clarify callout child rules (#2048)
-
-### Misc
-
-- fix/task id handling (#2023)
-- fix/task search pagination (#2041)
-
-## [v1.0.75] - 2026-07-22
-
-### Features
-
-- add okr single create shortcut & skill text opti (#1941)
-- **calendar**: auto-add bot self as attendee and note user-only search (#1991)
-
-### Bug Fixes
-
-- **base**: improve table shortcut behavior & guidance (#1803)
-- issue#1935 & whiteboard shortcut reformat (#1980)
-- remove legacy shortcut (#1997)
-- **e2e**: inject shared credentials by identity (#1995)
-
-### Documentation
-
-- **skill**: describe html5 block xml usage (#1380)
-- clarify fetch metadata and user cites (#1981)
-- add topic move collector workflow (#1473)
-- update lark doc HTML size limit (#2001)
-- **base**: align record write schema guidance (#2000)
-
-### Tests
-
-- **e2e**: declare request identities explicitly (#2004)
-
-### Misc
-
-- harden npm release publishing (#1918)
-
 ## [v1.0.74] - 2026-07-21
 
 ### Features
@@ -1667,8 +1608,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[v1.0.77]: https://github.com/larksuite/cli/releases/tag/v1.0.77
-[v1.0.75]: https://github.com/larksuite/cli/releases/tag/v1.0.75
 [v1.0.74]: https://github.com/larksuite/cli/releases/tag/v1.0.74
 [v1.0.73]: https://github.com/larksuite/cli/releases/tag/v1.0.73
 [v1.0.72]: https://github.com/larksuite/cli/releases/tag/v1.0.72

Makefile

@@ -51,7 +51,7 @@ script-test:
 	bash scripts/resolve-changed-from.test.sh
 	bash scripts/ci-workflow.test.sh
 	bash scripts/semantic-review-workflow.test.sh
-	$(NODE) --test scripts/e2e_domains.test.js scripts/fetch_e2e_tat.test.js scripts/install.test.js scripts/release-preflight.test.js scripts/semantic-review-verify-artifact.test.js scripts/pr-quality-summary.test.js scripts/semantic-review-publish.test.js scripts/ci-quality-summary-publish.test.js
+	$(NODE) --test scripts/e2e_domains.test.js scripts/fetch_e2e_tat.test.js scripts/semantic-review-verify-artifact.test.js scripts/pr-quality-summary.test.js scripts/semantic-review-publish.test.js scripts/ci-quality-summary-publish.test.js
 
 # ./extension/... keeps the public plugin SDK in the default test matrix.
 unit-test: fetch_meta

README.md

@@ -285,29 +285,6 @@ To reduce these risks, the tool enables default security protections at multiple
 
 We recommend using the Lark/Feishu bot integrated with this tool as a private conversational assistant. Do not add it to group chats or allow other users to interact with it, to avoid abuse of permissions or data leakage.
 
-To reduce the security risks associated with access token theft, the CLI sends a minimal set of risk-control signals with OpenAPI requests made to exact official Feishu/Lark HTTPS domains. These signals are used to help identify anomalous API activity. This protection is enabled by default. The information sent is limited to:
-
-- Operating system type: macOS, Windows, or Linux
-- Device hardware model: for example, Mac17,9
-
-To disable this protection for the current workspace, run:
-
-```bash
-lark-cli config risk-control off
-```
-
-To enable this protection for the current workspace, run:
-
-```bash
-lark-cli config risk-control on
-```
-
-To restore the default policy for the current workspace, run:
-
-```bash
-lark-cli config risk-control default
-```
-
 Please fully understand all usage risks. By using this tool, you are deemed to voluntarily assume all related responsibilities.
 
 ## Star History

README.zh.md

@@ -286,29 +286,6 @@ lark-cli schema im.messages.delete
 
 我们建议您将对接本工具的飞书机器人作为私人对话助手使用，请勿将其拉入群聊或允许其他用户与其交互，以避免权限被滥用或数据泄露。
 
-为降低访问令牌被盗用后的安全风险，CLI 在向飞书/Lark 官方 HTTPS 精确域名发起 OpenAPI 请求时，会随请求发送一组最小化的风控信号，用于辅助识别异常调用行为。该保护默认开启，发送的信息仅包括：
-
-- 操作系统类型：macOS、Windows 或 Linux
-- 设备的硬件产品型号：例如 Mac17,9
-
-如需让当前 workspace 退出该保护，可执行以下命令：
-
-```bash
-lark-cli config risk-control off
-```
-
-如需开启当前 workspace 的保护，可执行以下命令：
-
-```bash
-lark-cli config risk-control on
-```
-
-恢复当前 workspace 默认策略可执行：
-
-```bash
-lark-cli config risk-control default
-```
-
 请您充分知悉全部使用风险，使用本工具即视为您自愿承担相关所有责任。
 
 ## Star History

cmd/auth/auth_test.go

@@ -386,7 +386,7 @@ func TestAuthScopesRun_UsesTenantAccessTokenFromCredentialProvider(t *testing.T)
 		AppID: "test-app", AppSecret: "", Brand: core.BrandFeishu,
 	})
 	tokenResolver := &authScopesTokenResolver{}
-	f.Credential = newAuthTestCredentialProvider("test-app", tokenResolver)
+	f.Credential = credential.NewCredentialProvider(nil, nil, tokenResolver, nil)
 
 	appInfoStub := &httpmock.Stub{
 		Method: http.MethodGet,
@@ -442,7 +442,7 @@ func TestAuthScopesRun_LarkPermissionError_TypedAsPermissionError(t *testing.T)
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 	tokenResolver := &authScopesTokenResolver{}
-	f.Credential = newAuthTestCredentialProvider("test-app", tokenResolver)
+	f.Credential = credential.NewCredentialProvider(nil, nil, tokenResolver, nil)
 
 	reg.Register(&httpmock.Stub{
 		Method: http.MethodGet,
@@ -485,18 +485,6 @@ type authScopesTokenResolver struct {
 	requests []credential.TokenSpec
 }
 
-type authTestAccountResolver struct {
-	appID string
-}
-
-func (r authTestAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return &credential.Account{AppID: r.appID, Brand: core.BrandFeishu}, nil
-}
-
-func newAuthTestCredentialProvider(appID string, tokenResolver credential.DefaultTokenResolver) *credential.CredentialProvider {
-	return credential.NewCredentialProvider(nil, authTestAccountResolver{appID: appID}, tokenResolver, nil)
-}
-
 func (r *authScopesTokenResolver) ResolveToken(ctx context.Context, req credential.TokenSpec) (*credential.TokenResult, error) {
 	r.requests = append(r.requests, req)
 	switch req.Type {

cmd/auth/login.go

@@ -40,6 +40,10 @@ type LoginOptions struct {
 
 var pollDeviceToken = larkauth.PollDeviceToken
 
+var resolveLoginClientAuth = func(ctx context.Context, cfg *core.CliConfig) (larkauth.ClientAuth, error) {
+	return larkauth.ClientAuthFromConfig(cfg).ResolveSigner(ctx)
+}
+
 // NewCmdAuthLogin creates the auth login subcommand.
 func NewCmdAuthLogin(f *cmdutil.Factory, runF func(*LoginOptions) error) *cobra.Command {
 	opts := &LoginOptions{Factory: f}
@@ -265,7 +269,11 @@ func authLoginRun(opts *LoginOptions) error {
 	if err != nil {
 		return err
 	}
-	authResp, err := larkauth.RequestDeviceAuthorization(httpClient, config.AppID, config.AppSecret, config.Brand, finalScope, f.IOStreams.ErrOut)
+	clientAuth, err := resolveLoginClientAuth(opts.Ctx, config)
+	if err != nil {
+		return errs.NewAuthenticationError(errs.SubtypeUnknown, "device authorization failed: %v", err).WithCause(err)
+	}
+	authResp, err := larkauth.RequestDeviceAuthorization(opts.Ctx, httpClient, clientAuth, config.Brand, finalScope, f.IOStreams.ErrOut)
 	if err != nil {
 		return errs.NewAuthenticationError(errs.SubtypeUnknown, "device authorization failed: %v", err).WithCause(err)
 	}
@@ -325,7 +333,7 @@ func authLoginRun(opts *LoginOptions) error {
 
 	// Step 3: Poll for token
 	log(msg.WaitingAuth)
-	result := pollDeviceToken(opts.Ctx, httpClient, config.AppID, config.AppSecret, config.Brand,
+	result := pollDeviceToken(opts.Ctx, httpClient, clientAuth, config.Brand,
 		authResp.DeviceCode, authResp.Interval, authResp.ExpiresIn, f.IOStreams.ErrOut)
 
 	if !result.OK {
@@ -398,6 +406,10 @@ func authLoginPollDeviceCode(opts *LoginOptions, config *core.CliConfig, msg *lo
 	if err != nil {
 		return err
 	}
+	clientAuth, err := resolveLoginClientAuth(opts.Ctx, config)
+	if err != nil {
+		return errs.NewAuthenticationError(errs.SubtypeUnknown, "authorization failed: %v", err).WithCause(err)
+	}
 	requestedScope, err := loadLoginRequestedScope(opts.DeviceCode)
 	if err != nil {
 		fmt.Fprintf(f.IOStreams.ErrOut, "[lark-cli] [WARN] auth login: failed to load cached requested scopes: %v\n", err)
@@ -415,7 +427,7 @@ func authLoginPollDeviceCode(opts *LoginOptions, config *core.CliConfig, msg *lo
 		fmt.Fprintln(f.IOStreams.ErrOut, msg.AgentTimeoutHint)
 	}
 	log(msg.WaitingAuth)
-	result := pollDeviceToken(opts.Ctx, httpClient, config.AppID, config.AppSecret, config.Brand,
+	result := pollDeviceToken(opts.Ctx, httpClient, clientAuth, config.Brand,
 		opts.DeviceCode, 5, 600, f.IOStreams.ErrOut)
 
 	if !result.OK {

cmd/auth/login_test.go

@@ -716,6 +716,14 @@ func TestAuthLoginRun_DeviceCodeUsesCachedRequestedScopes(t *testing.T) {
 	setupLoginConfigDir(t)
 	t.Setenv("HOME", t.TempDir())
 
+	originalResolve := resolveLoginClientAuth
+	resolveCalls := 0
+	resolveLoginClientAuth = func(_ context.Context, cfg *core.CliConfig) (larkauth.ClientAuth, error) {
+		resolveCalls++
+		return larkauth.ClientAuthFromConfig(cfg), nil
+	}
+	t.Cleanup(func() { resolveLoginClientAuth = originalResolve })
+
 	multi := &core.MultiAppConfig{
 		CurrentApp: "default",
 		Apps: []core.AppConfig{
@@ -778,6 +786,9 @@ func TestAuthLoginRun_DeviceCodeUsesCachedRequestedScopes(t *testing.T) {
 	if err != nil {
 		t.Fatalf("no-wait authLoginRun() error = %v", err)
 	}
+	if resolveCalls != 1 {
+		t.Fatalf("no-wait client auth preparations = %d, want 1", resolveCalls)
+	}
 	if got, err := loadLoginRequestedScope("device-code"); err != nil || got != "im:message:send" {
 		t.Fatalf("loadLoginRequestedScope() = (%q, %v), want requested scope", got, err)
 	}
@@ -793,6 +804,9 @@ func TestAuthLoginRun_DeviceCodeUsesCachedRequestedScopes(t *testing.T) {
 	if err != nil {
 		t.Fatalf("device-code authLoginRun() error = %v", err)
 	}
+	if resolveCalls != 2 {
+		t.Fatalf("split-flow client auth preparations = %d, want one per invocation", resolveCalls)
+	}
 	got := stderr.String()
 	for _, want := range []string{
 		"OK: 授权成功! 用户: tester (ou_user)",
@@ -847,7 +861,7 @@ func TestAuthLoginRun_DeviceCodeTokenNilCleansScopeCache(t *testing.T) {
 
 	original := pollDeviceToken
 	t.Cleanup(func() { pollDeviceToken = original })
-	pollDeviceToken = func(ctx context.Context, httpClient *http.Client, appId, appSecret string, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) *larkauth.DeviceFlowResult {
+	pollDeviceToken = func(ctx context.Context, httpClient *http.Client, ca larkauth.ClientAuth, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) *larkauth.DeviceFlowResult {
 		return &larkauth.DeviceFlowResult{OK: true, Token: nil}
 	}
 
@@ -884,9 +898,17 @@ func TestAuthLoginRun_JSONAbort_StdoutEventOnly_StderrEmpty(t *testing.T) {
 	keyring.MockInit()
 	setupLoginConfigDir(t)
 
+	originalResolve := resolveLoginClientAuth
+	resolveCalls := 0
+	resolveLoginClientAuth = func(_ context.Context, cfg *core.CliConfig) (larkauth.ClientAuth, error) {
+		resolveCalls++
+		return larkauth.ClientAuthFromConfig(cfg), nil
+	}
+	t.Cleanup(func() { resolveLoginClientAuth = originalResolve })
+
 	original := pollDeviceToken
 	t.Cleanup(func() { pollDeviceToken = original })
-	pollDeviceToken = func(ctx context.Context, httpClient *http.Client, appId, appSecret string, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) *larkauth.DeviceFlowResult {
+	pollDeviceToken = func(ctx context.Context, httpClient *http.Client, ca larkauth.ClientAuth, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) *larkauth.DeviceFlowResult {
 		return &larkauth.DeviceFlowResult{OK: false, Message: "user denied"}
 	}
 
@@ -919,6 +941,9 @@ func TestAuthLoginRun_JSONAbort_StdoutEventOnly_StderrEmpty(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for aborted authorization")
 	}
+	if resolveCalls != 1 {
+		t.Fatalf("blocking-flow client auth preparations = %d, want 1", resolveCalls)
+	}
 	if gotCode := output.ExitCodeOf(err); gotCode != output.ExitAuth {
 		t.Fatalf("exit code = %d, want %d", gotCode, output.ExitAuth)
 	}

cmd/auth/status.go

@@ -27,9 +27,6 @@ func NewCmdAuthStatus(f *cmdutil.Factory, runF func(*StatusOptions) error) *cobr
 	cmd := &cobra.Command{
 		Use:   "status",
 		Short: "View current auth status",
-		Long: `Show OAuth user login, token validity, and granted scopes.
-For token-validity checks, run lark-cli auth status --json --verify.
-This is not profile/app selection diagnostics; use lark-cli whoami for the effective app/profile identity used by an invocation.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if runF != nil {
 				return runF(opts)

cmd/auth/status_test.go

@@ -4,35 +4,15 @@
 package auth
 
 import (
-	"context"
 	"encoding/json"
 	"net/http"
-	"strings"
 	"testing"
 
-	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/internal/httpmock"
 )
 
-func TestAuthStatusHelpDistinguishesFromWhoami(t *testing.T) {
-	cmd := NewCmdAuthStatus(nil, nil)
-	for _, want := range []string{
-		"OAuth user login",
-		"auth status --json --verify",
-		"not profile/app selection diagnostics",
-		"lark-cli whoami",
-	} {
-		if !strings.Contains(cmd.Long, want) {
-			t.Errorf("auth status --help Long missing %q; got:\n%s", want, cmd.Long)
-		}
-	}
-}
-
 func TestAuthStatusRun_SplitsBotAndUserIdentity(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "secret", Brand: core.BrandFeishu,
@@ -99,51 +79,6 @@ func TestAuthStatusRun_VerifyReportsBotIdentity(t *testing.T) {
 	}
 }
 
-type fixedStatusAccountResolver struct {
-	account *credential.Account
-}
-
-func (r *fixedStatusAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return r.account, nil
-}
-
-func TestAuthStatus_AllowsMatchingAppIDOnlySelectedProfile(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv(envvars.CliAppID, "cli_a")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv(envvars.CliUserAccessToken, "")
-	t.Setenv(envvars.CliTenantAccessToken, "")
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name:      "tenant_a",
-			AppId:     "cli_a",
-			AppSecret: core.PlainSecret("test-secret"),
-			Brand:     core.BrandFeishu,
-		}},
-	}); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	config := &core.CliConfig{ProfileName: "tenant_a", AppID: "cli_a", AppSecret: "test-secret", Brand: core.BrandFeishu}
-	f, stdout, _, _ := cmdutil.TestFactory(t, config)
-	f.Credential = credential.NewCredentialProvider(
-		[]extcred.Provider{&envprovider.Provider{}},
-		&fixedStatusAccountResolver{account: credential.AccountFromCliConfig(config)},
-		nil,
-		nil,
-	).WithProfileFromFlag("tenant_a")
-
-	cmd := NewCmdAuth(f)
-	cmd.SetArgs([]string{"status", "--json"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("auth status should use the selected built-in profile: %v", err)
-	}
-	if strings.Contains(stdout.String(), "credentials are provided externally") {
-		t.Fatalf("matching APP_ID-only env was misclassified as external:\n%s", stdout.String())
-	}
-}
-
 type statusOutput struct {
 	Identity   string `json:"identity"`
 	Verified   *bool  `json:"verified"`

cmd/bootstrap.go

@@ -6,10 +6,8 @@ package cmd
 import (
 	"errors"
 	"io"
-	"os"
 
 	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/envvars"
 	"github.com/spf13/pflag"
 )
 
@@ -28,13 +26,5 @@ func BootstrapInvocationContext(args []string) (cmdutil.InvocationContext, error
 	if err := fs.Parse(args); err != nil && !errors.Is(err, pflag.ErrHelp) {
 		return cmdutil.InvocationContext{}, err
 	}
-
-	profileFromFlag := fs.Changed("profile")
-	if !profileFromFlag {
-		globals.Profile = os.Getenv(envvars.CliProfile)
-	}
-	return cmdutil.InvocationContext{
-		Profile:         globals.Profile,
-		ProfileFromFlag: profileFromFlag,
-	}, nil
+	return cmdutil.InvocationContext{Profile: globals.Profile}, nil
 }

cmd/bootstrap_test.go

@@ -3,11 +3,7 @@
 
 package cmd
 
-import (
-	"testing"
-
-	"github.com/larksuite/cli/internal/envvars"
-)
+import "testing"
 
 func TestBootstrapInvocationContext_ProfileFlag(t *testing.T) {
 	inv, err := BootstrapInvocationContext([]string{"--profile", "target", "auth", "status"})
@@ -74,58 +70,3 @@ func TestBootstrapInvocationContext_HelpWithProfile(t *testing.T) {
 		t.Fatalf("profile = %q, want %q", inv.Profile, "target")
 	}
 }
-
-func TestBootstrapProfileEnvFallback(t *testing.T) {
-	t.Run("flag wins over env", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "tenant_env")
-		inv, err := BootstrapInvocationContext([]string{"--profile", "tenant_flag", "whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "tenant_flag" {
-			t.Errorf("got %q, want tenant_flag", inv.Profile)
-		}
-		if !inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = false, want true")
-		}
-	})
-	t.Run("explicit empty flag clears env selection", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "tenant_env")
-		inv, err := BootstrapInvocationContext([]string{"--profile=", "whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "" {
-			t.Errorf("got %q, want empty", inv.Profile)
-		}
-		if !inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = false, want true")
-		}
-	})
-	t.Run("env used when flag absent", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "tenant_env")
-		inv, err := BootstrapInvocationContext([]string{"whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "tenant_env" {
-			t.Errorf("got %q, want tenant_env", inv.Profile)
-		}
-		if inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = true, want false")
-		}
-	})
-	t.Run("empty when neither set", func(t *testing.T) {
-		t.Setenv(envvars.CliProfile, "")
-		inv, err := BootstrapInvocationContext([]string{"whoami"})
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		if inv.Profile != "" {
-			t.Errorf("got %q, want empty", inv.Profile)
-		}
-		if inv.ProfileFromFlag {
-			t.Errorf("ProfileFromFlag = true, want false")
-		}
-	})
-}

cmd/config/bind.go

@@ -4,12 +4,18 @@
 package config
 
 import (
+	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
+	"path/filepath"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/charmbracelet/huh"
+	"github.com/gofrs/flock"
 	"github.com/spf13/cobra"
 
 	"github.com/larksuite/cli/errs"
@@ -22,9 +28,14 @@ import (
 	"github.com/larksuite/cli/internal/vfs"
 )
 
+const bindCommitLockTimeout = 5 * time.Second
+
+var bindCommitMu sync.Mutex
+
 // BindOptions holds all inputs for config bind.
 type BindOptions struct {
 	Factory *cmdutil.Factory
+	Ctx     context.Context
 	Source  string
 	AppID   string
 	// Identity selects one of two presets — "bot-only" or "user-default" —
@@ -94,6 +105,7 @@ Interactive terminal use: run with no flags to enter the TUI form.`,
   # Interactive (terminal user) — TUI prompts for everything:
   lark-cli config bind`,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			opts.Ctx = cmd.Context()
 			opts.langExplicit = cmd.Flags().Changed("lang")
 			if runF != nil {
 				return runF(opts)
@@ -139,10 +151,11 @@ func configBindRun(opts *BindOptions) error {
 		return nil
 	}
 
-	appConfig, err := resolveAccount(opts, source)
+	result, err := resolveAccount(opts, source)
 	if err != nil {
 		return err
 	}
+	appConfig := result.AppConfig
 	opts.Brand = string(appConfig.Brand)
 
 	if err := resolveIdentity(opts); err != nil {
@@ -151,10 +164,20 @@ func configBindRun(opts *BindOptions) error {
 	if err := warnIdentityEscalation(opts, existing.ConfigBytes); err != nil {
 		return err
 	}
-	applyPreferences(appConfig, opts, priorLang(existing.ConfigBytes))
+	if err := validateBindResult(bindContext(opts), opts, result); err != nil {
+		return err
+	}
+	applyPreferences(appConfig, opts, priorLangForApp(existing.ConfigBytes, appConfig.AppId))
 	noticeUserDefaultRisk(opts)
 
-	return commitBinding(opts, appConfig, existing.ConfigBytes, source, targetConfigPath)
+	return commitBinding(opts, result, existing.ConfigBytes, source, targetConfigPath)
+}
+
+func bindContext(opts *BindOptions) context.Context {
+	if opts != nil && opts.Ctx != nil {
+		return opts.Ctx
+	}
+	return context.Background()
 }
 
 // existingBinding is the outcome of checking whether a workspace was already
@@ -239,9 +262,15 @@ func finalizeSource(opts *BindOptions) (string, error) {
 // notice on success so the caller still sees that a rebind happened.
 // See existingBinding for the returned fields.
 func reconcileExistingBinding(opts *BindOptions, source, configPath string) (existingBinding, error) {
-	oldConfigData, _ := vfs.ReadFile(configPath)
-	if oldConfigData == nil {
-		return existingBinding{}, nil
+	oldConfigData, err := vfs.ReadFile(configPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return existingBinding{}, nil
+		}
+		return existingBinding{}, errs.NewConfigError(errs.SubtypeInvalidConfig,
+			"cannot read existing workspace config %s: %v", configPath, err).
+			WithHint("fix the file permissions or I/O error before binding").
+			WithCause(err)
 	}
 
 	if opts.IsTUI {
@@ -264,7 +293,7 @@ func reconcileExistingBinding(opts *BindOptions, source, configPath string) (exi
 // enumerate candidates, pick one via the shared decision layer, and build a
 // ready-to-persist AppConfig. Adding a new bind source only requires
 // implementing SourceBinder — none of the logic below needs to change.
-func resolveAccount(opts *BindOptions, source string) (*core.AppConfig, error) {
+func resolveAccount(opts *BindOptions, source string) (*BindResult, error) {
 	binder, err := newBinder(source, opts)
 	if err != nil {
 		return nil, err
@@ -278,7 +307,7 @@ func resolveAccount(opts *BindOptions, source string) (*core.AppConfig, error) {
 	if err != nil {
 		return nil, err
 	}
-	return binder.Build(picked.AppID)
+	return binder.Build(bindContext(opts), *picked)
 }
 
 // resolveIdentity ensures opts.Identity is set before applyPreferences runs.
@@ -389,10 +418,21 @@ func applyPreferences(appConfig *core.AppConfig, opts *BindOptions, prior i18n.L
 // wrong profile's preference into a re-bind when the workspace holds multiple
 // named profiles and the active one disagrees with Apps[0].
 func priorLang(previousConfigBytes []byte) i18n.Lang {
+	return priorLangForApp(previousConfigBytes, "")
+}
+
+func priorLangForApp(previousConfigBytes []byte, appID string) i18n.Lang {
 	var multi core.MultiAppConfig
 	if json.Unmarshal(previousConfigBytes, &multi) != nil {
 		return ""
 	}
+	if appID != "" {
+		for i := range multi.Apps {
+			if multi.Apps[i].AppId == appID {
+				return multi.Apps[i].Lang
+			}
+		}
+	}
 	if app := multi.CurrentAppConfig(""); app != nil {
 		return app.Lang
 	}
@@ -400,12 +440,16 @@ func priorLang(previousConfigBytes []byte) i18n.Lang {
 }
 
 // commitBinding finalizes the bind: atomic write of the new workspace config,
-// best-effort cleanup of stale keychain entries from the previous binding (if
-// any), and a JSON success envelope. Cleanup runs only after the new config
-// is durably written — if anything fails earlier, the old workspace stays
-// usable.
-func commitBinding(opts *BindOptions, appConfig *core.AppConfig, previousConfigBytes []byte, source, configPath string) error {
-	multi := &core.MultiAppConfig{Apps: []core.AppConfig{*appConfig}}
+// deferred provider-manifest commit for keyless binds, and a JSON success
+// envelope. The write and provider commit are serialized across CLI processes;
+// if the provider commit fails, the workspace write is rolled back before any
+// success output so an existing binding remains usable.
+func commitBinding(opts *BindOptions, result *BindResult, previousConfigBytes []byte, source, configPath string) error {
+	appConfig := result.AppConfig
+	multi, err := mergeBoundApp(appConfig, previousConfigBytes, opts.langExplicit)
+	if err != nil {
+		return err
+	}
 
 	if err := vfs.MkdirAll(core.GetConfigDir(), 0700); err != nil {
 		return errs.NewInternalError(errs.SubtypeFileIO, "failed to create workspace directory: %v", err).WithCause(err)
@@ -414,9 +458,38 @@ func commitBinding(opts *BindOptions, appConfig *core.AppConfig, previousConfigB
 	if err != nil {
 		return errs.NewInternalError(errs.SubtypeStorage, "failed to marshal config: %v", err).WithCause(err)
 	}
-	if err := validate.AtomicWrite(configPath, append(data, '\n'), 0600); err != nil {
+	releaseCommitLock, err := acquireBindCommitLock(opts)
+	if err != nil {
+		return err
+	}
+	commitLockHeld := true
+	defer func() {
+		if commitLockHeld {
+			releaseCommitLock()
+		}
+	}()
+	if err := ensureBindingSnapshotUnchanged(configPath, previousConfigBytes); err != nil {
+		return err
+	}
+	newConfigBytes := append(data, '\n')
+	if err := validate.AtomicWrite(configPath, newConfigBytes, 0600); err != nil {
 		return errs.NewInternalError(errs.SubtypeStorage, "failed to write config %s: %v", configPath, err).WithCause(err)
 	}
+	if result.commitProviderManifest != nil {
+		if err := result.commitProviderManifest(); err != nil {
+			rollbackErr := rollbackBindingConfig(configPath, previousConfigBytes, newConfigBytes)
+			if rollbackErr != nil {
+				return errs.NewInternalError(errs.SubtypeStorage,
+					"failed to persist keyless signer provider: %v; failed to restore workspace config: %v", err, rollbackErr).
+					WithCause(err)
+			}
+			return errs.NewInternalError(errs.SubtypeStorage,
+				"failed to persist keyless signer provider (workspace config restored): %v", err).
+				WithCause(err)
+		}
+	}
+	releaseCommitLock()
+	commitLockHeld = false
 
 	replaced := previousConfigBytes != nil
 	// uiMsg renders human-facing TUI text (stderr success banner). Follows
@@ -425,10 +498,6 @@ func commitBinding(opts *BindOptions, appConfig *core.AppConfig, previousConfigB
 	uiMsg := getBindMsg(opts.UILang)
 	display := sourceDisplayName(source)
 
-	if replaced {
-		cleanupKeychainFromData(opts.Factory.Keychain, previousConfigBytes, appConfig)
-	}
-
 	fmt.Fprintln(opts.Factory.IOStreams.ErrOut,
 		fmt.Sprintf(uiMsg.BindSuccessHeader, display)+"\n"+uiMsg.BindSuccessNotice)
 
@@ -470,6 +539,133 @@ func commitBinding(opts *BindOptions, appConfig *core.AppConfig, previousConfigB
 	return nil
 }
 
+func acquireBindCommitLock(opts *BindOptions) (func(), error) {
+	bindCommitMu.Lock()
+	lockDir := filepath.Join(core.GetBaseConfigDir(), "locks")
+	if err := vfs.MkdirAll(lockDir, 0700); err != nil {
+		bindCommitMu.Unlock()
+		return nil, errs.NewInternalError(errs.SubtypeStorage,
+			"failed to create bind lock directory: %v", err).WithCause(err)
+	}
+	fileLock := flock.New(filepath.Join(lockDir, "config-bind.lock"))
+	ctx, cancel := context.WithTimeout(bindContext(opts), bindCommitLockTimeout)
+	locked, err := fileLock.TryLockContext(ctx, 50*time.Millisecond)
+	cancel()
+	if err != nil || !locked {
+		bindCommitMu.Unlock()
+		if err == nil {
+			err = context.DeadlineExceeded
+		}
+		return nil, errs.NewInternalError(errs.SubtypeStorage,
+			"failed to acquire config bind lock: %v", err).WithCause(err)
+	}
+	return func() {
+		_ = fileLock.Unlock()
+		bindCommitMu.Unlock()
+	}, nil
+}
+
+func ensureBindingSnapshotUnchanged(configPath string, previousConfigBytes []byte) error {
+	current, err := vfs.ReadFile(configPath)
+	if err != nil {
+		if os.IsNotExist(err) && previousConfigBytes == nil {
+			return nil
+		}
+		return errs.NewInternalError(errs.SubtypeStorage,
+			"failed to recheck workspace config %s before binding: %v", configPath, err).WithCause(err)
+	}
+	if previousConfigBytes != nil && bytes.Equal(current, previousConfigBytes) {
+		return nil
+	}
+	return errs.NewConfigError(errs.SubtypeInvalidConfig,
+		"workspace config %s changed while the bind was being validated", configPath).
+		WithHint("retry config bind using the latest workspace state")
+}
+
+func rollbackBindingConfig(configPath string, previousConfigBytes, writtenConfigBytes []byte) error {
+	current, err := vfs.ReadFile(configPath)
+	if err != nil {
+		if os.IsNotExist(err) && previousConfigBytes == nil {
+			return nil
+		}
+		//nolint:forbidigo // intermediate rollback diagnostic; commitBinding wraps it into a typed storage error
+		return fmt.Errorf("recheck workspace config before rollback: %w", err)
+	}
+	if !bytes.Equal(current, writtenConfigBytes) {
+		//nolint:forbidigo // intermediate rollback diagnostic; commitBinding wraps it into a typed storage error
+		return fmt.Errorf("workspace config changed after the bind write; refusing to overwrite it during rollback")
+	}
+	if previousConfigBytes != nil {
+		return validate.AtomicWrite(configPath, previousConfigBytes, 0600)
+	}
+	if err := vfs.Remove(configPath); err != nil && !os.IsNotExist(err) {
+		return err
+	}
+	return nil
+}
+
+// mergeBoundApp upserts by unique appId and activates the target while
+// preserving every non-target profile and root policy.
+func mergeBoundApp(incoming *core.AppConfig, previousBytes []byte, langExplicit bool) (*core.MultiAppConfig, error) {
+	if incoming == nil || strings.TrimSpace(incoming.AppId) == "" {
+		return nil, errs.NewInternalError(errs.SubtypeSDKError, "config bind produced an empty app")
+	}
+	if previousBytes == nil {
+		return &core.MultiAppConfig{Apps: []core.AppConfig{*incoming}, CurrentApp: incoming.ProfileName()}, nil
+	}
+
+	var multi core.MultiAppConfig
+	if err := json.Unmarshal(previousBytes, &multi); err != nil {
+		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig,
+			"cannot update malformed workspace config: %v", err).WithCause(err)
+	}
+	match := -1
+	for i := range multi.Apps {
+		if multi.Apps[i].AppId != incoming.AppId {
+			continue
+		}
+		if match >= 0 {
+			return nil, errs.NewConfigError(errs.SubtypeInvalidConfig,
+				"appId %s appears in multiple CLI profiles", incoming.AppId).
+				WithHint("remove the duplicate profile before binding")
+		}
+		match = i
+	}
+
+	oldActive := ""
+	if active := multi.CurrentAppConfig(""); active != nil {
+		oldActive = active.ProfileName()
+	}
+	if match >= 0 {
+		old := multi.Apps[match]
+		incoming.Name = old.Name
+		incoming.Users = old.Users
+		if !langExplicit {
+			incoming.Lang = old.Lang
+		}
+		multi.Apps[match] = *incoming
+	} else {
+		for i := range multi.Apps {
+			if multi.Apps[i].Name != "" && multi.Apps[i].Name == incoming.AppId {
+				return nil, errs.NewConfigError(errs.SubtypeInvalidConfig,
+					"new appId %s conflicts with existing profile name", incoming.AppId).
+					WithHint("rename the existing profile before binding")
+			}
+		}
+		incoming.Name = ""
+		incoming.Users = []core.AppUser{}
+		multi.Apps = append(multi.Apps, *incoming)
+		match = len(multi.Apps) - 1
+	}
+
+	targetName := multi.Apps[match].ProfileName()
+	if oldActive != targetName {
+		multi.PreviousApp = oldActive
+		multi.CurrentApp = targetName
+	}
+	return &multi, nil
+}
+
 // cleanupKeychainFromData removes keychain entries referenced by a previous
 // config snapshot, skipping any entry whose keychain ID is still in use by
 // the new app config. This prevents rebinding the same appId from deleting

cmd/config/bind_test.go

@@ -84,6 +84,21 @@ func saveWorkspace(t *testing.T) {
 	t.Cleanup(func() { core.SetCurrentWorkspace(orig) })
 }
 
+func TestReconcileExistingBinding_ReadFailureIsNotTreatedAsMissing(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	if err := os.Mkdir(configPath, 0700); err != nil {
+		t.Fatal(err)
+	}
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	_, err := reconcileExistingBinding(&BindOptions{Factory: f}, "openclaw", configPath)
+	if err == nil || !strings.Contains(err.Error(), "cannot read existing workspace config") {
+		t.Fatalf("reconcileExistingBinding error = %v", err)
+	}
+	if info, statErr := os.Stat(configPath); statErr != nil || !info.IsDir() {
+		t.Fatalf("unreadable existing config was changed: info=%v error=%v", info, statErr)
+	}
+}
+
 // ── Command flag parsing tests (aligned with config_test.go pattern) ──
 
 func TestConfigBindCmd_FlagParsing(t *testing.T) {
@@ -1497,7 +1512,11 @@ func assertPresetApplied(t *testing.T, configPath string, wantStrict core.Strict
 	if len(multi.Apps) == 0 {
 		t.Fatalf("no apps in %s", configPath)
 	}
-	app := multi.Apps[0]
+	appPtr := multi.CurrentAppConfig("")
+	if appPtr == nil {
+		t.Fatalf("no current app in %s", configPath)
+	}
+	app := *appPtr
 	if app.StrictMode == nil || *app.StrictMode != wantStrict {
 		t.Errorf("StrictMode = %v, want %q", app.StrictMode, wantStrict)
 	}

cmd/config/binder.go

@@ -4,6 +4,7 @@
 package config
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -23,6 +24,19 @@ type Candidate struct {
 	Label string
 }
 
+// BindResult carries the selected app. External signer configuration is the
+// logical provider on AppConfig.KeyRef; bind never persists executable paths.
+type BindResult struct {
+	AppConfig *core.AppConfig
+
+	// commitProviderManifest is populated only after a keyless bind probe has
+	// authenticated successfully. commitBinding runs it after the workspace
+	// config write and rolls that write back if the global provider index cannot
+	// be committed, so a failed bind never changes the signer used by existing
+	// applications.
+	commitProviderManifest func() error
+}
+
 // SourceBinder abstracts a bind source (openclaw / hermes / future sources).
 // Implementations only list candidates and build an AppConfig for a chosen
 // candidate — they stay out of mode (TUI vs flag) and orchestration concerns.
@@ -34,9 +48,9 @@ type SourceBinder interface {
 	// ListCandidates enumerates bindable accounts from the source config.
 	// An empty slice is valid (selectCandidate will turn it into a typed error).
 	ListCandidates() ([]Candidate, error)
-	// Build resolves secrets, persists to keychain, and returns a ready AppConfig
-	// for the chosen candidate AppID. Must be called after ListCandidates succeeds.
-	Build(appID string) (*core.AppConfig, error)
+	// Build resolves credentials and returns the app plus any signer command
+	// needed by the workspace. Must be called after ListCandidates succeeds.
+	Build(ctx context.Context, candidate Candidate) (*BindResult, error)
 }
 
 // newBinder constructs the SourceBinder for the given source name.
@@ -93,11 +107,21 @@ func selectCandidate(
 	}
 
 	if appIDFlag != "" {
+		var matches []Candidate
 		for i := range candidates {
 			if candidates[i].AppID == appIDFlag {
-				return &candidates[i], nil
+				matches = append(matches, candidates[i])
 			}
 		}
+		if len(matches) == 1 {
+			return &matches[0], nil
+		}
+		if len(matches) > 1 {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"--app-id %q matches multiple accounts in %s", appIDFlag, cfgBase).
+				WithHint("run 'lark-cli config bind' interactively to choose an account, or configure unique app IDs:\n  %s", formatCandidates(matches)).
+				WithParam("--app-id")
+		}
 		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "--app-id %q not found in %s", appIDFlag, cfgBase).
 			WithHint("available app IDs:\n  %s", formatCandidates(candidates)).
 			WithParam("--app-id")
@@ -168,20 +192,48 @@ func (b *openclawBinder) ListCandidates() ([]Candidate, error) {
 	return result, nil
 }
 
-func (b *openclawBinder) Build(appID string) (*core.AppConfig, error) {
+func (b *openclawBinder) Build(_ context.Context, candidate Candidate) (*BindResult, error) {
 	if b.cfg == nil {
 		return nil, errs.NewInternalError(errs.SubtypeSDKError, "internal: Build called before ListCandidates")
 	}
 
 	var selected *binding.CandidateApp
 	for i := range b.rawApps {
-		if b.rawApps[i].AppID == appID {
+		if b.rawApps[i].AppID == candidate.AppID && b.rawApps[i].Label == candidate.Label {
 			selected = &b.rawApps[i]
 			break
 		}
 	}
 	if selected == nil {
-		return nil, errs.NewInternalError(errs.SubtypeSDKError, "internal: appID %q not in candidates", appID)
+		return nil, errs.NewInternalError(errs.SubtypeSDKError,
+			"internal: account %q (appID %q) not in candidates", candidate.Label, candidate.AppID)
+	}
+	if selected.AuthMethod != "" && selected.AuthMethod != "app_secret" && selected.AuthMethod != binding.AuthMethodPrivateKeyJWT {
+		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "unknown authMethod %q for app %s in %s", selected.AuthMethod, selected.AppID, b.path).
+			WithHint("supported values are app_secret and private_key_jwt")
+	}
+
+	// openclaw-lark deliberately gives appSecret precedence when both shapes
+	// are present. Reproduce that behavior so bind never changes the effective
+	// credential type merely because authMethod was left stale.
+	if selected.AppSecret.IsZero() && selected.AuthMethod == binding.AuthMethodPrivateKeyJWT {
+		if strings.TrimSpace(selected.KeyRef) == "" {
+			return nil, errs.NewConfigError(errs.SubtypeInvalidConfig,
+				"private_key_jwt app %s in %s is missing keyRef", selected.AppID, b.path).
+				WithHint("re-run OpenClaw onboarding so the keyless account records its signer keyRef")
+		}
+		return &BindResult{
+			AppConfig: &core.AppConfig{
+				AppId:      selected.AppID,
+				Brand:      core.ParseBrand(selected.Brand),
+				AuthMethod: core.AuthMethodPrivateKeyJWT,
+				KeyRef: &core.SecretRef{
+					Source:   core.SecretSourceTEE,
+					Provider: core.KeylessProviderLarkSuite,
+					ID:       strings.TrimSpace(selected.KeyRef),
+				},
+			},
+		}, nil
 	}
 
 	if selected.AppSecret.IsZero() {
@@ -202,11 +254,11 @@ func (b *openclawBinder) Build(appID string) (*core.AppConfig, error) {
 			WithCause(err)
 	}
 
-	return &core.AppConfig{
+	return &BindResult{AppConfig: &core.AppConfig{
 		AppId:     selected.AppID,
 		AppSecret: stored,
 		Brand:     core.ParseBrand(selected.Brand),
-	}, nil
+	}}, nil
 }
 
 // ──────────────────────────────────────────────────────────────
@@ -238,7 +290,8 @@ func (b *hermesBinder) ListCandidates() ([]Candidate, error) {
 	return []Candidate{{AppID: appID, Label: "default"}}, nil
 }
 
-func (b *hermesBinder) Build(appID string) (*core.AppConfig, error) {
+func (b *hermesBinder) Build(_ context.Context, candidate Candidate) (*BindResult, error) {
+	appID := candidate.AppID
 	if b.envMap == nil {
 		return nil, errs.NewInternalError(errs.SubtypeSDKError, "internal: Build called before ListCandidates")
 	}
@@ -258,11 +311,11 @@ func (b *hermesBinder) Build(appID string) (*core.AppConfig, error) {
 			WithCause(err)
 	}
 
-	return &core.AppConfig{
+	return &BindResult{AppConfig: &core.AppConfig{
 		AppId:     appID,
 		AppSecret: stored,
 		Brand:     core.ParseBrand(b.envMap["FEISHU_DOMAIN"]),
-	}, nil
+	}}, nil
 }
 
 // ──────────────────────────────────────────────────────────────
@@ -295,7 +348,8 @@ func (b *larkChannelBinder) ListCandidates() ([]Candidate, error) {
 	return []Candidate{{AppID: cfg.Accounts.App.ID, Label: "default"}}, nil
 }
 
-func (b *larkChannelBinder) Build(appID string) (*core.AppConfig, error) {
+func (b *larkChannelBinder) Build(_ context.Context, candidate Candidate) (*BindResult, error) {
+	appID := candidate.AppID
 	if b.cfg == nil {
 		return nil, errs.NewInternalError(errs.SubtypeSDKError, "internal: Build called before ListCandidates")
 	}
@@ -323,11 +377,11 @@ func (b *larkChannelBinder) Build(appID string) (*core.AppConfig, error) {
 			WithCause(err)
 	}
 
-	return &core.AppConfig{
+	return &BindResult{AppConfig: &core.AppConfig{
 		AppId:     appID,
 		AppSecret: stored,
 		Brand:     core.ParseBrand(b.cfg.Accounts.App.Tenant),
-	}, nil
+	}}, nil
 }
 
 // ──────────────────────────────────────────────────────────────

cmd/config/binder_test.go

@@ -4,10 +4,12 @@
 package config
 
 import (
+	"context"
 	"path/filepath"
 	"reflect"
 	"testing"
 
+	"github.com/larksuite/cli/internal/binding"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
 )
@@ -20,10 +22,10 @@ type fakeBinder struct {
 	path string
 }
 
-func (b *fakeBinder) Name() string                                { return b.name }
-func (b *fakeBinder) ConfigPath() string                          { return b.path }
-func (b *fakeBinder) ListCandidates() ([]Candidate, error)        { return nil, nil }
-func (b *fakeBinder) Build(appID string) (*core.AppConfig, error) { return nil, nil }
+func (b *fakeBinder) Name() string                                          { return b.name }
+func (b *fakeBinder) ConfigPath() string                                    { return b.path }
+func (b *fakeBinder) ListCandidates() ([]Candidate, error)                  { return nil, nil }
+func (b *fakeBinder) Build(context.Context, Candidate) (*BindResult, error) { return nil, nil }
 
 // tuiUnreachable is a tuiPrompt that fails the test if called. It's the
 // guardrail that proves the non-TUI decision paths really do stay out of the
@@ -107,6 +109,20 @@ func TestSelectCandidate_AppIDFlag_NoMatch(t *testing.T) {
 	})
 }
 
+func TestSelectCandidate_AppIDFlag_RejectsDuplicateInheritedAppID(t *testing.T) {
+	b := &fakeBinder{name: "openclaw", path: "/tmp/openclaw.json"}
+	candidates := []Candidate{
+		{AppID: "cli_shared", Label: "work"},
+		{AppID: "cli_shared", Label: "personal"},
+	}
+	_, err := selectCandidate(b, candidates, "cli_shared", false, tuiUnreachable(t))
+	assertExitError(t, err, output.ExitValidation, wantErrDetail{
+		Type:    "validation",
+		Message: `--app-id "cli_shared" matches multiple accounts in openclaw.json`,
+		Hint:    "run 'lark-cli config bind' interactively to choose an account, or configure unique app IDs:\n  cli_shared (work)\n  cli_shared (personal)",
+	})
+}
+
 func TestSelectCandidate_MultiCandidate_NoFlag_NonTUI(t *testing.T) {
 	// Flag-mode with multiple candidates and no --app-id must produce a
 	// validation error and the candidate list, never an interactive prompt.
@@ -175,6 +191,27 @@ func TestSelectCandidate_AppIDFlag_WinsOverTUI(t *testing.T) {
 	assertCandidate(t, got, Candidate{AppID: "cli_b"})
 }
 
+func TestOpenClawBuildUsesSelectedLabelWhenAppIDIsShared(t *testing.T) {
+	b := &openclawBinder{
+		cfg: &binding.OpenClawRoot{},
+		rawApps: []binding.CandidateApp{
+			{Label: "work", AppID: "cli_shared", AuthMethod: binding.AuthMethodPrivateKeyJWT, KeyRef: "work-key"},
+			{Label: "personal", AppID: "cli_shared", AuthMethod: binding.AuthMethodPrivateKeyJWT, KeyRef: "personal-key"},
+		},
+	}
+
+	result, err := b.Build(context.Background(), Candidate{AppID: "cli_shared", Label: "personal"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.AppConfig.KeyRef == nil || result.AppConfig.KeyRef.ID != "personal-key" {
+		t.Fatalf("keyRef = %#v, want personal-key", result.AppConfig.KeyRef)
+	}
+	if result.AppConfig.KeyRef.Provider != core.KeylessProviderLarkSuite {
+		t.Fatalf("provider = %q, want %q", result.AppConfig.KeyRef.Provider, core.KeylessProviderLarkSuite)
+	}
+}
+
 func TestResolveLarkChannelConfigPath_Default(t *testing.T) {
 	home := t.TempDir()
 	t.Setenv("HOME", home)

cmd/config/config.go

@@ -31,7 +31,6 @@ func NewCmdConfig(f *cmdutil.Factory) *cobra.Command {
 	cmd.AddCommand(NewCmdConfigShow(f, nil))
 	cmd.AddCommand(NewCmdConfigDefaultAs(f))
 	cmd.AddCommand(NewCmdConfigStrictMode(f))
-	cmd.AddCommand(NewCmdConfigRiskControl(f))
 	cmd.AddCommand(NewCmdConfigPolicy(f))
 	cmd.AddCommand(NewCmdConfigPlugins(f))
 	cmd.AddCommand(NewCmdConfigKeychainDowngrade(f))

cmd/config/config_test.go

@@ -65,6 +65,39 @@ func TestConfigInitCmd_FlagParsing(t *testing.T) {
 	}
 }
 
+func TestConfigInitCmd_PrivateKeyJWTFlag(t *testing.T) {
+	clearAgentEnv(t) // assumes local workspace; guard refuses init in agent contexts
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+
+	var gotOpts *ConfigInitOptions
+	cmd := NewCmdConfigInit(f, func(opts *ConfigInitOptions) error {
+		gotOpts = opts
+		return nil
+	})
+	cmd.SetArgs([]string{"--new", "--private-key-jwt"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !gotOpts.PrivateKeyJWT {
+		t.Error("PrivateKeyJWT = false, want true")
+	}
+}
+
+func TestConfigInitCmd_AuthMethodFlagRemoved(t *testing.T) {
+	clearAgentEnv(t) // assumes local workspace; guard refuses init in agent contexts
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+
+	cmd := NewCmdConfigInit(f, func(opts *ConfigInitOptions) error { return nil })
+	cmd.SetArgs([]string{"--new", "--auth-method", core.AuthMethodPrivateKeyJWT})
+	err := cmd.Execute()
+	if err == nil {
+		t.Fatal("expected unknown flag error")
+	}
+	if !strings.Contains(err.Error(), "unknown flag: --auth-method") {
+		t.Fatalf("error = %v, want unknown --auth-method flag", err)
+	}
+}
+
 func TestConfigShowCmd_FlagParsing(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
@@ -84,16 +117,6 @@ func TestConfigShowCmd_FlagParsing(t *testing.T) {
 	}
 }
 
-func TestConfigShowHelpClarifiesSavedConfig(t *testing.T) {
-	cmd := NewCmdConfigShow(nil, nil)
-	if !strings.Contains(cmd.Short, "saved config") {
-		t.Errorf("config show short = %q, want saved config", cmd.Short)
-	}
-	if !strings.Contains(cmd.Long, "lark-cli whoami --json") {
-		t.Errorf("config show help missing whoami route")
-	}
-}
-
 func TestConfigShowRun_NotConfiguredReturnsStructuredError(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 
@@ -116,77 +139,6 @@ func TestConfigShowRun_NotConfiguredReturnsStructuredError(t *testing.T) {
 	}
 }
 
-// config show promises "saved config, not current usage" (help + skill
-// routing): the session profile (--profile / LARKSUITE_CLI_PROFILE) must not
-// change what it shows.
-func TestConfigShowRun_IgnoresSessionProfile(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{
-			{Name: "tenant_a", AppId: "cli_a", AppSecret: core.PlainSecret("your-secret-a"), Brand: core.BrandFeishu},
-			{Name: "tenant_b", AppId: "cli_b", AppSecret: core.PlainSecret("your-secret-b"), Brand: core.BrandFeishu},
-		},
-	}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-	f.Invocation.Profile = "tenant_b" // session selection must not leak in
-
-	if err := configShowRun(&ConfigShowOptions{Factory: f}); err != nil {
-		t.Fatalf("configShowRun: %v", err)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, `"cli_a"`) || !strings.Contains(out, `"tenant_a"`) {
-		t.Fatalf("output = %s, want the saved default tenant_a/cli_a", out)
-	}
-	if strings.Contains(out, `"cli_b"`) {
-		t.Fatalf("output = %s, session profile tenant_b must not change saved-config view", out)
-	}
-}
-
-// engagedEnvStub simulates a fully engaged external credential provider.
-type engagedEnvStub struct{}
-
-func (engagedEnvStub) Name() string  { return "env" }
-func (engagedEnvStub) Priority() int { return 10 }
-func (engagedEnvStub) ResolveAccount(context.Context) (*extcred.Account, error) {
-	return &extcred.Account{AppID: "cli_env", AppSecret: "your-password"}, nil // managed takeover
-}
-func (engagedEnvStub) ResolveToken(context.Context, extcred.TokenSpec) (*extcred.Token, error) {
-	return nil, nil
-}
-
-// config show inspects the SAVED config only, so the parent command's
-// external-credential gate must not apply: even with a fully engaged direct
-// env credential, `config show` still answers from the saved config.
-func TestConfigShow_BypassesExternalCredentialGate(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name: "tenant_a", AppId: "cli_a", AppSecret: core.PlainSecret("your-secret-a"), Brand: core.BrandFeishu,
-		}},
-	}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
-	f.Credential = credential.NewCredentialProvider([]extcred.Provider{engagedEnvStub{}}, nil, nil, nil)
-
-	cmd := NewCmdConfig(f)
-	cmd.SetArgs([]string{"show"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("config show must bypass the external-credential gate: %v", err)
-	}
-	if out := stdout.String(); !strings.Contains(out, `"cli_a"`) {
-		t.Fatalf("output = %s, want the saved config shown", out)
-	}
-}
-
 func TestConfigShowRun_NoActiveProfileReturnsStructuredError(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	multi := &core.MultiAppConfig{
@@ -274,7 +226,7 @@ func TestSaveInitConfig_OmitLangPreservesPrior(t *testing.T) {
 		t.Fatalf("seed config: %v", err)
 	}
 
-	if err := saveInitConfig("", existing, f, "cli_x", core.PlainSecret("s2"), core.BrandFeishu, ""); err != nil {
+	if err := saveInitConfig("", existing, f, "cli_x", core.PlainSecret("s2"), core.BrandFeishu, "", "", nil); err != nil {
 		t.Fatalf("saveInitConfig (no --lang): %v", err)
 	}
 
@@ -287,6 +239,68 @@ func TestSaveInitConfig_OmitLangPreservesPrior(t *testing.T) {
 	}
 }
 
+func TestKeyRefFromResult_PrivateKeyJWT(t *testing.T) {
+	ref := keyRefFromResult(&configInitResult{
+		AuthMethod: core.AuthMethodPrivateKeyJWT,
+		KeyLabel:   "lark-cli-default",
+	})
+	if ref == nil {
+		t.Fatal("keyRefFromResult returned nil")
+	}
+	if ref.Source != "tee" || ref.ID != "lark-cli-default" {
+		t.Fatalf("key ref = %#v, want tee/lark-cli-default", ref)
+	}
+
+	if ref := keyRefFromResult(&configInitResult{AuthMethod: core.AuthMethodPrivateKeyJWT}); ref != nil {
+		t.Fatalf("missing key label should not persist key ref, got %#v", ref)
+	}
+	if ref := keyRefFromResult(&configInitResult{AuthMethod: core.AuthMethodClientSecret, KeyLabel: "ignored"}); ref != nil {
+		t.Fatalf("client_secret should not persist key ref, got %#v", ref)
+	}
+	if ref := keyRefFromResult(nil); ref != nil {
+		t.Fatalf("nil result should not persist key ref, got %#v", ref)
+	}
+}
+
+func TestPersistInitResult_PrivateKeyJWT(t *testing.T) {
+	for _, tc := range []struct {
+		name    string
+		profile string
+		brand   core.LarkBrand
+	}{
+		{name: "single app", brand: core.BrandFeishu},
+		{name: "named profile", profile: "prod", brand: core.BrandLark},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+			f, _, _, _ := cmdutil.TestFactory(t, nil)
+			opts := &ConfigInitOptions{Factory: f, Ctx: context.Background(), Lang: "en_us"}
+			result := &configInitResult{
+				Brand: tc.brand, AppID: "cli_pkjwt",
+				AuthMethod: core.AuthMethodPrivateKeyJWT, KeyLabel: "lark-cli-default",
+			}
+			if err := persistInitResult(opts, f, tc.profile, result); err != nil {
+				t.Fatal(err)
+			}
+
+			got, err := core.LoadMultiAppConfig()
+			if err != nil {
+				t.Fatal(err)
+			}
+			app := got.CurrentAppConfig(tc.profile)
+			if app == nil || app.AppId != "cli_pkjwt" || app.AuthMethod != core.AuthMethodPrivateKeyJWT {
+				t.Fatalf("saved app = %#v", app)
+			}
+			if app.KeyRef == nil || app.KeyRef.Source != "tee" || app.KeyRef.ID != "lark-cli-default" {
+				t.Fatalf("KeyRef = %#v, want tee/lark-cli-default", app.KeyRef)
+			}
+			if !app.AppSecret.IsZero() {
+				t.Fatalf("private_key_jwt config must stay secretless, AppSecret value %#v", app.AppSecret)
+			}
+		})
+	}
+}
+
 // TestConfigInitCmd_InvalidLang verifies a non-empty --lang on config init is
 // strictly validated the same way bind validates: wrong-case / typo / removed
 // codes / hyphen form all exit with ExitValidation. (Empty is a no-op.)
@@ -469,7 +483,7 @@ func TestSaveAsProfile_RejectsProfileNameCollisionWithExistingAppID(t *testing.T
 		},
 	}
 
-	err := saveAsProfile(existing, keychain.KeychainAccess(&noopConfigKeychain{}), "cli_prod", "app-new", core.PlainSecret("new-secret"), core.BrandLark, "en")
+	err := saveAsProfile(existing, keychain.KeychainAccess(&noopConfigKeychain{}), "cli_prod", "app-new", core.PlainSecret("new-secret"), core.BrandLark, "en", "", nil)
 	if err == nil {
 		t.Fatal("expected conflict error")
 	}
@@ -508,6 +522,46 @@ func TestWrapSaveConfigError_PassesTypedValidationThrough(t *testing.T) {
 	}
 }
 
+func TestSaveAsProfile_UpdatePersistsPrivateKeyJWT(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+
+	existing := &core.MultiAppConfig{
+		Apps: []core.AppConfig{{
+			Name:      "prod",
+			AppId:     "cli_prod",
+			AppSecret: core.PlainSecret("old-secret"),
+			Brand:     core.BrandFeishu,
+			Users:     []core.AppUser{{UserOpenId: "ou_1", UserName: "User"}},
+		}},
+	}
+	keyRef := &core.SecretRef{Source: "tee", ID: "lark-cli-default"}
+
+	if err := saveAsProfile(existing, keychain.KeychainAccess(&noopConfigKeychain{}), "prod", "cli_prod", core.SecretInput{}, core.BrandLark, "en_us", core.AuthMethodPrivateKeyJWT, keyRef); err != nil {
+		t.Fatalf("saveAsProfile update private_key_jwt: %v", err)
+	}
+
+	got, err := core.LoadMultiAppConfig()
+	if err != nil {
+		t.Fatalf("LoadMultiAppConfig: %v", err)
+	}
+	app := got.FindApp("prod")
+	if app == nil {
+		t.Fatalf("profile prod not saved: %#v", got.Apps)
+	}
+	if app.AuthMethod != core.AuthMethodPrivateKeyJWT {
+		t.Fatalf("AuthMethod = %q, want private_key_jwt", app.AuthMethod)
+	}
+	if app.KeyRef == nil || app.KeyRef.Source != "tee" || app.KeyRef.ID != "lark-cli-default" {
+		t.Fatalf("KeyRef = %#v, want tee/lark-cli-default", app.KeyRef)
+	}
+	if app.AppSecret.Ref != nil || app.AppSecret.Plain != "" {
+		t.Fatalf("private_key_jwt update must stay secretless, AppSecret value %#v", app.AppSecret)
+	}
+	if len(app.Users) != 1 || app.Users[0].UserOpenId != "ou_1" {
+		t.Fatalf("same-app update should preserve users, Users=%#v", app.Users)
+	}
+}
+
 func TestUpdateExistingProfileWithoutSecret_RejectsAppIDChange(t *testing.T) {
 	multi := &core.MultiAppConfig{
 		CurrentApp: "prod",
@@ -562,8 +616,7 @@ func TestConfigBlockedByExternalProvider(t *testing.T) {
 	}{
 		{"init", []string{"init", "--app-id", "x", "--app-secret-stdin"}},
 		{"remove", []string{"remove"}},
-		// "show" is deliberately absent: it inspects the SAVED config only
-		// and bypasses this gate (TestConfigShow_BypassesExternalCredentialGate).
+		{"show", []string{"show"}},
 		{"default-as", []string{"default-as", "user"}},
 		{"strict-mode", []string{"strict-mode", "off"}},
 	}

cmd/config/init.go

@@ -19,6 +19,7 @@ import (
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/i18n"
 	"github.com/larksuite/cli/internal/keychain"
+	"github.com/larksuite/cli/internal/keysigner"
 	"github.com/larksuite/cli/internal/output"
 )
 
@@ -31,6 +32,7 @@ type ConfigInitOptions struct {
 	AppSecretStdin bool   // read app-secret from stdin (avoids process list exposure)
 	Brand          string
 	New            bool
+	PrivateKeyJWT  bool // --private-key-jwt: request private_key_jwt instead of the default client_secret
 
 	Lang         string // raw --lang (string for cobra); normalized to canonical/"" in validateInitLang
 	langExplicit bool   // true when --lang was explicitly passed
@@ -39,6 +41,8 @@ type ConfigInitOptions struct {
 
 	ProfileName string // when set, create/update a named profile instead of replacing Apps[0]
 
+	Restore bool // Restore re-registers the app already in config to recover a lost credential
+
 	// ForceInit overrides the agent-workspace guard. Without it, running
 	// init under OPENCLAW_HOME / HERMES_HOME refuses and points the caller
 	// at config bind — which is what AI agents almost always want. Manual
@@ -81,17 +85,26 @@ if the user explicitly wants a separate app inside the Agent workspace.`,
 	}
 
 	cmd.Flags().BoolVar(&opts.New, "new", false, "create a new app directly (skip mode selection)")
+	cmd.Flags().BoolVar(&opts.PrivateKeyJWT, "private-key-jwt", false, "create a new app with private_key_jwt (signed by a platform key, no app secret)")
 	cmd.Flags().StringVar(&opts.AppID, "app-id", "", "App ID (non-interactive)")
 	cmd.Flags().BoolVar(&opts.AppSecretStdin, "app-secret-stdin", false, "Read App Secret from stdin to avoid process list exposure")
 	cmd.Flags().StringVar(&opts.Brand, "brand", "feishu", "feishu or lark (non-interactive, default feishu)")
 	cmd.Flags().StringVar(&opts.Lang, "lang", "", "language preference (e.g. zh or zh_cn)")
 	cmd.Flags().StringVar(&opts.ProfileName, "name", "", "create or update a named profile (append instead of replace)")
+	cmd.Flags().BoolVar(&opts.Restore, "restore", false, "re-register the app already in config to recover a lost credential (keychain key / app secret); reuses the stored app ID and auth method")
 	cmd.Flags().BoolVar(&opts.ForceInit, "force-init", false, "allow init inside an Agent workspace (OPENCLAW_HOME / HERMES_HOME); use config bind instead unless you really want a separate app")
 	cmdutil.SetRisk(cmd, "write")
 
 	return cmd
 }
 
+func requestedInitAuthMethod(opts *ConfigInitOptions) string {
+	if opts.PrivateKeyJWT {
+		return core.AuthMethodPrivateKeyJWT
+	}
+	return core.AuthMethodClientSecret
+}
+
 // printLangPreferenceConfirmation echoes the set preference to stderr, only
 // when --lang explicitly set a non-empty value.
 func printLangPreferenceConfirmation(opts *ConfigInitOptions) {
@@ -132,7 +145,7 @@ func guardAgentWorkspace(opts *ConfigInitOptions) error {
 
 // hasAnyNonInteractiveFlag returns true if any non-interactive flag is set.
 func (o *ConfigInitOptions) hasAnyNonInteractiveFlag() bool {
-	return o.New || o.AppID != "" || o.AppSecretStdin
+	return o.New || o.Restore || o.AppID != "" || o.AppSecretStdin
 }
 
 // cleanupOldConfig clears keychain entries (AppSecret + UAT) for all apps in existing config except the app whose AppId equals skipAppID.
@@ -151,22 +164,61 @@ func cleanupOldConfig(existing *core.MultiAppConfig, f *cmdutil.Factory, skipApp
 	}
 }
 
+// removeStaleSecretForPKJWT clears a secret left in the keychain when the SAME
+// appId is migrated from client_secret to private_key_jwt. cleanupOldConfig
+// explicitly skips a matching appId, and saveAsProfile only cleans up on an
+// appId change, so a same-appId migration would orphan the old secret. This
+// fills that gap. RemoveSecretStore only deletes Source=="keychain" entries, so
+// the new pkjwt tee key handle is never touched.
+func removeStaleSecretForPKJWT(existing *core.MultiAppConfig, profileName, appID string, kc keychain.KeychainAccess) {
+	if existing == nil {
+		return
+	}
+	var prior *core.AppConfig
+	if profileName != "" {
+		if idx := findProfileIndexByName(existing, profileName); idx >= 0 {
+			prior = &existing.Apps[idx]
+		}
+	} else {
+		prior = existing.CurrentAppConfig("")
+	}
+	if prior != nil && prior.AppId == appID && !prior.AppSecret.IsZero() {
+		core.RemoveSecretStore(prior.AppSecret, kc)
+	}
+}
+
+// keyRefFromResult builds the TEE key reference to persist for a private_key_jwt
+// registration result, or nil for client_secret.
+func keyRefFromResult(r *configInitResult) *core.SecretRef {
+	if r != nil && r.AuthMethod == core.AuthMethodPrivateKeyJWT && r.KeyLabel != "" {
+		return &core.SecretRef{Source: "tee", ID: r.KeyLabel}
+	}
+	return nil
+}
+
 // saveAsOnlyApp overwrites config.json with a single-app config.
-func saveAsOnlyApp(appId string, secret core.SecretInput, brand core.LarkBrand, lang string) error {
+func saveAsOnlyApp(appId string, secret core.SecretInput, brand core.LarkBrand, lang, authMethod string, keyRef *core.SecretRef) error {
 	config := &core.MultiAppConfig{
 		Apps: []core.AppConfig{{
 			AppId: appId, AppSecret: secret, Brand: brand, Lang: i18n.Lang(lang), Users: []core.AppUser{},
+			AuthMethod: authMethod, KeyRef: keyRef,
 		}},
 	}
+	return saveMultiAppConfigForInit(config)
+}
+
+func saveMultiAppConfigForInit(config *core.MultiAppConfig) error {
 	return core.SaveMultiAppConfig(config)
 }
 
 // saveInitConfig saves a new/updated app config, respecting --profile mode.
 // With profileName: appends or updates the named profile (preserves other profiles).
 // Without profileName: cleans up old config and saves as the only app.
-func saveInitConfig(profileName string, existing *core.MultiAppConfig, f *cmdutil.Factory, appId string, secret core.SecretInput, brand core.LarkBrand, lang string) error {
+// authMethod/keyRef carry the credential type: ("", nil) for client_secret,
+// (private_key_jwt, &{tee,label}) for the secretless TEE flow.
+func saveInitConfig(profileName string, existing *core.MultiAppConfig, f *cmdutil.Factory, appId string, secret core.SecretInput, brand core.LarkBrand, lang, authMethod string, keyRef *core.SecretRef) error {
 	if profileName != "" {
-		return saveAsProfile(existing, f.Keychain, profileName, appId, secret, brand, lang)
+		return saveAsProfile(existing, f.Keychain, profileName, appId, secret, brand, lang, authMethod, keyRef)
 	}
 	cleanupOldConfig(existing, f, appId)
 	var prior i18n.Lang
@@ -175,7 +227,7 @@ func saveInitConfig(profileName string, existing *core.MultiAppConfig, f *cmduti
 			prior = app.Lang
 		}
 	}
-	return saveAsOnlyApp(appId, secret, brand, string(preferredLang(i18n.Lang(lang), prior)))
+	return saveAsOnlyApp(appId, secret, brand, string(preferredLang(i18n.Lang(lang), prior)), authMethod, keyRef)
 }
 
 // wrapSaveConfigError passes an already-typed error (e.g. the --name conflict
@@ -195,7 +247,7 @@ func wrapSaveConfigError(err error) error {
 // saveAsProfile appends or updates a named profile in the config.
 // If a profile with the same name exists, it updates it; otherwise appends.
 // When updating, cleans up old keychain secrets if AppId changed.
-func saveAsProfile(existing *core.MultiAppConfig, kc keychain.KeychainAccess, profileName, appId string, secret core.SecretInput, brand core.LarkBrand, lang string) error {
+func saveAsProfile(existing *core.MultiAppConfig, kc keychain.KeychainAccess, profileName, appId string, secret core.SecretInput, brand core.LarkBrand, lang, authMethod string, keyRef *core.SecretRef) error {
 	multi := existing
 	if multi == nil {
 		multi = &core.MultiAppConfig{}
@@ -214,6 +266,8 @@ func saveAsProfile(existing *core.MultiAppConfig, kc keychain.KeychainAccess, pr
 		multi.Apps[idx].AppSecret = secret
 		multi.Apps[idx].Brand = brand
 		multi.Apps[idx].Lang = preferredLang(i18n.Lang(lang), multi.Apps[idx].Lang)
+		multi.Apps[idx].AuthMethod = authMethod
+		multi.Apps[idx].KeyRef = keyRef
 	} else {
 		if findAppIndexByAppID(multi, profileName) >= 0 {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument,
@@ -222,15 +276,17 @@ func saveAsProfile(existing *core.MultiAppConfig, kc keychain.KeychainAccess, pr
 		}
 		// Append new profile
 		multi.Apps = append(multi.Apps, core.AppConfig{
-			Name:      profileName,
-			AppId:     appId,
-			AppSecret: secret,
-			Brand:     brand,
-			Lang:      i18n.Lang(lang),
-			Users:     []core.AppUser{},
+			Name:       profileName,
+			AppId:      appId,
+			AppSecret:  secret,
+			Brand:      brand,
+			Lang:       i18n.Lang(lang),
+			Users:      []core.AppUser{},
+			AuthMethod: authMethod,
+			KeyRef:     keyRef,
 		})
 	}
-	return core.SaveMultiAppConfig(multi)
+	return saveMultiAppConfigForInit(multi)
 }
 
 func findProfileIndexByName(multi *core.MultiAppConfig, profileName string) int {
@@ -302,12 +358,141 @@ func updateExistingProfileWithoutSecret(existing *core.MultiAppConfig, profileNa
 	app.AppId = appID
 	app.Brand = brand
 	app.Lang = preferredLang(i18n.Lang(lang), app.Lang)
-	return core.SaveMultiAppConfig(existing)
+	return saveMultiAppConfigForInit(existing)
+}
+
+func persistInitResult(opts *ConfigInitOptions, f *cmdutil.Factory, profileName string, result *configInitResult) error {
+	existing, _ := core.LoadMultiAppConfig()
+
+	switch {
+	case result.AuthMethod == core.AuthMethodPrivateKeyJWT:
+		if err := saveInitConfig(profileName, existing, f, result.AppID, core.SecretInput{}, result.Brand, opts.Lang, result.AuthMethod, keyRefFromResult(result)); err != nil {
+			return wrapSaveConfigError(err)
+		}
+		removeStaleSecretForPKJWT(existing, profileName, result.AppID, f.Keychain)
+		return nil
+	case result.AppSecret != "":
+		secret, err := core.ForStorage(result.AppID, core.PlainSecret(result.AppSecret), f.Keychain)
+		if err != nil {
+			return errs.NewInternalError(errs.SubtypeSDKError, "%v", err).WithCause(err)
+		}
+		if err := saveInitConfig(profileName, existing, f, result.AppID, secret, result.Brand, opts.Lang, "", nil); err != nil {
+			return wrapSaveConfigError(err)
+		}
+		return nil
+	case result.Mode == "existing" && result.AppID != "":
+		return wrapUpdateExistingProfileErr(updateExistingProfileWithoutSecret(existing, profileName, result.AppID, result.Brand, opts.Lang))
+	default:
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "App ID and App Secret cannot be empty").WithParam("--app-id")
+	}
+}
+
+func probeInitResult(opts *ConfigInitOptions, f *cmdutil.Factory, result *configInitResult) error {
+	if result.AuthMethod == core.AuthMethodPrivateKeyJWT {
+		return runProbePKJWT(opts.Ctx, f, result.Brand, result.AppID, keysigner.Active(), result.KeyLabel)
+	}
+	if result.AppSecret != "" {
+		return runProbe(opts.Ctx, f, result.AppID, result.AppSecret, result.Brand)
+	}
+	return nil
+}
+
+// persistAndProbeResult saves a registration/restore result into profileName and
+// runs the post-registration probe. profileName == "" replaces the single app
+// (legacy); a named profile is updated in place. Shared by --new and --restore.
+func persistAndProbeResult(opts *ConfigInitOptions, f *cmdutil.Factory, profileName string, result *configInitResult) error {
+	if err := persistInitResult(opts, f, profileName, result); err != nil {
+		return err
+	}
+	printLangPreferenceConfirmation(opts)
+	if result.AuthMethod == core.AuthMethodPrivateKeyJWT {
+		output.PrintJson(f.IOStreams.Out, map[string]interface{}{"appId": result.AppID, "authMethod": result.AuthMethod, "brand": result.Brand})
+	} else {
+		output.PrintJson(f.IOStreams.Out, map[string]interface{}{"appId": result.AppID, "appSecret": "****", "brand": result.Brand})
+	}
+	return probeInitResult(opts, f, result)
+}
+
+// runRestoreFlow re-registers the app already in config to recover a lost
+// credential (deleted keychain key / lost app secret). It reads the existing
+// app id + auth method + brand from config (no secret needed — that's the lost
+// part) and re-runs the device-flow registration with the app id sent on begin,
+// so the server re-registers that app instead of creating a new one. The
+// re-issued credential is written back to the same profile.
+func runRestoreFlow(opts *ConfigInitOptions, existing *core.MultiAppConfig, f *cmdutil.Factory, msg *initMsg) error {
+	if existing == nil {
+		return errs.NewConfigError(errs.SubtypeNotConfigured, "nothing to restore: no config found").
+			WithHint("run: lark-cli config init")
+	}
+	app := existing.CurrentAppConfig(opts.ProfileName)
+	if app == nil || app.AppId == "" {
+		return errs.NewConfigError(errs.SubtypeNotConfigured, "nothing to restore: no app id in config%s", profileSuffix(opts.ProfileName)).
+			WithHint("run: lark-cli config init")
+	}
+	if app.KeyRef != nil && strings.TrimSpace(app.KeyRef.Provider) != "" {
+		return errs.NewValidationError(errs.SubtypeFailedPrecondition,
+			"config init --restore does not manage external signer provider %q", app.KeyRef.Provider).
+			WithHint("repair the OpenClaw provider with onboarding doctor --fix, then run config bind again")
+	}
+
+	restoreAppID := app.AppId
+	// Reuse the stored auth method authoritatively — never prompt. Empty on disk
+	// means client_secret (omitempty back-compat); pass it explicitly so restore
+	// preserves the existing credential type.
+	authMethod := app.AuthMethod
+	if authMethod == "" {
+		authMethod = core.AuthMethodClientSecret
+	}
+	result, err := runCreateAppFlow(opts.Ctx, f, app.Brand, authMethod, msg, restoreAppID)
+	if err != nil {
+		return err
+	}
+	if result == nil {
+		return errs.NewInternalError(errs.SubtypeSDKError, "app restore returned no result")
+	}
+
+	// Safety: if the server did not honor app_id (e.g. not yet supported), it may
+	// have created a NEW app instead of restoring. Warn so the user is not silently
+	// switched to a different app id.
+	if result.AppID != restoreAppID {
+		fmt.Fprintf(f.IOStreams.ErrOut, "[lark-cli] [WARN] restore: server returned app %s, expected %s — it may have created a new app instead of restoring\n", result.AppID, restoreAppID)
+	}
+
+	// Write back to the profile we restored: an explicit --name, else the resolved
+	// app's own name. Empty name => legacy single-app replace.
+	saveProfile := opts.ProfileName
+	if saveProfile == "" {
+		saveProfile = app.Name
+	}
+	return persistAndProbeResult(opts, f, saveProfile, result)
+}
+
+// profileSuffix renders " (profile %q)" for error messages, or "" when unnamed.
+func profileSuffix(profileName string) string {
+	if profileName == "" {
+		return ""
+	}
+	return fmt.Sprintf(" (profile %q)", profileName)
 }
 
 func configInitRun(opts *ConfigInitOptions) error {
 	f := opts.Factory
-
+	if opts.PrivateKeyJWT {
+		switch {
+		case opts.Restore:
+			return errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"--private-key-jwt cannot be combined with --restore; restore preserves the stored auth method").
+				WithParam("--private-key-jwt")
+		case opts.AppID != "":
+			return errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"--private-key-jwt cannot be combined with --app-id; use --new to register a private_key_jwt app").
+				WithParam("--private-key-jwt")
+		case opts.AppSecretStdin:
+			return errs.NewValidationError(errs.SubtypeInvalidArgument,
+				"--private-key-jwt cannot be combined with --app-secret-stdin; private_key_jwt does not use an app secret").
+				WithParam("--private-key-jwt")
+		}
+	}
 	// Read secret from stdin if --app-secret-stdin is set
 	if opts.AppSecretStdin {
 		scanner := bufio.NewScanner(f.IOStreams.In)
@@ -335,6 +520,26 @@ func configInitRun(opts *ConfigInitOptions) error {
 		}
 	}
 
+	// --restore recovers an existing app; it is incompatible with creating a new
+	// app (--new) or importing one non-interactively (--app-id / stdin secret).
+	if opts.Restore {
+		if opts.New {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--restore cannot be combined with --new").WithParam("--restore")
+		}
+		if opts.AppID != "" || opts.AppSecretStdin {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--restore cannot be combined with --app-id / --app-secret-stdin").WithParam("--restore")
+		}
+	}
+
+	// A user who explicitly asks for private_key_jwt needs immediate feedback
+	// before any interactive prompt. Otherwise unsupported machines enter the
+	// TUI and fail only after the user chooses a create flow.
+	if opts.PrivateKeyJWT && !opts.New && !opts.Restore {
+		if _, err := resolveRegisterAuthMethod(opts.Ctx, f, core.AuthMethodPrivateKeyJWT); err != nil {
+			return err
+		}
+	}
+
 	// Mode 1: Non-interactive
 	if opts.AppID != "" && opts.appSecret != "" {
 		brand := parseBrand(opts.Brand)
@@ -342,7 +547,7 @@ func configInitRun(opts *ConfigInitOptions) error {
 		if err != nil {
 			return errs.NewInternalError(errs.SubtypeSDKError, "%v", err).WithCause(err)
 		}
-		if err := saveInitConfig(opts.ProfileName, existing, f, opts.AppID, secret, brand, opts.Lang); err != nil {
+		if err := saveInitConfig(opts.ProfileName, existing, f, opts.AppID, secret, brand, opts.Lang, "", nil); err != nil {
 			return wrapSaveConfigError(err)
 		}
 		output.PrintSuccess(f.IOStreams.ErrOut, fmt.Sprintf("Configuration saved to %s", core.GetConfigPath()))
@@ -368,34 +573,26 @@ func configInitRun(opts *ConfigInitOptions) error {
 
 	msg := getInitMsg(opts.UILang)
 
+	// Mode: Restore (--restore) — re-register the app already in config.
+	if opts.Restore {
+		return runRestoreFlow(opts, existing, f, msg)
+	}
+
 	// Mode 3: Create new app directly (--new)
 	if opts.New {
-		result, err := runCreateAppFlow(opts.Ctx, f, parseBrand(opts.Brand), msg)
+		result, err := runCreateAppFlow(opts.Ctx, f, parseBrand(opts.Brand), requestedInitAuthMethod(opts), msg, "")
 		if err != nil {
 			return err
 		}
 		if result == nil {
 			return errs.NewInternalError(errs.SubtypeSDKError, "app creation returned no result")
 		}
-		existing, _ := core.LoadMultiAppConfig()
-		secret, err := core.ForStorage(result.AppID, core.PlainSecret(result.AppSecret), f.Keychain)
-		if err != nil {
-			return errs.NewInternalError(errs.SubtypeSDKError, "%v", err).WithCause(err)
-		}
-		if err := saveInitConfig(opts.ProfileName, existing, f, result.AppID, secret, result.Brand, opts.Lang); err != nil {
-			return wrapSaveConfigError(err)
-		}
-		printLangPreferenceConfirmation(opts)
-		output.PrintJson(f.IOStreams.Out, map[string]interface{}{"appId": result.AppID, "appSecret": "****", "brand": result.Brand})
-		if err := runProbe(opts.Ctx, f, result.AppID, result.AppSecret, result.Brand); err != nil {
-			return err
-		}
-		return nil
+		return persistAndProbeResult(opts, f, opts.ProfileName, result)
 	}
 
 	// Mode 4: Interactive TUI (terminal)
 	if !opts.hasAnyNonInteractiveFlag() && f.IOStreams.IsTerminal {
-		result, err := runInteractiveConfigInit(opts.Ctx, f, msg)
+		result, err := runInteractiveConfigInit(opts.Ctx, f, requestedInitAuthMethod(opts), msg)
 		if err != nil {
 			return err
 		}
@@ -404,35 +601,21 @@ func configInitRun(opts *ConfigInitOptions) error {
 				WithParam("--app-id")
 		}
 
-		existing, _ := core.LoadMultiAppConfig()
-
-		if result.AppSecret != "" {
-			// New secret provided (either from "create" or "existing" with input)
-			secret, err := core.ForStorage(result.AppID, core.PlainSecret(result.AppSecret), f.Keychain)
-			if err != nil {
-				return errs.NewInternalError(errs.SubtypeSDKError, "%v", err).WithCause(err)
-			}
-			if err := saveInitConfig(opts.ProfileName, existing, f, result.AppID, secret, result.Brand, opts.Lang); err != nil {
-				return wrapSaveConfigError(err)
-			}
-		} else if result.Mode == "existing" && result.AppID != "" {
-			// Existing app with unchanged secret — update app ID and brand only
-			if err := wrapUpdateExistingProfileErr(updateExistingProfileWithoutSecret(existing, opts.ProfileName, result.AppID, result.Brand, opts.Lang)); err != nil {
+		if err := persistInitResult(opts, f, opts.ProfileName, result); err != nil {
+			return err
+		}
+		if result.AuthMethod == core.AuthMethodPrivateKeyJWT {
+			if err := probeInitResult(opts, f, result); err != nil {
 				return err
 			}
-		} else {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "App ID and App Secret cannot be empty").
-				WithParam("--app-id")
 		}
 
 		if result.Mode == "existing" {
 			output.PrintSuccess(f.IOStreams.ErrOut, fmt.Sprintf(msg.ConfigSaved, result.AppID))
 		}
 		printLangPreferenceConfirmation(opts)
-		if result.AppSecret != "" {
-			if err := runProbe(opts.Ctx, f, result.AppID, result.AppSecret, result.Brand); err != nil {
-				return err
-			}
+		if result.AuthMethod != core.AuthMethodPrivateKeyJWT {
+			return probeInitResult(opts, f, result)
 		}
 		return nil
 	}
@@ -517,7 +700,7 @@ func configInitRun(opts *ConfigInitOptions) error {
 	if err != nil {
 		return errs.NewInternalError(errs.SubtypeSDKError, "%v", err).WithCause(err)
 	}
-	if err := saveInitConfig(opts.ProfileName, existing, f, resolvedAppId, storedSecret, parseBrand(resolvedBrand), opts.Lang); err != nil {
+	if err := saveInitConfig(opts.ProfileName, existing, f, resolvedAppId, storedSecret, parseBrand(resolvedBrand), opts.Lang, "", nil); err != nil {
 		return wrapSaveConfigError(err)
 	}
 	output.PrintSuccess(f.IOStreams.ErrOut, fmt.Sprintf("Configuration saved to %s", core.GetConfigPath()))

cmd/config/init_auth_method_test.go

@@ -0,0 +1,306 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package config
+
+import (
+	"context"
+	"crypto"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+type authMethodTestSigner struct {
+	info     keysigner.HardwareInfo
+	probeErr error
+}
+
+func (authMethodTestSigner) EnsureKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return nil, nil
+}
+
+func (authMethodTestSigner) PublicKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return nil, nil
+}
+
+func (authMethodTestSigner) Sign(context.Context, keysigner.KeyRef, []byte) ([]byte, string, error) {
+	return nil, "", nil
+}
+
+func (s authMethodTestSigner) ProbeHardware(context.Context) (keysigner.HardwareInfo, error) {
+	return s.info, s.probeErr
+}
+
+// TestResolveRegisterAuthMethod covers the non-interactive gating paths. The
+// darwin keychain signer is compiled into every build, so the test cannot rely
+// on the binary lacking a signer — it forces a known no-signer state for the
+// rejection cases, then registers a stub for the success case.
+func TestResolveRegisterAuthMethod(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	f := &cmdutil.Factory{}
+	ctx := context.Background()
+
+	prevSigner := keysigner.Active()
+	t.Cleanup(func() { keysigner.Register(prevSigner) })
+	keysigner.Register(nil)
+
+	if m, err := resolveRegisterAuthMethod(ctx, f, core.AuthMethodClientSecret); err != nil || m != core.AuthMethodClientSecret {
+		t.Errorf("client_secret: got (%q, %v), want (client_secret, nil)", m, err)
+	}
+
+	if m, err := resolveRegisterAuthMethod(ctx, f, ""); err != nil || m != core.AuthMethodClientSecret {
+		t.Errorf("default: got (%q, %v), want (client_secret, nil)", m, err)
+	}
+
+	if _, err := resolveRegisterAuthMethod(ctx, f, "bogus"); err == nil {
+		t.Error("bogus auth-method: expected error")
+	}
+
+	if _, err := resolveRegisterAuthMethod(ctx, f, core.AuthMethodPrivateKeyJWT); err == nil {
+		t.Error("private_key_jwt without a signer: expected error")
+	}
+
+	keysigner.Register(authMethodTestSigner{info: keysigner.HardwareInfo{Backend: "tpm2", Available: true}})
+
+	if m, err := resolveRegisterAuthMethod(ctx, f, core.AuthMethodPrivateKeyJWT); err != nil || m != core.AuthMethodPrivateKeyJWT {
+		t.Errorf("private_key_jwt with signer: got (%q, %v), want (private_key_jwt, nil)", m, err)
+	}
+
+	f.IOStreams = &cmdutil.IOStreams{IsTerminal: true}
+	if m, err := resolveRegisterAuthMethod(ctx, f, ""); err != nil || m != core.AuthMethodClientSecret {
+		t.Errorf("default with terminal signer: got (%q, %v), want (client_secret, nil)", m, err)
+	}
+}
+
+func TestConfigInitRunRejectsPrivateKeyJWTIncompatibleModes(t *testing.T) {
+	tests := []struct {
+		name       string
+		configure  func(*ConfigInitOptions, *cmdutil.Factory)
+		wantTarget string
+	}{
+		{
+			name: "app id import",
+			configure: func(opts *ConfigInitOptions, _ *cmdutil.Factory) {
+				opts.AppID = "cli_test"
+			},
+			wantTarget: "--app-id",
+		},
+		{
+			name: "app secret stdin import",
+			configure: func(opts *ConfigInitOptions, f *cmdutil.Factory) {
+				opts.AppSecretStdin = true
+				f.IOStreams.In = strings.NewReader("secret\n")
+			},
+			wantTarget: "--app-secret-stdin",
+		},
+		{
+			name: "restore",
+			configure: func(opts *ConfigInitOptions, _ *cmdutil.Factory) {
+				opts.Restore = true
+			},
+			wantTarget: "--restore",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+			f, _, _, _ := cmdutil.TestFactory(t, nil)
+			opts := &ConfigInitOptions{
+				Factory:       f,
+				Ctx:           context.Background(),
+				PrivateKeyJWT: true,
+			}
+			tc.configure(opts, f)
+
+			err := configInitRun(opts)
+			if err == nil {
+				t.Fatal("expected incompatible mode error")
+			}
+			problem, ok := errs.ProblemOf(err)
+			if !ok {
+				t.Fatalf("error is not typed: %T %[1]v", err)
+			}
+			if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
+				t.Fatalf("problem = %s/%s, want validation/invalid_argument", problem.Category, problem.Subtype)
+			}
+			var validationErr *errs.ValidationError
+			if !errors.As(err, &validationErr) {
+				t.Fatalf("error = %T, want *errs.ValidationError", err)
+			}
+			if validationErr.Param != "--private-key-jwt" {
+				t.Fatalf("param = %q, want --private-key-jwt", validationErr.Param)
+			}
+			if !strings.Contains(problem.Message, tc.wantTarget) {
+				t.Fatalf("message = %q, want %s", problem.Message, tc.wantTarget)
+			}
+		})
+	}
+}
+
+func TestResolveRegisterAuthMethod_PrivateKeyJWTRejectsUnavailableHardware(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	prevSigner := keysigner.Active()
+	t.Cleanup(func() { keysigner.Register(prevSigner) })
+	keysigner.Register(authMethodTestSigner{info: keysigner.HardwareInfo{
+		Backend: "tpm2",
+		Reason:  "open /dev/tpmrm0: permission denied",
+	}})
+
+	_, err := resolveRegisterAuthMethod(context.Background(), &cmdutil.Factory{}, core.AuthMethodPrivateKeyJWT)
+	if err == nil {
+		t.Fatal("private_key_jwt with unavailable signer hardware: expected error")
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error is not typed: %T %[1]v", err)
+	}
+	if problem.Category != errs.CategoryConfig || problem.Subtype != errs.SubtypeInvalidClient {
+		t.Fatalf("problem = %s/%s, want config/invalid_client", problem.Category, problem.Subtype)
+	}
+	wantMessage := "this machine does not support --private-key-jwt"
+	if problem.Message != wantMessage {
+		t.Fatalf("message = %q, want %q", problem.Message, wantMessage)
+	}
+	if strings.Contains(problem.Message, "sks") || strings.Contains(problem.Message, "/dev/tpm") || strings.Contains(problem.Message, "tpm") || strings.Contains(problem.Message, "TEE") || strings.Contains(problem.Message, "Keychain") {
+		t.Fatalf("message exposes backend detail: %q", problem.Message)
+	}
+	if !strings.Contains(problem.Hint, "omit --private-key-jwt") {
+		t.Fatalf("hint = %q, want guidance to omit --private-key-jwt", problem.Hint)
+	}
+	if strings.Contains(problem.Hint, "fix the local signer") {
+		t.Fatalf("hint exposes unnecessary signer recovery: %q", problem.Hint)
+	}
+}
+
+func TestResolveRegisterAuthMethod_PrivateKeyJWTRejectsProbeError(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	probeErr := errors.New("probe exploded")
+	prevSigner := keysigner.Active()
+	t.Cleanup(func() { keysigner.Register(prevSigner) })
+	keysigner.Register(authMethodTestSigner{
+		info:     keysigner.HardwareInfo{Backend: "keychain"},
+		probeErr: probeErr,
+	})
+
+	_, err := resolveRegisterAuthMethod(context.Background(), &cmdutil.Factory{}, core.AuthMethodPrivateKeyJWT)
+	if err == nil {
+		t.Fatal("private_key_jwt with probe error: expected error")
+	}
+	if !errors.Is(err, probeErr) {
+		t.Fatalf("error does not preserve probe cause: %v", err)
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error is not typed: %T %[1]v", err)
+	}
+	if problem.Category != errs.CategoryConfig || problem.Subtype != errs.SubtypeInvalidClient {
+		t.Fatalf("problem = %s/%s, want config/invalid_client", problem.Category, problem.Subtype)
+	}
+	wantMessage := "this machine does not support --private-key-jwt"
+	if problem.Message != wantMessage {
+		t.Fatalf("message = %q, want %q", problem.Message, wantMessage)
+	}
+	if strings.Contains(problem.Message, "probe") || strings.Contains(problem.Message, "keychain signer") {
+		t.Fatalf("message exposes probe detail: %q", problem.Message)
+	}
+	if !strings.Contains(problem.Hint, "omit --private-key-jwt") {
+		t.Fatalf("hint = %q, want guidance to omit --private-key-jwt", problem.Hint)
+	}
+	if strings.Contains(problem.Hint, "fix the local signer") {
+		t.Fatalf("hint exposes unnecessary signer recovery: %q", problem.Hint)
+	}
+}
+
+func TestConfigInitRun_PrivateKeyJWTRejectsBeforeInteractiveMode(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	prevSigner := keysigner.Active()
+	t.Cleanup(func() { keysigner.Register(prevSigner) })
+	keysigner.Register(authMethodTestSigner{info: keysigner.HardwareInfo{
+		Backend: "tpm2",
+		Reason:  "not available",
+	}})
+
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	f.IOStreams.IsTerminal = true
+	opts := &ConfigInitOptions{
+		Factory:       f,
+		Ctx:           context.Background(),
+		PrivateKeyJWT: true,
+		Lang:          "zh_cn",
+		UILang:        "zh_cn",
+	}
+
+	err := configInitRun(opts)
+	if err == nil {
+		t.Fatal("config init --private-key-jwt on unsupported machine: expected error before interactive mode")
+	}
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("error is not typed: %T %[1]v", err)
+	}
+	if problem.Category != errs.CategoryConfig || problem.Subtype != errs.SubtypeInvalidClient {
+		t.Fatalf("problem = %s/%s, want config/invalid_client", problem.Category, problem.Subtype)
+	}
+	if problem.Message != "this machine does not support --private-key-jwt" {
+		t.Fatalf("message = %q", problem.Message)
+	}
+}
+
+func TestExistingAppRequiresSecret(t *testing.T) {
+	if !existingAppRequiresSecret(core.AuthMethodClientSecret) {
+		t.Error("client_secret existing app should require App Secret")
+	}
+	if existingAppRequiresSecret("") != true {
+		t.Error("default existing app should require App Secret")
+	}
+	if existingAppRequiresSecret(core.AuthMethodPrivateKeyJWT) {
+		t.Error("private_key_jwt existing app should not require App Secret")
+	}
+}
+
+// TestValidatePKJWTKeyBinding covers the guard that rejects a registration
+// resolving to private_key_jwt with no signing key bound (e.g. an existing
+// secret-based app was selected on the confirm page).
+func TestValidatePKJWTKeyBinding(t *testing.T) {
+	if err := validatePKJWTKeyBinding(core.AuthMethodPrivateKeyJWT, ""); err == nil {
+		t.Error("pkjwt with empty keyLabel: expected error")
+	}
+	if err := validatePKJWTKeyBinding(core.AuthMethodPrivateKeyJWT, "agent-key"); err != nil {
+		t.Errorf("pkjwt with keyLabel: expected nil, got %v", err)
+	}
+	if err := validatePKJWTKeyBinding(core.AuthMethodClientSecret, ""); err != nil {
+		t.Errorf("client_secret: expected nil, got %v", err)
+	}
+}
+
+// TestResolveFinalAuthMethod locks the authoritative-method logic. The 2nd case
+// is the real bug: we requested private_key_jwt but the server resolved to an
+// existing client_secret app — we must persist client_secret, not pkjwt.
+func TestResolveFinalAuthMethod(t *testing.T) {
+	if m := resolveFinalAuthMethod([]string{"client_secret", "private_key_jwt"}, core.AuthMethodClientSecret); m != core.AuthMethodPrivateKeyJWT {
+		t.Errorf("prefers private_key_jwt: got %q", m)
+	}
+	if m := resolveFinalAuthMethod([]string{"client_secret"}, core.AuthMethodPrivateKeyJWT); m != core.AuthMethodClientSecret {
+		t.Errorf("server client_secret must override requested pkjwt: got %q", m)
+	}
+	if m := resolveFinalAuthMethod(nil, core.AuthMethodPrivateKeyJWT); m != core.AuthMethodPrivateKeyJWT {
+		t.Errorf("fallback to requested when server is silent: got %q", m)
+	}
+	// Explicit empty slice (not just nil) also falls back to requested — the same
+	// len()==0 back-compat allowance the init guard relies on to let private_key_jwt
+	// proceed against an older server (see internal/auth
+	// TestRequestAppRegistrationInit_EmptySupportedAuthMethods).
+	if m := resolveFinalAuthMethod([]string{}, core.AuthMethodPrivateKeyJWT); m != core.AuthMethodPrivateKeyJWT {
+		t.Errorf("empty []string should fall back to requested private_key_jwt: got %q", m)
+	}
+	if m := resolveFinalAuthMethod(nil, ""); m != core.AuthMethodClientSecret {
+		t.Errorf("default to client_secret: got %q", m)
+	}
+}

cmd/config/init_interactive.go

@@ -8,6 +8,9 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"slices"
+	"strings"
+	"time"
 
 	"github.com/charmbracelet/huh"
 	"github.com/larksuite/cli/internal/build"
@@ -15,22 +18,26 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	larkauth "github.com/larksuite/cli/internal/auth"
+	"github.com/larksuite/cli/internal/auth/jwt"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keysigner"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/transport"
 )
 
 // configInitResult holds the result of the interactive config init flow.
 type configInitResult struct {
-	Mode      string // "create" or "existing"
-	Brand     core.LarkBrand
-	AppID     string
-	AppSecret string
+	Mode       string // "create" or "existing"
+	Brand      core.LarkBrand
+	AppID      string
+	AppSecret  string
+	AuthMethod string // "" == client_secret; core.AuthMethodPrivateKeyJWT
+	KeyLabel   string // TEE key handle when AuthMethod == private_key_jwt
 }
 
 // runInteractiveConfigInit shows an interactive TUI for config init.
-func runInteractiveConfigInit(ctx context.Context, f *cmdutil.Factory, msg *initMsg) (*configInitResult, error) {
+func runInteractiveConfigInit(ctx context.Context, f *cmdutil.Factory, authMethodFlag string, msg *initMsg) (*configInitResult, error) {
 	// Phase 1: Choose mode
 	var mode string
 	form1 := huh.NewForm(
@@ -53,14 +60,18 @@ func runInteractiveConfigInit(ctx context.Context, f *cmdutil.Factory, msg *init
 	}
 
 	if mode == "existing" {
-		return runExistingAppForm(f, msg)
+		return runExistingAppForm(ctx, f, authMethodFlag, msg)
 	}
 
-	return runCreateAppFlow(ctx, f, "", msg)
+	return runCreateAppFlow(ctx, f, "", authMethodFlag, msg, "")
+}
+
+func existingAppRequiresSecret(requestedAuthMethod string) bool {
+	return requestedAuthMethod != core.AuthMethodPrivateKeyJWT
 }
 
 // runExistingAppForm shows a huh form for manually entering App ID / App Secret / Brand.
-func runExistingAppForm(f *cmdutil.Factory, msg *initMsg) (*configInitResult, error) {
+func runExistingAppForm(ctx context.Context, f *cmdutil.Factory, requestedAuthMethod string, msg *initMsg) (*configInitResult, error) {
 	// Load existing config for defaults
 	existing, _ := core.LoadMultiAppConfig()
 	var firstApp *core.AppConfig
@@ -94,19 +105,31 @@ func runExistingAppForm(f *cmdutil.Factory, msg *initMsg) (*configInitResult, er
 		brand = string(firstApp.Brand)
 	}
 
-	form := huh.NewForm(
-		huh.NewGroup(
-			appIDInput,
-			appSecretInput,
-			huh.NewSelect[string]().
-				Title(msg.Platform).
-				Options(
-					huh.NewOption(msg.Feishu, "feishu"),
-					huh.NewOption("Lark", "lark"),
-				).
-				Value(&brand),
-		),
-	).WithTheme(cmdutil.ThemeFeishu())
+	brandSelect := huh.NewSelect[string]().
+		Title(msg.Platform).
+		Options(
+			huh.NewOption(msg.Feishu, "feishu"),
+			huh.NewOption("Lark", "lark"),
+		).
+		Value(&brand)
+
+	var form *huh.Form
+	if existingAppRequiresSecret(requestedAuthMethod) {
+		form = huh.NewForm(
+			huh.NewGroup(
+				appIDInput,
+				appSecretInput,
+				brandSelect,
+			),
+		).WithTheme(cmdutil.ThemeFeishu())
+	} else {
+		form = huh.NewForm(
+			huh.NewGroup(
+				appIDInput,
+				brandSelect,
+			),
+		).WithTheme(cmdutil.ThemeFeishu())
+	}
 
 	if err := form.Run(); err != nil {
 		if err == huh.ErrUserAborted {
@@ -119,6 +142,13 @@ func runExistingAppForm(f *cmdutil.Factory, msg *initMsg) (*configInitResult, er
 	if appID == "" && firstApp != nil {
 		appID = firstApp.AppId
 	}
+	if !existingAppRequiresSecret(requestedAuthMethod) {
+		if appID == "" {
+			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "App ID cannot be empty").
+				WithParam("--app-id")
+		}
+		return runCreateAppFlow(ctx, f, parseBrand(brand), core.AuthMethodPrivateKeyJWT, msg, appID)
+	}
 	if appSecret == "" && firstApp != nil && !firstApp.AppSecret.IsZero() {
 		// Keep existing secret - caller will handle
 		return &configInitResult{
@@ -148,9 +178,49 @@ func runExistingAppForm(f *cmdutil.Factory, msg *initMsg) (*configInitResult, er
 	}, nil
 }
 
+// resolveRegisterAuthMethod decides the auth method for a new-app registration.
+// An explicit private_key_jwt request wins; otherwise the default is
+// client_secret with no extra prompt.
+func resolveRegisterAuthMethod(ctx context.Context, _ *cmdutil.Factory, requested string) (string, error) {
+	const pkjwtUnsupportedMessage = "this machine does not support --private-key-jwt"
+
+	switch requested {
+	case core.AuthMethodPrivateKeyJWT:
+		info, ok, err := keysigner.ProbeActiveHardware(ctx)
+		if !ok {
+			return "", errs.NewConfigError(errs.SubtypeInvalidClient,
+				pkjwtUnsupportedMessage).
+				WithHint("omit --private-key-jwt to register with an app secret")
+		}
+		if err != nil {
+			return "", errs.NewConfigError(errs.SubtypeInvalidClient,
+				pkjwtUnsupportedMessage).
+				WithCause(err).
+				WithHint("omit --private-key-jwt to register with an app secret")
+		}
+		if !info.Available {
+			return "", errs.NewConfigError(errs.SubtypeInvalidClient,
+				pkjwtUnsupportedMessage).
+				WithHint("omit --private-key-jwt to register with an app secret")
+		}
+		return core.AuthMethodPrivateKeyJWT, nil
+	case core.AuthMethodClientSecret:
+		return core.AuthMethodClientSecret, nil
+	case "":
+		return core.AuthMethodClientSecret, nil
+	default:
+		return "", errs.NewValidationError(errs.SubtypeInvalidArgument,
+			"unknown auth method %q (use client_secret or private_key_jwt)", requested)
+	}
+}
+
 // runCreateAppFlow runs the "create new app" flow via OpenClaw device flow.
 // If brandOverride is non-empty, skip the interactive brand selection.
-func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride core.LarkBrand, msg *initMsg) (*configInitResult, error) {
+// requestedAuthMethod is the requested auth method; empty means client_secret.
+// restoreAppID, when non-empty, is sent on the registration begin request so the
+// server re-registers that existing app (credential recovery) instead of creating
+// a new one. Empty preserves the normal new-app flow.
+func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride core.LarkBrand, requestedAuthMethod string, msg *initMsg, restoreAppID string) (*configInitResult, error) {
 	var larkBrand core.LarkBrand
 	if brandOverride != "" {
 		larkBrand = brandOverride
@@ -178,17 +248,57 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 		larkBrand = parseBrand(brand)
 	}
 
-	// Step 1: Request app registration (begin)
+	authMethod, err := resolveRegisterAuthMethod(ctx, f, requestedAuthMethod)
+	if err != nil {
+		return nil, err
+	}
+
+	// Step 1: Request app registration (begin).
 	// 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)
+
+	// For private_key_jwt: init to obtain a nonce, then sign a TEE attestation
+	// (carrying the public key in its jwk header) to send with begin.
+	beginOpts := larkauth.AppRegistrationBeginOptions{}
+	keyLabel := ""
+	if authMethod == core.AuthMethodPrivateKeyJWT {
+		initResp, initErr := larkauth.RequestAppRegistrationInit(ctx, httpClient)
+		if initErr != nil {
+			return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration init failed: %v", initErr).WithCause(initErr)
+		}
+		// An empty SupportedAuthMethods is intentionally treated as "older server /
+		// unknown": len()==0 makes this guard false, so the requested
+		// private_key_jwt proceeds. This mirrors resolveFinalAuthMethod's
+		// back-compat fallback to the requested method. Only an explicit list that
+		// omits private_key_jwt rejects here.
+		if len(initResp.SupportedAuthMethods) > 0 && !slices.Contains(initResp.SupportedAuthMethods, core.AuthMethodPrivateKeyJWT) {
+			return nil, errs.NewConfigError(errs.SubtypeInvalidClient,
+				"server does not support private_key_jwt for this app type (supported: %s)", strings.Join(initResp.SupportedAuthMethods, ", ")).
+				WithHint("omit --private-key-jwt to register with an app secret instead")
+		}
+		keyLabel = keysigner.DefaultKeyLabel
+		signer := keysigner.Active() // non-nil, guaranteed by resolveRegisterAuthMethod
+		attestation, signErr := jwt.SignAttestation(ctx, signer, keysigner.KeyRef{Label: keyLabel}, initResp.Nonce, time.Now())
+		if signErr != nil {
+			return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "failed to sign registration attestation: %v", signErr).WithCause(signErr)
+		}
+		beginOpts = larkauth.AppRegistrationBeginOptions{
+			AuthMethod:      core.AuthMethodPrivateKeyJWT,
+			AuthAttestation: attestation,
+		}
+	}
+
+	// Restore flow: re-register the existing app instead of creating a new one.
+	beginOpts.RestoreAppID = restoreAppID
+
+	authResp, err := larkauth.RequestAppRegistration(ctx, httpClient, larkBrand, beginOpts, f.IOStreams.ErrOut)
 	if err != nil {
 		return nil, classifyRegistrationBeginError(err)
 	}
 
 	// Step 2: Build and display verification URL + QR code
-	verificationURL := larkauth.BuildVerificationURL(authResp.VerificationUriComplete, build.Version)
+	verificationURL := larkauth.BuildVerificationURL(authResp.VerificationUriComplete, build.Version, restoreAppID)
 
 	// Branch on TTY: human-friendly copy in interactive terminals,
 	// preserve original copy for AI / non-interactive callers.
@@ -217,18 +327,42 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 		return nil, classifyRegistrationError(err)
 	}
 
-	if result.ClientID == "" || result.ClientSecret == "" {
-		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration succeeded but missing client_id or client_secret")
+	// The final auth method is decided by the user/admin at confirmation and
+	// returned by poll — NOT necessarily what we requested. Selecting an existing
+	// client_secret app, for example, yields client_secret even though we sent
+	// private_key_jwt. Trust the result so we persist the truth.
+	finalMethod := resolveFinalAuthMethod(result.AuthMethods, authMethod)
+
+	if result.ClientID == "" {
+		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration succeeded but missing app_id")
+	}
+	if finalMethod != core.AuthMethodPrivateKeyJWT && result.ClientSecret == "" {
+		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration succeeded but missing client_secret")
 	}
 
+	// Surface a downgrade: requested private_key_jwt but the app resolved to a
+	// secret-based method (e.g. an existing app was selected). The key was NOT
+	// bound, so we must store the secret method, not private_key_jwt.
+	if authMethod == core.AuthMethodPrivateKeyJWT && finalMethod != core.AuthMethodPrivateKeyJWT {
+		fmt.Fprintf(f.IOStreams.ErrOut, "[lark-cli] note: requested private_key_jwt, but the app uses %q (e.g. an existing app was selected); storing %q.\n", finalMethod, finalMethod)
+	}
 	fmt.Fprintln(f.IOStreams.ErrOut)
 	output.PrintSuccess(f.IOStreams.ErrOut, fmt.Sprintf(msg.AppCreated, result.ClientID))
 
+	keyToStore := ""
+	if finalMethod == core.AuthMethodPrivateKeyJWT {
+		keyToStore = keyLabel
+	}
+	if err := validatePKJWTKeyBinding(finalMethod, keyToStore); err != nil {
+		return nil, err
+	}
 	return &configInitResult{
-		Mode:      "create",
-		Brand:     finalBrand,
-		AppID:     result.ClientID,
-		AppSecret: result.ClientSecret,
+		Mode:       "create",
+		Brand:      finalBrand,
+		AppID:      result.ClientID,
+		AppSecret:  result.ClientSecret, // empty for private_key_jwt; real secret otherwise
+		AuthMethod: finalMethod,
+		KeyLabel:   keyToStore,
 	}, nil
 }
 
@@ -268,3 +402,41 @@ func classifyRegistrationError(err error) error {
 		return errs.NewAuthenticationError(errs.SubtypeUnknown, "app registration failed: %v", err).WithCause(err)
 	}
 }
+
+// validatePKJWTKeyBinding rejects a registration that resolved to
+// private_key_jwt without a signing key bound to it. keyLabel is non-empty only
+// when the local flow chose private_key_jwt and signed a TEE attestation; a
+// resolved method of private_key_jwt with no key handle would save an unusable
+// config (rejected later at config load, surfacing as "saved OK, fails on first
+// use"), so it is caught here at registration time instead.
+func validatePKJWTKeyBinding(finalMethod, keyLabel string) error {
+	if finalMethod == core.AuthMethodPrivateKeyJWT && keyLabel == "" {
+		return errs.NewConfigError(errs.SubtypeInvalidClient,
+			"registration resolved to private_key_jwt but no signing key was bound to this app (an existing secret-based app may have been selected)").
+			WithHint("re-register with: lark-cli config init --new --private-key-jwt")
+	}
+	return nil
+}
+
+// resolveFinalAuthMethod picks the authoritative method from the poll result,
+// preferring private_key_jwt, then client_secret. It falls back to the requested
+// method when the server returns nothing (older servers).
+func resolveFinalAuthMethod(serverMethods []string, requested string) string {
+	if len(serverMethods) == 0 {
+		if requested == "" {
+			return core.AuthMethodClientSecret
+		}
+		return requested
+	}
+	for _, m := range serverMethods {
+		if m == core.AuthMethodPrivateKeyJWT {
+			return core.AuthMethodPrivateKeyJWT
+		}
+	}
+	for _, m := range serverMethods {
+		if m == core.AuthMethodClientSecret {
+			return core.AuthMethodClientSecret
+		}
+	}
+	return serverMethods[0]
+}

cmd/config/init_probe.go

@@ -16,6 +16,7 @@ import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/keysigner"
 )
 
 // probeTimeout is the total wall-clock budget for the credential probe step
@@ -90,3 +91,35 @@ func runProbe(parent context.Context, factory *cmdutil.Factory, appID, appSecret
 	_, _ = io.Copy(io.Discard, resp.Body)
 	return nil
 }
+
+// runProbePKJWT does a best-effort key-binding validation after a private_key_jwt
+// config is saved: it signs a client_assertion with the local platform key and
+// mints a token. A typed error (a deterministic server rejection — e.g. the key
+// is not bound to this app) is propagated so `config init` exits non-zero with
+// the canonical envelope; untyped errors (transport / HTTP / parse / timeout)
+// are swallowed (return nil). The mint itself is the probe — no second call.
+func runProbePKJWT(parent context.Context, factory *cmdutil.Factory, brand core.LarkBrand, clientID string, signer keysigner.Signer, keyLabel string) error {
+	if factory == nil {
+		return nil
+	}
+	if signer == nil {
+		return nil
+	}
+	httpClient, err := factory.HttpClient()
+	if err != nil {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(parent, probeTimeout)
+	defer cancel()
+
+	if _, err := credential.FetchTATWithAssertion(ctx, httpClient, brand, clientID, signer, keyLabel); err != nil {
+		// Typed = deterministic credential rejection → propagate. Untyped
+		// (transport / HTTP / parse / timeout) is ambiguous → stay silent.
+		if errs.IsTyped(err) {
+			return err
+		}
+		return nil
+	}
+	return nil
+}

cmd/config/init_probe_test.go

@@ -6,6 +6,11 @@ package config
 import (
 	"bytes"
 	"context"
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	crand "crypto/rand"
+	"crypto/sha256"
 	"errors"
 	"io"
 	"net/http"
@@ -17,14 +22,17 @@ import (
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keysigner"
 )
 
 // fakeRT routes requests to per-path handlers and records what it saw.
 type fakeRT struct {
 	tatHandler   func(req *http.Request) (*http.Response, error)
 	probeHandler func(req *http.Request) (*http.Response, error)
+	oauthHandler func(req *http.Request) (*http.Response, error)
 	tatCalls     int
 	probeCalls   int
+	oauthCalls   int
 	probeReq     *http.Request
 	probeBody    string
 }
@@ -48,10 +56,50 @@ func (f *fakeRT) RoundTrip(req *http.Request) (*http.Response, error) {
 			return jsonResp(200, `{"code":0,"data":{},"msg":"success"}`), nil
 		}
 		return f.probeHandler(req)
+	case strings.HasSuffix(req.URL.Path, "/authen/v2/oauth/token"):
+		f.oauthCalls++
+		if f.oauthHandler == nil {
+			return jsonResp(200, `{"access_token":"test-token"}`), nil
+		}
+		return f.oauthHandler(req)
 	}
 	return nil, errors.New("unexpected URL: " + req.URL.String())
 }
 
+// probeTestSigner is an in-memory real ECDSA P-256 signer used to sign the
+// client_assertion in runProbePKJWT tests (authMethodTestSigner returns a nil
+// key and cannot sign).
+type probeTestSigner struct{ key *ecdsa.PrivateKey }
+
+func newProbeTestSigner(t *testing.T) *probeTestSigner {
+	t.Helper()
+	k, err := ecdsa.GenerateKey(elliptic.P256(), crand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &probeTestSigner{key: k}
+}
+
+func (p *probeTestSigner) EnsureKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return p.key.Public(), nil
+}
+
+func (p *probeTestSigner) PublicKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return p.key.Public(), nil
+}
+
+func (p *probeTestSigner) Sign(_ context.Context, _ keysigner.KeyRef, in []byte) ([]byte, string, error) {
+	h := sha256.Sum256(in)
+	r, s, err := ecdsa.Sign(crand.Reader, p.key, h[:])
+	if err != nil {
+		return nil, "", err
+	}
+	sig := make([]byte, 64)
+	r.FillBytes(sig[:32])
+	s.FillBytes(sig[32:])
+	return sig, keysigner.AlgES256, nil
+}
+
 func jsonResp(code int, body string) *http.Response {
 	return &http.Response{
 		StatusCode: code,
@@ -208,10 +256,12 @@ func TestRunProbe_TATSuccess_ProbeFails_Silent(t *testing.T) {
 	assertSilent(t, err, errBuf)
 }
 
-func TestRunProbe_TATSuccess_ProbeOK_Silent(t *testing.T) {
+func TestProbeInitResult_ClientSecret(t *testing.T) {
 	rt := &fakeRT{}
 	f, errBuf := fakeFactory(t, rt)
-	err := runProbe(context.Background(), f, "cli_x", "secret_y", core.BrandFeishu)
+	opts := &ConfigInitOptions{Ctx: context.Background()}
+	result := &configInitResult{AppID: "cli_x", AppSecret: "test-secret", Brand: core.BrandFeishu}
+	err := probeInitResult(opts, f, result)
 	if rt.tatCalls != 1 || rt.probeCalls != 1 {
 		t.Errorf("expected 1/1 calls, got tat=%d probe=%d", rt.tatCalls, rt.probeCalls)
 	}
@@ -285,3 +335,47 @@ func TestRunProbe_TimeoutHonored(t *testing.T) {
 	// must stay silent and not block.
 	assertSilent(t, err, errBuf)
 }
+
+// runProbePKJWT: a deterministic server rejection (invalid_client) is propagated
+// as a typed ConfigError so config init exits non-zero.
+func TestRunProbePKJWT_DeterministicReject_Propagates(t *testing.T) {
+	rt := &fakeRT{oauthHandler: func(*http.Request) (*http.Response, error) {
+		return jsonResp(401, `{"error":"invalid_client","error_description":"unknown key"}`), nil
+	}}
+	f, errBuf := fakeFactory(t, rt)
+	err := runProbePKJWT(context.Background(), f, core.BrandFeishu, "cli_x", newProbeTestSigner(t), "agent-key")
+	if err == nil || !errs.IsTyped(err) {
+		t.Fatalf("expected propagated typed error, got %T %v", err, err)
+	}
+	if errBuf.Len() != 0 {
+		t.Errorf("runProbePKJWT must not write stderr, got %q", errBuf.String())
+	}
+}
+
+// runProbePKJWT: ambiguous upstream noise (HTTP 503) is swallowed — silent, exit 0.
+func TestRunProbePKJWT_Ambiguous_Silent(t *testing.T) {
+	rt := &fakeRT{oauthHandler: func(*http.Request) (*http.Response, error) {
+		return jsonResp(503, `unavailable`), nil
+	}}
+	f, errBuf := fakeFactory(t, rt)
+	assertSilent(t, runProbePKJWT(context.Background(), f, core.BrandFeishu, "cli_x", newProbeTestSigner(t), "agent-key"), errBuf)
+}
+
+// probeInitResult dispatches private_key_jwt to the assertion-backed probe.
+func TestProbeInitResult_PrivateKeyJWT(t *testing.T) {
+	rt := &fakeRT{} // default oauth handler returns 200 + access_token
+	f, errBuf := fakeFactory(t, rt)
+	previous := keysigner.Active()
+	keysigner.Register(newProbeTestSigner(t))
+	t.Cleanup(func() { keysigner.Register(previous) })
+	opts := &ConfigInitOptions{Ctx: context.Background()}
+	result := &configInitResult{AppID: "cli_x", AuthMethod: core.AuthMethodPrivateKeyJWT, KeyLabel: "agent-key", Brand: core.BrandFeishu}
+	assertSilent(t, probeInitResult(opts, f, result), errBuf)
+}
+
+// runProbePKJWT: a nil signer is a defensive no-op (should not be reached, must
+// not panic).
+func TestRunProbePKJWT_NilSigner_Silent(t *testing.T) {
+	f, errBuf := fakeFactory(t, &fakeRT{})
+	assertSilent(t, runProbePKJWT(context.Background(), f, core.BrandFeishu, "cli_x", nil, "k"), errBuf)
+}

cmd/config/init_test.go

@@ -10,9 +10,25 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/output"
 )
 
+// TestRunRestoreFlow_NothingToRestore covers the early guards that return before
+// any network/registration call: no config at all, and a config whose resolved
+// app has no app id (nothing to send on begin).
+func TestRunRestoreFlow_NothingToRestore(t *testing.T) {
+	// No config on disk.
+	if err := runRestoreFlow(&ConfigInitOptions{}, nil, nil, nil); err == nil {
+		t.Fatal("expected error when there is no config to restore")
+	}
+	// Config present but the resolved app has no app id.
+	existing := &core.MultiAppConfig{Apps: []core.AppConfig{{AppId: ""}}}
+	if err := runRestoreFlow(&ConfigInitOptions{}, existing, nil, nil); err == nil {
+		t.Fatal("expected error when the resolved app has no app id")
+	}
+}
+
 // updateExistingProfileWithoutSecret guards four blank-input scenarios. Each
 // must surface as *ValidationError(SubtypeInvalidArgument) per RFC 6749 §5.2:
 // SubtypeInvalidClient is reserved for IAM rejection of malformed credentials,
@@ -119,3 +135,58 @@ func assertValidationParam(t *testing.T, err error, wantParam string) {
 		t.Errorf("Param = %q, want %q", valErr.Param, wantParam)
 	}
 }
+
+// countingKeychain is an in-memory KeychainAccess that records whether Remove
+// was invoked, so the stale-secret cleanup can be asserted without a real OS
+// keychain.
+type countingKeychain struct {
+	store        map[string]string
+	removeCalled bool
+}
+
+func newCountingKeychain() *countingKeychain {
+	return &countingKeychain{store: map[string]string{}}
+}
+
+func (k *countingKeychain) Get(service, account string) (string, error) {
+	v, ok := k.store[service+"/"+account]
+	if !ok {
+		return "", keychain.ErrNotFound
+	}
+	return v, nil
+}
+
+func (k *countingKeychain) Set(service, account, value string) error {
+	k.store[service+"/"+account] = value
+	return nil
+}
+
+func (k *countingKeychain) Remove(service, account string) error {
+	k.removeCalled = true
+	delete(k.store, service+"/"+account)
+	return nil
+}
+
+func TestRemoveStaleSecretForPKJWT_SameAppID(t *testing.T) {
+	kc := newCountingKeychain()
+	ref, err := core.ForStorage("cli_same", core.PlainSecret("old-secret"), kc) // → Source:"keychain"
+	if err != nil {
+		t.Fatal(err)
+	}
+	existing := &core.MultiAppConfig{Apps: []core.AppConfig{{AppId: "cli_same", AppSecret: ref}}}
+	removeStaleSecretForPKJWT(existing, "", "cli_same", kc)
+	if !kc.removeCalled {
+		t.Error("same appId with keychain secret: expected kc.Remove to be invoked")
+	}
+}
+
+func TestRemoveStaleSecretForPKJWT_DifferentAppID(t *testing.T) {
+	kc := newCountingKeychain()
+	ref, _ := core.ForStorage("cli_old", core.PlainSecret("old-secret"), kc)
+	kc.removeCalled = false // ForStorage does not call Remove, but reset to be safe
+	existing := &core.MultiAppConfig{Apps: []core.AppConfig{{AppId: "cli_old", AppSecret: ref}}}
+	removeStaleSecretForPKJWT(existing, "", "cli_new", kc)
+	if kc.removeCalled {
+		t.Error("different appId: must NOT remove")
+	}
+}

cmd/config/keyless_bind.go

@@ -0,0 +1,86 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package config
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/keylessprovider"
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+const keylessBindProbeTimeout = 12 * time.Second
+
+var fetchTATForBind = fetchTATForFreshBind
+
+func fetchTATForFreshBind(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, clientID string, signer keysigner.Signer, provider, keyRef string) (string, func() error, error) {
+	helper, commitProviderManifest, err := keylessprovider.PrepareRefresh(ctx, provider)
+	if err != nil {
+		return "", nil, err
+	}
+	token, err := credential.FetchTATWithAssertionWithHelper(ctx, httpClient, brand, clientID, signer, helper, keyRef)
+	if err != nil {
+		return "", nil, err
+	}
+	return token, commitProviderManifest, nil
+}
+
+// validateBindResult proves that an OpenClaw keyless account can be used by
+// the exact helper/keyRef/appID tuple that will be persisted. Minting a TAT is
+// intentional: pubkey alone only proves that the helper runs (and some signer
+// implementations create a missing key during pubkey); a successful token mint
+// proves that this public key is already registered to the selected app, so no
+// attach flow or second user authorization is needed.
+func validateBindResult(parent context.Context, opts *BindOptions, result *BindResult) error {
+	if result == nil || result.AppConfig == nil {
+		return errs.NewInternalError(errs.SubtypeSDKError, "config bind produced no app configuration")
+	}
+	app := result.AppConfig
+	if app.AuthMethod != core.AuthMethodPrivateKeyJWT {
+		return nil
+	}
+	if app.KeyRef == nil || app.KeyRef.ID == "" {
+		return errs.NewConfigError(errs.SubtypeInvalidConfig,
+			"private_key_jwt bind for app %s is missing keyRef", app.AppId)
+	}
+	if strings.TrimSpace(app.KeyRef.Provider) != core.KeylessProviderLarkSuite {
+		return errs.NewConfigError(errs.SubtypeInvalidClient,
+			"OpenClaw private_key_jwt bind for app %s did not select provider %s", app.AppId, core.KeylessProviderLarkSuite)
+	}
+	if opts == nil || opts.Factory == nil || opts.Factory.HttpClient == nil {
+		return errs.NewInternalError(errs.SubtypeSDKError, "cannot validate keyless bind without an HTTP client")
+	}
+	httpClient, err := opts.Factory.HttpClient()
+	if err != nil {
+		return errs.NewNetworkError(errs.SubtypeNetworkTransport,
+			"cannot create HTTP client for keyless bind validation: %v", err).WithCause(err)
+	}
+
+	ctx, cancel := context.WithTimeout(parent, keylessBindProbeTimeout)
+	defer cancel()
+	_, commitProviderManifest, err := fetchTATForBind(
+		ctx, httpClient, app.Brand, app.AppId, keysigner.Active(), app.KeyRef.Provider, app.KeyRef.ID,
+	)
+	if err != nil {
+		if errs.IsTyped(err) {
+			return err
+		}
+		return errs.NewConfigError(errs.SubtypeInvalidClient,
+			"OpenClaw signer could not authenticate app %s: %v", app.AppId, err).
+			WithHint("repair or reinstall the OpenClaw Feishu plugin and its platform signer dependency, verify the keyless account, then retry config bind").
+			WithCause(err)
+	}
+	if commitProviderManifest == nil {
+		return errs.NewInternalError(errs.SubtypeStorage,
+			"OpenClaw signer validation did not produce a provider manifest commit")
+	}
+	result.commitProviderManifest = commitProviderManifest
+	return nil
+}

cmd/config/keyless_bind_test.go

@@ -0,0 +1,438 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/auth"
+	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/httpmock"
+	"github.com/larksuite/cli/internal/i18n"
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+func TestConfigBindRun_OpenClawKeylessWritesProviderWithoutPath(t *testing.T) {
+	saveWorkspace(t)
+	clearAgentEnv(t)
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	writeOpenClawKeylessConfig(t, "cli_keyless", "openclaw-lark")
+
+	var gotProvider, gotKeyRef, gotClientID string
+	var providerCommits int
+	var providerCommitSawWorkspace bool
+	replaceBindProbe(t, func(_ context.Context, _ *http.Client, _ core.LarkBrand, clientID string, _ keysigner.Signer, provider, keyRef string) (string, func() error, error) {
+		gotClientID, gotProvider, gotKeyRef = clientID, provider, keyRef
+		return "tat-ok", func() error {
+			providerCommits++
+			data, err := os.ReadFile(core.GetConfigPath())
+			if err != nil {
+				return err
+			}
+			providerCommitSawWorkspace = strings.Contains(string(data), "cli_keyless")
+			return nil
+		}, nil
+	})
+
+	f, stdout, _, _ := cmdutil.TestFactory(t, nil)
+	if err := configBindRun(&BindOptions{Factory: f, Source: "openclaw", Identity: "bot-only"}); err != nil {
+		t.Fatalf("configBindRun: %v", err)
+	}
+	if gotClientID != "cli_keyless" || gotProvider != core.KeylessProviderLarkSuite || gotKeyRef != "openclaw-lark" {
+		t.Fatalf("probe route = client %q provider %q keyRef %q", gotClientID, gotProvider, gotKeyRef)
+	}
+	multi, err := core.LoadMultiAppConfig()
+	if err != nil {
+		t.Fatal(err)
+	}
+	app := multi.CurrentAppConfig("")
+	if app == nil || app.AuthMethod != core.AuthMethodPrivateKeyJWT || app.KeyRef == nil ||
+		app.KeyRef.Provider != core.KeylessProviderLarkSuite || app.KeyRef.ID != "openclaw-lark" || !app.AppSecret.IsZero() {
+		t.Fatalf("persisted app = %#v", app)
+	}
+	if stdout.Len() == 0 {
+		t.Fatal("bind did not emit success envelope")
+	}
+	if providerCommits != 1 {
+		t.Fatalf("provider manifest commits = %d, want 1", providerCommits)
+	}
+	if !providerCommitSawWorkspace {
+		t.Fatal("provider manifest committed before the workspace config became readable")
+	}
+}
+
+func TestConfigBindRun_OpenClawOptionalSignerClosedLoop(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("test helper uses a POSIX shebang; Windows resolution is compile-checked separately")
+	}
+	saveWorkspace(t)
+	clearAgentEnv(t)
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	signerPath := installOpenClawOptionalSigner(t)
+	writeOpenClawKeylessConfig(t, "cli_keyless_optional", "openclaw-lark")
+
+	f, _, _, registry := cmdutil.TestFactory(t, nil)
+	registry.Register(&httpmock.Stub{
+		Method: http.MethodPost,
+		URL:    auth.PathOAuthTokenV2,
+		Body:   map[string]any{"code": 0, "access_token": "tat-from-optional-signer"},
+		BodyFilter: func(body []byte) bool {
+			form, err := url.ParseQuery(string(body))
+			return err == nil &&
+				form.Get("client_id") == "cli_keyless_optional" &&
+				form.Get("client_assertion_type") == "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" &&
+				form.Get("client_assertion") == "optional.jwt" &&
+				!form.Has("client_secret")
+		},
+	})
+
+	if err := configBindRun(&BindOptions{Factory: f, Source: "openclaw", Identity: "bot-only"}); err != nil {
+		t.Fatalf("configBindRun: %v", err)
+	}
+	data, err := os.ReadFile(core.GetConfigPath())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasSuffix(string(data), "\n") || !strings.Contains(string(data), "\n  \"apps\": [") {
+		t.Fatalf("config is not formatted JSON with a trailing newline:\n%s", data)
+	}
+	if strings.Contains(string(data), signerPath) {
+		t.Fatalf("config persisted the discovered signer executable path:\n%s", data)
+	}
+	providerData, err := os.ReadFile(filepath.Join(core.GetBaseConfigDir(), "signing-providers.json"))
+	if err != nil {
+		t.Fatalf("read global signer manifest: %v", err)
+	}
+	if !strings.Contains(string(providerData), signerPath) {
+		t.Fatalf("global signer manifest did not record the verified executable")
+	}
+	multi, err := core.LoadMultiAppConfig()
+	if err != nil {
+		t.Fatal(err)
+	}
+	app := multi.CurrentAppConfig("")
+	if app == nil || app.AppId != "cli_keyless_optional" || app.KeyRef == nil ||
+		app.KeyRef.Provider != core.KeylessProviderLarkSuite || app.KeyRef.ID != "openclaw-lark" || !app.AppSecret.IsZero() {
+		t.Fatalf("resolved config = %#v", app)
+	}
+}
+
+func TestConfigBindRun_OpenClawKeylessProbeFailureDoesNotWrite(t *testing.T) {
+	saveWorkspace(t)
+	clearAgentEnv(t)
+	base := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", base)
+	writeOpenClawKeylessConfig(t, "cli_wrong_key", "openclaw-lark")
+	replaceBindProbe(t, func(context.Context, *http.Client, core.LarkBrand, string, keysigner.Signer, string, string) (string, func() error, error) {
+		return "", nil, errs.NewConfigError(errs.SubtypeInvalidClient, "public key is not bound")
+	})
+
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	if err := configBindRun(&BindOptions{Factory: f, Source: "openclaw", Identity: "bot-only"}); err == nil {
+		t.Fatal("expected probe error")
+	}
+	if _, err := os.Stat(filepath.Join(base, "openclaw", "config.json")); !os.IsNotExist(err) {
+		t.Fatalf("config must not be written; stat error = %v", err)
+	}
+}
+
+func TestConfigBindRun_OpenClawKeylessMissingProviderCommitFailsClosed(t *testing.T) {
+	saveWorkspace(t)
+	clearAgentEnv(t)
+	base := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", base)
+	writeOpenClawKeylessConfig(t, "cli_missing_commit", "openclaw-lark")
+	replaceBindProbe(t, func(context.Context, *http.Client, core.LarkBrand, string, keysigner.Signer, string, string) (string, func() error, error) {
+		return "tat-ok", nil, nil
+	})
+
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	err := configBindRun(&BindOptions{Factory: f, Source: "openclaw", Identity: "bot-only"})
+	if err == nil || !strings.Contains(err.Error(), "did not produce a provider manifest commit") {
+		t.Fatalf("configBindRun error = %v", err)
+	}
+	if _, statErr := os.Stat(filepath.Join(base, "openclaw", "config.json")); !os.IsNotExist(statErr) {
+		t.Fatalf("config must not be written; stat error = %v", statErr)
+	}
+}
+
+func TestCommitBinding_ProviderManifestFailureRestoresWorkspace(t *testing.T) {
+	saveWorkspace(t)
+	base := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", base)
+	core.SetCurrentWorkspace(core.WorkspaceOpenClaw)
+	configPath := core.GetConfigPath()
+	if err := os.MkdirAll(filepath.Dir(configPath), 0700); err != nil {
+		t.Fatal(err)
+	}
+	previous := []byte("{\n  \"current_app\": \"old\",\n  \"apps\": [{\"name\": \"old\", \"app_id\": \"cli_old\", \"app_secret\": \"keep\"}]\n}\n")
+	if err := os.WriteFile(configPath, previous, 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	f, stdout, stderr, _ := cmdutil.TestFactory(t, nil)
+	commitCalls := 0
+	result := &BindResult{
+		AppConfig: &core.AppConfig{AppId: "cli_new", Brand: core.BrandFeishu},
+		commitProviderManifest: func() error {
+			commitCalls++
+			return errors.New("manifest write failed")
+		},
+	}
+	err := commitBinding(&BindOptions{Factory: f, Identity: "bot-only"}, result, previous, "openclaw", configPath)
+	if err == nil || !strings.Contains(err.Error(), "workspace config restored") {
+		t.Fatalf("commitBinding error = %v", err)
+	}
+	if commitCalls != 1 {
+		t.Fatalf("provider manifest commits = %d, want 1", commitCalls)
+	}
+	got, readErr := os.ReadFile(configPath)
+	if readErr != nil {
+		t.Fatal(readErr)
+	}
+	if string(got) != string(previous) {
+		t.Fatalf("workspace was not restored:\n%s", got)
+	}
+	if stdout.Len() != 0 || stderr.Len() != 0 {
+		t.Fatalf("failed bind emitted success output: stdout=%q stderr=%q", stdout.String(), stderr.String())
+	}
+}
+
+func TestCommitBinding_ProviderManifestFailureRemovesNewWorkspace(t *testing.T) {
+	saveWorkspace(t)
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	core.SetCurrentWorkspace(core.WorkspaceOpenClaw)
+	configPath := core.GetConfigPath()
+	f, stdout, stderr, _ := cmdutil.TestFactory(t, nil)
+	result := &BindResult{
+		AppConfig: &core.AppConfig{AppId: "cli_new", Brand: core.BrandFeishu},
+		commitProviderManifest: func() error {
+			return errors.New("manifest write failed")
+		},
+	}
+	err := commitBinding(&BindOptions{Factory: f, Identity: "bot-only"}, result, nil, "openclaw", configPath)
+	if err == nil || !strings.Contains(err.Error(), "workspace config restored") {
+		t.Fatalf("commitBinding error = %v", err)
+	}
+	if _, statErr := os.Stat(configPath); !os.IsNotExist(statErr) {
+		t.Fatalf("new workspace config was not removed; stat error = %v", statErr)
+	}
+	if stdout.Len() != 0 || stderr.Len() != 0 {
+		t.Fatalf("failed bind emitted success output: stdout=%q stderr=%q", stdout.String(), stderr.String())
+	}
+}
+
+func TestCommitBinding_WorkspaceWriteFailureDoesNotCommitProvider(t *testing.T) {
+	saveWorkspace(t)
+	base := t.TempDir()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", base)
+	core.SetCurrentWorkspace(core.WorkspaceOpenClaw)
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	providerCommitted := false
+	result := &BindResult{
+		AppConfig: &core.AppConfig{AppId: "cli_new", Brand: core.BrandFeishu},
+		commitProviderManifest: func() error {
+			providerCommitted = true
+			return nil
+		},
+	}
+	configPath := filepath.Join(base, "missing-parent", "config.json")
+	if err := commitBinding(&BindOptions{Factory: f, Identity: "bot-only"}, result, nil, "openclaw", configPath); err == nil {
+		t.Fatal("expected workspace write failure")
+	}
+	if providerCommitted {
+		t.Fatal("provider manifest was committed before the workspace config write succeeded")
+	}
+}
+
+func TestCommitBinding_ConcurrentWorkspaceChangeFailsBeforeProviderCommit(t *testing.T) {
+	saveWorkspace(t)
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	core.SetCurrentWorkspace(core.WorkspaceOpenClaw)
+	configPath := core.GetConfigPath()
+	if err := os.MkdirAll(filepath.Dir(configPath), 0700); err != nil {
+		t.Fatal(err)
+	}
+	previous := []byte(`{"apps":[{"app_id":"cli_old","app_secret":"old"}]}`)
+	concurrent := []byte(`{"apps":[{"app_id":"cli_other","app_secret":"newer"}]}`)
+	if err := os.WriteFile(configPath, concurrent, 0600); err != nil {
+		t.Fatal(err)
+	}
+	f, _, _, _ := cmdutil.TestFactory(t, nil)
+	providerCommitted := false
+	result := &BindResult{
+		AppConfig: &core.AppConfig{AppId: "cli_new", Brand: core.BrandFeishu},
+		commitProviderManifest: func() error {
+			providerCommitted = true
+			return nil
+		},
+	}
+	err := commitBinding(&BindOptions{Factory: f, Identity: "bot-only"}, result, previous, "openclaw", configPath)
+	if err == nil || !strings.Contains(err.Error(), "changed while the bind was being validated") {
+		t.Fatalf("commitBinding error = %v", err)
+	}
+	if providerCommitted {
+		t.Fatal("provider manifest was committed after a concurrent workspace change")
+	}
+	got, readErr := os.ReadFile(configPath)
+	if readErr != nil || string(got) != string(concurrent) {
+		t.Fatalf("concurrent workspace was overwritten: %q, %v", got, readErr)
+	}
+}
+
+func TestCommitBinding_ProviderFailureDoesNotOverwriteConcurrentWriter(t *testing.T) {
+	saveWorkspace(t)
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	core.SetCurrentWorkspace(core.WorkspaceOpenClaw)
+	configPath := core.GetConfigPath()
+	if err := os.MkdirAll(filepath.Dir(configPath), 0700); err != nil {
+		t.Fatal(err)
+	}
+	previous := []byte(`{"apps":[{"app_id":"cli_old","app_secret":"old"}]}`)
+	concurrent := []byte(`{"apps":[{"app_id":"cli_other","app_secret":"newer"}]}`)
+	if err := os.WriteFile(configPath, previous, 0600); err != nil {
+		t.Fatal(err)
+	}
+	f, stdout, stderr, _ := cmdutil.TestFactory(t, nil)
+	result := &BindResult{
+		AppConfig: &core.AppConfig{AppId: "cli_new", Brand: core.BrandFeishu},
+		commitProviderManifest: func() error {
+			if err := os.WriteFile(configPath, concurrent, 0600); err != nil {
+				return err
+			}
+			return errors.New("manifest write failed")
+		},
+	}
+	err := commitBinding(&BindOptions{Factory: f, Identity: "bot-only"}, result, previous, "openclaw", configPath)
+	if err == nil || !strings.Contains(err.Error(), "refusing to overwrite") {
+		t.Fatalf("commitBinding error = %v", err)
+	}
+	got, readErr := os.ReadFile(configPath)
+	if readErr != nil || string(got) != string(concurrent) {
+		t.Fatalf("concurrent workspace was overwritten: %q, %v", got, readErr)
+	}
+	if stdout.Len() != 0 || stderr.Len() != 0 {
+		t.Fatalf("failed bind emitted success output: stdout=%q stderr=%q", stdout.String(), stderr.String())
+	}
+}
+
+func TestMergeBoundApp_UpsertsAndActivatesWithoutClobberingSiblings(t *testing.T) {
+	lang := "en_us"
+	previous := &core.MultiAppConfig{
+		StrictMode: core.StrictModeUser,
+		CurrentApp: "other",
+		Apps: []core.AppConfig{
+			{Name: "bound", AppId: "cli_target", Brand: core.BrandLark, Lang: coreLang(lang), Users: []core.AppUser{{UserOpenId: "ou_1", UserName: "alice"}}},
+			{Name: "other", AppId: "cli_other", AppSecret: core.PlainSecret("keep"), Brand: core.BrandFeishu, Users: []core.AppUser{}},
+		},
+	}
+	beforeSibling := previous.Apps[1]
+	data := mustJSON(t, previous)
+	incoming := &core.AppConfig{AppId: "cli_target", Brand: core.BrandFeishu, AuthMethod: core.AuthMethodPrivateKeyJWT,
+		KeyRef: &core.SecretRef{Source: core.SecretSourceTEE, Provider: core.KeylessProviderLarkSuite, ID: "openclaw-lark"}}
+
+	got, err := mergeBoundApp(incoming, data, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Apps) != 2 || got.CurrentApp != "bound" || got.PreviousApp != "other" || got.StrictMode != previous.StrictMode {
+		t.Fatalf("merged root = %#v", got)
+	}
+	if !reflect.DeepEqual(got.Apps[1], beforeSibling) {
+		t.Fatalf("sibling changed: got %#v want %#v", got.Apps[1], beforeSibling)
+	}
+	if got.Apps[0].Name != "bound" || got.Apps[0].Lang != coreLang(lang) || !reflect.DeepEqual(got.Apps[0].Users, previous.Apps[0].Users) {
+		t.Fatalf("target-owned fields were lost: %#v", got.Apps[0])
+	}
+}
+
+func writeOpenClawKeylessConfig(t *testing.T, appID, keyRef string) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "openclaw.json")
+	data := []byte(`{"channels":{"feishu":{"appId":"` + appID + `","authMethod":"private_key_jwt","keyRef":"` + keyRef + `","domain":"feishu"}}}`)
+	if err := os.WriteFile(path, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("OPENCLAW_CONFIG_PATH", path)
+}
+
+func replaceBindProbe(t *testing.T, fn func(context.Context, *http.Client, core.LarkBrand, string, keysigner.Signer, string, string) (string, func() error, error)) {
+	t.Helper()
+	previous := fetchTATForBind
+	fetchTATForBind = fn
+	t.Cleanup(func() { fetchTATForBind = previous })
+}
+
+func mustJSON(t *testing.T, value any) []byte {
+	t.Helper()
+	data, err := json.Marshal(value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return data
+}
+
+func coreLang(value string) i18n.Lang { return i18n.Lang(value) }
+
+func installOpenClawOptionalSigner(t *testing.T) string {
+	t.Helper()
+	// This closure specifically exercises the no-inspect compatibility path;
+	// keylessprovider tests separately cover authoritative managed-project
+	// discovery from `openclaw plugins inspect`.
+	t.Setenv("PATH", "")
+	type signerPackage struct {
+		name, npmOS, npmCPU, binary string
+	}
+	packages := map[string]signerPackage{
+		"darwin/arm64": {"@larksuite/lark-keyless-signer-darwin-arm64", "darwin", "arm64", "lark-keyless-signer"},
+		"darwin/amd64": {"@larksuite/lark-keyless-signer-darwin-x64", "darwin", "x64", "lark-keyless-signer"},
+		"linux/arm64":  {"@larksuite/lark-keyless-signer-linux-arm64", "linux", "arm64", "lark-keyless-signer"},
+		"linux/amd64":  {"@larksuite/lark-keyless-signer-linux-x64", "linux", "x64", "lark-keyless-signer"},
+	}
+	spec, ok := packages[runtime.GOOS+"/"+runtime.GOARCH]
+	if !ok {
+		t.Skipf("no optional signer package for %s/%s", runtime.GOOS, runtime.GOARCH)
+		return ""
+	}
+
+	stateDir := filepath.Join(t.TempDir(), "openclaw state")
+	packageDir := filepath.Join(
+		stateDir, "extensions", "openclaw-lark", "node_modules", "@larksuite", strings.TrimPrefix(spec.name, "@larksuite/"),
+	)
+	binDir := filepath.Join(packageDir, "bin")
+	if err := os.MkdirAll(binDir, 0700); err != nil {
+		t.Fatal(err)
+	}
+	packageJSON, err := json.MarshalIndent(map[string]any{
+		"name": spec.name, "version": "1.2.3", "os": []string{spec.npmOS}, "cpu": []string{spec.npmCPU},
+	}, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(packageDir, "package.json"), append(packageJSON, '\n'), 0600); err != nil {
+		t.Fatal(err)
+	}
+	script := "#!/bin/sh\n" +
+		"IFS= read -r request\n" +
+		"printf '%s\\n' '{\"ok\":true,\"client_assertion_type\":\"urn:ietf:params:oauth:client-assertion-type:jwt-bearer\",\"client_assertion\":\"optional.jwt\"}'\n"
+	signerPath := filepath.Join(binDir, spec.binary)
+	if err := os.WriteFile(signerPath, []byte(script), 0700); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("OPENCLAW_STATE_DIR", stateDir)
+	t.Setenv("PATH", "")
+	return signerPath
+}

cmd/config/risk_control.go

@@ -1,80 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-// NewCmdConfigRiskControl creates the workspace risk-control policy command.
-func NewCmdConfigRiskControl(f *cmdutil.Factory) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "risk-control [on|off|default]",
-		Short: "Manage workspace account-protection policy",
-		Long: `View or set the account-protection risk-control policy for this workspace.
-
-Account protection is on by default. Use off to opt this workspace out, on to
-opt it back in explicitly, or default to remove the explicit preference.`,
-		Args: cobra.MaximumNArgs(1),
-		// This is persistent workspace policy, not credential management.
-		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
-			cmd.SilenceUsage = true
-			return nil
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			config, err := core.LoadOrNotConfigured()
-			if err != nil {
-				return err
-			}
-			if len(args) == 0 {
-				printRiskControl(f, config)
-				return nil
-			}
-
-			switch args[0] {
-			case "on":
-				enabled := true
-				config.RiskControl = &enabled
-			case "off":
-				enabled := false
-				config.RiskControl = &enabled
-			case "default":
-				config.RiskControl = nil
-			default:
-				return errs.NewValidationError(errs.SubtypeInvalidArgument,
-					"invalid risk-control value %q, valid values: on | off | default", args[0])
-			}
-
-			if err := core.SaveMultiAppConfig(config); err != nil {
-				return errs.NewInternalError(errs.SubtypeStorage,
-					"failed to save risk-control policy: %v", err).WithCause(err)
-			}
-			fmt.Fprintf(f.IOStreams.ErrOut, "Risk control set to %s (workspace)\n", args[0])
-			return nil
-		},
-	}
-	cmdutil.SetRisk(cmd, cmdutil.RiskWrite)
-	return cmd
-}
-
-func printRiskControl(f *cmdutil.Factory, config *core.MultiAppConfig) {
-	source := "default"
-	if config.RiskControl != nil {
-		source = "workspace"
-	}
-	fmt.Fprintf(f.IOStreams.Out, "risk-control: %s (source: %s)\n", riskControlState(config.RiskControlEnabled()), source)
-}
-
-func riskControlState(enabled bool) string {
-	if enabled {
-		return "on"
-	}
-	return "off"
-}

cmd/config/risk_control_test.go

@@ -1,130 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-)
-
-func TestRiskControlWorkspacePolicy(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(config); err != nil {
-		t.Fatal(err)
-	}
-
-	f, stdout, stderr, _ := cmdutil.TestFactory(t, nil)
-	cmd := NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"off"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set off: %v", err)
-	}
-	loaded, err := core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || *loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit false", loaded.RiskControl)
-	}
-	if !strings.Contains(stderr.String(), "set to off") {
-		t.Fatalf("stderr = %q", stderr.String())
-	}
-
-	stdout.Reset()
-	cmd = NewCmdConfigRiskControl(f)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("show: %v", err)
-	}
-	if got := stdout.String(); got != "risk-control: off (source: workspace)\n" {
-		t.Fatalf("stdout = %q", got)
-	}
-
-	cmd = NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"on"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set on: %v", err)
-	}
-	loaded, err = core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || !*loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit true", loaded.RiskControl)
-	}
-
-	cmd = NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"default"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("reset default: %v", err)
-	}
-	loaded, err = core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl != nil {
-		t.Fatalf("RiskControl = %v, want nil", loaded.RiskControl)
-	}
-
-	stdout.Reset()
-	cmd = NewCmdConfigRiskControl(f)
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("show default: %v", err)
-	}
-	if got := stdout.String(); got != "risk-control: on (source: default)\n" {
-		t.Fatalf("stdout = %q", got)
-	}
-}
-
-func TestRiskControlWorkspacePolicyRejectsInvalidValue(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}); err != nil {
-		t.Fatal(err)
-	}
-
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	cmd := NewCmdConfigRiskControl(f)
-	cmd.SetArgs([]string{"invalid"})
-	err := cmd.Execute()
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("error = %T %v, want *errs.ValidationError", err, err)
-	}
-	if validationErr.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype = %q, want %q", validationErr.Subtype, errs.SubtypeInvalidArgument)
-	}
-}
-
-func TestRiskControlWorkspacePolicyAllowedWithExternalCredentials(t *testing.T) {
-	f := newConfigFactoryWithExternalProvider(t)
-	config := &core.MultiAppConfig{Apps: []core.AppConfig{{
-		AppId: "cli_test", AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(config); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := NewCmdConfig(f)
-	cmd.SetArgs([]string{"risk-control", "off"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("set off with external credentials: %v", err)
-	}
-
-	loaded, err := core.LoadMultiAppConfig()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded.RiskControl == nil || *loaded.RiskControl {
-		t.Fatalf("RiskControl = %v, want explicit false", loaded.RiskControl)
-	}
-}

cmd/config/show.go

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

cmd/doctor/doctor.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"sync"
@@ -19,6 +20,8 @@ import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/identitydiag"
+	"github.com/larksuite/cli/internal/keylessprovider"
+	"github.com/larksuite/cli/internal/keysigner"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/transport"
 	"github.com/larksuite/cli/internal/update"
@@ -135,6 +138,9 @@ func doctorRun(opts *DoctorOptions) error {
 		checks = append(checks, fail("identity_ready", "no usable bot or user identity is available", ""))
 	}
 
+	// ── 3b. private_key_jwt / TEE signer (local; runs even with --offline) ──
+	checks = append(checks, teeSignerCheck(opts.Ctx, cfg))
+
 	// ── 4 & 5. Endpoint reachability ──
 	checks = append(checks, networkChecks(opts.Ctx, opts, ep)...)
 
@@ -148,6 +154,73 @@ func identityCheck(name string, id identitydiag.Identity) checkResult {
 	return warn(name, id.Message, id.Hint)
 }
 
+const teeUnavailableHint = "ensure the device secure hardware is accessible (Linux TPM: add your user to the 'tss' group or run with sufficient privileges)"
+
+// teeSignerCheck reports the private_key_jwt signing backend (TEE/TPM) status.
+// The probe is local hardware only (no network), so it runs even with --offline;
+// in a build without a TEE signer it short-circuits without touching any
+// hardware. It is a hard requirement for private_key_jwt apps and purely
+// informational for client_secret apps.
+func teeSignerCheck(ctx context.Context, cfg *core.CliConfig) checkResult {
+	usesPKJWT := cfg != nil && cfg.AuthMethod == core.AuthMethodPrivateKeyJWT
+	if usesPKJWT && cfg.KeyProvider != "" {
+		helper, err := keylessprovider.Resolve(ctx, cfg.KeyProvider)
+		if err != nil {
+			return fail("tee_signer", "external keyless signer is unavailable",
+				fmt.Sprintf("repair or reinstall the OpenClaw Feishu plugin and its platform signer dependency: %v", err))
+		}
+		keyLabel := ""
+		if cfg != nil {
+			keyLabel = cfg.KeyLabel
+		}
+		if err := helper.Probe(ctx, keyLabel); err != nil {
+			hint := fmt.Sprintf("fix the configured external keyless signer, or re-run config init to replace/remove it: %v", err)
+			if usesPKJWT {
+				return fail("tee_signer", "external keyless signer is unavailable", hint)
+			}
+			return warn("tee_signer", "external keyless signer is misconfigured", hint)
+		}
+		return pass("tee_signer", "external keyless signer available")
+	}
+	info, ok, err := keysigner.ProbeActiveHardware(ctx)
+	return teeCheckResult(info, ok, err, usesPKJWT)
+}
+
+// teeCheckResult maps a hardware probe to a doctor check. Split out from
+// teeSignerCheck so the full matrix is unit-testable without a TPM.
+func teeCheckResult(info keysigner.HardwareInfo, ok bool, probeErr error, usesPKJWT bool) checkResult {
+	const name = "tee_signer"
+
+	// No signer registered → private_key_jwt is unsupported on this build.
+	if !ok {
+		if usesPKJWT {
+			return fail(name,
+				"app uses private_key_jwt but this build has no TEE key signer",
+				"the platform key signer ships by default on macOS, Linux, and Windows/amd64; this platform (e.g. Windows/arm64) has none — use a supported platform or re-register without --private-key-jwt")
+		}
+		return skip(name, "no TEE signer in this build (only private_key_jwt is affected; client_secret is unaffected)")
+	}
+
+	backend := info.Backend
+	if backend == "" {
+		backend = "tee"
+	}
+
+	switch {
+	case probeErr != nil:
+		return warn(name, fmt.Sprintf("%s signer present but probe errored: %s", backend, probeErr), "")
+	case info.Available:
+		if info.VendorName != "" {
+			return pass(name, fmt.Sprintf("%s TEE available (%s)", backend, info.VendorName))
+		}
+		return pass(name, fmt.Sprintf("%s TEE available", backend))
+	case usesPKJWT:
+		return fail(name, fmt.Sprintf("%s signer present but TEE unavailable: %s", backend, info.Reason), teeUnavailableHint)
+	default:
+		return warn(name, fmt.Sprintf("%s signer present but TEE unavailable: %s", backend, info.Reason), teeUnavailableHint)
+	}
+}
+
 // networkChecks probes Open API and MCP endpoints concurrently.
 func networkChecks(ctx context.Context, opts *DoctorOptions, ep core.Endpoints) []checkResult {
 	if opts.Offline {
@@ -237,14 +310,90 @@ func finishDoctor(f *cmdutil.Factory, checks []checkResult) error {
 		}
 	}
 
-	result := map[string]interface{}{
-		"ok":        allOK,
-		"workspace": core.CurrentWorkspace().Display(),
-		"checks":    checks,
+	workspace := core.CurrentWorkspace().Display()
+	// A terminal on STDOUT gets a readable report; pipes, redirects, scripts and
+	// tests keep the stable JSON contract (NO_COLOR disables ANSI styling).
+	// OutIsTerminal checks stdout specifically — IOStreams.IsTerminal reflects
+	// stdin, which would wrongly send the human report into `doctor | jq`.
+	if f.IOStreams.OutIsTerminal {
+		renderDoctorHuman(f.IOStreams.Out, workspace, checks, allOK, os.Getenv("NO_COLOR") == "")
+	} else {
+		output.PrintJson(f.IOStreams.Out, map[string]interface{}{
+			"ok":        allOK,
+			"workspace": workspace,
+			"checks":    checks,
+		})
 	}
-	output.PrintJson(f.IOStreams.Out, result)
 	if !allOK {
 		return output.ErrBare(1)
 	}
 	return nil
 }
+
+// renderDoctorHuman writes a readable health report: one aligned line per check
+// with a colored status tag, an indented hint when present, and a summary line.
+func renderDoctorHuman(w io.Writer, workspace string, checks []checkResult, allOK, color bool) {
+	const (
+		green  = "\033[32m"
+		yellow = "\033[33m"
+		red    = "\033[31m"
+		gray   = "\033[90m"
+		bold   = "\033[1m"
+		reset  = "\033[0m"
+	)
+	colorOf := map[string]string{"pass": green, "warn": yellow, "fail": red, "skip": gray}
+	tagOf := map[string]string{"pass": "PASS", "warn": "WARN", "fail": "FAIL", "skip": "SKIP"}
+	paint := func(code, s string) string {
+		if !color || code == "" {
+			return s
+		}
+		return code + s + reset
+	}
+
+	nameW := 0
+	for _, c := range checks {
+		if len(c.Name) > nameW {
+			nameW = len(c.Name)
+		}
+	}
+
+	fmt.Fprintf(w, "\n%s  (workspace: %s)\n\n", paint(bold, "lark-cli doctor"), workspace)
+
+	var passN, warnN, failN, skipN int
+	for _, c := range checks {
+		tag := tagOf[c.Status]
+		if tag == "" {
+			tag = "????"
+		}
+		fmt.Fprintf(w, "  %s  %-*s  %s\n", paint(colorOf[c.Status], "["+tag+"]"), nameW, c.Name, c.Message)
+		if c.Hint != "" {
+			fmt.Fprintf(w, "         %-*s  %s\n", nameW, "", paint(gray, "↳ "+c.Hint))
+		}
+		switch c.Status {
+		case "pass":
+			passN++
+		case "warn":
+			warnN++
+		case "fail":
+			failN++
+		case "skip":
+			skipN++
+		}
+	}
+
+	headline := paint(green, "healthy")
+	if !allOK {
+		headline = paint(red, "problems found")
+	}
+	fmt.Fprintf(w, "\n  %s — %d passed", headline, passN)
+	if warnN > 0 {
+		fmt.Fprintf(w, ", %d warning(s)", warnN)
+	}
+	if failN > 0 {
+		fmt.Fprintf(w, ", %d failed", failN)
+	}
+	if skipN > 0 {
+		fmt.Fprintf(w, ", %d skipped", skipN)
+	}
+	fmt.Fprintln(w)
+}

cmd/doctor/doctor_test.go

@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"net/http"
 	"strings"
 	"testing"
@@ -17,6 +18,7 @@ import (
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
+	"github.com/larksuite/cli/internal/keysigner"
 )
 
 func TestNewCmdDoctor_FlagParsing(t *testing.T) {
@@ -144,6 +146,107 @@ func TestDoctorRun_SplitsBotAndMissingUserIdentity(t *testing.T) {
 	assertCheck(t, got.Checks, "identity_ready", "pass")
 }
 
+func TestTeeCheckResult(t *testing.T) {
+	avail := keysigner.HardwareInfo{Backend: "tpm2", Available: true, VendorName: "ACME"}
+	unavail := keysigner.HardwareInfo{Backend: "tpm2", Reason: "open /dev/tpmrm0: permission denied"}
+
+	cases := []struct {
+		name     string
+		info     keysigner.HardwareInfo
+		ok       bool
+		probeErr error
+		pkjwt    bool
+		want     string
+	}{
+		{"no signer + private_key_jwt → fail", keysigner.HardwareInfo{}, false, nil, true, "fail"},
+		{"no signer + client_secret → skip", keysigner.HardwareInfo{}, false, nil, false, "skip"},
+		{"available + private_key_jwt → pass", avail, true, nil, true, "pass"},
+		{"available + client_secret → pass", avail, true, nil, false, "pass"},
+		{"unavailable + private_key_jwt → fail", unavail, true, nil, true, "fail"},
+		{"unavailable + client_secret → warn", unavail, true, nil, false, "warn"},
+		{"probe error → warn", keysigner.HardwareInfo{Backend: "tpm2"}, true, errors.New("boom"), true, "warn"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := teeCheckResult(tc.info, tc.ok, tc.probeErr, tc.pkjwt)
+			if got.Name != "tee_signer" {
+				t.Errorf("name = %q, want tee_signer", got.Name)
+			}
+			if got.Status != tc.want {
+				t.Errorf("status = %q, want %q (msg=%q)", got.Status, tc.want, got.Message)
+			}
+		})
+	}
+}
+
+// TestDoctorRun_TeeSignerWired proves the tee_signer check is part of doctorRun.
+// It asserts the build-independent invariant (a client_secret app must never
+// FAIL on TEE) so the test passes whether or not a signer is compiled in.
+func TestDoctorRun_TeeSignerWired(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
+		CurrentApp: "default",
+		Apps: []core.AppConfig{{
+			Name: "default", AppId: "test-app",
+			AppSecret: core.PlainSecret("secret"), Brand: core.BrandFeishu,
+		}},
+	}); err != nil {
+		t.Fatalf("SaveMultiAppConfig() error = %v", err)
+	}
+	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app", AppSecret: "secret", Brand: core.BrandFeishu,
+	})
+	if err := doctorRun(&DoctorOptions{Factory: f, Ctx: context.Background(), Offline: true}); err != nil {
+		t.Fatalf("doctorRun() error = %v", err)
+	}
+	var got struct {
+		Checks []checkResult `json:"checks"`
+	}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatalf("json.Unmarshal() error = %v", err)
+	}
+	var c *checkResult
+	for i := range got.Checks {
+		if got.Checks[i].Name == "tee_signer" {
+			c = &got.Checks[i]
+		}
+	}
+	if c == nil {
+		t.Fatalf("tee_signer check not present in doctor output: %#v", got.Checks)
+	}
+	if c.Status == "fail" {
+		t.Errorf("tee_signer = fail for a client_secret app; want skip/warn/pass (msg=%q)", c.Message)
+	}
+}
+
+func TestRenderDoctorHuman(t *testing.T) {
+	var buf bytes.Buffer
+	checks := []checkResult{
+		pass("cli_version", "1.0.50"),
+		warn("tee_signer", "tpm2 signer present but TEE unavailable", "add your user to the 'tss' group"),
+		fail("identity_ready", "no usable identity", "run: lark-cli auth status --verify"),
+		skip("endpoint_open", "skipped (--offline)"),
+	}
+	renderDoctorHuman(&buf, "local", checks, false, false)
+	out := buf.String()
+
+	for _, want := range []string{
+		"lark-cli doctor", "workspace: local",
+		"[PASS]", "cli_version", "1.0.50",
+		"[WARN]", "tee_signer", "↳ add your user to the 'tss' group",
+		"[FAIL]", "identity_ready", "↳ run: lark-cli auth status --verify",
+		"[SKIP]", "endpoint_open",
+		"problems found", "1 passed", "1 warning(s)", "1 failed", "1 skipped",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("output missing %q\n---\n%s", want, out)
+		}
+	}
+	if strings.Contains(out, "\033[") {
+		t.Errorf("color=false but ANSI escapes present:\n%s", out)
+	}
+}
+
 func assertCheck(t *testing.T, checks []checkResult, name, status string) {
 	t.Helper()
 	if got := findCheck(t, checks, name); got.Status != status {

cmd/event/consume_test.go

@@ -110,20 +110,8 @@ func (failingTokenResolver) ResolveToken(_ context.Context, _ credential.TokenSp
 	return nil, errors.New("backend unavailable")
 }
 
-type eventTestAccountResolver struct {
-	appID string
-}
-
-func (r eventTestAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return &credential.Account{AppID: r.appID}, nil
-}
-
-func newEventTestCredentialProvider(appID string, tokenResolver credential.DefaultTokenResolver) *credential.CredentialProvider {
-	return credential.NewCredentialProvider(nil, eventTestAccountResolver{appID: appID}, tokenResolver, nil)
-}
-
 func factoryWithResolver(r credential.DefaultTokenResolver) *cmdutil.Factory {
-	return &cmdutil.Factory{Credential: newEventTestCredentialProvider("cli_x", r)}
+	return &cmdutil.Factory{Credential: credential.NewCredentialProvider(nil, nil, r, nil)}
 }
 
 func TestResolveTenantToken_EmptyTokenResult(t *testing.T) {

cmd/event/runtime_test.go

@@ -44,7 +44,7 @@ func newTestConsumeRuntime(rt http.RoundTripper) *consumeRuntime {
 		client: &client.APIClient{
 			SDK:        sdk,
 			ErrOut:     io.Discard,
-			Credential: newEventTestCredentialProvider("test-app", &staticTokenResolver{}),
+			Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
 			Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 		},
 		accessIdentity: core.AsBot,

cmd/profile/list.go

@@ -17,14 +17,11 @@ import (
 )
 
 // profileListItem is the JSON output for a single profile entry.
-// `default` (formerly `active`, renamed in this feature as a declared
-// breaking change) marks the saved default profile — never the identity
-// effective for the current invocation; that is whoami's job.
 type profileListItem struct {
 	Name        string         `json:"name"`
 	AppID       string         `json:"appId"`
 	Brand       core.LarkBrand `json:"brand"`
-	Default     bool           `json:"default"`
+	Active      bool           `json:"active"`
 	User        string         `json:"user,omitempty"`
 	TokenStatus string         `json:"tokenStatus,omitempty"`
 }
@@ -33,8 +30,7 @@ type profileListItem struct {
 func NewCmdProfileList(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "list",
-		Short: "List saved profiles",
-		Long:  "Lists saved profiles. To see the app/profile lark-cli is using now, run `lark-cli whoami --json`.",
+		Short: "List all profiles",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return profileListRun(f)
 		},
@@ -57,7 +53,7 @@ func profileListRun(f *cmdutil.Factory) error {
 		return nil
 	}
 
-	// Intentionally uses "" to show the saved default profile, not the ephemeral --profile override.
+	// Intentionally uses "" to show the persistent active profile, not the ephemeral --profile override.
 	currentApp := multi.CurrentAppConfig("")
 	currentName := ""
 	if currentApp != nil {
@@ -70,10 +66,10 @@ func profileListRun(f *cmdutil.Factory) error {
 		name := app.ProfileName()
 
 		item := profileListItem{
-			Name:    name,
-			AppID:   app.AppId,
-			Brand:   app.Brand,
-			Default: name == currentName,
+			Name:   name,
+			AppID:  app.AppId,
+			Brand:  app.Brand,
+			Active: name == currentName,
 		}
 
 		if len(app.Users) > 0 {

cmd/profile/profile.go

@@ -14,17 +14,6 @@ func NewCmdProfile(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "profile",
 		Short: "Manage configuration profiles",
-		Long: `Profiles are named app identities managed by lark-cli.
-
-Identity diagnostics and profile selection:
-  lark-cli whoami --json       Show the app/profile lark-cli is using now.
-  lark-cli auth status --json --verify  Verify OAuth login and token state.
-  --profile <name>             Use a profile for this command only.
-  LARKSUITE_CLI_PROFILE        Use a profile for the current shell / agent session.
-  config show / profile list   Inspect saved config, not current usage.
-  unset LARKSUITE_CLI_PROFILE  Clear the session profile and fall back to direct app env or configured default.
-
-A selected profile takes precedence over matching direct env credentials and tokens.`,
 	}
 	cmdutil.DisableAuthCheck(cmd)
 	cmdutil.SetTips(cmd, []string{

cmd/profile/profile_test.go

@@ -306,24 +306,14 @@ func TestProfileListRun_OutputsProfiles(t *testing.T) {
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("Unmarshal() error = %v; output=%s", err, stdout.String())
 	}
-	raw := stdout.String()
-	// `active` is renamed to `default` as a declared breaking change: keeping
-	// a permanently mirrored alias would keep misleading agents into reading
-	// it as the currently effective identity (whoami's job).
-	if strings.Contains(raw, `"active"`) {
-		t.Fatalf("profile list output contains renamed active field: %s", raw)
-	}
-	if !strings.Contains(raw, `"default"`) {
-		t.Fatalf("profile list output missing default field: %s", raw)
-	}
 	if len(got) != 2 {
 		t.Fatalf("len(got) = %d, want 2", len(got))
 	}
-	if got[0].Name != "default" || !got[0].Default {
-		t.Fatalf("got[0] = %#v, want configured default profile", got[0])
+	if got[0].Name != "default" || !got[0].Active {
+		t.Fatalf("got[0] = %#v, want active default profile", got[0])
 	}
-	if got[1].Name != "target" || got[1].Default {
-		t.Fatalf("got[1] = %#v, want non-default target profile", got[1])
+	if got[1].Name != "target" || got[1].Active {
+		t.Fatalf("got[1] = %#v, want inactive target profile", got[1])
 	}
 }
 
@@ -637,39 +627,6 @@ func TestProfileRemoveRun_ValidationErrors(t *testing.T) {
 	})
 }
 
-// TestProfileHelpHasSelectionSection asserts `profile --help` documents the
-// per-invocation flag and session-scoped env var for selecting a profile, so
-// users and AI agents can find LARKSUITE_CLI_PROFILE without reading source.
-func TestProfileHelpHasSelectionSection(t *testing.T) {
-	cmd := NewCmdProfile(nil)
-	if !strings.Contains(cmd.Long, "Identity diagnostics and profile selection:") {
-		t.Errorf("profile --help missing identity diagnostics and profile selection section")
-	}
-	if !strings.Contains(cmd.Long, "LARKSUITE_CLI_PROFILE") {
-		t.Errorf("profile --help missing LARKSUITE_CLI_PROFILE")
-	}
-	if !strings.Contains(cmd.Long, "lark-cli whoami --json") {
-		t.Errorf("profile --help missing whoami identity route")
-	}
-	if !strings.Contains(cmd.Long, "config show / profile list") {
-		t.Errorf("profile --help missing saved-config boundary")
-	}
-	const precedence = "A selected profile takes precedence over matching direct env credentials and tokens."
-	if !strings.Contains(cmd.Long, precedence) {
-		t.Errorf("profile --help missing precedence statement %q", precedence)
-	}
-}
-
-func TestProfileListHelpClarifiesSavedProfiles(t *testing.T) {
-	cmd := NewCmdProfileList(nil)
-	if !strings.Contains(cmd.Short, "saved profiles") {
-		t.Errorf("profile list short = %q, want saved profiles", cmd.Short)
-	}
-	if !strings.Contains(cmd.Long, "lark-cli whoami --json") {
-		t.Errorf("profile list help missing whoami route")
-	}
-}
-
 func TestProfileListRun_InvalidConfigReturnsValidationError(t *testing.T) {
 	dir := setupProfileConfigDir(t)
 	if err := os.WriteFile(filepath.Join(dir, "config.json"), []byte("{invalid json"), 0600); err != nil {

cmd/whoami/whoami.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/identitydiag"
 	"github.com/larksuite/cli/internal/output"
 )
@@ -34,15 +33,6 @@ type whoamiResult struct {
 	TokenStatus    string         `json:"tokenStatus"`
 	OnBehalfOf     *delegatedUser `json:"onBehalfOf,omitempty"`
 	Hint           string         `json:"hint,omitempty"`
-
-	// CredentialSource, Explicit, and DirectCredentialEnv surface the cached
-	// credential.IdentitySelection computed during resolution (not re-inferred
-	// here). On the non-env extension-provider path CredentialSource is
-	// "extension:<provider>" (e.g. "extension:sidecar"); an empty value only
-	// means the selection was never resolved.
-	CredentialSource    string                         `json:"credentialSource"`
-	Explicit            bool                           `json:"explicit"`
-	DirectCredentialEnv credential.DirectCredentialEnv `json:"directCredentialEnv"`
 }
 
 // delegatedUser is the user a user-identity acts on behalf of.
@@ -68,10 +58,6 @@ func NewCmdWhoami(f *cmdutil.Factory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "whoami",
 		Short: "Show the current effective identity, app, profile, and token status (JSON)",
-		Long: `Show the effective app identity used by this invocation. This is not OAuth login status;
-use ` + "`lark-cli auth status --json`" + ` for OAuth user/token state.
-The JSON output includes credentialSource, appId, brand, and whether direct app credential
-env is present and matches the selected profile.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return whoamiRun(cmd, opts)
 		},
@@ -111,17 +97,7 @@ func whoamiRun(cmd *cobra.Command, opts *Options) error {
 		f.ResolveStrictMode(ctx).ForcedIdentity(),
 	)
 	diag := identitydiag.Diagnose(ctx, f, cfg, false)
-	// Read the cached selection computed during resolution; never re-infer it
-	// here. A resolution failure (e.g. under a non-env extension provider that
-	// doesn't populate a selection) degrades to the zero value rather than
-	// regressing whoami's own error/diagnostic path above.
-	var selection credential.IdentitySelection
-	if f.Credential != nil {
-		if sel, err := f.Credential.Selection(ctx); err == nil {
-			selection = sel
-		}
-	}
-	res := buildResult(cfg, as, source, diag, selection)
+	res := buildResult(cfg, as, source, diag)
 	output.PrintJson(f.IOStreams.Out, res)
 	return nil
 }
@@ -146,23 +122,18 @@ func resolveSource(changedAs bool, flagAs core.Identity, autoDetected bool, stri
 
 // buildResult maps the resolved identity and local diagnostics into the output.
 // ResolveAs only ever returns user or bot, so the default branch handles user.
-// selection is the cached credential.IdentitySelection from resolution; it is
-// read as-is, never recomputed.
-func buildResult(cfg *core.CliConfig, as core.Identity, source string, diag identitydiag.Result, selection credential.IdentitySelection) *whoamiResult {
+func buildResult(cfg *core.CliConfig, as core.Identity, source string, diag identitydiag.Result) *whoamiResult {
 	defaultAs := cfg.DefaultAs
 	if defaultAs == "" {
 		defaultAs = core.AsAuto
 	}
 	res := &whoamiResult{
-		Profile:             cfg.ProfileName,
-		AppID:               cfg.AppID,
-		Brand:               cfg.Brand,
-		DefaultAs:           string(defaultAs),
-		Identity:            string(as),
-		IdentitySource:      source,
-		CredentialSource:    string(selection.Source),
-		Explicit:            selection.Explicit(),
-		DirectCredentialEnv: selection.DirectCredentialEnv,
+		Profile:        cfg.ProfileName,
+		AppID:          cfg.AppID,
+		Brand:          cfg.Brand,
+		DefaultAs:      string(defaultAs),
+		Identity:       string(as),
+		IdentitySource: source,
 	}
 	// Use the diagnosed hint as-is: it is tailored to the credential source, so
 	// it never says "auth login" when that is blocked under an external provider.

cmd/whoami/whoami_test.go

@@ -15,13 +15,10 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/internal/identitydiag"
-	"github.com/larksuite/cli/internal/keychain"
 )
 
 func TestResolveSource(t *testing.T) {
@@ -55,7 +52,7 @@ func TestBuildResult_UserValid(t *testing.T) {
 	diag := identitydiag.Result{
 		User: identitydiag.Identity{Available: true, Status: "ready", TokenStatus: "valid", OpenID: "ou_x", UserName: "Alice"},
 	}
-	r := buildResult(cfg, core.AsUser, "auto_detect", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsUser, "auto_detect", diag)
 
 	if r.Identity != "user" || r.IdentitySource != "auto_detect" {
 		t.Fatalf("identity/source = %q/%q", r.Identity, r.IdentitySource)
@@ -80,7 +77,7 @@ func TestBuildResult_UserMissingToken(t *testing.T) {
 	diag := identitydiag.Result{
 		User: identitydiag.Identity{Available: false, Status: "missing", Hint: "run: lark-cli auth login --help"}, // never logged in
 	}
-	r := buildResult(cfg, core.AsUser, "auto_detect", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsUser, "auto_detect", diag)
 
 	if r.Available {
 		t.Fatalf("available = true, want false")
@@ -103,7 +100,7 @@ func TestBuildResult_BotReady(t *testing.T) {
 	diag := identitydiag.Result{
 		Bot: identitydiag.Identity{Available: true, Status: "ready"},
 	}
-	r := buildResult(cfg, core.AsBot, "default_as", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsBot, "default_as", diag)
 
 	if r.Identity != "bot" || r.IdentitySource != "default_as" {
 		t.Fatalf("identity/source = %q/%q", r.Identity, r.IdentitySource)
@@ -124,7 +121,7 @@ func TestBuildResult_BotNotConfigured(t *testing.T) {
 	diag := identitydiag.Result{
 		Bot: identitydiag.Identity{Available: false, Status: "not_configured", Hint: "run: lark-cli config --help"},
 	}
-	r := buildResult(cfg, core.AsBot, "auto_detect", diag, credential.IdentitySelection{})
+	r := buildResult(cfg, core.AsBot, "auto_detect", diag)
 
 	if r.Available {
 		t.Fatalf("available = true, want false")
@@ -321,94 +318,3 @@ func TestWhoami_ExternalProvider_UserHintNotKeychain(t *testing.T) {
 		t.Fatalf("hint should explain external management: %q", got.Hint)
 	}
 }
-
-// noopWhoamiKeychain is a no-op KeychainAccess; the profile below uses a
-// plaintext secret, so no keychain lookup is actually required.
-type noopWhoamiKeychain struct{}
-
-func (noopWhoamiKeychain) Get(service, account string) (string, error) { return "", nil }
-func (noopWhoamiKeychain) Set(service, account, value string) error    { return nil }
-func (noopWhoamiKeychain) Remove(service, account string) error        { return nil }
-
-// credentialSourceSecret is the profile secret written to config for
-// TestWhoamiIncludesCredentialSource. It must never leak into whoami's output
-// (security: never leak a secret).
-const credentialSourceSecret = "test-secret"
-
-// profileSelectionFactory builds a Factory whose CredentialProvider resolves
-// an explicit profile ("tenant_a") supplied via the LARKSUITE_CLI_PROFILE env
-// fallback (not --profile), so Selection().Source resolves to
-// env:LARKSUITE_CLI_PROFILE and Explicit() is true, with no direct
-// app-credential env vars present.
-func profileSelectionFactory(t *testing.T) (*cmdutil.Factory, *bytes.Buffer) {
-	t.Helper()
-	t.Setenv(envvars.CliAppID, "")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	multi := &core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name:      "tenant_a",
-			AppId:     "cli_a",
-			AppSecret: core.PlainSecret(credentialSourceSecret),
-			Brand:     core.BrandFeishu,
-		}},
-	}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	defaultAcct := credential.NewDefaultAccountProvider(func() keychain.KeychainAccess { return noopWhoamiKeychain{} }, "tenant_a")
-	cred := credential.NewCredentialProvider([]extcred.Provider{&envprovider.Provider{}}, defaultAcct, nil, nil)
-	cred.WithProfileFromEnv("tenant_a")
-
-	cfg := &core.CliConfig{ProfileName: "tenant_a", AppID: "cli_a", AppSecret: credentialSourceSecret, Brand: core.BrandFeishu}
-	out := &bytes.Buffer{}
-	f := &cmdutil.Factory{
-		Config:     func() (*core.CliConfig, error) { return cfg, nil },
-		Credential: cred,
-		IOStreams:  &cmdutil.IOStreams{Out: out, ErrOut: &bytes.Buffer{}},
-	}
-	return f, out
-}
-
-// TestWhoamiIncludesCredentialSource locks in the diagnostic fields surfaced
-// from the cached credential.IdentitySelection: credentialSource,
-// explicit, and directCredentialEnv. whoami must read the cached selection
-// as-is, not re-infer it.
-func TestWhoamiIncludesCredentialSource(t *testing.T) {
-	f, out := profileSelectionFactory(t)
-
-	cmd := NewCmdWhoami(f)
-	cmd.SetArgs([]string{})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("Execute() error = %v", err)
-	}
-
-	raw := out.String()
-	if strings.Contains(raw, credentialSourceSecret) {
-		t.Fatalf("whoami output leaked the profile secret: %s", raw)
-	}
-
-	var got whoamiResult
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("json.Unmarshal() error = %v\n%s", err, raw)
-	}
-	if got.CredentialSource != string(credential.SourceEnvProfile) {
-		t.Fatalf("credentialSource = %q, want %q", got.CredentialSource, credential.SourceEnvProfile)
-	}
-	if !got.Explicit {
-		t.Fatalf("explicit = false, want true")
-	}
-	if got.DirectCredentialEnv.Present {
-		t.Fatalf("directCredentialEnv.present = true, want false: %#v", got.DirectCredentialEnv)
-	}
-	if !strings.Contains(raw, `"credentialSource": "env:LARKSUITE_CLI_PROFILE"`) {
-		t.Fatalf("raw JSON missing credentialSource literal: %s", raw)
-	}
-	if got.DirectCredentialEnv.Present || len(got.DirectCredentialEnv.Keys) != 0 ||
-		got.DirectCredentialEnv.AppID != "" || got.DirectCredentialEnv.Matched || got.DirectCredentialEnv.ConflictsWithProfile {
-		t.Fatalf("directCredentialEnv = %#v, want only present:false set", got.DirectCredentialEnv)
-	}
-}

errs/ERROR_CONTRACT.md

@@ -67,17 +67,6 @@ Typed errors render to **stderr** as one JSON object per process exit:
 | `error.params` | per-Subtype-stable | per-parameter validation detail array (`ValidationError`); see **Validation parameters** |
 | per-Subtype extension fields | per-Subtype-stable | e.g. `missing_scopes`, `console_url`, `challenge_url` |
 
-Credential/identity-selection extension fields (per-Subtype-stable):
-
-| Field | Carrier | Subtypes | Notes |
-|-------|---------|----------|-------|
-| `missing_keys` | `ConfigError` | `app_credential_incomplete` | env var NAMES that must all be set; never values |
-| `required_any_of` | `ConfigError` | `app_credential_incomplete` | env var NAMES where any one completes the credential; mutually exclusive with `missing_keys` |
-| `profile` | `ConfigError` | `profile_not_found`, `profile_secret_invalid` | requested profile name |
-| `app_id` | `ConfigError` | `profile_secret_invalid` | plaintext app id; never a secret |
-| `credential_source` | `ConfigError` | `profile_not_found`, `no_active_profile` | how the identity was (not) chosen: `flag:--profile` \| `env:LARKSUITE_CLI_PROFILE` \| `config` |
-| `profile_app_id`, `env_app_id` | `ValidationError` | `profile_app_credential_conflict` | the two conflicting plaintext app ids |
-
 `SecurityPolicyError` renders through the same typed envelope as every
 other category. `error.type` is `"policy"`, `error.subtype` is one of
 `challenge_required` / `access_denied`, and process exit is `6` via

errs/marshal_test.go

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

errs/subtypes.go

@@ -12,9 +12,8 @@ const (
 
 // CategoryValidation subtypes
 const (
-	SubtypeInvalidArgument              Subtype = "invalid_argument"                // user-supplied flag / arg failed validation (gRPC INVALID_ARGUMENT alignment)
-	SubtypeFailedPrecondition           Subtype = "failed_precondition"             // request is valid but the system/resource state is not in the state required to execute; caller must change state (not retry) — e.g. ambiguous remote mapping (gRPC FAILED_PRECONDITION alignment)
-	SubtypeProfileAppCredentialConflict Subtype = "profile_app_credential_conflict" // profile and direct app env both set but app_id differs
+	SubtypeInvalidArgument    Subtype = "invalid_argument"    // user-supplied flag / arg failed validation (gRPC INVALID_ARGUMENT alignment)
+	SubtypeFailedPrecondition Subtype = "failed_precondition" // request is valid but the system/resource state is not in the state required to execute; caller must change state (not retry) — e.g. ambiguous remote mapping (gRPC FAILED_PRECONDITION alignment)
 )
 
 // CategoryAuthentication subtypes
@@ -42,13 +41,9 @@ const (
 
 // CategoryConfig subtypes
 const (
-	SubtypeInvalidClient           Subtype = "invalid_client"            // app_id / app_secret incorrect (RFC 6749 §5.2 alignment)
-	SubtypeNotConfigured           Subtype = "not_configured"            // local config file absent (user has not run `config init`)
-	SubtypeInvalidConfig           Subtype = "invalid_config"            // local config file present but malformed
-	SubtypeProfileNotFound         Subtype = "profile_not_found"         // --profile / LARKSUITE_CLI_PROFILE points to a nonexistent profile
-	SubtypeNoActiveProfile         Subtype = "no_active_profile"         // no active identity input and no usable default profile
-	SubtypeAppCredentialIncomplete Subtype = "app_credential_incomplete" // direct app env missing app_id or app_secret
-	SubtypeProfileSecretInvalid    Subtype = "profile_secret_invalid"    // profile exists but its secret cannot be resolved locally
+	SubtypeInvalidClient Subtype = "invalid_client" // app_id / app_secret incorrect (RFC 6749 §5.2 alignment)
+	SubtypeNotConfigured Subtype = "not_configured" // local config file absent (user has not run `config init`)
+	SubtypeInvalidConfig Subtype = "invalid_config" // local config file present but malformed
 )
 
 // CategoryNetwork subtypes

errs/types.go

@@ -61,11 +61,9 @@ type TypedError interface {
 // it is intentionally not serialized.
 type ValidationError struct {
 	Problem
-	Param        string         `json:"param,omitempty"`
-	Params       []InvalidParam `json:"params,omitempty"`
-	ProfileAppID string         `json:"profile_app_id,omitempty"`
-	EnvAppID     string         `json:"env_app_id,omitempty"`
-	Cause        error          `json:"-"`
+	Param  string         `json:"param,omitempty"`
+	Params []InvalidParam `json:"params,omitempty"`
+	Cause  error          `json:"-"`
 }
 
 // InvalidParam is one structured validation diagnostic: the parameter that
@@ -152,12 +150,6 @@ func (e *ValidationError) WithCause(cause error) *ValidationError {
 	return e
 }
 
-func (e *ValidationError) WithProfileAppConflict(profileAppID, envAppID string) *ValidationError {
-	e.ProfileAppID = profileAppID
-	e.EnvAppID = envAppID
-	return e
-}
-
 // =========================== AuthenticationError =============================
 
 // AuthenticationError is the typed error for CategoryAuthentication.
@@ -323,18 +315,8 @@ func (e *PermissionError) WithCause(cause error) *PermissionError {
 // intentionally not serialized.
 type ConfigError struct {
 	Problem
-	Field         string   `json:"field,omitempty"`
-	MissingKeys   []string `json:"missing_keys,omitempty"`
-	RequiredAnyOf []string `json:"required_any_of,omitempty"`
-	Profile       string   `json:"profile,omitempty"`
-	AppID         string   `json:"app_id,omitempty"`
-	// CredentialSource is the machine-readable App/credential selection source
-	// that produced this config error (e.g. "flag:--profile",
-	// "env:LARKSUITE_CLI_PROFILE", "config"). It is required on
-	// profile_not_found and no_active_profile so an agent can branch
-	// on how the identity was (or was not) chosen. It is never a secret.
-	CredentialSource string `json:"credential_source,omitempty"`
-	Cause            error  `json:"-"`
+	Field string `json:"field,omitempty"`
+	Cause error  `json:"-"`
 }
 
 // Unwrap is nil-receiver safe; see ValidationError.Unwrap.
@@ -388,34 +370,6 @@ func (e *ConfigError) WithField(field string) *ConfigError {
 	return e
 }
 
-func (e *ConfigError) WithMissingKeys(keys ...string) *ConfigError {
-	e.MissingKeys = slices.Clone(keys)
-	return e
-}
-
-func (e *ConfigError) WithRequiredAnyOf(keys ...string) *ConfigError {
-	e.RequiredAnyOf = slices.Clone(keys)
-	return e
-}
-
-func (e *ConfigError) WithProfile(name string) *ConfigError {
-	e.Profile = name
-	return e
-}
-
-func (e *ConfigError) WithAppID(appID string) *ConfigError {
-	e.AppID = appID
-	return e
-}
-
-// WithCredentialSource records the machine-readable credential-selection source
-// on the wire (snake_case credential_source). The value is an enum string
-// (e.g. "flag:--profile", "config"), never a secret.
-func (e *ConfigError) WithCredentialSource(source string) *ConfigError {
-	e.CredentialSource = source
-	return e
-}
-
 func (e *ConfigError) WithCause(cause error) *ConfigError {
 	e.Cause = cause
 	return e

errs/types_test.go

@@ -643,29 +643,3 @@ func TestBuilderSetter_DefensiveCopy(t *testing.T) {
 		}
 	})
 }
-
-// ======================= Profile selection error subtypes =======================
-
-func TestConfigErrorProfileFields(t *testing.T) {
-	e := errs.NewConfigError(errs.SubtypeAppCredentialIncomplete, "incomplete").
-		WithMissingKeys("LARKSUITE_CLI_APP_ID").
-		WithCredentialSource("env:LARKSUITE_CLI_PROFILE")
-	p, ok := errs.ProblemOf(e)
-	if !ok || p.Subtype != errs.SubtypeAppCredentialIncomplete {
-		t.Fatalf("subtype mismatch: %+v", p)
-	}
-	if len(e.MissingKeys) != 1 || e.MissingKeys[0] != "LARKSUITE_CLI_APP_ID" {
-		t.Errorf("missing_keys not set: %v", e.MissingKeys)
-	}
-	if e.CredentialSource != "env:LARKSUITE_CLI_PROFILE" {
-		t.Errorf("credential_source not set: %q", e.CredentialSource)
-	}
-}
-
-func TestValidationErrorProfileConflict(t *testing.T) {
-	e := errs.NewValidationError(errs.SubtypeProfileAppCredentialConflict, "conflict").
-		WithProfileAppConflict("cli_profile", "cli_env")
-	if e.ProfileAppID != "cli_profile" || e.EnvAppID != "cli_env" {
-		t.Errorf("conflict fields not set: %q %q", e.ProfileAppID, e.EnvAppID)
-	}
-}

extension/credential/env/env.go

@@ -23,89 +23,63 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 	appSecret := os.Getenv(envvars.CliAppSecret)
 	hasUAT := os.Getenv(envvars.CliUserAccessToken) != ""
 	hasTAT := os.Getenv(envvars.CliTenantAccessToken) != ""
-	presentKeys := presentCredentialEnvKeys(appID, appSecret, hasUAT, hasTAT)
-	if len(presentKeys) == 0 {
-		return nil, nil
+	if appID == "" && appSecret == "" {
+		switch {
+		case hasUAT:
+			return nil, &credential.BlockError{Provider: "env", Reason: envvars.CliUserAccessToken + " is set but " + envvars.CliAppID + " is missing"}
+		case hasTAT:
+			return nil, &credential.BlockError{Provider: "env", Reason: envvars.CliTenantAccessToken + " is set but " + envvars.CliAppID + " is missing"}
+		default:
+			return nil, nil
+		}
 	}
+	if appID == "" {
+		return nil, &credential.BlockError{Provider: "env", Reason: envvars.CliAppSecret + " is set but " + envvars.CliAppID + " is missing"}
+	}
+	if appSecret == "" && !hasUAT && !hasTAT {
+		return nil, &credential.BlockError{
+			Provider: "env",
+			Reason:   envvars.CliAppID + " is set but no app secret or access token is available",
+		}
+	}
+	brand := credential.Brand(core.ParseBrand(os.Getenv(envvars.CliBrand)))
+	acct := &credential.Account{AppID: appID, AppSecret: appSecret, Brand: brand}
 
-	// Identity policy variables are validated whenever a direct credential
-	// input is present. Their errors must not be hidden by a later credential
-	// completeness check or profile arbitration.
-	defaultAs := credential.Identity(os.Getenv(envvars.CliDefaultAs))
-	switch defaultAs {
-	case "", credential.IdentityAuto, credential.IdentityUser, credential.IdentityBot:
+	switch id := credential.Identity(os.Getenv(envvars.CliDefaultAs)); id {
+	case "", credential.IdentityAuto:
+		acct.DefaultAs = id
+	case credential.IdentityUser, credential.IdentityBot:
+		acct.DefaultAs = id
 	default:
 		return nil, &credential.BlockError{
 			Provider: "env",
-			Reason:   fmt.Sprintf("invalid %s %q (want user, bot, or auto)", envvars.CliDefaultAs, defaultAs),
-			Code:     credential.BlockReasonInvalidPolicy,
-			Param:    envvars.CliDefaultAs,
+			Reason:   fmt.Sprintf("invalid %s %q (want user, bot, or auto)", envvars.CliDefaultAs, id),
 		}
 	}
 
-	strictMode := os.Getenv(envvars.CliStrictMode)
-	var supported credential.IdentitySupport
-	switch strictMode {
+	// Explicit strict mode policy takes priority
+	switch strictMode := os.Getenv(envvars.CliStrictMode); strictMode {
 	case "bot":
-		supported = credential.SupportsBot
+		acct.SupportedIdentities = credential.SupportsBot
 	case "user":
-		supported = credential.SupportsUser
+		acct.SupportedIdentities = credential.SupportsUser
 	case "off":
-		supported = credential.SupportsAll
+		acct.SupportedIdentities = credential.SupportsAll
 	case "":
+		// Infer from available tokens
 		if hasUAT {
-			supported |= credential.SupportsUser
+			acct.SupportedIdentities |= credential.SupportsUser
 		}
 		if hasTAT {
-			supported |= credential.SupportsBot
+			acct.SupportedIdentities |= credential.SupportsBot
 		}
 	default:
 		return nil, &credential.BlockError{
 			Provider: "env",
 			Reason:   fmt.Sprintf("invalid %s %q (want bot, user, or off)", envvars.CliStrictMode, strictMode),
-			Code:     credential.BlockReasonInvalidPolicy,
-			Param:    envvars.CliStrictMode,
 		}
 	}
 
-	if appID == "" && appSecret == "" {
-		switch {
-		case hasUAT:
-			return nil, incompleteCredentialError(
-				appID,
-				envvars.CliUserAccessToken+" is set but "+envvars.CliAppID+" is missing",
-				[]string{envvars.CliAppID}, nil, presentKeys)
-		case hasTAT:
-			return nil, incompleteCredentialError(
-				appID,
-				envvars.CliTenantAccessToken+" is set but "+envvars.CliAppID+" is missing",
-				[]string{envvars.CliAppID}, nil, presentKeys)
-		}
-	}
-	if appID == "" {
-		return nil, incompleteCredentialError(
-			appID,
-			envvars.CliAppSecret+" is set but "+envvars.CliAppID+" is missing",
-			[]string{envvars.CliAppID}, nil, presentKeys)
-	}
-	if appSecret == "" && !hasUAT && !hasTAT {
-		return nil, incompleteCredentialError(
-			appID,
-			envvars.CliAppID+" is set but no app secret or access token is available",
-			nil,
-			[]string{envvars.CliAppSecret, envvars.CliUserAccessToken, envvars.CliTenantAccessToken},
-			presentKeys)
-	}
-	brand := credential.Brand(core.ParseBrand(os.Getenv(envvars.CliBrand)))
-	acct := &credential.Account{
-		AppID:               appID,
-		AppSecret:           appSecret,
-		Brand:               brand,
-		DefaultAs:           defaultAs,
-		SupportedIdentities: supported,
-		Kind:                credential.AccountDirect,
-	}
-
 	if acct.DefaultAs == "" {
 		switch {
 		case hasUAT:
@@ -118,35 +92,6 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 	return acct, nil
 }
 
-func incompleteCredentialError(appID, reason string, missingKeys, requiredAnyOf, presentKeys []string) *credential.BlockError {
-	return &credential.BlockError{
-		Provider:      "env",
-		Reason:        reason,
-		Code:          credential.BlockReasonCredentialIncomplete,
-		MissingKeys:   missingKeys,
-		RequiredAnyOf: requiredAnyOf,
-		PresentKeys:   presentKeys,
-		AppID:         appID,
-	}
-}
-
-func presentCredentialEnvKeys(appID, appSecret string, hasUAT, hasTAT bool) []string {
-	var keys []string
-	if appID != "" {
-		keys = append(keys, envvars.CliAppID)
-	}
-	if appSecret != "" {
-		keys = append(keys, envvars.CliAppSecret)
-	}
-	if hasUAT {
-		keys = append(keys, envvars.CliUserAccessToken)
-	}
-	if hasTAT {
-		keys = append(keys, envvars.CliTenantAccessToken)
-	}
-	return keys
-}
-
 func (p *Provider) ResolveToken(ctx context.Context, req credential.TokenSpec) (*credential.Token, error) {
 	var envKey string
 	switch req.Type {

extension/credential/env/env_test.go

@@ -6,7 +6,6 @@ package env
 import (
 	"context"
 	"errors"
-	"slices"
 	"strings"
 	"testing"
 
@@ -48,22 +47,6 @@ func TestResolveAccount_OnlyIDSet(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %v", err)
 	}
-	if blockErr.Code != credential.BlockReasonCredentialIncomplete {
-		t.Fatalf("Code = %q, want %q", blockErr.Code, credential.BlockReasonCredentialIncomplete)
-	}
-	want := []string{envvars.CliAppSecret, envvars.CliUserAccessToken, envvars.CliTenantAccessToken}
-	if !slices.Equal(blockErr.RequiredAnyOf, want) {
-		t.Fatalf("RequiredAnyOf = %v, want %v", blockErr.RequiredAnyOf, want)
-	}
-	if len(blockErr.MissingKeys) != 0 {
-		t.Fatalf("MissingKeys = %v, want empty", blockErr.MissingKeys)
-	}
-	if !slices.Equal(blockErr.PresentKeys, []string{envvars.CliAppID}) {
-		t.Fatalf("PresentKeys = %v, want [%s]", blockErr.PresentKeys, envvars.CliAppID)
-	}
-	if blockErr.AppID != "cli_test" {
-		t.Fatalf("AppID = %q, want cli_test", blockErr.AppID)
-	}
 }
 
 func TestResolveAccount_AppIDAndUserTokenWithoutSecret(t *testing.T) {
@@ -92,81 +75,18 @@ func TestResolveAccount_OnlySecretSet(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %v", err)
 	}
-	if blockErr.Code != credential.BlockReasonCredentialIncomplete ||
-		!slices.Equal(blockErr.MissingKeys, []string{envvars.CliAppID}) ||
-		!slices.Equal(blockErr.PresentKeys, []string{envvars.CliAppSecret}) {
-		t.Fatalf("BlockError = %+v, want incomplete with missing APP_ID and present APP_SECRET", blockErr)
-	}
-	if len(blockErr.RequiredAnyOf) != 0 {
-		t.Fatalf("RequiredAnyOf = %v, want empty for APP_SECRET-only", blockErr.RequiredAnyOf)
-	}
 }
 
 func TestResolveAccount_OnlyTokenSetWithoutAppID(t *testing.T) {
-	for _, tt := range []struct {
-		name string
-		key  string
-	}{
-		{name: "UAT", key: envvars.CliUserAccessToken},
-		{name: "TAT", key: envvars.CliTenantAccessToken},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv(envvars.CliAppID, "")
-			t.Setenv(envvars.CliAppSecret, "")
-			t.Setenv(envvars.CliUserAccessToken, "")
-			t.Setenv(envvars.CliTenantAccessToken, "")
-			t.Setenv(tt.key, "token_test")
+	t.Setenv(envvars.CliUserAccessToken, "uat_test")
 
-			_, err := (&Provider{}).ResolveAccount(context.Background())
-			var blockErr *credential.BlockError
-			if !errors.As(err, &blockErr) {
-				t.Fatalf("expected BlockError, got %v", err)
-			}
-			if !strings.Contains(err.Error(), envvars.CliAppID) {
-				t.Fatalf("error = %v, want mention of %s", err, envvars.CliAppID)
-			}
-			if blockErr.Code != credential.BlockReasonCredentialIncomplete ||
-				!slices.Equal(blockErr.MissingKeys, []string{envvars.CliAppID}) ||
-				!slices.Equal(blockErr.PresentKeys, []string{tt.key}) {
-				t.Fatalf("BlockError = %+v, want incomplete for %s", blockErr, tt.key)
-			}
-			if len(blockErr.RequiredAnyOf) != 0 {
-				t.Fatalf("RequiredAnyOf = %v, want empty for %s-only", blockErr.RequiredAnyOf, tt.name)
-			}
-		})
+	_, err := (&Provider{}).ResolveAccount(context.Background())
+	var blockErr *credential.BlockError
+	if !errors.As(err, &blockErr) {
+		t.Fatalf("expected BlockError, got %v", err)
 	}
-}
-
-func TestResolveAccount_InvalidPolicyRejectedBeforeIncomplete(t *testing.T) {
-	for _, tt := range []struct {
-		name string
-		key  string
-	}{
-		{name: "DEFAULT_AS", key: envvars.CliDefaultAs},
-		{name: "STRICT_MODE", key: envvars.CliStrictMode},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv(envvars.CliAppID, "cli_test")
-			t.Setenv(envvars.CliAppSecret, "")
-			t.Setenv(envvars.CliUserAccessToken, "")
-			t.Setenv(envvars.CliTenantAccessToken, "")
-			t.Setenv(tt.key, "banana")
-
-			_, err := (&Provider{}).ResolveAccount(context.Background())
-			var blockErr *credential.BlockError
-			if !errors.As(err, &blockErr) {
-				t.Fatalf("error = %T %v, want BlockError", err, err)
-			}
-			if blockErr.Code != credential.BlockReasonInvalidPolicy {
-				t.Fatalf("Code = %q, want %q", blockErr.Code, credential.BlockReasonInvalidPolicy)
-			}
-			if blockErr.Param != tt.key {
-				t.Fatalf("Param = %q, want %q", blockErr.Param, tt.key)
-			}
-			if !strings.Contains(blockErr.Reason, tt.key) {
-				t.Fatalf("reason = %q, want %s", blockErr.Reason, tt.key)
-			}
-		})
+	if !strings.Contains(err.Error(), envvars.CliAppID) {
+		t.Fatalf("error = %v, want mention of %s", err, envvars.CliAppID)
 	}
 }
 
@@ -338,9 +258,6 @@ func TestResolveAccount_InvalidStrictModeRejected(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %T", err)
 	}
-	if blockErr.Code != credential.BlockReasonInvalidPolicy || blockErr.Param != envvars.CliStrictMode {
-		t.Fatalf("BlockError = %+v, want invalid_policy with Param %s", blockErr, envvars.CliStrictMode)
-	}
 	if !strings.Contains(err.Error(), envvars.CliStrictMode) {
 		t.Fatalf("error = %v, want mention of %s", err, envvars.CliStrictMode)
 	}
@@ -359,9 +276,6 @@ func TestResolveAccount_InvalidDefaultAsRejected(t *testing.T) {
 	if !errors.As(err, &blockErr) {
 		t.Fatalf("expected BlockError, got %T", err)
 	}
-	if blockErr.Code != credential.BlockReasonInvalidPolicy || blockErr.Param != envvars.CliDefaultAs {
-		t.Fatalf("BlockError = %+v, want invalid_policy with Param %s", blockErr, envvars.CliDefaultAs)
-	}
 	if !strings.Contains(err.Error(), envvars.CliDefaultAs) {
 		t.Fatalf("error = %v, want mention of %s", err, envvars.CliDefaultAs)
 	}

extension/credential/sidecar/provider.go

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

extension/credential/sidecar/provider_test.go

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

extension/credential/types.go

@@ -44,27 +44,6 @@ func (s IdentitySupport) UserOnly() bool { return s == SupportsUser }
 // BotOnly returns true if only bot identity is supported.
 func (s IdentitySupport) BotOnly() bool { return s == SupportsBot }
 
-// AccountKind declares how an account participates in credential arbitration.
-type AccountKind int
-
-const (
-	// AccountManaged means the provider owns the whole identity; winning it
-	// ends arbitration outright. The zero value, so existing providers are
-	// unchanged.
-	AccountManaged AccountKind = iota
-	// AccountDirect marks an actively supplied raw credential (the env
-	// provider's LARKSUITE_CLI_* variables). It participates in profile
-	// arbitration and conflict detection instead of winning outright.
-	//
-	// RESERVED: only the builtin env provider may declare AccountDirect
-	// today — the arbitration's direct-credential diagnostics are defined in
-	// terms of the process environment, and the caller rejects AccountDirect
-	// from any other provider. Third-party providers must return
-	// AccountManaged until the SPI carries provider-reported input
-	// descriptors.
-	AccountDirect
-)
-
 // Account holds resolved app credentials and configuration.
 type Account struct {
 	AppID               string
@@ -74,7 +53,6 @@ type Account struct {
 	ProfileName         string
 	OpenID              string          // optional; if UAT is available, API result takes precedence
 	SupportedIdentities IdentitySupport // zero = provider did not declare; treat as no restriction
-	Kind                AccountKind     // AccountManaged (default) or AccountDirect
 }
 
 // Token holds a resolved access token and optional metadata.
@@ -98,38 +76,11 @@ type TokenSpec struct {
 	AppID string
 }
 
-// BlockReason classifies provider-originated block conditions that callers may
-// safely map to a more specific public error contract.
-type BlockReason string
-
-const (
-	// BlockReasonCredentialIncomplete marks incomplete inputs from the builtin
-	// process-env credential provider. It is reserved for that provider because
-	// direct-credential arbitration and diagnostics currently name the fixed
-	// LARKSUITE_CLI_* env surface. Third-party providers must return an
-	// unclassified BlockError until the SPI carries provider-owned input
-	// descriptors. Blocks without a Code propagate unchanged.
-	BlockReasonCredentialIncomplete BlockReason = "credential_incomplete"
-
-	// BlockReasonInvalidPolicy marks a user-supplied policy input (e.g.
-	// LARKSUITE_CLI_DEFAULT_AS / LARKSUITE_CLI_STRICT_MODE) that failed
-	// validation. The caller maps it to a typed validation error carrying
-	// Param and a repair hint, so user input mistakes never surface as
-	// internal errors.
-	BlockReasonInvalidPolicy BlockReason = "invalid_policy"
-)
-
 // BlockError is returned by a Provider to actively reject a request
 // and prevent subsequent providers in the chain from being consulted.
 type BlockError struct {
-	Provider      string
-	Reason        string
-	Code          BlockReason
-	MissingKeys   []string // environment variable names only; never values
-	RequiredAnyOf []string // environment variable names only; never values
-	PresentKeys   []string // environment variable names only; never values
-	AppID         string   // plaintext app identifier used only for source comparison; never a secret
-	Param         string   // name of the invalid input variable on invalid_policy blocks; never a value
+	Provider string
+	Reason   string
 }
 
 func (e *BlockError) Error() string {

go.mod

@@ -7,6 +7,8 @@ require (
 	github.com/bmatcuk/doublestar/v4 v4.10.0
 	github.com/charmbracelet/huh v1.0.0
 	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/facebookincubator/flog v0.0.0-20190930132826-d2511d0ce33c
+	github.com/facebookincubator/sks v0.0.0-20251112220143-6823f23937b4
 	github.com/gofrs/flock v0.8.1
 	github.com/google/uuid v1.6.0
 	github.com/itchyny/gojq v0.12.17
@@ -27,7 +29,10 @@ require (
 	gopkg.in/yaml.v3 v3.0.1
 )
 
+require github.com/ebitengine/purego v0.10.1
+
 require (
+	github.com/StackExchange/wmi v1.2.1 // indirect
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/catppuccin/go v0.3.0 // indirect
@@ -42,12 +47,21 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/go-ole/go-ole v1.2.5 // indirect
 	github.com/godbus/dbus/v5 v5.2.2 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/google/btree v1.1.2 // indirect
+	github.com/google/certificate-transparency-go v1.1.8 // indirect
+	github.com/google/certtostore v1.0.6 // indirect
+	github.com/google/deck v0.0.0-20230104221208-105ad94aa8ae // indirect
+	github.com/google/go-attestation v0.5.1 // indirect
+	github.com/google/go-tpm v0.9.0 // indirect
+	github.com/google/go-tspi v0.3.0 // indirect
 	github.com/gopherjs/gopherjs v1.17.2 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/itchyny/timefmt-go v0.1.6 // indirect
+	github.com/jgoguen/go-utils v0.0.0-20200211015258-b42ad41486fd // indirect
 	github.com/jtolds/gls v4.20.0+incompatible // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -57,10 +71,12 @@ require (
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
+	github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/smarty/assertions v1.15.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	golang.org/x/crypto v0.31.0 // indirect
 )

go.sum

@@ -2,6 +2,8 @@ github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ
 github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA=
+github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
@@ -50,14 +52,42 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/ebitengine/purego v0.10.1 h1:dewVBCBT2GaMu1SrNTYxQhgQBethzfhiwvZiLGP/qyY=
+github.com/ebitengine/purego v0.10.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/facebookincubator/flog v0.0.0-20190930132826-d2511d0ce33c h1:KqlxcP2nuOcMjudCvK0qME2K/aFBDH+xcvYv7HYQaYc=
+github.com/facebookincubator/flog v0.0.0-20190930132826-d2511d0ce33c/go.mod h1:QGzNH9ujQ2ZUr/CjDGZGWeDAVStrWNjHeEcjJL96Nuk=
+github.com/facebookincubator/sks v0.0.0-20251112220143-6823f23937b4 h1:z9oNXvtDZv73Rg8UjFhu+wMtDvGkhLm1NMTwZQ68gOM=
+github.com/facebookincubator/sks v0.0.0-20251112220143-6823f23937b4/go.mod h1:FEWpPBUpkMwxqAbprURvgWgdwjeGkge5QFDaZBsfRHQ=
+github.com/go-ole/go-ole v1.2.5 h1:t4MGB5xEDZvXI+0rMjjsfBsD7yAgp/s9ZDkL1JndXwY=
+github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
 github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU=
+github.com/google/btree v1.1.2/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
+github.com/google/certificate-transparency-go v1.0.21/go.mod h1:QeJfpSbVSfYc7RgB3gJFj9cbuQMMchQxrWXz8Ruopmg=
+github.com/google/certificate-transparency-go v1.1.8 h1:LGYKkgZF7satzgTak9R4yzfJXEeYVAjV6/EAEJOf1to=
+github.com/google/certificate-transparency-go v1.1.8/go.mod h1:bV/o8r0TBKRf1X//iiiSgWrvII4d7/8OiA+3vG26gI8=
+github.com/google/certtostore v1.0.6 h1:LlCIgyTvDxTlcncMPTSYZGo6lCsiHzO6Dy7ff6ltk/0=
+github.com/google/certtostore v1.0.6/go.mod h1:2N0ZPLkGvQWhYvXaiBGq02r71fnSLfq78VKIWQHr1wo=
+github.com/google/deck v0.0.0-20230104221208-105ad94aa8ae h1:Iy1Ad7L9qPtNAFJad+Ch2kwDXrcwu7QUBR0bfChjnEM=
+github.com/google/deck v0.0.0-20230104221208-105ad94aa8ae/go.mod h1:DoDv8G58DuLNZF0KysYn0bA/6ZWhmRW3fZE2VnGEH0w=
+github.com/google/go-attestation v0.5.1 h1:jqtOrLk5MNdliTKjPbIPrAaRKJaKW+0LIU2n/brJYms=
+github.com/google/go-attestation v0.5.1/go.mod h1:KqGatdUhg5kPFkokyzSBDxwSCFyRgIgtRkMp6c3lOBQ=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-tpm v0.9.0 h1:sQF6YqWMi+SCXpsmS3fd21oPy/vSddwZry4JnmltHVk=
+github.com/google/go-tpm v0.9.0/go.mod h1:FkNVkc6C+IsvDI9Jw1OveJmxGZUUaKxtrpOS47QWKfU=
+github.com/google/go-tpm-tools v0.4.2 h1:iyaCPKt2N5Rd0yz0G8ANa022SgCNZkMpp+db6QELtvI=
+github.com/google/go-tpm-tools v0.4.2/go.mod h1:fGUDZu4tw3V4hUVuFHmiYgRd0c58/IXivn9v3Ea/ck4=
+github.com/google/go-tspi v0.3.0 h1:ADtq8RKfP+jrTyIWIZDIYcKOMecRqNJFOew2IT0Inus=
+github.com/google/go-tspi v0.3.0/go.mod h1:xfMGI3G0PhxCdNVcYr1C4C+EizojDg/TXuX5by8CiHI=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
@@ -70,6 +100,8 @@ github.com/itchyny/gojq v0.12.17 h1:8av8eGduDb5+rvEdaOO+zQUjA04MS0m3Ps8HiD+fceg=
 github.com/itchyny/gojq v0.12.17/go.mod h1:WBrEMkgAfAGO1LUcGOckBl5O726KPp+OlkKug0I/FEY=
 github.com/itchyny/timefmt-go v0.1.6 h1:ia3s54iciXDdzWzwaVKXZPbiXzxxnv1SPGFfM/myJ5Q=
 github.com/itchyny/timefmt-go v0.1.6/go.mod h1:RRDZYC5s9ErkjQvTvvU7keJjxUYzIISJGxm9/mAERQg=
+github.com/jgoguen/go-utils v0.0.0-20200211015258-b42ad41486fd h1:E3y4CkzAXArgOQAw9gzW0Exe7XQqF4MYH3rCYprAj+Q=
+github.com/jgoguen/go-utils v0.0.0-20200211015258-b42ad41486fd/go.mod h1:ayRB9iNq3dqzUb9oW2JkoVQkDBkJ88NJb66OH13CKSk=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
@@ -97,6 +129,8 @@ github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELU
 github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
 github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
+github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
@@ -137,6 +171,8 @@ go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
@@ -154,6 +190,7 @@ golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
 golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/auth/app_registration.go

@@ -65,6 +65,7 @@ type AppRegistrationResponse struct {
 	VerificationUriComplete string
 	ExpiresIn               int
 	Interval                int
+	RequestedAuthMethod     string
 }
 
 // AppRegistrationResult is the result of a successful app registration poll.
@@ -72,6 +73,11 @@ type AppRegistrationResult struct {
 	ClientID     string
 	ClientSecret string
 	UserInfo     *AppRegUserInfo
+	// AuthMethods is the authoritative auth method(s) the app must use, as
+	// returned by the registration service after user/admin confirmation. It may
+	// differ from what the client requested, for example when selecting an
+	// existing client_secret app. Empty is accepted for compatible older servers.
+	AuthMethods []string
 }
 
 // AppRegUserInfo contains user info returned from app registration.
@@ -85,10 +91,81 @@ func appRegistrationEndpoint(brand core.LarkBrand) string {
 	return core.ResolveEndpoints(brand).Accounts + PathAppRegistration
 }
 
+// AppRegistrationInit is the response from the app registration init endpoint.
+type AppRegistrationInit struct {
+	Nonce                string
+	SupportedAuthMethods []string // e.g. ["client_secret", "private_key_jwt"]
+}
+
+// AppRegistrationBeginOptions parametrizes the registration begin request.
+// A zero value selects the legacy client_secret flow, preserving prior behavior.
+type AppRegistrationBeginOptions struct {
+	AuthMethod      string // "" => client_secret; core.AuthMethodPrivateKeyJWT
+	AuthAttestation string // private_key_jwt: the TEE-signed attestation JWT
+	RestoreAppID    string // when set, asks the server to re-register this existing app
+}
+
+// RequestAppRegistrationInit performs the init step of the registration flow,
+// returning a server nonce (to be embedded in a TEE-signed attestation JWT) and
+// the auth methods the server supports for this archetype.
+func RequestAppRegistrationInit(ctx context.Context, httpClient *http.Client) (*AppRegistrationInit, error) {
+	// Registration always begins against the Feishu accounts host (mirrors begin).
+	endpoint := appRegistrationEndpoint(registrationBootstrapBrand)
+	ctx, cancel := context.WithTimeout(ctx, beginRequestTimeout)
+	defer cancel()
+
+	form := url.Values{}
+	form.Set("action", "init")
+	form.Set("archetype", "PersonalAgent")
+
+	req, err := http.NewRequestWithContext(ctx, "POST", endpoint, strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	logHTTPResponse(resp)
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("app registration init failed: read body: %w", err)
+	}
+
+	var data map[string]interface{}
+	if err := json.Unmarshal(body, &data); err != nil {
+		return nil, fmt.Errorf("app registration init failed: HTTP %d – response not JSON", resp.StatusCode)
+	}
+
+	if _, hasError := data["error"]; resp.StatusCode >= 400 || hasError {
+		msg := getStr(data, "error_description")
+		if msg == "" {
+			msg = getStr(data, "error")
+		}
+		if msg == "" {
+			msg = "Unknown error"
+		}
+		return nil, fmt.Errorf("app registration init failed: %s", msg)
+	}
+
+	out := &AppRegistrationInit{
+		Nonce:                getStr(data, "nonce"),
+		SupportedAuthMethods: parseAuthMethods(data["supported_auth_methods"]),
+	}
+	if out.Nonce == "" {
+		return nil, fmt.Errorf("app registration init failed: server returned no nonce")
+	}
+	return out, nil
+}
+
 // RequestAppRegistration initiates the device flow. The registration protocol
 // always bootstraps on Feishu; brand selects the user-facing verification host.
 // The request is bounded by ctx and a begin timeout.
-func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, errOut io.Writer) (*AppRegistrationResponse, error) {
+func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, opts AppRegistrationBeginOptions, errOut io.Writer) (*AppRegistrationResponse, error) {
 	if errOut == nil {
 		errOut = io.Discard
 	}
@@ -99,11 +176,25 @@ func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand
 	ep := core.ResolveEndpoints(brand)
 	endpoint := appRegistrationEndpoint(registrationBootstrapBrand)
 
+	authMethod := opts.AuthMethod
+	if authMethod == "" {
+		authMethod = core.AuthMethodClientSecret
+	}
+
 	form := url.Values{}
 	form.Set("action", "begin")
 	form.Set("archetype", "PersonalAgent")
-	form.Set("auth_method", "client_secret")
+	form.Set("auth_method", authMethod)
 	form.Set("request_user_info", "open_id tenant_brand")
+	if opts.AuthAttestation != "" {
+		form.Set("auth_attestation", opts.AuthAttestation)
+	}
+	// Restore flow: the registration service accepts the existing OAuth client
+	// identifier under client_id. The launcher URL still uses app_id; these are
+	// separate contracts and must not be changed together.
+	if opts.RestoreAppID != "" {
+		form.Set("client_id", opts.RestoreAppID)
+	}
 
 	req, err := http.NewRequestWithContext(ctx, "POST", endpoint, strings.NewReader(form.Encode()))
 	if err != nil {
@@ -156,7 +247,24 @@ func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand
 
 	userCode := getStr(data, "user_code")
 	verificationUri := getStr(data, "verification_uri")
-	verificationUriComplete := fmt.Sprintf("%s/page/cli?user_code=%s", ep.Open, userCode)
+	// Prefer the server-provided complete URL (currently /page/launcher); fall
+	// back to building it from verification_uri, then to /page/launcher. The old
+	// hard-coded /page/cli is stale — the server now returns /page/launcher.
+	verificationUriComplete := getStr(data, "verification_uri_complete")
+	if verificationUriComplete == "" {
+		base := verificationUri
+		if base == "" {
+			base = ep.Open + "/page/launcher"
+		}
+		// The server may return verification_uri with its own query (e.g.
+		// app_id when registering against an existing app), so join with
+		// the same ?/& logic as BuildVerificationURL.
+		sep := "?"
+		if strings.Contains(base, "?") {
+			sep = "&"
+		}
+		verificationUriComplete = base + sep + "user_code=" + url.QueryEscape(userCode)
+	}
 
 	return &AppRegistrationResponse{
 		DeviceCode:              deviceCode,
@@ -165,18 +273,91 @@ func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand
 		VerificationUriComplete: verificationUriComplete,
 		ExpiresIn:               expiresIn,
 		Interval:                interval,
+		RequestedAuthMethod:     authMethod,
 	}, nil
 }
 
+// parseAuthMethods normalizes the poll response `auth_method` field, which the
+// server returns as a JSON array of strings (e.g. ["private_key_jwt"]) — or, on
+// some variants, a single space-separated string.
+func parseAuthMethods(v interface{}) []string {
+	switch t := v.(type) {
+	case []interface{}:
+		out := make([]string, 0, len(t))
+		for _, m := range t {
+			if s, ok := m.(string); ok && s != "" {
+				out = append(out, s)
+			}
+		}
+		return out
+	case string:
+		return strings.Fields(t)
+	default:
+		return nil
+	}
+}
+
+func containsAuthMethod(methods []string, target string) bool {
+	for _, method := range methods {
+		if method == target {
+			return true
+		}
+	}
+	return false
+}
+
+func registrationResultComplete(result *AppRegistrationResult, requestedAuthMethod string) bool {
+	if result.ClientID == "" {
+		return false
+	}
+	if result.ClientSecret != "" {
+		return true
+	}
+	if len(result.AuthMethods) > 0 {
+		return containsAuthMethod(result.AuthMethods, core.AuthMethodPrivateKeyJWT)
+	}
+	// Older servers may omit auth_method. In that case only a begin request
+	// explicitly made as private_key_jwt may complete without a client secret.
+	return requestedAuthMethod == core.AuthMethodPrivateKeyJWT
+}
+
 // BuildVerificationURL appends CLI tracking parameters to the verification URL.
-func BuildVerificationURL(baseURL, cliVersion string) string {
+// When targetAppID is non-empty, it is also included so the launcher can lock
+// authorization to that existing app.
+func BuildVerificationURL(baseURL, cliVersion string, targetAppID ...string) string {
+	u, err := url.Parse(baseURL)
+	if err != nil {
+		return appendVerificationURLFallback(baseURL, cliVersion, targetAppID...)
+	}
+	q := u.Query()
+	if q.Get("lpv") == "" {
+		q.Set("lpv", cliVersion)
+	}
+	if q.Get("ocv") == "" {
+		q.Set("ocv", cliVersion)
+	}
+	if q.Get("from") == "" {
+		q.Set("from", "cli")
+	}
+	if len(targetAppID) > 0 && targetAppID[0] != "" && q.Get("app_id") == "" {
+		q.Set("app_id", targetAppID[0])
+	}
+	u.RawQuery = q.Encode()
+	return u.String()
+}
+
+func appendVerificationURLFallback(baseURL, cliVersion string, targetAppID ...string) string {
 	sep := "&"
 	if !strings.Contains(baseURL, "?") {
 		sep = "?"
 	}
-	return baseURL + sep + "lpv=" + url.QueryEscape(cliVersion) +
+	out := baseURL + sep + "lpv=" + url.QueryEscape(cliVersion) +
 		"&ocv=" + url.QueryEscape(cliVersion) +
 		"&from=cli"
+	if len(targetAppID) > 0 && targetAppID[0] != "" && !strings.Contains(baseURL, "app_id=") {
+		out += "&app_id=" + url.QueryEscape(targetAppID[0])
+	}
+	return out
 }
 
 // pollOnce performs one ctx-bound poll request and decodes the payload.
@@ -273,6 +454,7 @@ func RegisterAppWithDiscovery(ctx context.Context, httpClient *http.Client, resp
 			result := &AppRegistrationResult{
 				ClientID:     getStr(data, "client_id"),
 				ClientSecret: getStr(data, "client_secret"),
+				AuthMethods:  parseAuthMethods(data["auth_method"]),
 			}
 			if userInfoRaw, ok := data["user_info"].(map[string]interface{}); ok {
 				result.UserInfo = &AppRegUserInfo{
@@ -281,7 +463,7 @@ func RegisterAppWithDiscovery(ctx context.Context, httpClient *http.Client, resp
 				}
 			}
 
-			if result.ClientID != "" && result.ClientSecret != "" {
+			if registrationResultComplete(result, resp.RequestedAuthMethod) {
 				// The issuing domain is authoritative; a contradictory final
 				// tenant report is a protocol violation, not a brand override.
 				if result.UserInfo != nil && result.UserInfo.TenantBrand != "" &&

internal/auth/app_registration_test.go

@@ -8,6 +8,8 @@ import (
 	"errors"
 	"io"
 	"net/http"
+	"net/url"
+	"slices"
 	"strings"
 	"testing"
 	"time"
@@ -30,10 +32,14 @@ func jsonResponse(body string) *http.Response {
 func Test_BuildVerificationURL(t *testing.T) {
 	t.Run("URL不含问号则添加?分隔符", func(t *testing.T) {
 		result := BuildVerificationURL("https://example.com/verify", "1.0.0")
+		got, err := url.Parse(result)
+		if err != nil {
+			t.Fatal(err)
+		}
 		convey.Convey("should add ? separator", t, func() {
-			convey.So(result, convey.ShouldContainSubstring, "?lpv=1.0.0")
-			convey.So(result, convey.ShouldContainSubstring, "&ocv=1.0.0")
-			convey.So(result, convey.ShouldContainSubstring, "&from=cli")
+			convey.So(got.Query().Get("lpv"), convey.ShouldEqual, "1.0.0")
+			convey.So(got.Query().Get("ocv"), convey.ShouldEqual, "1.0.0")
+			convey.So(got.Query().Get("from"), convey.ShouldEqual, "cli")
 			convey.So(result, convey.ShouldStartWith, "https://example.com/verify?")
 		})
 	})
@@ -47,6 +53,237 @@ func Test_BuildVerificationURL(t *testing.T) {
 			convey.So(result, convey.ShouldNotContainSubstring, "?lpv=")
 		})
 	})
+
+	t.Run("指定已有应用时添加app_id", func(t *testing.T) {
+		result := BuildVerificationURL("https://example.com/verify?user_code=abc", "2.0.0", "cli_existing")
+		got, err := url.Parse(result)
+		if err != nil {
+			t.Fatal(err)
+		}
+		convey.Convey("should include target app_id", t, func() {
+			convey.So(got.Query().Get("app_id"), convey.ShouldEqual, "cli_existing")
+			convey.So(got.Query().Get("client_id"), convey.ShouldEqual, "")
+			convey.So(got.Query().Get("lpv"), convey.ShouldEqual, "2.0.0")
+		})
+	})
+
+	t.Run("服务端已返回app_id时不覆盖", func(t *testing.T) {
+		result := BuildVerificationURL("https://example.com/verify?app_id=cli_server&user_code=abc", "2.0.0", "cli_existing")
+		got, err := url.Parse(result)
+		if err != nil {
+			t.Fatal(err)
+		}
+		convey.Convey("should keep server app_id", t, func() {
+			convey.So(got.Query().Get("app_id"), convey.ShouldEqual, "cli_server")
+		})
+	})
+}
+
+// captureClient returns an http.Client that records the last request's form body
+// and replies with the given JSON payload.
+func captureClient(gotBody *url.Values, respJSON string) *http.Client {
+	return &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			if req.Body != nil {
+				b, _ := io.ReadAll(req.Body)
+				v, _ := url.ParseQuery(string(b))
+				*gotBody = v
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     make(http.Header),
+				Body:       io.NopCloser(strings.NewReader(respJSON)),
+			}, nil
+		}),
+	}
+}
+
+func TestRequestAppRegistrationInit_ParsesNonceAndMethods(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, `{"nonce":"n-123","supported_auth_methods":["client_secret","private_key_jwt"]}`)
+
+	out, err := RequestAppRegistrationInit(context.Background(), hc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if out.Nonce != "n-123" {
+		t.Errorf("nonce = %q, want n-123", out.Nonce)
+	}
+	if len(out.SupportedAuthMethods) != 2 || out.SupportedAuthMethods[1] != "private_key_jwt" {
+		t.Errorf("methods = %v", out.SupportedAuthMethods)
+	}
+	if body.Get("action") != "init" {
+		t.Errorf("action = %q, want init", body.Get("action"))
+	}
+}
+
+func TestRequestAppRegistrationInit_ErrorOnMissingNonce(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, `{"supported_auth_methods":["client_secret"]}`)
+	if _, err := RequestAppRegistrationInit(context.Background(), hc); err == nil {
+		t.Fatal("expected error when server returns no nonce")
+	}
+}
+
+// TestRequestAppRegistrationInit_EmptySupportedAuthMethods covers the older-server
+// back-compat path: an empty supported_auth_methods array parses to an empty
+// slice, so the init guard in cmd/config/init_interactive.go
+// (`len(SupportedAuthMethods) > 0 && !slices.Contains(...)`) stays false and does
+// NOT reject the requested private_key_jwt. This aligns with
+// resolveFinalAuthMethod(nil/[], private_key_jwt) == private_key_jwt
+// (see cmd/config TestResolveFinalAuthMethod).
+func TestRequestAppRegistrationInit_EmptySupportedAuthMethods(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, `{"nonce":"n-1","supported_auth_methods":[]}`)
+
+	out, err := RequestAppRegistrationInit(context.Background(), hc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if out.Nonce != "n-1" {
+		t.Errorf("nonce = %q, want n-1", out.Nonce)
+	}
+	if len(out.SupportedAuthMethods) != 0 {
+		t.Errorf("SupportedAuthMethods = %v, want empty", out.SupportedAuthMethods)
+	}
+	// Reproduce the init guard expression on the real parsed result: an empty
+	// slice must NOT reject private_key_jwt.
+	rejected := len(out.SupportedAuthMethods) > 0 &&
+		!slices.Contains(out.SupportedAuthMethods, core.AuthMethodPrivateKeyJWT)
+	if rejected {
+		t.Error("empty SupportedAuthMethods must allow private_key_jwt (older-server back-compat)")
+	}
+}
+
+const beginRespJSON = `{"device_code":"dc","user_code":"uc","verification_uri":"https://example/verify","expires_in":300,"interval":5}`
+
+func TestRequestAppRegistration_BeginDefaultsToClientSecret(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, beginRespJSON)
+
+	if _, err := RequestAppRegistration(context.Background(), hc, core.BrandFeishu, AppRegistrationBeginOptions{}, nil); err != nil {
+		t.Fatal(err)
+	}
+	if body.Get("action") != "begin" {
+		t.Errorf("action = %q", body.Get("action"))
+	}
+	if body.Get("auth_method") != "client_secret" {
+		t.Errorf("auth_method = %q, want client_secret (default)", body.Get("auth_method"))
+	}
+	if body.Has("auth_attestation") {
+		t.Errorf("auth_attestation should be absent for client_secret, got %q", body.Get("auth_attestation"))
+	}
+	// Normal (non-restore) begin must NOT carry client_id.
+	if body.Has("client_id") {
+		t.Errorf("client_id should be absent when RestoreAppID is empty, got %q", body.Get("client_id"))
+	}
+}
+
+// TestRequestAppRegistration_BeginRestoreAppID verifies the restore flow sends the
+// existing app id on begin so the server re-registers that app.
+func TestRequestAppRegistration_BeginRestoreAppID(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, beginRespJSON)
+
+	opts := AppRegistrationBeginOptions{RestoreAppID: "cli_restore_me"}
+	if _, err := RequestAppRegistration(context.Background(), hc, core.BrandFeishu, opts, nil); err != nil {
+		t.Fatal(err)
+	}
+	if body.Get("action") != "begin" {
+		t.Errorf("action = %q, want begin", body.Get("action"))
+	}
+	if body.Get("client_id") != "cli_restore_me" {
+		t.Errorf("client_id = %q, want cli_restore_me", body.Get("client_id"))
+	}
+	if body.Has("app_id") {
+		t.Errorf("begin form app_id must be absent, got %q", body.Get("app_id"))
+	}
+}
+
+func TestRequestAppRegistration_VerificationURICompleteFallback(t *testing.T) {
+	cases := []struct {
+		name string
+		resp string
+		want string
+	}{
+		{
+			name: "bare verification_uri",
+			resp: `{"device_code":"dc","user_code":"uc","verification_uri":"https://example/verify","expires_in":300,"interval":5}`,
+			want: "https://example/verify?user_code=uc",
+		},
+		{
+			name: "verification_uri with existing query",
+			resp: `{"device_code":"dc","user_code":"uc","verification_uri":"https://example/verify?app_id=cli_x","expires_in":300,"interval":5}`,
+			want: "https://example/verify?app_id=cli_x&user_code=uc",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			var body url.Values
+			hc := captureClient(&body, tc.resp)
+			got, err := RequestAppRegistration(context.Background(), hc, core.BrandFeishu, AppRegistrationBeginOptions{}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got.VerificationUriComplete != tc.want {
+				t.Errorf("VerificationUriComplete = %q, want %q", got.VerificationUriComplete, tc.want)
+			}
+		})
+	}
+}
+
+func TestParseAuthMethods(t *testing.T) {
+	if got := parseAuthMethods([]interface{}{"private_key_jwt", "client_secret"}); len(got) != 2 || got[0] != "private_key_jwt" {
+		t.Errorf("array form = %v", got)
+	}
+	if got := parseAuthMethods("client_secret private_key_jwt"); len(got) != 2 || got[1] != "private_key_jwt" {
+		t.Errorf("string form = %v", got)
+	}
+	if got := parseAuthMethods(nil); got != nil {
+		t.Errorf("nil form = %v, want nil", got)
+	}
+}
+
+func TestRequestAppRegistration_BeginPrivateKeyJWT(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, beginRespJSON)
+
+	opts := AppRegistrationBeginOptions{
+		AuthMethod:      core.AuthMethodPrivateKeyJWT,
+		AuthAttestation: "header.claims.sig",
+	}
+	if _, err := RequestAppRegistration(context.Background(), hc, core.BrandFeishu, opts, nil); err != nil {
+		t.Fatal(err)
+	}
+	if body.Get("auth_method") != "private_key_jwt" {
+		t.Errorf("auth_method = %q, want private_key_jwt", body.Get("auth_method"))
+	}
+	if body.Get("auth_attestation") != "header.claims.sig" {
+		t.Errorf("auth_attestation = %q", body.Get("auth_attestation"))
+	}
+}
+
+func TestRequestAppRegistration_BeginPrivateKeyJWTExistingAppID(t *testing.T) {
+	var body url.Values
+	hc := captureClient(&body, beginRespJSON)
+
+	opts := AppRegistrationBeginOptions{
+		AuthMethod:      core.AuthMethodPrivateKeyJWT,
+		AuthAttestation: "header.claims.sig",
+		RestoreAppID:    "cli_existing",
+	}
+	if _, err := RequestAppRegistration(context.Background(), hc, core.BrandFeishu, opts, nil); err != nil {
+		t.Fatal(err)
+	}
+	if body.Get("auth_method") != "private_key_jwt" {
+		t.Errorf("auth_method = %q, want private_key_jwt", body.Get("auth_method"))
+	}
+	if body.Get("auth_attestation") != "header.claims.sig" {
+		t.Errorf("auth_attestation = %q", body.Get("auth_attestation"))
+	}
+	if body.Get("client_id") != "cli_existing" {
+		t.Errorf("client_id = %q, want cli_existing", body.Get("client_id"))
+	}
 }
 
 func TestAppRegistrationEndpoint(t *testing.T) {
@@ -80,11 +317,11 @@ func TestRequestAppRegistration_UsesFeishuBootstrapAndConfiguredVerificationBran
 				}
 				return jsonResponse(`{"device_code":"d","user_code":"TEST-CODE","expire_in":60,"interval":5}`), nil
 			})}
-			resp, err := RequestAppRegistration(context.Background(), client, c.brand, io.Discard)
+			resp, err := RequestAppRegistration(context.Background(), client, c.brand, AppRegistrationBeginOptions{}, io.Discard)
 			if err != nil {
 				t.Fatalf("RequestAppRegistration(%q) error = %v", c.brand, err)
 			}
-			if !strings.HasPrefix(resp.VerificationUriComplete, "https://"+c.verificationHost+"/page/cli?") {
+			if !strings.HasPrefix(resp.VerificationUriComplete, "https://"+c.verificationHost+"/page/launcher?") {
 				t.Errorf("verification URL = %q, want host %q", resp.VerificationUriComplete, c.verificationHost)
 			}
 		})
@@ -115,11 +352,11 @@ func TestRegisterAppWithDiscovery_LarkFlowUsesProtocolBootstrap(t *testing.T) {
 		t.Errorf("unexpected host polled: %s", r.URL.Host)
 		return jsonResponse(`{}`), nil
 	})}
-	resp, err := RequestAppRegistration(context.Background(), client, core.BrandLark, io.Discard)
+	resp, err := RequestAppRegistration(context.Background(), client, core.BrandLark, AppRegistrationBeginOptions{}, io.Discard)
 	if err != nil {
 		t.Fatalf("RequestAppRegistration error = %v", err)
 	}
-	if got, want := resp.VerificationUriComplete, "https://open.larksuite.com/page/cli?user_code=TEST-CODE"; got != want {
+	if got, want := resp.VerificationUriComplete, "https://open.larksuite.com/page/launcher?user_code=TEST-CODE"; got != want {
 		t.Errorf("verification URL = %q, want %q", got, want)
 	}
 
@@ -219,6 +456,51 @@ func TestRegisterAppWithDiscovery_PollsUntilCredentials(t *testing.T) {
 	}
 }
 
+func TestRegisterAppWithDiscovery_KeylessCompletesWithoutSecret(t *testing.T) {
+	tests := []struct {
+		name                string
+		response            string
+		requestedAuthMethod string
+	}{
+		{
+			name:     "server explicitly returns private_key_jwt",
+			response: `{"client_id":"cli_keyless","auth_method":["private_key_jwt"]}`,
+		},
+		{
+			name:                "older server omits auth_method for a keyless begin",
+			response:            `{"client_id":"cli_keyless"}`,
+			requestedAuthMethod: core.AuthMethodPrivateKeyJWT,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			polls := 0
+			client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
+				polls++
+				return jsonResponse(tt.response), nil
+			})}
+			resp := &AppRegistrationResponse{
+				DeviceCode:          "device",
+				Interval:            0,
+				ExpiresIn:           5,
+				RequestedAuthMethod: tt.requestedAuthMethod,
+			}
+
+			result, _, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
+			if err != nil {
+				t.Fatalf("RegisterAppWithDiscovery error = %v, want nil", err)
+			}
+			if polls != 1 {
+				t.Errorf("polls = %d, want 1", polls)
+			}
+			if result.ClientID != "cli_keyless" || result.ClientSecret != "" {
+				t.Errorf("result = (%q, %q), want (cli_keyless, empty secret)", result.ClientID, result.ClientSecret)
+			}
+		})
+	}
+}
+
 // Neither the first poll nor the cross-brand switch waits out the interval
 // (a 5s interval would blow the elapsed bound).
 func TestRegisterAppWithDiscovery_ImmediateFirstPollAndSwitch(t *testing.T) {
@@ -286,7 +568,7 @@ func TestRequestAppRegistration_ProtocolFields(t *testing.T) {
 	}
 
 	resp, err := RequestAppRegistration(context.Background(),
-		serve(`{"device_code":"d","expire_in":60,"interval":3}`), core.BrandFeishu, io.Discard)
+		serve(`{"device_code":"d","expire_in":60,"interval":3}`), core.BrandFeishu, AppRegistrationBeginOptions{}, io.Discard)
 	if err != nil {
 		t.Fatalf("begin error = %v", err)
 	}
@@ -295,7 +577,7 @@ func TestRequestAppRegistration_ProtocolFields(t *testing.T) {
 	}
 
 	resp, err = RequestAppRegistration(context.Background(),
-		serve(`{"device_code":"d","expires_in":45}`), core.BrandFeishu, io.Discard)
+		serve(`{"device_code":"d","expires_in":45}`), core.BrandFeishu, AppRegistrationBeginOptions{}, io.Discard)
 	if err != nil {
 		t.Fatalf("legacy begin error = %v", err)
 	}
@@ -304,7 +586,7 @@ func TestRequestAppRegistration_ProtocolFields(t *testing.T) {
 	}
 
 	resp, err = RequestAppRegistration(context.Background(),
-		serve(`{"device_code":"d","interval":0}`), core.BrandFeishu, io.Discard)
+		serve(`{"device_code":"d","interval":0}`), core.BrandFeishu, AppRegistrationBeginOptions{}, io.Discard)
 	if err != nil {
 		t.Fatalf("defaults begin error = %v", err)
 	}
@@ -313,7 +595,7 @@ func TestRequestAppRegistration_ProtocolFields(t *testing.T) {
 	}
 
 	if _, err := RequestAppRegistration(context.Background(),
-		serve(`{"interval":5}`), core.BrandFeishu, io.Discard); err == nil {
+		serve(`{"interval":5}`), core.BrandFeishu, AppRegistrationBeginOptions{}, io.Discard); err == nil {
 		t.Error("missing device_code: expected error, got nil")
 	}
 }
@@ -394,7 +676,7 @@ func TestRequestAppRegistration_BodyReadCancelKeepsCause(t *testing.T) {
 			Header:     make(http.Header),
 		}, nil
 	})}
-	_, err := RequestAppRegistration(context.Background(), client, core.BrandFeishu, io.Discard)
+	_, err := RequestAppRegistration(context.Background(), client, core.BrandFeishu, AppRegistrationBeginOptions{}, io.Discard)
 	if !errors.Is(err, context.Canceled) {
 		t.Errorf("err = %v, want a context.Canceled cause", err)
 	}

internal/auth/client_auth.go

@@ -0,0 +1,124 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package auth
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/larksuite/cli/internal/auth/jwt"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keylesshelper"
+	"github.com/larksuite/cli/internal/keylessprovider"
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+// ClientAuth describes how to authenticate the OAuth client at the token
+// endpoint: with a client_secret (default) or a TEE-signed client_assertion
+// (private_key_jwt).
+type ClientAuth struct {
+	AppID       string
+	AppSecret   string
+	AuthMethod  string // "" == client_secret; core.AuthMethodPrivateKeyJWT
+	Signer      keysigner.Signer
+	KeyLabel    string
+	KeyProvider string
+
+	// externalSigner is a verified provider snapshot prepared once for a
+	// multi-request operation (for example a device-flow poll loop). The helper
+	// still re-verifies its binary and mints a fresh assertion on every call.
+	externalSigner clientAssertionSigner
+}
+
+type clientAssertionSigner interface {
+	SignClientAssertion(context.Context, string, string, string) (string, string, error)
+}
+
+var resolveExternalAssertionSigner = func(ctx context.Context, provider string) (clientAssertionSigner, error) {
+	return keylessprovider.Resolve(ctx, provider)
+}
+
+// ClientAuthFromConfig builds a ClientAuth from resolved config, picking up the
+// active key signer for private_key_jwt apps.
+func ClientAuthFromConfig(cfg *core.CliConfig) ClientAuth {
+	if cfg == nil {
+		return ClientAuth{}
+	}
+	return ClientAuth{
+		AppID:       cfg.AppID,
+		AppSecret:   cfg.AppSecret,
+		AuthMethod:  cfg.AuthMethod,
+		KeyLabel:    cfg.KeyLabel,
+		KeyProvider: cfg.KeyProvider,
+		Signer:      keysigner.Active(),
+	}
+}
+
+func (c ClientAuth) isPrivateKeyJWT() bool { return c.AuthMethod == core.AuthMethodPrivateKeyJWT }
+
+// ResolveSigner prepares the external private_key_jwt signer for reuse within
+// one operation and returns the prepared copy. Built-in signers and
+// client_secret authentication need no provider discovery. Keeping the
+// resolved helper on ClientAuth separates expensive provider discovery from
+// assertion minting: callers may reuse the returned value, while every call to
+// applyClientAssertion still asks the signer for a fresh assertion.
+func (c ClientAuth) ResolveSigner(ctx context.Context) (ClientAuth, error) {
+	if !c.isPrivateKeyJWT() || c.KeyProvider == "" || c.externalSigner != nil {
+		return c, nil
+	}
+	helper, err := resolveExternalAssertionSigner(ctx, c.KeyProvider)
+	if err != nil {
+		return c, err
+	}
+	if helper == nil {
+		return c, fmt.Errorf("private_key_jwt provider %q resolved without a signer", c.KeyProvider)
+	}
+	c.externalSigner = helper
+	return c, nil
+}
+
+// SignClientAssertion signs with a resolved external helper when present,
+// otherwise with the platform signer.
+func SignClientAssertion(ctx context.Context, signer keysigner.Signer, helper *keylesshelper.Command, keyLabel, clientID, audience string) (string, string, error) {
+	if helper != nil {
+		return helper.SignClientAssertion(ctx, keyLabel, clientID, audience)
+	}
+	assertion, err := jwt.SignClientAssertion(ctx, signer, keysigner.KeyRef{Label: keyLabel}, clientID, audience, time.Now())
+	return jwt.ClientAssertionType, assertion, err
+}
+
+// applyClientAssertion adds client_assertion(+type) to a token-endpoint form for
+// private_key_jwt and returns true. For client_secret it returns false, leaving
+// the caller to apply its own secret-based authentication. audience is the token
+// endpoint URL (the assertion's aud claim).
+func (c ClientAuth) applyClientAssertion(ctx context.Context, form url.Values, audience string) (bool, error) {
+	if !c.isPrivateKeyJWT() {
+		return false, nil
+	}
+	var err error
+	if c.KeyProvider != "" {
+		c, err = c.ResolveSigner(ctx)
+		if err != nil {
+			return false, err
+		}
+	}
+	helper := c.externalSigner
+	if helper == nil && c.Signer == nil {
+		return false, fmt.Errorf("private_key_jwt requires a key signer, but none is available on this build")
+	}
+	var assertionType, assertion string
+	if helper != nil {
+		assertionType, assertion, err = helper.SignClientAssertion(ctx, c.KeyLabel, c.AppID, audience)
+	} else {
+		assertionType, assertion, err = SignClientAssertion(ctx, c.Signer, nil, c.KeyLabel, c.AppID, audience)
+	}
+	if err != nil {
+		return false, err
+	}
+	form.Set("client_assertion_type", assertionType)
+	form.Set("client_assertion", assertion)
+	return true, nil
+}

internal/auth/client_auth_test.go

@@ -0,0 +1,227 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package auth
+
+import (
+	"context"
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/sha256"
+	"fmt"
+	"net/url"
+	"testing"
+
+	"github.com/larksuite/cli/internal/auth/jwt"
+	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+// fakeAuthSigner is a real in-memory ECDSA P-256 signer for client-auth tests.
+type fakeAuthSigner struct{ key *ecdsa.PrivateKey }
+
+type fakeExternalAssertionSigner struct {
+	keyRef, clientID, audience string
+	calls                      int
+}
+
+func (f *fakeExternalAssertionSigner) SignClientAssertion(_ context.Context, keyRef, clientID, audience string) (string, string, error) {
+	f.keyRef, f.clientID, f.audience = keyRef, clientID, audience
+	f.calls++
+	return jwt.ClientAssertionType, fmt.Sprintf("external.jwt.%d", f.calls), nil
+}
+
+func newFakeAuthSigner(t *testing.T) *fakeAuthSigner {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &fakeAuthSigner{key: k}
+}
+
+func (f *fakeAuthSigner) EnsureKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return f.key.Public(), nil
+}
+func (f *fakeAuthSigner) PublicKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return f.key.Public(), nil
+}
+func (f *fakeAuthSigner) Sign(_ context.Context, _ keysigner.KeyRef, in []byte) ([]byte, string, error) {
+	h := sha256.Sum256(in)
+	r, s, err := ecdsa.Sign(rand.Reader, f.key, h[:])
+	if err != nil {
+		return nil, "", err
+	}
+	sig := make([]byte, 64)
+	r.FillBytes(sig[:32])
+	s.FillBytes(sig[32:])
+	return sig, keysigner.AlgES256, nil
+}
+
+func TestClientAuth_applyClientAssertion_ClientSecret(t *testing.T) {
+	ca := ClientAuth{AppID: "cli_a", AppSecret: "test-secret"} // AuthMethod "" => client_secret
+	form := url.Values{}
+	used, err := ca.applyClientAssertion(context.Background(), form, "https://aud/token")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if used {
+		t.Error("client_secret must not produce a client_assertion")
+	}
+	if form.Has("client_assertion") || form.Has("client_assertion_type") {
+		t.Errorf("form should be untouched, got %v", form)
+	}
+}
+
+func TestClientAuth_applyClientAssertion_PrivateKeyJWT(t *testing.T) {
+	ca := ClientAuth{
+		AppID:      "cli_a",
+		AuthMethod: core.AuthMethodPrivateKeyJWT,
+		Signer:     newFakeAuthSigner(t),
+		KeyLabel:   "k",
+	}
+	form := url.Values{}
+	used, err := ca.applyClientAssertion(context.Background(), form, "https://accounts.feishu.cn/open-apis/authen/v2/oauth/token")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !used {
+		t.Fatal("expected client_assertion to be applied")
+	}
+	if form.Get("client_assertion_type") != jwt.ClientAssertionType {
+		t.Errorf("client_assertion_type = %q", form.Get("client_assertion_type"))
+	}
+	if form.Get("client_assertion") == "" {
+		t.Error("client_assertion is empty")
+	}
+	if form.Has("client_secret") {
+		t.Error("client_secret must NOT be present for private_key_jwt")
+	}
+}
+
+func TestClientAuth_applyClientAssertion_NilSigner(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	ca := ClientAuth{AppID: "cli_a", AuthMethod: core.AuthMethodPrivateKeyJWT} // Signer nil
+	if _, err := ca.applyClientAssertion(context.Background(), url.Values{}, "aud"); err == nil {
+		t.Fatal("expected error when private_key_jwt has no signer")
+	}
+}
+
+func TestClientAuth_applyClientAssertion_UnknownProviderFailsClosed(t *testing.T) {
+	ca := ClientAuth{AppID: "cli_a", AuthMethod: core.AuthMethodPrivateKeyJWT, Signer: newFakeAuthSigner(t), KeyLabel: "k", KeyProvider: "evil.provider"}
+	form := url.Values{}
+	used, err := ca.applyClientAssertion(context.Background(), form, "aud")
+	if err == nil || used || form.Has("client_assertion") {
+		t.Fatalf("unknown provider must fail closed: used=%v form=%v err=%v", used, form, err)
+	}
+}
+
+func TestClientAuth_applyClientAssertion_NilExternalProviderDoesNotFallback(t *testing.T) {
+	previous := resolveExternalAssertionSigner
+	resolveExternalAssertionSigner = func(context.Context, string) (clientAssertionSigner, error) {
+		return nil, nil
+	}
+	t.Cleanup(func() { resolveExternalAssertionSigner = previous })
+
+	ca := ClientAuth{
+		AppID: "cli_a", AppSecret: "must-not-send", AuthMethod: core.AuthMethodPrivateKeyJWT,
+		Signer: newFakeAuthSigner(t), KeyLabel: "k", KeyProvider: core.KeylessProviderLarkSuite,
+	}
+	form := url.Values{}
+	used, err := ca.applyClientAssertion(context.Background(), form, "aud")
+	if err == nil || used || form.Has("client_assertion") || form.Has("client_secret") {
+		t.Fatalf("nil external provider must fail closed: used=%v form=%v err=%v", used, form, err)
+	}
+}
+
+func TestClientAuth_applyClientAssertion_ExplicitProviderDoesNotUseBuiltinOrSecret(t *testing.T) {
+	fake := &fakeExternalAssertionSigner{}
+	previous := resolveExternalAssertionSigner
+	resolveExternalAssertionSigner = func(_ context.Context, provider string) (clientAssertionSigner, error) {
+		if provider != core.KeylessProviderLarkSuite {
+			t.Fatalf("provider = %q", provider)
+		}
+		return fake, nil
+	}
+	t.Cleanup(func() { resolveExternalAssertionSigner = previous })
+
+	ca := ClientAuth{
+		AppID: "cli_external", AppSecret: "must-not-send", AuthMethod: core.AuthMethodPrivateKeyJWT,
+		Signer: newFakeAuthSigner(t), KeyLabel: "openclaw-lark", KeyProvider: core.KeylessProviderLarkSuite,
+	}
+	form := url.Values{}
+	used, err := ca.applyClientAssertion(context.Background(), form, "open.feishu.cn")
+	if err != nil || !used {
+		t.Fatalf("applyClientAssertion = used %v err %v", used, err)
+	}
+	if form.Get("client_assertion") != "external.jwt.1" || form.Has("client_secret") ||
+		fake.keyRef != "openclaw-lark" || fake.clientID != "cli_external" || fake.audience != "open.feishu.cn" {
+		t.Fatalf("form=%v signer=(%q,%q,%q)", form, fake.keyRef, fake.clientID, fake.audience)
+	}
+}
+
+func TestClientAuth_ResolveSignerPreparedCopyReusesResolutionAndRemintsAssertions(t *testing.T) {
+	fake := &fakeExternalAssertionSigner{}
+	resolveCalls := 0
+	previous := resolveExternalAssertionSigner
+	resolveExternalAssertionSigner = func(_ context.Context, provider string) (clientAssertionSigner, error) {
+		resolveCalls++
+		if provider != core.KeylessProviderLarkSuite {
+			t.Fatalf("provider = %q", provider)
+		}
+		return fake, nil
+	}
+	t.Cleanup(func() { resolveExternalAssertionSigner = previous })
+
+	original := ClientAuth{
+		AppID: "cli_external", AuthMethod: core.AuthMethodPrivateKeyJWT,
+		KeyLabel: "openclaw-lark", KeyProvider: core.KeylessProviderLarkSuite,
+	}
+	prepared, err := original.ResolveSigner(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if original.externalSigner != nil {
+		t.Fatal("ResolveSigner must return a prepared copy without mutating the original")
+	}
+
+	forms := []url.Values{{}, {}}
+	for _, form := range forms {
+		used, err := prepared.applyClientAssertion(context.Background(), form, "open.feishu.cn")
+		if err != nil || !used {
+			t.Fatalf("applyClientAssertion = used %v err %v", used, err)
+		}
+	}
+
+	if resolveCalls != 1 {
+		t.Fatalf("provider resolution calls = %d, want 1", resolveCalls)
+	}
+	if fake.calls != 2 {
+		t.Fatalf("assertion signing calls = %d, want 2", fake.calls)
+	}
+	first := forms[0].Get("client_assertion")
+	second := forms[1].Get("client_assertion")
+	if first == "" || second == "" || first == second {
+		t.Fatalf("assertions = (%q, %q), want two fresh values", first, second)
+	}
+	for _, form := range forms {
+		if form.Has("client_secret") {
+			t.Fatalf("private_key_jwt form leaked client_secret: %v", form)
+		}
+	}
+}
+
+func TestClientAuthFromConfig(t *testing.T) {
+	ca := ClientAuthFromConfig(&core.CliConfig{
+		AppID:      "cli_x",
+		AppSecret:  "test-secret",
+		AuthMethod: core.AuthMethodPrivateKeyJWT,
+		KeyLabel:   "label-1",
+	})
+	if ca.AppID != "cli_x" || ca.AppSecret != "test-secret" || ca.AuthMethod != core.AuthMethodPrivateKeyJWT || ca.KeyLabel != "label-1" {
+		t.Errorf("ClientAuth = %+v", ca)
+	}
+}

internal/auth/device_flow.go

@@ -62,7 +62,7 @@ func ResolveOAuthEndpoints(brand core.LarkBrand) OAuthEndpoints {
 }
 
 // RequestDeviceAuthorization requests a device authorization code.
-func RequestDeviceAuthorization(httpClient *http.Client, appId, appSecret string, brand core.LarkBrand, scope string, errOut io.Writer) (*DeviceAuthResponse, error) {
+func RequestDeviceAuthorization(ctx context.Context, httpClient *http.Client, ca ClientAuth, brand core.LarkBrand, scope string, errOut io.Writer) (*DeviceAuthResponse, error) {
 	if errOut == nil {
 		errOut = io.Discard
 	}
@@ -77,18 +77,26 @@ func RequestDeviceAuthorization(httpClient *http.Client, appId, appSecret string
 		}
 	}
 
-	basicAuth := base64.StdEncoding.EncodeToString([]byte(appId + ":" + appSecret))
-
 	form := url.Values{}
-	form.Set("client_id", appId)
+	form.Set("client_id", ca.AppID)
 	form.Set("scope", scope)
 
-	req, err := http.NewRequest("POST", endpoints.DeviceAuthorization, strings.NewReader(form.Encode()))
+	// private_key_jwt authenticates the client with a signed assertion in the
+	// body; client_secret uses HTTP Basic.
+	usedAssertion, err := ca.applyClientAssertion(ctx, form, core.OpenAPIAudience(brand))
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", endpoints.DeviceAuthorization, strings.NewReader(form.Encode()))
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("Authorization", "Basic "+basicAuth)
+	if !usedAssertion {
+		basicAuth := base64.StdEncoding.EncodeToString([]byte(ca.AppID + ":" + ca.AppSecret))
+		req.Header.Set("Authorization", "Basic "+basicAuth)
+	}
 
 	resp, err := httpClient.Do(req)
 	if err != nil {
@@ -139,7 +147,7 @@ func RequestDeviceAuthorization(httpClient *http.Client, appId, appSecret string
 }
 
 // PollDeviceToken polls the token endpoint until authorization completes or times out.
-func PollDeviceToken(ctx context.Context, httpClient *http.Client, appId, appSecret string, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) *DeviceFlowResult {
+func PollDeviceToken(ctx context.Context, httpClient *http.Client, ca ClientAuth, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) *DeviceFlowResult {
 	if errOut == nil {
 		errOut = io.Discard
 	}
@@ -171,10 +179,16 @@ func PollDeviceToken(ctx context.Context, httpClient *http.Client, appId, appSec
 		form := url.Values{}
 		form.Set("grant_type", "urn:ietf:params:oauth:grant-type:device_code")
 		form.Set("device_code", deviceCode)
-		form.Set("client_id", appId)
-		form.Set("client_secret", appSecret)
+		form.Set("client_id", ca.AppID)
+		usedAssertion, caErr := ca.applyClientAssertion(ctx, form, core.OpenAPIAudience(brand))
+		if caErr != nil {
+			return &DeviceFlowResult{OK: false, Error: "invalid_client", Message: caErr.Error()}
+		}
+		if !usedAssertion {
+			form.Set("client_secret", ca.AppSecret)
+		}
 
-		req, err := http.NewRequest("POST", endpoints.Token, strings.NewReader(form.Encode()))
+		req, err := http.NewRequestWithContext(ctx, "POST", endpoints.Token, strings.NewReader(form.Encode()))
 		if err != nil {
 			continue
 		}

internal/auth/device_flow_test.go

@@ -7,8 +7,10 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"io"
 	"log"
 	"net/http"
+	"net/url"
 	"strings"
 	"sync/atomic"
 	"testing"
@@ -83,7 +85,7 @@ func TestRequestDeviceAuthorization_LogsResponse(t *testing.T) {
 	})
 	t.Cleanup(restore)
 
-	_, err := RequestDeviceAuthorization(httpmock.NewClient(reg), "cli_a", "secret_b", core.BrandFeishu, "", nil)
+	_, err := RequestDeviceAuthorization(context.Background(), httpmock.NewClient(reg), ClientAuth{AppID: "cli_a", AppSecret: "test-secret"}, core.BrandFeishu, "", nil)
 	if err != nil {
 		t.Fatalf("RequestDeviceAuthorization() error: %v", err)
 	}
@@ -106,6 +108,66 @@ func TestRequestDeviceAuthorization_LogsResponse(t *testing.T) {
 	}
 }
 
+// captureRT records the last request + body and returns a canned device-auth response.
+func captureDeviceAuthClient(gotReq **http.Request, gotBody *string, respJSON string) *http.Client {
+	return &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+		*gotReq = req
+		if req.Body != nil {
+			b, _ := io.ReadAll(req.Body)
+			*gotBody = string(b)
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Header:     make(http.Header),
+			Body:       io.NopCloser(strings.NewReader(respJSON)),
+		}, nil
+	})}
+}
+
+const deviceAuthRespJSON = `{"device_code":"dc","user_code":"uc","verification_uri":"https://example/verify","expires_in":300,"interval":5}`
+
+func TestRequestDeviceAuthorization_PrivateKeyJWT_UsesAssertionNotBasic(t *testing.T) {
+	var req *http.Request
+	var body string
+	client := captureDeviceAuthClient(&req, &body, deviceAuthRespJSON)
+
+	ca := ClientAuth{AppID: "cli_a", AuthMethod: core.AuthMethodPrivateKeyJWT, Signer: newFakeAuthSigner(t), KeyLabel: "k"}
+	if _, err := RequestDeviceAuthorization(context.Background(), client, ca, core.BrandFeishu, "im:message:send", nil); err != nil {
+		t.Fatal(err)
+	}
+	if req.Header.Get("Authorization") != "" {
+		t.Errorf("private_key_jwt must NOT send Basic auth, got %q", req.Header.Get("Authorization"))
+	}
+	form, _ := url.ParseQuery(body)
+	if form.Get("client_assertion") == "" {
+		t.Error("missing client_assertion")
+	}
+	if form.Get("client_assertion_type") != "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" {
+		t.Errorf("client_assertion_type = %q", form.Get("client_assertion_type"))
+	}
+	if form.Has("client_secret") {
+		t.Error("client_secret must not be present for private_key_jwt")
+	}
+}
+
+func TestRequestDeviceAuthorization_ClientSecret_UsesBasic(t *testing.T) {
+	var req *http.Request
+	var body string
+	client := captureDeviceAuthClient(&req, &body, deviceAuthRespJSON)
+
+	ca := ClientAuth{AppID: "cli_a", AppSecret: "test-secret"} // client_secret
+	if _, err := RequestDeviceAuthorization(context.Background(), client, ca, core.BrandFeishu, "", nil); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasPrefix(req.Header.Get("Authorization"), "Basic ") {
+		t.Errorf("client_secret should use Basic auth, got %q", req.Header.Get("Authorization"))
+	}
+	form, _ := url.ParseQuery(body)
+	if form.Has("client_assertion") {
+		t.Error("client_secret must not send a client_assertion")
+	}
+}
+
 // TestFormatAuthCmdline_TruncatesExtraArgs verifies that long command lines are truncated.
 func TestFormatAuthCmdline_TruncatesExtraArgs(t *testing.T) {
 	got := keychain.FormatAuthCmdline([]string{
@@ -205,7 +267,7 @@ func TestPollDeviceToken_DefaultsZeroIntervalToFiveSeconds(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 	t.Cleanup(cancel)
 
-	result := PollDeviceToken(ctx, client, "cli_a", "secret_b", core.BrandFeishu, "device-code", 0, 10, nil)
+	result := PollDeviceToken(ctx, client, ClientAuth{AppID: "cli_a", AppSecret: "test-secret"}, core.BrandFeishu, "device-code", 0, 10, nil)
 	if result == nil {
 		t.Fatal("PollDeviceToken() returned nil result")
 	}

internal/auth/jwt/jwt.go

@@ -0,0 +1,152 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package jwt builds compact JWS tokens signed by a keysigner.Signer.
+//
+// It deliberately depends only on the standard library plus the existing
+// google/uuid dependency — no third-party JWT library is introduced, keeping
+// go.mod free of new dependencies. The actual signing (and, for ECDSA, the
+// ASN.1->r||s conversion) is delegated to the Signer implementation.
+package jwt
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+func b64(b []byte) string { return base64.RawURLEncoding.EncodeToString(b) }
+
+// buildSignedJWT builds a compact JWS:
+//
+//	base64url(header).base64url(claims).base64url(signature)
+//
+// alg is written into the header (it is part of the signed input) and verified
+// against the alg the signer reports, guarding against a header/key mismatch.
+// typ defaults to "JWT" because the client-assertion endpoint requires that
+// protected-header value, even though some protocol examples show only alg.
+func buildSignedJWT(ctx context.Context, signer keysigner.Signer, ref keysigner.KeyRef, alg string, header, claims map[string]any) (string, error) {
+	if signer == nil {
+		return "", fmt.Errorf("jwt: no signer available (private_key_jwt unsupported on this build)")
+	}
+	if header == nil {
+		header = map[string]any{}
+	}
+	header["alg"] = alg
+	if _, ok := header["typ"]; !ok {
+		header["typ"] = "JWT"
+	}
+
+	hb, err := json.Marshal(header)
+	if err != nil {
+		return "", fmt.Errorf("jwt: marshal header: %w", err)
+	}
+	cb, err := json.Marshal(claims)
+	if err != nil {
+		return "", fmt.Errorf("jwt: marshal claims: %w", err)
+	}
+
+	signingInput := b64(hb) + "." + b64(cb)
+	sig, gotAlg, err := signer.Sign(ctx, ref, []byte(signingInput))
+	if err != nil {
+		return "", fmt.Errorf("jwt: sign: %w", err)
+	}
+	if gotAlg != alg {
+		return "", fmt.Errorf("jwt: signer alg %q does not match header alg %q", gotAlg, alg)
+	}
+	return signingInput + "." + b64(sig), nil
+}
+
+// newJTI returns a random unique token identifier.
+func newJTI() string { return uuid.NewString() }
+
+// attestationTTL bounds the attestation JWT's lifetime. The init nonce (60s,
+// single-use) is the real anti-replay constraint; this is a modest margin for
+// clock skew on top of the immediate init→sign→begin round-trip.
+const attestationTTL = 2 * time.Minute
+
+// attestationClaims builds the registration attestation claim set per the App
+// Registration JWT spec: jti, iat, exp (all required) and the init-issued nonce.
+func attestationClaims(nonce string, now time.Time) map[string]any {
+	return map[string]any{
+		"jti":   newJTI(),
+		"iat":   now.Unix(),
+		"exp":   now.Add(attestationTTL).Unix(),
+		"nonce": nonce,
+	}
+}
+
+// clientAssertionClaims builds an RFC 7523 client_assertion claim set used to
+// mint tokens in place of client_secret. aud is the brand's token endpoint URL.
+func clientAssertionClaims(clientID, aud string, now time.Time, ttl time.Duration) map[string]any {
+	return map[string]any{
+		"iss": clientID,
+		"sub": clientID,
+		"aud": aud,
+		"iat": now.Unix(),
+		"exp": now.Add(ttl).Unix(),
+		"jti": newJTI(),
+	}
+}
+
+// ClientAssertionType is the RFC 7523 client_assertion_type value used for JWT
+// bearer client authentication at the token endpoint.
+const ClientAssertionType = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
+
+// defaultAssertionTTL bounds a client_assertion's lifetime.
+const defaultAssertionTTL = 5 * time.Minute
+
+// SignAttestation signs the registration attestation JWT. The public key is
+// embedded in the JWS "jwk" header so the registration backend can bind it to
+// the app during action=begin; the claims carry the server nonce as a
+// proof-of-possession challenge.
+func SignAttestation(ctx context.Context, signer keysigner.Signer, ref keysigner.KeyRef, nonce string, now time.Time) (string, error) {
+	if signer == nil {
+		return "", fmt.Errorf("jwt: no signer available (private_key_jwt unsupported on this build)")
+	}
+	pub, err := signer.EnsureKey(ctx, ref)
+	if err != nil {
+		return "", fmt.Errorf("jwt: ensure key: %w", err)
+	}
+	alg, err := keysigner.AlgForKey(pub)
+	if err != nil {
+		return "", err
+	}
+	jwk, err := keysigner.PublicKeyJWK(pub)
+	if err != nil {
+		return "", err
+	}
+	return buildSignedJWT(ctx, signer, ref, alg, map[string]any{"jwk": jwk}, attestationClaims(nonce, now))
+}
+
+// SignClientAssertion mints a short-lived RFC 7523 client_assertion: it reads the
+// registered key (it must already exist — bound at registration; a missing key is
+// an error, not a reason to create a new unbound one), derives the JWS alg from
+// the public key, and signs an assertion whose audience is the brand's Open API
+// host. The server, holding the public key bound at registration, verifies it in
+// place of client_secret. The assertion header carries only alg (no jwk/kid);
+// the server locates the key via iss/sub = client_id.
+//
+// This is the model-independent glue: the assertion JWT is identical whether the
+// server augments an existing grant (device_code/refresh_token) with client
+// authentication or uses a dedicated jwt-bearer grant — only where the caller
+// attaches it differs.
+func SignClientAssertion(ctx context.Context, signer keysigner.Signer, ref keysigner.KeyRef, clientID, audience string, now time.Time) (string, error) {
+	if signer == nil {
+		return "", fmt.Errorf("jwt: no signer available (private_key_jwt unsupported on this build)")
+	}
+	pub, err := signer.PublicKey(ctx, ref)
+	if err != nil {
+		return "", fmt.Errorf("jwt: public key: %w", err)
+	}
+	alg, err := keysigner.AlgForKey(pub)
+	if err != nil {
+		return "", err
+	}
+	return buildSignedJWT(ctx, signer, ref, alg, map[string]any{}, clientAssertionClaims(clientID, audience, now, defaultAssertionTTL))
+}

internal/auth/jwt/jwt_test.go

@@ -0,0 +1,254 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package jwt
+
+import (
+	"context"
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"math/big"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/larksuite/cli/internal/keysigner"
+)
+
+// fakeSigner is a real in-memory ECDSA P-256 signer, so tests exercise the full
+// JWS path and the produced token is actually cryptographically verifiable.
+type fakeSigner struct{ key *ecdsa.PrivateKey }
+
+func newFakeSigner(t *testing.T) *fakeSigner {
+	t.Helper()
+	k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &fakeSigner{key: k}
+}
+
+func (f *fakeSigner) EnsureKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return f.key.Public(), nil
+}
+func (f *fakeSigner) PublicKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return f.key.Public(), nil
+}
+func (f *fakeSigner) Sign(_ context.Context, _ keysigner.KeyRef, in []byte) ([]byte, string, error) {
+	h := sha256.Sum256(in)
+	r, s, err := ecdsa.Sign(rand.Reader, f.key, h[:])
+	if err != nil {
+		return nil, "", err
+	}
+	// JOSE ES256: fixed-width big-endian r||s (32 bytes each for P-256).
+	sig := make([]byte, 64)
+	r.FillBytes(sig[:32])
+	s.FillBytes(sig[32:])
+	return sig, keysigner.AlgES256, nil
+}
+
+func TestBuildSignedJWT_VerifiableES256(t *testing.T) {
+	f := newFakeSigner(t)
+	now := time.Unix(1700000000, 0)
+
+	tok, err := buildSignedJWT(context.Background(), f, keysigner.KeyRef{Label: "x"}, keysigner.AlgES256,
+		map[string]any{}, clientAssertionClaims("cli_app", "https://accounts.example/token", now, 5*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	parts := strings.Split(tok, ".")
+	if len(parts) != 3 {
+		t.Fatalf("want 3 JWS parts, got %d", len(parts))
+	}
+
+	hb, err := base64.RawURLEncoding.DecodeString(parts[0])
+	if err != nil {
+		t.Fatalf("header not base64url: %v", err)
+	}
+	var hdr map[string]any
+	if err := json.Unmarshal(hb, &hdr); err != nil {
+		t.Fatal(err)
+	}
+	if hdr["alg"] != "ES256" || hdr["typ"] != "JWT" {
+		t.Errorf("header = %v, want alg=ES256 typ=JWT", hdr)
+	}
+
+	cb, _ := base64.RawURLEncoding.DecodeString(parts[1])
+	var claims map[string]any
+	if err := json.Unmarshal(cb, &claims); err != nil {
+		t.Fatal(err)
+	}
+	if claims["iss"] != "cli_app" || claims["sub"] != "cli_app" || claims["aud"] != "https://accounts.example/token" {
+		t.Errorf("claims = %v", claims)
+	}
+
+	// Cryptographically verify the signature against the signing input.
+	sig, err := base64.RawURLEncoding.DecodeString(parts[2])
+	if err != nil {
+		t.Fatalf("sig not base64url: %v", err)
+	}
+	if len(sig) != 64 {
+		t.Fatalf("ES256 sig len = %d, want 64", len(sig))
+	}
+	r := new(big.Int).SetBytes(sig[:32])
+	s := new(big.Int).SetBytes(sig[32:])
+	h := sha256.Sum256([]byte(parts[0] + "." + parts[1]))
+	if !ecdsa.Verify(f.key.Public().(*ecdsa.PublicKey), h[:], r, s) {
+		t.Error("signature did not verify")
+	}
+}
+
+func TestBuildSignedJWT_NilSigner(t *testing.T) {
+	if _, err := buildSignedJWT(context.Background(), nil, keysigner.KeyRef{}, "ES256", nil, nil); err == nil {
+		t.Fatal("expected error for nil signer")
+	}
+}
+
+func TestBuildSignedJWT_AlgMismatch(t *testing.T) {
+	f := newFakeSigner(t) // always reports ES256
+	if _, err := buildSignedJWT(context.Background(), f, keysigner.KeyRef{}, keysigner.AlgRS256, nil, nil); err == nil {
+		t.Fatal("expected error when header alg != signer alg")
+	}
+}
+
+func TestBuildSignedJWT_MarshalErrors(t *testing.T) {
+	f := newFakeSigner(t)
+	ctx := context.Background()
+
+	_, err := buildSignedJWT(ctx, f, keysigner.KeyRef{}, keysigner.AlgES256,
+		map[string]any{"bad": func() {}}, nil)
+	if err == nil || !strings.Contains(err.Error(), "jwt: marshal header") {
+		t.Fatalf("header marshal error = %v, want prefix %q", err, "jwt: marshal header")
+	}
+
+	_, err = buildSignedJWT(ctx, f, keysigner.KeyRef{}, keysigner.AlgES256,
+		nil, map[string]any{"bad": make(chan int)})
+	if err == nil || !strings.Contains(err.Error(), "jwt: marshal claims") {
+		t.Fatalf("claims marshal error = %v, want prefix %q", err, "jwt: marshal claims")
+	}
+}
+
+func TestSignClientAssertion(t *testing.T) {
+	f := newFakeSigner(t)
+	now := time.Unix(1700000000, 0)
+	const aud = "https://accounts.feishu.cn/open-apis/authen/v2/oauth/token"
+
+	tok, err := SignClientAssertion(context.Background(), f, keysigner.KeyRef{Label: "k"}, "cli_app", aud, now)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	parts := strings.Split(tok, ".")
+	if len(parts) != 3 {
+		t.Fatalf("want 3 parts, got %d", len(parts))
+	}
+	cb, _ := base64.RawURLEncoding.DecodeString(parts[1])
+	var claims map[string]any
+	if err := json.Unmarshal(cb, &claims); err != nil {
+		t.Fatal(err)
+	}
+	if claims["iss"] != "cli_app" || claims["aud"] != aud {
+		t.Errorf("claims = %v", claims)
+	}
+
+	// Signature must verify against the key's public half.
+	sig, _ := base64.RawURLEncoding.DecodeString(parts[2])
+	r := new(big.Int).SetBytes(sig[:32])
+	s := new(big.Int).SetBytes(sig[32:])
+	h := sha256.Sum256([]byte(parts[0] + "." + parts[1]))
+	if !ecdsa.Verify(f.key.Public().(*ecdsa.PublicKey), h[:], r, s) {
+		t.Error("client_assertion signature did not verify")
+	}
+}
+
+func TestSignClientAssertion_NilSigner(t *testing.T) {
+	if _, err := SignClientAssertion(context.Background(), nil, keysigner.KeyRef{}, "cli_app", "aud", time.Unix(0, 0)); err == nil {
+		t.Fatal("expected error for nil signer")
+	}
+}
+
+func TestSignAttestation(t *testing.T) {
+	f := newFakeSigner(t)
+	now := time.Unix(1700000000, 0)
+
+	tok, err := SignAttestation(context.Background(), f, keysigner.KeyRef{Label: "k"}, "nonce-abc", now)
+	if err != nil {
+		t.Fatal(err)
+	}
+	parts := strings.Split(tok, ".")
+	if len(parts) != 3 {
+		t.Fatalf("want 3 parts, got %d", len(parts))
+	}
+
+	hb, _ := base64.RawURLEncoding.DecodeString(parts[0])
+	var hdr map[string]any
+	if err := json.Unmarshal(hb, &hdr); err != nil {
+		t.Fatal(err)
+	}
+	jwk, ok := hdr["jwk"].(map[string]any)
+	if !ok {
+		t.Fatalf("attestation header missing jwk: %v", hdr)
+	}
+	if jwk["kty"] != "EC" || jwk["crv"] != "P-256" || jwk["use"] != "sig" {
+		t.Errorf("jwk = %v", jwk)
+	}
+
+	cb, _ := base64.RawURLEncoding.DecodeString(parts[1])
+	var claims map[string]any
+	if err := json.Unmarshal(cb, &claims); err != nil {
+		t.Fatal(err)
+	}
+	if claims["nonce"] != "nonce-abc" {
+		t.Errorf("nonce = %v", claims["nonce"])
+	}
+	// jti, iat, exp are all required by the attestation spec.
+	iat, iatOK := claims["iat"].(float64)
+	exp, expOK := claims["exp"].(float64)
+	if !iatOK || !expOK || exp <= iat {
+		t.Errorf("claims iat/exp invalid: iat=%v exp=%v", claims["iat"], claims["exp"])
+	}
+	if jti, _ := claims["jti"].(string); jti == "" {
+		t.Error("claims jti empty")
+	}
+
+	// Signature verifies against the embedded key.
+	sig, _ := base64.RawURLEncoding.DecodeString(parts[2])
+	r := new(big.Int).SetBytes(sig[:32])
+	s := new(big.Int).SetBytes(sig[32:])
+	h := sha256.Sum256([]byte(parts[0] + "." + parts[1]))
+	if !ecdsa.Verify(f.key.Public().(*ecdsa.PublicKey), h[:], r, s) {
+		t.Error("attestation signature did not verify")
+	}
+}
+
+func TestSignAttestation_NilSigner(t *testing.T) {
+	if _, err := SignAttestation(context.Background(), nil, keysigner.KeyRef{}, "n", time.Unix(0, 0)); err == nil {
+		t.Fatal("expected error for nil signer")
+	}
+}
+
+func TestClaimFactories(t *testing.T) {
+	now := time.Unix(1700000000, 0)
+
+	a := attestationClaims("nonce-xyz", now)
+	if a["nonce"] != "nonce-xyz" || a["iat"] != now.Unix() {
+		t.Errorf("attestation claims = %v", a)
+	}
+	if a["exp"] != now.Add(attestationTTL).Unix() {
+		t.Errorf("attestation exp = %v, want %v", a["exp"], now.Add(attestationTTL).Unix())
+	}
+	if jti, _ := a["jti"].(string); jti == "" {
+		t.Error("attestation jti empty")
+	}
+
+	c := clientAssertionClaims("cli_app", "aud", now, time.Minute)
+	if c["exp"].(int64) != now.Add(time.Minute).Unix() {
+		t.Errorf("client_assertion exp = %v", c["exp"])
+	}
+}

internal/auth/uat_client.go

@@ -21,6 +21,7 @@ import (
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/errclass"
+	"github.com/larksuite/cli/internal/keysigner"
 	"github.com/larksuite/cli/internal/vfs"
 )
 
@@ -33,11 +34,15 @@ func sanitizeID(id string) string {
 
 // UATCallOptions contains options for UAT API calls.
 type UATCallOptions struct {
-	UserOpenId string
-	AppId      string
-	AppSecret  string
-	Domain     core.LarkBrand
-	ErrOut     io.Writer // diagnostic/status output (caller injects f.IOStreams.ErrOut)
+	UserOpenId  string
+	AppId       string
+	AppSecret   string
+	Domain      core.LarkBrand
+	AuthMethod  string           // "" == client_secret; core.AuthMethodPrivateKeyJWT
+	KeyLabel    string           // TEE key handle for private_key_jwt
+	KeyProvider string           // empty == built-in signer; explicit external route otherwise
+	Signer      keysigner.Signer // active signer for private_key_jwt
+	ErrOut      io.Writer        // diagnostic/status output (caller injects f.IOStreams.ErrOut)
 }
 
 // UATStatus represents the status of a user access token.
@@ -57,11 +62,15 @@ func NewUATCallOptions(cfg *core.CliConfig, errOut io.Writer) UATCallOptions {
 		errOut = os.Stderr
 	}
 	return UATCallOptions{
-		UserOpenId: cfg.UserOpenId,
-		AppId:      cfg.AppID,
-		AppSecret:  cfg.AppSecret,
-		Domain:     cfg.Brand,
-		ErrOut:     errOut,
+		UserOpenId:  cfg.UserOpenId,
+		AppId:       cfg.AppID,
+		AppSecret:   cfg.AppSecret,
+		Domain:      cfg.Brand,
+		AuthMethod:  cfg.AuthMethod,
+		KeyLabel:    cfg.KeyLabel,
+		KeyProvider: cfg.KeyProvider,
+		Signer:      keysigner.Active(),
+		ErrOut:      errOut,
 	}
 }
 
@@ -187,13 +196,31 @@ func doRefreshToken(httpClient *http.Client, opts UATCallOptions, stored *Stored
 	}
 
 	endpoints := ResolveOAuthEndpoints(opts.Domain)
+	clientAuth := ClientAuth{
+		AppID:       opts.AppId,
+		AppSecret:   opts.AppSecret,
+		AuthMethod:  opts.AuthMethod,
+		Signer:      opts.Signer,
+		KeyLabel:    opts.KeyLabel,
+		KeyProvider: opts.KeyProvider,
+	}
+	clientAuth, err := clientAuth.ResolveSigner(context.Background())
+	if err != nil {
+		return nil, err
+	}
 
 	callEndpoint := func() (map[string]interface{}, error) {
 		form := url.Values{}
 		form.Set("grant_type", "refresh_token")
 		form.Set("refresh_token", stored.RefreshToken)
 		form.Set("client_id", opts.AppId)
-		form.Set("client_secret", opts.AppSecret)
+		usedAssertion, caErr := clientAuth.applyClientAssertion(context.Background(), form, core.OpenAPIAudience(opts.Domain))
+		if caErr != nil {
+			return nil, caErr
+		}
+		if !usedAssertion {
+			form.Set("client_secret", opts.AppSecret)
+		}
 
 		req, err := http.NewRequest("POST", endpoints.Token, strings.NewReader(form.Encode()))
 		if err != nil {

internal/auth/uat_client_options_test.go

@@ -38,3 +38,27 @@ func TestNewUATCallOptions(t *testing.T) {
 		t.Error("ErrOut not set correctly")
 	}
 }
+
+// TestNewUATCallOptions_PrivateKeyJWT verifies the auth-method fields propagate
+// so the refresh path can mint a client_assertion instead of sending a secret.
+func TestNewUATCallOptions_PrivateKeyJWT(t *testing.T) {
+	cfg := &core.CliConfig{
+		AppID:       "cli_pk",
+		Brand:       core.BrandFeishu,
+		UserOpenId:  "ou_test",
+		AuthMethod:  core.AuthMethodPrivateKeyJWT,
+		KeyLabel:    "agent-key",
+		KeyProvider: core.KeylessProviderLarkSuite,
+	}
+	opts := NewUATCallOptions(cfg, &bytes.Buffer{})
+
+	if opts.AuthMethod != core.AuthMethodPrivateKeyJWT {
+		t.Errorf("AuthMethod = %q, want private_key_jwt", opts.AuthMethod)
+	}
+	if opts.KeyLabel != "agent-key" {
+		t.Errorf("KeyLabel = %q, want agent-key", opts.KeyLabel)
+	}
+	if opts.KeyProvider != core.KeylessProviderLarkSuite {
+		t.Errorf("KeyProvider = %q, want %q", opts.KeyProvider, core.KeylessProviderLarkSuite)
+	}
+}

internal/auth/uat_client_test.go

@@ -0,0 +1,122 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package auth
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/larksuite/cli/internal/auth/jwt"
+	"github.com/larksuite/cli/internal/core"
+)
+
+type uatRoundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn uatRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
+
+type retryExternalAssertionSigner struct {
+	calls int
+}
+
+func (s *retryExternalAssertionSigner) SignClientAssertion(_ context.Context, _, _, _ string) (string, string, error) {
+	s.calls++
+	return jwt.ClientAssertionType, fmt.Sprintf("refresh.jwt.%d", s.calls), nil
+}
+
+func TestDoRefreshToken_PrivateKeyJWTRetryResolvesOnceAndRemintsAssertion(t *testing.T) {
+	signer := &retryExternalAssertionSigner{}
+	resolveCalls := 0
+	previous := resolveExternalAssertionSigner
+	resolveExternalAssertionSigner = func(_ context.Context, provider string) (clientAssertionSigner, error) {
+		resolveCalls++
+		if provider != core.KeylessProviderLarkSuite {
+			t.Fatalf("provider = %q", provider)
+		}
+		return signer, nil
+	}
+	t.Cleanup(func() { resolveExternalAssertionSigner = previous })
+
+	var forms []url.Values
+	httpClient := &http.Client{Transport: uatRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		body, err := io.ReadAll(req.Body)
+		if err != nil {
+			return nil, err
+		}
+		form, err := url.ParseQuery(string(body))
+		if err != nil {
+			return nil, err
+		}
+		forms = append(forms, form)
+
+		responseBody := `{"code":20050,"error":"server_error","error_description":"retry"}`
+		if len(forms) == 2 {
+			// A success-shaped response without a token lets the test exercise the
+			// retry without writing platform keychain state.
+			responseBody = `{"code":0}`
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Header:     make(http.Header),
+			Body:       io.NopCloser(strings.NewReader(responseBody)),
+			Request:    req,
+		}, nil
+	})}
+
+	now := time.Now().UnixMilli()
+	stored := &StoredUAToken{
+		UserOpenId:       "ou_test",
+		AppId:            "cli_external",
+		RefreshToken:     "refresh-token",
+		RefreshExpiresAt: now + int64(time.Hour/time.Millisecond),
+		Scope:            "offline_access",
+		GrantedAt:        now,
+	}
+	opts := UATCallOptions{
+		UserOpenId:  stored.UserOpenId,
+		AppId:       stored.AppId,
+		Domain:      core.BrandFeishu,
+		AuthMethod:  core.AuthMethodPrivateKeyJWT,
+		KeyLabel:    "openclaw-lark",
+		KeyProvider: core.KeylessProviderLarkSuite,
+		ErrOut:      io.Discard,
+	}
+
+	updated, err := doRefreshToken(httpClient, opts, stored)
+	if err == nil || !strings.Contains(err.Error(), "no access_token") {
+		t.Fatalf("doRefreshToken error = %v, want missing access_token after retry", err)
+	}
+	if updated != nil {
+		t.Fatalf("updated token = %#v, want nil", updated)
+	}
+	if resolveCalls != 1 {
+		t.Fatalf("provider resolution calls = %d, want 1", resolveCalls)
+	}
+	if signer.calls != 2 {
+		t.Fatalf("assertion signing calls = %d, want 2", signer.calls)
+	}
+	if len(forms) != 2 {
+		t.Fatalf("token endpoint requests = %d, want 2", len(forms))
+	}
+	first := forms[0].Get("client_assertion")
+	second := forms[1].Get("client_assertion")
+	if first == "" || second == "" || first == second {
+		t.Fatalf("assertions = (%q, %q), want two fresh values", first, second)
+	}
+	for _, form := range forms {
+		if form.Get("grant_type") != "refresh_token" {
+			t.Fatalf("grant_type = %q, want refresh_token", form.Get("grant_type"))
+		}
+		if form.Has("client_secret") {
+			t.Fatalf("private_key_jwt form leaked client_secret: %v", form)
+		}
+	}
+}

internal/binding/keyless_types_test.go

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package binding
+
+import "testing"
+
+func TestListCandidateApps_KeylessSingleAccount(t *testing.T) {
+	apps := ListCandidateApps(&FeishuChannel{
+		AppID:      "cli_keyless",
+		Brand:      "feishu",
+		AuthMethod: AuthMethodPrivateKeyJWT,
+		KeyRef:     "openclaw-lark",
+	})
+	if len(apps) != 1 {
+		t.Fatalf("count = %d, want 1", len(apps))
+	}
+	if !apps[0].IsKeyless() {
+		t.Fatalf("candidate = %#v, want keyless", apps[0])
+	}
+	if apps[0].KeyRef != "openclaw-lark" {
+		t.Fatalf("KeyRef = %q, want openclaw-lark", apps[0].KeyRef)
+	}
+}
+
+func TestListCandidateApps_KeylessMultiAccountInheritance(t *testing.T) {
+	apps := ListCandidateApps(&FeishuChannel{
+		AppID:      "cli_top",
+		Brand:      "lark",
+		AuthMethod: AuthMethodPrivateKeyJWT,
+		KeyRef:     "openclaw-lark",
+		Accounts: map[string]*FeishuAccount{
+			"work": {},
+		},
+	})
+	if len(apps) != 2 {
+		t.Fatalf("count = %d, want 2 (implicit default + work)", len(apps))
+	}
+	app := candidateByLabel(t, apps, "work")
+	if app.Label != "work" || app.AppID != "cli_top" || app.Brand != "lark" {
+		t.Fatalf("candidate identity = %#v", app)
+	}
+	if app.AuthMethod != AuthMethodPrivateKeyJWT || app.KeyRef != "openclaw-lark" || !app.IsKeyless() {
+		t.Fatalf("candidate keyless fields = %#v", app)
+	}
+}
+
+func TestListCandidateApps_KeylessAccountOverride(t *testing.T) {
+	apps := ListCandidateApps(&FeishuChannel{
+		AppID:      "cli_top",
+		AuthMethod: AuthMethodPrivateKeyJWT,
+		KeyRef:     "top-key",
+		Accounts: map[string]*FeishuAccount{
+			"work": {AppID: "cli_work", KeyRef: "work-key"},
+		},
+	})
+	if len(apps) != 2 {
+		t.Fatalf("count = %d, want 2 (implicit default + work)", len(apps))
+	}
+	if got := candidateByLabel(t, apps, "work"); got.AppID != "cli_work" || got.KeyRef != "work-key" || !got.IsKeyless() {
+		t.Fatalf("candidate = %#v", got)
+	}
+}
+
+func candidateByLabel(t *testing.T, apps []CandidateApp, label string) CandidateApp {
+	t.Helper()
+	for _, app := range apps {
+		if app.Label == label {
+			return app
+		}
+	}
+	t.Fatalf("candidate %q not found in %#v", label, apps)
+	return CandidateApp{}
+}
+
+func TestCandidateApp_SecretTakesPrecedenceOverKeyless(t *testing.T) {
+	app := CandidateApp{
+		AppID:      "cli_both",
+		AppSecret:  SecretInput{Plain: "secret"},
+		AuthMethod: AuthMethodPrivateKeyJWT,
+		KeyRef:     "openclaw-lark",
+	}
+	if app.IsKeyless() {
+		t.Fatal("an appSecret-backed OpenClaw account must not be treated as keyless")
+	}
+}
+
+func TestCandidateApp_KeylessRequiresKeyRef(t *testing.T) {
+	app := CandidateApp{AppID: "cli_missing_key", AuthMethod: AuthMethodPrivateKeyJWT}
+	if app.IsKeyless() {
+		t.Fatal("private_key_jwt without keyRef must not be treated as usable keyless")
+	}
+}
+
+func TestListCandidateApps_KeylessImplicitDefault(t *testing.T) {
+	apps := ListCandidateApps(&FeishuChannel{
+		AppID:      "cli_default",
+		AuthMethod: AuthMethodPrivateKeyJWT,
+		KeyRef:     "openclaw-lark",
+		Accounts: map[string]*FeishuAccount{
+			"work": {AppID: "cli_work", AuthMethod: AuthMethodPrivateKeyJWT, KeyRef: "work-key"},
+		},
+	})
+	if len(apps) != 2 {
+		t.Fatalf("count = %d, want 2", len(apps))
+	}
+	for _, app := range apps {
+		if !app.IsKeyless() {
+			t.Fatalf("candidate = %#v, want keyless", app)
+		}
+	}
+}

internal/binding/types.go

@@ -31,20 +31,24 @@ type ChannelsRoot struct {
 // `Brand` stays aligned with our internal terminology, but the JSON
 // tag matches OpenClaw's on-disk format.
 type FeishuChannel struct {
-	Enabled   *bool                     `json:"enabled,omitempty"` // nil = default enabled
-	AppID     string                    `json:"appId,omitempty"`
-	AppSecret SecretInput               `json:"appSecret,omitempty"`
-	Brand     string                    `json:"domain,omitempty"`
-	Accounts  map[string]*FeishuAccount `json:"accounts,omitempty"`
+	Enabled    *bool                     `json:"enabled,omitempty"` // nil = default enabled
+	AppID      string                    `json:"appId,omitempty"`
+	AppSecret  SecretInput               `json:"appSecret,omitempty"`
+	Brand      string                    `json:"domain,omitempty"`
+	Accounts   map[string]*FeishuAccount `json:"accounts,omitempty"`
+	AuthMethod string                    `json:"authMethod,omitempty"`
+	KeyRef     string                    `json:"keyRef,omitempty"`
 }
 
 // FeishuAccount is a single account entry within Accounts.
 // Like FeishuChannel, `Brand` maps to OpenClaw's `domain` key.
 type FeishuAccount struct {
-	Enabled   *bool       `json:"enabled,omitempty"` // nil = default enabled
-	AppID     string      `json:"appId,omitempty"`
-	AppSecret SecretInput `json:"appSecret,omitempty"`
-	Brand     string      `json:"domain,omitempty"`
+	Enabled    *bool       `json:"enabled,omitempty"` // nil = default enabled
+	AppID      string      `json:"appId,omitempty"`
+	AppSecret  SecretInput `json:"appSecret,omitempty"`
+	Brand      string      `json:"domain,omitempty"`
+	AuthMethod string      `json:"authMethod,omitempty"`
+	KeyRef     string      `json:"keyRef,omitempty"`
 }
 
 // isEnabled returns true if the enabled field is nil (default) or explicitly true.
@@ -228,10 +232,25 @@ func LookupProvider(ref *SecretRef, cfg *SecretsConfig) (*ProviderConfig, error)
 
 // CandidateApp represents a bindable app from OpenClaw's feishu channel config.
 type CandidateApp struct {
-	Label     string
-	AppID     string
-	AppSecret SecretInput
-	Brand     string
+	Label      string
+	AppID      string
+	AppSecret  SecretInput
+	Brand      string
+	AuthMethod string
+	KeyRef     string
+}
+
+const AuthMethodPrivateKeyJWT = "private_key_jwt"
+
+// IsKeyless mirrors openclaw-lark's resolved-account precedence: an app
+// secret wins when both credential shapes are present. Only a secretless
+// private_key_jwt account with a keyRef is eligible for helper reuse.
+func (c CandidateApp) IsKeyless() bool {
+	return c.AppSecret.IsZero() && c.AuthMethod == AuthMethodPrivateKeyJWT && strings.TrimSpace(c.KeyRef) != ""
+}
+
+func bindableCredential(secret SecretInput, authMethod, keyRef string) bool {
+	return !secret.IsZero() || (authMethod == AuthMethodPrivateKeyJWT && strings.TrimSpace(keyRef) != "")
 }
 
 // ListCandidateApps enumerates all bindable (enabled) apps from a FeishuChannel.
@@ -243,7 +262,7 @@ func ListCandidateApps(ch *FeishuChannel) []CandidateApp {
 	if len(ch.Accounts) > 0 {
 		apps := make([]CandidateApp, 0, len(ch.Accounts)+1)
 
-		// When accounts exist AND top-level has its own appId+appSecret,
+		// When accounts exist AND top-level has its own bindable credential,
 		// include the top-level as a "default" candidate — aligned with
 		// openclaw-lark getLarkAccountIds() which adds DEFAULT_ACCOUNT_ID
 		// when top-level credentials are present and no explicit "default" exists.
@@ -254,12 +273,15 @@ func ListCandidateApps(ch *FeishuChannel) []CandidateApp {
 				break
 			}
 		}
-		if !hasDefault && ch.AppID != "" && !ch.AppSecret.IsZero() && isEnabled(ch.Enabled) {
+		if !hasDefault && ch.AppID != "" && isEnabled(ch.Enabled) &&
+			bindableCredential(ch.AppSecret, ch.AuthMethod, ch.KeyRef) {
 			apps = append(apps, CandidateApp{
-				Label:     "default",
-				AppID:     ch.AppID,
-				AppSecret: ch.AppSecret,
-				Brand:     ch.Brand,
+				Label:      "default",
+				AppID:      ch.AppID,
+				AppSecret:  ch.AppSecret,
+				Brand:      ch.Brand,
+				AuthMethod: ch.AuthMethod,
+				KeyRef:     ch.KeyRef,
 			})
 		}
 
@@ -282,11 +304,21 @@ func ListCandidateApps(ch *FeishuChannel) []CandidateApp {
 			if brand == "" {
 				brand = ch.Brand
 			}
+			authMethod := acct.AuthMethod
+			if authMethod == "" {
+				authMethod = ch.AuthMethod
+			}
+			keyRef := acct.KeyRef
+			if keyRef == "" {
+				keyRef = ch.KeyRef
+			}
 			apps = append(apps, CandidateApp{
-				Label:     label,
-				AppID:     appID,
-				AppSecret: appSecret,
-				Brand:     brand,
+				Label:      label,
+				AppID:      appID,
+				AppSecret:  appSecret,
+				Brand:      brand,
+				AuthMethod: authMethod,
+				KeyRef:     keyRef,
 			})
 		}
 		return apps
@@ -295,10 +327,12 @@ func ListCandidateApps(ch *FeishuChannel) []CandidateApp {
 	// Single account at top level — check if channel itself is enabled
 	if ch.AppID != "" && isEnabled(ch.Enabled) {
 		return []CandidateApp{{
-			Label:     "",
-			AppID:     ch.AppID,
-			AppSecret: ch.AppSecret,
-			Brand:     ch.Brand,
+			Label:      "",
+			AppID:      ch.AppID,
+			AppSecret:  ch.AppSecret,
+			Brand:      ch.Brand,
+			AuthMethod: ch.AuthMethod,
+			KeyRef:     ch.KeyRef,
 		}}
 	}
 

internal/client/client_test.go

@@ -48,18 +48,6 @@ func (s *staticTokenResolver) ResolveToken(_ context.Context, _ credential.Token
 	return &credential.TokenResult{Token: "test-token"}, nil
 }
 
-type clientTestAccountResolver struct {
-	appID string
-}
-
-func (r clientTestAccountResolver) ResolveAccount(context.Context) (*credential.Account, error) {
-	return &credential.Account{AppID: r.appID, Brand: core.BrandFeishu}, nil
-}
-
-func newClientTestCredentialProvider(appID string, tokenResolver credential.DefaultTokenResolver) *credential.CredentialProvider {
-	return credential.NewCredentialProvider(nil, clientTestAccountResolver{appID: appID}, tokenResolver, nil)
-}
-
 // newTestAPIClient creates an APIClient with a mock HTTP transport.
 func newTestAPIClient(t *testing.T, rt http.RoundTripper) (*APIClient, *bytes.Buffer) {
 	t.Helper()
@@ -70,7 +58,7 @@ func newTestAPIClient(t *testing.T, rt http.RoundTripper) (*APIClient, *bytes.Bu
 		lark.WithLogLevel(larkcore.LogLevelError),
 		lark.WithHttpClient(httpClient),
 	)
-	testCred := newClientTestCredentialProvider("test-app", &staticTokenResolver{})
+	testCred := credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil)
 	cfg := &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu}
 	return &APIClient{
 		SDK:        sdk,
@@ -475,7 +463,7 @@ func TestDoStream_IgnoresBaseHTTPClientTimeout(t *testing.T) {
 
 	ac := &APIClient{
 		HTTP:       &http.Client{Timeout: 5 * time.Millisecond},
-		Credential: newClientTestCredentialProvider("test-app", &staticTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}
 
@@ -510,7 +498,7 @@ func TestDoStream_TransportFailureSplitsSubtype(t *testing.T) {
 	})
 	ac := &APIClient{
 		HTTP:       &http.Client{Transport: rt},
-		Credential: newClientTestCredentialProvider("test-app", &staticTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &staticTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}
 
@@ -544,7 +532,7 @@ func (f *failingTokenResolver) ResolveToken(_ context.Context, spec credential.T
 func TestResolveAccessToken_NoToken_ReturnsTypedAuthenticationError(t *testing.T) {
 	ac := &APIClient{
 		HTTP:       &http.Client{},
-		Credential: newClientTestCredentialProvider("test-app", &failingTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &failingTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}
 
@@ -584,7 +572,7 @@ func (f *needAuthTokenResolver) ResolveToken(_ context.Context, _ credential.Tok
 func TestResolveAccessToken_NeedAuthorization_SurfacesAsTypedAuthentication(t *testing.T) {
 	ac := &APIClient{
 		HTTP:       &http.Client{},
-		Credential: newClientTestCredentialProvider("test-app", &needAuthTokenResolver{userOpenID: "ou_test_user"}),
+		Credential: credential.NewCredentialProvider(nil, nil, &needAuthTokenResolver{userOpenID: "ou_test_user"}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}
 
@@ -624,7 +612,7 @@ func TestResolveAccessToken_NeedAuthorization_SurfacesAsTypedAuthentication(t *t
 func TestDoSDKRequest_AuthFailureSurfacesTypedAuthenticationError(t *testing.T) {
 	ac := &APIClient{
 		HTTP:       &http.Client{},
-		Credential: newClientTestCredentialProvider("test-app", &failingTokenResolver{}),
+		Credential: credential.NewCredentialProvider(nil, nil, &failingTokenResolver{}, nil),
 		Config:     &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu},
 	}
 

internal/cmdutil/factory.go

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

internal/cmdutil/factory_default.go

@@ -22,7 +22,6 @@ import (
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/keychain"
 	"github.com/larksuite/cli/internal/registry"
-	"github.com/larksuite/cli/internal/riskcontrol"
 	_ "github.com/larksuite/cli/internal/security/contentsafety" // register content safety provider
 	"github.com/larksuite/cli/internal/transport"
 	_ "github.com/larksuite/cli/internal/vfs/localfileio" // register default FileIO provider
@@ -34,7 +33,7 @@ import (
 //	Phase 1: HttpClient (no credential dependency)
 //	Phase 2: Credential (sole data source for account info)
 //	Phase 3: Config derived from Credential
-//	Phase 4: LarkClient derived from Credential and workspace policy
+//	Phase 4: LarkClient derived from Credential
 func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 	streams = normalizeStreams(streams)
 	f := &Factory{
@@ -55,22 +54,20 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 
 	// Phase 0: FileIO provider (no dependency)
 	f.FileIOProvider = fileio.GetProvider()
-	workspaceConfig := core.NewConfigSnapshot()
 
 	// Phase 1: HttpClient (no credential dependency)
-	f.HttpClient = cachedHttpClientFunc(f, workspaceConfig)
+	f.HttpClient = cachedHttpClientFunc(f)
 
 	// Phase 2: Credential (sole data source)
 	// Keychain is read via closure so callers can replace f.Keychain after construction.
 	f.Credential = buildCredentialProvider(credentialDeps{
-		Keychain:        func() keychain.KeychainAccess { return f.Keychain },
-		Profile:         inv.Profile,
-		ProfileFromFlag: inv.ProfileFromFlag,
-		HttpClient:      f.HttpClient,
-		ErrOut:          f.IOStreams.ErrOut,
+		Keychain:   func() keychain.KeychainAccess { return f.Keychain },
+		Profile:    inv.Profile,
+		HttpClient: f.HttpClient,
+		ErrOut:     f.IOStreams.ErrOut,
 	})
 
-	// Phase 3: Runtime config contains resolved account data only.
+	// Phase 3: Config derived from Credential via an explicit conversion boundary.
 	f.Config = sync.OnceValues(func() (*core.CliConfig, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
 		if err != nil {
@@ -81,9 +78,8 @@ func NewDefault(streams *IOStreams, inv InvocationContext) *Factory {
 		return cfg, nil
 	})
 
-	// Phase 4: LarkClient composes account data and workspace policy at the SDK
-	// transport boundary.
-	f.LarkClient = cachedLarkClientFunc(f, workspaceConfig)
+	// Phase 4: LarkClient from Credential (placeholder AppSecret)
+	f.LarkClient = cachedLarkClientFunc(f)
 
 	return f
 }
@@ -112,16 +108,13 @@ func safeRedirectPolicy(req *http.Request, via []*http.Request) error {
 // .StderrIsTerminal field, which tests set directly.
 var warnIfProxied = transport.WarnIfProxied
 
-func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*http.Client, error) {
+func cachedHttpClientFunc(f *Factory) func() (*http.Client, error) {
 	return sync.OnceValues(func() (*http.Client, error) {
 		if f.IOStreams.StderrIsTerminal {
 			warnIfProxied(f.IOStreams.ErrOut)
 		}
 
-		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-
 		var rt http.RoundTripper = transport.Shared()
-		rt = riskcontrol.NewTransport(rt, hostSignalSource)
 		rt = &RetryTransport{Base: rt}
 		rt = &SecurityHeaderTransport{Base: rt}
 		rt = &auth.SecurityPolicyTransport{Base: rt} // Add our global response interceptor
@@ -135,7 +128,7 @@ func cachedHttpClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }
 
-func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) func() (*lark.Client, error) {
+func cachedLarkClientFunc(f *Factory) func() (*lark.Client, error) {
 	return sync.OnceValues(func() (*lark.Client, error) {
 		acct, err := f.Credential.ResolveAccount(context.Background())
 		if err != nil {
@@ -149,15 +142,8 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 		if f.IOStreams.StderrIsTerminal {
 			warnIfProxied(f.IOStreams.ErrOut)
 		}
-		hostSignalSource := resolveSDKHostSignalSource(workspaceConfig)
-		var sdkBase http.RoundTripper = transport.Shared()
-		// The innermost SDK boundary always strips reserved host-signal headers;
-		// a nil source makes it strip-only when workspace policy disables signal
-		// collection.
-		sdkBase = riskcontrol.NewTransport(sdkBase, hostSignalSource)
-		sdkTransport := wrapSDKTransport(sdkBase)
 		opts = append(opts, lark.WithHttpClient(&http.Client{
-			Transport:     sdkTransport,
+			Transport:     buildSDKTransport(),
 			CheckRedirect: safeRedirectPolicy,
 		}))
 		ep := core.ResolveEndpoints(acct.Brand)
@@ -166,8 +152,9 @@ func cachedLarkClientFunc(f *Factory, workspaceConfig workspaceConfigSource) fun
 	})
 }
 
-func wrapSDKTransport(next http.RoundTripper) http.RoundTripper {
-	var sdkTransport http.RoundTripper = &RetryTransport{Base: next}
+func buildSDKTransport() http.RoundTripper {
+	var sdkTransport http.RoundTripper = transport.Shared()
+	sdkTransport = &RetryTransport{Base: sdkTransport}
 	sdkTransport = &UserAgentTransport{Base: sdkTransport}
 	sdkTransport = &BuildHeaderTransport{Base: sdkTransport}
 	sdkTransport = &auth.SecurityPolicyTransport{Base: sdkTransport}
@@ -175,11 +162,10 @@ func wrapSDKTransport(next http.RoundTripper) http.RoundTripper {
 }
 
 type credentialDeps struct {
-	Keychain        func() keychain.KeychainAccess
-	Profile         string
-	ProfileFromFlag bool
-	HttpClient      func() (*http.Client, error)
-	ErrOut          io.Writer
+	Keychain   func() keychain.KeychainAccess
+	Profile    string
+	HttpClient func() (*http.Client, error)
+	ErrOut     io.Writer
 }
 
 func buildCredentialProvider(deps credentialDeps) *credential.CredentialProvider {
@@ -192,13 +178,5 @@ func buildCredentialProvider(deps credentialDeps) *credential.CredentialProvider
 	// depend on. enrichUserInfo failures are already non-fatal (the
 	// provider clears unverified identity fields), so silencing the
 	// warning is safe.
-	cred := credential.NewCredentialProvider(providers, defaultAcct, defaultToken, deps.HttpClient)
-	if deps.Profile == "" {
-		// No profile selected — don't record a phantom env source.
-		return cred
-	}
-	if deps.ProfileFromFlag {
-		return cred.WithProfileFromFlag(deps.Profile)
-	}
-	return cred.WithProfileFromEnv(deps.Profile)
+	return credential.NewCredentialProvider(providers, defaultAcct, defaultToken, deps.HttpClient)
 }

internal/cmdutil/factory_http_test.go

@@ -6,15 +6,10 @@ package cmdutil
 import (
 	"io"
 	"testing"
-
-	"github.com/larksuite/cli/internal/core"
 )
 
 func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 
 	c1, err := fn()
 	if err != nil {
@@ -34,10 +29,7 @@ func TestCachedHttpClientFunc_ReturnsSameInstance(t *testing.T) {
 }
 
 func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.Timeout == 0 {
 		t.Error("expected non-zero timeout")
@@ -45,10 +37,7 @@ func TestCachedHttpClientFunc_HasTimeout(t *testing.T) {
 }
 
 func TestCachedHttpClientFunc_HasRedirectPolicy(t *testing.T) {
-	isEnabled := false
-	f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-	f.IOStreams.ErrOut = io.Discard
-	fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+	fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{ErrOut: io.Discard}})
 	c, _ := fn()
 	if c.CheckRedirect == nil {
 		t.Error("expected CheckRedirect to be set (safeRedirectPolicy)")

internal/cmdutil/factory_proxy_warn_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	_ "github.com/larksuite/cli/extension/credential/env" // registers the env-backed account provider
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/envvars"
 )
 
@@ -37,15 +36,13 @@ var proxyWarnGateCases = []struct {
 // TestCachedHttpClientFunc_ProxyWarnGate verifies the http-client init path
 // invokes WarnIfProxied only when stderr is an interactive terminal.
 func TestCachedHttpClientFunc_ProxyWarnGate(t *testing.T) {
-	isEnabled := false
 	for _, tc := range proxyWarnGateCases {
 		t.Run(tc.name, func(t *testing.T) {
 			calls := installProxyWarnSpy(t)
 
-			f, _, _, _ := TestFactory(t, &core.CliConfig{AppID: "test-app"})
-			f.IOStreams.ErrOut = io.Discard
-			f.IOStreams.StderrIsTerminal = tc.terminal
-			fn := cachedHttpClientFunc(f, staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &isEnabled}})
+			fn := cachedHttpClientFunc(&Factory{IOStreams: &IOStreams{
+				ErrOut: io.Discard, StderrIsTerminal: tc.terminal,
+			}})
 			if _, err := fn(); err != nil {
 				t.Fatalf("http client init: %v", err)
 			}
@@ -76,7 +73,7 @@ func TestCachedLarkClientFunc_ProxyWarnGate(t *testing.T) {
 			// normalizeStreams copies the struct (out := *s), so the
 			// StderrIsTerminal field survives into f.IOStreams.
 			f := NewDefault(&IOStreams{ErrOut: io.Discard, StderrIsTerminal: tc.terminal}, InvocationContext{})
-			if _, err := cachedLarkClientFunc(f, nil)(); err != nil {
+			if _, err := cachedLarkClientFunc(f)(); err != nil {
 				t.Fatalf("lark client init: %v", err)
 			}
 

internal/cmdutil/factory_test.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
-	envprovider "github.com/larksuite/cli/extension/credential/env"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/credential"
 	"github.com/larksuite/cli/internal/envvars"
@@ -406,14 +405,6 @@ type stubExtProvider struct {
 	err  error
 }
 
-type stubDefaultAccountResolver struct {
-	acct *credential.Account
-}
-
-func (s *stubDefaultAccountResolver) ResolveAccount(_ context.Context) (*credential.Account, error) {
-	return s.acct, nil
-}
-
 func (s *stubExtProvider) Name() string { return s.name }
 func (s *stubExtProvider) ResolveAccount(_ context.Context) (*extcred.Account, error) {
 	return s.acct, s.err
@@ -457,86 +448,6 @@ func TestRequireBuiltinCredentialProvider_AllowsBuiltinProvider(t *testing.T) {
 	}
 }
 
-func TestRequireBuiltinCredentialProvider_AllowsMatchingAppIDOnlyProfile(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	t.Setenv(envvars.CliAppID, "cli_a")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv(envvars.CliUserAccessToken, "")
-	t.Setenv(envvars.CliTenantAccessToken, "")
-	if err := core.SaveMultiAppConfig(&core.MultiAppConfig{
-		CurrentApp: "tenant_a",
-		Apps: []core.AppConfig{{
-			Name:      "tenant_a",
-			AppId:     "cli_a",
-			AppSecret: core.PlainSecret("test-secret"),
-			Brand:     core.BrandFeishu,
-		}},
-	}); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{&envprovider.Provider{}},
-		&stubDefaultAccountResolver{acct: &credential.Account{AppID: "cli_a", AppSecret: "test-secret"}},
-		nil,
-		nil,
-	).WithProfileFromFlag("tenant_a")
-	f, _, _, _ := TestFactory(t, nil)
-	f.Credential = cred
-
-	if err := f.RequireBuiltinCredentialProvider(context.Background(), "auth"); err != nil {
-		t.Fatalf("matching APP_ID-only profile should use builtin credentials: %v", err)
-	}
-}
-
-// A stale LARKSUITE_CLI_PROFILE (profile that cannot resolve) must not lock
-// the user out of the builtin setup/repair commands this gate guards: the
-// probe falls back to provider engagement and lets the command run.
-func TestRequireBuiltinCredentialProvider_StaleProfileDoesNotLockOut(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir()) // no config -> "ghost" cannot resolve
-
-	stub := &stubExtProvider{name: "env"} // not engaged: returns nil, nil
-	cred := credential.NewCredentialProvider(
-		[]extcred.Provider{stub},
-		&stubDefaultAccountResolver{},
-		nil,
-		nil,
-	).WithProfileFromEnv("ghost")
-	f, _, _, _ := TestFactory(t, nil)
-	f.Credential = cred
-
-	if err := f.RequireBuiltinCredentialProvider(context.Background(), "config"); err != nil {
-		t.Fatalf("stale profile must not lock out builtin auth/config commands: %v", err)
-	}
-}
-
-// An invalid policy variable (e.g. LARKSUITE_CLI_DEFAULT_AS=banana) is a user
-// input error, not an external credential takeover: the gate surfaces the
-// same typed validation error as formal arbitration instead of a misleading
-// "provided externally" refusal.
-func TestRequireBuiltinCredentialProvider_InvalidPolicySurfacesTypedError(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	stub := &stubExtProvider{name: "env", err: &extcred.BlockError{
-		Provider: "env",
-		Reason:   "invalid LARKSUITE_CLI_DEFAULT_AS \"banana\" (want user, bot, or auto)",
-		Code:     extcred.BlockReasonInvalidPolicy,
-		Param:    envvars.CliDefaultAs,
-	}}
-	cred := credential.NewCredentialProvider([]extcred.Provider{stub}, &stubDefaultAccountResolver{}, nil, nil)
-	f, _, _, _ := TestFactory(t, nil)
-	f.Credential = cred
-
-	err := f.RequireBuiltinCredentialProvider(context.Background(), "auth")
-	prob, ok := errs.ProblemOf(err)
-	if !ok || prob.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("err = %v, want typed invalid_argument (same as formal arbitration)", err)
-	}
-	if strings.Contains(err.Error(), "provided externally") {
-		t.Fatalf("err = %v, must not read as external takeover", err)
-	}
-}
-
 func TestRequireBuiltinCredentialProvider_NilCredential(t *testing.T) {
 	f, _, _, _ := TestFactory(t, nil)
 	f.Credential = nil

internal/cmdutil/localfile.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"io/fs"
-
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-// StatLocalFile returns metadata for a path in the process filesystem namespace.
-// It is intended for advisory validation; callers must validate the opened file
-// again before using its contents.
-func StatLocalFile(path string) (fs.FileInfo, error) {
-	localPath, err := validate.LocalInputPath(path)
-	if err != nil {
-		return nil, &fileio.PathValidationError{Err: err}
-	}
-	return vfs.Stat(localPath)
-}
-
-// OpenLocalFile opens a path in the process filesystem namespace.
-// Absolute and relative paths are accepted. It is the shared replacement for
-// direct os.Open/os.ReadFile use in commands that intentionally read local
-// paths outside the workspace sandbox. Callers inspect the returned descriptor
-// before reading so validation and use apply to the same opened file.
-func OpenLocalFile(path string) (fs.File, error) {
-	localPath, err := validate.LocalInputPath(path)
-	if err != nil {
-		return nil, &fileio.PathValidationError{Err: err}
-	}
-	return vfs.Open(localPath)
-}

internal/cmdutil/localfile_test.go

@@ -1,96 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"errors"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/vfs"
-)
-
-func TestOpenLocalFile_AcceptsAbsoluteAndParentRelativePaths(t *testing.T) {
-	root := t.TempDir()
-	workDir := filepath.Join(root, "work")
-	if err := os.Mkdir(workDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	path := filepath.Join(root, "input.txt")
-	if err := os.WriteFile(path, []byte("content"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	TestChdir(t, workDir)
-
-	for _, input := range []string{path, filepath.Join("..", "input.txt")} {
-		f, err := OpenLocalFile(input)
-		if err != nil {
-			t.Fatalf("OpenLocalFile(%q) error = %v", input, err)
-		}
-		got, readErr := io.ReadAll(f)
-		closeErr := f.Close()
-		if readErr != nil || closeErr != nil || string(got) != "content" {
-			t.Fatalf("OpenLocalFile(%q) content=%q read=%v close=%v", input, got, readErr, closeErr)
-		}
-	}
-}
-
-func TestOpenLocalFile_RejectsInvalidInput(t *testing.T) {
-	if _, err := OpenLocalFile("input\n.txt"); !errors.Is(err, fileio.ErrPathValidation) {
-		t.Fatalf("OpenLocalFile() error = %v, want ErrPathValidation", err)
-	}
-}
-
-func TestStatLocalFile_ReturnsMetadata(t *testing.T) {
-	info, err := StatLocalFile(t.TempDir())
-	if err != nil {
-		t.Fatalf("StatLocalFile() error = %v", err)
-	}
-	if !info.IsDir() {
-		t.Fatalf("StatLocalFile() mode = %v, want directory", info.Mode())
-	}
-}
-
-func TestOpenLocalFile_DoesNotStatBeforeOpen(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "input.txt")
-	if err := os.WriteFile(path, []byte("content"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	previous := vfs.DefaultFS
-	counting := &countingLocalFileFS{FS: previous}
-	vfs.DefaultFS = counting
-	t.Cleanup(func() { vfs.DefaultFS = previous })
-
-	f, err := OpenLocalFile(path)
-	if err != nil {
-		t.Fatalf("OpenLocalFile() error = %v", err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if counting.openCalls != 1 || counting.statCalls != 0 {
-		t.Fatalf("OpenLocalFile() calls: Open=%d Stat=%d, want Open=1 Stat=0", counting.openCalls, counting.statCalls)
-	}
-}
-
-type countingLocalFileFS struct {
-	vfs.FS
-	openCalls int
-	statCalls int
-}
-
-func (f *countingLocalFileFS) Open(name string) (*os.File, error) {
-	f.openCalls++
-	return f.FS.Open(name)
-}
-
-func (f *countingLocalFileFS) Stat(name string) (fs.FileInfo, error) {
-	f.statCalls++
-	return f.FS.Stat(name)
-}

internal/cmdutil/risk_control.go

@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/riskcontrol"
-)
-
-type workspaceConfigSource interface {
-	MultiAppConfig() (*core.MultiAppConfig, error)
-}
-
-// resolveSDKHostSignalSource applies workspace policy at the SDK transport
-// boundary.
-func resolveSDKHostSignalSource(config workspaceConfigSource) riskcontrol.Source {
-	if config == nil {
-		return nil
-	}
-	workspace, configErr := config.MultiAppConfig()
-	// Default-on means an existing config with no explicit preference. Absent
-	// or unreadable config cannot authorize host-signal collection.
-	if configErr != nil || !workspace.RiskControlEnabled() {
-		return nil
-	}
-	return riskcontrol.NewHostSource()
-}

internal/cmdutil/risk_control_test.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmdutil
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/internal/core"
-)
-
-type staticWorkspaceConfig struct {
-	config *core.MultiAppConfig
-	err    error
-}
-
-func (s staticWorkspaceConfig) MultiAppConfig() (*core.MultiAppConfig, error) {
-	return s.config, s.err
-}
-
-func TestResolveSDKHostSignalSource(t *testing.T) {
-	disabled := false
-	tests := []struct {
-		name       string
-		config     workspaceConfigSource
-		wantSource bool
-	}{
-		{name: "workspace default on", config: staticWorkspaceConfig{config: &core.MultiAppConfig{}}, wantSource: true},
-		{name: "workspace opt-out", config: staticWorkspaceConfig{config: &core.MultiAppConfig{RiskControl: &disabled}}},
-		{name: "missing config", config: staticWorkspaceConfig{err: errors.New("file does not exist")}},
-		{name: "unreadable config", config: staticWorkspaceConfig{err: errors.New("permission denied")}},
-		{name: "nil config value", config: staticWorkspaceConfig{}},
-		{name: "nil config source"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			got := resolveSDKHostSignalSource(test.config)
-			if (got != nil) != test.wantSource {
-				t.Fatalf("resolveSDKHostSignalSource() = %T, wantSource %t", got, test.wantSource)
-			}
-		})
-	}
-}

internal/cmdutil/transport_test.go

@@ -15,7 +15,6 @@ import (
 
 	exttransport "github.com/larksuite/cli/extension/transport"
 	internalauth "github.com/larksuite/cli/internal/auth"
-	"github.com/larksuite/cli/internal/riskcontrol"
 )
 
 type roundTripFunc func(*http.Request) (*http.Response, error)
@@ -92,13 +91,13 @@ func TestRetryTransport_DefaultNoRetry(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-// wrapSDKTransport chain composition
+// buildSDKTransport chain composition
 // ---------------------------------------------------------------------------
 
-func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+func TestBuildSDKTransport_IncludesRetryTransport(t *testing.T) {
+	transport := buildSDKTransport()
 
-	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
@@ -111,23 +110,18 @@ func TestWrapSDKTransport_IncludesRetryTransport(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }
 
-func TestWrapSDKTransport_WithExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
+func TestBuildSDKTransport_WithExtension(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{})
-	t.Cleanup(func() { exttransport.Register(previous) })
+	t.Cleanup(func() { exttransport.Register(nil) })
 
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+	transport := buildSDKTransport()
 
-	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: extensionMiddleware → SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	mid, ok := transport.(*extensionMiddleware)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *extensionMiddleware", transport)
@@ -144,23 +138,17 @@ func TestWrapSDKTransport_WithExtension(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("innermost transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }
 
-func TestWrapSDKTransport_WithoutExtension(t *testing.T) {
-	previous := exttransport.GetProvider()
+func TestBuildSDKTransport_WithoutExtension(t *testing.T) {
 	exttransport.Register(nil)
-	t.Cleanup(func() { exttransport.Register(previous) })
 
-	transport := wrapSDKTransport(riskcontrol.NewTransport(http.DefaultTransport, nil))
+	transport := buildSDKTransport()
 
-	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → RiskControl → Base
+	// Chain: SecurityPolicy → BuildHeader → UserAgent → Retry → Base
 	sec, ok := transport.(*internalauth.SecurityPolicyTransport)
 	if !ok {
 		t.Fatalf("outer transport type = %T, want *auth.SecurityPolicyTransport", transport)
@@ -173,13 +161,9 @@ func TestWrapSDKTransport_WithoutExtension(t *testing.T) {
 	if !ok {
 		t.Fatalf("layer after BuildHeader = %T, want *UserAgentTransport", bh.Base)
 	}
-	retry, ok := ua.Base.(*RetryTransport)
-	if !ok {
+	if _, ok := ua.Base.(*RetryTransport); !ok {
 		t.Fatalf("inner transport type = %T, want *RetryTransport", ua.Base)
 	}
-	if _, ok := retry.Base.(*riskcontrol.Transport); !ok {
-		t.Fatalf("layer after Retry = %T, want *riskcontrol.Transport", retry.Base)
-	}
 }
 
 // ---------------------------------------------------------------------------
@@ -277,40 +261,6 @@ func (buildTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Resp
 	return nil
 }
 
-type riskHeaderTamperingInterceptor struct{}
-
-func (riskHeaderTamperingInterceptor) PreRoundTrip(req *http.Request) func(*http.Response, error) {
-	req.Header.Set(riskcontrol.HeaderOSType, "extension-value")
-	req.Header.Set(riskcontrol.HeaderProductModel, "extension-value")
-	return nil
-}
-
-func TestWrapSDKTransport_StripsExtensionRiskHeaders(t *testing.T) {
-	previous := exttransport.GetProvider()
-	exttransport.Register(&stubTransportProvider{interceptor: riskHeaderTamperingInterceptor{}})
-	t.Cleanup(func() { exttransport.Register(previous) })
-
-	var received http.Header
-	network := roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		received = req.Header.Clone()
-		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil
-	})
-	req, err := http.NewRequest(http.MethodGet, "https://open.feishu.cn/open-apis/test", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req.Header.Set("Authorization", "Bearer token")
-
-	resp, err := wrapSDKTransport(riskcontrol.NewTransport(network, nil)).RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-	if received.Get(riskcontrol.HeaderOSType) != "" || received.Get(riskcontrol.HeaderProductModel) != "" {
-		t.Fatalf("extension risk headers reached network: %v", received)
-	}
-}
-
 // TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader verifies that the
 // X-Cli-Build header is force-written by BuildHeaderTransport in the SDK
 // transport chain, even when an extension tries to delete or spoof it. This
@@ -327,7 +277,7 @@ func TestBuildHeaderTransport_SDKChain_OverridesTamperedHeader(t *testing.T) {
 	exttransport.Register(&stubTransportProvider{interceptor: buildTamperingInterceptor{}})
 	t.Cleanup(func() { exttransport.Register(nil) })
 
-	// Replicate the SDK chain layering used by wrapSDKTransport.
+	// Replicate the SDK chain layering used by buildSDKTransport.
 	var base http.RoundTripper = http.DefaultTransport
 	base = &RetryTransport{Base: base}
 	base = &UserAgentTransport{Base: base}

internal/core/config.go

@@ -36,6 +36,14 @@ type AppUser struct {
 	UserName   string `json:"userName"`
 }
 
+// Auth methods for app credentials. An empty AppConfig.AuthMethod means the
+// default, client_secret.
+const (
+	AuthMethodClientSecret  = "client_secret"   // app_id + app_secret
+	authMethodPKJWTValue    = "private_key_jwt" // TEE-signed client_assertion; no app secret
+	AuthMethodPrivateKeyJWT = authMethodPKJWTValue
+)
+
 // AppConfig is a per-app configuration entry (stored format — secrets may be unresolved).
 type AppConfig struct {
 	Name       string      `json:"name,omitempty"`
@@ -46,6 +54,15 @@ type AppConfig struct {
 	DefaultAs  Identity    `json:"defaultAs,omitempty"` // AsUser | AsBot | AsAuto
 	StrictMode *StrictMode `json:"strictMode,omitempty"`
 	Users      []AppUser   `json:"users"`
+
+	// AuthMethod selects how tokens are minted. Empty == AuthMethodClientSecret
+	// (back-compat). AuthMethodPrivateKeyJWT uses a TEE-held key (see KeyRef) to
+	// sign client_assertion JWTs instead of sending an app secret.
+	AuthMethod string `json:"authMethod,omitempty"`
+	// KeyRef references the non-exportable signing key for private_key_jwt.
+	// Source is "tee" and ID is the backend key label; the actual key never
+	// leaves the secure backend, so this is a handle, not secret material.
+	KeyRef *SecretRef `json:"keyRef,omitempty"`
 }
 
 // ProfileName returns the display name for this app config.
@@ -60,18 +77,11 @@ func (a *AppConfig) ProfileName() string {
 // MultiAppConfig is the multi-app config file format.
 type MultiAppConfig struct {
 	StrictMode  StrictMode  `json:"strictMode,omitempty"`
-	RiskControl *bool       `json:"riskControl,omitempty"`
 	CurrentApp  string      `json:"currentApp,omitempty"`
 	PreviousApp string      `json:"previousApp,omitempty"`
 	Apps        []AppConfig `json:"apps"`
 }
 
-// RiskControlEnabled resolves the workspace policy. An omitted preference
-// keeps the default-on account-protection behavior.
-func (m *MultiAppConfig) RiskControlEnabled() bool {
-	return m != nil && (m.RiskControl == nil || *m.RiskControl)
-}
-
 // CurrentAppConfig returns the currently active app config.
 // Resolution priority: profileOverride > CurrentApp field > Apps[0].
 func (m *MultiAppConfig) CurrentAppConfig(profileOverride string) *AppConfig {
@@ -168,7 +178,10 @@ type CliConfig struct {
 	UserOpenId          string
 	UserName            string
 	Lang                i18n.Lang
-	SupportedIdentities uint8 `json:"-"` // bitflag: 1=user, 2=bot; set by credential provider
+	SupportedIdentities uint8  `json:"-"` // bitflag: 1=user, 2=bot; set by credential provider
+	AuthMethod          string // "" == client_secret; AuthMethodPrivateKeyJWT
+	KeyLabel            string // resolved TEE key handle for private_key_jwt
+	KeyProvider         string // empty == built-in signer; otherwise an explicit external signer route
 }
 
 // identityBotBit is the bit flag for bot identity in SupportedIdentities.
@@ -254,35 +267,67 @@ func ResolveConfigFromMulti(raw *MultiAppConfig, kc keychain.KeychainAccess, pro
 			WithHint("available profiles: %s", formatProfileNames(raw.ProfileNames()))
 	}
 
-	if err := ValidateSecretKeyMatch(app.AppId, app.AppSecret); err != nil {
-		// invalid_config, not not_configured: the config exists but is
-		// internally inconsistent. not_configured would let callers degrade
-		// this into a generic "secret invalid" answer and destroy the precise
-		// repair hint (which names the expected keychain key — never a value).
-		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "appId and appSecret keychain key are out of sync").
-			WithHint("%s", err.Error()).
-			WithCause(err)
+	// Validate the auth method first so a malformed profile fails here rather
+	// than silently degrading to client_secret (unknown method) or failing later
+	// at token-signing. Empty stays empty — downstream treats it as client_secret
+	// (back-compat).
+	switch app.AuthMethod {
+	case "", AuthMethodClientSecret, AuthMethodPrivateKeyJWT:
+	default:
+		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "unknown authMethod %q", app.AuthMethod).
+			WithHint("supported: %s, %s (empty defaults to %s)", AuthMethodClientSecret, AuthMethodPrivateKeyJWT, AuthMethodClientSecret)
 	}
 
-	secret, err := ResolveSecretInput(app.AppSecret, kc)
-	if err != nil {
-		if errs.IsTyped(err) {
-			return nil, err
+	// private_key_jwt carries no secret: validate the key handle and skip secret
+	// resolution entirely, so a stale/broken AppSecret ref never produces a
+	// confusing secret-resolution error for an otherwise-valid pkjwt profile.
+	var secret string
+	if app.AuthMethod == AuthMethodPrivateKeyJWT {
+		if app.KeyRef == nil || app.KeyRef.Source != "tee" || app.KeyRef.ID == "" {
+			return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "private_key_jwt requires a key handle (keyRef) but none is configured").
+				WithHint("re-run: lark-cli config init --new --private-key-jwt")
 		}
-		subtype := errs.SubtypeNotConfigured
-		if isMalformedConfigError(err) {
-			subtype = errs.SubtypeInvalidConfig
+		provider := strings.TrimSpace(app.KeyRef.Provider)
+		switch provider {
+		case "", KeylessProviderLarkSuite:
+		default:
+			return nil, errs.NewConfigError(errs.SubtypeInvalidConfig,
+				"unknown keyless signer provider %q", app.KeyRef.Provider).
+				WithHint("supported external provider: %s; omit provider to use the built-in signer", KeylessProviderLarkSuite)
+		}
+	} else {
+		if err := ValidateSecretKeyMatch(app.AppId, app.AppSecret); err != nil {
+			return nil, errs.NewConfigError(errs.SubtypeNotConfigured, "appId and appSecret keychain key are out of sync").
+				WithHint("%s", err.Error()).
+				WithCause(err)
+		}
+		var resolveErr error
+		secret, resolveErr = ResolveSecretInput(app.AppSecret, kc)
+		if resolveErr != nil {
+			if errs.IsTyped(resolveErr) {
+				return nil, resolveErr
+			}
+			subtype := errs.SubtypeNotConfigured
+			if isMalformedConfigError(resolveErr) {
+				subtype = errs.SubtypeInvalidConfig
+			}
+			return nil, errs.NewConfigError(subtype, "%s", resolveErr.Error()).WithCause(resolveErr)
 		}
-		return nil, errs.NewConfigError(subtype, "%s", err.Error()).WithCause(err)
 	}
+
 	cfg := &CliConfig{
 		ProfileName: app.ProfileName(),
 		AppID:       app.AppId,
 		AppSecret:   secret,
 		Brand:       ParseBrand(string(app.Brand)),
 		Lang:        app.Lang,
+		AuthMethod:  app.AuthMethod,
 		DefaultAs:   app.DefaultAs,
 	}
+	if app.KeyRef != nil {
+		cfg.KeyLabel = app.KeyRef.ID
+		cfg.KeyProvider = strings.TrimSpace(app.KeyRef.Provider)
+	}
 	if len(app.Users) > 0 {
 		cfg.UserOpenId = app.Users[0].UserOpenId
 		cfg.UserName = app.Users[0].UserName

internal/core/config_snapshot.go

@@ -1,37 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package core
-
-import (
-	"io/fs"
-	"sync"
-)
-
-// ConfigSnapshot lazily captures one stable view of config.json for a CLI
-// invocation. All runtime consumers share the same load result so account and
-// workspace policy resolution cannot observe different file revisions. Callers
-// must treat the returned config as read-only.
-type ConfigSnapshot struct {
-	load func() (*MultiAppConfig, error)
-}
-
-// NewConfigSnapshot creates a lazily loaded invocation-scoped config snapshot.
-func NewConfigSnapshot() *ConfigSnapshot {
-	return newConfigSnapshot(LoadMultiAppConfig)
-}
-
-func newConfigSnapshot(load func() (*MultiAppConfig, error)) *ConfigSnapshot {
-	if load == nil {
-		return &ConfigSnapshot{}
-	}
-	return &ConfigSnapshot{load: sync.OnceValues(load)}
-}
-
-// MultiAppConfig returns the captured persistent config and load error.
-func (s *ConfigSnapshot) MultiAppConfig() (*MultiAppConfig, error) {
-	if s == nil || s.load == nil {
-		return nil, fs.ErrNotExist
-	}
-	return s.load()
-}

internal/core/config_snapshot_test.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package core
-
-import (
-	"errors"
-	"io/fs"
-	"testing"
-)
-
-func TestConfigSnapshotLoadsOnce(t *testing.T) {
-	calls := 0
-	want := &MultiAppConfig{}
-	snapshot := newConfigSnapshot(func() (*MultiAppConfig, error) {
-		calls++
-		return want, nil
-	})
-
-	for range 2 {
-		config, err := snapshot.MultiAppConfig()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if config != want {
-			t.Fatal("snapshot returned a different config instance")
-		}
-	}
-	if calls != 1 {
-		t.Fatalf("config loads = %d, want 1", calls)
-	}
-}
-
-func TestConfigSnapshotZeroValueIsMissing(t *testing.T) {
-	config, err := (&ConfigSnapshot{}).MultiAppConfig()
-	if config != nil || !errors.Is(err, fs.ErrNotExist) {
-		t.Fatalf("MultiAppConfig() = (%v, %v), want (nil, fs.ErrNotExist)", config, err)
-	}
-}
-
-func TestConfigSnapshotCachesError(t *testing.T) {
-	calls := 0
-	want := errors.New("load failed")
-	snapshot := newConfigSnapshot(func() (*MultiAppConfig, error) {
-		calls++
-		return nil, want
-	})
-
-	for range 2 {
-		config, err := snapshot.MultiAppConfig()
-		if config != nil || !errors.Is(err, want) {
-			t.Fatalf("MultiAppConfig() = (%v, %v), want (nil, %v)", config, err, want)
-		}
-	}
-	if calls != 1 {
-		t.Fatalf("config loads = %d, want 1", calls)
-	}
-}

internal/core/config_test.go

@@ -60,9 +60,7 @@ func TestAppConfig_LangOmitEmpty(t *testing.T) {
 }
 
 func TestMultiAppConfig_RoundTrip(t *testing.T) {
-	disabled := false
 	config := &MultiAppConfig{
-		RiskControl: &disabled,
 		Apps: []AppConfig{{
 			AppId: "cli_test", AppSecret: PlainSecret("s"),
 			Brand: BrandLark, Lang: "zh", Users: []AppUser{},
@@ -86,8 +84,34 @@ func TestMultiAppConfig_RoundTrip(t *testing.T) {
 	if got.Apps[0].Brand != BrandLark {
 		t.Errorf("Brand = %q, want %q", got.Apps[0].Brand, BrandLark)
 	}
-	if got.RiskControl == nil || *got.RiskControl {
-		t.Errorf("RiskControl = %v, want explicit false", got.RiskControl)
+}
+
+func TestResolveConfigFromMulti_KeyProviderRouting(t *testing.T) {
+	base := AppConfig{
+		AppId: "cli_pk", Brand: BrandFeishu, AuthMethod: AuthMethodPrivateKeyJWT,
+		KeyRef: &SecretRef{Source: SecretSourceTEE, ID: "key-1"}, Users: []AppUser{},
+	}
+
+	for _, provider := range []string{"", KeylessProviderLarkSuite} {
+		app := base
+		ref := *base.KeyRef
+		ref.Provider = provider
+		app.KeyRef = &ref
+		cfg, err := ResolveConfigFromMulti(&MultiAppConfig{Apps: []AppConfig{app}}, stubKeychain{}, "")
+		if err != nil {
+			t.Fatalf("provider %q: %v", provider, err)
+		}
+		if cfg.KeyProvider != provider {
+			t.Fatalf("KeyProvider = %q, want %q", cfg.KeyProvider, provider)
+		}
+	}
+
+	app := base
+	ref := *base.KeyRef
+	ref.Provider = "unknown.provider"
+	app.KeyRef = &ref
+	if _, err := ResolveConfigFromMulti(&MultiAppConfig{Apps: []AppConfig{app}}, stubKeychain{}, ""); err == nil {
+		t.Fatal("unknown provider must fail closed")
 	}
 }
 
@@ -138,6 +162,108 @@ func TestResolveConfigFromMulti_AcceptsPlainSecret(t *testing.T) {
 	}
 }
 
+// TestResolveConfigFromMulti_RejectsUnknownAuthMethod ensures an unsupported
+// authMethod fails at resolution rather than silently degrading to client_secret.
+func TestResolveConfigFromMulti_RejectsUnknownAuthMethod(t *testing.T) {
+	raw := &MultiAppConfig{
+		Apps: []AppConfig{
+			{
+				AppId:      "cli_abc",
+				AppSecret:  PlainSecret("my-secret"),
+				Brand:      BrandFeishu,
+				AuthMethod: "bogus_method",
+			},
+		},
+	}
+
+	_, err := ResolveConfigFromMulti(raw, nil, "")
+	if err == nil {
+		t.Fatal("expected error for unknown authMethod")
+	}
+	var cfgErr *errs.ConfigError
+	if !errors.As(err, &cfgErr) {
+		t.Fatalf("expected ConfigError, got %T: %v", err, err)
+	}
+}
+
+// TestResolveConfigFromMulti_PrivateKeyJWTRequiresKeyRef ensures private_key_jwt
+// without a key handle fails at resolution rather than later at token-signing.
+func TestResolveConfigFromMulti_PrivateKeyJWTRequiresKeyRef(t *testing.T) {
+	raw := &MultiAppConfig{
+		Apps: []AppConfig{
+			{
+				AppId:      "cli_abc",
+				AppSecret:  SecretInput{}, // private_key_jwt carries no app secret
+				Brand:      BrandFeishu,
+				AuthMethod: AuthMethodPrivateKeyJWT,
+				// KeyRef intentionally nil
+			},
+		},
+	}
+
+	_, err := ResolveConfigFromMulti(raw, nil, "")
+	if err == nil {
+		t.Fatal("expected error for private_key_jwt without keyRef")
+	}
+	var cfgErr *errs.ConfigError
+	if !errors.As(err, &cfgErr) {
+		t.Fatalf("expected ConfigError, got %T: %v", err, err)
+	}
+
+	// Control: same config WITH a keyRef resolves cleanly and sets KeyLabel.
+	raw.Apps[0].KeyRef = &SecretRef{Source: "tee", ID: "larksuite-cli-agent"}
+	cfg, err := ResolveConfigFromMulti(raw, nil, "")
+	if err != nil {
+		t.Fatalf("unexpected error with keyRef present: %v", err)
+	}
+	if cfg.KeyLabel != "larksuite-cli-agent" {
+		t.Errorf("KeyLabel = %q, want larksuite-cli-agent", cfg.KeyLabel)
+	}
+}
+
+// TestResolveConfigFromMulti_PKJWTSkipsSecretResolution ensures a private_key_jwt
+// profile that carries a stale/broken AppSecret ref still resolves cleanly: the
+// auth method is judged before any secret handling, so the stale ref is ignored
+// instead of producing a confusing secret-resolution failure.
+func TestResolveConfigFromMulti_PKJWTSkipsSecretResolution(t *testing.T) {
+	raw := &MultiAppConfig{
+		Apps: []AppConfig{{
+			AppId: "cli_pk",
+			// Stale keychain ref whose ID does not match appId — would trip
+			// ValidateSecretKeyMatch / ResolveSecretInput if it were reached.
+			AppSecret:  SecretInput{Ref: &SecretRef{Source: "keychain", ID: "appsecret:cli_OTHER"}},
+			Brand:      BrandFeishu,
+			AuthMethod: AuthMethodPrivateKeyJWT,
+			KeyRef:     &SecretRef{Source: "tee", ID: "agent-key"},
+			Users:      []AppUser{},
+		}},
+	}
+	cfg, err := ResolveConfigFromMulti(raw, stubKeychain{}, "")
+	if err != nil {
+		t.Fatalf("pkjwt with stale secret ref must skip secret resolution, got %v", err)
+	}
+	if cfg.AuthMethod != AuthMethodPrivateKeyJWT || cfg.KeyLabel != "agent-key" {
+		t.Errorf("got authMethod=%q keyLabel=%q", cfg.AuthMethod, cfg.KeyLabel)
+	}
+}
+
+// TestResolveConfigFromMulti_PKJWTRejectsBadKeyRef ensures the stricter keyRef
+// check (Source=="tee" && ID!="") rejects malformed handles.
+func TestResolveConfigFromMulti_PKJWTRejectsBadKeyRef(t *testing.T) {
+	for i, ref := range []*SecretRef{
+		{Source: "keychain", ID: "x"}, // wrong source
+		{Source: "tee", ID: ""},       // empty id
+	} {
+		raw := &MultiAppConfig{Apps: []AppConfig{{
+			AppId: "cli_pk", Brand: BrandFeishu,
+			AuthMethod: AuthMethodPrivateKeyJWT, KeyRef: ref, Users: []AppUser{},
+		}}}
+		if _, err := ResolveConfigFromMulti(raw, stubKeychain{}, ""); err == nil {
+			t.Errorf("case %d: expected ConfigError for bad keyRef", i)
+		}
+	}
+}
+
 func TestResolveConfigFromMulti_CarriesLang(t *testing.T) {
 	raw := &MultiAppConfig{
 		Apps: []AppConfig{

internal/core/notconfigured.go

@@ -36,13 +36,16 @@ func LoadOrNotConfigured() (*MultiAppConfig, error) {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil, NotConfiguredError()
 		}
-		// Surface the real cause so the user can fix the broken file. Every
-		// non-ENOENT load failure — malformed JSON, permission denied, I/O
-		// error — means a config EXISTS but cannot be used: invalid_config.
-		// Only a genuinely absent config is not_configured; anything else
-		// classified as not_configured would let callers degrade it into
-		// profile_not_found / no_active_profile and hide the real cause.
-		return nil, errs.NewConfigError(errs.SubtypeInvalidConfig, "failed to load config: %v", err).WithCause(err)
+		// Surface the real cause (parse error, permission denied, etc.)
+		// so the user can fix the broken file. A malformed file is
+		// invalid_config; anything else (permission denied, etc.) is
+		// not_configured. Both stay on the typed structured-envelope path
+		// at the root command's error sink.
+		subtype := errs.SubtypeNotConfigured
+		if isMalformedConfigError(err) {
+			subtype = errs.SubtypeInvalidConfig
+		}
+		return nil, errs.NewConfigError(subtype, "failed to load config: %v", err).WithCause(err)
 	}
 	if multi == nil || len(multi.Apps) == 0 {
 		return nil, NotConfiguredError()

internal/core/secret.go

@@ -19,6 +19,12 @@ type SecretRef struct {
 	ID       string `json:"id"`                 // env var name / file path / command / keychain key
 }
 
+// KeylessProviderLarkSuite is the only external private_key_jwt signer route.
+// An absent or empty provider always means the CLI's built-in signer.
+const KeylessProviderLarkSuite = "larksuite.keyless"
+
+const SecretSourceTEE = "tee"
+
 // ---------------------------------------------------------------------------
 // SecretInput — union type: plain string or SecretRef
 // ---------------------------------------------------------------------------

internal/core/types.go

@@ -63,3 +63,10 @@ func ResolveEndpoints(brand LarkBrand) Endpoints {
 func ResolveOpenBaseURL(brand LarkBrand) string {
 	return ResolveEndpoints(brand).Open
 }
+
+// OpenAPIAudience returns the client_assertion `aud` value for the brand: the
+// bare Open API host per the App Authentication JWT spec — "open.feishu.cn" or
+// "open.larksuite.com" — not the full token endpoint URL.
+func OpenAPIAudience(brand LarkBrand) string {
+	return strings.TrimPrefix(ResolveOpenBaseURL(brand), "https://")
+}

internal/core/types_test.go

@@ -91,3 +91,12 @@ func TestResolveEndpoints_NormalizesBrand(t *testing.T) {
 		t.Errorf("ResolveEndpoints(unexpected).Open = %q, want the feishu default", got)
 	}
 }
+
+func TestOpenAPIAudience(t *testing.T) {
+	if got := OpenAPIAudience(BrandFeishu); got != "open.feishu.cn" {
+		t.Errorf("OpenAPIAudience(feishu) = %q, want open.feishu.cn", got)
+	}
+	if got := OpenAPIAudience(BrandLark); got != "open.larksuite.com" {
+		t.Errorf("OpenAPIAudience(lark) = %q, want open.larksuite.com", got)
+	}
+}

internal/credential/authsidecar_contract_test.go

@@ -1,154 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-//go:build authsidecar
-
-package credential_test
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	extcred "github.com/larksuite/cli/extension/credential"
-	sidecarprovider "github.com/larksuite/cli/extension/credential/sidecar"
-	"github.com/larksuite/cli/internal/credential"
-	"github.com/larksuite/cli/internal/envvars"
-	"github.com/larksuite/cli/internal/output"
-	"github.com/larksuite/cli/sidecar"
-)
-
-func newRealSidecarCredentialProvider(t *testing.T) *credential.CredentialProvider {
-	t.Helper()
-	t.Setenv(envvars.CliAuthProxy, "http://127.0.0.1:16384")
-	t.Setenv(envvars.CliProxyKey, "test-key")
-	t.Setenv(envvars.CliAppID, "cli_sidecar")
-	t.Setenv(envvars.CliAppSecret, "")
-	t.Setenv(envvars.CliUserAccessToken, "")
-	t.Setenv(envvars.CliTenantAccessToken, "")
-	t.Setenv(envvars.CliDefaultAs, "")
-	t.Setenv(envvars.CliStrictMode, "")
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	return credential.NewCredentialProvider(
-		[]extcred.Provider{&sidecarprovider.Provider{}},
-		nil,
-		nil,
-		nil,
-	)
-}
-
-func TestAuthSidecarInvalidPolicyUsesValidationContract(t *testing.T) {
-	for _, tt := range []struct {
-		name string
-		key  string
-	}{
-		{name: "default as", key: envvars.CliDefaultAs},
-		{name: "strict mode", key: envvars.CliStrictMode},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			cp := newRealSidecarCredentialProvider(t)
-			t.Setenv(tt.key, "banana")
-
-			_, err := cp.ResolveAccount(context.Background())
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("error = %T %v, want typed validation error", err, err)
-			}
-			if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
-				t.Fatalf("problem = %s/%s, want %s/%s", problem.Category, problem.Subtype, errs.CategoryValidation, errs.SubtypeInvalidArgument)
-			}
-			var validationErr *errs.ValidationError
-			if !errors.As(err, &validationErr) {
-				t.Fatalf("error = %T %v, want ValidationError", err, err)
-			}
-			if validationErr.Param != tt.key {
-				t.Fatalf("param = %q, want %q", validationErr.Param, tt.key)
-			}
-			if got := output.ExitCodeOf(err); got != output.ExitValidation {
-				t.Fatalf("exit code = %d, want %d", got, output.ExitValidation)
-			}
-			if !strings.Contains(problem.Hint, tt.key) {
-				t.Fatalf("hint = %q, want variable name %s", problem.Hint, tt.key)
-			}
-			var blockErr *extcred.BlockError
-			if !errors.As(err, &blockErr) ||
-				blockErr.Code != extcred.BlockReasonInvalidPolicy ||
-				blockErr.Param != tt.key {
-				t.Fatalf("cause = %T %v, want classified BlockError for %s", err, err, tt.key)
-			}
-		})
-	}
-}
-
-func TestAuthSidecarGateProbeUsesValidationContract(t *testing.T) {
-	cp := newRealSidecarCredentialProvider(t)
-	t.Setenv(envvars.CliStrictMode, "banana")
-
-	name, err := cp.ActiveExtensionProviderName(context.Background())
-	if name != "" {
-		t.Fatalf("provider name = %q, want empty on invalid policy", name)
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error = %T %v, want typed validation error", err, err)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("error = %T %v, want ValidationError", err, err)
-	}
-	if problem.Category != errs.CategoryValidation ||
-		problem.Subtype != errs.SubtypeInvalidArgument ||
-		validationErr.Param != envvars.CliStrictMode {
-		t.Fatalf("problem = %+v param = %q, want validation/invalid_argument param %s", problem, validationErr.Param, envvars.CliStrictMode)
-	}
-}
-
-func TestAuthSidecarTokenHonorsSelectedAppID(t *testing.T) {
-	t.Run("matching app returns sentinel", func(t *testing.T) {
-		cp := newRealSidecarCredentialProvider(t)
-
-		result, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
-			Type:  credential.TokenTypeUAT,
-			AppID: "cli_sidecar",
-		})
-		if err != nil {
-			t.Fatalf("ResolveToken: %v", err)
-		}
-		if result == nil || result.Token != sidecar.SentinelUAT {
-			t.Fatalf("result = %+v, want sidecar UAT sentinel", result)
-		}
-	})
-
-	for _, tt := range []struct {
-		name  string
-		appID string
-	}{
-		{name: "empty app id", appID: ""},
-		{name: "conflicting app id", appID: "cli_other"},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			cp := newRealSidecarCredentialProvider(t)
-
-			result, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
-				Type:  credential.TokenTypeUAT,
-				AppID: tt.appID,
-			})
-			if result != nil {
-				t.Fatalf("result = %+v, want no sidecar sentinel", result)
-			}
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("error = %T %v, want typed internal error", err, err)
-			}
-			if problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeUnknown {
-				t.Fatalf("problem = %s/%s, want %s/%s", problem.Category, problem.Subtype, errs.CategoryInternal, errs.SubtypeUnknown)
-			}
-			if strings.Contains(err.Error(), sidecar.SentinelUAT) {
-				t.Fatalf("error leaked sidecar sentinel: %v", err)
-			}
-		})
-	}
-}

internal/credential/credential_provider.go

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

internal/credential/credential_provider_test.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/larksuite/cli/errs"
 	extcred "github.com/larksuite/cli/extension/credential"
 	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/core"
@@ -24,7 +23,6 @@ type mockExtProvider struct {
 	err        error
 	accountErr error
 	tokenErr   error
-	tokenCalls int
 }
 
 func (m *mockExtProvider) Name() string { return m.name }
@@ -35,7 +33,6 @@ func (m *mockExtProvider) ResolveAccount(ctx context.Context) (*extcred.Account,
 	return m.account, m.err
 }
 func (m *mockExtProvider) ResolveToken(ctx context.Context, req extcred.TokenSpec) (*extcred.Token, error) {
-	m.tokenCalls++
 	if m.tokenErr != nil {
 		return nil, m.tokenErr
 	}
@@ -52,13 +49,11 @@ func (m *mockDefaultAcct) ResolveAccount(ctx context.Context) (*Account, error)
 }
 
 type mockDefaultToken struct {
-	result     *TokenResult
-	err        error
-	tokenCalls int
+	result *TokenResult
+	err    error
 }
 
 func (m *mockDefaultToken) ResolveToken(ctx context.Context, req TokenSpec) (*TokenResult, error) {
-	m.tokenCalls++
 	return m.result, m.err
 }
 
@@ -121,45 +116,35 @@ func TestCredentialProvider_AccountCached(t *testing.T) {
 }
 
 func TestCredentialProvider_TokenFromExtension(t *testing.T) {
-	for _, sourceName := range []string{"env", "authsidecar"} {
-		t.Run(sourceName, func(t *testing.T) {
-			cp := NewCredentialProvider(
-				[]extcred.Provider{&mockExtProvider{
-					name:    sourceName,
-					account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-					token:   &extcred.Token{Value: "ext_tok", Source: sourceName},
-				}},
-				&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-				&mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
-			)
-			result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
-			if err != nil {
-				t.Fatal(err)
-			}
-			if result.Token != "ext_tok" {
-				t.Errorf("expected ext_tok, got %s", result.Token)
-			}
-		})
+	cp := NewCredentialProvider(
+		[]extcred.Provider{&mockExtProvider{
+			name:    "env",
+			account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
+			token:   &extcred.Token{Value: "ext_tok", Source: "env"},
+		}},
+		&mockDefaultAcct{}, &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
+	)
+	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Token != "ext_tok" {
+		t.Errorf("expected ext_tok, got %s", result.Token)
 	}
 }
 
 func TestCredentialProvider_TokenFallsToDefault(t *testing.T) {
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
 	cp := NewCredentialProvider(
 		[]extcred.Provider{&mockExtProvider{name: "skip"}},
-		&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-		defaultToken, nil,
+		&mockDefaultAcct{}, &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}, nil,
 	)
-	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err != nil {
 		t.Fatal(err)
 	}
 	if result.Token != "default_tok" {
 		t.Errorf("expected default_tok, got %s", result.Token)
 	}
-	if defaultToken.tokenCalls != 1 {
-		t.Fatalf("default ResolveToken() calls = %d, want 1", defaultToken.tokenCalls)
-	}
 }
 
 func TestCredentialProvider_TokenDoesNotMixSourcesAfterDefaultAccountSelection(t *testing.T) {
@@ -174,7 +159,7 @@ func TestCredentialProvider_TokenDoesNotMixSourcesAfterDefaultAccountSelection(t
 		t.Fatalf("ResolveAccount() error = %v", err)
 	}
 
-	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err != nil {
 		t.Fatalf("ResolveToken() error = %v", err)
 	}
@@ -196,7 +181,7 @@ func TestCredentialProvider_SelectedSourceWithoutTokenReturnsUnavailableError(t
 		t.Fatalf("ResolveAccount() error = %v", err)
 	}
 
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil {
 		t.Fatal("ResolveToken() error = nil, want unavailable error")
 	}
@@ -217,7 +202,7 @@ func TestCredentialProvider_ResolveTokenPropagatesNonBlockExtensionError(t *test
 		nil,
 	)
 
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil || err.Error() != "provider exploded" {
 		t.Fatalf("ResolveToken() error = %v, want provider exploded", err)
 	}
@@ -327,12 +312,12 @@ func TestCredentialProvider_ResolveIdentityHint_CachesResult(t *testing.T) {
 func TestCredentialProvider_ResolveTokenTreatsEmptyDefaultTokenAsMalformed(t *testing.T) {
 	cp := NewCredentialProvider(
 		nil,
-		&mockDefaultAcct{account: &Account{AppID: "default_app"}},
+		nil,
 		&mockDefaultToken{result: &TokenResult{Token: ""}},
 		nil,
 	)
 
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil || !strings.Contains(err.Error(), "empty token") {
 		t.Fatalf("ResolveToken() error = %v, want malformed empty token error", err)
 	}
@@ -425,189 +410,17 @@ func TestCredentialProvider_ResolveAccountWarnsWhenExtensionIdentityVerification
 }
 
 func TestCredentialProvider_ResolveTokenDoesNotBypassFailedDefaultAccountResolution(t *testing.T) {
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
 	cp := NewCredentialProvider(
 		nil,
 		&mockDefaultAcct{err: errors.New("config unavailable")},
-		defaultToken,
+		&mockDefaultToken{result: &TokenResult{Token: "default_tok"}},
 		nil,
 	)
 
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "default_app"})
+	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT})
 	if err == nil || err.Error() != "config unavailable" {
 		t.Fatalf("ResolveToken() error = %v, want config unavailable", err)
 	}
-	if defaultToken.tokenCalls != 0 {
-		t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsUnboundAppBeforeExtensionIO(t *testing.T) {
-	tests := []struct {
-		name  string
-		appID string
-	}{
-		{name: "empty app id"},
-		{name: "different app id", appID: "other_app"},
-	}
-
-	for _, tt := range tests {
-		for _, sourceName := range []string{"env", "authsidecar"} {
-			t.Run(tt.name+"/"+sourceName, func(t *testing.T) {
-				provider := &mockExtProvider{
-					name:    sourceName,
-					account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-					token:   &extcred.Token{Value: "ext_tok", Source: sourceName},
-				}
-				httpClientCalls := 0
-				cp := NewCredentialProvider(
-					[]extcred.Provider{provider},
-					&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-					&mockDefaultToken{result: &TokenResult{Token: "default_tok"}},
-					func() (*http.Client, error) {
-						httpClientCalls++
-						return nil, errors.New("unexpected user_info call")
-					},
-				)
-
-				_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: tt.appID})
-				if err == nil {
-					t.Fatal("ResolveToken() error = nil, want app binding error")
-				}
-				assertInternalUnknownWithRetryHint(t, err)
-				if provider.tokenCalls != 0 {
-					t.Fatalf("extension ResolveToken() calls = %d, want 0", provider.tokenCalls)
-				}
-				if httpClientCalls != 0 {
-					t.Fatalf("httpClient() calls = %d, want 0", httpClientCalls)
-				}
-			})
-		}
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsUnboundAppBeforeDefaultIO(t *testing.T) {
-	tests := []struct {
-		name  string
-		appID string
-	}{
-		{name: "empty app id"},
-		{name: "different app id", appID: "other_app"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
-			cp := NewCredentialProvider(
-				nil,
-				&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-				defaultToken,
-				nil,
-			)
-
-			_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: tt.appID})
-			if err == nil {
-				t.Fatal("ResolveToken() error = nil, want app binding error")
-			}
-			assertInternalUnknownWithRetryHint(t, err)
-			if defaultToken.tokenCalls != 0 {
-				t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-			}
-		})
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsNilAccountBeforeTokenIO(t *testing.T) {
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
-	cp := NewCredentialProvider(
-		nil,
-		&mockDefaultAcct{},
-		defaultToken,
-		nil,
-	)
-
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "requested_app"})
-	if err == nil {
-		t.Fatal("ResolveToken() error = nil, want nil account error")
-	}
-	assertInternalUnknownWithRetryHint(t, err)
-	if defaultToken.tokenCalls != 0 {
-		t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-	}
-}
-
-func TestCredentialProvider_ResolveTokenRejectsMissingSelectedSourceWithoutFallback(t *testing.T) {
-	extension := &mockExtProvider{
-		name:  "env",
-		token: &extcred.Token{Value: "ext_tok", Source: "env"},
-	}
-	defaultToken := &mockDefaultToken{result: &TokenResult{Token: "default_tok"}}
-	cp := NewCredentialProvider(
-		[]extcred.Provider{extension},
-		&mockDefaultAcct{account: &Account{AppID: "default_app"}},
-		defaultToken,
-		nil,
-	)
-	cp.account = &Account{AppID: "selected_app"}
-	cp.accountOnce.Do(func() {})
-
-	_, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "selected_app"})
-	if err == nil {
-		t.Fatal("ResolveToken() error = nil, want missing selected source error")
-	}
-	assertInternalUnknownWithRetryHint(t, err)
-	if extension.tokenCalls != 0 {
-		t.Fatalf("extension ResolveToken() calls = %d, want 0", extension.tokenCalls)
-	}
-	if defaultToken.tokenCalls != 0 {
-		t.Fatalf("default ResolveToken() calls = %d, want 0", defaultToken.tokenCalls)
-	}
-}
-
-func TestCredentialProvider_ResolveTokenMatchingExtensionDoesNotEnrichIdentity(t *testing.T) {
-	provider := &mockExtProvider{
-		name:    "env",
-		account: &extcred.Account{AppID: "ext_app", Brand: "feishu"},
-		token:   &extcred.Token{Value: "ext_tok", Source: "env"},
-	}
-	httpClientCalls := 0
-	cp := NewCredentialProvider(
-		[]extcred.Provider{provider},
-		nil,
-		nil,
-		func() (*http.Client, error) {
-			httpClientCalls++
-			return nil, errors.New("unexpected user_info call")
-		},
-	)
-
-	result, err := cp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "ext_app"})
-	if err != nil {
-		t.Fatalf("ResolveToken() error = %v", err)
-	}
-	if result.Token != "ext_tok" {
-		t.Fatalf("ResolveToken() token = %q, want %q", result.Token, "ext_tok")
-	}
-	if provider.tokenCalls != 1 {
-		t.Fatalf("extension ResolveToken() calls = %d, want 1", provider.tokenCalls)
-	}
-	if httpClientCalls != 0 {
-		t.Fatalf("httpClient() calls = %d, want 0", httpClientCalls)
-	}
-}
-
-func assertInternalUnknownWithRetryHint(t *testing.T, err error) {
-	t.Helper()
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error type = %T, want typed internal error", err)
-	}
-	if problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeUnknown {
-		t.Fatalf("error problem = %+v, want internal/unknown", problem)
-	}
-	if problem.Hint != "retry the command." {
-		t.Fatalf("error hint = %q, want retry hint", problem.Hint)
-	}
 }
 
 func TestActiveExtensionProviderName_ExtActive(t *testing.T) {

internal/credential/decide_test.go

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

internal/credential/default_provider.go

@@ -17,6 +17,7 @@ import (
 	"github.com/larksuite/cli/internal/keychain"
 
 	extcred "github.com/larksuite/cli/extension/credential"
+	"github.com/larksuite/cli/internal/keysigner"
 )
 
 // classifyTATResponseCode wraps a deterministic (non-transient) failure from the
@@ -74,13 +75,9 @@ func NewDefaultAccountProvider(kc func() keychain.KeychainAccess, profile string
 
 func (p *DefaultAccountProvider) ResolveAccount(ctx context.Context) (*Account, error) {
 	// Load config once — used for both credentials and strict mode.
-	// LoadOrNotConfigured distinguishes an absent config (→ not_configured)
-	// from a malformed/unreadable one (→ invalid_config with cause), so a
-	// broken config is never masked as "run config init" — matching the
-	// explicit-profile path in doResolveAccount.
-	multi, err := core.LoadOrNotConfigured()
+	multi, err := core.LoadMultiAppConfig()
 	if err != nil {
-		return nil, err
+		return nil, core.NotConfiguredError()
 	}
 
 	cfg, err := core.ResolveConfigFromMulti(multi, p.keychain(), p.profile)
@@ -120,7 +117,6 @@ type DefaultTokenProvider struct {
 
 	tatOnce   sync.Once
 	tatResult *TokenResult
-	tatAppID  string
 	tatErr    error
 }
 
@@ -131,42 +127,21 @@ func NewDefaultTokenProvider(defaultAcct *DefaultAccountProvider, httpClient fun
 func (p *DefaultTokenProvider) ResolveToken(ctx context.Context, req TokenSpec) (*TokenResult, error) {
 	switch req.Type {
 	case TokenTypeUAT:
-		return p.resolveUAT(ctx, req)
+		return p.resolveUAT(ctx)
 	case TokenTypeTAT:
-		return p.resolveTAT(ctx, req)
+		return p.resolveTAT(ctx)
 	default:
 		return nil, fmt.Errorf("unsupported token type: %s", req.Type)
 	}
 }
 
-// checkTokenAppID refuses to hand out a token for a different app than the
-// caller resolved. The token provider re-reads the config, so a concurrent
-// profile edit between account resolution and token resolution could otherwise
-// cross tokens between apps. TokenSpec.AppID is REQUIRED here: an empty value
-// would silently disable the guarantee, so it is rejected rather than skipped.
-func checkTokenAppID(req TokenSpec, resolvedAppID string) error {
-	if req.AppID == "" {
-		return errs.NewInternalError(errs.SubtypeUnknown,
-			"TokenSpec.AppID is required for %s token resolution", req.Type)
-	}
-	if req.AppID == resolvedAppID {
-		return nil
-	}
-	return errs.NewInternalError(errs.SubtypeUnknown,
-		"config changed during resolution: token requested for app %q but the saved profile now resolves to a different app", req.AppID).
-		WithHint("retry the command.")
-}
-
 // resolveUAT resolves a user access token. Not cached (unlike TAT) because UAT
 // may be refreshed between calls and GetValidAccessToken handles its own caching.
-func (p *DefaultTokenProvider) resolveUAT(ctx context.Context, req TokenSpec) (*TokenResult, error) {
+func (p *DefaultTokenProvider) resolveUAT(ctx context.Context) (*TokenResult, error) {
 	acct, err := p.defaultAcct.ResolveAccount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if err := checkTokenAppID(req, acct.AppID); err != nil {
-		return nil, err
-	}
 	httpClient, err := p.httpClient()
 	if err != nil {
 		return nil, err
@@ -183,40 +158,36 @@ func (p *DefaultTokenProvider) resolveUAT(ctx context.Context, req TokenSpec) (*
 	return &TokenResult{Token: token, Scopes: scopes}, nil
 }
 
-// resolveTAT resolves a tenant access token. The result is cached after the
-// first mint via sync.Once — only the context from that call is used.
-//
-// The account is resolved and checked against the request BEFORE any token
-// work: a mismatched request must not trigger a token mint (network call,
-// quota, audit trail) for the wrong app. The cached result is additionally
-// re-checked on every hit, so a token minted for one app is never served to
-// a request that resolved another.
-func (p *DefaultTokenProvider) resolveTAT(ctx context.Context, req TokenSpec) (*TokenResult, error) {
+// resolveTAT resolves a tenant access token. The result is cached after the first
+// call via sync.Once — only the context from the first call is used.
+func (p *DefaultTokenProvider) resolveTAT(ctx context.Context) (*TokenResult, error) {
+	p.tatOnce.Do(func() {
+		p.tatResult, p.tatErr = p.doResolveTAT(ctx)
+	})
+	return p.tatResult, p.tatErr
+}
+
+func (p *DefaultTokenProvider) doResolveTAT(ctx context.Context) (*TokenResult, error) {
 	acct, err := p.defaultAcct.ResolveAccount(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if err := checkTokenAppID(req, acct.AppID); err != nil {
-		return nil, err
-	}
-	p.tatOnce.Do(func() {
-		p.tatResult, p.tatErr = p.doResolveTAT(ctx, acct)
-		p.tatAppID = acct.AppID
-	})
-	if p.tatErr != nil {
-		return nil, p.tatErr
-	}
-	if err := checkTokenAppID(req, p.tatAppID); err != nil {
-		return nil, err
-	}
-	return p.tatResult, nil
-}
-
-func (p *DefaultTokenProvider) doResolveTAT(ctx context.Context, acct *Account) (*TokenResult, error) {
 	httpClient, err := p.httpClient()
 	if err != nil {
 		return nil, err
 	}
+
+	// private_key_jwt apps have no app secret: mint via the jwt-bearer grant
+	// using a TEE-signed client_assertion instead.
+	if acct.AuthMethod == core.AuthMethodPrivateKeyJWT {
+		signer := keysigner.Active()
+		token, err := FetchTATWithAssertionForProvider(ctx, httpClient, acct.Brand, acct.AppID, signer, acct.KeyProvider, acct.KeyLabel)
+		if err != nil {
+			return nil, err
+		}
+		return &TokenResult{Token: token}, nil
+	}
+
 	token, err := FetchTAT(ctx, httpClient, acct.Brand, acct.AppID, acct.AppSecret)
 	if err != nil {
 		return nil, err

internal/credential/default_provider_test.go

@@ -4,15 +4,10 @@
 package credential
 
 import (
-	"context"
 	"errors"
-	"io"
-	"net/http"
-	"strings"
 	"testing"
 
 	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/core"
 )
 
 func TestDefaultTokenProvider_Dispatches(t *testing.T) {
@@ -97,136 +92,3 @@ func TestClassifyTATResponseCode_CodeZeroOtherError_StillTyped(t *testing.T) {
 		t.Fatalf("code-0 invalid_scope must not be a ConfigError, got %T", err)
 	}
 }
-
-func TestCheckTokenAppID(t *testing.T) {
-	if err := checkTokenAppID(TokenSpec{Type: TokenTypeUAT}, "cli_a"); err == nil {
-		t.Fatal("empty requested app must be rejected: it would silently disable the guarantee")
-	}
-	if err := checkTokenAppID(TokenSpec{AppID: "cli_a"}, "cli_a"); err != nil {
-		t.Fatalf("matching app must pass: %v", err)
-	}
-	err := checkTokenAppID(TokenSpec{AppID: "cli_a"}, "cli_b")
-	if err == nil {
-		t.Fatal("mismatched app must be refused")
-	}
-	var ie *errs.InternalError
-	if !errors.As(err, &ie) {
-		t.Fatalf("error type = %T, want *errs.InternalError", err)
-	}
-}
-
-// REAL-path regression for review F2: the token provider re-reads the config,
-// so a profile edit between account resolution and token resolution must not
-// hand a token minted for the new app to a caller that resolved the old one.
-// Uses the real DefaultAccountProvider + DefaultTokenProvider; the HTTP stub
-// makes the network step unreachable, so reaching it proves the app check ran
-// and passed first.
-func TestDefaultTokenProvider_RefusesTokenAfterConfigSwap(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	writeCfg := func(appID string) {
-		t.Helper()
-		multi := &core.MultiAppConfig{CurrentApp: "tenant_a", Apps: []core.AppConfig{{
-			Name: "tenant_a", AppId: appID, AppSecret: core.PlainSecret("your-secret"), Brand: core.BrandFeishu,
-		}}}
-		if err := core.SaveMultiAppConfig(multi); err != nil {
-			t.Fatalf("SaveMultiAppConfig: %v", err)
-		}
-	}
-	writeCfg("cli_a")
-
-	httpSentinel := errors.New("http client sentinel: unreachable in test")
-	tp := NewDefaultTokenProvider(
-		NewDefaultAccountProvider(nil, "tenant_a"),
-		func() (*http.Client, error) { return nil, httpSentinel },
-		nil,
-	)
-
-	// Matching app: the consistency check passes and resolution proceeds to
-	// the (stubbed) HTTP step.
-	_, err := tp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "cli_a"})
-	if !errors.Is(err, httpSentinel) {
-		t.Fatalf("err = %v, want the HTTP sentinel (check must pass for a matching app)", err)
-	}
-
-	// The profile now resolves to a different app: the token request that was
-	// arbitrated for cli_a must be refused before any token work happens.
-	writeCfg("cli_b")
-	_, err = tp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeUAT, AppID: "cli_a"})
-	if err == nil || !strings.Contains(err.Error(), "config changed during resolution") {
-		t.Fatalf("err = %v, want config-changed refusal", err)
-	}
-}
-
-// F1 regression: a TAT request for a mismatched app must be refused BEFORE
-// any token work starts — no HTTP client construction, no mint, no cache —
-// otherwise the CLI mints (and caches) a token for the wrong app and only
-// then refuses to return it, leaving auth audit/quota side effects behind.
-func TestDefaultTokenProvider_TATChecksAppBeforeAnyTokenWork(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{CurrentApp: "tenant_a", Apps: []core.AppConfig{{
-		Name: "tenant_a", AppId: "cli_b", AppSecret: core.PlainSecret("your-secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	httpCalled := false
-	tp := NewDefaultTokenProvider(
-		NewDefaultAccountProvider(nil, "tenant_a"),
-		func() (*http.Client, error) { httpCalled = true; return nil, errors.New("http sentinel") },
-		nil,
-	)
-
-	// The profile resolves to cli_b, but the caller arbitrated cli_a.
-	_, err := tp.ResolveToken(context.Background(), TokenSpec{Type: TokenTypeTAT, AppID: "cli_a"})
-	if err == nil || !strings.Contains(err.Error(), "config changed during resolution") {
-		t.Fatalf("err = %v, want config-changed refusal", err)
-	}
-	if httpCalled {
-		t.Fatal("token work started for a mismatched app: the check must run before any HTTP client is built")
-	}
-}
-
-// countingTATTripper serves a canned successful TAT response and counts calls.
-type countingTATTripper struct{ calls int }
-
-func (c *countingTATTripper) RoundTrip(*http.Request) (*http.Response, error) {
-	c.calls++
-	return &http.Response{
-		StatusCode: http.StatusOK,
-		Body:       io.NopCloser(strings.NewReader(`{"code":0,"access_token":"your-access-token"}`)),
-		Header:     http.Header{"Content-Type": []string{"application/json"}},
-	}, nil
-}
-
-// TAT happy path: the first request mints the token over HTTP, the second is
-// served from the sync.Once cache without another HTTP call.
-func TestDefaultTokenProvider_TATSuccessAndCacheHit(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	multi := &core.MultiAppConfig{CurrentApp: "tenant_a", Apps: []core.AppConfig{{
-		Name: "tenant_a", AppId: "cli_a", AppSecret: core.PlainSecret("your-secret"), Brand: core.BrandFeishu,
-	}}}
-	if err := core.SaveMultiAppConfig(multi); err != nil {
-		t.Fatalf("SaveMultiAppConfig: %v", err)
-	}
-
-	tripper := &countingTATTripper{}
-	tp := NewDefaultTokenProvider(
-		NewDefaultAccountProvider(nil, "tenant_a"),
-		func() (*http.Client, error) { return &http.Client{Transport: tripper}, nil },
-		nil,
-	)
-
-	req := TokenSpec{Type: TokenTypeTAT, AppID: "cli_a"}
-	first, err := tp.ResolveToken(context.Background(), req)
-	if err != nil || first.Token != "your-access-token" {
-		t.Fatalf("first resolve = %+v, %v; want minted token", first, err)
-	}
-	second, err := tp.ResolveToken(context.Background(), req)
-	if err != nil || second.Token != "your-access-token" {
-		t.Fatalf("second resolve = %+v, %v; want cached token", second, err)
-	}
-	if tripper.calls != 1 {
-		t.Fatalf("HTTP calls = %d, want exactly 1 (second resolve must hit the cache)", tripper.calls)
-	}
-}

internal/credential/identity_selection.go

@@ -1,54 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package credential
-
-// CredentialSourceKind is the wire-stable App/credential selection source.
-type CredentialSourceKind string
-
-const (
-	SourceFlagProfile      CredentialSourceKind = "flag:--profile"
-	SourceEnvProfile       CredentialSourceKind = "env:LARKSUITE_CLI_PROFILE"
-	SourceEnvAppID         CredentialSourceKind = "env:LARKSUITE_CLI_APP_ID"
-	SourceConfigCurrentApp CredentialSourceKind = "config:currentApp"
-	SourceConfigFirstApp   CredentialSourceKind = "config:firstApp"
-
-	// SourceExtensionPrefix prefixes the name of a managed extension provider
-	// that won selection outright (e.g. "extension:sidecar"). With it, an
-	// empty Source is left with exactly one meaning: not resolved.
-	SourceExtensionPrefix CredentialSourceKind = "extension:"
-)
-
-// SourceExtension reports the selection source for a managed extension
-// provider by name.
-func SourceExtension(name string) CredentialSourceKind {
-	return SourceExtensionPrefix + CredentialSourceKind(name)
-}
-
-// DirectCredentialEnv describes the state of direct app credential env vars.
-// It never carries a secret value — only names and the non-sensitive app_id.
-type DirectCredentialEnv struct {
-	Present              bool     `json:"present"`
-	Keys                 []string `json:"keys,omitempty"`
-	AppID                string   `json:"appId,omitempty"`
-	Matched              bool     `json:"matched,omitempty"`
-	ConflictsWithProfile bool     `json:"conflictsWithProfile,omitempty"`
-}
-
-// IdentitySelection is the explainable result of credential selection.
-// It carries NO secret value.
-type IdentitySelection struct {
-	Source              CredentialSourceKind
-	DirectCredentialEnv DirectCredentialEnv
-}
-
-// Explicit reports whether the identity was actively specified by the
-// user/agent (flag or env), which governs no-fallback behavior.
-func (s IdentitySelection) Explicit() bool {
-	switch s.Source {
-	case SourceFlagProfile, SourceEnvProfile, SourceEnvAppID:
-		return true
-	default:
-		return false
-	}
-}

internal/credential/identity_selection_test.go

@@ -1,25 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package credential
-
-import "testing"
-
-func TestIdentitySelectionExplicit(t *testing.T) {
-	cases := []struct {
-		src      CredentialSourceKind
-		explicit bool
-	}{
-		{SourceFlagProfile, true},
-		{SourceEnvProfile, true},
-		{SourceEnvAppID, true},
-		{SourceConfigCurrentApp, false},
-		{SourceConfigFirstApp, false},
-	}
-	for _, c := range cases {
-		sel := IdentitySelection{Source: c.src}
-		if sel.Explicit() != c.explicit {
-			t.Errorf("source %q: Explicit()=%v want %v", c.src, sel.Explicit(), c.explicit)
-		}
-	}
-}

internal/credential/integration_test.go

@@ -52,24 +52,6 @@ func TestFullChain_EnvWins(t *testing.T) {
 	}
 }
 
-func TestFullChain_EnvRejectsDifferentApp(t *testing.T) {
-	t.Setenv(envvars.CliAppID, "env_app")
-	t.Setenv(envvars.CliAppSecret, "env_secret")
-	t.Setenv(envvars.CliUserAccessToken, "env_uat")
-
-	cp := credential.NewCredentialProvider(
-		[]extcred.Provider{&envprovider.Provider{}},
-		nil, nil, nil,
-	)
-
-	_, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
-		Type: credential.TokenTypeUAT, AppID: "other_app",
-	})
-	if err == nil {
-		t.Fatal("ResolveToken() error = nil, want app binding error")
-	}
-}
-
 func TestFullChain_Fallthrough(t *testing.T) {
 	// env provider returns nil (no env vars set), falls through to default token
 	ep := &envprovider.Provider{}
@@ -77,8 +59,7 @@ func TestFullChain_Fallthrough(t *testing.T) {
 
 	cp := credential.NewCredentialProvider(
 		[]extcred.Provider{ep},
-		&mockDefaultAccountProvider{account: &credential.Account{AppID: "app1"}},
-		mock, nil,
+		nil, mock, nil,
 	)
 	result, err := cp.ResolveToken(context.Background(), credential.TokenSpec{
 		Type: credential.TokenTypeUAT, AppID: "app1",
@@ -91,14 +72,6 @@ func TestFullChain_Fallthrough(t *testing.T) {
 	}
 }
 
-type mockDefaultAccountProvider struct {
-	account *credential.Account
-}
-
-func (m *mockDefaultAccountProvider) ResolveAccount(context.Context) (*credential.Account, error) {
-	return m.account, nil
-}
-
 type mockDefaultTokenProvider struct {
 	token  string
 	scopes string

internal/credential/tat_fetch.go

@@ -12,7 +12,12 @@ import (
 	"net/url"
 	"strings"
 
+	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/auth"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keylesshelper"
+	"github.com/larksuite/cli/internal/keylessprovider"
+	"github.com/larksuite/cli/internal/keysigner"
 )
 
 // FetchTAT performs a single HTTP POST to mint a tenant access token via the
@@ -100,3 +105,120 @@ func FetchTAT(ctx context.Context, httpClient *http.Client, brand core.LarkBrand
 	}
 	return "", classifyTATResponseCode(result.Code, result.Error, desc, string(brand), appID)
 }
+
+// FetchTATWithAssertion mints a tenant access token for a private_key_jwt app via
+// the RFC 7523 jwt-bearer grant: it signs a short-lived client_assertion with the
+// TEE-held key and posts it to the unified OAuth token endpoint, replacing the
+// app_secret entirely.
+//
+// The unified v2 token endpoint returns the minted token as access_token
+// (tenant_access_token is accepted as a fallback).
+func FetchTATWithAssertion(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, clientID string, signer keysigner.Signer, keyLabel string) (string, error) {
+	return FetchTATWithAssertionForProvider(ctx, httpClient, brand, clientID, signer, "", keyLabel)
+}
+
+// FetchTATWithAssertionForProvider routes one app authentication by its
+// persisted keyRef.provider. Empty is the stable built-in signer route;
+// larksuite.keyless is resolved afresh for this operation; all other values
+// fail closed in keylessprovider.Resolve.
+func FetchTATWithAssertionForProvider(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, clientID string, signer keysigner.Signer, provider, keyLabel string) (string, error) {
+	var helper *keylesshelper.Command
+	var err error
+	if strings.TrimSpace(provider) != "" {
+		helper, err = keylessprovider.Resolve(ctx, provider)
+		if err != nil {
+			return "", err
+		}
+	}
+	return FetchTATWithAssertionWithHelper(ctx, httpClient, brand, clientID, signer, helper, keyLabel)
+}
+
+// FetchTATWithAssertionWithHelper is the single-resolution variant used when
+// the caller must make a preflight decision from the same helper snapshot.
+func FetchTATWithAssertionWithHelper(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, clientID string, signer keysigner.Signer, helper *keylesshelper.Command, keyLabel string) (string, error) {
+	if signer == nil && helper == nil {
+		return "", errs.NewConfigError(errs.SubtypeInvalidClient,
+			"profile uses private_key_jwt but no TEE key signer is available on this build").
+			WithHint("install a build with the platform key-signer extension, configure an external keyless signer, or reconfigure the app to use an app secret")
+	}
+	ep := core.ResolveEndpoints(brand)
+	endpoint := ep.Open + auth.PathOAuthTokenV2
+
+	assertionType, assertion, err := auth.SignClientAssertion(ctx, signer, helper, keyLabel, clientID, core.OpenAPIAudience(brand))
+	if err != nil {
+		return "", err
+	}
+
+	form := url.Values{}
+	form.Set("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer")
+	form.Set("client_id", clientID)
+	form.Set("client_assertion_type", assertionType)
+	form.Set("client_assertion", assertion)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, strings.NewReader(form.Encode()))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return "", fmt.Errorf("read token response: %w", err)
+	}
+
+	var result struct {
+		Code              int    `json:"code"`
+		Msg               string `json:"msg"`
+		Error             string `json:"error"`
+		ErrorDescription  string `json:"error_description"`
+		AccessToken       string `json:"access_token"`
+		TenantAccessToken string `json:"tenant_access_token"`
+	}
+	_ = json.Unmarshal(body, &result) // best-effort; error body may not be JSON
+
+	token := result.AccessToken
+	if token == "" {
+		token = result.TenantAccessToken
+	}
+	if resp.StatusCode == http.StatusOK && token != "" && result.Error == "" && result.Code == 0 {
+		return token, nil
+	}
+
+	// Surface the server's reason, preferring the OAuth `error` code (e.g.
+	// unauthorized_client) which is more diagnostic than the description alone.
+	detail := result.ErrorDescription
+	if detail == "" {
+		detail = result.Msg
+	}
+	if detail == "" {
+		detail = strings.TrimSpace(string(body))
+	}
+	if result.Error != "" {
+		return "", classifyAssertionError(result.Error, resp.StatusCode, detail)
+	}
+	return "", fmt.Errorf("token endpoint HTTP %d (code=%d): %s", resp.StatusCode, result.Code, detail)
+}
+
+// classifyAssertionError maps the OAuth token endpoint's `error` field to a
+// typed or untyped error. Only deterministic client-credential rejections get a
+// typed errs.ConfigError (so runProbePKJWT can tell "this key is not bound to
+// this app" apart from upstream noise); every other error (e.g.
+// temporarily_unavailable) stays untyped and is swallowed by the probe. detail
+// carries only the server's error_description / msg / body text — it never
+// echoes the client_assertion or private key (the assertion lives only in the
+// request form).
+func classifyAssertionError(oauthError string, httpStatus int, detail string) error {
+	switch oauthError {
+	case "invalid_client", "unauthorized_client", "invalid_grant":
+		return errs.NewConfigError(errs.SubtypeInvalidClient,
+			"token endpoint rejected the key (%s): %s", oauthError, detail)
+	default:
+		return fmt.Errorf("token endpoint HTTP %d (%s): %s", httpStatus, oauthError, detail)
+	}
+}

internal/credential/tat_fetch_test.go

@@ -5,15 +5,22 @@ package credential
 
 import (
 	"context"
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/sha256"
 	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"strings"
 	"testing"
 
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/core"
+	"github.com/larksuite/cli/internal/keysigner"
 )
 
 // stubRoundTripper lets us assert request shape and return canned responses.
@@ -307,3 +314,141 @@ func (r *urlRewriteRT) RoundTrip(req *http.Request) (*http.Response, error) {
 	req2.Header = req.Header
 	return http.DefaultTransport.RoundTrip(req2)
 }
+
+// fakeTATSigner is a real in-memory ECDSA P-256 signer for assertion tests.
+type fakeTATSigner struct{ key *ecdsa.PrivateKey }
+
+func newFakeTATSigner(t *testing.T) *fakeTATSigner {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &fakeTATSigner{key: k}
+}
+
+func (f *fakeTATSigner) EnsureKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return f.key.Public(), nil
+}
+func (f *fakeTATSigner) PublicKey(context.Context, keysigner.KeyRef) (crypto.PublicKey, error) {
+	return f.key.Public(), nil
+}
+func (f *fakeTATSigner) Sign(_ context.Context, _ keysigner.KeyRef, in []byte) ([]byte, string, error) {
+	h := sha256.Sum256(in)
+	r, s, err := ecdsa.Sign(rand.Reader, f.key, h[:])
+	if err != nil {
+		return nil, "", err
+	}
+	sig := make([]byte, 64)
+	r.FillBytes(sig[:32])
+	s.FillBytes(sig[32:])
+	return sig, keysigner.AlgES256, nil
+}
+
+func TestFetchTATWithAssertion_Success(t *testing.T) {
+	rt := &stubRoundTripper{respCode: 200, respBody: `{"access_token":"test-token","token_type":"Bearer","expires_in":7200}`}
+	hc := &http.Client{Transport: rt}
+
+	token, err := FetchTATWithAssertion(context.Background(), hc, core.BrandFeishu, "cli_app", newFakeTATSigner(t), "agent-key")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if token != "test-token" {
+		t.Errorf("token = %q, want test-token", token)
+	}
+	if rt.gotReq.URL.String() != "https://open.feishu.cn/open-apis/authen/v2/oauth/token" {
+		t.Errorf("url = %s", rt.gotReq.URL.String())
+	}
+
+	form, err := url.ParseQuery(rt.gotBody)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if form.Get("grant_type") != "urn:ietf:params:oauth:grant-type:jwt-bearer" {
+		t.Errorf("grant_type = %q", form.Get("grant_type"))
+	}
+	if form.Get("client_assertion_type") != "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" {
+		t.Errorf("client_assertion_type = %q", form.Get("client_assertion_type"))
+	}
+	if form.Get("client_assertion") == "" {
+		t.Error("client_assertion is empty")
+	}
+	if form.Has("client_secret") {
+		t.Error("client_secret must NOT be sent for private_key_jwt")
+	}
+	if form.Get("client_id") != "cli_app" {
+		t.Errorf("client_id = %q", form.Get("client_id"))
+	}
+}
+
+func TestFetchTATWithAssertion_NilSigner(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	hc := &http.Client{Transport: &stubRoundTripper{respCode: 200, respBody: `{}`}}
+	if _, err := FetchTATWithAssertion(context.Background(), hc, core.BrandFeishu, "cli_app", nil, "k"); err == nil {
+		t.Fatal("expected error when signer is nil")
+	}
+}
+
+func TestFetchTATWithAssertion_ServerError(t *testing.T) {
+	rt := &stubRoundTripper{respCode: 200, respBody: `{"error":"invalid_client","error_description":"unknown key"}`}
+	hc := &http.Client{Transport: rt}
+	if _, err := FetchTATWithAssertion(context.Background(), hc, core.BrandFeishu, "cli_app", newFakeTATSigner(t), "k"); err == nil {
+		t.Fatal("expected error for invalid_client response")
+	}
+}
+
+func TestFetchTATWithAssertion_LimitsErrorBody(t *testing.T) {
+	rt := &stubRoundTripper{respCode: 502, respBody: strings.Repeat("x", 2<<20)}
+	hc := &http.Client{Transport: rt}
+
+	_, err := FetchTATWithAssertion(context.Background(), hc, core.BrandFeishu, "cli_app", newFakeTATSigner(t), "k")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if len(err.Error()) > (1<<20)+512 {
+		t.Fatalf("error length = %d, want bounded", len(err.Error()))
+	}
+}
+
+// Deterministic OAuth client rejections must be typed (ConfigError /
+// SubtypeInvalidClient) so runProbePKJWT can tell "the key is not bound to this
+// app" apart from transport noise.
+func TestFetchTATWithAssertion_DeterministicReject_Typed(t *testing.T) {
+	for _, oauthErr := range []string{"invalid_client", "unauthorized_client", "invalid_grant"} {
+		rt := &stubRoundTripper{respCode: 401, respBody: `{"error":"` + oauthErr + `","error_description":"bad key"}`}
+		hc := &http.Client{Transport: rt}
+		_, err := FetchTATWithAssertion(context.Background(), hc, core.BrandFeishu, "cli_app", newFakeTATSigner(t), "k")
+		if err == nil {
+			t.Fatalf("%s: expected error", oauthErr)
+		}
+		if !errs.IsTyped(err) {
+			t.Errorf("%s: must be typed, got %T", oauthErr, err)
+		}
+		var cfgErr *errs.ConfigError
+		if !errors.As(err, &cfgErr) || cfgErr.Subtype != errs.SubtypeInvalidClient {
+			t.Errorf("%s: want ConfigError/InvalidClient, got %T %v", oauthErr, err, err)
+		}
+	}
+}
+
+// Unrecognized OAuth errors and non-payload noise stay UNTYPED so the probe
+// treats them as upstream noise and stays silent.
+func TestFetchTATWithAssertion_AmbiguousError_Untyped(t *testing.T) {
+	cases := []string{
+		`{"error":"temporarily_unavailable","error_description":"retry"}`,
+		`{"code":99999,"msg":"weird"}`,
+		`not json`,
+	}
+	for _, body := range cases {
+		rt := &stubRoundTripper{respCode: 503, respBody: body}
+		hc := &http.Client{Transport: rt}
+		_, err := FetchTATWithAssertion(context.Background(), hc, core.BrandFeishu, "cli_app", newFakeTATSigner(t), "k")
+		if err == nil {
+			t.Fatalf("body %q: expected error", body)
+		}
+		if errs.IsTyped(err) {
+			t.Errorf("body %q: must be UNTYPED, got typed %T", body, err)
+		}
+	}
+}

internal/credential/types.go

@@ -26,6 +26,9 @@ type Account struct {
 	UserName            string
 	Lang                i18n.Lang
 	SupportedIdentities uint8
+	AuthMethod          string // "" == client_secret; core.AuthMethodPrivateKeyJWT
+	KeyLabel            string // resolved TEE key handle for private_key_jwt
+	KeyProvider         string // empty == built-in signer; explicit external provider otherwise
 }
 
 const runtimePlaceholderAppSecret = "__LARKSUITE_CLI_TOKEN_ONLY__"
@@ -69,6 +72,9 @@ func AccountFromCliConfig(cfg *core.CliConfig) *Account {
 		UserName:            cfg.UserName,
 		Lang:                cfg.Lang,
 		SupportedIdentities: cfg.SupportedIdentities,
+		AuthMethod:          cfg.AuthMethod,
+		KeyLabel:            cfg.KeyLabel,
+		KeyProvider:         cfg.KeyProvider,
 	}
 }
 
@@ -88,6 +94,9 @@ func (a *Account) ToCliConfig() *core.CliConfig {
 		UserName:            a.UserName,
 		Lang:                a.Lang,
 		SupportedIdentities: a.SupportedIdentities,
+		AuthMethod:          a.AuthMethod,
+		KeyLabel:            a.KeyLabel,
+		KeyProvider:         a.KeyProvider,
 	}
 }
 

internal/credential/types_test.go

@@ -56,13 +56,16 @@ func TestAccountFromCliConfigAndBack_ReturnCopies(t *testing.T) {
 		UserName:            "alice",
 		Lang:                i18n.LangJaJP,
 		SupportedIdentities: 3,
+		AuthMethod:          core.AuthMethodPrivateKeyJWT,
+		KeyLabel:            "openclaw-lark",
+		KeyProvider:         core.KeylessProviderLarkSuite,
 	}
 
 	acct := AccountFromCliConfig(cfg)
 	if acct == nil {
 		t.Fatal("AccountFromCliConfig() = nil")
 	}
-	if acct.AppID != cfg.AppID || acct.ProfileName != cfg.ProfileName || acct.UserName != cfg.UserName {
+	if acct.AppID != cfg.AppID || acct.ProfileName != cfg.ProfileName || acct.UserName != cfg.UserName || acct.KeyProvider != cfg.KeyProvider {
 		t.Fatalf("AccountFromCliConfig() = %#v, want copied fields from %#v", acct, cfg)
 	}
 	if acct.Lang != cfg.Lang {
@@ -73,7 +76,7 @@ func TestAccountFromCliConfigAndBack_ReturnCopies(t *testing.T) {
 	if roundtrip == nil {
 		t.Fatal("ToCliConfig() = nil")
 	}
-	if roundtrip.AppID != cfg.AppID || roundtrip.ProfileName != cfg.ProfileName || roundtrip.UserName != cfg.UserName {
+	if roundtrip.AppID != cfg.AppID || roundtrip.ProfileName != cfg.ProfileName || roundtrip.UserName != cfg.UserName || roundtrip.KeyProvider != cfg.KeyProvider {
 		t.Fatalf("ToCliConfig() = %#v, want copied fields from %#v", roundtrip, cfg)
 	}
 	if roundtrip.Lang != cfg.Lang {

internal/envvars/envvars.go

@@ -21,7 +21,6 @@ const (
 
 	CliAgentName  = "LARKSUITE_CLI_AGENT_NAME"
 	CliAgentTrace = "LARKSUITE_CLI_AGENT_TRACE"
-	CliProfile    = "LARKSUITE_CLI_PROFILE"
 
 	CliProxyEnable  = "LARKSUITE_CLI_PROXY_ENABLE"
 	CliProxyAddress = "LARKSUITE_CLI_PROXY_ADDRESS"

internal/identitydiag/diagnostics.go

@@ -202,7 +202,9 @@ func diagnoseBot(ctx context.Context, f *cmdutil.Factory, cfg *core.CliConfig, v
 			Hint:    "check strict mode or the active credential provider",
 		}
 	}
-	if cfg.SupportedIdentities == 0 && !credential.HasRealAppSecret(cfg.AppSecret) {
+	// private_key_jwt apps have no app secret — the bot/tenant token is minted via
+	// a TEE-signed client_assertion — so absence of a secret is NOT "unconfigured".
+	if cfg.SupportedIdentities == 0 && !credential.HasRealAppSecret(cfg.AppSecret) && cfg.AuthMethod != core.AuthMethodPrivateKeyJWT {
 		return Identity{
 			Status:  StatusNotConfigured,
 			Message: "Bot identity: not configured (missing app secret or bot token)",

internal/keylesshelper/helper.go

@@ -0,0 +1,287 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+// Package keylesshelper invokes a signer generation that has already been
+// resolved and verified by internal/keylessprovider.
+package keylesshelper
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/larksuite/cli/internal/keysigner"
+	"github.com/larksuite/cli/internal/vfs"
+)
+
+const (
+	helperOutputLimit      = 1 << 20
+	helperStderrLimit      = 64 << 10
+	helperExecutionTimeout = 10 * time.Second
+)
+
+type request struct {
+	Op       string `json:"op"`
+	KeyRef   string `json:"keyRef,omitempty"`
+	Nonce    string `json:"nonce,omitempty"`
+	ClientID string `json:"clientId,omitempty"`
+	Audience string `json:"aud,omitempty"`
+}
+
+type response struct {
+	OK                  bool           `json:"ok"`
+	Error               *protocolError `json:"error,omitempty"`
+	Attestation         string         `json:"attestation,omitempty"`
+	ClientAssertionType string         `json:"client_assertion_type,omitempty"`
+	ClientAssertion     string         `json:"client_assertion,omitempty"`
+}
+
+type protocolError struct {
+	Type    string `json:"type"`
+	Message string `json:"message"`
+}
+
+// Command is one verified provider executable. It is intentionally impossible
+// to construct from an app-config path, argv, or environment variable.
+type Command struct {
+	argv         []string
+	providerCWD  string
+	providerHome string
+	providerSHA  string
+}
+
+// NewProviderCommand builds the fixed empty-argv command used by a verified
+// provider executable. Provider execution never accepts argv from app config or
+// the environment.
+func NewProviderCommand(binaryPath, providerRoot, signerHome, expectedSHA256 string) (*Command, error) {
+	if strings.TrimSpace(binaryPath) == "" || strings.TrimSpace(providerRoot) == "" {
+		return nil, fmt.Errorf("provider binary path and root must be non-empty")
+	}
+	if len(expectedSHA256) != 64 {
+		return nil, fmt.Errorf("provider binary digest must be a SHA-256 hex string")
+	}
+	return &Command{argv: []string{binaryPath}, providerCWD: providerRoot, providerHome: signerHome, providerSHA: expectedSHA256}, nil
+}
+
+// Probe asks this resolved helper for its public key.
+func (c *Command) Probe(ctx context.Context, keyRef string) error {
+	resp, err := c.execute(ctx, request{
+		Op:     "pubkey",
+		KeyRef: defaultKeyRef(keyRef),
+	})
+	if err != nil {
+		return err
+	}
+	return validateResponse(resp)
+}
+
+// SignAttestation asks this resolved helper to mint a registration attestation JWT.
+func (c *Command) SignAttestation(ctx context.Context, keyRef, nonce string) (string, error) {
+	resp, err := c.execute(ctx, request{
+		Op:     "sign-attestation",
+		KeyRef: defaultKeyRef(keyRef),
+		Nonce:  nonce,
+	})
+	if err != nil {
+		return "", err
+	}
+	if err := validateResponse(resp); err != nil {
+		return "", err
+	}
+	if resp.Attestation == "" {
+		return "", fmt.Errorf("keyless helper returned empty attestation")
+	}
+	return resp.Attestation, nil
+}
+
+// SignClientAssertion asks this resolved helper to mint a token-endpoint client_assertion.
+func (c *Command) SignClientAssertion(ctx context.Context, keyRef, clientID, audience string) (string, string, error) {
+	resp, err := c.execute(ctx, request{
+		Op:       "sign-assertion",
+		KeyRef:   defaultKeyRef(keyRef),
+		ClientID: clientID,
+		Audience: audience,
+	})
+	if err != nil {
+		return "", "", err
+	}
+	if err := validateResponse(resp); err != nil {
+		return "", "", err
+	}
+	if resp.ClientAssertionType == "" {
+		return "", "", fmt.Errorf("keyless helper returned empty client_assertion_type")
+	}
+	if resp.ClientAssertion == "" {
+		return "", "", fmt.Errorf("keyless helper returned empty client_assertion")
+	}
+	return resp.ClientAssertionType, resp.ClientAssertion, nil
+}
+
+func (c *Command) execute(ctx context.Context, req request) (response, error) {
+	if err := verifyProviderBinary(c.argv[0], c.providerSHA); err != nil {
+		return response{}, err
+	}
+	return runCommandConfigured(ctx, c.argv, req, c.providerCWD, providerEnvironment(c.providerHome))
+}
+
+func verifyProviderBinary(path, expectedSHA string) error {
+	info, err := vfs.Lstat(path)
+	if err != nil {
+		return fmt.Errorf("recheck provider signer: %w", err)
+	}
+	if !info.Mode().IsRegular() || info.Mode()&os.ModeSymlink != 0 || info.Size() <= 0 || info.Size() > 512<<20 {
+		return fmt.Errorf("provider signer changed before execution")
+	}
+	f, err := vfs.Open(path)
+	if err != nil {
+		return fmt.Errorf("reopen provider signer: %w", err)
+	}
+	defer f.Close()
+	h := sha256.New()
+	n, err := io.Copy(h, io.LimitReader(f, 512<<20+1))
+	if err != nil || n != info.Size() {
+		return fmt.Errorf("rehash provider signer: file changed while reading")
+	}
+	if hex.EncodeToString(h.Sum(nil)) != expectedSHA {
+		return fmt.Errorf("provider signer digest changed before execution")
+	}
+	return nil
+}
+
+func validateResponse(resp response) error {
+	if resp.Error != nil {
+		return fmt.Errorf("keyless helper %s: %s", resp.Error.Type, resp.Error.Message)
+	}
+	if !resp.OK {
+		return fmt.Errorf("keyless helper returned ok=false")
+	}
+	return nil
+}
+
+func defaultKeyRef(keyRef string) string {
+	if keyRef != "" {
+		return keyRef
+	}
+	return keysigner.DefaultKeyLabel
+}
+
+func runCommand(ctx context.Context, argv []string, req request) (response, error) {
+	return runCommandConfigured(ctx, argv, req, "", nil)
+}
+
+func runCommandConfigured(ctx context.Context, argv []string, req request, cwd string, env []string) (response, error) {
+	body, err := json.Marshal(req)
+	if err != nil {
+		return response{}, fmt.Errorf("marshal keyless helper request: %w", err)
+	}
+	body = append(body, '\n')
+
+	helperCtx, cancel := withExecutionTimeout(ctx)
+	defer cancel()
+
+	// CommandContext's default cancellation kills the helper process. This is
+	// important for unattended agent calls: a signer blocked on platform UI must
+	// not hold the caller indefinitely.
+	cmd := exec.CommandContext(helperCtx, argv[0], argv[1:]...)
+	if cwd != "" {
+		cmd.Dir = cwd
+		cmd.Env = env
+	}
+	cmd.Stdin = bytes.NewReader(body)
+	stdout := &limitedBuffer{limit: helperOutputLimit}
+	stderr := &limitedBuffer{limit: helperStderrLimit}
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+
+	runErr := cmd.Run()
+	if err := helperCtx.Err(); err != nil {
+		// Never parse or include helper output on cancellation. A partially written
+		// response may contain a client assertion or other credential material.
+		if errors.Is(err, context.DeadlineExceeded) {
+			return response{}, fmt.Errorf("keyless helper timed out: %w", context.DeadlineExceeded)
+		}
+		return response{}, fmt.Errorf("keyless helper canceled: %w", err)
+	}
+	var resp response
+	if err := json.Unmarshal(stdout.Bytes(), &resp); err != nil {
+		if runErr != nil {
+			return response{}, helperRunError(runErr, stderr.String())
+		}
+		return response{}, fmt.Errorf("keyless helper produced invalid JSON: %w", err)
+	}
+	if runErr != nil && resp.Error == nil {
+		return response{}, helperRunError(runErr, stderr.String())
+	}
+	return resp, nil
+}
+
+func providerEnvironment(homeOverride string) []string {
+	// Signer implementations use OS facilities and must not inherit language
+	// runtime/proxy/library injection variables. HOME/TMPDIR/SystemRoot are the
+	// minimal cross-platform values currently needed by supported backends.
+	keep := map[string]bool{"HOME": true, "TMPDIR": true, "TEMP": true, "TMP": true, "SystemRoot": true, "WINDIR": true}
+	var env []string
+	for _, entry := range os.Environ() {
+		name := entry
+		if idx := strings.IndexByte(entry, '='); idx >= 0 {
+			name = entry[:idx]
+		}
+		if keep[name] && !(name == "HOME" && homeOverride != "") {
+			env = append(env, entry)
+		}
+	}
+	if homeOverride != "" {
+		env = append(env, "HOME="+homeOverride)
+	}
+	return env
+}
+
+func withExecutionTimeout(ctx context.Context) (context.Context, context.CancelFunc) {
+	return context.WithTimeout(ctx, helperExecutionTimeout)
+}
+
+func helperRunError(runErr error, stderr string) error {
+	if errors.Is(runErr, os.ErrNotExist) {
+		return fmt.Errorf("keyless helper executable no longer exists; repair or reinstall the OpenClaw Feishu plugin: %w", runErr)
+	}
+	if strings.TrimSpace(stderr) != "" {
+		return fmt.Errorf("keyless helper failed: %w (stderr omitted)", runErr)
+	}
+	return fmt.Errorf("keyless helper failed: %w", runErr)
+}
+
+type limitedBuffer struct {
+	buf   bytes.Buffer
+	limit int
+}
+
+func (b *limitedBuffer) Write(p []byte) (int, error) {
+	if b.limit <= 0 {
+		return len(p), nil
+	}
+	remaining := b.limit - b.buf.Len()
+	if remaining > 0 {
+		if len(p) < remaining {
+			remaining = len(p)
+		}
+		_, _ = b.buf.Write(p[:remaining])
+	}
+	return len(p), nil
+}
+
+func (b *limitedBuffer) Bytes() []byte {
+	return b.buf.Bytes()
+}
+
+func (b *limitedBuffer) String() string {
+	return b.buf.String()
+}